// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package auth provides a system for identifying and authenticating
// users through third party cloud systems in Cogent Core apps.
package auth

import (
        "context"
        "crypto/rand"
        "encoding/base64"
        "errors"
        "fmt"
        "io/fs"
        "log/slog"
        "net/http"
        "os"
        "path/filepath"

        "cogentcore.org/core/base/iox/jsonx"
        "cogentcore.org/core/core"
        "github.com/coreos/go-oidc/v3/oidc"
        "golang.org/x/oauth2"
)

// AuthConfig is the configuration information passed to [Auth].
type AuthConfig struct {
        // Ctx is the context to use. It is [context.TODO] if unspecified.
        Ctx context.Context

        // ProviderName is the name of the provider to authenticate with (eg: "google")
        ProviderName string

        // ProviderURL is the URL of the provider (eg: "https://accounts.google.com")
        ProviderURL string

        // ClientID is the client ID for the app, which is typically obtained through a developer oauth
        // portal (eg: the Credentials section of https://console.developers.google.com/).
        ClientID string

        // ClientSecret is the client secret for the app, which is typically obtained through a developer oauth
        // portal (eg: the Credentials section of https://console.developers.google.com/).
        ClientSecret string

        // TokenFile is an optional function that returns the filename at which the token for the given user will be stored as JSON.
        // If it is nil or it returns "", the token is not stored. Also, if it is non-nil, Auth skips the user-facing authentication
        // step if it finds a valid token at the file (ie: remember me). It checks all [AuthConfig.Accounts] until it finds one
        // that works for that step. If [AuthConfig.Accounts] is nil, it checks with a blank ("") email account.
        TokenFile func(email string) string

        // Accounts are optional accounts to check for the remember me feature described in [AuthConfig.TokenFile].
        // If it is nil and TokenFile is not, it defaults to contain one blank ("") element.
        Accounts []string

        // Scopes are additional scopes to request beyond the default "openid", "profile", and "email" scopes
        Scopes []string
}

// Auth authenticates the user using the given configuration information and returns the
// resulting oauth token and user info. See [AuthConfig] for more information on the
// configuration options.
func Auth(c *AuthConfig) (*oauth2.Token, *oidc.UserInfo, error) {
        if c.Ctx == nil {
                c.Ctx = context.TODO()
        }
        if c.ClientID == "" || c.ClientSecret == "" {
                slog.Warn("got empty client id and/or client secret; did you forgot to set env variables?")
        }

        provider, err := oidc.NewProvider(c.Ctx, c.ProviderURL)
        if err != nil {
                return nil, nil, err
        }

        config := oauth2.Config{
                ClientID:     c.ClientID,
                ClientSecret: c.ClientSecret,
                RedirectURL:  "http://127.0.0.1:5556/auth/" + c.ProviderName + "/callback",
                Endpoint:     provider.Endpoint(),
                Scopes:       append([]string{oidc.ScopeOpenID, "profile", "email"}, c.Scopes...),
        }

        var token *oauth2.Token

        if c.TokenFile != nil {
                if c.Accounts == nil {
                        c.Accounts = []string{""}
                }
                for _, account := range c.Accounts {
                        tf := c.TokenFile(account)
                        if tf != "" {
                                err := jsonx.Open(&token, tf)
                                if err != nil && !errors.Is(err, fs.ErrNotExist) {
                                        return nil, nil, err
                                }
                                break
                        }
                }
        }

        // if we didn't get it through remember me, we have to get it manually
        if token == nil {
                b := make([]byte, 16)
                rand.Read(b)
                state := base64.RawURLEncoding.EncodeToString(b)

                code := make(chan string)

                sm := http.NewServeMux()
                sm.HandleFunc("/auth/"+c.ProviderName+"/callback", func(w http.ResponseWriter, r *http.Request) {
                        if r.URL.Query().Get("state") != state {
                                http.Error(w, "state did not match", http.StatusBadRequest)
                                return
                        }
                        code <- r.URL.Query().Get("code")
                        w.Write([]byte("<h1>Signed in</h1><p>You can return to the app</p>"))
                })
                // TODO(kai/auth): more graceful closing / error handling
                go http.ListenAndServe("127.0.0.1:5556", sm)

                core.TheApp.OpenURL(config.AuthCodeURL(state))

                cs := <-code

                token, err = config.Exchange(c.Ctx, cs)
                if err != nil {
                        return nil, nil, fmt.Errorf("failed to exchange token: %w", err)
                }
        }

        tokenSource := config.TokenSource(c.Ctx, token)
        // the access token could have changed
        newToken, err := tokenSource.Token()
        if err != nil {
                return nil, nil, err
        }

        userInfo, err := provider.UserInfo(c.Ctx, tokenSource)
        if err != nil {
                return nil, nil, fmt.Errorf("failed to get user info: %w", err)
        }

        if c.TokenFile != nil {
                tf := c.TokenFile(userInfo.Email)
                if tf != "" {
                        err := os.MkdirAll(filepath.Dir(tf), 0700)
                        if err != nil {
                                return nil, nil, err
                        }
                        // TODO(kai/auth): more secure saving of token file
                        err = jsonx.Save(token, tf)
                        if err != nil {
                                return nil, nil, err
                        }
                }
        }

        return newToken, userInfo, nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package auth

import (
        "context"

        "cogentcore.org/core/base/auth/cicons"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "github.com/coreos/go-oidc/v3/oidc"

        "golang.org/x/oauth2"
)

// ButtonsConfig is the configuration information passed to [Buttons].
type ButtonsConfig struct {
        // SuccessFunc, if non-nil, is the function called after the user successfully
        // authenticates. It is passed the user's authentication token and info.
        SuccessFunc func(token *oauth2.Token, userInfo *oidc.UserInfo)

        // TokenFile, if non-nil, is the function used to determine what token file function is
        // used for [AuthConfig.TokenFile]. It is passed the provider being used (eg: "google") and the
        // email address of the user authenticating.
        TokenFile func(provider, email string) string

        // Accounts are optional accounts to check for the remember me feature described in [AuthConfig.TokenFile].
        // See [AuthConfig.Accounts] for more information. If it is nil and TokenFile is not, it defaults to contain
        // one blank ("") element.
        Accounts []string

        // Scopes, if non-nil, is a map of scopes to pass to [Auth], keyed by the
        // provider being used (eg: "google").
        Scopes map[string][]string
}

// Buttons adds a new vertical layout to the given parent with authentication
// buttons for major platforms, using the given configuration options. See
// [ButtonsConfig] for more information on the configuration options. The
// configuration options can be nil, in which case default values will be used.
func Buttons(par core.Widget, c *ButtonsConfig) *core.Frame {
        ly := core.NewFrame(par)
        ly.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
        })

        GoogleButton(ly, c)
        return ly
}

// Button makes a new button for signing in with the provider
// that has the given name and auth func. It should not typically
// be used by end users; instead, use [Buttons] or the platform-specific
// functions (eg: [Google]). The configuration options can be nil, in
// which case default values will be used.
func Button(par core.Widget, c *ButtonsConfig, provider string, authFunc func(c *AuthConfig) (*oauth2.Token, *oidc.UserInfo, error)) *core.Button {
        if c == nil {
                c = &ButtonsConfig{}
        }
        if c.SuccessFunc == nil {
                c.SuccessFunc = func(token *oauth2.Token, userInfo *oidc.UserInfo) {}
        }
        if c.Scopes == nil {
                c.Scopes = map[string][]string{}
        }

        bt := core.NewButton(par).SetText("Sign in")

        tf := func(email string) string {
                if c.TokenFile != nil {
                        return c.TokenFile(provider, email)
                }
                return ""
        }
        ac := &AuthConfig{
                Ctx:          context.TODO(),
                ProviderName: provider,
                TokenFile:    tf,
                Accounts:     c.Accounts,
                Scopes:       c.Scopes[provider],
        }

        auth := func() {
                token, userInfo, err := authFunc(ac)
                if err != nil {
                        core.ErrorDialog(bt, err, "Error signing in with "+strcase.ToSentence(provider))
                        return
                }
                c.SuccessFunc(token, userInfo)
        }
        bt.OnClick(func(e events.Event) {
                auth()
        })

        // if we have a valid token file, we auth immediately without the user clicking on the button
        if c.TokenFile != nil {
                if c.Accounts == nil {
                        c.Accounts = []string{""}
                }
                for _, account := range c.Accounts {
                        tf := c.TokenFile(provider, account)
                        if tf != "" {
                                exists, err := fsx.FileExists(tf)
                                if err != nil {
                                        core.ErrorDialog(bt, err, "Error searching for saved "+strcase.ToSentence(provider)+" auth token file")
                                        return bt
                                }
                                if exists {
                                        // have to wait until the scene is shown in case any dialogs are created
                                        bt.OnShow(func(e events.Event) {
                                                auth()
                                        })
                                }
                        }
                }
        }
        return bt
}

// GoogleButton adds a new button for signing in with Google
// to the given parent using the given configuration information.
func GoogleButton(par core.Widget, c *ButtonsConfig) *core.Button {
        bt := Button(par, c, "google", Google).SetType(core.ButtonOutlined).
                SetText("Sign in with Google").SetIcon(cicons.SignInWithGoogle)
        bt.Styler(func(s *styles.Style) {
                s.Color = colors.Scheme.OnSurface
        })
        return bt
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "cogentcore.org/core/base/auth"
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/core"
        "github.com/coreos/go-oidc/v3/oidc"
        "golang.org/x/oauth2"
)

func main() {
        b := core.NewBody("Auth basic example")
        fun := func(token *oauth2.Token, userInfo *oidc.UserInfo) {
                d := core.NewBody("User info")
                core.NewText(d).SetType(core.TextHeadlineMedium).SetText("Basic info")
                core.NewForm(d).SetStruct(userInfo)
                core.NewText(d).SetType(core.TextHeadlineMedium).SetText("Detailed info")
                claims := map[string]any{}
                errors.Log(userInfo.Claims(&claims))
                core.NewKeyedList(d).SetMap(&claims)
                d.AddOKOnly().RunFullDialog(b)
        }
        auth.Buttons(b, &auth.ButtonsConfig{SuccessFunc: fun})
        b.RunMainWindow()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "path/filepath"

        "cogentcore.org/core/base/auth"
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/core"
        "github.com/coreos/go-oidc/v3/oidc"
        "golang.org/x/oauth2"
)

func main() {
        b := core.NewBody("Auth scopes and token file example")
        fun := func(token *oauth2.Token, userInfo *oidc.UserInfo) {
                d := core.NewBody()
                core.NewText(d).SetType(core.TextHeadlineMedium).SetText("Basic info")
                core.NewForm(d).SetStruct(userInfo)
                core.NewText(d).SetType(core.TextHeadlineMedium).SetText("Detailed info")
                claims := map[string]any{}
                errors.Log(userInfo.Claims(&claims))
                core.NewKeyedList(d).SetMap(&claims)
                d.AddOKOnly().RunFullDialog(b)
        }
        auth.Buttons(b, &auth.ButtonsConfig{
                SuccessFunc: fun,
                TokenFile: func(provider, email string) string {
                        return filepath.Join(core.TheApp.AppDataDir(), provider+"-token.json")
                },
                Scopes: map[string][]string{
                        "google": {"https://mail.google.com/"},
                },
        })
        b.RunMainWindow()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package auth

import (
        "os"

        "github.com/coreos/go-oidc/v3/oidc"
        "golang.org/x/oauth2"
)

// Google authenticates the user with Google using [Auth] and the given configuration
// information and returns the resulting oauth token and user info. It sets the values
// of [AuthConfig.ProviderName], [AuthConfig.ProviderURL], [AuthConfig.ClientID], and
// [AuthConfig.ClientSecret] if they are not already set.
func Google(c *AuthConfig) (*oauth2.Token, *oidc.UserInfo, error) {
        if c.ProviderName == "" {
                c.ProviderName = "google"
        }
        if c.ProviderURL == "" {
                c.ProviderURL = "https://accounts.google.com"
        }
        if c.ClientID == "" {
                c.ClientID = os.Getenv("GOOGLE_OAUTH2_CLIENT_ID")
        }
        if c.ClientSecret == "" {
                c.ClientSecret = os.Getenv("GOOGLE_OAUTH2_CLIENT_SECRET")
        }
        return Auth(c)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/c2h5oh/datasize
// Copyright (c) 2016 Maciej Lisiewski

// Package datasize provides a data size type and constants.
package datasize

import (
        "errors"
        "fmt"
        "strconv"
        "strings"
)

// Size represents a data size.
type Size uint64

const (
        B  Size = 1
        KB      = B << 10
        MB      = KB << 10
        GB      = MB << 10
        TB      = GB << 10
        PB      = TB << 10
        EB      = PB << 10

        fnUnmarshalText string = "UnmarshalText"
        maxUint64       uint64 = (1 << 64) - 1
        cutoff          uint64 = maxUint64 / 10
)

var ErrBits = errors.New("unit with capital unit prefix and lower case unit (b) - bits, not bytes")

func (b Size) Bytes() uint64 {
        return uint64(b)
}

func (b Size) KBytes() float64 {
        v := b / KB
        r := b % KB
        return float64(v) + float64(r)/float64(KB)
}

func (b Size) MBytes() float64 {
        v := b / MB
        r := b % MB
        return float64(v) + float64(r)/float64(MB)
}

func (b Size) GBytes() float64 {
        v := b / GB
        r := b % GB
        return float64(v) + float64(r)/float64(GB)
}

func (b Size) TBytes() float64 {
        v := b / TB
        r := b % TB
        return float64(v) + float64(r)/float64(TB)
}

func (b Size) PBytes() float64 {
        v := b / PB
        r := b % PB
        return float64(v) + float64(r)/float64(PB)
}

func (b Size) EBytes() float64 {
        v := b / EB
        r := b % EB
        return float64(v) + float64(r)/float64(EB)
}

// String returns a human-readable representation of the data size.
func (b Size) String() string {
        switch {
        case b > EB:
                return fmt.Sprintf("%.1f EB", b.EBytes())
        case b > PB:
                return fmt.Sprintf("%.1f PB", b.PBytes())
        case b > TB:
                return fmt.Sprintf("%.1f TB", b.TBytes())
        case b > GB:
                return fmt.Sprintf("%.1f GB", b.GBytes())
        case b > MB:
                return fmt.Sprintf("%.1f MB", b.MBytes())
        case b > KB:
                return fmt.Sprintf("%.1f KB", b.KBytes())
        default:
                return fmt.Sprintf("%d B", b)
        }
}

// MachineString returns a machine-friendly representation of the data size.
func (b Size) MachineString() string {
        switch {
        case b == 0:
                return "0B"
        case b%EB == 0:
                return fmt.Sprintf("%dEB", b/EB)
        case b%PB == 0:
                return fmt.Sprintf("%dPB", b/PB)
        case b%TB == 0:
                return fmt.Sprintf("%dTB", b/TB)
        case b%GB == 0:
                return fmt.Sprintf("%dGB", b/GB)
        case b%MB == 0:
                return fmt.Sprintf("%dMB", b/MB)
        case b%KB == 0:
                return fmt.Sprintf("%dKB", b/KB)
        default:
                return fmt.Sprintf("%dB", b)
        }
}

func (b Size) MarshalText() ([]byte, error) {
        return []byte(b.MachineString()), nil
}

func (b *Size) UnmarshalText(t []byte) error {
        var val uint64
        var unit string

        // copy for error message
        t0 := t

        var c byte
        var i int

ParseLoop:
        for i < len(t) {
                c = t[i]
                switch {
                case '0' <= c && c <= '9':
                        if val > cutoff {
                                goto Overflow
                        }

                        c = c - '0'
                        val *= 10

                        if val > val+uint64(c) {
                                // val+v overflows
                                goto Overflow
                        }
                        val += uint64(c)
                        i++

                default:
                        if i == 0 {
                                goto SyntaxError
                        }
                        break ParseLoop
                }
        }

        unit = strings.TrimSpace(string(t[i:]))
        switch unit {
        case "Kb", "Mb", "Gb", "Tb", "Pb", "Eb":
                goto BitsError
        }
        unit = strings.ToLower(unit)
        switch unit {
        case "", "b", "byte":
                // do nothing - already in bytes

        case "k", "kb", "kilo", "kilobyte", "kilobytes":
                if val > maxUint64/uint64(KB) {
                        goto Overflow
                }
                val *= uint64(KB)

        case "m", "mb", "mega", "megabyte", "megabytes":
                if val > maxUint64/uint64(MB) {
                        goto Overflow
                }
                val *= uint64(MB)

        case "g", "gb", "giga", "gigabyte", "gigabytes":
                if val > maxUint64/uint64(GB) {
                        goto Overflow
                }
                val *= uint64(GB)

        case "t", "tb", "tera", "terabyte", "terabytes":
                if val > maxUint64/uint64(TB) {
                        goto Overflow
                }
                val *= uint64(TB)

        case "p", "pb", "peta", "petabyte", "petabytes":
                if val > maxUint64/uint64(PB) {
                        goto Overflow
                }
                val *= uint64(PB)

        case "E", "EB", "e", "eb", "eB":
                if val > maxUint64/uint64(EB) {
                        goto Overflow
                }
                val *= uint64(EB)

        default:
                goto SyntaxError
        }

        *b = Size(val)
        return nil

Overflow:
        *b = Size(maxUint64)
        return &strconv.NumError{fnUnmarshalText, string(t0), strconv.ErrRange}

SyntaxError:
        *b = 0
        return &strconv.NumError{fnUnmarshalText, string(t0), strconv.ErrSyntax}

BitsError:
        *b = 0
        return &strconv.NumError{fnUnmarshalText, string(t0), ErrBits}
}

func Parse(t []byte) (Size, error) {
        var v Size
        err := v.UnmarshalText(t)
        return v, err
}

func MustParse(t []byte) Size {
        v, err := Parse(t)
        if err != nil {
                panic(err)
        }
        return v
}

func ParseString(s string) (Size, error) {
        return Parse([]byte(s))
}

func MustParseString(s string) Size {
        return MustParse([]byte(s))
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package elide provides basic text eliding functions.
package elide

import "strings"

// End elides from the end of the string if it is longer than given
// size parameter.  The resulting string will not exceed sz in length,
// with space reserved for … at the end.
func End(s string, sz int) string {
        n := len(s)
        if n <= sz {
                return s
        }
        return s[:sz-1] + "…"
}

// Middle elides from the middle of the string if it is longer than given
// size parameter.  The resulting string will not exceed sz in length,
// with space reserved for … in the middle
func Middle(s string, sz int) string {
        n := len(s)
        if n <= sz {
                return s
        }
        en := sz - 1
        mid := en / 2
        rest := en - mid
        return s[:mid] + "…" + s[n-rest:]
}

// AppName elides the given app name to be twelve characters or less
// by removing word(s) from the middle of the string if necessary and possible.
func AppName(s string) string {
        if len(s) <= 12 {
                return s
        }
        words := strings.Fields(s)
        if len(words) < 3 {
                return s
        }
        return words[0] + " " + words[len(words)-1]
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package errors provides a set of error handling helpers,
// extending the standard library errors package.
package errors

import (
        "log/slog"
        "runtime"
        "strconv"
)

// Log takes the given error and logs it if it is non-nil.
// The intended usage is:
//
//        errors.Log(MyFunc(v))
//        // or
//        return errors.Log(MyFunc(v))
func Log(err error) error {
        if err != nil {
                slog.Error(err.Error() + " | " + CallerInfo())
        }
        return err
}

// Log1 takes the given value and error and returns the value if
// the error is nil, and logs the error and returns a zero value
// if the error is non-nil. The intended usage is:
//
//        a := errors.Log1(MyFunc(v))
func Log1[T any](v T, err error) T { //yaegi:add
        if err != nil {
                slog.Error(err.Error() + " | " + CallerInfo())
        }
        return v
}

// Log2 takes the given two values and error and returns the values if
// the error is nil, and logs the error and returns zero values
// if the error is non-nil. The intended usage is:
//
//        a, b := errors.Log2(MyFunc(v))
func Log2[T1, T2 any](v1 T1, v2 T2, err error) (T1, T2) {
        if err != nil {
                slog.Error(err.Error() + " | " + CallerInfo())
        }
        return v1, v2
}

// Must takes the given error and panics if it is non-nil.
// The intended usage is:
//
//        errors.Must(MyFunc(v))
func Must(err error) {
        if err != nil {
                panic(err)
        }
}

// Must1 takes the given value and error and returns the value if
// the error is nil, and panics if the error is non-nil. The intended usage is:
//
//        a := errors.Must1(MyFunc(v))
func Must1[T any](v T, err error) T {
        if err != nil {
                panic(err)
        }
        return v
}

// Must2 takes the given two values and error and returns the values if
// the error is nil, and panics if the error is non-nil. The intended usage is:
//
//        a, b := errors.Must2(MyFunc(v))
func Must2[T1, T2 any](v1 T1, v2 T2, err error) (T1, T2) {
        if err != nil {
                panic(err)
        }
        return v1, v2
}

// Ignore1 ignores an error return value for a function returning
// a value and an error, allowing direct usage of the value.
// The intended usage is:
//
//        a := errors.Ignore1(MyFunc(v))
func Ignore1[T any](v T, err error) T {
        return v
}

// Ignore2 ignores an error return value for a function returning
// two values and an error, allowing direct usage of the values.
// The intended usage is:
//
//        a, b := errors.Ignore2(MyFunc(v))
func Ignore2[T1, T2 any](v1 T1, v2 T2, err error) (T1, T2) {
        return v1, v2
}

// CallerInfo returns string information about the caller
// of the function that called CallerInfo.
func CallerInfo() string {
        pc, file, line, _ := runtime.Caller(2)
        return runtime.FuncForPC(pc).Name() + " " + file + ":" + strconv.Itoa(line)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package errors

import "errors"

// Aliases for standard library errors package:

// ErrUnsupported indicates that a requested operation cannot be performed,
// because it is unsupported. For example, a call to [os.Link] when using a
// file system that does not support hard links.
//
// Functions and methods should not return this error but should instead
// return an error including appropriate context that satisfies
//
//        errors.Is(err, errors.ErrUnsupported)
//
// either by directly wrapping ErrUnsupported or by implementing an [Is] method.
//
// Functions and methods should document the cases in which an error
// wrapping this will be returned.
var ErrUnsupported = errors.ErrUnsupported

// As finds the first error in err's tree that matches target, and if one is found, sets
// target to that error value and returns true. Otherwise, it returns false.
//
// The tree consists of err itself, followed by the errors obtained by repeatedly
// calling its Unwrap() error or Unwrap() []error method. When err wraps multiple
// errors, As examines err followed by a depth-first traversal of its children.
//
// An error matches target if the error's concrete value is assignable to the value
// pointed to by target, or if the error has a method As(interface{}) bool such that
// As(target) returns true. In the latter case, the As method is responsible for
// setting target.
//
// An error type might provide an As method so it can be treated as if it were a
// different error type.
//
// As panics if target is not a non-nil pointer to either a type that implements
// error, or to any interface type.
func As(err error, target any) bool { return errors.As(err, target) }

// Is reports whether any error in err's tree matches target.
//
// The tree consists of err itself, followed by the errors obtained by repeatedly
// calling its Unwrap() error or Unwrap() []error method. When err wraps multiple
// errors, Is examines err followed by a depth-first traversal of its children.
//
// An error is considered to match a target if it is equal to that target or if
// it implements a method Is(error) bool such that Is(target) returns true.
//
// An error type might provide an Is method so it can be treated as equivalent
// to an existing error. For example, if MyError defines
//
//        func (m MyError) Is(target error) bool { return target == fs.ErrExist }
//
// then Is(MyError{}, fs.ErrExist) returns true. See [syscall.Errno.Is] for
// an example in the standard library. An Is method should only shallowly
// compare err and the target and not call [Unwrap] on either.
func Is(err, target error) bool { return errors.Is(err, target) }

// Join returns an error that wraps the given errors.
// Any nil error values are discarded.
// Join returns nil if every value in errs is nil.
// The error formats as the concatenation of the strings obtained
// by calling the Error method of each element of errs, with a newline
// between each string.
//
// A non-nil error returned by Join implements the Unwrap() []error method.
func Join(errs ...error) error { return errors.Join(errs...) }

// New returns an error that formats as the given text.
// Each call to New returns a distinct error value even if the text is identical.
func New(text string) error { return errors.New(text) }

// Unwrap returns the result of calling the Unwrap method on err, if err's
// type contains an Unwrap method returning error.
// Otherwise, Unwrap returns nil.
//
// Unwrap only calls a method of the form "Unwrap() error".
// In particular Unwrap does not unwrap errors returned by [Join].
func Unwrap(err error) error { return errors.Unwrap(err) }

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package exec

import (
        "bytes"
        "fmt"
        "os/exec"
        "strings"
)

// Cmd is a type alias for [exec.Cmd].
type Cmd = exec.Cmd

// CmdIO maintains an [exec.Cmd] pointer and IO state saved for the command
type CmdIO struct {
        StdIOState

        // Cmd is the [exec.Cmd]
        Cmd *exec.Cmd
}

func (c *CmdIO) String() string {
        if c.Cmd == nil {
                return "<nil>"
        }
        str := ""
        if c.Cmd.ProcessState != nil {
                str = c.Cmd.ProcessState.String()
        } else if c.Cmd.Process != nil {
                str = fmt.Sprintf("%d          ", c.Cmd.Process.Pid)
        } else {
                str = "no process info"
        }
        str += " " + c.Cmd.String()
        return str
}

// NewCmdIO returns a new [CmdIO] initialized with StdIO settings from given Config
func NewCmdIO(c *Config) *CmdIO {
        cio := &CmdIO{}
        cio.StdIO = c.StdIO
        return cio
}

// RunIO runs the given command using the given
// configuration information and arguments,
// waiting for it to complete before returning.
// This IO version of [Run] uses specified stdio and sets the
// command in it as well, for easier management of
// dynamically updated IO routing.
func (c *Config) RunIO(cio *CmdIO, cmd string, args ...string) error {
        cm, _, err := c.exec(&cio.StdIO, false, cmd, args...)
        cio.Cmd = cm
        return err
}

// StartIO starts the given command using the given
// configuration information and arguments,
// just starting the command but not waiting for it to finish.
// This IO version of [Start] uses specified stdio and sets the
// command in it as well, which should be used to Wait for the
// command to finish (in a separate goroutine).
// For dynamic IO routing uses, call [CmdIO.StackStart] prior to
// setting the IO values using Push commands, and then call
// [PopToStart] after Wait finishes, to close any open IO and reset.
func (c *Config) StartIO(cio *CmdIO, cmd string, args ...string) error {
        cm, _, err := c.exec(&cio.StdIO, true, cmd, args...)
        cio.Cmd = cm
        return err
}

// OutputIO runs the command and returns the text from stdout.
func (c *Config) OutputIO(cio *CmdIO, cmd string, args ...string) (string, error) {
        // need to use buf to capture output
        sio := cio.StdIO // copy
        buf := &bytes.Buffer{}
        sio.Out = buf
        _, _, err := c.exec(&sio, false, cmd, args...)
        if cio.Out != nil {
                cio.Out.Write(buf.Bytes())
        }
        return strings.TrimSuffix(buf.String(), "\n"), err
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package exec provides an easy way to execute commands,
// improving the ease-of-use and error handling of the
// standard library os/exec package. For example:
//
//        err := exec.Run("git", "commit", "-am")
//        // or
//        err := exec.RunSh("git commit -am")
//        // or
//        err := exec.Verbose().Run("git", "commit", "-am")
package exec

//go:generate core generate

import (
        "io"
        "os"

        "log/slog"

        "cogentcore.org/core/base/logx"
)

// Config contains the configuration information that
// controls the behavior of exec. It is passed to most
// high-level functions, and a default version of it
// can be easily constructed using [DefaultConfig].
type Config struct { //types:add -setters

        // Buffer is whether to buffer the output of Stdout and Stderr,
        // which is necessary for the correct printing of commands and output
        // when there is an error with a command, and for correct coloring
        // on Windows. Therefore, it should be kept at the default value of
        // true in most cases, except for when a command will run for a log
        // time and print output throughout (eg: a log command).
        Buffer bool

        // PrintOnly is whether to only print commands that would be run and
        // not actually run them. It can be used, for example, for safely testing
        // an app.
        PrintOnly bool

        // The directory to execute commands in. If it is unset,
        // commands are run in the current directory.
        Dir string

        // Env contains any additional environment variables specified.
        // The current environment variables will also be passed to the
        // command, but they will be overridden by any variables here
        // if there are conflicts.
        Env map[string]string `set:"-"`

        // Echo is the writer for echoing the command string to.
        // It can be set to nil to disable echoing.
        Echo io.Writer

        // Standard Input / Output management
        StdIO StdIO
}

// SetStdout sets the standard output
func (c *Config) SetStdout(w io.Writer) *Config {
        c.StdIO.Out = w
        return c
}

// SetStderr sets the standard error
func (c *Config) SetStderr(w io.Writer) *Config {
        c.StdIO.Err = w
        return c
}

// SetStdin sets the standard input
func (c *Config) SetStdin(r io.Reader) *Config {
        c.StdIO.In = r
        return c
}

// major is the config object for [Major] specified through [SetMajor]
var major *Config

// Major returns the default [Config] object for a major command,
// based on [logx.UserLevel]. It should be used for commands that
// are central to an app's logic and are more important for the user
// to know about and be able to see the output of. It results in
// commands and output being printed with a [logx.UserLevel] of
// [slog.LevelInfo] or below, whereas [Minor] results in that when
// it is [slog.LevelDebug] or below. Most commands in a typical use
// case should be Major, which is why the global helper functions
// operate on it. The object returned by Major is guaranteed to be
// unique, so it can be modified directly.
func Major() *Config {
        if major != nil {
                // need to make a new copy so people can't modify the underlying
                res := *major
                return &res
        }
        if logx.UserLevel <= slog.LevelInfo {
                c := &Config{
                        Buffer: true,
                        Env:    map[string]string{},
                        Echo:   os.Stdout,
                }
                c.StdIO.SetFromOS()
                return c
        }
        c := &Config{
                Buffer: true,
                Env:    map[string]string{},
        }
        c.StdIO.SetFromOS()
        c.StdIO.Out = nil
        return c
}

// SetMajor sets the config object that [Major] returns. It should
// be used sparingly, and only in cases where there is a clear property
// that should be set for all commands. If the given config object is
// nil, [Major] will go back to returning its default value.
func SetMajor(c *Config) {
        major = c
}

// minor is the config object for [Minor] specified through [SetMinor]
var minor *Config

// Minor returns the default [Config] object for a minor command,
// based on [logx.UserLevel]. It should be used for commands that
// support an app behind the scenes and are less important for the
// user to know about and be able to see the output of. It results in
// commands and output being printed with a [logx.UserLevel] of
// [slog.LevelDebug] or below, whereas [Major] results in that when
// it is [slog.LevelInfo] or below. The object returned by Minor is
// guaranteed to be unique, so it can be modified directly.
func Minor() *Config {
        if minor != nil {
                // need to make a new copy so people can't modify the underlying
                res := *minor
                return &res
        }
        if logx.UserLevel <= slog.LevelDebug {
                c := &Config{
                        Buffer: true,
                        Env:    map[string]string{},
                        Echo:   os.Stdout,
                }
                c.StdIO.SetFromOS()
                return c
        }
        c := &Config{
                Buffer: true,
                Env:    map[string]string{},
        }
        c.StdIO.SetFromOS()
        c.StdIO.Out = nil
        return c
}

// SetMinor sets the config object that [Minor] returns. It should
// be used sparingly, and only in cases where there is a clear property
// that should be set for all commands. If the given config object is
// nil, [Minor] will go back to returning its default value.
func SetMinor(c *Config) {
        minor = c
}

// verbose is the config object for [Verbose] specified through [SetVerbose]
var verbose *Config

// Verbose returns the default [Config] object for a verbose command,
// based on [logx.UserLevel]. It should be used for commands
// whose output are central to an application; for example, for a
// logger or app runner. It results in commands and output being
// printed with a [logx.UserLevel] of [slog.LevelWarn] or below,
// whereas [Major] and [Minor] result in that when it is [slog.LevelInfo]
// and [slog.levelDebug] or below, respectively. The object returned by
// Verbose is guaranteed to be unique, so it can be modified directly.
func Verbose() *Config {
        if verbose != nil {
                // need to make a new copy so people can't modify the underlying
                res := *verbose
                return &res
        }
        if logx.UserLevel <= slog.LevelWarn {
                c := &Config{
                        Buffer: true,
                        Env:    map[string]string{},
                        Echo:   os.Stdout,
                }
                c.StdIO.SetFromOS()
                return c
        }
        c := &Config{
                Buffer: true,
                Env:    map[string]string{},
        }
        c.StdIO.SetFromOS()
        c.StdIO.Out = nil
        return c
}

// SetVerbose sets the config object that [Verbose] returns. It should
// be used sparingly, and only in cases where there is a clear property
// that should be set for all commands. If the given config object is
// nil, [Verbose] will go back to returning its default value.
func SetVerbose(c *Config) {
        verbose = c
}

// silent is the config object for [Silent] specified through [SetSilent]
var silent *Config

// Silent returns the default [Config] object for a silent command,
// based on [logx.UserLevel]. It should be used for commands that
// whose output/input is private and needs to be always hidden from
// the user; for example, for a command that involves passwords.
// It results in commands and output never being printed. The object
// returned by Silent is guaranteed to be unique, so it can be modified directly.
func Silent() *Config {
        if silent != nil {
                // need to make a new copy so people can't modify the underlying
                res := *silent
                return &res
        }
        c := &Config{
                Buffer: true,
                Env:    map[string]string{},
        }
        c.StdIO.In = os.Stdin
        return c
}

// SetSilent sets the config object that [Silent] returns. It should
// be used sparingly, and only in cases where there is a clear property
// that should be set for all commands. If the given config object is
// nil, [Silent] will go back to returning its default value.
func SetSilent(c *Config) {
        silent = c
}

// GetWriter returns the appropriate writer to use based on the given writer and error.
// If the given error is non-nil, the returned writer is guaranteed to be non-nil,
// with [Config.Stderr] used as a backup. Otherwise, the returned writer will only
// be non-nil if the passed one is.
func (c *Config) GetWriter(w io.Writer, err error) io.Writer {
        res := w
        if res == nil && err != nil {
                res = c.StdIO.Err
        }
        return res
}

// PrintCmd uses [GetWriter] to print the given command to [Config.Echo]
// or [Config.Stderr], based on the given error and the config settings.
// A newline is automatically inserted.
func (c *Config) PrintCmd(cmd string, err error) {
        cmds := c.GetWriter(c.Echo, err)
        if cmds != nil {
                if c.Dir != "" {
                        cmds.Write([]byte(logx.SuccessColor(c.Dir) + ": "))
                }
                cmds.Write([]byte(logx.CmdColor(cmd) + "\n"))
        }
}

// PrintCmd calls [Config.PrintCmd] on [Major]
func PrintCmd(cmd string, err error) {
        Major().PrintCmd(cmd, err)
}

// SetEnv sets the given environment variable.
func (c *Config) SetEnv(key, val string) *Config {
        c.Env[key] = val
        return c
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted in part from: https://github.com/magefile/mage
// Copyright presumably by Nate Finch, primary contributor
// Apache License, Version 2.0, January 2004

package exec

import (
        "bytes"
        "fmt"
        "os"
        "os/exec"
        "strings"

        "cogentcore.org/core/base/logx"
)

// exec executes the command, piping its stdout and stderr to the config
// writers. If start, uses cmd.Start, else.Run.
// If the command fails, it will return an error with the command output.
// The given cmd and args may include references
// to environment variables in $FOO format, in which case these will be
// expanded before the command is run.
//
// Ran reports if the command ran (rather than was not found or not executable).
// Code reports the exit code the command returned if it ran. If err == nil, ran
// is always true and code is always 0.
func (c *Config) exec(sio *StdIO, start bool, cmd string, args ...string) (excmd *exec.Cmd, ran bool, err error) {
        expand := func(s string) string {
                s2, ok := c.Env[s]
                if ok {
                        return s2
                }
                return os.Getenv(s)
        }
        cmd = os.Expand(cmd, expand)
        for i := range args {
                args[i] = os.Expand(args[i], expand)
        }
        excmd, ran, code, err := c.run(sio, start, cmd, args...)
        _ = code
        if err == nil {
                return excmd, true, nil
        }
        return excmd, ran, fmt.Errorf(`failed to run "%s %s: %v"`, cmd, strings.Join(args, " "), err)
}

func (c *Config) run(sio *StdIO, start bool, cmd string, args ...string) (excmd *exec.Cmd, ran bool, code int, err error) {
        cm := exec.Command(cmd, args...)
        cm.Env = os.Environ()
        for k, v := range c.Env {
                cm.Env = append(cm.Env, k+"="+v)
        }
        // need to store in buffer so we can color and print commands and stdout correctly
        // (need to declare regardless even if we aren't using so that it is accessible)
        ebuf := &bytes.Buffer{}
        obuf := &bytes.Buffer{}
        if !start && c.Buffer {
                cm.Stderr = ebuf
                cm.Stdout = obuf
        } else {
                cm.Stderr = sio.Err
                cm.Stdout = sio.Out
        }
        // need to do now because we aren't buffering, or we are guaranteed to print them
        // regardless of whether there is an error anyway, so we should print it now so
        // people can see it earlier (especially important if it runs for a long time).
        if !start || !c.Buffer || c.Echo != nil {
                c.PrintCmd(cmd+" "+strings.Join(args, " "), err)
        }

        cm.Stdin = sio.In
        cm.Dir = c.Dir

        if !c.PrintOnly {
                if start {
                        err = cm.Start()
                        excmd = cm
                } else {
                        err = cm.Run()
                }

                // we must call InitColor after calling a system command
                // TODO(kai): maybe figure out a better solution to this
                // or expand this list
                if cmd == "cp" || cmd == "ls" || cmd == "mv" {
                        logx.InitColor()
                }
        }

        if !start && c.Buffer {
                // if we have an error, we print the commands and stdout regardless of the config info
                // (however, we don't print the command if we are guaranteed to print it regardless, as
                // we already printed it above in that case)
                if c.Echo == nil {
                        c.PrintCmd(cmd+" "+strings.Join(args, " "), err)
                }
                sout := c.GetWriter(sio.Out, err)
                if sout != nil {
                        sout.Write(obuf.Bytes())
                }
                estr := ebuf.String()
                if estr != "" && sio.Err != nil {
                        sio.Err.Write([]byte(logx.ErrorColor(estr)))
                }
        }
        return excmd, CmdRan(err), ExitStatus(err), err
}

// CmdRan examines the error to determine if it was generated as a result of a
// command running via os/exec.Command.  If the error is nil, or the command ran
// (even if it exited with a non-zero exit code), CmdRan reports true.  If the
// error is an unrecognized type, or it is an error from exec.Command that says
// the command failed to run (usually due to the command not existing or not
// being executable), it reports false.
func CmdRan(err error) bool {
        if err == nil {
                return true
        }
        ee, ok := err.(*exec.ExitError)
        if ok {
                return ee.Exited()
        }
        return false
}

type exitStatus interface {
        ExitStatus() int
}

// ExitStatus returns the exit status of the error if it is an exec.ExitError
// or if it implements ExitStatus() int.
// 0 if it is nil or 1 if it is a different error.
func ExitStatus(err error) int {
        if err == nil {
                return 0
        }
        if e, ok := err.(exitStatus); ok {
                return e.ExitStatus()
        }
        if e, ok := err.(*exec.ExitError); ok {
                if ex, ok := e.Sys().(exitStatus); ok {
                        return ex.ExitStatus()
                }
        }
        return 1
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package exec

import (
        "fmt"
        "os"
        "os/exec"
)

// LookPath searches for an executable named file in the
// directories named by the PATH environment variable.
// If file contains a slash, it is tried directly and the PATH is not consulted.
// Otherwise, on success, the result is an absolute path.
//
// In older versions of Go, LookPath could return a path relative to the current directory.
// As of Go 1.19, LookPath will instead return that path along with an error satisfying
// errors.Is(err, ErrDot). See the package documentation for more details.
func LookPath(file string) (string, error) { return exec.LookPath(file) }

// RemoveAll is a helper function that calls [os.RemoveAll] and [Config.PrintCmd].
func (c *Config) RemoveAll(path string) error {
        var err error
        if !c.PrintOnly {
                err = os.RemoveAll(path)
        }
        c.PrintCmd(fmt.Sprintf("rm -rf %q", path), err)
        return err
}

// RemoveAll calls [Config.RemoveAll] on [Major]
func RemoveAll(path string) error {
        return Major().RemoveAll(path)
}

// MkdirAll is a helper function that calls [os.MkdirAll] and [Config.PrintCmd].
func (c *Config) MkdirAll(path string, perm os.FileMode) error {
        var err error
        if !c.PrintOnly {
                err = os.MkdirAll(path, perm)
        }
        c.PrintCmd(fmt.Sprintf("mkdir -p %q", path), err)
        return err
}

// MkdirAll calls [Config.MkdirAll] on [Major]
func MkdirAll(path string, perm os.FileMode) error {
        return Major().MkdirAll(path, perm)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted in part from: https://github.com/magefile/mage
// Copyright presumably by Nate Finch, primary contributor
// Apache License, Version 2.0, January 2004

package exec

import (
        "bytes"
        "os/exec"
        "strings"
)

// Run runs the given command using the given
// configuration information and arguments,
// waiting for it to complete before returning.
func (c *Config) Run(cmd string, args ...string) error {
        _, _, err := c.exec(&c.StdIO, false, cmd, args...)
        return err
}

// Start starts the given command using the given
// configuration information and arguments,
// just starting the command but not waiting for it to finish.
// Returns the [exec.Cmd] command on which you can Wait for
// the command to finish (in a separate goroutine).
// See [StartIO] for a version that manages dynamic IO routing for you.
func (c *Config) Start(cmd string, args ...string) (*exec.Cmd, error) {
        excmd, _, err := c.exec(&c.StdIO, true, cmd, args...)
        return excmd, err
}

// Output runs the command and returns the text from stdout.
func (c *Config) Output(cmd string, args ...string) (string, error) {
        // need to use buf to capture output
        buf := &bytes.Buffer{}
        sio := c.StdIO // copy
        sio.Out = buf
        _, _, err := c.exec(&sio, false, cmd, args...)
        if c.StdIO.Out != nil {
                c.StdIO.Out.Write(buf.Bytes())
        }
        return strings.TrimSuffix(buf.String(), "\n"), err
}

// Run calls [Config.Run] on [Major]
func Run(cmd string, args ...string) error {
        return Major().Run(cmd, args...)
}

// Start calls [Config.Start] on [Major]
func Start(cmd string, args ...string) (*exec.Cmd, error) {
        return Major().Start(cmd, args...)
}

// Output calls [Config.Output] on [Major]
func Output(cmd string, args ...string) (string, error) {
        return Major().Output(cmd, args...)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package exec

import (
        "fmt"
        "io"
        "io/fs"
        "log/slog"
        "os"

        "cogentcore.org/core/base/stack"
)

// StdIO contains one set of standard input / output Reader / Writers.
type StdIO struct {
        // Out is the writer to write the standard output of called commands to.
        // It can be set to nil to disable the writing of the standard output.
        Out io.Writer

        // Err is the writer to write the standard error of called commands to.
        // It can be set to nil to disable the writing of the standard error.
        Err io.Writer

        // In is the reader to use as the standard input.
        In io.Reader
}

// SetFromOS sets all our IO to current os.Std*
func (st *StdIO) SetFromOS() {
        st.Out, st.Err, st.In = os.Stdout, os.Stderr, os.Stdin
}

// SetAll sets all our IO from given args
func (st *StdIO) SetAll(out, err io.Writer, in io.Reader) {
        st.Out, st.Err, st.In = out, err, in
}

// Set sets our values from other StdIO, returning
// the current values at time of call, to restore later.
func (st *StdIO) Set(o *StdIO) *StdIO {
        cur := *st
        *st = *o
        return &cur
}

// SetToOS sets the current IO to os.Std*, returning
// a StdIO with the current IO settings prior to this call,
// which can be used to restore.
// Note: os.Std* are *os.File types, and this function will panic
// if the current IO are not actually *os.Files.
// The results of a prior SetToOS call will do the right thing for
// saving and restoring the os state.
func (st *StdIO) SetToOS() *StdIO {
        cur := &StdIO{}
        cur.SetFromOS()
        if sif, ok := st.In.(*os.File); ok {
                os.Stdin = sif
        } else {
                fmt.Printf("In is not an *os.File: %#v\n", st.In)
        }
        os.Stdout = st.Out.(*os.File)
        os.Stderr = st.Err.(*os.File)
        return cur
}

// Print prints to the [StdIO.Out]
func (st *StdIO) Print(v ...any) {
        fmt.Fprint(st.Out, v...)
}

// Println prints to the [StdIO.Out]
func (st *StdIO) Println(v ...any) {
        fmt.Fprintln(st.Out, v...)
}

// Printf prints to the [StdIO.Out]
func (st *StdIO) Printf(f string, v ...any) {
        fmt.Fprintf(st.Out, f, v...)
}

// ErrPrint prints to the [StdIO.Err]
func (st *StdIO) ErrPrint(v ...any) {
        fmt.Fprint(st.Err, v...)
}

// ErrPrintln prints to the [StdIO.Err]
func (st *StdIO) ErrPrintln(v ...any) {
        fmt.Fprintln(st.Err, v...)
}

// ErrPrintf prints to the [StdIO.Err]
func (st *StdIO) ErrPrintf(f string, v ...any) {
        fmt.Fprintf(st.Err, f, v...)
}

// IsPipe returns true if the given object is an os.File corresponding to a Pipe,
// which is also not the same as the current os.Stdout, in case that is a Pipe.
func IsPipe(rw any) bool {
        if rw == nil {
                return false
        }
        _, ok := rw.(io.Writer)
        if !ok {
                return false
        }
        of, ok := rw.(*os.File)
        if !ok {
                return false
        }
        st, err := of.Stat()
        if err != nil {
                return false
        }
        md := st.Mode()
        if md&fs.ModeNamedPipe != 0 {
                return true
        }
        return md&fs.ModeCharDevice == 0
}

// OutIsPipe returns true if current Out is a Pipe
func (st *StdIO) OutIsPipe() bool { return IsPipe(st.Out) }

// StdIOState maintains a stack of StdIO settings for easier management
// of dynamic IO routing.  Call [StackStart] prior to
// setting the IO values using Push commands, and then call
// [PopToStart] when done to close any open IO and reset.
type StdIOState struct {
        StdIO

        // OutStack is stack of out
        OutStack stack.Stack[io.Writer]

        // ErrStack is stack of err
        ErrStack stack.Stack[io.Writer]

        // InStack is stack of in
        InStack stack.Stack[io.Reader]

        // PipeIn is a stack of the os.File to use for reading from the Out,
        // when Out is a Pipe, created by [PushOutPipe].
        // Use [OutIsPipe] function to determine if the current output is a Pipe
        // in order to determine whether to use the current [PipeIn.Peek()].
        // These will be automatically closed during [PopToStart] whenever the
        // corresponding Out is a Pipe.
        PipeIn stack.Stack[*os.File]

        // Starting depths of the respective stacks, for unwinding the stack
        // to a defined starting point.
        OutStart, ErrStart, InStart int
}

// PushOut pushes a new io.Writer as the current [Out],
// saving the current one on a stack, which can be restored using [PopOut].
func (st *StdIOState) PushOut(out io.Writer) {
        st.OutStack.Push(st.Out)
        st.Out = out
}

// PushOutPipe calls os.Pipe() and pushes the writer side
// as the new [Out], and pushes the Reader side to [PipeIn]
// which should then be used as the [In] for any other relevant process.
// Call [OutIsPipe] to determine if the current Out is a Pipe, to know
// whether to use the PipeIn.Peek() value.
func (st *StdIOState) PushOutPipe() {
        r, w, err := os.Pipe()
        if err != nil {
                slog.Error(err.Error())
        }
        st.PushOut(w)
        st.PipeIn.Push(r)
}

// PopOut restores previous io.Writer as [Out] from the stack,
// saved during [PushOut], returning the current Out at time of call.
// Pops and closes corresponding PipeIn if current Out is a Pipe.
// This does NOT close the current one, in case you need to use it before closing,
// so that is your responsibility (see [PopToStart] that does this for you).
func (st *StdIOState) PopOut() io.Writer {
        if st.OutIsPipe() && len(st.PipeIn) > 0 {
                CloseReader(st.PipeIn.Pop())
        }
        cur := st.Out
        st.Out = st.OutStack.Pop()
        return cur
}

// PushErr pushes a new io.Writer as the current [Err],
// saving the current one on a stack, which can be restored using [PopErr].
func (st *StdIOState) PushErr(err io.Writer) {
        st.ErrStack.Push(st.Err)
        st.Err = err
}

// PopErr restores previous io.Writer as [Err] from the stack,
// saved during [PushErr], returning the current Err at time of call.
// This does NOT close the current one, in case you need to use it before closing,
// so that is your responsibility (see [PopToStart] that does this for you).
// Note that Err is often the same as Out, in which case only Out should be closed.
func (st *StdIOState) PopErr() io.Writer {
        cur := st.Err
        st.Err = st.ErrStack.Pop()
        return cur
}

// PushIn pushes a new [io.Reader] as the current [In],
// saving the current one on a stack, which can be restored using [PopIn].
func (st *StdIOState) PushIn(in io.Reader) {
        st.InStack.Push(st.In)
        st.In = in
}

// PopIn restores previous io.Reader as [In] from the stack,
// saved during [PushIn], returning the current In at time of call.
// This does NOT close the current one, in case you need to use it before closing,
// so that is your responsibility (see [PopToStart] that does this for you).
func (st *StdIOState) PopIn() io.Reader {
        cur := st.In
        st.In = st.InStack.Pop()
        return cur
}

// StackStart records the starting depths of the IO stacks
func (st *StdIOState) StackStart() {
        st.OutStart = len(st.OutStack)
        st.ErrStart = len(st.ErrStack)
        st.InStart = len(st.InStack)
}

// PopToStart unwinds the IO stacks to the depths recorded at [StackStart],
// automatically closing the ones that are popped.
// It automatically checks if any of the Err items are the same as Out
// and does not redundantly close those.
func (st *StdIOState) PopToStart() {
        for len(st.ErrStack) > st.ErrStart {
                er := st.PopErr()
                if !st.ErrIsInOut(er) {
                        fmt.Println("close err")
                        CloseWriter(er)
                }
        }
        for len(st.OutStack) > st.OutStart {
                CloseWriter(st.PopOut())
        }
        for len(st.InStack) > st.InStart {
                st.PopIn()
        }
        for len(st.PipeIn) > 0 {
                CloseReader(st.PipeIn.Pop())
        }
}

// ErrIsInOut returns true if the given Err writer is also present
// within the active (> [OutStart]) stack of Outs.
// If this is true, then Err should not be closed, as it will be closed
// when the Out is closed.
func (st *StdIOState) ErrIsInOut(er io.Writer) bool {
        for i := st.OutStart; i < len(st.OutStack); i++ {
                if st.OutStack[i] == er {
                        return true
                }
        }
        return false
}

// CloseWriter closes given Writer, if it has a Close() method
func CloseWriter(w io.Writer) {
        if st, ok := w.(io.Closer); ok {
                st.Close()
        }
}

// CloseReader closes given Reader, if it has a Close() method
func CloseReader(r io.Reader) {
        if st, ok := r.(io.Closer); ok {
                st.Close()
        }
}

// WriteWrapper is an io.Writer that wraps another io.Writer
type WriteWrapper struct {
        io.Writer
}

// ReadWrapper is an io.Reader that wraps another io.Reader
type ReadWrapper struct {
        io.Reader
}

// NewWrappers initializes this StdIO with wrappers around given StdIO
func (st *StdIO) NewWrappers(o *StdIO) {
        st.Out = &WriteWrapper{Writer: o.Out}
        st.Err = &WriteWrapper{Writer: o.Err}
        st.In = &ReadWrapper{Reader: o.In}
}

// SetWrappers sets the wrappers to current values from given StdIO,
// returning a copy of the wrapped values previously in place at start of call,
// which can be used in restoring state later.
// The wrappers must have been created using NewWrappers initially.
func (st *StdIO) SetWrappers(o *StdIO) *StdIO {
        if o == nil {
                return nil
        }
        cur := st.GetWrapped()
        if cur == nil {
                return nil
        }
        st.Out.(*WriteWrapper).Writer = o.Out
        st.Err.(*WriteWrapper).Writer = o.Err
        st.In.(*ReadWrapper).Reader = o.In
        return cur
}

// SetWrappedOut sets the wrapped Out to given writer.
// The wrappers must have been created using NewWrappers initially.
func (st *StdIO) SetWrappedOut(w io.Writer) {
        st.Out.(*WriteWrapper).Writer = w
}

// SetWrappedErr sets the wrapped Err to given writer.
// The wrappers must have been created using NewWrappers initially.
func (st *StdIO) SetWrappedErr(w io.Writer) {
        st.Err.(*WriteWrapper).Writer = w
}

// SetWrappedIn sets the wrapped In to given reader.
// The wrappers must have been created using NewWrappers initially.
func (st *StdIO) SetWrappedIn(r io.Reader) {
        st.In.(*ReadWrapper).Reader = r
}

// GetWrapped returns the current wrapped values as a StdIO.
// The wrappers must have been created using NewWrappers initially.
func (st *StdIO) GetWrapped() *StdIO {
        _, ok := st.Out.(*WriteWrapper)
        if !ok {
                return nil
        }
        o := &StdIO{}
        o.Out = st.Out.(*WriteWrapper).Writer
        o.Err = st.Err.(*WriteWrapper).Writer
        o.In = st.In.(*ReadWrapper).Reader
        return o
}

// Code generated by "core generate"; DO NOT EDIT.

package exec

import (
        "io"

        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/base/exec.Config", IDName: "config", Doc: "Config contains the configuration information that\ncontrols the behavior of exec. It is passed to most\nhigh-level functions, and a default version of it\ncan be easily constructed using [DefaultConfig].", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Fields: []types.Field{{Name: "Buffer", Doc: "Buffer is whether to buffer the output of Stdout and Stderr,\nwhich is necessary for the correct printing of commands and output\nwhen there is an error with a command, and for correct coloring\non Windows. Therefore, it should be kept at the default value of\ntrue in most cases, except for when a command will run for a log\ntime and print output throughout (eg: a log command)."}, {Name: "PrintOnly", Doc: "PrintOnly is whether to only print commands that would be run and\nnot actually run them. It can be used, for example, for safely testing\nan app."}, {Name: "Dir", Doc: "The directory to execute commands in. If it is unset,\ncommands are run in the current directory."}, {Name: "Env", Doc: "Env contains any additional environment variables specified.\nThe current environment variables will also be passed to the\ncommand, but they will be overridden by any variables here\nif there are conflicts."}, {Name: "Echo", Doc: "Echo is the writer for echoing the command string to.\nIt can be set to nil to disable echoing."}, {Name: "StdIO", Doc: "Standard Input / Output management"}}})

// SetBuffer sets the [Config.Buffer]:
// Buffer is whether to buffer the output of Stdout and Stderr,
// which is necessary for the correct printing of commands and output
// when there is an error with a command, and for correct coloring
// on Windows. Therefore, it should be kept at the default value of
// true in most cases, except for when a command will run for a log
// time and print output throughout (eg: a log command).
func (t *Config) SetBuffer(v bool) *Config { t.Buffer = v; return t }

// SetPrintOnly sets the [Config.PrintOnly]:
// PrintOnly is whether to only print commands that would be run and
// not actually run them. It can be used, for example, for safely testing
// an app.
func (t *Config) SetPrintOnly(v bool) *Config { t.PrintOnly = v; return t }

// SetDir sets the [Config.Dir]:
// The directory to execute commands in. If it is unset,
// commands are run in the current directory.
func (t *Config) SetDir(v string) *Config { t.Dir = v; return t }

// SetEcho sets the [Config.Echo]:
// Echo is the writer for echoing the command string to.
// It can be set to nil to disable echoing.
func (t *Config) SetEcho(v io.Writer) *Config { t.Echo = v; return t }

// SetStdIO sets the [Config.StdIO]:
// Standard Input / Output management
func (t *Config) SetStdIO(v StdIO) *Config { t.StdIO = v; return t }

// Code generated by "core generate"; DO NOT EDIT.

package fileinfo

import (
        "cogentcore.org/core/enums"
)

var _CategoriesValues = []Categories{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}

// CategoriesN is the highest valid value for type Categories, plus one.
const CategoriesN Categories = 16

var _CategoriesValueMap = map[string]Categories{`UnknownCategory`: 0, `Folder`: 1, `Archive`: 2, `Backup`: 3, `Code`: 4, `Doc`: 5, `Sheet`: 6, `Data`: 7, `Text`: 8, `Image`: 9, `Model`: 10, `Audio`: 11, `Video`: 12, `Font`: 13, `Exe`: 14, `Bin`: 15}

var _CategoriesDescMap = map[Categories]string{0: `UnknownCategory is an unknown file category`, 1: `Folder is a folder / directory`, 2: `Archive is a collection of files, e.g., zip tar`, 3: `Backup is a backup file (# ~ etc)`, 4: `Code is a programming language file`, 5: `Doc is an editable word processing file including latex, markdown, html, css, etc`, 6: `Sheet is a spreadsheet file (.xls etc)`, 7: `Data is some kind of data format (csv, json, database, etc)`, 8: `Text is some other kind of text file`, 9: `Image is an image (jpeg, png, svg, etc) *including* PDF`, 10: `Model is a 3D model`, 11: `Audio is an audio file`, 12: `Video is a video file`, 13: `Font is a font file`, 14: `Exe is a binary executable file (scripts go in Code)`, 15: `Bin is some other type of binary (object files, libraries, etc)`}

var _CategoriesMap = map[Categories]string{0: `UnknownCategory`, 1: `Folder`, 2: `Archive`, 3: `Backup`, 4: `Code`, 5: `Doc`, 6: `Sheet`, 7: `Data`, 8: `Text`, 9: `Image`, 10: `Model`, 11: `Audio`, 12: `Video`, 13: `Font`, 14: `Exe`, 15: `Bin`}

// String returns the string representation of this Categories value.
func (i Categories) String() string { return enums.String(i, _CategoriesMap) }

// SetString sets the Categories value from its string representation,
// and returns an error if the string is invalid.
func (i *Categories) SetString(s string) error {
        return enums.SetString(i, s, _CategoriesValueMap, "Categories")
}

// Int64 returns the Categories value as an int64.
func (i Categories) Int64() int64 { return int64(i) }

// SetInt64 sets the Categories value from an int64.
func (i *Categories) SetInt64(in int64) { *i = Categories(in) }

// Desc returns the description of the Categories value.
func (i Categories) Desc() string { return enums.Desc(i, _CategoriesDescMap) }

// CategoriesValues returns all possible values for the type Categories.
func CategoriesValues() []Categories { return _CategoriesValues }

// Values returns all possible values for the type Categories.
func (i Categories) Values() []enums.Enum { return enums.Values(_CategoriesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Categories) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Categories) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Categories")
}

var _KnownValues = []Known{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132}

// KnownN is the highest valid value for type Known, plus one.
const KnownN Known = 133

var _KnownValueMap = map[string]Known{`Unknown`: 0, `Any`: 1, `AnyKnown`: 2, `AnyFolder`: 3, `AnyArchive`: 4, `Multipart`: 5, `Tar`: 6, `Zip`: 7, `GZip`: 8, `SevenZ`: 9, `Xz`: 10, `BZip`: 11, `Dmg`: 12, `Shar`: 13, `AnyBackup`: 14, `Trash`: 15, `AnyCode`: 16, `Ada`: 17, `Bash`: 18, `Cosh`: 19, `Csh`: 20, `C`: 21, `CSharp`: 22, `D`: 23, `Diff`: 24, `Eiffel`: 25, `Erlang`: 26, `Forth`: 27, `Fortran`: 28, `FSharp`: 29, `Go`: 30, `Goal`: 31, `Haskell`: 32, `Java`: 33, `JavaScript`: 34, `Lisp`: 35, `Lua`: 36, `Makefile`: 37, `Mathematica`: 38, `Matlab`: 39, `ObjC`: 40, `OCaml`: 41, `Pascal`: 42, `Perl`: 43, `Php`: 44, `Prolog`: 45, `Python`: 46, `R`: 47, `Ruby`: 48, `Rust`: 49, `Scala`: 50, `SQL`: 51, `Tcl`: 52, `AnyDoc`: 53, `BibTeX`: 54, `TeX`: 55, `Texinfo`: 56, `Troff`: 57, `Html`: 58, `Css`: 59, `Markdown`: 60, `Rtf`: 61, `MSWord`: 62, `OpenText`: 63, `OpenPres`: 64, `MSPowerpoint`: 65, `EBook`: 66, `EPub`: 67, `AnySheet`: 68, `MSExcel`: 69, `OpenSheet`: 70, `AnyData`: 71, `Csv`: 72, `Json`: 73, `Xml`: 74, `Protobuf`: 75, `Ini`: 76, `Tsv`: 77, `Uri`: 78, `Color`: 79, `Yaml`: 80, `Toml`: 81, `Number`: 82, `String`: 83, `Tensor`: 84, `Table`: 85, `AnyText`: 86, `PlainText`: 87, `ICal`: 88, `VCal`: 89, `VCard`: 90, `AnyImage`: 91, `Pdf`: 92, `Postscript`: 93, `Gimp`: 94, `GraphVis`: 95, `Gif`: 96, `Jpeg`: 97, `Png`: 98, `Svg`: 99, `Tiff`: 100, `Pnm`: 101, `Pbm`: 102, `Pgm`: 103, `Ppm`: 104, `Xbm`: 105, `Xpm`: 106, `Bmp`: 107, `Heic`: 108, `Heif`: 109, `AnyModel`: 110, `Vrml`: 111, `X3d`: 112, `Obj`: 113, `AnyAudio`: 114, `Aac`: 115, `Flac`: 116, `Mp3`: 117, `Ogg`: 118, `Midi`: 119, `Wav`: 120, `AnyVideo`: 121, `Mpeg`: 122, `Mp4`: 123, `Mov`: 124, `Ogv`: 125, `Wmv`: 126, `Avi`: 127, `AnyFont`: 128, `TrueType`: 129, `WebOpenFont`: 130, `AnyExe`: 131, `AnyBin`: 132}

var _KnownDescMap = map[Known]string{0: `Unknown = a non-known file type`, 1: `Any is used when selecting a file type, if any type is OK (including Unknown) see also AnyKnown and the Any options for each category`, 2: `AnyKnown is used when selecting a file type, if any Known file type is OK (excludes Unknown) -- see Any and Any options for each category`, 3: `Folder is a folder / directory`, 4: `Archive is a collection of files, e.g., zip tar`, 5: ``, 6: ``, 7: ``, 8: ``, 9: ``, 10: ``, 11: ``, 12: ``, 13: ``, 14: `Backup files`, 15: ``, 16: `Code is a programming language file`, 17: ``, 18: ``, 19: ``, 20: ``, 21: ``, 22: ``, 23: ``, 24: ``, 25: ``, 26: ``, 27: ``, 28: ``, 29: ``, 30: ``, 31: ``, 32: ``, 33: ``, 34: ``, 35: ``, 36: ``, 37: ``, 38: ``, 39: ``, 40: ``, 41: ``, 42: ``, 43: ``, 44: ``, 45: ``, 46: ``, 47: ``, 48: ``, 49: ``, 50: ``, 51: ``, 52: ``, 53: `Doc is an editable word processing file including latex, markdown, html, css, etc`, 54: ``, 55: ``, 56: ``, 57: ``, 58: ``, 59: ``, 60: ``, 61: ``, 62: ``, 63: ``, 64: ``, 65: ``, 66: ``, 67: ``, 68: `Sheet is a spreadsheet file (.xls etc)`, 69: ``, 70: ``, 71: `Data is some kind of data format (csv, json, database, etc)`, 72: ``, 73: ``, 74: ``, 75: ``, 76: ``, 77: ``, 78: ``, 79: ``, 80: ``, 81: ``, 82: `special support for data fs`, 83: ``, 84: ``, 85: ``, 86: `Text is some other kind of text file`, 87: ``, 88: ``, 89: ``, 90: ``, 91: `Image is an image (jpeg, png, svg, etc) *including* PDF`, 92: ``, 93: ``, 94: ``, 95: ``, 96: ``, 97: ``, 98: ``, 99: ``, 100: ``, 101: ``, 102: ``, 103: ``, 104: ``, 105: ``, 106: ``, 107: ``, 108: ``, 109: ``, 110: `Model is a 3D model`, 111: ``, 112: ``, 113: ``, 114: `Audio is an audio file`, 115: ``, 116: ``, 117: ``, 118: ``, 119: ``, 120: ``, 121: `Video is a video file`, 122: ``, 123: ``, 124: ``, 125: ``, 126: ``, 127: ``, 128: `Font is a font file`, 129: ``, 130: ``, 131: `Exe is a binary executable file`, 132: `Bin is some other unrecognized binary type`}

var _KnownMap = map[Known]string{0: `Unknown`, 1: `Any`, 2: `AnyKnown`, 3: `AnyFolder`, 4: `AnyArchive`, 5: `Multipart`, 6: `Tar`, 7: `Zip`, 8: `GZip`, 9: `SevenZ`, 10: `Xz`, 11: `BZip`, 12: `Dmg`, 13: `Shar`, 14: `AnyBackup`, 15: `Trash`, 16: `AnyCode`, 17: `Ada`, 18: `Bash`, 19: `Cosh`, 20: `Csh`, 21: `C`, 22: `CSharp`, 23: `D`, 24: `Diff`, 25: `Eiffel`, 26: `Erlang`, 27: `Forth`, 28: `Fortran`, 29: `FSharp`, 30: `Go`, 31: `Goal`, 32: `Haskell`, 33: `Java`, 34: `JavaScript`, 35: `Lisp`, 36: `Lua`, 37: `Makefile`, 38: `Mathematica`, 39: `Matlab`, 40: `ObjC`, 41: `OCaml`, 42: `Pascal`, 43: `Perl`, 44: `Php`, 45: `Prolog`, 46: `Python`, 47: `R`, 48: `Ruby`, 49: `Rust`, 50: `Scala`, 51: `SQL`, 52: `Tcl`, 53: `AnyDoc`, 54: `BibTeX`, 55: `TeX`, 56: `Texinfo`, 57: `Troff`, 58: `Html`, 59: `Css`, 60: `Markdown`, 61: `Rtf`, 62: `MSWord`, 63: `OpenText`, 64: `OpenPres`, 65: `MSPowerpoint`, 66: `EBook`, 67: `EPub`, 68: `AnySheet`, 69: `MSExcel`, 70: `OpenSheet`, 71: `AnyData`, 72: `Csv`, 73: `Json`, 74: `Xml`, 75: `Protobuf`, 76: `Ini`, 77: `Tsv`, 78: `Uri`, 79: `Color`, 80: `Yaml`, 81: `Toml`, 82: `Number`, 83: `String`, 84: `Tensor`, 85: `Table`, 86: `AnyText`, 87: `PlainText`, 88: `ICal`, 89: `VCal`, 90: `VCard`, 91: `AnyImage`, 92: `Pdf`, 93: `Postscript`, 94: `Gimp`, 95: `GraphVis`, 96: `Gif`, 97: `Jpeg`, 98: `Png`, 99: `Svg`, 100: `Tiff`, 101: `Pnm`, 102: `Pbm`, 103: `Pgm`, 104: `Ppm`, 105: `Xbm`, 106: `Xpm`, 107: `Bmp`, 108: `Heic`, 109: `Heif`, 110: `AnyModel`, 111: `Vrml`, 112: `X3d`, 113: `Obj`, 114: `AnyAudio`, 115: `Aac`, 116: `Flac`, 117: `Mp3`, 118: `Ogg`, 119: `Midi`, 120: `Wav`, 121: `AnyVideo`, 122: `Mpeg`, 123: `Mp4`, 124: `Mov`, 125: `Ogv`, 126: `Wmv`, 127: `Avi`, 128: `AnyFont`, 129: `TrueType`, 130: `WebOpenFont`, 131: `AnyExe`, 132: `AnyBin`}

// String returns the string representation of this Known value.
func (i Known) String() string { return enums.String(i, _KnownMap) }

// SetString sets the Known value from its string representation,
// and returns an error if the string is invalid.
func (i *Known) SetString(s string) error { return enums.SetString(i, s, _KnownValueMap, "Known") }

// Int64 returns the Known value as an int64.
func (i Known) Int64() int64 { return int64(i) }

// SetInt64 sets the Known value from an int64.
func (i *Known) SetInt64(in int64) { *i = Known(in) }

// Desc returns the description of the Known value.
func (i Known) Desc() string { return enums.Desc(i, _KnownDescMap) }

// KnownValues returns all possible values for the type Known.
func KnownValues() []Known { return _KnownValues }

// Values returns all possible values for the type Known.
func (i Known) Values() []enums.Enum { return enums.Values(_KnownValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Known) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Known) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Known") }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fileinfo

// Categories is a functional category for files; a broad functional
// categorization that can help decide what to do with the file.
//
// It is computed in part from the mime type, but some types require
// other information.
//
// No single categorization scheme is perfect, so any given use
// may require examination of the full mime type etc, but this
// provides a useful broad-scope categorization of file types.
type Categories int32 //enums:enum

const (
        // UnknownCategory is an unknown file category
        UnknownCategory Categories = iota

        // Folder is a folder / directory
        Folder

        // Archive is a collection of files, e.g., zip tar
        Archive

        // Backup is a backup file (# ~ etc)
        Backup

        // Code is a programming language file
        Code

        // Doc is an editable word processing file including latex, markdown, html, css, etc
        Doc

        // Sheet is a spreadsheet file (.xls etc)
        Sheet

        // Data is some kind of data format (csv, json, database, etc)
        Data

        // Text is some other kind of text file
        Text

        // Image is an image (jpeg, png, svg, etc) *including* PDF
        Image

        // Model is a 3D model
        Model

        // Audio is an audio file
        Audio

        // Video is a video file
        Video

        // Font is a font file
        Font

        // Exe is a binary executable file (scripts go in Code)
        Exe

        // Bin is some other type of binary (object files, libraries, etc)
        Bin
)

// CategoryFromMime returns the file category based on the mime type;
// not all Categories can be inferred from file types
func CategoryFromMime(mime string) Categories {
        if mime == "" {
                return UnknownCategory
        }
        mime = MimeNoChar(mime)
        if mt, has := AvailableMimes[mime]; has {
                return mt.Cat // must be set!
        }
        // try from type:
        ms := MimeTop(mime)
        if ms == "" {
                return UnknownCategory
        }
        switch ms {
        case "image":
                return Image
        case "audio":
                return Audio
        case "video":
                return Video
        case "font":
                return Font
        case "model":
                return Model
        }
        if ms == "text" {
                return Text
        }
        return UnknownCategory
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package fileinfo manages file information and categorizes file types;
// it is the single, consolidated place where file info, mimetypes, and
// filetypes are managed in Cogent Core.
//
// This whole space is a bit of a heterogenous mess; most file types
// we care about are not registered on the official iana registry, which
// seems mainly to have paid registrations in application/ category,
// and doesn't have any of the main programming languages etc.
//
// The official Go std library support depends on different platform
// libraries and mac doesn't have one, so it has very limited support
//
// So we sucked it up and made a full list of all the major file types
// that we really care about and also provide a broader category-level organization
// that is useful for functionally organizing / operating on files.
//
// As fallback, we are this Go package:
// github.com/h2non/filetype
package fileinfo

import (
        "errors"
        "fmt"
        "io/fs"
        "log"
        "os"
        "path"
        "path/filepath"
        "strings"
        "testing"
        "time"

        "cogentcore.org/core/base/datasize"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/icons"
        "github.com/Bios-Marcel/wastebasket/v2"
)

// FileInfo represents the information about a given file / directory,
// including icon, mimetype, etc
type FileInfo struct { //types:add

        // icon for file
        Ic icons.Icon `table:"no-header"`

        // name of the file, without any path
        Name string `width:"40"`

        // size of the file
        Size datasize.Size

        // type of file / directory; shorter, more user-friendly
        // version of mime type, based on category
        Kind string `width:"20" max-width:"20"`

        // full official mime type of the contents
        Mime string `table:"-"`

        // functional category of the file, based on mime data etc
        Cat Categories `table:"-"`

        // known file type
        Known Known `table:"-"`

        // file mode bits
        Mode fs.FileMode `table:"-"`

        // time that contents (only) were last modified
        ModTime time.Time `label:"Last modified"`

        // version control system status, when enabled
        VCS vcs.FileStatus `table:"-"`

        // Generated indicates that the file is generated and should not be edited.
        // For Go files, this regex: `^// Code generated .* DO NOT EDIT\.$` is used.
        Generated bool `table:"-"`

        // full path to file, including name; for file functions
        Path string `table:"-"`
}

// NewFileInfo returns a new FileInfo for given file.
func NewFileInfo(fname string) (*FileInfo, error) {
        fi := &FileInfo{}
        err := fi.InitFile(fname)
        return fi, err
}

// NewFileInfoType returns a new FileInfo representing the given file type.
func NewFileInfoType(ftyp Known) *FileInfo {
        fi := &FileInfo{}
        fi.SetType(ftyp)
        return fi
}

// InitFile initializes a FileInfo for os file based on a filename,
// which is updated to full path using filepath.Abs.
// Returns error from filepath.Abs and / or fs.Stat error on the given file,
// but file info will be updated based on the filename even if
// the file does not exist.
func (fi *FileInfo) InitFile(fname string) error {
        fi.Cat = UnknownCategory
        fi.Known = Unknown
        fi.Generated = false
        fi.Kind = ""
        var errs []error
        path, err := filepath.Abs(fname)
        if err == nil {
                fi.Path = path
        } else {
                fi.Path = fname
        }
        _, fi.Name = filepath.Split(path)
        info, err := os.Stat(fi.Path)
        if err != nil {
                errs = append(errs, err)
                fi.MimeFromFilename()
        } else {
                fi.SetFileInfo(info)
        }
        return errors.Join(errs...)
}

// InitFileFS initializes a FileInfo based on filename in given fs.FS.
// Returns error from fs.Stat error on the given file,
// but file info will be updated based on the filename even if
// the file does not exist.
func (fi *FileInfo) InitFileFS(fsys fs.FS, fname string) error {
        fi.Cat = UnknownCategory
        fi.Known = Unknown
        fi.Generated = false
        fi.Kind = ""
        var errs []error
        fi.Path = fname
        _, fi.Name = path.Split(fname)
        info, err := fs.Stat(fsys, fi.Path)
        if err != nil {
                errs = append(errs, err)
                fi.MimeFromFilename()
        } else {
                fi.SetFileInfo(info)
        }
        return errors.Join(errs...)
}

// MimeFromFilename sets the mime data based only on the filename
// without attempting to open the file.
func (fi *FileInfo) MimeFromFilename() error {
        ext := strings.ToLower(filepath.Ext(fi.Path))
        if mtype, has := ExtMimeMap[ext]; has { // only use our filename ext map
                fi.SetMimeFromType(mtype)
                return nil
        }
        return errors.New("FileInfo MimeFromFilename: Filename extension not known: " + ext)
}

// MimeFromFile sets the mime data for a valid file (i.e., os.Stat works).
// Use MimeFromFilename to only examine the filename.
func (fi *FileInfo) MimeFromFile() error {
        if fi.Path == "" || fi.Path == "." || fi.IsDir() {
                return nil
        }
        fi.Generated = IsGeneratedFile(fi.Path)
        mtype, _, err := MimeFromFile(fi.Path)
        if err != nil {
                return err
        }
        fi.SetMimeFromType(mtype)
        return nil
}

// SetMimeType sets file info fields from given mime type string.
func (fi *FileInfo) SetMimeFromType(mtype string) {
        fi.Mime = mtype
        fi.Cat = CategoryFromMime(mtype)
        fi.Known = MimeKnown(mtype)
        if fi.Cat != UnknownCategory {
                fi.Kind = fi.Cat.String() + ": "
        }
        if fi.Known != Unknown {
                fi.Kind += fi.Known.String()
        } else {
                fi.Kind += MimeSub(fi.Mime)
        }
}

// SetFileInfo updates from given [fs.FileInfo]. It uses a canonical
// [FileInfo.ModTime] when testing to ensure consistent results.
func (fi *FileInfo) SetFileInfo(info fs.FileInfo) {
        fi.Size = datasize.Size(info.Size())
        fi.Mode = info.Mode()
        if testing.Testing() {
                // We use a canonical time when testing to ensure consistent results.
                fi.ModTime = time.Unix(1500000000, 0)
        } else {
                fi.ModTime = info.ModTime()
        }
        if info.IsDir() {
                fi.Kind = "Folder"
                fi.Cat = Folder
                fi.Known = AnyFolder
        } else {
                if fi.Mode.IsRegular() {
                        fi.MimeFromFile()
                }
                if fi.Cat == UnknownCategory {
                        if fi.IsExec() {
                                fi.Cat = Exe
                                fi.Known = AnyExe
                        }
                }
        }
        icn, _ := fi.FindIcon()
        fi.Ic = icn
}

// SetType sets file type information for given Known file type
func (fi *FileInfo) SetType(ftyp Known) {
        mt := MimeFromKnown(ftyp)
        fi.Mime = mt.Mime
        fi.Cat = mt.Cat
        fi.Known = mt.Known
        if fi.Name == "" && len(mt.Exts) > 0 {
                fi.Name = "_fake" + mt.Exts[0]
                fi.Path = fi.Name
        }
        fi.Kind = fi.Cat.String() + ": "
        if fi.Known != Unknown {
                fi.Kind += fi.Known.String()
        }
}

// IsDir returns true if file is a directory (folder)
func (fi *FileInfo) IsDir() bool {
        return fi.Mode.IsDir()
}

// IsExec returns true if file is an executable file
func (fi *FileInfo) IsExec() bool {
        if fi.Mode&0111 != 0 {
                return true
        }
        ext := filepath.Ext(fi.Path)
        return ext == ".exe"
}

// IsSymLink returns true if file is a symbolic link
func (fi *FileInfo) IsSymlink() bool {
        return fi.Mode&os.ModeSymlink != 0
}

// IsHidden returns true if file name starts with . or _ which are typically hidden
func (fi *FileInfo) IsHidden() bool {
        return fi.Name == "" || fi.Name[0] == '.' || fi.Name[0] == '_'
}

//////////////////////////////////////////////////////////////////////////////
//    File ops

// Duplicate creates a copy of given file -- only works for regular files, not
// directories.
func (fi *FileInfo) Duplicate() (string, error) { //types:add
        if fi.IsDir() {
                err := fmt.Errorf("core.Duplicate: cannot copy directory: %v", fi.Path)
                log.Println(err)
                return "", err
        }
        ext := filepath.Ext(fi.Path)
        noext := strings.TrimSuffix(fi.Path, ext)
        dst := noext + "_Copy" + ext
        cpcnt := 0
        for {
                if _, err := os.Stat(dst); !os.IsNotExist(err) {
                        cpcnt++
                        dst = noext + fmt.Sprintf("_Copy%d", cpcnt) + ext
                } else {
                        break
                }
        }
        return dst, fsx.CopyFile(dst, fi.Path, fi.Mode)
}

// Delete moves the file to the trash / recycling bin.
// On mobile and web, it deletes it directly.
func (fi *FileInfo) Delete() error { //types:add
        err := wastebasket.Trash(fi.Path)
        if errors.Is(err, wastebasket.ErrPlatformNotSupported) {
                return os.RemoveAll(fi.Path)
        }
        return err
}

// Filenames recursively adds fullpath filenames within the starting directory to the "names" slice.
// Directory names within the starting directory are not added.
func Filenames(d os.File, names *[]string) (err error) {
        nms, err := d.Readdirnames(-1)
        if err != nil {
                return err
        }
        for _, n := range nms {
                fp := filepath.Join(d.Name(), n)
                ffi, ferr := os.Stat(fp)
                if ferr != nil {
                        return ferr
                }
                if ffi.IsDir() {
                        dd, err := os.Open(fp)
                        if err != nil {
                                return err
                        }
                        defer dd.Close()
                        Filenames(*dd, names)
                } else {
                        *names = append(*names, fp)
                }
        }
        return nil
}

// Filenames returns a slice of file names from the starting directory and its subdirectories
func (fi *FileInfo) Filenames(names *[]string) (err error) {
        if !fi.IsDir() {
                err = errors.New("not a directory: Filenames returns a list of files within a directory")
                return err
        }
        path := fi.Path
        d, err := os.Open(path)
        if err != nil {
                return err
        }
        defer d.Close()

        err = Filenames(*d, names)
        return err
}

// RenamePath returns the proposed path or the new full path.
// Does not actually do the renaming -- see Rename method.
func (fi *FileInfo) RenamePath(path string) (newpath string, err error) {
        if path == "" {
                err = errors.New("core.Rename: new name is empty")
                log.Println(err)
                return path, err
        }
        if path == fi.Path {
                return "", nil
        }
        ndir, np := filepath.Split(path)
        if ndir == "" {
                if np == fi.Name {
                        return path, nil
                }
                dir, _ := filepath.Split(fi.Path)
                newpath = filepath.Join(dir, np)
        }
        return newpath, nil
}

// Rename renames (moves) this file to given new path name.
// Updates the FileInfo setting to the new name, although it might
// be out of scope if it moved into a new path
func (fi *FileInfo) Rename(path string) (newpath string, err error) { //types:add
        orgpath := fi.Path
        newpath, err = fi.RenamePath(path)
        if err != nil {
                return
        }
        err = os.Rename(string(orgpath), newpath)
        if err == nil {
                fi.Path = newpath
                _, fi.Name = filepath.Split(newpath)
        }
        return
}

// FindIcon uses file info to find an appropriate icon for this file -- uses
// Kind string first to find a correspondingly named icon, and then tries the
// extension.  Returns true on success.
func (fi *FileInfo) FindIcon() (icons.Icon, bool) {
        if fi.IsDir() {
                return icons.Folder, true
        }
        return Icons[fi.Known], true
}

// Note: can get all the detailed birth, access, change times from this package
//         "github.com/djherbis/times"

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fileinfo

//go:generate core generate

import (
        "fmt"
)

// Known is an enumerated list of known file types, for which
// appropriate actions can be taken etc.
type Known int32 //enums:enum

// KnownMimes maps from the known type into the MimeType info for each
// known file type; the known MimeType may be just one of
// multiple that correspond to the known type; it should be first in list
// and have extensions defined
var KnownMimes map[Known]MimeType

// MimeString gives the string representation of the canonical mime type
// associated with given known mime type.
func MimeString(kn Known) string {
        mt, has := KnownMimes[kn]
        if !has {
                // log.Printf("fileinfo.MimeString called with unrecognized 'Known' type: %v\n", sup)
                return ""
        }
        return mt.Mime
}

// Cat returns the Cat category for given known file type
func (kn Known) Cat() Categories {
        if kn == Unknown {
                return UnknownCategory
        }
        mt, has := KnownMimes[kn]
        if !has {
                // log.Printf("fileinfo.KnownCat called with unrecognized 'Known' type: %v\n", sup)
                return UnknownCategory
        }
        return mt.Cat
}

// IsMatch returns true if given file type matches target type,
// which could be any of the Any options
func IsMatch(targ, typ Known) bool {
        if targ == Any {
                return true
        }
        if targ == AnyKnown {
                return typ != Unknown
        }
        if targ == typ {
                return true
        }
        cat := typ.Cat()
        switch targ {
        case AnyFolder:
                return cat == Folder
        case AnyArchive:
                return cat == Archive
        case AnyBackup:
                return cat == Backup
        case AnyCode:
                return cat == Code
        case AnyDoc:
                return cat == Doc
        case AnySheet:
                return cat == Sheet
        case AnyData:
                return cat == Data
        case AnyText:
                return cat == Text
        case AnyImage:
                return cat == Image
        case AnyModel:
                return cat == Model
        case AnyAudio:
                return cat == Audio
        case AnyVideo:
                return cat == Video
        case AnyFont:
                return cat == Font
        case AnyExe:
                return cat == Exe
        case AnyBin:
                return cat == Bin
        }
        return false
}

// IsMatchList returns true if given file type matches any of a list of targets
// if list is empty, then always returns true
func IsMatchList(targs []Known, typ Known) bool {
        if len(targs) == 0 {
                return true
        }
        for _, trg := range targs {
                if IsMatch(trg, typ) {
                        return true
                }
        }
        return false
}

// KnownByName looks up known file type by caps or lowercase name
func KnownByName(name string) (Known, error) {
        var kn Known
        err := kn.SetString(name)
        if err != nil {
                err = fmt.Errorf("fileinfo.KnownByName: doesn't look like that is a known file type: %v", name)
                return kn, err
        }
        return kn, nil
}

// These are the super high-frequency used mime types, to have very quick const level support
const (
        TextPlain = "text/plain"
        DataJson  = "application/json"
        DataXml   = "application/xml"
        DataCsv   = "text/csv"
)

// These are the known file types, organized by category
const (
        // Unknown = a non-known file type
        Unknown Known = iota

        // Any is used when selecting a file type, if any type is OK (including Unknown)
        // see also AnyKnown and the Any options for each category
        Any

        // AnyKnown is used when selecting a file type, if any Known
        // file type is OK (excludes Unknown) -- see Any and Any options for each category
        AnyKnown

        // Folder is a folder / directory
        AnyFolder

        // Archive is a collection of files, e.g., zip tar
        AnyArchive
        Multipart
        Tar
        Zip
        GZip
        SevenZ
        Xz
        BZip
        Dmg
        Shar

        // Backup files
        AnyBackup
        Trash

        // Code is a programming language file
        AnyCode
        Ada
        Bash
        Cosh
        Csh
        C // includes C++
        CSharp
        D
        Diff
        Eiffel
        Erlang
        Forth
        Fortran
        FSharp
        Go
        Goal
        Haskell
        Java
        JavaScript
        Lisp
        Lua
        Makefile
        Mathematica
        Matlab
        ObjC
        OCaml
        Pascal
        Perl
        Php
        Prolog
        Python
        R
        Ruby
        Rust
        Scala
        SQL
        Tcl

        // Doc is an editable word processing file including latex, markdown, html, css, etc
        AnyDoc
        BibTeX
        TeX
        Texinfo
        Troff

        Html
        Css
        Markdown
        Rtf
        MSWord
        OpenText
        OpenPres
        MSPowerpoint

        EBook
        EPub

        // Sheet is a spreadsheet file (.xls etc)
        AnySheet
        MSExcel
        OpenSheet

        // Data is some kind of data format (csv, json, database, etc)
        AnyData
        Csv
        Json
        Xml
        Protobuf
        Ini
        Tsv
        Uri
        Color
        Yaml
        Toml
        // special support for data fs
        Number
        String
        Tensor
        Table

        // Text is some other kind of text file
        AnyText
        PlainText // text/plain mimetype -- used for clipboard
        ICal
        VCal
        VCard

        // Image is an image (jpeg, png, svg, etc) *including* PDF
        AnyImage
        Pdf
        Postscript
        Gimp
        GraphVis
        Gif
        Jpeg
        Png
        Svg
        Tiff
        Pnm
        Pbm
        Pgm
        Ppm
        Xbm
        Xpm
        Bmp
        Heic
        Heif

        // Model is a 3D model
        AnyModel
        Vrml
        X3d
        Obj

        // Audio is an audio file
        AnyAudio
        Aac
        Flac
        Mp3
        Ogg
        Midi
        Wav

        // Video is a video file
        AnyVideo
        Mpeg
        Mp4
        Mov
        Ogv
        Wmv
        Avi

        // Font is a font file
        AnyFont
        TrueType
        WebOpenFont

        // Exe is a binary executable file
        AnyExe

        // Bin is some other unrecognized binary type
        AnyBin
)

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package mimedata defines MIME data support used in clipboard and
// drag-and-drop functions in the Cogent Core GUI.  mimedata.Data struct contains
// format and []byte data, and multiple representations of the same data are
// encoded in mimedata.Mimes which is just a []mimedata.Data slice -- it can
// be encoded / decoded from mime multipart.
//
// See the fileinfo package for known mimetypes.
package mimedata

import (
        "bytes"
        "encoding/base64"
        "fmt"
        "io"
        "log"
        "mime"
        "mime/multipart"
        "net/textproto"
        "strings"
)

const (
        MIMEVersion1            = "MIME-Version: 1.0"
        ContentType             = "Content-Type"
        ContentTransferEncoding = "Content-Transfer-Encoding"

        TextPlain = "text/plain"
        DataJson  = "application/json"
        DataXml   = "application/xml"
)

var (
        MIMEVersion1B            = ([]byte)(MIMEVersion1)
        ContentTypeB             = ([]byte)(ContentType)
        ContentTransferEncodingB = ([]byte)(ContentTransferEncoding)
)

// Data represents one element of MIME data as a type string and byte slice
type Data struct {
        // MIME Type string representing the data, e.g., text/plain, text/html, text/xml, text/uri-list, image/jpg, png etc
        Type string

        // Data for the item
        Data []byte
}

// NewTextData returns a Data representation of the string -- good idea to
// always have a text/plain representation of everything on clipboard /
// drag-n-drop
func NewTextData(text string) *Data {
        return &Data{TextPlain, []byte(text)}
}

// NewTextDataBytes returns a Data representation of the bytes string
func NewTextDataBytes(text []byte) *Data {
        return &Data{TextPlain, text}
}

// IsText returns true if type is any of the text/ types (literally looks for that
// at start of Type) or is another known text type (e.g., AppJSON, XML)
func IsText(typ string) bool {
        if strings.HasPrefix(typ, "text/") {
                return true
        }
        return typ == DataJson || typ == DataXml
}

////////////////////////////////////////////////////////////////////////////////
//    Mimes

// Mimes is a slice of mime data, potentially encoding the same data in
// different formats -- this is used for all system APIs for maximum
// flexibility
type Mimes []*Data

// NewMimes returns a new Mimes slice of given length and capacity
func NewMimes(ln, cp int) Mimes {
        return make(Mimes, ln, cp)
}

// NewText returns a Mimes representation of the string as a single text/plain Data
func NewText(text string) Mimes {
        md := NewTextData(text)
        mi := make(Mimes, 1)
        mi[0] = md
        return mi
}

// NewTextBytes returns a Mimes representation of the bytes string as a single text/plain Data
func NewTextBytes(text []byte) Mimes {
        md := NewTextDataBytes(text)
        mi := make(Mimes, 1)
        mi[0] = md
        return mi
}

// NewTextPlus returns a Mimes representation of an item as a text string plus
// a more specific type
func NewTextPlus(text, typ string, data []byte) Mimes {
        md := NewTextData(text)
        mi := make(Mimes, 2)
        mi[0] = md
        mi[1] = &Data{typ, data}
        return mi
}

// NewMime returns a Mimes representation of one element
func NewMime(typ string, data []byte) Mimes {
        mi := make(Mimes, 1)
        mi[0] = &Data{typ, data}
        return mi
}

// HasType returns true if Mimes has given type of data available
func (mi Mimes) HasType(typ string) bool {
        for _, d := range mi {
                if d.Type == typ {
                        return true
                }
        }
        return false
}

// TypeData returns data associated with given MIME type
func (mi Mimes) TypeData(typ string) []byte {
        for _, d := range mi {
                if d.Type == typ {
                        return d.Data
                }
        }
        return nil
}

// Text extracts all the text elements of given type as a string
func (mi Mimes) Text(typ string) string {
        str := ""
        for _, d := range mi {
                if d.Type == typ {
                        str = str + string(d.Data)
                }
        }
        return str
}

// ToMultipart produces a MIME multipart representation of multiple data
// elements present in the stream -- this should be used in system.Clipboard
// whenever there are multiple elements to be pasted, because windows doesn't
// support multiple clip elements, and linux isn't very convenient either
func (mi Mimes) ToMultipart() []byte {
        var b bytes.Buffer
        mpw := multipart.NewWriter(io.Writer(&b))
        hdr := fmt.Sprintf("%v\n%v: multipart/mixed; boundary=%v\n", MIMEVersion1, ContentType, mpw.Boundary())
        b.Write(([]byte)(hdr))
        for _, d := range mi {
                mh := textproto.MIMEHeader{ContentType: {d.Type}}
                bin := false
                if !IsText(d.Type) {
                        mh.Add(ContentTransferEncoding, "base64")
                        bin = true
                }
                wp, _ := mpw.CreatePart(mh)
                if bin {
                        eb := make([]byte, base64.StdEncoding.EncodedLen(len(d.Data)))
                        base64.StdEncoding.Encode(eb, d.Data)
                        wp.Write(eb)
                } else {
                        wp.Write(d.Data)
                }
        }
        mpw.Close()
        return b.Bytes()
}

// IsMultipart examines data bytes to see if it has a MIME-Version: 1.0
// ContentType: multipart/* header -- returns the actual multipart media type,
// body of the data string after the header (assumed to be a single \n
// terminated line at start of string, and the boundary separating multipart
// elements (all from mime.ParseMediaType) -- mediaType is the mediaType if it
// is another MIME type -- can check that for non-empty string
func IsMultipart(str []byte) (isMulti bool, mediaType, boundary string, body []byte) {
        isMulti = false
        mediaType = ""
        boundary = ""
        body = ([]byte)("")
        var pars map[string]string
        var err error
        if bytes.HasPrefix(str, MIMEVersion1B) {
                cri := bytes.IndexByte(str, '\n')
                if cri < 0 { // shouldn't happen
                        return
                }
                ctln := str[cri+1:]
                if bytes.HasPrefix(ctln, ContentTypeB) { // should
                        cri2 := bytes.IndexByte(ctln, '\n')
                        if cri2 < 0 { // shouldn't happen
                                return
                        }
                        hdr := ctln[len(ContentTypeB)+1 : cri2]
                        mediaType, pars, err = mime.ParseMediaType(string(hdr))
                        if err != nil { // shouldn't happen
                                log.Printf("mimedata.IsMultipart: malformed MIME header: %v\n", err)
                                return
                        }
                        if strings.HasPrefix(mediaType, "multipart/") {
                                isMulti = true
                                body = str[cri2+1:]
                                boundary = pars["boundary"]
                        }
                }
        }
        return
}

// FromMultipart parses a MIME multipart representation of multiple data
// elements into corresponding mime data components
func FromMultipart(body []byte, boundary string) Mimes {
        mi := make(Mimes, 0, 10)
        sr := bytes.NewReader(body)
        mr := multipart.NewReader(sr, boundary)
        for {
                p, err := mr.NextPart()
                if err == io.EOF {
                        return mi
                }
                if err != nil {
                        log.Printf("mimedata.IsMultipart: malformed multipart MIME: %v\n", err)
                        return mi
                }
                b, err := io.ReadAll(p)
                if err != nil {
                        log.Printf("mimedata.IsMultipart: bad ReadAll of multipart MIME: %v\n", err)
                        return mi
                }
                d := Data{}
                d.Type = p.Header.Get(ContentType)
                cte := p.Header.Get(ContentTransferEncoding)
                if cte != "" {
                        switch cte {
                        case "base64":
                                eb := make([]byte, base64.StdEncoding.DecodedLen(len(b)))
                                base64.StdEncoding.Decode(eb, b)
                                b = eb
                        }
                }
                d.Data = b
                mi = append(mi, &d)
        }
}

// todo: image, etc extractors

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fileinfo

import (
        "fmt"
        "mime"
        "os"
        "path/filepath"
        "regexp"
        "strings"

        "github.com/h2non/filetype"
)

// MimeNoChar returns the mime string without any charset
// encoding information, or anything else after a ;
func MimeNoChar(mime string) string {
        if sidx := strings.Index(mime, ";"); sidx > 0 {
                return strings.TrimSpace(mime[:sidx])
        }
        return mime
}

// MimeTop returns the top-level main type category from mime type
// i.e., the thing before the /  -- returns empty if no /
func MimeTop(mime string) string {
        if sidx := strings.Index(mime, "/"); sidx > 0 {
                return mime[:sidx]
        }
        return ""
}

// MimeSub returns the sub-level subtype category from mime type
// i.e., the thing after the /  -- returns empty if no /
// also trims off any charset encoding stuff
func MimeSub(mime string) string {
        if sidx := strings.Index(MimeNoChar(mime), "/"); sidx > 0 {
                return mime[sidx+1:]
        }
        return ""
}

// MimeFromFile gets mime type from file, using Gabriel Vasile's mimetype
// package, mime.TypeByExtension, the chroma syntax highlighter,
// CustomExtMimeMap, and finally FileExtMimeMap.  Use the mimetype package's
// extension mechanism to add further content-based matchers as needed, and
// set CustomExtMimeMap to your own map or call AddCustomExtMime for
// extension-based ones.
func MimeFromFile(fname string) (mtype, ext string, err error) {
        ext = strings.ToLower(filepath.Ext(fname))
        if mtyp, has := ExtMimeMap[ext]; has { // use our map first: very fast!
                return mtyp, ext, nil
        }
        _, fn := filepath.Split(fname)
        var fc, lc byte
        if len(fn) > 0 {
                fc = fn[0]
                lc = fn[len(fn)-1]
        }
        if fc == '~' || fc == '%' || fc == '#' || lc == '~' || lc == '%' || lc == '#' {
                return MimeString(Trash), ext, nil
        }
        mtypt, err := filetype.MatchFile(fn) // h2non next -- has good coverage
        ptyp := ""
        isplain := false
        if err == nil {
                mtyp := mtypt.MIME.Value
                ext = mtypt.Extension
                if strings.HasPrefix(mtyp, "text/plain") {
                        isplain = true
                        ptyp = mtyp
                } else {
                        return mtyp, ext, nil
                }
        }
        mtyp := mime.TypeByExtension(ext)
        if mtyp != "" {
                return mtyp, ext, nil
        }
        // TODO(kai/binsize): figure out how to do this without dragging in chroma dependency
        // lexer := lexers.Match(fn) // todo: could get start of file and pass to
        // // Analyze, but might be too slow..
        // if lexer != nil {
        //         config := lexer.Config()
        //         if len(config.MimeTypes) > 0 {
        //                 mtyp = config.MimeTypes[0]
        //                 return mtyp, ext, nil
        //         }
        //         mtyp := "application/" + strings.ToLower(config.Name)
        //         return mtyp, ext, nil
        // }
        if isplain {
                return ptyp, ext, nil
        }
        if strings.ToLower(fn) == "makefile" {
                return MimeString(Makefile), ext, nil
        }
        return "", ext, fmt.Errorf("fileinfo.MimeFromFile could not find mime type for ext: %v file: %v", ext, fn)
}

var generatedRe = regexp.MustCompile(`^// Code generated .* DO NOT EDIT`)

func IsGeneratedFile(fname string) bool {
        file, err := os.Open(fname)
        if err != nil {
                return false
        }
        head := make([]byte, 2048)
        file.Read(head)
        return generatedRe.Match(head)
}

// todo: use this to check against mime types!

// MimeToKindMapInit makes sure the MimeToKindMap is initialized from
// InitMimeToKindMap plus chroma lexer types.
// func MimeToKindMapInit() {
//         if MimeToKindMap != nil {
//                 return
//         }
//         MimeToKindMap = InitMimeToKindMap
//         for _, l := range lexers.Registry.Lexers {
//                 config := l.Config()
//                 nm := strings.ToLower(config.Name)
//                 if len(config.MimeTypes) > 0 {
//                         mtyp := config.MimeTypes[0]
//                         MimeToKindMap[mtyp] = nm
//                 } else {
//                         MimeToKindMap["application/"+nm] = nm
//                 }
//         }
// }

//////////////////////////////////////////////////////////////////////////////
//    Mime types

// ExtMimeMap is the map from extension to mime type, built from AvailMimes
var ExtMimeMap = map[string]string{}

// MimeType contains all the information associated with a given mime type
type MimeType struct {

        // mimetype string: type/subtype
        Mime string

        // file extensions associated with this file type
        Exts []string

        // category of file
        Cat Categories

        // if known, the name of the known file type, else NoSupporUnknown
        Known Known
}

// CustomMimes can be set by other apps to contain custom mime types that
// go beyond what is in the standard ones, and can also redefine and
// override the standard one
var CustomMimes []MimeType

// AvailableMimes is the full list (as a map from mimetype) of available defined mime types
// built from StdMimes (compiled in) and then CustomMimes can override
var AvailableMimes map[string]MimeType

// MimeKnown returns the known type for given mime key,
// or Unknown if not found or not a known file type
func MimeKnown(mime string) Known {
        mt, has := AvailableMimes[MimeNoChar(mime)]
        if !has {
                return Unknown
        }
        return mt.Known
}

// ExtKnown returns the known type for given file extension,
// or Unknown if not found or not a known file type
func ExtKnown(ext string) Known {
        mime, has := ExtMimeMap[ext]
        if !has {
                return Unknown
        }
        mt, has := AvailableMimes[mime]
        if !has {
                return Unknown
        }
        return mt.Known
}

// KnownFromFile returns the known type for given file,
// or Unknown if not found or not a known file type
func KnownFromFile(fname string) Known {
        mtyp, _, err := MimeFromFile(fname)
        if err != nil {
                return Unknown
        }
        return MimeKnown(mtyp)
}

// MimeFromKnown returns MimeType info for given known file type.
func MimeFromKnown(ftyp Known) MimeType {
        for _, mt := range AvailableMimes {
                if mt.Known == ftyp {
                        return mt
                }
        }
        return MimeType{}
}

// MergeAvailableMimes merges the StdMimes and CustomMimes into AvailMimes
// if CustomMimes is updated, then this should be called -- initially
// it just has StdMimes.
// It also builds the ExtMimeMap to map from extension to mime type
// and KnownMimes map of known file types onto their full
// mime type entry
func MergeAvailableMimes() {
        AvailableMimes = make(map[string]MimeType, len(StandardMimes)+len(CustomMimes))
        for _, mt := range StandardMimes {
                AvailableMimes[mt.Mime] = mt
        }
        for _, mt := range CustomMimes {
                AvailableMimes[mt.Mime] = mt // overwrite automatically
        }
        ExtMimeMap = make(map[string]string) // start over
        KnownMimes = make(map[Known]MimeType)
        for _, mt := range AvailableMimes {
                if len(mt.Exts) > 0 { // first pass add only ext guys to support
                        for _, ex := range mt.Exts {
                                if ex[0] != '.' {
                                        fmt.Printf("fileinfo.MergeAvailMimes: ext: %v does not start with a . in type: %v\n", ex, mt.Mime)
                                }
                                if pmt, has := ExtMimeMap[ex]; has {
                                        fmt.Printf("fileinfo.MergeAvailMimes: non-unique ext: %v assigned to mime type: %v AND %v\n", ex, pmt, mt.Mime)
                                } else {
                                        ExtMimeMap[ex] = mt.Mime
                                }
                        }
                        if mt.Known != Unknown {
                                if hsp, has := KnownMimes[mt.Known]; has {
                                        fmt.Printf("fileinfo.MergeAvailMimes: more-than-one mimetype has extensions for same known file type: %v -- one: %v other %v\n", mt.Known, hsp.Mime, mt.Mime)
                                } else {
                                        KnownMimes[mt.Known] = mt
                                }
                        }
                }
        }
        // second pass to get any known guys that don't have exts
        for _, mt := range AvailableMimes {
                if mt.Known != Unknown {
                        if _, has := KnownMimes[mt.Known]; !has {
                                KnownMimes[mt.Known] = mt
                        }
                }
        }
}

func init() {
        MergeAvailableMimes()
}

// http://www.iana.org/assignments/media-types/media-types.xhtml
// https://github.com/mirage/ocaml-magic-mime/blob/master/x-mime.types
// https://www.apt-browse.org/browse/debian/stretch/main/all/mime-support/3.60/file/etc/mime.types
// https://developer.apple.com/library/archive/documentation/Miscellaneous/Reference/UTIRef/Articles/System-DeclaredUniformTypeIdentifiers.html
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Complete_list_of_MIME_types

// StandardMimes is the full list of standard mime types compiled into our code
// various other maps etc are constructed from it.
// When there are multiple types associated with the same real type, pick one
// to be the canonical one and give it, and *only* it, the extensions!
var StandardMimes = []MimeType{
        // Folder
        {"text/directory", nil, Folder, Unknown},

        // Archive
        {"multipart/mixed", nil, Archive, Multipart},
        {"application/tar", []string{".tar", ".tar.gz", ".tgz", ".taz", ".taZ", ".tar.bz2", ".tz2", ".tbz2", ".tbz", ".tar.lz", ".tar.lzma", ".tlz", ".tar.lzop", ".tar.xz"}, Archive, Tar},
        {"application/x-gtar", nil, Archive, Tar},
        {"application/x-gtar-compressed", nil, Archive, Tar},
        {"application/x-tar", nil, Archive, Tar},

        {"application/zip", []string{".zip"}, Archive, Zip},
        {"application/gzip", []string{".gz"}, Archive, GZip},
        {"application/x-7z-compressed", []string{".7z"}, Archive, SevenZ},
        {"application/x-xz", []string{".xz"}, Archive, Xz},
        {"application/x-bzip", []string{".bz", ".bz2"}, Archive, BZip},
        {"application/x-bzip2", nil, Archive, BZip},

        {"application/x-apple-diskimage", []string{".dmg"}, Archive, Dmg},
        {"application/x-shar", []string{".shar"}, Archive, Shar},

        {"application/x-bittorrent", []string{".torrent"}, Archive, Unknown},
        {"application/rar", []string{".rar"}, Archive, Unknown},
        {"application/x-stuffit", []string{".sit", ".sitx"}, Archive, Unknown},

        {"application/vnd.android.package-archive", []string{".apk"}, Archive, Unknown},
        {"application/vnd.debian.binary-package", []string{".deb", ".ddeb", ".udeb"}, Archive, Unknown},
        {"application/x-debian-package", nil, Archive, Unknown},
        {"application/x-redhat-package-manager", []string{".rpm"}, Archive, Unknown},
        {"text/x-rpm-spec", nil, Archive, Unknown},

        // Backup
        {"application/x-trash", []string{".bak", ".old", ".sik"}, Backup, Trash}, // also "~", "%", "#",

        // Code -- use text/ as main instead of application as there are more text
        {"text/x-ada", []string{".adb", ".ads", ".ada"}, Code, Ada},
        {"text/x-asp", []string{".aspx", ".asax", ".ascx", ".ashx", ".asmx", ".axd"}, Code, Unknown},

        {"text/x-sh", []string{".bash", ".sh"}, Code, Bash},
        {"application/x-sh", nil, Code, Bash},

        {"text/x-csrc", []string{".c", ".C", ".c++", ".cpp", ".cxx", ".cc", ".h", ".h++", ".hpp", ".hxx", ".hh", ".hlsl", ".gsl", ".frag", ".vert", ".mm"}, Code, C}, // this is apparently the main one now
        {"text/x-chdr", nil, Code, C},
        {"text/x-c", nil, Code, C},
        {"text/x-c++hdr", nil, Code, C},
        {"text/x-c++src", nil, Code, C},
        {"text/x-chdr", nil, Code, C},
        {"text/x-cpp", nil, Code, C},

        {"text/x-csh", []string{".csh"}, Code, Csh},
        {"application/x-csh", nil, Code, Csh},

        {"text/x-csharp", []string{".cs"}, Code, CSharp},
        {"text/x-dsrc", []string{".d"}, Code, D},
        {"text/x-diff", []string{".diff", ".patch"}, Code, Diff},
        {"text/x-eiffel", []string{".e"}, Code, Eiffel},
        {"text/x-erlang", []string{".erl", ".hrl", ".escript"}, Code, Erlang}, // note: ".es" conflicts with ecmascript
        {"text/x-forth", []string{".frt"}, Code, Forth},                       // note: ".fs" conflicts with fsharp
        {"text/x-fortran", []string{".f", ".F"}, Code, Fortran},
        {"text/x-fsharp", []string{".fs", ".fsi"}, Code, FSharp},
        {"text/x-gosrc", []string{".go", ".mod", ".work", ".goal"}, Code, Go},
        {"text/x-haskell", []string{".hs", ".lhs"}, Code, Haskell},
        {"text/x-literate-haskell", nil, Code, Haskell}, // todo: not sure if same or not

        {"text/x-java", []string{".java", ".jar"}, Code, Java},
        {"application/java-archive", nil, Code, Java},
        {"application/javascript", []string{".js"}, Code, JavaScript},
        {"application/ecmascript", []string{".es"}, Code, Unknown},

        {"text/x-common-lisp", []string{".lisp", ".cl", ".el"}, Code, Lisp},
        {"text/elisp", nil, Code, Lisp},
        {"text/x-elisp", nil, Code, Lisp},
        {"application/emacs-lisp", nil, Code, Lisp},

        {"text/x-lua", []string{".lua", ".wlua"}, Code, Lua},

        {"text/x-makefile", nil, Code, Makefile},
        {"text/x-autoconf", nil, Code, Makefile},

        {"text/x-moc", []string{".moc"}, Code, Unknown},

        {"application/mathematica", []string{".nb", ".nbp"}, Code, Mathematica},

        {"text/x-matlab", []string{".m"}, Code, Matlab},
        {"text/matlab", nil, Code, Matlab},
        {"text/octave", nil, Code, Matlab},
        {"text/scilab", []string{".sci", ".sce", ".tst"}, Code, Unknown},

        {"text/x-modelica", []string{".mo"}, Code, Unknown},
        {"text/x-nemerle", []string{".n"}, Code, Unknown},

        {"text/x-objcsrc", nil, Code, ObjC}, // doesn't have chroma support -- use C instead
        {"text/x-objective-j", nil, Code, Unknown},

        {"text/x-ocaml", []string{".ml", ".mli", ".mll", ".mly"}, Code, OCaml},
        {"text/x-pascal", []string{".p", ".pas"}, Code, Pascal},
        {"text/x-perl", []string{".pl", ".pm"}, Code, Perl},
        {"text/x-php", []string{".php", ".php3", ".php4", ".php5", ".inc"}, Code, Php},
        {"text/x-prolog", []string{".ecl", ".prolog", ".pro"}, Code, Prolog}, // note: ".pl" conflicts

        {"text/x-python", []string{".py", ".pyc", ".pyo", ".pyw"}, Code, Python},
        {"application/x-python-code", nil, Code, Python},

        {"text/x-rust", []string{".rs"}, Code, Rust},
        {"text/rust", nil, Code, Rust},

        {"text/x-r", []string{".r", ".S", ".R", ".Rhistory", ".Rprofile", ".Renviron"}, Code, R},
        {"text/x-R", nil, Code, R},
        {"text/S-Plus", nil, Code, R},
        {"text/S", nil, Code, R},
        {"text/x-r-source", nil, Code, R},
        {"text/x-r-history", nil, Code, R},
        {"text/x-r-profile", nil, Code, R},

        {"text/x-ruby", []string{".rb"}, Code, Ruby},
        {"application/x-ruby", nil, Code, Ruby},
        {"text/x-scala", []string{".scala"}, Code, Scala},
        {"text/x-tcl", []string{".tcl", ".tk"}, Code, Tcl},
        {"application/x-tcl", nil, Code, Tcl},

        // Doc
        {"text/x-bibtex", []string{".bib"}, Doc, BibTeX},
        {"text/x-tex", []string{".tex", ".ltx", ".sty", ".cls", ".latex"}, Doc, TeX},
        {"application/x-latex", nil, Doc, TeX},

        {"application/x-texinfo", []string{".texinfo", ".texi"}, Doc, Texinfo},

        {"application/x-troff", []string{".t", ".tr", ".roff", ".man", ".me", ".ms"}, Doc, Troff},
        {"application/x-troff-man", nil, Doc, Troff},
        {"application/x-troff-me", nil, Doc, Troff},
        {"application/x-troff-ms", nil, Doc, Troff},

        {"text/html", []string{".html", ".htm", ".shtml", ".xhtml", ".xht"}, Doc, Html},
        {"application/xhtml+xml", nil, Doc, Html},
        {"text/mathml", []string{".mml"}, Doc, Unknown},
        {"text/css", []string{".css"}, Doc, Css},

        {"text/markdown", []string{".md", ".markdown"}, Doc, Markdown},
        {"text/x-markdown", nil, Doc, Markdown},

        {"application/rtf", []string{".rtf"}, Doc, Rtf},
        {"text/richtext", []string{".rtx"}, Doc, Unknown},

        {"application/mbox", []string{".mbox"}, Doc, Unknown},
        {"application/x-rss+xml", []string{".rss"}, Doc, Unknown},

        {"application/msword", []string{".doc", ".dot", ".docx", ".dotx"}, Doc, MSWord},
        {"application/vnd.ms-word", nil, Doc, MSWord},
        {"application/vnd.openxmlformats-officedocument.wordprocessingml.document", nil, Doc, MSWord},
        {"application/vnd.openxmlformats-officedocument.wordprocessingml.template", nil, Doc, MSWord},

        {"application/vnd.oasis.opendocument.text", []string{".odt", ".odm", ".ott", ".oth", ".sxw", ".sxg", ".stw", ".sxm"}, Doc, OpenText},
        {"application/vnd.oasis.opendocument.text-master", nil, Doc, OpenText},
        {"application/vnd.oasis.opendocument.text-template", nil, Doc, OpenText},
        {"application/vnd.oasis.opendocument.text-web", nil, Doc, OpenText},
        {"application/vnd.sun.xml.writer", nil, Doc, OpenText},
        {"application/vnd.sun.xml.writer.global", nil, Doc, OpenText},
        {"application/vnd.sun.xml.writer.template", nil, Doc, OpenText},
        {"application/vnd.sun.xml.math", nil, Doc, OpenText},

        {"application/vnd.oasis.opendocument.presentation", []string{".odp", ".otp", ".sxi", ".sti"}, Doc, OpenPres},
        {"application/vnd.oasis.opendocument.presentation-template", nil, Doc, OpenPres},
        {"application/vnd.sun.xml.impress", nil, Doc, OpenPres},
        {"application/vnd.sun.xml.impress.template", nil, Doc, OpenPres},

        {"application/vnd.ms-powerpoint", []string{".ppt", ".pps", ".pptx", ".sldx", ".ppsx", ".potx"}, Doc, MSPowerpoint},
        {"application/vnd.openxmlformats-officedocument.presentationml.presentation", nil, Doc, MSPowerpoint},
        {"application/vnd.openxmlformats-officedocument.presentationml.slide", nil, Doc, MSPowerpoint},
        {"application/vnd.openxmlformats-officedocument.presentationml.slideshow", nil, Doc, MSPowerpoint},
        {"application/vnd.openxmlformats-officedocument.presentationml.template", nil, Doc, MSPowerpoint},

        {"application/ms-tnef", nil, Doc, Unknown},
        {"application/vnd.ms-tnef", nil, Doc, Unknown},

        {"application/onenote", []string{".one", ".onetoc2", ".onetmp", ".onepkg"}, Doc, Unknown},

        {"application/pgp-encrypted", []string{".pgp"}, Doc, Unknown},
        {"application/pgp-keys", []string{".key"}, Doc, Unknown},
        {"application/pgp-signature", []string{".sig"}, Doc, Unknown},

        {"application/vnd.amazon.ebook", []string{".azw"}, Doc, EBook},
        {"application/epub+zip", []string{".epub"}, Doc, EPub},

        // Sheet
        {"application/vnd.ms-excel", []string{".xls", ".xlb", ".xlt", ".xlsx", ".xltx"}, Sheet, MSExcel},
        {"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", nil, Sheet, MSExcel},
        {"application/vnd.openxmlformats-officedocument.spreadsheetml.template", nil, Sheet, MSExcel},

        {"application/vnd.oasis.opendocument.spreadsheet", []string{".ods", ".ots", ".sxc", ".stc", ".odf"}, Sheet, OpenSheet},
        {"application/vnd.oasis.opendocument.spreadsheet-template", nil, Sheet, OpenSheet},
        {"application/vnd.oasis.opendocument.formula", nil, Sheet, OpenSheet}, // todo: could be separate
        {"application/vnd.sun.xml.calc", nil, Sheet, OpenSheet},
        {"application/vnd.sun.xml.calc.template", nil, Sheet, OpenSheet},

        // Data
        {"text/csv", []string{".csv"}, Data, Csv},
        {"application/json", []string{".json"}, Data, Json},
        {"application/xml", []string{".xml", ".xsd"}, Data, Xml},
        {"text/xml", nil, Data, Xml},
        {"text/x-protobuf", []string{".proto"}, Data, Protobuf},
        {"text/x-ini", []string{".ini", ".cfg", ".inf"}, Data, Ini},
        {"text/x-ini-file", nil, Data, Ini},
        {"text/uri-list", nil, Data, Uri},
        {"application/x-color", nil, Data, Color},
        {"text/toml", []string{".toml"}, Data, Toml},
        {"application/toml", nil, Data, Toml},
        {"application/yaml", []string{".yaml"}, Data, Yaml},

        {"application/rdf+xml", []string{".rdf"}, Data, Unknown},
        {"application/msaccess", []string{".mdb"}, Data, Unknown},
        {"application/vnd.oasis.opendocument.database", []string{".odb"}, Data, Unknown},
        {"text/tab-separated-values", []string{".tsv"}, Data, Tsv},
        {"application/vnd.google-earth.kml+xml", []string{".kml", ".kmz"}, Data, Unknown},
        {"application/vnd.google-earth.kmz", nil, Data, Unknown},
        {"application/x-sql", []string{".sql"}, Data, Unknown},

        // Text
        {"text/plain", []string{".asc", ".txt", ".text", ".pot", ".brf", ".srt"}, Text, PlainText},
        {"text/cache-manifest", []string{".appcache"}, Text, Unknown},
        {"text/calendar", []string{".ics", ".icz"}, Text, ICal},
        {"text/x-vcalendar", []string{".vcs"}, Text, VCal},
        {"text/vcard", []string{".vcf", ".vcard"}, Text, VCard},

        // Image
        {"application/pdf", []string{".pdf"}, Image, Pdf},
        {"application/postscript", []string{".ps", ".ai", ".eps", ".epsi", ".epsf", ".eps2", ".eps3"}, Image, Postscript},
        {"application/vnd.oasis.opendocument.graphics", []string{".odc", ".odg", ".otg", ".odi", ".sxd", ".std"}, Image, Unknown},
        {"application/vnd.oasis.opendocument.chart", nil, Image, Unknown},
        {"application/vnd.oasis.opendocument.graphics-template", nil, Image, Unknown},
        {"application/vnd.oasis.opendocument.image", nil, Image, Unknown},
        {"application/vnd.sun.xml.draw", nil, Image, Unknown},
        {"application/vnd.sun.xml.draw.template", nil, Image, Unknown},
        {"application/x-xfig", []string{".fig"}, Image, Unknown},
        {"application/x-xcf", []string{".xcf"}, Image, Gimp},
        {"text/vnd.graphviz", []string{".gv"}, Image, GraphVis},

        {"image/gif", []string{".gif"}, Image, Gif},
        {"image/ief", []string{".ief"}, Image, Unknown},
        {"image/jp2", []string{".jp2", ".jpg2"}, Image, Unknown},
        {"image/jpeg", []string{".jpeg", ".jpg", ".jpe"}, Image, Jpeg},
        {"image/jpm", []string{".jpm"}, Image, Unknown},
        {"image/jpx", []string{".jpx", ".jpf"}, Image, Unknown},
        {"image/pcx", []string{".pcx"}, Image, Unknown},
        {"image/png", []string{".png"}, Image, Png},
        {"image/heic", []string{".heic"}, Image, Heic},
        {"image/heif", []string{".heif"}, Image, Heif},
        {"image/svg+xml", []string{".svg", ".svgz"}, Image, Svg},
        {"image/tiff", []string{".tiff", ".tif"}, Image, Tiff},
        {"image/vnd.djvu", []string{".djvu", ".djv"}, Image, Unknown},
        {"image/vnd.microsoft.icon", []string{".ico"}, Image, Unknown},
        {"image/vnd.wap.wbmp", []string{".wbmp"}, Image, Unknown},
        {"image/x-canon-cr2", []string{".cr2"}, Image, Unknown},
        {"image/x-canon-crw", []string{".crw"}, Image, Unknown},
        {"image/x-cmu-raster", []string{".ras"}, Image, Unknown},
        {"image/x-coreldraw", []string{".cdr", ".pat", ".cdt", ".cpt"}, Image, Unknown},
        {"image/x-coreldrawpattern", nil, Image, Unknown},
        {"image/x-coreldrawtemplate", nil, Image, Unknown},
        {"image/x-corelphotopaint", nil, Image, Unknown},
        {"image/x-epson-erf", []string{".erf"}, Image, Unknown},
        {"image/x-jg", []string{".art"}, Image, Unknown},
        {"image/x-jng", []string{".jng"}, Image, Unknown},
        {"image/x-ms-bmp", []string{".bmp"}, Image, Bmp},
        {"image/x-nikon-nef", []string{".nef"}, Image, Unknown},
        {"image/x-olympus-orf", []string{".orf"}, Image, Unknown},
        {"image/x-photoshop", []string{".psd"}, Image, Unknown},
        {"image/x-portable-anymap", []string{".pnm"}, Image, Pnm},
        {"image/x-portable-bitmap", []string{".pbm"}, Image, Pbm},
        {"image/x-portable-graymap", []string{".pgm"}, Image, Pgm},
        {"image/x-portable-pixmap", []string{".ppm"}, Image, Ppm},
        {"image/x-rgb", []string{".rgb"}, Image, Unknown},
        {"image/x-xbitmap", []string{".xbm"}, Image, Xbm},
        {"image/x-xpixmap", []string{".xpm"}, Image, Xpm},
        {"image/x-xwindowdump", []string{".xwd"}, Image, Unknown},

        // Model
        {"model/iges", []string{".igs", ".iges"}, Model, Unknown},
        {"model/mesh", []string{".msh", ".mesh", ".silo"}, Model, Unknown},
        {"model/vrml", []string{".wrl", ".vrml", ".vrm"}, Model, Vrml},
        {"x-world/x-vrml", nil, Model, Vrml},
        {"model/x3d+xml", []string{".x3dv", ".x3d", ".x3db"}, Model, X3d},
        {"model/x3d+vrml", nil, Model, X3d},
        {"model/x3d+binary", nil, Model, X3d},
        {"application/object", []string{".obj", ".mtl"}, Model, Obj},

        // Audio
        {"audio/aac", []string{".aac"}, Audio, Aac},
        {"audio/flac", []string{".flac"}, Audio, Flac},
        {"audio/mpeg", []string{".mpga", ".mpega", ".mp2", ".mp3", ".m4a"}, Audio, Mp3},
        {"audio/mpegurl", []string{".m3u"}, Audio, Unknown},
        {"audio/x-mpegurl", nil, Audio, Unknown},
        {"audio/ogg", []string{".oga", ".ogg", ".opus", ".spx"}, Audio, Ogg},
        {"audio/amr", []string{".amr"}, Audio, Unknown},
        {"audio/amr-wb", []string{".awb"}, Audio, Unknown},
        {"audio/annodex", []string{".axa"}, Audio, Unknown},
        {"audio/basic", []string{".au", ".snd"}, Audio, Unknown},
        {"audio/csound", []string{".csd", ".orc", ".sco"}, Audio, Unknown},
        {"audio/midi", []string{".mid", ".midi", ".kar"}, Audio, Midi},
        {"audio/prs.sid", []string{".sid"}, Audio, Unknown},
        {"audio/x-aiff", []string{".aif", ".aiff", ".aifc"}, Audio, Unknown},
        {"audio/x-gsm", []string{".gsm"}, Audio, Unknown},
        {"audio/x-ms-wma", []string{".wma"}, Audio, Unknown},
        {"audio/x-ms-wax", []string{".wax"}, Audio, Unknown},
        {"audio/x-pn-realaudio", []string{".ra", ".rm", ".ram"}, Audio, Unknown},
        {"audio/x-realaudio", nil, Audio, Unknown},
        {"audio/x-scpls", []string{".pls"}, Audio, Unknown},
        {"audio/x-sd2", []string{".sd2"}, Audio, Unknown},
        {"audio/x-wav", []string{".wav"}, Audio, Wav},

        // Video
        {"video/3gpp", []string{".3gp"}, Video, Unknown},
        {"video/annodex", []string{".axv"}, Video, Unknown},
        {"video/dl", []string{".dl"}, Video, Unknown},
        {"video/dv", []string{".dif", ".dv"}, Video, Unknown},
        {"video/fli", []string{".fli"}, Video, Unknown},
        {"video/gl", []string{".gl"}, Video, Unknown},
        {"video/h264", nil, Video, Unknown},
        {"video/mpeg", []string{".mpeg", ".mpg", ".mpe"}, Video, Mpeg},
        {"video/MP2T", []string{".ts"}, Video, Unknown},
        {"video/mp4", []string{".mp4"}, Video, Mp4},
        {"video/quicktime", []string{".qt", ".mov"}, Video, Mov},
        {"video/ogg", []string{".ogv"}, Video, Ogv},
        {"video/webm", []string{".webm"}, Video, Unknown},
        {"video/vnd.mpegurl", []string{".mxu"}, Video, Unknown},
        {"video/x-flv", []string{".flv"}, Video, Unknown},
        {"video/x-la-asf", []string{".lsf", ".lsx"}, Video, Unknown},
        {"video/x-mng", []string{".mng"}, Video, Unknown},
        {"video/x-ms-asf", []string{".asf", ".asx"}, Video, Unknown},
        {"video/x-ms-wm", []string{".wm"}, Video, Unknown},
        {"video/x-ms-wmv", []string{".wmv"}, Video, Wmv},
        {"video/x-ms-wmx", []string{".wmx"}, Video, Unknown},
        {"video/x-ms-wvx", []string{".wvx"}, Video, Unknown},
        {"video/x-msvideo", []string{".avi"}, Video, Avi},
        {"video/x-sgi-movie", []string{".movie"}, Video, Unknown},
        {"video/x-matroska", []string{".mpv", ".mkv"}, Video, Unknown},
        {"application/x-shockwave-flash", []string{".swf"}, Video, Unknown},

        // Font
        {"font/ttf", []string{".otf", ".ttf", ".ttc"}, Font, TrueType},
        {"font/otf", nil, Font, TrueType},
        {"application/font-sfnt", nil, Font, TrueType},
        {"application/x-font-ttf", nil, Font, TrueType},

        {"application/x-font", []string{".pfa", ".pfb", ".gsf", ".pcf", ".pcf.Z"}, Font, Unknown},
        {"application/x-font-pcf", nil, Font, Unknown},
        {"application/vnd.ms-fontobject", []string{".eot"}, Font, Unknown},

        {"font/woff", []string{".woff", ".woff2"}, Font, WebOpenFont},
        {"font/woff2", nil, Font, WebOpenFont},
        {"application/font-woff", nil, Font, WebOpenFont},

        // Exe
        {"application/x-executable", nil, Exe, Unknown},
        {"application/x-msdos-program", []string{".com", ".exe", ".bat", ".dll"}, Exe, Unknown},

        // Binary
        {"application/octet-stream", []string{".bin"}, Bin, Unknown},
        {"application/x-object", []string{".o"}, Bin, Unknown},
        {"text/x-libtool", nil, Bin, Unknown},
}

// below are entries from official /etc/mime.types that we don't recognize
// or consider to be old / obsolete / not relevant -- please file an issue
// or a pull-request to add to main list or add yourself in your own app

// application/activemessage
// application/andrew-insetez
// application/annodexanx
// application/applefile
// application/atom+xmlatom
// application/atomcat+xmlatomcat
// application/atomicmail
// application/atomserv+xmlatomsrv
// application/batch-SMTP
// application/bbolinlin
// application/beep+xml
// application/cals-1840
// application/commonground
// application/cu-seemecu
// application/cybercash
// application/davmount+xmldavmount
// application/dca-rft
// application/dec-dx
// application/dicomdcm
// application/docbook+xml
// application/dsptypetsp
// application/dvcs
// application/edi-consent
// application/edi-x12
// application/edifact
// application/eshop
// application/font-tdpfrpfr
// application/futuresplashspl
// application/ghostview
// application/htahta
// application/http
// application/hyperstudio
// application/iges
// application/index
// application/index.cmd
// application/index.obj
// application/index.response
// application/index.vnd
// application/iotp
// application/ipp
// application/isup
// application/java-serialized-objectser
// application/java-vmclass
// application/m3gm3g
// application/mac-binhex40hqx
// application/mac-compactprocpt
// application/macwriteii
// application/marc
// application/mxfmxf
// application/news-message-id
// application/news-transmission
// application/ocsp-request
// application/ocsp-response
// application/octet-streambin deploy msu msp
// application/odaoda
// application/oebps-package+xmlopf
// application/oggogx
// application/parityfec
// application/pics-rulesprf
// application/pkcs10
// application/pkcs7-mime
// application/pkcs7-signature
// application/pkix-cert
// application/pkix-crl
// application/pkixcmp
// application/prs.alvestrand.titrax-sheet
// application/prs.cww
// application/prs.nprend
// application/qsig
// application/remote-printing
// application/riscos
// application/sdp
// application/set-payment
// application/set-payment-initiation
// application/set-registration
// application/set-registration-initiation
// application/sgml
// application/sgml-open-catalog
// application/sieve
// application/slastl
// application/slate
// application/smil+xmlsmi smil
// application/timestamp-query
// application/timestamp-reply
// application/vemmi
// application/whoispp-query
// application/whoispp-response
// application/wita
// application/x400-bp
// application/xml-dtd
// application/xml-external-parsed-entity
// application/xslt+xmlxsl xslt
// application/xspf+xmlxspf
// application/vnd.3M.Post-it-Notes
// application/vnd.accpac.simply.aso
// application/vnd.accpac.simply.imp
// application/vnd.acucobol
// application/vnd.aether.imp
// application/vnd.anser-web-certificate-issue-initiation
// application/vnd.anser-web-funds-transfer-initiation
// application/vnd.audiograph
// application/vnd.bmi
// application/vnd.businessobjects
// application/vnd.canon-cpdl
// application/vnd.canon-lips
// application/vnd.cinderellacdy
// application/vnd.claymore
// application/vnd.commerce-battelle
// application/vnd.commonspace
// application/vnd.comsocaller
// application/vnd.contact.cmsg
// application/vnd.cosmocaller
// application/vnd.ctc-posml
// application/vnd.cups-postscript
// application/vnd.cups-raster
// application/vnd.cups-raw
// application/vnd.cybank
// application/vnd.dna
// application/vnd.dpgraph
// application/vnd.dxr
// application/vnd.ecdis-update
// application/vnd.ecowin.chart
// application/vnd.ecowin.filerequest
// application/vnd.ecowin.fileupdate
// application/vnd.ecowin.series
// application/vnd.ecowin.seriesrequest
// application/vnd.ecowin.seriesupdate
// application/vnd.enliven
// application/vnd.epson.esf
// application/vnd.epson.msf
// application/vnd.epson.quickanime
// application/vnd.epson.salt
// application/vnd.epson.ssf
// application/vnd.ericsson.quickcall
// application/vnd.eudora.data
// application/vnd.fdf
// application/vnd.ffsns
// application/vnd.flographit
// application/vnd.font-fontforge-sfdsfd
// application/vnd.framemaker
// application/vnd.fsc.weblaunch
// application/vnd.fujitsu.oasys
// application/vnd.fujitsu.oasys2
// application/vnd.fujitsu.oasys3
// application/vnd.fujitsu.oasysgp
// application/vnd.fujitsu.oasysprs
// application/vnd.fujixerox.ddd
// application/vnd.fujixerox.docuworks
// application/vnd.fujixerox.docuworks.binder
// application/vnd.fut-misnet
// application/vnd.grafeq
// application/vnd.groove-account
// application/vnd.groove-identity-message
// application/vnd.groove-injector
// application/vnd.groove-tool-message
// application/vnd.groove-tool-template
// application/vnd.groove-vcard
// application/vnd.hhe.lesson-player
// application/vnd.hp-HPGL
// application/vnd.hp-PCL
// application/vnd.hp-PCLXL
// application/vnd.hp-hpid
// application/vnd.hp-hps
// application/vnd.httphone
// application/vnd.hzn-3d-crossword
// application/vnd.ibm.MiniPay
// application/vnd.ibm.afplinedata
// application/vnd.ibm.modcap
// application/vnd.informix-visionary
// application/vnd.intercon.formnet
// application/vnd.intertrust.digibox
// application/vnd.intertrust.nncp
// application/vnd.intu.qbo
// application/vnd.intu.qfx
// application/vnd.irepository.package+xml
// application/vnd.is-xpr
// application/vnd.japannet-directory-service
// application/vnd.japannet-jpnstore-wakeup
// application/vnd.japannet-payment-wakeup
// application/vnd.japannet-registration
// application/vnd.japannet-registration-wakeup
// application/vnd.japannet-setstore-wakeup
// application/vnd.japannet-verification
// application/vnd.japannet-verification-wakeup
// application/vnd.koan
// application/vnd.lotus-1-2-3
// application/vnd.lotus-approach
// application/vnd.lotus-freelance
// application/vnd.lotus-notes
// application/vnd.lotus-organizer
// application/vnd.lotus-screencam
// application/vnd.lotus-wordpro
// application/vnd.mcd
// application/vnd.mediastation.cdkey
// application/vnd.meridian-slingshot
// application/vnd.mif
// application/vnd.minisoft-hp3000-save
// application/vnd.mitsubishi.misty-guard.trustweb
// application/vnd.mobius.daf
// application/vnd.mobius.dis
// application/vnd.mobius.msl
// application/vnd.mobius.plc
// application/vnd.mobius.txf
// application/vnd.motorola.flexsuite
// application/vnd.motorola.flexsuite.adsi
// application/vnd.motorola.flexsuite.fis
// application/vnd.motorola.flexsuite.gotap
// application/vnd.motorola.flexsuite.kmr
// application/vnd.motorola.flexsuite.ttc
// application/vnd.motorola.flexsuite.wem
// application/vnd.mozilla.xul+xmlxul
// application/vnd.ms-artgalry
// application/vnd.ms-asf
// application/vnd.ms-excel.addin.macroEnabled.12xlam
// application/vnd.ms-excel.sheet.binary.macroEnabled.12xlsb
// application/vnd.ms-excel.sheet.macroEnabled.12xlsm
// application/vnd.ms-excel.template.macroEnabled.12xltm
// application/vnd.ms-fontobjecteot
// application/vnd.ms-lrm
// application/vnd.ms-officethemethmx
// application/vnd.ms-pki.seccatcat
// #application/vnd.ms-pki.stlstl
// application/vnd.ms-powerpoint.addin.macroEnabled.12ppam
// application/vnd.ms-powerpoint.presentation.macroEnabled.12pptm
// application/vnd.ms-powerpoint.slide.macroEnabled.12sldm
// application/vnd.ms-powerpoint.slideshow.macroEnabled.12ppsm
// application/vnd.ms-powerpoint.template.macroEnabled.12potm
// application/vnd.ms-project
// application/vnd.ms-word.document.macroEnabled.12docm
// application/vnd.ms-word.template.macroEnabled.12dotm
// application/vnd.ms-works
// application/vnd.mseq
// application/vnd.msign
// application/vnd.music-niff
// application/vnd.musician
// application/vnd.netfpx
// application/vnd.noblenet-directory
// application/vnd.noblenet-sealer
// application/vnd.noblenet-web
// application/vnd.novadigm.EDM
// application/vnd.novadigm.EDX
// application/vnd.novadigm.EXT
// application/vnd.osa.netdeploy
// application/vnd.palm
// application/vnd.pg.format
// application/vnd.pg.osasli
// application/vnd.powerbuilder6
// application/vnd.powerbuilder6-s
// application/vnd.powerbuilder7
// application/vnd.powerbuilder7-s
// application/vnd.powerbuilder75
// application/vnd.powerbuilder75-s
// application/vnd.previewsystems.box
// application/vnd.publishare-delta-tree
// application/vnd.pvi.ptid1
// application/vnd.pwg-xhtml-print+xml
// application/vnd.rapid
// application/vnd.rim.codcod
// application/vnd.s3sms
// application/vnd.seemail
// application/vnd.shana.informed.formdata
// application/vnd.shana.informed.formtemplate
// application/vnd.shana.informed.interchange
// application/vnd.shana.informed.package
// application/vnd.smafmmf
// application/vnd.sss-cod
// application/vnd.sss-dtf
// application/vnd.sss-ntf
// application/vnd.stardivision.calcsdc
// application/vnd.stardivision.chartsds
// application/vnd.stardivision.drawsda
// application/vnd.stardivision.impresssdd
// application/vnd.stardivision.mathsdf
// application/vnd.stardivision.writersdw
// application/vnd.stardivision.writer-globalsgl
// application/vnd.street-stream
// application/vnd.svd
// application/vnd.swiftview-ics
// application/vnd.symbian.installsis
// application/vnd.tcpdump.pcapcap pcap
// application/vnd.triscape.mxs
// application/vnd.trueapp
// application/vnd.truedoc
// application/vnd.tve-trigger
// application/vnd.ufdl
// application/vnd.uplanet.alert
// application/vnd.uplanet.alert-wbxml
// application/vnd.uplanet.bearer-choice
// application/vnd.uplanet.bearer-choice-wbxml
// application/vnd.uplanet.cacheop
// application/vnd.uplanet.cacheop-wbxml
// application/vnd.uplanet.channel
// application/vnd.uplanet.channel-wbxml
// application/vnd.uplanet.list
// application/vnd.uplanet.list-wbxml
// application/vnd.uplanet.listcmd
// application/vnd.uplanet.listcmd-wbxml
// application/vnd.uplanet.signal
// application/vnd.vcx
// application/vnd.vectorworks
// application/vnd.vidsoft.vidconference
// application/vnd.visiovsd vst vsw vss
// application/vnd.vividence.scriptfile
// application/vnd.wap.sic
// application/vnd.wap.slc
// application/vnd.wap.wbxmlwbxml
// application/vnd.wap.wmlcwmlc
// application/vnd.wap.wmlscriptcwmlsc
// application/vnd.webturbo
// application/vnd.wordperfectwpd
// application/vnd.wordperfect5.1wp5
// application/vnd.wrq-hp3000-labelled
// application/vnd.wt.stf
// application/vnd.xara
// application/vnd.xfdl
// application/vnd.yellowriver-custom-menu
// application/zlib
// application/x-123wk
// application/x-abiwordabw
// application/x-bcpiobcpio
// application/x-cabcab
// application/x-cbrcbr
// application/x-cbzcbz
// application/x-cdfcdf cda
// application/x-cdlinkvcd
// application/x-chess-pgnpgn
// application/x-comsolmph
// application/x-core
// application/x-cpiocpio
// application/x-directordcr dir dxr
// application/x-dmsdms
// application/x-doomwad
// application/x-dvidvi
// application/x-freemindmm
// application/x-futuresplashspl
// application/x-ganttprojectgan
// application/x-gnumericgnumeric
// application/x-go-sgfsgf
// application/x-graphing-calculatorgcf
// application/x-hdfhdf
// #application/x-httpd-erubyrhtml
// #application/x-httpd-phpphtml pht php
// #application/x-httpd-php-sourcephps
// #application/x-httpd-php3php3
// #application/x-httpd-php3-preprocessedphp3p
// #application/x-httpd-php4php4
// #application/x-httpd-php5php5
// application/x-hwphwp
// application/x-icaica
// application/x-infoinfo
// application/x-internet-signupins isp
// application/x-iphoneiii
// application/x-iso9660-imageiso
// application/x-jamjam
// application/x-java-applet
// application/x-java-bean
// application/x-java-jnlp-filejnlp
// application/x-jmoljmz
// application/x-kchartchrt
// application/x-kdelnk
// application/x-killustratorkil
// application/x-koanskp skd skt skm
// application/x-kpresenterkpr kpt
// application/x-kspreadksp
// application/x-kwordkwd kwt
// application/x-lhalha
// application/x-lyxlyx
// application/x-lzhlzh
// application/x-lzxlzx
// application/x-makerfrm maker frame fm fb book fbdoc
// application/x-mifmif
// application/x-mpegURLm3u8
// application/x-ms-applicationapplication
// application/x-ms-manifestmanifest
// application/x-ms-wmdwmd
// application/x-ms-wmzwmz
// application/x-msimsi
// application/x-netcdfnc
// application/x-ns-proxy-autoconfigpac
// application/x-nwcnwc
// application/x-oz-applicationoza
// application/x-pkcs7-certreqrespp7r
// application/x-pkcs7-crlcrl
// application/x-qgisqgs shp shx
// application/x-quicktimeplayerqtl
// application/x-rdprdp
// application/x-rx
// application/x-scilabsci sce
// application/x-scilab-xcosxcos
// application/x-shellscript
// application/x-shockwave-flashswf swfl
// application/x-silverlightscr
// application/x-sv4cpiosv4cpio
// application/x-sv4crcsv4crc

// application/x-tex-gfgf
// application/x-tex-pkpk
// application/x-ustarustar
// application/x-videolan
// application/x-wais-sourcesrc
// application/x-wingzwz
// application/x-x509-ca-certcrt
// application/x-xpinstallxpi

// audio/32kadpcm
// audio/3gpp
// audio/g.722.1
// audio/l16
// audio/mp4a-latm
// audio/mpa-robust
// audio/parityfec
// audio/telephone-event
// audio/tone
// audio/vnd.cisco.nse
// audio/vnd.cns.anp1
// audio/vnd.cns.inf1
// audio/vnd.digital-winds
// audio/vnd.everad.plj
// audio/vnd.lucent.voice
// audio/vnd.nortel.vbk
// audio/vnd.nuera.ecelp4800
// audio/vnd.nuera.ecelp7470
// audio/vnd.nuera.ecelp9600
// audio/vnd.octel.sbc
// audio/vnd.qcelp
// audio/vnd.rhetorex.32kadpcm
// audio/vnd.vmx.cvsd

// chemical/x-alchemyalc
// chemical/x-cachecac cache
// chemical/x-cache-csfcsf
// chemical/x-cactvs-binarycbin cascii ctab
// chemical/x-cdxcdx
// chemical/x-ceriuscer
// chemical/x-chem3dc3d
// chemical/x-chemdrawchm
// chemical/x-cifcif
// chemical/x-cmdfcmdf
// chemical/x-cmlcml
// chemical/x-compasscpa
// chemical/x-crossfirebsd
// chemical/x-csmlcsml csm
// chemical/x-ctxctx
// chemical/x-cxfcxf cef
// #chemical/x-daylight-smilessmi
// chemical/x-embl-dl-nucleotideemb embl
// chemical/x-galactic-spcspc
// chemical/x-gamess-inputinp gam gamin
// chemical/x-gaussian-checkpointfch fchk
// chemical/x-gaussian-cubecub
// chemical/x-gaussian-inputgau gjc gjf
// chemical/x-gaussian-loggal
// chemical/x-gcg8-sequencegcg
// chemical/x-genbankgen
// chemical/x-hinhin
// chemical/x-isostaristr ist
// chemical/x-jcamp-dxjdx dx
// chemical/x-kinemagekin
// chemical/x-macmoleculemcm
// chemical/x-macromodel-inputmmd mmod
// chemical/x-mdl-molfilemol
// chemical/x-mdl-rdfilerd
// chemical/x-mdl-rxnfilerxn
// chemical/x-mdl-sdfilesd sdf
// chemical/x-mdl-tgftgf
// #chemical/x-mifmif
// chemical/x-mmcifmcif
// chemical/x-mol2mol2
// chemical/x-molconn-Zb
// chemical/x-mopac-graphgpt
// chemical/x-mopac-inputmop mopcrt mpc zmt
// chemical/x-mopac-outmoo
// chemical/x-mopac-vibmvb
// chemical/x-ncbi-asn1asn
// chemical/x-ncbi-asn1-asciiprt ent
// chemical/x-ncbi-asn1-binaryval aso
// chemical/x-ncbi-asn1-specasn
// chemical/x-pdbpdb ent
// chemical/x-rosdalros
// chemical/x-swissprotsw
// chemical/x-vamas-iso14976vms
// chemical/x-vmdvmd
// chemical/x-xtelxtel
// chemical/x-xyzxyz

// image/cgm
// image/g3fax
// image/naplps
// image/prs.btif
// image/prs.pti
// image/vnd.cns.inf2
// image/vnd.dwg
// image/vnd.dxf
// image/vnd.fastbidsheet
// image/vnd.fpx
// image/vnd.fst
// image/vnd.fujixerox.edmics-mmr
// image/vnd.fujixerox.edmics-rlc
// image/vnd.mix
// image/vnd.net-fpx
// image/vnd.svf
// image/vnd.xiff
// image/x-icon

// inode/chardevice
// inode/blockdevice
// inode/directory-locked
// inode/directory
// inode/fifo
// inode/socket

// message/delivery-status
// message/disposition-notification
// message/external-body
// message/http
// message/s-http
// message/news
// message/partial
// message/rfc822eml

// model/vnd.dwf
// model/vnd.flatland.3dml
// model/vnd.gdl
// model/vnd.gs-gdl
// model/vnd.gtw
// model/vnd.mts
// model/vnd.vtu

// multipart/alternative
// multipart/appledouble
// multipart/byteranges
// multipart/digest
// multipart/encrypted
// multipart/form-data
// multipart/header-set
// multipart/mixed
// multipart/parallel
// multipart/related
// multipart/report
// multipart/signed
// multipart/voice-message

// text/english
// text/enriched
// {"text/x-gap",
// {"text/x-gtkrc",
// text/h323323
// text/iulsuls
//{"text/x-idl",
//{"text/x-netrexx",
//{"text/x-ocl",
//{"text/x-dtd",
// {"text/x-gettext-translation",
// {"text/x-gettext-translation-template",
// text/parityfec
// text/prs.lines.tag
// text/rfc822-headers
// text/scriptletsct wsc
// text/t140
// text/texmacstm
// text/turtlettl
// text/vnd.abc
// text/vnd.curl
// text/vnd.debian.copyright
// text/vnd.DMClientScript
// text/vnd.flatland.3dml
// text/vnd.fly
// text/vnd.fmi.flexstor
// text/vnd.in3d.3dml
// text/vnd.in3d.spot
// text/vnd.IPTC.NewsML
// text/vnd.IPTC.NITF
// text/vnd.latex-z
// text/vnd.motorola.reflex
// text/vnd.ms-mediapackage
// text/vnd.sun.j2me.app-descriptorjad
// text/vnd.wap.si
// text/vnd.wap.sl
// text/vnd.wap.wmlwml
// text/vnd.wap.wmlscriptwmls
// text/x-booboo
// text/x-componenthtc
// text/x-crontab
// text/x-lilypondly
// text/x-pcs-gcdgcd
// text/x-setextetx
// text/x-sfvsfv

// video/mp4v-es
// video/parityfec
// video/pointer
// video/vnd.fvt
// video/vnd.motorola.video
// video/vnd.motorola.videop
// video/vnd.mts
// video/vnd.nokia.interleaved-multimedia
// video/vnd.vivo

// x-conference/x-cooltalkice
//
// x-epoc/x-sisx-appsisx

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fsx

import (
        "io/fs"
        "os"
        "path/filepath"
        "strings"

        "cogentcore.org/core/base/errors"
)

// Sub returns [fs.Sub] with any error automatically logged
// for cases where the directory is hardcoded and there is
// no chance of error.
func Sub(fsys fs.FS, dir string) fs.FS {
        return errors.Log1(fs.Sub(fsys, dir))
}

// DirFS returns the directory part of given file path as an os.DirFS
// and the filename as a string.  These can then be used to access the file
// using the FS-based interface, consistent with embed and other use-cases.
func DirFS(fpath string) (fs.FS, string, error) {
        fabs, err := filepath.Abs(fpath)
        if err != nil {
                return nil, "", err
        }
        dir, fname := filepath.Split(fabs)
        dfs := os.DirFS(dir)
        return dfs, fname, nil
}

// FileExistsFS checks whether given file exists, returning true if so,
// false if not, and error if there is an error in accessing the file.
func FileExistsFS(fsys fs.FS, filePath string) (bool, error) {
        if fsys, ok := fsys.(fs.StatFS); ok {
                fileInfo, err := fsys.Stat(filePath)
                if err == nil {
                        return !fileInfo.IsDir(), nil
                }
                if errors.Is(err, fs.ErrNotExist) {
                        return false, nil
                }
                return false, err
        }
        fp, err := fsys.Open(filePath)
        if err == nil {
                fp.Close()
                return true, nil
        }
        if errors.Is(err, fs.ErrNotExist) {
                return false, nil
        }
        return false, err
}

// SplitRootPathFS returns a split of the given FS path (only / path separators)
// into the root element and everything after that point.
// Examples:
//   - "/a/b/c" returns "/", "a/b/c"
//   - "a/b/c" returns "a", "b/c" (note removal of intervening "/")
//   - "a" returns "a", ""
//   - "a/" returns "a", "" (note removal of trailing "/")
func SplitRootPathFS(path string) (root, rest string) {
        pi := strings.IndexByte(path, '/')
        if pi < 0 {
                return path, ""
        }
        if pi == 0 {
                return "/", path[1:]
        }
        if pi < len(path)-1 {
                return path[:pi], path[pi+1:]
        }
        return path[:pi], ""
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package fsx provides various utility functions for dealing with filesystems.
package fsx

import (
        "errors"
        "fmt"
        "go/build"
        "io"
        "io/fs"
        "os"
        "path/filepath"
        "sort"
        "strings"
        "time"
)

// Filename is used to open a file picker dialog when used as an argument
// type in a function, or as a field value.
type Filename string

// GoSrcDir tries to locate dir in GOPATH/src/ or GOROOT/src/pkg/ and returns its
// full path. GOPATH may contain a list of paths. From Robin Elkind github.com/mewkiz/pkg.
func GoSrcDir(dir string) (absDir string, err error) {
        for _, srcDir := range build.Default.SrcDirs() {
                absDir = filepath.Join(srcDir, dir)
                finfo, err := os.Stat(absDir)
                if err == nil && finfo.IsDir() {
                        return absDir, nil
                }
        }
        return "", fmt.Errorf("fsx.GoSrcDir: unable to locate directory (%q) in GOPATH/src/ (%q) or GOROOT/src/pkg/ (%q)", dir, os.Getenv("GOPATH"), os.Getenv("GOROOT"))
}

// Files returns all the DirEntry's for files with given extension(s) in directory
// in sorted order (if extensions are empty then all files are returned).
// In case of error, returns nil.
func Files(path string, extensions ...string) []fs.DirEntry {
        files, err := os.ReadDir(path)
        if err != nil {
                return nil
        }
        if len(extensions) == 0 {
                return files
        }
        sz := len(files)
        if sz == 0 {
                return nil
        }
        for i := sz - 1; i >= 0; i-- {
                fn := files[i]
                ext := filepath.Ext(fn.Name())
                keep := false
                for _, ex := range extensions {
                        if strings.EqualFold(ext, ex) {
                                keep = true
                                break
                        }
                }
                if !keep {
                        files = append(files[:i], files[i+1:]...)
                }
        }
        return files
}

// Filenames returns all the file names with given extension(s) in directory
// in sorted order (if extensions is empty then all files are returned)
func Filenames(path string, extensions ...string) []string {
        f, err := os.Open(path)
        if err != nil {
                return nil
        }
        files, err := f.Readdirnames(-1)
        f.Close()
        if err != nil {
                return nil
        }
        if len(extensions) == 0 {
                sort.StringSlice(files).Sort()
                return files
        }
        sz := len(files)
        if sz == 0 {
                return nil
        }
        for i := sz - 1; i >= 0; i-- {
                fn := files[i]
                ext := filepath.Ext(fn)
                keep := false
                for _, ex := range extensions {
                        if strings.EqualFold(ext, ex) {
                                keep = true
                                break
                        }
                }
                if !keep {
                        files = append(files[:i], files[i+1:]...)
                }
        }
        sort.StringSlice(files).Sort()
        return files
}

// Dirs returns a slice of all the directories within a given directory
func Dirs(path string) []string {
        files, err := os.ReadDir(path)
        if err != nil {
                return nil
        }

        var fnms []string
        for _, fi := range files {
                if fi.IsDir() {
                        fnms = append(fnms, fi.Name())
                }
        }
        return fnms
}

// LatestMod returns the latest (most recent) modification time for any of the
// files in the directory (optionally filtered by extension(s) if exts != nil)
// if no files or error, returns zero time value
func LatestMod(path string, exts ...string) time.Time {
        tm := time.Time{}
        files := Files(path, exts...)
        if len(files) == 0 {
                return tm
        }
        for _, de := range files {
                fi, err := de.Info()
                if err == nil {
                        if fi.ModTime().After(tm) {
                                tm = fi.ModTime()
                        }
                }
        }
        return tm
}

// HasFile returns true if given directory has given file (exact match)
func HasFile(path, file string) bool {
        files, err := os.ReadDir(path)
        if err != nil {
                return false
        }
        for _, fn := range files {
                if fn.Name() == file {
                        return true
                }
        }
        return false
}

// FindFilesOnPaths attempts to locate given file(s) on given list of paths,
// returning the full Abs path to each file found (nil if none)
func FindFilesOnPaths(paths []string, files ...string) []string {
        var res []string
        for _, path := range paths {
                for _, fn := range files {
                        fp := filepath.Join(path, fn)
                        ok, _ := FileExists(fp)
                        if ok {
                                res = append(res, fp)
                        }
                }
        }
        return res
}

// FileExists checks whether given file exists, returning true if so,
// false if not, and error if there is an error in accessing the file.
func FileExists(filePath string) (bool, error) {
        fileInfo, err := os.Stat(filePath)
        if err == nil {
                return !fileInfo.IsDir(), nil
        }
        if errors.Is(err, os.ErrNotExist) {
                return false, nil
        }
        return false, err
}

// DirAndFile returns the final dir and file name.
func DirAndFile(file string) string {
        dir, fnm := filepath.Split(file)
        return filepath.Join(filepath.Base(dir), fnm)
}

// RelativeFilePath returns the file name relative to given root file path, if it is
// under that root; otherwise it returns the final dir and file name.
func RelativeFilePath(file, root string) string {
        rp, err := filepath.Rel(root, file)
        if err == nil && !strings.HasPrefix(rp, "..") {
                return rp
        }
        return DirAndFile(file)
}

// ExtSplit returns the split between the extension and name before
// the extension, for the given file name.  Any path elements in the
// file name are preserved; pass [filepath.Base](file) to extract only the
// last element of the file path if that is what is desired.
func ExtSplit(file string) (base, ext string) {
        ext = filepath.Ext(file)
        base = strings.TrimSuffix(file, ext)
        return
}

// here's all the discussion about why CopyFile is not in std lib:
// https://old.reddit.com/r/golang/comments/3lfqoh/why_golang_does_not_provide_a_copy_file_func/
// https://github.com/golang/go/issues/8868

// CopyFile copies the contents from src to dst atomically.
// If dst does not exist, CopyFile creates it with permissions perm.
// If the copy fails, CopyFile aborts and dst is preserved.
func CopyFile(dst, src string, perm os.FileMode) error {
        in, err := os.Open(src)
        if err != nil {
                return err
        }
        defer in.Close()
        tmp, err := os.CreateTemp(filepath.Dir(dst), "")
        if err != nil {
                return err
        }
        _, err = io.Copy(tmp, in)
        if err != nil {
                tmp.Close()
                os.Remove(tmp.Name())
                return err
        }
        if err = tmp.Close(); err != nil {
                os.Remove(tmp.Name())
                return err
        }
        if err = os.Chmod(tmp.Name(), perm); err != nil {
                os.Remove(tmp.Name())
                return err
        }
        return os.Rename(tmp.Name(), dst)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package generate provides utilities for building code generators in Go.
// The standard path for a code generator is: [Load] -> [PrintHeader] -> [Inspect] -> [Write].
package generate

import (
        "fmt"
        "go/ast"
        "io"
        "os"
        "path/filepath"
        "strings"

        "golang.org/x/tools/go/packages"
        "golang.org/x/tools/imports"
)

// Load loads and returns the Go packages named by the given patterns.
// Load calls [packages.Load] and ensures that there is at least one
// package; this means that, if there is a nil error, the length
// of the resulting packages is guaranteed to be greater than zero.
func Load(cfg *packages.Config, patterns ...string) ([]*packages.Package, error) {
        pkgs, err := packages.Load(cfg, patterns...)
        if err != nil {
                return nil, err
        }
        if len(pkgs) == 0 {
                return nil, fmt.Errorf("expected at least one package but got %d", len(pkgs))
        }
        return pkgs, nil
}

// PrintHeader prints a header to the given writer for a generated
// file in the given package with the given imports. Imports do not
// need to be set if you are running [Format] on the code later,
// but they should be set for any external packages that many not
// be found correctly by goimports.
func PrintHeader(w io.Writer, pkg string, imports ...string) {
        cmdstr := strings.TrimSuffix(filepath.Base(os.Args[0]), ".exe")
        if len(os.Args) > 1 {
                cmdstr += " " + strings.Join(os.Args[1:], " ")
        }
        fmt.Fprintf(w, "// Code generated by \"%s\"; DO NOT EDIT.\n\n", cmdstr)
        fmt.Fprintf(w, "package %s\n", pkg)
        if len(imports) > 0 {
                fmt.Fprint(w, "import (\n")
                for _, imp := range imports {
                        fmt.Fprintf(w, "\t%q\n", imp)
                }
                fmt.Fprint(w, ")\n")
        }
}

// ExcludeFile returns true if the given file is on the exclude list.
func ExcludeFile(pkg *packages.Package, file *ast.File, exclude ...string) bool {
        fpos := pkg.Fset.Position(file.FileStart)
        _, fname := filepath.Split(fpos.Filename)
        for _, ex := range exclude {
                if fname == ex {
                        return true
                }
        }
        return false
}

// Inspect goes through all of the files in the given package,
// except those listed in the exclude list, and calls the given
// function on each node. The bool return value from the given function
// indicates whether to continue traversing down the AST tree
// of that node and look at its children. If a non-nil error value
// is returned by the given function, the traversal of the tree is
// stopped and the error value is returned.
func Inspect(pkg *packages.Package, f func(n ast.Node) (bool, error), exclude ...string) error {
        for _, file := range pkg.Syntax {
                if ExcludeFile(pkg, file, exclude...) {
                        continue
                }
                var terr error
                var terrNode ast.Node
                ast.Inspect(file, func(n ast.Node) bool {
                        if terr != nil {
                                return false
                        }
                        cont, err := f(n)
                        if err != nil {
                                terr = err
                                terrNode = n
                        }
                        return cont
                })
                if terr != nil {
                        return fmt.Errorf("generate.Inspect: error while calling inspect function for node %v: %w", terrNode, terr)
                }
        }
        return nil
}

// Filepath returns the filepath of a file in the given
// package with the given filename relative to the package.
func Filepath(pkg *packages.Package, filename string) string {
        dir := "."
        if len(pkg.Syntax) > 0 {
                dir = filepath.Dir(pkg.Fset.Position(pkg.Syntax[0].FileStart).Filename)
        }
        return filepath.Join(dir, filename)
}

// Write writes the given bytes to the given filename after
// applying goimports using the given options.
func Write(filename string, src []byte, opt *imports.Options) error {
        b, ferr := Format(filename, src, opt)
        // we still write file even if formatting failed, as it is still useful
        // then we handle error later
        werr := os.WriteFile(filename, b, 0666)
        if werr != nil {
                return fmt.Errorf("generate.Write: error writing file: %w", werr)
        }
        if ferr != nil {
                return fmt.Errorf("generate.Write: error formatting code: %w", ferr)
        }
        return nil
}

// Format returns the given bytes with goimports applied.
// It wraps [imports.Process] by wrapping any error with
// additional context.
func Format(filename string, src []byte, opt *imports.Options) ([]byte, error) {
        b, err := imports.Process(filename, src, opt)
        if err != nil {
                // Should never happen, but can arise when developing code.
                // The user can compile the output to see the error.
                return src, fmt.Errorf("internal/programmer error: generate.Format: invalid Go generated: %w; compile the package to analyze the error", err)
        }
        return b, nil
}

// Code generated by "core generate"; DO NOT EDIT.

package indent

import (
        "cogentcore.org/core/enums"
)

var _CharacterValues = []Character{0, 1}

// CharacterN is the highest valid value for type Character, plus one.
const CharacterN Character = 2

var _CharacterValueMap = map[string]Character{`Tab`: 0, `Space`: 1}

var _CharacterDescMap = map[Character]string{0: `Tab indicates to use tabs for indentation.`, 1: `Space indicates to use spaces for indentation.`}

var _CharacterMap = map[Character]string{0: `Tab`, 1: `Space`}

// String returns the string representation of this Character value.
func (i Character) String() string { return enums.String(i, _CharacterMap) }

// SetString sets the Character value from its string representation,
// and returns an error if the string is invalid.
func (i *Character) SetString(s string) error {
        return enums.SetString(i, s, _CharacterValueMap, "Character")
}

// Int64 returns the Character value as an int64.
func (i Character) Int64() int64 { return int64(i) }

// SetInt64 sets the Character value from an int64.
func (i *Character) SetInt64(in int64) { *i = Character(in) }

// Desc returns the description of the Character value.
func (i Character) Desc() string { return enums.Desc(i, _CharacterDescMap) }

// CharacterValues returns all possible values for the type Character.
func CharacterValues() []Character { return _CharacterValues }

// Values returns all possible values for the type Character.
func (i Character) Values() []enums.Enum { return enums.Values(_CharacterValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Character) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Character) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Character")
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package indent provides indentation generation methods.
package indent

//go:generate core generate

import (
        "bytes"
        "strings"
)

// Character is the type of indentation character to use.
type Character int32 //enums:enum

const (
        // Tab indicates to use tabs for indentation.
        Tab Character = iota

        // Space indicates to use spaces for indentation.
        Space
)

// Tabs returns a string of n tabs.
func Tabs(n int) string {
        return strings.Repeat("\t", n)
}

// TabBytes returns []byte of n tabs.
func TabBytes(n int) []byte {
        return bytes.Repeat([]byte("\t"), n)
}

// Spaces returns a string of n*width spaces.
func Spaces(n, width int) string {
        return strings.Repeat(" ", n*width)
}

// SpaceBytes returns a []byte of n*width spaces.
func SpaceBytes(n, width int) []byte {
        return bytes.Repeat([]byte(" "), n*width)
}

// String returns a string of n tabs or n*width spaces depending on the indent character.
func String(ich Character, n, width int) string {
        if ich == Tab {
                return Tabs(n)
        }
        return Spaces(n, width)
}

// Bytes returns []byte of n tabs or n*width spaces depending on the indent character.
func Bytes(ich Character, n, width int) []byte {
        if ich == Tab {
                return TabBytes(n)
        }
        return SpaceBytes(n, width)
}

// Len returns the length of the indent string given indent character and indent level.
func Len(ich Character, n, width int) int {
        if ich == Tab {
                return n
        }
        return n * width
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package iox provides boilerplate wrapper functions for the Go standard
// io functions to Read, Open, Write, and Save, with implementations for
// commonly used encoding formats.
package iox

import (
        "bufio"
        "bytes"
        "io"
        "io/fs"
        "os"
)

// Decoder is an interface for standard decoder types
type Decoder interface {
        // Decode decodes from io.Reader specified at creation
        Decode(v any) error
}

// DecoderFunc is a function that creates a new Decoder for given reader
type DecoderFunc func(r io.Reader) Decoder

// NewDecoderFunc returns a DecoderFunc for a specific Decoder type
func NewDecoderFunc[T Decoder](f func(r io.Reader) T) DecoderFunc {
        return func(r io.Reader) Decoder { return f(r) }
}

// Open reads the given object from the given filename using the given [DecoderFunc]
func Open(v any, filename string, f DecoderFunc) error {
        fp, err := os.Open(filename)
        if err != nil {
                return err
        }
        defer fp.Close()
        return Read(v, bufio.NewReader(fp), f)
}

// OpenFiles reads the given object from the given filenames using the given [DecoderFunc]
func OpenFiles(v any, filenames []string, f DecoderFunc) error {
        for _, file := range filenames {
                err := Open(v, file, f)
                if err != nil {
                        return err
                }
        }
        return nil
}

// OpenFS reads the given object from the given filename using the given [DecoderFunc],
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFS(v any, fsys fs.FS, filename string, f DecoderFunc) error {
        fp, err := fsys.Open(filename)
        if err != nil {
                return err
        }
        defer fp.Close()
        return Read(v, bufio.NewReader(fp), f)
}

// OpenFilesFS reads the given object from the given filenames using the given [DecoderFunc],
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFilesFS(v any, fsys fs.FS, filenames []string, f DecoderFunc) error {
        for _, file := range filenames {
                err := OpenFS(v, fsys, file, f)
                if err != nil {
                        return err
                }
        }
        return nil
}

// Read reads the given object from the given reader,
// using the given [DecoderFunc]
func Read(v any, reader io.Reader, f DecoderFunc) error {
        d := f(reader)
        return d.Decode(v)
}

// ReadBytes reads the given object from the given bytes,
// using the given [DecoderFunc]
func ReadBytes(v any, data []byte, f DecoderFunc) error {
        b := bytes.NewBuffer(data)
        return Read(v, b, f)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package iox

import (
        "bufio"
        "bytes"
        "io"
        "os"
)

// Encoder is an interface for standard encoder types
type Encoder interface {
        // Encode encodes to io.Writer specified at creation
        Encode(v any) error
}

// EncoderFunc is a function that creates a new Encoder for given writer
type EncoderFunc func(w io.Writer) Encoder

// NewEncoderFunc returns a EncoderFunc for a specific Encoder type
func NewEncoderFunc[T Encoder](f func(w io.Writer) T) EncoderFunc {
        return func(w io.Writer) Encoder { return f(w) }
}

// Save writes the given object to the given filename using the given [EncoderFunc]
func Save(v any, filename string, f EncoderFunc) error {
        fp, err := os.Create(filename)
        if err != nil {
                return err
        }
        defer fp.Close()
        bw := bufio.NewWriter(fp)
        err = Write(v, bw, f)
        if err != nil {
                return err
        }
        return bw.Flush()
}

// Write writes the given object using the given [EncoderFunc]
func Write(v any, writer io.Writer, f EncoderFunc) error {
        e := f(writer)
        return e.Encode(v)
}

// WriteBytes writes the given object, returning bytes of the encoding,
// using the given [EncoderFunc]
func WriteBytes(v any, f EncoderFunc) ([]byte, error) {
        var b bytes.Buffer
        e := f(&b)
        err := e.Encode(v)
        if err != nil {
                return nil, err
        }
        return b.Bytes(), nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package imagex

import (
        "bytes"
        "encoding/base64"
        "errors"
        "image"
        "image/jpeg"
        "image/png"
        "log"
        "strings"
)

// ToBase64PNG returns bytes of image encoded as a PNG in Base64 format
// with "image/png" mimetype returned
func ToBase64PNG(img image.Image) ([]byte, string) {
        ibuf := &bytes.Buffer{}
        png.Encode(ibuf, img)
        ib := ibuf.Bytes()
        eb := make([]byte, base64.StdEncoding.EncodedLen(len(ib)))
        base64.StdEncoding.Encode(eb, ib)
        return eb, "image/png"
}

// ToBase64JPG returns bytes image encoded as a JPG in Base64 format
// with "image/jpeg" mimetype returned
func ToBase64JPG(img image.Image) ([]byte, string) {
        ibuf := &bytes.Buffer{}
        jpeg.Encode(ibuf, img, &jpeg.Options{Quality: 90})
        ib := ibuf.Bytes()
        eb := make([]byte, base64.StdEncoding.EncodedLen(len(ib)))
        base64.StdEncoding.Encode(eb, ib)
        return eb, "image/jpeg"
}

// Base64SplitLines splits the encoded Base64 bytes into standard lines of 76
// chars each.  The last line also ends in a newline
func Base64SplitLines(b []byte) []byte {
        ll := 76
        sz := len(b)
        nl := (sz / ll)
        rb := make([]byte, sz+nl+1)
        for i := 0; i < nl; i++ {
                st := ll * i
                rst := ll*i + i
                copy(rb[rst:rst+ll], b[st:st+ll])
                rb[rst+ll] = '\n'
        }
        st := ll * nl
        rst := ll*nl + nl
        ln := sz - st
        copy(rb[rst:rst+ln], b[st:st+ln])
        rb[rst+ln] = '\n'
        return rb
}

// FromBase64PNG returns image from Base64-encoded bytes in PNG format
func FromBase64PNG(eb []byte) (image.Image, error) {
        if eb[76] == ' ' {
                eb = bytes.ReplaceAll(eb, []byte(" "), []byte("\n"))
        }
        db := make([]byte, base64.StdEncoding.DecodedLen(len(eb)))
        _, err := base64.StdEncoding.Decode(db, eb)
        if err != nil {
                log.Println(err)
                return nil, err
        }
        rb := bytes.NewReader(db)
        return png.Decode(rb)
}

// FromBase64JPG returns image from Base64-encoded bytes in PNG format
func FromBase64JPG(eb []byte) (image.Image, error) {
        if eb[76] == ' ' {
                eb = bytes.ReplaceAll(eb, []byte(" "), []byte("\n"))
        }
        db := make([]byte, base64.StdEncoding.DecodedLen(len(eb)))
        _, err := base64.StdEncoding.Decode(db, eb)
        if err != nil {
                log.Println(err)
                return nil, err
        }
        rb := bytes.NewReader(db)
        return jpeg.Decode(rb)
}

// FromBase64 returns image from Base64-encoded bytes in either PNG or JPEG format
// based on fmt which must end in either png, jpg, or jpeg
func FromBase64(fmt string, eb []byte) (image.Image, error) {
        if strings.HasSuffix(fmt, "png") {
                return FromBase64PNG(eb)
        }
        if strings.HasSuffix(fmt, "jpg") || strings.HasSuffix(fmt, "jpeg") {
                return FromBase64JPG(eb)
        }
        return nil, errors.New("image format must be either png or jpeg")
}

// Code generated by "core generate"; DO NOT EDIT.

package imagex

import (
        "cogentcore.org/core/enums"
)

var _FormatsValues = []Formats{0, 1, 2, 3, 4, 5, 6}

// FormatsN is the highest valid value for type Formats, plus one.
const FormatsN Formats = 7

var _FormatsValueMap = map[string]Formats{`None`: 0, `PNG`: 1, `JPEG`: 2, `GIF`: 3, `TIFF`: 4, `BMP`: 5, `WebP`: 6}

var _FormatsDescMap = map[Formats]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``, 5: ``, 6: ``}

var _FormatsMap = map[Formats]string{0: `None`, 1: `PNG`, 2: `JPEG`, 3: `GIF`, 4: `TIFF`, 5: `BMP`, 6: `WebP`}

// String returns the string representation of this Formats value.
func (i Formats) String() string { return enums.String(i, _FormatsMap) }

// SetString sets the Formats value from its string representation,
// and returns an error if the string is invalid.
func (i *Formats) SetString(s string) error {
        return enums.SetString(i, s, _FormatsValueMap, "Formats")
}

// Int64 returns the Formats value as an int64.
func (i Formats) Int64() int64 { return int64(i) }

// SetInt64 sets the Formats value from an int64.
func (i *Formats) SetInt64(in int64) { *i = Formats(in) }

// Desc returns the description of the Formats value.
func (i Formats) Desc() string { return enums.Desc(i, _FormatsDescMap) }

// FormatsValues returns all possible values for the type Formats.
func FormatsValues() []Formats { return _FormatsValues }

// Values returns all possible values for the type Formats.
func (i Formats) Values() []enums.Enum { return enums.Values(_FormatsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Formats) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Formats) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Formats") }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package imagex

//go:generate core generate

import (
        "bufio"
        "errors"
        "fmt"
        "image"
        "image/gif"
        "image/jpeg"
        "image/png"
        "io"
        "io/fs"
        "os"
        "path/filepath"
        "strings"

        "golang.org/x/image/bmp"
        "golang.org/x/image/tiff"
        _ "golang.org/x/image/webp"
)

// Formats are the supported image encoding / decoding formats
type Formats int32 //enums:enum

// The supported image encoding formats
const (
        None Formats = iota
        PNG
        JPEG
        GIF
        TIFF
        BMP
        WebP
)

// ExtToFormat returns a Format based on a filename extension,
// which can start with a . or not
func ExtToFormat(ext string) (Formats, error) {
        if len(ext) == 0 {
                return None, errors.New("ExtToFormat: ext is empty")
        }
        if ext[0] == '.' {
                ext = ext[1:]
        }
        ext = strings.ToLower(ext)
        switch ext {
        case "png":
                return PNG, nil
        case "jpg", "jpeg":
                return JPEG, nil
        case "gif":
                return GIF, nil
        case "tif", "tiff":
                return TIFF, nil
        case "bmp":
                return BMP, nil
        case "webp":
                return WebP, nil
        }
        return None, fmt.Errorf("ExtToFormat: extension %q not recognized", ext)
}

// Open opens an image from the given filename.
// The format is inferred automatically,
// and is returned using the Formats enum.
// png, jpeg, gif, tiff, bmp, and webp are supported.
func Open(filename string) (image.Image, Formats, error) {
        file, err := os.Open(filename)
        if err != nil {
                return nil, None, err
        }
        defer file.Close()
        return Read(file)
}

// OpenFS opens an image from the given filename
// using the given [fs.FS] filesystem (e.g., for embed files).
// The format is inferred automatically,
// and is returned using the Formats enum.
// png, jpeg, gif, tiff, bmp, and webp are supported.
func OpenFS(fsys fs.FS, filename string) (image.Image, Formats, error) {
        file, err := fsys.Open(filename)
        if err != nil {
                return nil, None, err
        }
        defer file.Close()
        return Read(file)
}

// Read reads an image to the given reader,
// The format is inferred automatically,
// and is returned using the Formats enum.
// png, jpeg, gif, tiff, bmp, and webp are supported.
func Read(r io.Reader) (image.Image, Formats, error) {
        im, ext, err := image.Decode(r)
        if err != nil {
                return im, None, err
        }
        f, err := ExtToFormat(ext)
        return im, f, err
}

// Save saves the image to the given filename,
// with the format inferred from the filename.
// png, jpeg, gif, tiff, and bmp are supported.
func Save(im image.Image, filename string) error {
        ext := filepath.Ext(filename)
        f, err := ExtToFormat(ext)
        if err != nil {
                return err
        }
        file, err := os.Create(filename)
        if err != nil {
                return err
        }
        defer file.Close()
        bw := bufio.NewWriter(file)
        defer bw.Flush()
        return Write(im, file, f)
}

// Write writes the image to the given writer using the given foramt.
// png, jpeg, gif, tiff, and bmp are supported.
// It [Unwrap]s any [Wrapped] images.
func Write(im image.Image, w io.Writer, f Formats) error {
        im = Unwrap(im)
        switch f {
        case PNG:
                return png.Encode(w, im)
        case JPEG:
                return jpeg.Encode(w, im, &jpeg.Options{Quality: 90})
        case GIF:
                return gif.Encode(w, im, nil)
        case TIFF:
                return tiff.Encode(w, im, nil)
        case BMP:
                return bmp.Encode(w, im)
        default:
                return fmt.Errorf("iox/imagex.Save: format %q not valid", f)
        }
}

// Copyright 2023 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package imagex

import (
        "errors"
        "image"
        "image/color"
        "io/fs"
        "os"
        "path/filepath"
        "strings"

        "cogentcore.org/core/base/num"
)

// TestingT is an interface wrapper around *testing.T
type TestingT interface {
        Errorf(format string, args ...any)
}

// UpdateTestImages indicates whether to update currently saved test
// images in [AssertImage] instead of comparing against them.
// It is automatically set if the build tag "update" is specified,
// or if the environment variable "CORE_UPDATE_TESTDATA" is set to "true".
// It should typically only be set through those methods. It should only be
// set when behavior has been updated that causes test images to change,
// and it should only be set once and then turned back off.
var UpdateTestImages = updateTestImages

// CompareUint8 returns true if two numbers are more different than tol
func CompareUint8(cc, ic uint8, tol int) bool {
        d := int(cc) - int(ic)
        if d < -tol {
                return false
        }
        if d > tol {
                return false
        }
        return true
}

// CompareColors returns true if two colors are more different than tol
func CompareColors(cc, ic color.RGBA, tol int) bool {
        if !CompareUint8(cc.R, ic.R, tol) {
                return false
        }
        if !CompareUint8(cc.G, ic.G, tol) {
                return false
        }
        if !CompareUint8(cc.B, ic.B, tol) {
                return false
        }
        if !CompareUint8(cc.A, ic.A, tol) {
                return false
        }
        return true
}

// DiffImage returns the difference between two images,
// with pixels having the abs of the difference between pixels.
func DiffImage(a, b image.Image) image.Image {
        ab := a.Bounds()
        di := image.NewRGBA(ab)
        for y := ab.Min.Y; y < ab.Max.Y; y++ {
                for x := ab.Min.X; x < ab.Max.X; x++ {
                        cc := color.RGBAModel.Convert(a.At(x, y)).(color.RGBA)
                        ic := color.RGBAModel.Convert(b.At(x, y)).(color.RGBA)
                        r := uint8(num.Abs(int(cc.R) - int(ic.R)))
                        g := uint8(num.Abs(int(cc.G) - int(ic.G)))
                        b := uint8(num.Abs(int(cc.B) - int(ic.B)))
                        c := color.RGBA{r, g, b, 255}
                        di.Set(x, y, c)
                }
        }
        return di
}

// Assert asserts that the given image is equivalent
// to the image stored at the given filename in the testdata directory,
// with ".png" added to the filename if there is no extension
// (eg: "button" becomes "testdata/button.png"). Forward slashes are
// automatically replaced with backslashes on Windows.
// If it is not, it fails the test with an error, but continues its
// execution. If there is no image at the given filename in the testdata
// directory, it creates the image.
func Assert(t TestingT, img image.Image, filename string) {
        filename = filepath.Join("testdata", filename)
        if filepath.Ext(filename) == "" {
                filename += ".png"
        }

        err := os.MkdirAll(filepath.Dir(filename), 0750)
        if err != nil {
                t.Errorf("error making testdata directory: %v", err)
        }

        ext := filepath.Ext(filename)
        failFilename := strings.TrimSuffix(filename, ext) + ".fail" + ext
        diffFilename := strings.TrimSuffix(filename, ext) + ".diff" + ext

        if UpdateTestImages {
                err := Save(img, filename)
                if err != nil {
                        t.Errorf("AssertImage: error saving updated image: %v", err)
                }
                err = os.RemoveAll(failFilename)
                if err != nil {
                        t.Errorf("AssertImage: error removing old fail image: %v", err)
                }
                os.RemoveAll(diffFilename)
                return
        }

        fimg, _, err := Open(filename)
        if err != nil {
                if !errors.Is(err, fs.ErrNotExist) {
                        t.Errorf("AssertImage: error opening saved image: %v", err)
                        return
                }
                // we don't have the file yet, so we make it
                err := Save(img, filename)
                if err != nil {
                        t.Errorf("AssertImage: error saving new image: %v", err)
                }
                return
        }

        failed := false

        ibounds := img.Bounds()
        fbounds := fimg.Bounds()
        if ibounds != fbounds {
                t.Errorf("AssertImage: expected bounds %v for image for %s, but got bounds %v; see %s", fbounds, filename, ibounds, failFilename)
                failed = true
        } else {
                for y := ibounds.Min.Y; y < ibounds.Max.Y; y++ {
                        for x := ibounds.Min.X; x < ibounds.Max.X; x++ {
                                cc := color.RGBAModel.Convert(img.At(x, y)).(color.RGBA)
                                ic := color.RGBAModel.Convert(fimg.At(x, y)).(color.RGBA)
                                // TODO(#1456): reduce tolerance to 1 after we fix rendering inconsistencies
                                if !CompareColors(cc, ic, 10) {
                                        t.Errorf("AssertImage: image for %s is not the same as expected; see %s; expected color %v at (%d, %d), but got %v", filename, failFilename, ic, x, y, cc)
                                        failed = true
                                        break
                                }
                        }
                        if failed {
                                break
                        }
                }
        }

        if failed {
                err := Save(img, failFilename)
                if err != nil {
                        t.Errorf("AssertImage: error saving fail image: %v", err)
                }
                err = Save(DiffImage(img, fimg), diffFilename)
                if err != nil {
                        t.Errorf("AssertImage: error saving diff image: %v", err)
                }
        } else {
                err := os.RemoveAll(failFilename)
                if err != nil {
                        t.Errorf("AssertImage: error removing old fail image: %v", err)
                }
                os.RemoveAll(diffFilename)
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !js

package imagex

import "image"

// WrapJS returns a JavaScript optimized wrapper around the given
// [image.Image] on web, and just returns the image on other platforms.
func WrapJS(src image.Image) image.Image {
        return src
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package imagex

import (
        "image"

        "github.com/anthonynsimon/bild/clone"
)

// Wrapped extends the [image.Image] interface with two methods that manage
// the wrapping of an underlying Go [image.Image]. This can be used for images that
// are actually GPU textures, and to manage JavaScript pointers on the js platform.
type Wrapped interface {
        image.Image

        // Update is called whenever the image data has been updated,
        // to update any additional data based on the new image.
        // This may copy an image to the GPU or update JavaScript pointers.
        Update()

        // Underlying returns the underlying image.Image, which should
        // be called whenever passing the image to some other Go-based
        // function that is likely to be optimized for different image types,
        // such as [draw.Draw]. Do NOT use this for functions that will
        // directly handle the wrapped image!
        Underlying() image.Image
}

// Update calls [Wrapped.Update] on a [Wrapped] if it is one.
// It does nothing otherwise.
func Update(src image.Image) {
        if wr, ok := src.(Wrapped); ok {
                wr.Update()
        }
}

// Unwrap calls [Wrapped.Underlying] on a [Wrapped] if it is one.
// It returns the original image otherwise.
func Unwrap(src image.Image) image.Image {
        if wr, ok := src.(Wrapped); ok {
                return wr.Underlying()
        }
        return src
}

// CloneAsRGBA returns an [*image.RGBA] copy of the supplied image.
// It calls [Unwrap] first. See also [AsRGBA].
func CloneAsRGBA(src image.Image) *image.RGBA {
        return clone.AsRGBA(Unwrap(src))
}

// AsRGBA returns the image as an [*image.RGBA]. If it already is one,
// it returns that image directly. Otherwise it returns a clone.
// It calls [Unwrap] first. See also [CloneAsRGBA].
func AsRGBA(src image.Image) *image.RGBA {
        return clone.AsShallowRGBA(Unwrap(src))
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package jsonx

import (
        "encoding/json"
        "io"
        "io/fs"

        "cogentcore.org/core/base/iox"
)

// Open reads the given object from the given filename using JSON encoding
func Open(v any, filename string) error {
        return iox.Open(v, filename, iox.NewDecoderFunc(json.NewDecoder))
}

// OpenFiles reads the given object from the given filenames using JSON encoding
func OpenFiles(v any, filenames ...string) error {
        return iox.OpenFiles(v, filenames, iox.NewDecoderFunc(json.NewDecoder))
}

// OpenFS reads the given object from the given filename using JSON encoding,
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFS(v any, fsys fs.FS, filename string) error {
        return iox.OpenFS(v, fsys, filename, iox.NewDecoderFunc(json.NewDecoder))
}

// OpenFilesFS reads the given object from the given filenames using JSON encoding,
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFilesFS(v any, fsys fs.FS, filenames ...string) error {
        return iox.OpenFilesFS(v, fsys, filenames, iox.NewDecoderFunc(json.NewDecoder))
}

// Read reads the given object from the given reader,
// using JSON encoding
func Read(v any, reader io.Reader) error {
        return iox.Read(v, reader, iox.NewDecoderFunc(json.NewDecoder))
}

// ReadBytes reads the given object from the given bytes,
// using JSON encoding
func ReadBytes(v any, data []byte) error {
        return iox.ReadBytes(v, data, iox.NewDecoderFunc(json.NewDecoder))
}

// Save writes the given object to the given filename using JSON encoding
func Save(v any, filename string) error {
        return iox.Save(v, filename, iox.NewEncoderFunc(json.NewEncoder))
}

// Write writes the given object using JSON encoding
func Write(v any, writer io.Writer) error {
        return iox.Write(v, writer, iox.NewEncoderFunc(json.NewEncoder))
}

// WriteBytes writes the given object, returning bytes of the encoding,
// using JSON encoding
func WriteBytes(v any) ([]byte, error) {
        return iox.WriteBytes(v, iox.NewEncoderFunc(json.NewEncoder))
}

// IndentEncoderFunc is a [iox.EncoderFunc] that sets indentation
var IndentEncoderFunc = func(w io.Writer) iox.Encoder {
        e := json.NewEncoder(w)
        e.SetIndent("", "\t")
        return e
}

// SaveIndent writes the given object to the given filename using JSON encoding, with indentation
func SaveIndent(v any, filename string) error {
        return iox.Save(v, filename, IndentEncoderFunc)
}

// WriteIndent writes the given object using JSON encoding, with indentation
func WriteIndent(v any, writer io.Writer) error {
        return iox.Write(v, writer, IndentEncoderFunc)
}

// WriteBytesIndent writes the given object, returning bytes of the encoding,
// using JSON encoding, with indentation
func WriteBytesIndent(v any) ([]byte, error) {
        return iox.WriteBytes(v, IndentEncoderFunc)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tomlx

import (
        "errors"
        "io"
        "io/fs"

        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/iox"
        "github.com/pelletier/go-toml/v2"
)

// NewDecoder returns a new [iox.Decoder]
func NewDecoder(r io.Reader) iox.Decoder { return toml.NewDecoder(r) }

// Open reads the given object from the given filename using TOML encoding
func Open(v any, filename string) error {
        return iox.Open(v, filename, NewDecoder)
}

// OpenFiles reads the given object from the given filenames using TOML encoding
func OpenFiles(v any, filenames ...string) error {
        return iox.OpenFiles(v, filenames, NewDecoder)
}

// OpenFS reads the given object from the given filename using TOML encoding,
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFS(v any, fsys fs.FS, filename string) error {
        return iox.OpenFS(v, fsys, filename, NewDecoder)
}

// OpenFilesFS reads the given object from the given filenames using TOML encoding,
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFilesFS(v any, fsys fs.FS, filenames ...string) error {
        return iox.OpenFilesFS(v, fsys, filenames, NewDecoder)
}

// Read reads the given object from the given reader,
// using TOML encoding
func Read(v any, reader io.Reader) error {
        return iox.Read(v, reader, NewDecoder)
}

// ReadBytes reads the given object from the given bytes,
// using TOML encoding
func ReadBytes(v any, data []byte) error {
        return iox.ReadBytes(v, data, NewDecoder)
}

// NewEncoder returns a new [iox.Encoder]
func NewEncoder(w io.Writer) iox.Encoder {
        return toml.NewEncoder(w).SetIndentTables(true).SetArraysMultiline(true)
}

// Save writes the given object to the given filename using TOML encoding
func Save(v any, filename string) error {
        return iox.Save(v, filename, NewEncoder)
}

// Write writes the given object using TOML encoding
func Write(v any, writer io.Writer) error {
        return iox.Write(v, writer, NewEncoder)
}

// WriteBytes writes the given object, returning bytes of the encoding,
// using TOML encoding
func WriteBytes(v any) ([]byte, error) {
        return iox.WriteBytes(v, NewEncoder)
}

// OpenFromPaths reads the given object from the given TOML file,
// looking on paths for the file.
func OpenFromPaths(v any, file string, paths ...string) error {
        filenames := fsx.FindFilesOnPaths(paths, file)
        if len(filenames) == 0 {
                return errors.New("OpenFromPaths: no files found")
        }
        return Open(v, filenames[0])
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package xmlx

import (
        "encoding/xml"
        "io"
        "io/fs"

        "cogentcore.org/core/base/iox"
)

// Open reads the given object from the given filename using XML encoding
func Open(v any, filename string) error {
        return iox.Open(v, filename, iox.NewDecoderFunc(xml.NewDecoder))
}

// OpenFiles reads the given object from the given filenames using XML encoding
func OpenFiles(v any, filenames ...string) error {
        return iox.OpenFiles(v, filenames, iox.NewDecoderFunc(xml.NewDecoder))
}

// OpenFS reads the given object from the given filename using XML encoding,
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFS(v any, fsys fs.FS, filename string) error {
        return iox.OpenFS(v, fsys, filename, iox.NewDecoderFunc(xml.NewDecoder))
}

// OpenFilesFS reads the given object from the given filenames using XML encoding,
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFilesFS(v any, fsys fs.FS, filenames ...string) error {
        return iox.OpenFilesFS(v, fsys, filenames, iox.NewDecoderFunc(xml.NewDecoder))
}

// Read reads the given object from the given reader,
// using XML encoding
func Read(v any, reader io.Reader) error {
        return iox.Read(v, reader, iox.NewDecoderFunc(xml.NewDecoder))
}

// ReadBytes reads the given object from the given bytes,
// using XML encoding
func ReadBytes(v any, data []byte) error {
        return iox.ReadBytes(v, data, iox.NewDecoderFunc(xml.NewDecoder))
}

// Save writes the given object to the given filename using XML encoding
func Save(v any, filename string) error {
        return iox.Save(v, filename, iox.NewEncoderFunc(xml.NewEncoder))
}

// Write writes the given object using XML encoding
func Write(v any, writer io.Writer) error {
        return iox.Write(v, writer, iox.NewEncoderFunc(xml.NewEncoder))
}

// WriteBytes writes the given object, returning bytes of the encoding,
// using XML encoding
func WriteBytes(v any) ([]byte, error) {
        return iox.WriteBytes(v, iox.NewEncoderFunc(xml.NewEncoder))
}

// IndentEncoderFunc is a [iox.EncoderFunc] that sets indentation
var IndentEncoderFunc = func(w io.Writer) iox.Encoder {
        e := xml.NewEncoder(w)
        e.Indent("", "\t")
        return e
}

// SaveIndent writes the given object to the given filename using XML encoding, with indentation
func SaveIndent(v any, filename string) error {
        return iox.Save(v, filename, IndentEncoderFunc)
}

// WriteIndent writes the given object using XML encoding, with indentation
func WriteIndent(v any, writer io.Writer) error {
        return iox.Write(v, writer, IndentEncoderFunc)
}

// WriteBytesIndent writes the given object, returning bytes of the encoding,
// using XML encoding, with indentation
func WriteBytesIndent(v any) ([]byte, error) {
        return iox.WriteBytes(v, IndentEncoderFunc)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package yamlx

import (
        "io"
        "io/fs"

        "cogentcore.org/core/base/iox"
        "gopkg.in/yaml.v3"
)

// Open reads the given object from the given filename using YAML encoding
func Open(v any, filename string) error {
        return iox.Open(v, filename, iox.NewDecoderFunc(yaml.NewDecoder))
}

// OpenFiles reads the given object from the given filenames using YAML encoding
func OpenFiles(v any, filenames ...string) error {
        return iox.OpenFiles(v, filenames, iox.NewDecoderFunc(yaml.NewDecoder))
}

// OpenFS reads the given object from the given filename using YAML encoding,
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFS(v any, fsys fs.FS, filename string) error {
        return iox.OpenFS(v, fsys, filename, iox.NewDecoderFunc(yaml.NewDecoder))
}

// OpenFilesFS reads the given object from the given filenames using YAML encoding,
// using the given [fs.FS] filesystem (e.g., for embed files)
func OpenFilesFS(v any, fsys fs.FS, filenames ...string) error {
        return iox.OpenFilesFS(v, fsys, filenames, iox.NewDecoderFunc(yaml.NewDecoder))
}

// Read reads the given object from the given reader,
// using YAML encoding
func Read(v any, reader io.Reader) error {
        return iox.Read(v, reader, iox.NewDecoderFunc(yaml.NewDecoder))
}

// ReadBytes reads the given object from the given bytes,
// using YAML encoding
func ReadBytes(v any, data []byte) error {
        return iox.ReadBytes(v, data, iox.NewDecoderFunc(yaml.NewDecoder))
}

// Save writes the given object to the given filename using YAML encoding
func Save(v any, filename string) error {
        return iox.Save(v, filename, iox.NewEncoderFunc(yaml.NewEncoder))
}

// Write writes the given object using YAML encoding
func Write(v any, writer io.Writer) error {
        return iox.Write(v, writer, iox.NewEncoderFunc(yaml.NewEncoder))
}

// WriteBytes writes the given object, returning bytes of the encoding,
// using YAML encoding
func WriteBytes(v any) ([]byte, error) {
        return iox.WriteBytes(v, iox.NewEncoderFunc(yaml.NewEncoder))
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package keylist implements an ordered list (slice) of items,
with a map from a key (e.g., names) to indexes,
to support fast lookup by name.
This is a different implementation of the [ordmap] package,
that has separate slices for Values and Keys, instead of
using a tuple list of both. The awkwardness of value access
through the tuple is the major problem with ordmap.
*/
package keylist

import (
        "fmt"
        "slices"
)

// TODO: probably want to consolidate ordmap and keylist: https://github.com/cogentcore/core/issues/1224

// List implements an ordered list (slice) of Values,
// with a map from a key (e.g., names) to indexes,
// to support fast lookup by name.
type List[K comparable, V any] struct { //types:add
        // List is the ordered slice of items.
        Values []V

        // Keys is the ordered list of keys, in same order as [List.Values]
        Keys []K

        // indexes is the key-to-index mapping.
        indexes map[K]int
}

// New returns a new [List].  The zero value
// is usable without initialization, so this is
// just a simple standard convenience method.
func New[K comparable, V any]() *List[K, V] {
        return &List[K, V]{}
}

func (kl *List[K, V]) makeIndexes() {
        kl.indexes = make(map[K]int)
}

// initIndexes ensures that the index map exists.
func (kl *List[K, V]) initIndexes() {
        if kl.indexes == nil {
                kl.makeIndexes()
        }
}

// Reset resets the list, removing any existing elements.
func (kl *List[K, V]) Reset() {
        kl.Values = nil
        kl.Keys = nil
        kl.makeIndexes()
}

// Set sets given key to given value, adding to the end of the list
// if not already present, and otherwise replacing with this new value.
// This is the same semantics as a Go map.
// See [List.Add] for version that only adds and does not replace.
func (kl *List[K, V]) Set(key K, val V) {
        kl.initIndexes()
        if idx, ok := kl.indexes[key]; ok {
                kl.Values[idx] = val
                kl.Keys[idx] = key
                return
        }
        kl.indexes[key] = len(kl.Values)
        kl.Values = append(kl.Values, val)
        kl.Keys = append(kl.Keys, key)
}

// Add adds an item to the list with given key,
// An error is returned if the key is already on the list.
// See [List.Set] for a method that automatically replaces.
func (kl *List[K, V]) Add(key K, val V) error {
        kl.initIndexes()
        if _, ok := kl.indexes[key]; ok {
                return fmt.Errorf("keylist.Add: key %v is already on the list", key)
        }
        kl.indexes[key] = len(kl.Values)
        kl.Values = append(kl.Values, val)
        kl.Keys = append(kl.Keys, key)
        return nil
}

// Insert inserts the given value with the given key at the given index.
// This is relatively slow because it needs regenerate the keys list.
// It panics if the key already exists because the behavior is undefined
// in that situation.
func (kl *List[K, V]) Insert(idx int, key K, val V) {
        if _, has := kl.indexes[key]; has {
                panic("keylist.Add: key is already on the list")
        }

        kl.Keys = slices.Insert(kl.Keys, idx, key)
        kl.Values = slices.Insert(kl.Values, idx, val)
        kl.makeIndexes()
        for i, k := range kl.Keys {
                kl.indexes[k] = i
        }
}

// At returns the value corresponding to the given key,
// with a zero value returned for a missing key. See [List.AtTry]
// for one that returns a bool for missing keys.
// For index-based access, use [List.Values] or [List.Keys] slices directly.
func (kl *List[K, V]) At(key K) V {
        idx, ok := kl.indexes[key]
        if ok {
                return kl.Values[idx]
        }
        var zv V
        return zv
}

// AtTry returns the value corresponding to the given key,
// with false returned for a missing key, in case the zero value
// is not diagnostic.
func (kl *List[K, V]) AtTry(key K) (V, bool) {
        idx, ok := kl.indexes[key]
        if ok {
                return kl.Values[idx], true
        }
        var zv V
        return zv, false
}

// IndexIsValid returns an error if the given index is invalid.
func (kl *List[K, V]) IndexIsValid(idx int) error {
        if idx >= len(kl.Values) || idx < 0 {
                return fmt.Errorf("keylist.List: IndexIsValid: index %d is out of range of a list of length %d", idx, len(kl.Values))
        }
        return nil
}

// IndexByKey returns the index of the given key, with a -1 for missing key.
func (kl *List[K, V]) IndexByKey(key K) int {
        idx, ok := kl.indexes[key]
        if !ok {
                return -1
        }
        return idx
}

// Len returns the number of items in the list.
func (kl *List[K, V]) Len() int {
        if kl == nil {
                return 0
        }
        return len(kl.Values)
}

// DeleteByIndex deletes item(s) within the index range [i:j].
// This is relatively slow because it needs to regenerate the
// index map.
func (kl *List[K, V]) DeleteByIndex(i, j int) {
        ndel := j - i
        if ndel <= 0 {
                panic("index range is <= 0")
        }
        kl.Keys = slices.Delete(kl.Keys, i, j)
        kl.Values = slices.Delete(kl.Values, i, j)
        kl.makeIndexes()
        for i, k := range kl.Keys {
                kl.indexes[k] = i
        }

}

// DeleteByKey deletes the item with the given key,
// returning false if it does not find it.
// This is relatively slow because it needs to regenerate the
// index map.
func (kl *List[K, V]) DeleteByKey(key K) bool {
        idx, ok := kl.indexes[key]
        if !ok {
                return false
        }
        kl.DeleteByIndex(idx, idx+1)
        return true
}

// RenameIndex renames the item at given index to new key.
func (kl *List[K, V]) RenameIndex(i int, key K) {
        old := kl.Keys[i]
        delete(kl.indexes, old)
        kl.Keys[i] = key
        kl.indexes[key] = i
}

// Copy copies all of the entries from the given key list
// into this list. It keeps existing entries in this
// list unless they also exist in the given list, in which case
// they are overwritten.  Use [List.Reset] first to get an exact copy.
func (kl *List[K, V]) Copy(from *List[K, V]) {
        for i, v := range from.Values {
                kl.Set(kl.Keys[i], v)
        }
}

// String returns a string representation of the list.
func (kl *List[K, V]) String() string {
        sv := "{"
        for i, v := range kl.Values {
                sv += fmt.Sprintf("%v", kl.Keys[i]) + ": " + fmt.Sprintf("%v", v) + ", "
        }
        sv += "}"
        return sv
}

// UpdateIndexes updates the Indexes from Keys and Values.
// This must be called after loading Values from a file, for example,
// where Keys can be populated from Values or are also otherwise available.
func (kl *List[K, V]) UpdateIndexes() {
        kl.makeIndexes()
        for i := range kl.Values {
                k := kl.Keys[i]
                kl.indexes[k] = i
        }
}

/*
// GoString returns the list as Go code.
func (kl *List[K, V]) GoString() string {
        var zk K
        var zv V
        res := fmt.Sprintf("ordlist.Make([]ordlist.KeyVal[%T, %T]{\n", zk, zv)
        for _, kv := range kl.Order {
                res += fmt.Sprintf("{%#v, %#v},\n", kv.Key, kv.Value)
        }
        res += "})"
        return res
}
*/

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package labels

import (
        "fmt"
        "reflect"
        "strings"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/strcase"
)

// FriendlyTypeName returns a user-friendly version of the name of the given type.
// It transforms it into sentence case, excludes the package, and converts various
// builtin types into more friendly forms (eg: "int" to "Number").
func FriendlyTypeName(typ reflect.Type) string {
        nptyp := reflectx.NonPointerType(typ)
        if nptyp == nil {
                return "None"
        }
        nm := nptyp.Name()

        // if it is named, we use that
        if nm != "" {
                switch nm {
                case "string":
                        return "Text"
                case "float32", "float64", "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr":
                        return "Number"
                }
                return strcase.ToSentence(nm)
        }

        // otherwise, we fall back on Kind
        switch nptyp.Kind() {
        case reflect.Slice, reflect.Array, reflect.Map:
                bnm := FriendlyTypeName(nptyp.Elem())
                if strings.HasSuffix(bnm, "s") {
                        return "List of " + bnm
                } else if strings.Contains(bnm, "Function of") {
                        return strings.ReplaceAll(bnm, "Function of", "Functions of") + "s"
                }
                return bnm + "s"
        case reflect.Func:
                str := "Function"
                ni := nptyp.NumIn()
                if ni > 0 {
                        str += " of"
                }
                for i := 0; i < ni; i++ {
                        str += " " + FriendlyTypeName(nptyp.In(i))
                        if ni == 2 && i == 0 {
                                str += " and"
                        } else if i == ni-2 {
                                str += ", and"
                        } else if i < ni-1 {
                                str += ","
                        }
                }
                return str
        }
        if nptyp.String() == "interface {}" {
                return "Value"
        }
        return nptyp.String()
}

// FriendlyStructLabel returns a user-friendly label for the given struct value.
func FriendlyStructLabel(v reflect.Value) string {
        npv := reflectx.NonPointerValue(v)
        if !v.IsValid() || v.IsZero() {
                return "None"
        }
        opv := reflectx.UnderlyingPointer(v)
        if lbler, ok := opv.Interface().(Labeler); ok {
                return lbler.Label()
        }
        return FriendlyTypeName(npv.Type())
}

// FriendlySliceLabel returns a user-friendly label for the given slice value.
func FriendlySliceLabel(v reflect.Value) string {
        uv := reflectx.Underlying(v)
        label := ""
        if !uv.IsValid() {
                label = "None"
        } else {
                if uv.Kind() == reflect.Array || !uv.IsNil() {
                        bnm := FriendlyTypeName(reflectx.SliceElementType(v.Interface()))
                        if strings.HasSuffix(bnm, "s") {
                                label = strcase.ToSentence(fmt.Sprintf("%d lists of %s", uv.Len(), bnm))
                        } else {
                                label = strcase.ToSentence(fmt.Sprintf("%d %ss", uv.Len(), bnm))
                        }
                } else {
                        label = "None"
                }
        }
        return label
}

// FriendlyMapLabel returns a user-friendly label for the given map value.
func FriendlyMapLabel(v reflect.Value) string {
        uv := reflectx.Underlying(v)
        mpi := v.Interface()
        label := ""
        if !uv.IsValid() || uv.IsNil() {
                label = "None"
        } else {
                bnm := FriendlyTypeName(reflectx.MapValueType(mpi))
                if strings.HasSuffix(bnm, "s") {
                        label = strcase.ToSentence(fmt.Sprintf("%d lists of %s", uv.Len(), bnm))
                } else {
                        label = strcase.ToSentence(fmt.Sprintf("%d %ss", uv.Len(), bnm))
                }
        }
        return label
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package labels

import (
        "cogentcore.org/core/base/reflectx"
)

// Labeler interface provides a GUI-appropriate label for an item,
// via a Label string method. See [ToLabel] and [ToLabeler].
type Labeler interface {

        // Label returns a GUI-appropriate label for item
        Label() string
}

// ToLabel returns the GUI-appropriate label for an item, using the Labeler
// interface if it is defined, and falling back on [reflectx.ToString] converter
// otherwise.
func ToLabel(v any) string {
        if lb, ok := v.(Labeler); ok {
                return lb.Label()
        }
        return reflectx.ToString(v)
}

// ToLabeler returns the Labeler label, true if it was defined, else "", false
func ToLabeler(v any) (string, bool) {
        if lb, ok := v.(Labeler); ok {
                return lb.Label(), true
        }
        return "", false
}

// SliceLabeler interface provides a GUI-appropriate label
// for a slice item, given an index into the slice.
type SliceLabeler interface {

        // ElemLabel returns a GUI-appropriate label for slice element at given index.
        ElemLabel(idx int) string
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package logx

import (
        "image/color"
        "log/slog"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/matcolor"
        "github.com/muesli/termenv"
)

var (
        // UseColor is whether to use color in log messages. It is on by default.
        UseColor = true

        // ColorSchemeIsDark is whether the color scheme of the current terminal is dark-themed.
        // Its primary use is in [ColorScheme], and it should typically only be accessed via that.
        ColorSchemeIsDark = true
)

// ColorScheme returns the appropriate appropriate color scheme
// for terminal colors. It should be used instead of [colors.Scheme]
// for terminal colors because the theme (dark vs light) of the terminal
// could be different than that of the main app.
func ColorScheme() *matcolor.Scheme {
        if ColorSchemeIsDark {
                return &colors.Schemes.Dark
        }
        return &colors.Schemes.Light
}

// colorProfile is the termenv color profile, stored globally for convenience.
// It is set by [SetDefaultLogger] to [termenv.ColorProfile] if [UseColor] is true.
var colorProfile termenv.Profile

// InitColor sets up the terminal environment for color output. It is called automatically
// in an init function if UseColor is set to true. However, if you call a system command
// (ls, cp, etc), you need to call this function again.
func InitColor() {
        restoreFunc, err := termenv.EnableVirtualTerminalProcessing(termenv.DefaultOutput())
        if err != nil {
                slog.Warn("error enabling virtual terminal processing for colored output on Windows", "err", err)
        }
        _ = restoreFunc // TODO: figure out how to call this at the end of the program
        colorProfile = termenv.ColorProfile()
        ColorSchemeIsDark = termenv.HasDarkBackground()
}

// ApplyColor applies the given color to the given string
// and returns the resulting string. If [UseColor] is set
// to false, it just returns the string it was passed.
func ApplyColor(clr color.Color, str string) string {
        if !UseColor {
                return str
        }
        return termenv.String(str).Foreground(colorProfile.FromColor(clr)).String()
}

// LevelColor applies the color associated with the given level to the
// given string and returns the resulting string. If [UseColor] is set
// to false, it just returns the string it was passed.
func LevelColor(level slog.Level, str string) string {
        var clr color.RGBA
        switch level {
        case slog.LevelDebug:
                return DebugColor(str)
        case slog.LevelInfo:
                return InfoColor(str)
        case slog.LevelWarn:
                return WarnColor(str)
        case slog.LevelError:
                return ErrorColor(str)
        }
        return ApplyColor(clr, str)
}

// DebugColor applies the color associated with the debug level to
// the given string and returns the resulting string. If [UseColor] is set
// to false, it just returns the string it was passed.
func DebugColor(str string) string {
        return ApplyColor(colors.ToUniform(ColorScheme().Tertiary.Base), str)
}

// InfoColor applies the color associated with the info level to
// the given string and returns the resulting string. Because the
// color associated with the info level is just white/black, it just
// returns the given string, but it exists for API consistency.
func InfoColor(str string) string {
        return str
}

// WarnColor applies the color associated with the warn level to
// the given string and returns the resulting string. If [UseColor] is set
// to false, it just returns the string it was passed.
func WarnColor(str string) string {
        return ApplyColor(colors.ToUniform(ColorScheme().Warn.Base), str)
}

// ErrorColor applies the color associated with the error level to
// the given string and returns the resulting string. If [UseColor] is set
// to false, it just returns the string it was passed.
func ErrorColor(str string) string {
        return ApplyColor(colors.ToUniform(ColorScheme().Error.Base), str)
}

// SuccessColor applies the color associated with success to the
// given string and returns the resulting string. If [UseColor] is set
// to false, it just returns the string it was passed.
func SuccessColor(str string) string {
        return ApplyColor(colors.ToUniform(ColorScheme().Success.Base), str)
}

// CmdColor applies the color associated with terminal commands and arguments
// to the given string and returns the resulting string. If [UseColor] is set
// to false, it just returns the string it was passed.
func CmdColor(str string) string {
        return ApplyColor(colors.ToUniform(ColorScheme().Primary.Base), str)
}

// TitleColor applies the color associated with titles and section headers
// to the given string and returns the resulting string. If [UseColor] is set
// to false, it just returns the string it was passed.
func TitleColor(str string) string {
        return ApplyColor(colors.ToUniform(ColorScheme().Warn.Base), str)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package logx

import "log/slog"

// UserLevel is the verbosity [slog.Level] that the user has selected for
// what logging and printing messages should be shown. Messages at
// levels at or above this level will be shown. It should typically
// be set through exec to the end user's preference. The default user
// verbosity level is [slog.LevelInfo]. If the build tag "debug" is
// specified, it is [slog.LevelDebug]. If the build tag "release" is
// specified, it is [slog.levelWarn]. Any updates to this value will
// be automatically reflected in the behavior of the logx default logger.
var UserLevel = defaultUserLevel

// LevelFromFlags returns the [slog.Level] object corresponding to the given
// user flag options. The flags correspond to the following values:
//   - vv: [slog.LevelDebug]
//   - v: [slog.LevelInfo]
//   - q: [slog.LevelError]
//   - (default: [slog.LevelWarn])

// The flags are evaluated in that order, so, for example, if both
// vv and q are specified, it will still return [Debug].
func LevelFromFlags(vv, v, q bool) slog.Level {
        switch {
        case vv:
                return slog.LevelDebug
        case v:
                return slog.LevelInfo
        case q:
                return slog.LevelError
        default:
                return slog.LevelWarn
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This code is based on https://github.com/jba/slog/blob/main/handlers/loghandler/log_handler.go
// Copyright (c) 2022, Jonathan Amsterdam. All rights reserved. (BSD 3-Clause License)

// Package logx implements structured log handling and provides
// global log and print verbosity and color options.
package logx

import (
        "context"
        "fmt"
        "io"
        "log/slog"
        "os"
        "runtime"
        "strconv"
        "sync"
)

// Handler is a [slog.Handler] whose output resembles that of [log.Logger].
// Use [NewHandler] to make a new [Handler] from a writer and options.
type Handler struct {
        Opts      slog.HandlerOptions
        Prefix    string // preformatted group names followed by a dot
        Preformat string // preformatted Attrs, with an initial space

        Mu sync.Mutex
        W  io.Writer
}

var _ slog.Handler = &Handler{}

// SetDefaultLogger sets the default logger to be a [Handler] with the
// level set to track [UserLevel]. It is called on program start
// automatically, so it should not need to be called by end user code
// in almost all circumstances.
func SetDefaultLogger() {
        slog.SetDefault(slog.New(NewHandler(os.Stderr, &slog.HandlerOptions{
                Level: &UserLevel,
        })))
        if UseColor {
                InitColor()
        }
}

func init() {
        SetDefaultLogger()
}

// NewHandler makes a new [Handler] for the given writer with the given options.
func NewHandler(w io.Writer, opts *slog.HandlerOptions) *Handler {
        h := &Handler{W: w}
        if opts != nil {
                h.Opts = *opts
        }
        if h.Opts.ReplaceAttr == nil {
                h.Opts.ReplaceAttr = func(_ []string, a slog.Attr) slog.Attr { return a }
        }
        return h
}

// Enabled returns whether the handler should log a mesage with the given
// level in the given context.
func (h *Handler) Enabled(ctx context.Context, level slog.Level) bool {
        minLevel := slog.LevelInfo
        if h.Opts.Level != nil {
                minLevel = h.Opts.Level.Level()
        }
        return level >= minLevel
}

func (h *Handler) WithGroup(name string) slog.Handler {
        return &Handler{
                W:         h.W,
                Opts:      h.Opts,
                Preformat: h.Preformat,
                Prefix:    h.Prefix + name + ".",
        }
}

func (h *Handler) WithAttrs(attrs []slog.Attr) slog.Handler {
        var buf []byte
        for _, a := range attrs {
                buf = h.AppendAttr(buf, h.Prefix, a)
        }
        return &Handler{
                W:         h.W,
                Opts:      h.Opts,
                Prefix:    h.Prefix,
                Preformat: h.Preformat + string(buf),
        }
}

func (h *Handler) Handle(ctx context.Context, r slog.Record) error {
        var buf []byte
        if !r.Time.IsZero() {
                buf = r.Time.AppendFormat(buf, "2006/01/02 15:04:05")
                buf = append(buf, ' ')
        }
        buf = append(buf, r.Level.String()...)
        buf = append(buf, ' ')
        if h.Opts.AddSource && r.PC != 0 {
                fs := runtime.CallersFrames([]uintptr{r.PC})
                f, _ := fs.Next()
                buf = append(buf, f.File...)
                buf = append(buf, ':')
                buf = strconv.AppendInt(buf, int64(f.Line), 10)
                buf = append(buf, ' ')
        }
        buf = append(buf, r.Message...)
        buf = append(buf, h.Preformat...)
        r.Attrs(func(a slog.Attr) bool {
                buf = h.AppendAttr(buf, h.Prefix, a)
                return true
        })
        buf = append(buf, '\n')
        h.Mu.Lock()
        defer h.Mu.Unlock()
        if UseColor {
                _, err := h.W.Write([]byte(LevelColor(r.Level, string(buf))))
                return err
        }
        _, err := h.W.Write(buf)
        return err
}

func (h *Handler) AppendAttr(buf []byte, prefix string, a slog.Attr) []byte {
        if a.Equal(slog.Attr{}) {
                return buf
        }
        if a.Value.Kind() != slog.KindGroup {
                buf = append(buf, ' ')
                buf = append(buf, prefix...)
                buf = append(buf, a.Key...)
                buf = append(buf, '=')
                return fmt.Appendf(buf, "%v", a.Value.Any())
        }
        // Group
        if a.Key != "" {
                prefix += a.Key + "."
        }
        for _, a := range a.Value.Group() {
                buf = h.AppendAttr(buf, prefix, a)
        }
        return buf
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package logx

import (
        "fmt"
        "log/slog"
)

// Print is equivalent to [fmt.Print], but with color based on the given level.
// Also, if [UserLevel] is above the given level, it does not print anything.
func Print(level slog.Level, a ...any) (n int, err error) {
        if UserLevel > level {
                return 0, nil
        }
        return fmt.Print(LevelColor(level, fmt.Sprint(a...)))
}

// PrintDebug is equivalent to [Print] with level [slog.LevelDebug].
func PrintDebug(a ...any) (n int, err error) {
        return Print(slog.LevelDebug, a...)
}

// PrintInfo is equivalent to [Print] with level [slog.LevelInfo].
func PrintInfo(a ...any) (n int, err error) {
        return Print(slog.LevelInfo, a...)
}

// PrintWarn is equivalent to [Print] with level [slog.LevelWarn].
func PrintWarn(a ...any) (n int, err error) {
        return Print(slog.LevelWarn, a...)
}

// PrintError is equivalent to [Print] with level [slog.LevelError].
func PrintError(a ...any) (n int, err error) {
        return Print(slog.LevelError, a...)
}

// Println is equivalent to [fmt.Println], but with color based on the given level.
// Also, if [UserLevel] is above the given level, it does not print anything.
func Println(level slog.Level, a ...any) (n int, err error) {
        if UserLevel > level {
                return 0, nil
        }
        return fmt.Println(LevelColor(level, fmt.Sprint(a...)))
}

// PrintlnDebug is equivalent to [Println] with level [slog.LevelDebug].
func PrintlnDebug(a ...any) (n int, err error) {
        return Println(slog.LevelDebug, a...)
}

// PrintlnInfo is equivalent to [Println] with level [slog.LevelInfo].
func PrintlnInfo(a ...any) (n int, err error) {
        return Println(slog.LevelInfo, a...)
}

// PrintlnWarn is equivalent to [Println] with level [slog.LevelWarn].
func PrintlnWarn(a ...any) (n int, err error) {
        return Println(slog.LevelWarn, a...)
}

// PrintlnError is equivalent to [Println] with level [slog.LevelError].
func PrintlnError(a ...any) (n int, err error) {
        return Println(slog.LevelError, a...)
}

// Printf is equivalent to [fmt.Printf], but with color based on the given level.
// Also, if [UserLevel] is above the given level, it does not print anything.
func Printf(level slog.Level, format string, a ...any) (n int, err error) {
        if UserLevel > level {
                return 0, nil
        }
        return fmt.Println(LevelColor(level, fmt.Sprintf(format, a...)))
}

// PrintfDebug is equivalent to [Printf] with level [slog.LevelDebug].
func PrintfDebug(format string, a ...any) (n int, err error) {
        return Printf(slog.LevelDebug, format, a...)
}

// PrintfInfo is equivalent to [Printf] with level [slog.LevelInfo].
func PrintfInfo(format string, a ...any) (n int, err error) {
        return Printf(slog.LevelInfo, format, a...)
}

// PrintfWarn is equivalent to [Printf] with level [slog.LevelWarn].
func PrintfWarn(format string, a ...any) (n int, err error) {
        return Printf(slog.LevelWarn, format, a...)
}

// PrintfError is equivalent to [Printf] with level [slog.LevelError].
func PrintfError(format string, a ...any) (n int, err error) {
        return Printf(slog.LevelError, format, a...)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/laher/mergefs
// Copyright (c) 2021 Amir Laher under the MIT License

// Package mergefs provides support for merging multiple filesystems together.
package mergefs

import (
        "errors"
        "io/fs"
        "os"
)

// Merge merges the given filesystems together,
func Merge(filesystems ...fs.FS) fs.FS {
        return MergedFS{filesystems: filesystems}
}

// MergedFS combines filesystems. Each filesystem can serve different paths.
// The first FS takes precedence
type MergedFS struct {
        filesystems []fs.FS
}

// Open opens the named file.
func (mfs MergedFS) Open(name string) (fs.File, error) {
        for _, fs := range mfs.filesystems {
                file, err := fs.Open(name)
                if err == nil { // TODO should we return early when it's not an os.ErrNotExist? Should we offer options to decide this behaviour?
                        return file, nil
                }
        }
        return nil, os.ErrNotExist
}

// ReadDir reads from the directory, and produces a DirEntry array of different
// directories.
//
// It iterates through all different filesystems that exist in the mfs MergeFS
// filesystem slice and it identifies overlapping directories that exist in different
// filesystems
func (mfs MergedFS) ReadDir(name string) ([]fs.DirEntry, error) {
        dirsMap := make(map[string]fs.DirEntry)
        notExistCount := 0
        for _, filesystem := range mfs.filesystems {
                dir, err := fs.ReadDir(filesystem, name)
                if err != nil {
                        if errors.Is(err, fs.ErrNotExist) {
                                notExistCount++
                                continue
                        }
                        return nil, err
                }
                for _, v := range dir {
                        if _, ok := dirsMap[v.Name()]; !ok {
                                dirsMap[v.Name()] = v
                        }
                }
                continue
        }
        if len(mfs.filesystems) == notExistCount {
                return nil, fs.ErrNotExist
        }
        dirs := make([]fs.DirEntry, 0, len(dirsMap))

        for _, value := range dirsMap {
                dirs = append(dirs, value)
        }

        return dirs, nil
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package metadata provides a map of named any elements
// with generic support for type-safe Get and nil-safe Set.
// Metadata keys often function as optional fields in a struct,
// and therefore a CamelCase naming convention is typical.
// Provides default support for "Name", "Doc", "File" standard keys.
package metadata

import (
        "fmt"
        "maps"

        "cogentcore.org/core/base/errors"
)

// Data is metadata as a map of named any elements
// with generic support for type-safe Get and nil-safe Set.
// Metadata keys often function as optional fields in a struct,
// and therefore a CamelCase naming convention is typical.
// Provides default support for "Name" and "Doc" standard keys.
// In general it is good practice to provide access functions
// that establish standard key names, to avoid issues with typos.
type Data map[string]any

func (md *Data) init() {
        if *md == nil {
                *md = make(map[string]any)
        }
}

// Set sets key to given value, ensuring that
// the map is created if not previously.
func (md *Data) Set(key string, value any) {
        md.init()
        (*md)[key] = value
}

// GetFromData gets metadata value of given type from given Data.
// Returns error if not present or item is a different type.
func GetFromData[T any](md Data, key string) (T, error) {
        var z T
        x, ok := md[key]
        if !ok {
                return z, fmt.Errorf("key %q not found in metadata", key)
        }
        v, ok := x.(T)
        if !ok {
                return z, fmt.Errorf("key %q has a different type than expected %T: is %T", key, z, x)
        }
        return v, nil
}

// Copy does a shallow copy of metadata from source.
// Any pointer-based values will still point to the same
// underlying data as the source, but the two maps remain
// distinct.  It uses [maps.Copy].
func (md *Data) Copy(src Data) {
        if src == nil {
                return
        }
        md.init()
        maps.Copy(*md, src)
}

//////// Metadataer

// Metadataer is an interface for a type that returns associated
// metadata.Data using a Metadata() method. To be able to set metadata,
// the method should be defined with a pointer receiver.
type Metadataer interface {
        Metadata() *Data
}

// GetData gets the Data from given object, if it implements the
// Metadata() method. Returns nil if it does not.
// Must pass a pointer to the object.
func GetData(obj any) *Data {
        if md, ok := obj.(Metadataer); ok {
                return md.Metadata()
        }
        return nil
}

// Get gets metadata value of given type from given object,
// if it implements the Metadata() method.
// Must pass a pointer to the object.
// Returns error if not present or item is a different type.
func Get[T any](obj any, key string) (T, error) {
        md := GetData(obj)
        if md == nil {
                var zv T
                return zv, errors.New("metadata not available for given object type")
        }
        return GetFromData[T](*md, key)
}

// Set sets metadata value on given object, if it implements
// the Metadata() method. Returns error if no Metadata on object.
// Must pass a pointer to the object.
func Set(obj any, key string, value any) error {
        md := GetData(obj)
        if md == nil {
                return errors.Log(errors.New("metadata not available for given object type"))
        }
        md.Set(key, value)
        return nil
}

// Copy copies metadata from source
// Must pass a pointer to the object.
func Copy(to, src any) *Data {
        tod := GetData(to)
        if tod == nil {
                return nil
        }
        srcd := GetData(src)
        if srcd == nil {
                return tod
        }
        tod.Copy(*srcd)
        return tod
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package metadata

import "os"

// SetName sets the "Name" standard key.
func SetName(obj any, name string) {
        Set(obj, "Name", name)
}

// Name returns the "Name" standard key value (empty if not set).
func Name(obj any) string {
        nm, _ := Get[string](obj, "Name")
        return nm
}

// SetDoc sets the "Doc" standard key.
func SetDoc(obj any, doc string) {
        Set(obj, "Doc", doc)
}

// Doc returns the "Doc" standard key value (empty if not set).
func Doc(obj any) string {
        doc, _ := Get[string](obj, "Doc")
        return doc
}

// SetFile sets the "File" standard key for *os.File.
func SetFile(obj any, file *os.File) {
        Set(obj, "File", file)
}

// File returns the "File" standard key value (nil if not set).
func File(obj any) *os.File {
        doc, _ := Get[*os.File](obj, "File")
        return doc
}

// SetFilename sets the "Filename" standard key.
func SetFilename(obj any, file string) {
        Set(obj, "Filename", file)
}

// Filename returns the "Filename" standard key value (empty if not set).
func Filename(obj any) string {
        doc, _ := Get[string](obj, "Filename")
        return doc
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package nptime provides a non-pointer version of the time.Time struct
that does not have the location pointer information that time.Time has,
which is more efficient from a memory management perspective, in cases
where you have a lot of time values being kept: https://segment.com/blog/allocation-efficiency-in-high-performance-go-services/
*/
package nptime

import "time"

// Time represents the value of time.Time without using any pointers for the
// location information, so it is more memory efficient when lots of time
// values are being stored.
type Time struct {

        // [time.Time.Unix] seconds since 1970
        Sec int64

        // [time.Time.Nanosecond]; nanosecond offset within second, *not* UnixNano
        NSec uint32
}

// IsZero returns true if the time is zero and has not been initialized.
func (t Time) IsZero() bool {
        return t == Time{}
}

// Time returns the [time.Time] value for this [Time] value.
func (t Time) Time() time.Time {
        return time.Unix(t.Sec, int64(t.NSec))
}

// SetTime sets the [Time] value based on the [time.Time]. value
func (t *Time) SetTime(tt time.Time) {
        t.Sec = tt.Unix()
        t.NSec = uint32(tt.Nanosecond())
}

// Now sets the time value to [time.Now].
func (t *Time) Now() {
        t.SetTime(time.Now())
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package num

// Abs returns the absolute value of the given value.
func Abs[T Signed | Float](x T) T {
        if x < 0 {
                return -x
        }
        return x
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package num

// see: https://github.com/golang/go/issues/61915

// ToBool returns a bool true if the given number is not zero,
// and false if it is zero, providing a direct way to convert
// numbers to bools as is done automatically in C and other languages.
func ToBool[T Number](v T) bool {
        return v != 0
}

// FromBool returns a 1 if the bool is true and a 0 for false.
// Typically the type parameter cannot be inferred and must be provided.
// See SetFromBool for a version that uses a pointer to the destination
// which avoids the need to specify the type parameter.
func FromBool[T Number](v bool) T {
        if v {
                return 1
        }
        return 0
}

// SetFromBool converts a bool into a number, using generics,
// setting the pointer to the dst destination value to a 1 if bool is true,
// and 0 otherwise.
// This version of FromBool does not require type parameters typically.
func SetFromBool[T Number](dst *T, b bool) {
        if b {
                *dst = 1
        }
        *dst = 0
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package option provides optional (nullable) types.
package option

// Option represents an optional (nullable) type. If Valid is true, Option
// represents Value. Otherwise, it represents a null/unset/invalid value.
type Option[T any] struct {
        Valid bool `label:"Set"`
        Value T
}

// New returns a new [Option] set to the given value.
func New[T any](v T) *Option[T] {
        o := &Option[T]{}
        o.Set(v)
        return o
}

// Set sets the value to the given value.
func (o *Option[T]) Set(v T) *Option[T] {
        o.Value = v
        o.Valid = true
        return o
}

// Clear marks the value as null/unset/invalid.
func (o *Option[T]) Clear() *Option[T] {
        o.Valid = false
        return o
}

// Or returns the value of the option if it is not marked
// as null/unset/invalid, and otherwise it returns the given value.
func (o *Option[T]) Or(or T) T {
        if o.Valid {
                return o.Value
        }
        return or
}

func (o *Option[T]) ShouldSave() bool {
        return o.Valid
}

func (o *Option[T]) ShouldDisplay(field string) bool {
        switch field {
        case "Value":
                return o.Valid
        }
        return true
}

// Copyright (c) 2022, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
package ordmap implements an ordered map that retains the order of items
added to a slice, while also providing fast key-based map lookup of items,
using the Go 1.18 generics system.

The implementation is fully visible and the API provides a minimal
subset of methods, compared to other implementations that are heavier,
so that additional functionality can be added as needed.

The slice structure holds the Key and Value for items as they are added,
enabling direct updating of the corresponding map, which holds the
index into the slice.  Adding and access are fast, while deleting
and inserting are relatively slow, requiring updating of the index map,
but these are already slow due to the slice updating.
*/
package ordmap

import (
        "fmt"

        "slices"
)

// KeyValue represents a key-value pair.
type KeyValue[K comparable, V any] struct {
        Key   K
        Value V
}

// Map is a generic ordered map that combines the order of a slice
// and the fast key lookup of a map. A map stores an index
// into a slice that has the value and key associated with the value.
type Map[K comparable, V any] struct {

        // Order is an ordered list of values and associated keys, in the order added.
        Order []KeyValue[K, V]

        // Map is the key to index mapping.
        Map map[K]int `display:"-"`
}

// New returns a new ordered map.
func New[K comparable, V any]() *Map[K, V] {
        return &Map[K, V]{
                Map: make(map[K]int),
        }
}

// Make constructs a new ordered map with the given key-value pairs
func Make[K comparable, V any](vals []KeyValue[K, V]) *Map[K, V] {
        om := &Map[K, V]{
                Order: vals,
                Map:   make(map[K]int, len(vals)),
        }
        for i, v := range om.Order {
                om.Map[v.Key] = i
        }
        return om
}

// Init initializes the map if it isn't already.
func (om *Map[K, V]) Init() {
        if om.Map == nil {
                om.Map = make(map[K]int)
        }
}

// Reset resets the map, removing any existing elements.
func (om *Map[K, V]) Reset() {
        om.Map = nil
        om.Order = nil
}

// Add adds a new value for given key.
// If key already exists in map, it replaces the item at that existing index,
// otherwise it is added to the end.
func (om *Map[K, V]) Add(key K, val V) {
        om.Init()
        if idx, has := om.Map[key]; has {
                om.Map[key] = idx
                om.Order[idx] = KeyValue[K, V]{Key: key, Value: val}
        } else {
                om.Map[key] = len(om.Order)
                om.Order = append(om.Order, KeyValue[K, V]{Key: key, Value: val})
        }
}

// ReplaceIndex replaces the value at the given index
// with the given new item with the given key.
func (om *Map[K, V]) ReplaceIndex(idx int, key K, val V) {
        old := om.Order[idx]
        if key != old.Key {
                delete(om.Map, old.Key)
                om.Map[key] = idx
        }
        om.Order[idx] = KeyValue[K, V]{Key: key, Value: val}
}

// InsertAtIndex inserts the given value with the given key at the given index.
// This is relatively slow because it needs to renumber the index map above
// the inserted value.  It will panic if the key already exists because
// the behavior is undefined in that situation.
func (om *Map[K, V]) InsertAtIndex(idx int, key K, val V) {
        if _, has := om.Map[key]; has {
                panic("key already exists")
        }
        om.Init()
        sz := len(om.Order)
        for o := idx; o < sz; o++ {
                om.Map[om.Order[o].Key] = o + 1
        }
        om.Map[key] = idx
        om.Order = slices.Insert(om.Order, idx, KeyValue[K, V]{Key: key, Value: val})
}

// ValueByKey returns the value corresponding to the given key,
// with a zero value returned for a missing key. See [Map.ValueByKeyTry]
// for one that returns a bool for missing keys.
func (om *Map[K, V]) ValueByKey(key K) V {
        idx, ok := om.Map[key]
        if ok {
                return om.Order[idx].Value
        }
        var zv V
        return zv
}

// ValueByKeyTry returns the value corresponding to the given key,
// with false returned for a missing key.
func (om *Map[K, V]) ValueByKeyTry(key K) (V, bool) {
        idx, ok := om.Map[key]
        if ok {
                return om.Order[idx].Value, ok
        }
        var zv V
        return zv, false
}

// IndexIsValid returns an error if the given index is invalid
func (om *Map[K, V]) IndexIsValid(idx int) error {
        if idx >= len(om.Order) || idx < 0 {
                return fmt.Errorf("ordmap.Map: IndexIsValid: index %d is out of range of a map of length %d", idx, len(om.Order))
        }
        return nil
}

// IndexByKey returns the index of the given key, with a -1 for missing key.
// See [Map.IndexByKeyTry] for a version returning a bool for missing key.
func (om *Map[K, V]) IndexByKey(key K) int {
        idx, ok := om.Map[key]
        if !ok {
                return -1
        }
        return idx
}

// IndexByKeyTry returns the index of the given key, with false for a missing key.
func (om *Map[K, V]) IndexByKeyTry(key K) (int, bool) {
        idx, ok := om.Map[key]
        return idx, ok
}

// ValueByIndex returns the value at the given index in the ordered slice.
func (om *Map[K, V]) ValueByIndex(idx int) V {
        return om.Order[idx].Value
}

// KeyByIndex returns the key for the given index in the ordered slice.
func (om *Map[K, V]) KeyByIndex(idx int) K {
        return om.Order[idx].Key
}

// Len returns the number of items in the map.
func (om *Map[K, V]) Len() int {
        if om == nil {
                return 0
        }
        return len(om.Order)
}

// DeleteIndex deletes item(s) within the index range [i:j].
// This is relatively slow because it needs to renumber the
// index map above the deleted range.
func (om *Map[K, V]) DeleteIndex(i, j int) {
        sz := len(om.Order)
        ndel := j - i
        if ndel <= 0 {
                panic("index range is <= 0")
        }
        for o := j; o < sz; o++ {
                om.Map[om.Order[o].Key] = o - ndel
        }
        for o := i; o < j; o++ {
                delete(om.Map, om.Order[o].Key)
        }
        om.Order = slices.Delete(om.Order, i, j)
}

// DeleteKey deletes the item with the given key, returning false if it does not find it.
func (om *Map[K, V]) DeleteKey(key K) bool {
        idx, ok := om.Map[key]
        if !ok {
                return false
        }
        om.DeleteIndex(idx, idx+1)
        return true
}

// Keys returns a slice of the keys in order.
func (om *Map[K, V]) Keys() []K {
        kl := make([]K, om.Len())
        for i, kv := range om.Order {
                kl[i] = kv.Key
        }
        return kl
}

// Values returns a slice of the values in order.
func (om *Map[K, V]) Values() []V {
        vl := make([]V, om.Len())
        for i, kv := range om.Order {
                vl[i] = kv.Value
        }
        return vl
}

// Copy copies all of the entries from the given ordered map
// into this ordered map. It keeps existing entries in this
// map unless they also exist in the given map, in which case
// they are overwritten.
func (om *Map[K, V]) Copy(from *Map[K, V]) {
        for _, kv := range from.Order {
                om.Add(kv.Key, kv.Value)
        }
}

// String returns a string representation of the map.
func (om *Map[K, V]) String() string {
        return fmt.Sprintf("%v", om.Order)
}

// GoString returns the map as Go code.
func (om *Map[K, V]) GoString() string {
        var zk K
        var zv V
        res := fmt.Sprintf("ordmap.Make([]ordmap.KeyVal[%T, %T]{\n", zk, zv)
        for _, kv := range om.Order {
                res += fmt.Sprintf("{%#v, %#v},\n", kv.Key, kv.Value)
        }
        res += "})"
        return res
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package plan provides an efficient mechanism for updating a slice
// to contain a target list of elements, generating minimal edits to
// modify the current slice contents to match the target.
// The mechanism depends on the use of unique name string identifiers
// to determine whether an element is currently configured correctly.
// These could be algorithmically generated hash strings or any other
// such unique identifier.
package plan

import (
        "slices"

        "cogentcore.org/core/base/slicesx"
)

// Namer is an interface that types can implement to specify their name in a plan context.
type Namer interface {

        // PlanName returns the name of the object in a plan context.
        PlanName() string
}

// Update ensures that the elements of the given slice contain
// the elements according to the plan specified by the given arguments.
// The argument n specifies the total number of items in the target plan.
// The elements have unique names specified by the given name function.
// If a new item is needed, the given new function is called to create it
// for the given name at the given index position. After a new element is
// created, it is added to the slice, and if the given optional init function
// is non-nil, it is called with the new element and its index. If the
// given destroy function is not-nil, then it is called on any element
// that is being deleted from the slice. Update returns whether any changes
// were made. The given slice must be a pointer so that it can be modified
// live, which is required for init functions to run when the slice is
// correctly updated to the current state.
func Update[T Namer](s *[]T, n int, name func(i int) string, new func(name string, i int) T, init func(e T, i int), destroy func(e T)) bool {
        changed := false
        // first make a map for looking up the indexes of the target names
        names := make([]string, n)
        nmap := make(map[string]int, n)
        smap := make(map[string]int, n)
        for i := range n {
                nm := name(i)
                names[i] = nm
                if _, has := nmap[nm]; has {
                        panic("plan.Update: duplicate name: " + nm) // no way to recover
                }
                nmap[nm] = i
        }
        // first remove anything we don't want
        sn := len(*s)
        for i := sn - 1; i >= 0; i-- {
                nm := (*s)[i].PlanName()
                if _, ok := nmap[nm]; !ok {
                        changed = true
                        if destroy != nil {
                                destroy((*s)[i])
                        }
                        *s = slices.Delete(*s, i, i+1)
                }
                smap[nm] = i
        }
        // next add and move items as needed; in order so guaranteed
        for i, tn := range names {
                ci := slicesx.Search(*s, func(e T) bool { return e.PlanName() == tn }, smap[tn])
                if ci < 0 { // item not currently on the list
                        changed = true
                        ne := new(tn, i)
                        *s = slices.Insert(*s, i, ne)
                        if init != nil {
                                init(ne, i)
                        }
                } else { // on the list; is it in the right place?
                        if ci != i {
                                changed = true
                                e := (*s)[ci]
                                *s = slices.Delete(*s, ci, ci+1)
                                *s = slices.Insert(*s, i, e)
                        }
                }
        }
        return changed
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package profile provides basic but effective profiling of targeted
// functions or code sections, which can often be more informative than
// generic cpu profiling.
//
// Here's how you use it:
//
//        // somewhere near start of program (e.g., using flag package)
//        profileFlag := flag.Bool("profile", false, "turn on targeted profiling")
//        ...
//        flag.Parse()
//        profile.Profiling = *profileFlag
//        ...
//        // surrounding the code of interest:
//        pr := profile.Start()
//        ... code
//        pr.End()
//        ...
//        // at the end or whenever you've got enough data:
//        profile.Report(time.Millisecond) // or time.Second or whatever
package profile

import (
        "cmp"
        "fmt"
        "runtime"
        "slices"
        "strings"
        "sync"
        "time"

        "cogentcore.org/core/base/errors"
)

// Main User API:

// Start starts profiling and returns a Profile struct that must have [Profile.End]
// called on it when done timing. It will be nil if not the first to start
// timing on this function; it assumes nested inner / outer loop structure for
// calls to the same method. It uses the short, package-qualified name of the
// calling function as the name of the profile struct. Extra information can be
// passed to Start, which will be added at the end of the name in a dash-delimited
// format. See [StartName] for a version that supports a custom name.
func Start(info ...string) *Profile {
        if !Profiling {
                return nil
        }
        name := ""
        pc, _, _, ok := runtime.Caller(1)
        if ok {
                name = runtime.FuncForPC(pc).Name()
                // get rid of everything before the package
                if li := strings.LastIndex(name, "/"); li >= 0 {
                        name = name[li+1:]
                }
        } else {
                err := "profile.Start: unexpected error: unable to get caller"
                errors.Log(errors.New(err))
                name = "!(" + err + ")"
        }
        if len(info) > 0 {
                name += "-" + strings.Join(info, "-")
        }
        return TheProfiler.Start(name)
}

// StartName starts profiling and returns a Profile struct that must have
// [Profile.End] called on it when done timing. It will be nil if not the first
// to start timing on this function; it assumes nested inner / outer loop structure
// for calls to the same method. It uses the given name as the name of the profile
// struct. Extra information can be passed to StartName, which will be added at
// the end of the name in a dash-delimited format. See [Start] for a version that
// automatically determines the name from the name of the calling function.
func StartName(name string, info ...string) *Profile {
        if len(info) > 0 {
                name += "-" + strings.Join(info, "-")
        }
        return TheProfiler.Start(name)
}

// Report generates a report of all the profile data collected.
func Report(units time.Duration) {
        TheProfiler.Report(units)
}

// Reset resets all of the profiling data.
func Reset() {
        TheProfiler.Reset()
}

// Profiling is whether profiling is currently enabled.
var Profiling = false

// TheProfiler is the global instance of [Profiler].
var TheProfiler = Profiler{}

// Profile represents one profiled function.
type Profile struct {
        Name   string
        Total  time.Duration
        N      int64
        Avg    float64
        St     time.Time
        Timing bool
}

func (p *Profile) Start() *Profile {
        if !p.Timing {
                p.St = time.Now()
                p.Timing = true
                return p
        }
        return nil
}

func (p *Profile) End() {
        if p == nil || !Profiling {
                return
        }
        dur := time.Since(p.St)
        p.Total += dur
        p.N++
        p.Avg = float64(p.Total) / float64(p.N)
        p.Timing = false
}

func (p *Profile) Report(tot float64, units time.Duration) {
        us := strings.TrimPrefix(units.String(), "1")
        fmt.Printf("%-60sTotal:%8.2f %s\tAvg:%6.2f\tN:%6d\tPct:%6.2f\n",
                p.Name, float64(p.Total)/float64(units), us, p.Avg/float64(units), p.N, 100.0*float64(p.Total)/tot)
}

// Profiler manages a map of profiled functions.
type Profiler struct {
        Profiles map[string]*Profile
        mu       sync.Mutex
}

// Start starts profiling and returns a Profile struct that must have .End()
// called on it when done timing
func (p *Profiler) Start(name string) *Profile {
        if !Profiling {
                return nil
        }
        p.mu.Lock()
        if p.Profiles == nil {
                p.Profiles = make(map[string]*Profile, 0)
        }
        pr, ok := p.Profiles[name]
        if !ok {
                pr = &Profile{Name: name}
                p.Profiles[name] = pr
        }
        prval := pr.Start()
        p.mu.Unlock()
        return prval
}

// Report generates a report of all the profile data collected
func (p *Profiler) Report(units time.Duration) {
        if !Profiling {
                return
        }
        list := make([]*Profile, len(p.Profiles))
        tot := 0.0
        idx := 0
        for _, pr := range p.Profiles {
                tot += float64(pr.Total)
                list[idx] = pr
                idx++
        }
        slices.SortFunc(list, func(a, b *Profile) int {
                return cmp.Compare(b.Total, a.Total)
        })
        for _, pr := range list {
                pr.Report(tot, units)
        }
}

func (p *Profiler) Reset() {
        p.Profiles = make(map[string]*Profile, 0)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package reflectx

import (
        "fmt"
        "log"
        "reflect"
        "sort"
        "strings"
        "time"

        "cogentcore.org/core/base/errors"
)

// This file contains helpful functions for dealing with maps
// in the reflect system

// MapValueType returns the type of the value for the given map (which can be
// a pointer to a map or a direct map); just Elem() of map type, but using
// this function makes it more explicit what is going on.
func MapValueType(mp any) reflect.Type {
        return NonPointerType(reflect.TypeOf(mp)).Elem()
}

// MapKeyType returns the type of the key for the given map (which can be a
// pointer to a map or a direct map); just Key() of map type, but using
// this function makes it more explicit what is going on.
func MapKeyType(mp any) reflect.Type {
        return NonPointerType(reflect.TypeOf(mp)).Key()
}

// MapAdd adds a new blank entry to the map.
func MapAdd(mv any) {
        mpv := reflect.ValueOf(mv)
        mpvnp := Underlying(mpv)
        mvtyp := mpvnp.Type()
        valtyp := MapValueType(mv)
        if valtyp.Kind() == reflect.Interface && valtyp.String() == "interface {}" {
                valtyp = reflect.TypeOf("")
        }
        nkey := reflect.New(MapKeyType(mv))
        nval := reflect.New(valtyp)
        if mpvnp.IsNil() { // make a new map
                mpv.Elem().Set(reflect.MakeMap(mvtyp))
                mpvnp = Underlying(mpv)
        }
        mpvnp.SetMapIndex(nkey.Elem(), nval.Elem())
}

// MapDelete deletes the given key from the given map.
func MapDelete(mv any, key reflect.Value) {
        mpv := reflect.ValueOf(mv)
        mpvnp := Underlying(mpv)
        mpvnp.SetMapIndex(key, reflect.Value{}) // delete
}

// MapDeleteAll deletes everything from the given map.
func MapDeleteAll(mv any) {
        mpv := reflect.ValueOf(mv)
        mpvnp := Underlying(mpv)
        if mpvnp.Len() == 0 {
                return
        }
        itr := mpvnp.MapRange()
        for itr.Next() {
                mpvnp.SetMapIndex(itr.Key(), reflect.Value{}) // delete
        }
}

// MapSort sorts the keys of the map either by key or by value,
// and returns those keys as a slice of [reflect.Value]s.
func MapSort(mp any, byKey, ascending bool) []reflect.Value {
        mpv := reflect.ValueOf(mp)
        mpvnp := Underlying(mpv)
        keys := mpvnp.MapKeys() // note: this is a slice of reflect.Value!
        if byKey {
                ValueSliceSort(keys, ascending)
        } else {
                MapValueSort(mpvnp, keys, ascending)
        }
        return keys
}

// MapValueSort sorts the keys of the given map by their values.
func MapValueSort(mpvnp reflect.Value, keys []reflect.Value, ascending bool) error {
        if len(keys) == 0 {
                return nil
        }
        keyval := keys[0]
        felval := mpvnp.MapIndex(keyval)
        eltyp := felval.Type()
        elnptyp := NonPointerType(eltyp)
        vk := elnptyp.Kind()
        elval := OnePointerValue(felval)
        elif := elval.Interface()

        // try all the numeric types first!

        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                sort.Slice(keys, func(i, j int) bool {
                        iv := Underlying(mpvnp.MapIndex(keys[i])).Int()
                        jv := Underlying(mpvnp.MapIndex(keys[j])).Int()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                sort.Slice(keys, func(i, j int) bool {
                        iv := Underlying(mpvnp.MapIndex(keys[i])).Uint()
                        jv := Underlying(mpvnp.MapIndex(keys[j])).Uint()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                sort.Slice(keys, func(i, j int) bool {
                        iv := Underlying(mpvnp.MapIndex(keys[i])).Float()
                        jv := Underlying(mpvnp.MapIndex(keys[j])).Float()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk == reflect.Struct && ShortTypeName(elnptyp) == "time.Time":
                sort.Slice(keys, func(i, j int) bool {
                        iv := Underlying(mpvnp.MapIndex(keys[i])).Interface().(time.Time)
                        jv := Underlying(mpvnp.MapIndex(keys[j])).Interface().(time.Time)
                        if ascending {
                                return iv.Before(jv)
                        }
                        return jv.Before(iv)
                })
        }

        // this stringer case will likely pick up most of the rest
        switch elif.(type) {
        case fmt.Stringer:
                sort.Slice(keys, func(i, j int) bool {
                        iv := Underlying(mpvnp.MapIndex(keys[i])).Interface().(fmt.Stringer).String()
                        jv := Underlying(mpvnp.MapIndex(keys[j])).Interface().(fmt.Stringer).String()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        }

        // last resort!
        switch {
        case vk == reflect.String:
                sort.Slice(keys, func(i, j int) bool {
                        iv := Underlying(mpvnp.MapIndex(keys[i])).String()
                        jv := Underlying(mpvnp.MapIndex(keys[j])).String()
                        if ascending {
                                return strings.ToLower(iv) < strings.ToLower(jv)
                        }
                        return strings.ToLower(iv) > strings.ToLower(jv)
                })
                return nil
        }

        err := fmt.Errorf("MapValueSort: unable to sort elements of type: %v", eltyp.String())
        log.Println(err)
        return err
}

// SetMapRobust robustly sets a map value using [reflect.Value]
// representations of the map, key, and value elements, ensuring that the
// proper types are used for the key and value elements using sensible
// conversions.
func SetMapRobust(mp, ky, val reflect.Value) bool {
        mtyp := mp.Type()
        if mtyp.Kind() != reflect.Map {
                log.Printf("reflectx.SetMapRobust: map arg is not map, is: %v\n", mtyp.String())
                return false
        }
        if !mp.CanSet() {
                log.Printf("reflectx.SetMapRobust: map arg is not settable: %v\n", mtyp.String())
                return false
        }
        ktyp := mtyp.Key()
        etyp := mtyp.Elem()
        if etyp.Kind() == val.Kind() && ky.Kind() == ktyp.Kind() {
                mp.SetMapIndex(ky, val)
                return true
        }
        if ky.Kind() == ktyp.Kind() {
                mp.SetMapIndex(ky, val.Convert(etyp))
                return true
        }
        if etyp.Kind() == val.Kind() {
                mp.SetMapIndex(ky.Convert(ktyp), val)
                return true
        }
        mp.SetMapIndex(ky.Convert(ktyp), val.Convert(etyp))
        return true
}

// CopyMapRobust robustly copies maps.
func CopyMapRobust(to, from any) error {
        tov := reflect.ValueOf(to)
        fmv := reflect.ValueOf(from)
        tonp := Underlying(tov)
        fmnp := Underlying(fmv)
        totyp := tonp.Type()
        if totyp.Kind() != reflect.Map {
                err := fmt.Errorf("reflectx.CopyMapRobust: 'to' is not map, is: %v", totyp)
                return errors.Log(err)
        }
        fmtyp := fmnp.Type()
        if fmtyp.Kind() != reflect.Map {
                err := fmt.Errorf("reflectx.CopyMapRobust: 'from' is not map, is: %v", fmtyp)
                return errors.Log(err)
        }
        if tonp.IsNil() {
                OnePointerValue(tov).Elem().Set(reflect.MakeMap(totyp))
        } else {
                MapDeleteAll(to)
        }
        if fmnp.Len() == 0 {
                return nil
        }
        eltyp := SliceElementType(to)
        itr := fmnp.MapRange()
        for itr.Next() {
                tonp.SetMapIndex(itr.Key(), CloneToType(eltyp, itr.Value().Interface()).Elem())
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package reflectx

import (
        "reflect"
)

// NonPointerType returns a non-pointer version of the given type.
func NonPointerType(typ reflect.Type) reflect.Type {
        if typ == nil {
                return typ
        }
        for typ.Kind() == reflect.Pointer {
                typ = typ.Elem()
        }
        return typ
}

// NonPointerValue returns a non-pointer version of the given value.
// If it encounters a nil pointer, it returns the nil pointer instead
// of an invalid value.
func NonPointerValue(v reflect.Value) reflect.Value {
        for v.Kind() == reflect.Pointer {
                new := v.Elem()
                if !new.IsValid() {
                        return v
                }
                v = new
        }
        return v
}

// PointerValue returns a pointer to the given value if it is not already
// a pointer.
func PointerValue(v reflect.Value) reflect.Value {
        if !v.IsValid() {
                return v
        }
        if v.Kind() == reflect.Pointer {
                return v
        }
        if v.CanAddr() {
                return v.Addr()
        }
        pv := reflect.New(v.Type())
        pv.Elem().Set(v)
        return pv
}

// OnePointerValue returns a value that is exactly one pointer away
// from a non-pointer value.
func OnePointerValue(v reflect.Value) reflect.Value {
        if !v.IsValid() {
                return v
        }
        if v.Kind() != reflect.Pointer {
                if v.CanAddr() {
                        return v.Addr()
                }
                // slog.Error("reflectx.OnePointerValue: cannot take address of value", "value", v)
                pv := reflect.New(v.Type())
                pv.Elem().Set(v)
                return pv
        }
        for v.Elem().Kind() == reflect.Pointer {
                v = v.Elem()
        }

        return v
}

// Underlying returns the actual underlying version of the given value,
// going through any pointers and interfaces. If it encounters a nil
// pointer or interface, it returns the nil pointer or interface instead of
// an invalid value.
func Underlying(v reflect.Value) reflect.Value {
        if !v.IsValid() {
                return v
        }
        for v.Type().Kind() == reflect.Interface || v.Type().Kind() == reflect.Pointer {
                new := v.Elem()
                if !new.IsValid() {
                        return v
                }
                v = new
        }
        return v
}

// UnderlyingPointer returns a pointer to the actual underlying version of the
// given value, going through any pointers and interfaces. It is equivalent to
// [OnePointerValue] of [Underlying], so if it encounters a nil pointer or
// interface, it stops at the nil pointer or interface instead of returning
// an invalid value.
func UnderlyingPointer(v reflect.Value) reflect.Value {
        if !v.IsValid() {
                return v
        }
        uv := Underlying(v)
        if !uv.IsValid() {
                return v
        }
        return OnePointerValue(uv)
}

// NonNilNew has the same overall behavior as [reflect.New] except that
// it traverses through any pointers such that a new zero non-pointer value
// will be created in the end, so any pointers in the original type will not
// be nil. For example, in pseudo-code, NonNilNew(**int) will return
// &(&(&(0))).
func NonNilNew(typ reflect.Type) reflect.Value {
        n := 0
        for typ.Kind() == reflect.Pointer {
                n++
                typ = typ.Elem()
        }
        v := reflect.New(typ)
        for range n {
                pv := reflect.New(v.Type())
                pv.Elem().Set(v)
                v = pv
        }
        return v
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package reflectx

import (
        "fmt"
        "reflect"
        "sort"
        "strings"
        "time"

        "cogentcore.org/core/base/errors"
)

// This file contains helpful functions for dealing with slices
// in the reflect system

// SliceElementType returns the type of the elements of the given slice (which can be
// a pointer to a slice or a direct slice); just [reflect.Type.Elem] of slice type, but
// using this function bypasses any pointer issues and makes it more explicit what is going on.
func SliceElementType(sl any) reflect.Type {
        return Underlying(reflect.ValueOf(sl)).Type().Elem()
}

// SliceElementValue returns a new [reflect.Value] of the [SliceElementType].
func SliceElementValue(sl any) reflect.Value {
        return NonNilNew(SliceElementType(sl)).Elem()
}

// SliceNewAt inserts a new blank element at the given index in the given slice.
// -1 means the end.
func SliceNewAt(sl any, idx int) {
        up := UnderlyingPointer(reflect.ValueOf(sl))
        np := up.Elem()
        val := SliceElementValue(sl)
        sz := np.Len()
        np = reflect.Append(np, val)
        if idx >= 0 && idx < sz {
                reflect.Copy(np.Slice(idx+1, sz+1), np.Slice(idx, sz))
                np.Index(idx).Set(val)
        }
        up.Elem().Set(np)
}

// SliceDeleteAt deletes the element at the given index in the given slice.
func SliceDeleteAt(sl any, idx int) {
        svl := OnePointerValue(reflect.ValueOf(sl))
        svnp := NonPointerValue(svl)
        svtyp := svnp.Type()
        nval := reflect.New(svtyp.Elem())
        sz := svnp.Len()
        reflect.Copy(svnp.Slice(idx, sz-1), svnp.Slice(idx+1, sz))
        svnp.Index(sz - 1).Set(nval.Elem())
        svl.Elem().Set(svnp.Slice(0, sz-1))
}

// SliceSort sorts a slice of basic values (see [StructSliceSort] for sorting a
// slice-of-struct using a specific field), using float, int, string, and [time.Time]
// conversions.
func SliceSort(sl any, ascending bool) error {
        sv := reflect.ValueOf(sl)
        svnp := NonPointerValue(sv)
        if svnp.Len() == 0 {
                return nil
        }
        eltyp := SliceElementType(sl)
        elnptyp := NonPointerType(eltyp)
        vk := elnptyp.Kind()
        elval := OnePointerValue(svnp.Index(0))
        elif := elval.Interface()

        // try all the numeric types first!
        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        iv := NonPointerValue(svnp.Index(i)).Int()
                        jv := NonPointerValue(svnp.Index(j)).Int()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        iv := NonPointerValue(svnp.Index(i)).Uint()
                        jv := NonPointerValue(svnp.Index(j)).Uint()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        iv := NonPointerValue(svnp.Index(i)).Float()
                        jv := NonPointerValue(svnp.Index(j)).Float()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk == reflect.Struct && ShortTypeName(elnptyp) == "time.Time":
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        iv := NonPointerValue(svnp.Index(i)).Interface().(time.Time)
                        jv := NonPointerValue(svnp.Index(j)).Interface().(time.Time)
                        if ascending {
                                return iv.Before(jv)
                        }
                        return jv.Before(iv)
                })
        }

        // this stringer case will likely pick up most of the rest
        switch elif.(type) {
        case fmt.Stringer:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        iv := NonPointerValue(svnp.Index(i)).Interface().(fmt.Stringer).String()
                        jv := NonPointerValue(svnp.Index(j)).Interface().(fmt.Stringer).String()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        }

        // last resort!
        switch {
        case vk == reflect.String:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        iv := NonPointerValue(svnp.Index(i)).String()
                        jv := NonPointerValue(svnp.Index(j)).String()
                        if ascending {
                                return strings.ToLower(iv) < strings.ToLower(jv)
                        }
                        return strings.ToLower(iv) > strings.ToLower(jv)
                })
                return nil
        }

        err := fmt.Errorf("SortSlice: unable to sort elements of type: %v", eltyp.String())
        return errors.Log(err)
}

// StructSliceSort sorts the given slice of structs according to the given field
// indexes and sort direction, using float, int, string, and [time.Time] conversions.
// It will panic if the field indexes are invalid.
func StructSliceSort(structSlice any, fieldIndex []int, ascending bool) error {
        sv := reflect.ValueOf(structSlice)
        svnp := NonPointerValue(sv)
        if svnp.Len() == 0 {
                return nil
        }
        structTyp := SliceElementType(structSlice)
        structNptyp := NonPointerType(structTyp)
        fld := structNptyp.FieldByIndex(fieldIndex) // not easy to check.
        vk := fld.Type.Kind()
        structVal := OnePointerValue(svnp.Index(0))
        fieldVal := structVal.Elem().FieldByIndex(fieldIndex)
        fieldIf := fieldVal.Interface()

        // try all the numeric types first!
        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        ival := OnePointerValue(svnp.Index(i))
                        iv := ival.Elem().FieldByIndex(fieldIndex).Int()
                        jval := OnePointerValue(svnp.Index(j))
                        jv := jval.Elem().FieldByIndex(fieldIndex).Int()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        ival := OnePointerValue(svnp.Index(i))
                        iv := ival.Elem().FieldByIndex(fieldIndex).Uint()
                        jval := OnePointerValue(svnp.Index(j))
                        jv := jval.Elem().FieldByIndex(fieldIndex).Uint()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        ival := OnePointerValue(svnp.Index(i))
                        iv := ival.Elem().FieldByIndex(fieldIndex).Float()
                        jval := OnePointerValue(svnp.Index(j))
                        jv := jval.Elem().FieldByIndex(fieldIndex).Float()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk == reflect.Struct && ShortTypeName(fld.Type) == "time.Time":
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        ival := OnePointerValue(svnp.Index(i))
                        iv := ival.Elem().FieldByIndex(fieldIndex).Interface().(time.Time)
                        jval := OnePointerValue(svnp.Index(j))
                        jv := jval.Elem().FieldByIndex(fieldIndex).Interface().(time.Time)
                        if ascending {
                                return iv.Before(jv)
                        }
                        return jv.Before(iv)
                })
        }

        // this stringer case will likely pick up most of the rest
        switch fieldIf.(type) {
        case fmt.Stringer:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        ival := OnePointerValue(svnp.Index(i))
                        iv := ival.Elem().FieldByIndex(fieldIndex).Interface().(fmt.Stringer).String()
                        jval := OnePointerValue(svnp.Index(j))
                        jv := jval.Elem().FieldByIndex(fieldIndex).Interface().(fmt.Stringer).String()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        }

        // last resort!
        switch {
        case vk == reflect.String:
                sort.Slice(svnp.Interface(), func(i, j int) bool {
                        ival := OnePointerValue(svnp.Index(i))
                        iv := ival.Elem().FieldByIndex(fieldIndex).String()
                        jval := OnePointerValue(svnp.Index(j))
                        jv := jval.Elem().FieldByIndex(fieldIndex).String()
                        if ascending {
                                return strings.ToLower(iv) < strings.ToLower(jv)
                        }
                        return strings.ToLower(iv) > strings.ToLower(jv)
                })
                return nil
        }

        err := fmt.Errorf("SortStructSlice: unable to sort on field of type: %v", fld.Type.String())
        return errors.Log(err)
}

// ValueSliceSort sorts a slice of [reflect.Value]s using basic types where possible.
func ValueSliceSort(sl []reflect.Value, ascending bool) error {
        if len(sl) == 0 {
                return nil
        }
        felval := sl[0] // reflect.Value
        eltyp := felval.Type()
        elnptyp := NonPointerType(eltyp)
        vk := elnptyp.Kind()
        elval := OnePointerValue(felval)
        elif := elval.Interface()

        // try all the numeric types first!
        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                sort.Slice(sl, func(i, j int) bool {
                        iv := NonPointerValue(sl[i]).Int()
                        jv := NonPointerValue(sl[j]).Int()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                sort.Slice(sl, func(i, j int) bool {
                        iv := NonPointerValue(sl[i]).Uint()
                        jv := NonPointerValue(sl[j]).Uint()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                sort.Slice(sl, func(i, j int) bool {
                        iv := NonPointerValue(sl[i]).Float()
                        jv := NonPointerValue(sl[j]).Float()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        case vk == reflect.Struct && ShortTypeName(elnptyp) == "time.Time":
                sort.Slice(sl, func(i, j int) bool {
                        iv := NonPointerValue(sl[i]).Interface().(time.Time)
                        jv := NonPointerValue(sl[j]).Interface().(time.Time)
                        if ascending {
                                return iv.Before(jv)
                        }
                        return jv.Before(iv)
                })
        }

        // this stringer case will likely pick up most of the rest
        switch elif.(type) {
        case fmt.Stringer:
                sort.Slice(sl, func(i, j int) bool {
                        iv := NonPointerValue(sl[i]).Interface().(fmt.Stringer).String()
                        jv := NonPointerValue(sl[j]).Interface().(fmt.Stringer).String()
                        if ascending {
                                return iv < jv
                        }
                        return iv > jv
                })
                return nil
        }

        // last resort!
        switch {
        case vk == reflect.String:
                sort.Slice(sl, func(i, j int) bool {
                        iv := NonPointerValue(sl[i]).String()
                        jv := NonPointerValue(sl[j]).String()
                        if ascending {
                                return strings.ToLower(iv) < strings.ToLower(jv)
                        }
                        return strings.ToLower(iv) > strings.ToLower(jv)
                })
                return nil
        }

        err := fmt.Errorf("ValueSliceSort: unable to sort elements of type: %v", eltyp.String())
        return errors.Log(err)
}

// CopySliceRobust robustly copies slices.
func CopySliceRobust(to, from any) error {
        tov := reflect.ValueOf(to)
        fmv := reflect.ValueOf(from)
        tonp := Underlying(tov)
        fmnp := Underlying(fmv)
        totyp := tonp.Type()
        if totyp.Kind() != reflect.Slice {
                err := fmt.Errorf("reflectx.CopySliceRobust: 'to' is not slice, is: %v", totyp.String())
                return errors.Log(err)
        }
        fmtyp := fmnp.Type()
        if fmtyp.Kind() != reflect.Slice {
                err := fmt.Errorf("reflectx.CopySliceRobust: 'from' is not slice, is: %v", fmtyp.String())
                return errors.Log(err)
        }
        fmlen := fmnp.Len()
        if tonp.IsNil() {
                tonp.Set(reflect.MakeSlice(totyp, fmlen, fmlen))
        } else {
                if tonp.Len() > fmlen {
                        tonp.SetLen(fmlen)
                }
        }
        for i := 0; i < fmlen; i++ {
                tolen := tonp.Len()
                if i >= tolen {
                        SliceNewAt(to, i)
                }
                SetRobust(PointerValue(tonp.Index(i)).Interface(), fmnp.Index(i).Interface())
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package reflectx

import (
        "fmt"
        "log/slog"
        "reflect"
        "strconv"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/iox/jsonx"
)

// WalkFields calls the given walk function on all the exported primary fields of the
// given parent struct value, including those on anonymous embedded
// structs that this struct has. It effectively flattens all of the embedded fields
// of the struct.
//
// It passes the current parent struct, current [reflect.StructField],
// and current field value to the given should and walk functions.
//
// The given should function is called on every struct field (including
// on embedded structs themselves) to determine whether that field and any fields
// it has embedded should be handled (a return value of true indicates to continue
// down and a value of false indicates to not).
func WalkFields(parent reflect.Value, should func(parent reflect.Value, field reflect.StructField, value reflect.Value) bool, walk func(parent reflect.Value, parentField *reflect.StructField, field reflect.StructField, value reflect.Value)) {
        walkFields(parent, nil, should, walk)
}

func walkFields(parent reflect.Value, parentField *reflect.StructField, should func(parent reflect.Value, field reflect.StructField, value reflect.Value) bool, walk func(parent reflect.Value, parentField *reflect.StructField, field reflect.StructField, value reflect.Value)) {
        typ := parent.Type()
        for i := 0; i < typ.NumField(); i++ {
                field := typ.Field(i)
                if !field.IsExported() {
                        continue
                }
                value := parent.Field(i)
                if !should(parent, field, value) {
                        continue
                }
                if field.Type.Kind() == reflect.Struct && field.Anonymous {
                        walkFields(value, &field, should, walk)
                } else {
                        walk(parent, parentField, field, value)
                }
        }
}

// NumAllFields returns the number of elemental fields in the given struct type
// using [WalkFields].
func NumAllFields(parent reflect.Value) int {
        n := 0
        WalkFields(parent,
                func(parent reflect.Value, field reflect.StructField, value reflect.Value) bool {
                        return true
                }, func(parent reflect.Value, parentField *reflect.StructField, field reflect.StructField, value reflect.Value) {
                        n++
                })
        return n
}

// ValueIsDefault returns whether the given value is equivalent to the
// given string representation used in a field default tag.
func ValueIsDefault(fv reflect.Value, def string) bool {
        kind := fv.Kind()
        if kind >= reflect.Int && kind <= reflect.Complex128 && strings.Contains(def, ":") {
                dtags := strings.Split(def, ":")
                lo, _ := strconv.ParseFloat(dtags[0], 64)
                hi, _ := strconv.ParseFloat(dtags[1], 64)
                vf, err := ToFloat(fv.Interface())
                if err != nil {
                        slog.Error("reflectx.ValueIsDefault: error parsing struct field numerical range def tag", "def", def, "err", err)
                        return true
                }
                return lo <= vf && vf <= hi
        }
        dtags := strings.Split(def, ",")
        if strings.ContainsAny(def, "{[") { // complex type, so don't split on commas
                dtags = []string{def}
        }
        for _, df := range dtags {
                df = FormatDefault(df)
                if df == "" {
                        return fv.IsZero()
                }
                dv := reflect.New(fv.Type())
                err := SetRobust(dv.Interface(), df)
                if err != nil {
                        slog.Error("reflectx.ValueIsDefault: error getting value from default struct tag", "defaultStructTag", df, "value", fv, "err", err)
                        return false
                }
                if reflect.DeepEqual(fv.Interface(), dv.Elem().Interface()) {
                        return true
                }
        }
        return false
}

// SetFromDefaultTags sets the values of fields in the given struct based on
// `default:` default value struct field tags.
func SetFromDefaultTags(v any) error {
        ov := reflect.ValueOf(v)
        if IsNil(ov) {
                return nil
        }
        val := NonPointerValue(ov)
        typ := val.Type()
        for i := 0; i < typ.NumField(); i++ {
                f := typ.Field(i)
                if !f.IsExported() {
                        continue
                }
                fv := val.Field(i)
                def := f.Tag.Get("default")
                if NonPointerType(f.Type).Kind() == reflect.Struct && def == "" {
                        SetFromDefaultTags(PointerValue(fv).Interface())
                        continue
                }
                err := SetFromDefaultTag(fv, def)
                if err != nil {
                        return fmt.Errorf("reflectx.SetFromDefaultTags: error setting field %q in object of type %q from val %q: %w", f.Name, typ.Name(), def, err)
                }
        }
        return nil
}

// SetFromDefaultTag sets the given value from the given default tag.
func SetFromDefaultTag(v reflect.Value, def string) error {
        def = FormatDefault(def)
        if def == "" {
                return nil
        }
        return SetRobust(UnderlyingPointer(v).Interface(), def)
}

// ShouldSaver is an interface that types can implement to specify
// whether a value should be included in the result of [NonDefaultFields].
type ShouldSaver interface {

        // ShouldSave returns whether this value should be included in the
        // result of [NonDefaultFields].
        ShouldSave() bool
}

// TODO: it would be good to return an ordmap or struct of the fields for
// ordered output, but that may be difficult.

// NonDefaultFields returns a map representing all of the fields of the given
// struct (or pointer to a struct) that have values different than their default
// values as specified by the `default:` struct tag. The resulting map is then typically
// saved using something like JSON or TOML. If a value has no default value, it
// checks whether its value is non-zero. If a field has a `save:"-"` tag, it wil
// not be included in the resulting map. If a field implements [ShouldSaver] and
// returns false, it will not be included in the resulting map.
func NonDefaultFields(v any) map[string]any {
        res := map[string]any{}

        rv := Underlying(reflect.ValueOf(v))
        if IsNil(rv) {
                return nil
        }
        rt := rv.Type()
        nf := rt.NumField()
        for i := 0; i < nf; i++ {
                fv := rv.Field(i)
                ft := rt.Field(i)
                if ft.Tag.Get("save") == "-" {
                        continue
                }
                if ss, ok := UnderlyingPointer(fv).Interface().(ShouldSaver); ok {
                        if !ss.ShouldSave() {
                                continue
                        }
                }
                def := ft.Tag.Get("default")
                if NonPointerType(ft.Type).Kind() == reflect.Struct && def == "" {
                        sfm := NonDefaultFields(fv.Interface())
                        if len(sfm) > 0 {
                                res[ft.Name] = sfm
                        }
                        continue
                }
                if !ValueIsDefault(fv, def) {
                        res[ft.Name] = fv.Interface()
                }
        }
        return res
}

// FormatDefault converts the given `default:` struct tag string into a format suitable
// for being used as a value in [SetRobust]. If it returns "", the default value
// should not be used.
func FormatDefault(def string) string {
        if def == "" {
                return ""
        }
        if strings.ContainsAny(def, "{[") { // complex type, so don't split on commas and colons
                return strings.ReplaceAll(def, `'`, `"`) // allow single quote to work as double quote for JSON format
        }
        // we split on commas and colons so we get the first item of lists and ranges
        def = strings.Split(def, ",")[0]
        def = strings.Split(def, ":")[0]
        return def
}

// StructTags returns a map[string]string of the tag string from a [reflect.StructTag] value.
func StructTags(tags reflect.StructTag) map[string]string {
        if len(tags) == 0 {
                return nil
        }
        flds := strings.Fields(string(tags))
        smap := make(map[string]string, len(flds))
        for _, fld := range flds {
                cli := strings.Index(fld, ":")
                if cli < 0 || len(fld) < cli+3 {
                        continue
                }
                vl := strings.TrimSuffix(fld[cli+2:], `"`)
                smap[fld[:cli]] = vl
        }
        return smap
}

// StringJSON returns an indented JSON string representation
// of the given value for printing/debugging.
func StringJSON(v any) string {
        return string(errors.Log1(jsonx.WriteBytesIndent(v)))
}

// FieldByPath returns the [reflect.Value] of given field within given struct value,
// where the field can be a path with . separators, for fields within struct fields.
func FieldByPath(s reflect.Value, fieldPath string) (reflect.Value, error) {
        sv := Underlying(s)
        if sv.Kind() != reflect.Struct {
                return reflect.Value{}, errors.New("reflectx.FieldByPath: kind is not struct")
        }
        fps := strings.Split(fieldPath, ".")
        for _, fp := range fps {
                fv := sv.FieldByName(fp)
                if !fv.IsValid() {
                        return reflect.Value{}, errors.New("reflectx.FieldByPath: field name not found: " + fp)
                }
                sv = fv
        }
        return sv, nil
}

// CopyFields copies the named fields from src struct into dest struct.
// Fields can be paths with . separators for sub-fields of fields.
func CopyFields(dest, src any, fields ...string) error {
        dsv := Underlying(reflect.ValueOf(dest))
        if dsv.Kind() != reflect.Struct {
                return errors.New("reflectx.CopyFields: destination kind is not struct")
        }
        ssv := Underlying(reflect.ValueOf(src))
        if ssv.Kind() != reflect.Struct {
                return errors.New("reflectx.CopyFields: source kind is not struct")
        }
        var errs []error
        for _, f := range fields {
                dfv, err := FieldByPath(dsv, f)
                if err != nil {
                        errs = append(errs, err)
                        continue
                }
                sfv, err := FieldByPath(ssv, f)
                if err != nil {
                        errs = append(errs, err)
                        continue
                }
                err = SetRobust(PointerValue(dfv).Interface(), sfv.Interface())
                if err != nil {
                        errs = append(errs, err)
                        continue
                }
        }
        return errors.Join(errs...)
}

// SetFieldsFromMap sets given map[string]any values to fields of given object,
// where the map keys are field paths (with . delimiters for sub-field paths).
// The value can be any appropriate type that applies to the given field.
// It prints a message if a parameter fails to be set, and returns an error.
func SetFieldsFromMap(obj any, vals map[string]any) error {
        objv := reflect.ValueOf(obj)
        npv := NonPointerValue(objv)
        if npv.Kind() == reflect.Map {
                err := CopyMapRobust(obj, vals)
                if errors.Log(err) != nil {
                        return err
                }
        }
        var errs []error
        for k, v := range vals {
                fld, err := FieldByPath(objv, k)
                if err != nil {
                        errs = append(errs, err)
                }
                err = SetRobust(PointerValue(fld).Interface(), v)
                if err != nil {
                        err = errors.Log(fmt.Errorf("SetFieldsFromMap: was not able to apply value: %v to field: %s", v, k))
                        errs = append(errs, err)
                }
        }
        return errors.Join(errs...)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package reflectx

import (
        "path"
        "reflect"
)

// LongTypeName returns the long, full package-path qualified type name.
// This is guaranteed to be unique and used for internal storage of
// several maps to avoid any conflicts.  It is also very quick to compute.
func LongTypeName(typ reflect.Type) string {
        nptyp := NonPointerType(typ)
        nm := nptyp.Name()
        if nm != "" {
                p := nptyp.PkgPath()
                if p != "" {
                        return p + "." + nm
                }
                return nm
        }
        return typ.String()
}

// ShortTypeName returns the short version of a package-qualified type name
// which just has the last element of the path.  This is what is used in
// standard Go programming, and is is used for the key to lookup reflect.Type
// names -- i.e., this is what you should save in a JSON file.
// The potential naming conflict is worth the brevity, and typically a given
// file will only contain mutually compatible, non-conflicting types.
// This is cached in ShortNames because the path.Base computation is apparently
// a bit slow.
func ShortTypeName(typ reflect.Type) string {
        nptyp := NonPointerType(typ)
        nm := nptyp.Name()
        if nm != "" {
                p := nptyp.PkgPath()
                if p != "" {
                        return path.Base(p) + "." + nm
                }
                return nm
        }
        return typ.String()
}

// CloneToType creates a new pointer to the given type
// and uses [SetRobust] to copy an existing value
// (of potentially another type) to it.
func CloneToType(typ reflect.Type, val any) reflect.Value {
        vn := reflect.New(typ)
        evi := vn.Interface()
        SetRobust(evi, val)
        return vn
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package reflectx provides a collection of helpers for the reflect
// package in the Go standard library.
package reflectx

import (
        "encoding/json"
        "fmt"
        "image"
        "image/color"
        "reflect"
        "strconv"
        "time"

        "cogentcore.org/core/base/bools"
        "cogentcore.org/core/base/elide"
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/enums"
)

// IsNil returns whether the given value is nil or invalid.
// If it is a non-nillable type, it does not check whether
// it is nil to avoid panics.
func IsNil(v reflect.Value) bool {
        if !v.IsValid() {
                return true
        }
        switch v.Kind() {
        case reflect.Pointer, reflect.Interface, reflect.Map, reflect.Slice, reflect.Func, reflect.Chan:
                return v.IsNil()
        }
        return false
}

// KindIsBasic returns whether the given [reflect.Kind] is a basic,
// elemental type such as Int, Float, etc.
func KindIsBasic(vk reflect.Kind) bool {
        return vk >= reflect.Bool && vk <= reflect.Complex128
}

// KindIsNumber returns whether the given [reflect.Kind] is a numeric
// type such as Int, Float, etc.
func KindIsNumber(vk reflect.Kind) bool {
        return vk >= reflect.Int && vk <= reflect.Complex128
}

// KindIsInt returns whether the given [reflect.Kind] is an int
// type such as int, int32 etc.
func KindIsInt(vk reflect.Kind) bool {
        return vk >= reflect.Int && vk <= reflect.Uintptr
}

// KindIsFloat returns whether the given [reflect.Kind] is a
// float32 or float64.
func KindIsFloat(vk reflect.Kind) bool {
        return vk >= reflect.Float32 && vk <= reflect.Float64
}

// ToBool robustly converts to a bool any basic elemental type
// (including pointers to such) using a big type switch organized
// for greatest efficiency. It tries the [bools.Booler]
// interface if not a bool type. It falls back on reflection when all
// else fails.
func ToBool(v any) (bool, error) {
        switch vt := v.(type) {
        case bool:
                return vt, nil
        case *bool:
                if vt == nil {
                        return false, errors.New("got nil *bool")
                }
                return *vt, nil
        }

        if br, ok := v.(bools.Booler); ok {
                return br.Bool(), nil
        }

        switch vt := v.(type) {
        case int:
                return vt != 0, nil
        case *int:
                if vt == nil {
                        return false, errors.New("got nil *int")
                }
                return *vt != 0, nil
        case int32:
                return vt != 0, nil
        case *int32:
                if vt == nil {
                        return false, errors.New("got nil *int32")
                }
                return *vt != 0, nil
        case int64:
                return vt != 0, nil
        case *int64:
                if vt == nil {
                        return false, errors.New("got nil *int64")
                }
                return *vt != 0, nil
        case uint8:
                return vt != 0, nil
        case *uint8:
                if vt == nil {
                        return false, errors.New("got nil *uint8")
                }
                return *vt != 0, nil
        case float64:
                return vt != 0, nil
        case *float64:
                if vt == nil {
                        return false, errors.New("got nil *float64")
                }
                return *vt != 0, nil
        case float32:
                return vt != 0, nil
        case *float32:
                if vt == nil {
                        return false, errors.New("got nil *float32")
                }
                return *vt != 0, nil
        case string:
                r, err := strconv.ParseBool(vt)
                if err != nil {
                        return false, err
                }
                return r, nil
        case *string:
                if vt == nil {
                        return false, errors.New("got nil *string")
                }
                r, err := strconv.ParseBool(*vt)
                if err != nil {
                        return false, err
                }
                return r, nil
        case int8:
                return vt != 0, nil
        case *int8:
                if vt == nil {
                        return false, errors.New("got nil *int8")
                }
                return *vt != 0, nil
        case int16:
                return vt != 0, nil
        case *int16:
                if vt == nil {
                        return false, errors.New("got nil *int16")
                }
                return *vt != 0, nil
        case uint:
                return vt != 0, nil
        case *uint:
                if vt == nil {
                        return false, errors.New("got nil *uint")
                }
                return *vt != 0, nil
        case uint16:
                return vt != 0, nil
        case *uint16:
                if vt == nil {
                        return false, errors.New("got nil *uint16")
                }
                return *vt != 0, nil
        case uint32:
                return vt != 0, nil
        case *uint32:
                if vt == nil {
                        return false, errors.New("got nil *uint32")
                }
                return *vt != 0, nil
        case uint64:
                return vt != 0, nil
        case *uint64:
                if vt == nil {
                        return false, errors.New("got nil *uint64")
                }
                return *vt != 0, nil
        case uintptr:
                return vt != 0, nil
        case *uintptr:
                if vt == nil {
                        return false, errors.New("got nil *uintptr")
                }
                return *vt != 0, nil
        }

        // then fall back on reflection
        uv := Underlying(reflect.ValueOf(v))
        if IsNil(uv) {
                return false, fmt.Errorf("got nil value of type %T", v)
        }
        vk := uv.Kind()
        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                return (uv.Int() != 0), nil
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                return (uv.Uint() != 0), nil
        case vk == reflect.Bool:
                return uv.Bool(), nil
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                return (uv.Float() != 0.0), nil
        case vk >= reflect.Complex64 && vk <= reflect.Complex128:
                return (real(uv.Complex()) != 0.0), nil
        case vk == reflect.String:
                r, err := strconv.ParseBool(uv.String())
                if err != nil {
                        return false, err
                }
                return r, nil
        default:
                return false, fmt.Errorf("got value %v of unsupported type %T", v, v)
        }
}

// ToInt robustly converts to an int64 any basic elemental type
// (including pointers to such) using a big type switch organized
// for greatest efficiency, only falling back on reflection when all
// else fails.
func ToInt(v any) (int64, error) {
        switch vt := v.(type) {
        case int:
                return int64(vt), nil
        case *int:
                if vt == nil {
                        return 0, errors.New("got nil *int")
                }
                return int64(*vt), nil
        case int32:
                return int64(vt), nil
        case *int32:
                if vt == nil {
                        return 0, errors.New("got nil *int32")
                }
                return int64(*vt), nil
        case int64:
                return vt, nil
        case *int64:
                if vt == nil {
                        return 0, errors.New("got nil *int64")
                }
                return *vt, nil
        case uint8:
                return int64(vt), nil
        case *uint8:
                if vt == nil {
                        return 0, errors.New("got nil *uint8")
                }
                return int64(*vt), nil
        case float64:
                return int64(vt), nil
        case *float64:
                if vt == nil {
                        return 0, errors.New("got nil *float64")
                }
                return int64(*vt), nil
        case float32:
                return int64(vt), nil
        case *float32:
                if vt == nil {
                        return 0, errors.New("got nil *float32")
                }
                return int64(*vt), nil
        case bool:
                if vt {
                        return 1, nil
                }
                return 0, nil
        case *bool:
                if vt == nil {
                        return 0, errors.New("got nil *bool")
                }
                if *vt {
                        return 1, nil
                }
                return 0, nil
        case string:
                r, err := strconv.ParseInt(vt, 0, 64)
                if err != nil {
                        return 0, err
                }
                return r, nil
        case *string:
                if vt == nil {
                        return 0, errors.New("got nil *string")
                }
                r, err := strconv.ParseInt(*vt, 0, 64)
                if err != nil {
                        return 0, err
                }
                return r, nil
        case enums.Enum:
                return vt.Int64(), nil
        case int8:
                return int64(vt), nil
        case *int8:
                if vt == nil {
                        return 0, errors.New("got nil *int8")
                }
                return int64(*vt), nil
        case int16:
                return int64(vt), nil
        case *int16:
                if vt == nil {
                        return 0, errors.New("got nil *int16")
                }
                return int64(*vt), nil
        case uint:
                return int64(vt), nil
        case *uint:
                if vt == nil {
                        return 0, errors.New("got nil *uint")
                }
                return int64(*vt), nil
        case uint16:
                return int64(vt), nil
        case *uint16:
                if vt == nil {
                        return 0, errors.New("got nil *uint16")
                }
                return int64(*vt), nil
        case uint32:
                return int64(vt), nil
        case *uint32:
                if vt == nil {
                        return 0, errors.New("got nil *uint32")
                }
                return int64(*vt), nil
        case uint64:
                return int64(vt), nil
        case *uint64:
                if vt == nil {
                        return 0, errors.New("got nil *uint64")
                }
                return int64(*vt), nil
        case uintptr:
                return int64(vt), nil
        case *uintptr:
                if vt == nil {
                        return 0, errors.New("got nil *uintptr")
                }
                return int64(*vt), nil
        }

        // then fall back on reflection
        uv := Underlying(reflect.ValueOf(v))
        if IsNil(uv) {
                return 0, fmt.Errorf("got nil value of type %T", v)
        }
        vk := uv.Kind()
        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                return uv.Int(), nil
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                return int64(uv.Uint()), nil
        case vk == reflect.Bool:
                if uv.Bool() {
                        return 1, nil
                }
                return 0, nil
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                return int64(uv.Float()), nil
        case vk >= reflect.Complex64 && vk <= reflect.Complex128:
                return int64(real(uv.Complex())), nil
        case vk == reflect.String:
                r, err := strconv.ParseInt(uv.String(), 0, 64)
                if err != nil {
                        return 0, err
                }
                return r, nil
        default:
                return 0, fmt.Errorf("got value %v of unsupported type %T", v, v)
        }
}

// ToFloat robustly converts to a float64 any basic elemental type
// (including pointers to such) using a big type switch organized for
// greatest efficiency, only falling back on reflection when all else fails.
func ToFloat(v any) (float64, error) {
        switch vt := v.(type) {
        case float64:
                return vt, nil
        case *float64:
                if vt == nil {
                        return 0, errors.New("got nil *float64")
                }
                return *vt, nil
        case float32:
                return float64(vt), nil
        case *float32:
                if vt == nil {
                        return 0, errors.New("got nil *float32")
                }
                return float64(*vt), nil
        case int:
                return float64(vt), nil
        case *int:
                if vt == nil {
                        return 0, errors.New("got nil *int")
                }
                return float64(*vt), nil
        case int32:
                return float64(vt), nil
        case *int32:
                if vt == nil {
                        return 0, errors.New("got nil *int32")
                }
                return float64(*vt), nil
        case int64:
                return float64(vt), nil
        case *int64:
                if vt == nil {
                        return 0, errors.New("got nil *int64")
                }
                return float64(*vt), nil
        case uint8:
                return float64(vt), nil
        case *uint8:
                if vt == nil {
                        return 0, errors.New("got nil *uint8")
                }
                return float64(*vt), nil
        case bool:
                if vt {
                        return 1, nil
                }
                return 0, nil
        case *bool:
                if vt == nil {
                        return 0, errors.New("got nil *bool")
                }
                if *vt {
                        return 1, nil
                }
                return 0, nil
        case string:
                r, err := strconv.ParseFloat(vt, 64)
                if err != nil {
                        return 0.0, err
                }
                return r, nil
        case *string:
                if vt == nil {
                        return 0, errors.New("got nil *string")
                }
                r, err := strconv.ParseFloat(*vt, 64)
                if err != nil {
                        return 0.0, err
                }
                return r, nil
        case int8:
                return float64(vt), nil
        case *int8:
                if vt == nil {
                        return 0, errors.New("got nil *int8")
                }
                return float64(*vt), nil
        case int16:
                return float64(vt), nil
        case *int16:
                if vt == nil {
                        return 0, errors.New("got nil *int16")
                }
                return float64(*vt), nil
        case uint:
                return float64(vt), nil
        case *uint:
                if vt == nil {
                        return 0, errors.New("got nil *uint")
                }
                return float64(*vt), nil
        case uint16:
                return float64(vt), nil
        case *uint16:
                if vt == nil {
                        return 0, errors.New("got nil *uint16")
                }
                return float64(*vt), nil
        case uint32:
                return float64(vt), nil
        case *uint32:
                if vt == nil {
                        return 0, errors.New("got nil *uint32")
                }
                return float64(*vt), nil
        case uint64:
                return float64(vt), nil
        case *uint64:
                if vt == nil {
                        return 0, errors.New("got nil *uint64")
                }
                return float64(*vt), nil
        case uintptr:
                return float64(vt), nil
        case *uintptr:
                if vt == nil {
                        return 0, errors.New("got nil *uintptr")
                }
                return float64(*vt), nil
        }

        // then fall back on reflection
        uv := Underlying(reflect.ValueOf(v))
        if IsNil(uv) {
                return 0, fmt.Errorf("got nil value of type %T", v)
        }
        vk := uv.Kind()
        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                return float64(uv.Int()), nil
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                return float64(uv.Uint()), nil
        case vk == reflect.Bool:
                if uv.Bool() {
                        return 1, nil
                }
                return 0, nil
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                return uv.Float(), nil
        case vk >= reflect.Complex64 && vk <= reflect.Complex128:
                return real(uv.Complex()), nil
        case vk == reflect.String:
                r, err := strconv.ParseFloat(uv.String(), 64)
                if err != nil {
                        return 0, err
                }
                return r, nil
        default:
                return 0, fmt.Errorf("got value %v of unsupported type %T", v, v)
        }
}

// ToFloat32 robustly converts to a float32 any basic elemental type
// (including pointers to such) using a big type switch organized for
// greatest efficiency, only falling back on reflection when all else fails.
func ToFloat32(v any) (float32, error) {
        switch vt := v.(type) {
        case float32:
                return vt, nil
        case *float32:
                if vt == nil {
                        return 0, errors.New("got nil *float32")
                }
                return *vt, nil
        case float64:
                return float32(vt), nil
        case *float64:
                if vt == nil {
                        return 0, errors.New("got nil *float64")
                }
                return float32(*vt), nil
        case int:
                return float32(vt), nil
        case *int:
                if vt == nil {
                        return 0, errors.New("got nil *int")
                }
                return float32(*vt), nil
        case int32:
                return float32(vt), nil
        case *int32:
                if vt == nil {
                        return 0, errors.New("got nil *int32")
                }
                return float32(*vt), nil
        case int64:
                return float32(vt), nil
        case *int64:
                if vt == nil {
                        return 0, errors.New("got nil *int64")
                }
                return float32(*vt), nil
        case uint8:
                return float32(vt), nil
        case *uint8:
                if vt == nil {
                        return 0, errors.New("got nil *uint8")
                }
                return float32(*vt), nil
        case bool:
                if vt {
                        return 1, nil
                }
                return 0, nil
        case *bool:
                if vt == nil {
                        return 0, errors.New("got nil *bool")
                }
                if *vt {
                        return 1, nil
                }
                return 0, nil
        case string:
                r, err := strconv.ParseFloat(vt, 32)
                if err != nil {
                        return 0, err
                }
                return float32(r), nil
        case *string:
                if vt == nil {
                        return 0, errors.New("got nil *string")
                }
                r, err := strconv.ParseFloat(*vt, 32)
                if err != nil {
                        return 0, err
                }
                return float32(r), nil
        case int8:
                return float32(vt), nil
        case *int8:
                if vt == nil {
                        return 0, errors.New("got nil *int8")
                }
                return float32(*vt), nil
        case int16:
                return float32(vt), nil
        case *int16:
                if vt == nil {
                        return 0, errors.New("got nil *int8")
                }
                return float32(*vt), nil
        case uint:
                return float32(vt), nil
        case *uint:
                if vt == nil {
                        return 0, errors.New("got nil *uint")
                }
                return float32(*vt), nil
        case uint16:
                return float32(vt), nil
        case *uint16:
                if vt == nil {
                        return 0, errors.New("got nil *uint16")
                }
                return float32(*vt), nil
        case uint32:
                return float32(vt), nil
        case *uint32:
                if vt == nil {
                        return 0, errors.New("got nil *uint32")
                }
                return float32(*vt), nil
        case uint64:
                return float32(vt), nil
        case *uint64:
                if vt == nil {
                        return 0, errors.New("got nil *uint64")
                }
                return float32(*vt), nil
        case uintptr:
                return float32(vt), nil
        case *uintptr:
                if vt == nil {
                        return 0, errors.New("got nil *uintptr")
                }
                return float32(*vt), nil
        }

        // then fall back on reflection
        uv := Underlying(reflect.ValueOf(v))
        if IsNil(uv) {
                return 0, fmt.Errorf("got nil value of type %T", v)
        }
        vk := uv.Kind()
        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                return float32(uv.Int()), nil
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                return float32(uv.Uint()), nil
        case vk == reflect.Bool:
                if uv.Bool() {
                        return 1, nil
                }
                return 0, nil
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                return float32(uv.Float()), nil
        case vk >= reflect.Complex64 && vk <= reflect.Complex128:
                return float32(real(uv.Complex())), nil
        case vk == reflect.String:
                r, err := strconv.ParseFloat(uv.String(), 32)
                if err != nil {
                        return 0, err
                }
                return float32(r), nil
        default:
                return 0, fmt.Errorf("got value %v of unsupported type %T", v, v)
        }
}

// ToString robustly converts anything to a String
// using a big type switch organized for greatest efficiency.
// First checks for string or []byte and returns that immediately,
// then checks for the Stringer interface as the preferred conversion
// (e.g., for enums), and then falls back on strconv calls for numeric types.
// If everything else fails, it uses fmt.Sprintf("%v") which always works,
// so there is no need for an error return value. It returns "nil" for any nil
// pointers, and byte is converted as string(byte), not the decimal representation.
func ToString(v any) string {
        nilstr := "nil"
        // TODO: this reflection is unideal for performance, but we need it to prevent panics,
        // so this whole "greatest efficiency" type switch is kind of pointless.
        rv := reflect.ValueOf(v)
        if IsNil(rv) {
                return nilstr
        }
        switch vt := v.(type) {
        case string:
                return vt
        case *string:
                if vt == nil {
                        return nilstr
                }
                return *vt
        case []byte:
                return string(vt)
        case *[]byte:
                if vt == nil {
                        return nilstr
                }
                return string(*vt)
        }

        if stringer, ok := v.(fmt.Stringer); ok {
                return stringer.String()
        }

        switch vt := v.(type) {
        case bool:
                if vt {
                        return "true"
                }
                return "false"
        case *bool:
                if vt == nil {
                        return nilstr
                }
                if *vt {
                        return "true"
                }
                return "false"
        case int:
                return strconv.FormatInt(int64(vt), 10)
        case *int:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(int64(*vt), 10)
        case int32:
                return strconv.FormatInt(int64(vt), 10)
        case *int32:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(int64(*vt), 10)
        case int64:
                return strconv.FormatInt(vt, 10)
        case *int64:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(*vt, 10)
        case uint8: // byte, converts as string char
                return string(vt)
        case *uint8:
                if vt == nil {
                        return nilstr
                }
                return string(*vt)
        case float64:
                return strconv.FormatFloat(vt, 'G', -1, 64)
        case *float64:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatFloat(*vt, 'G', -1, 64)
        case float32:
                return strconv.FormatFloat(float64(vt), 'G', -1, 32)
        case *float32:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatFloat(float64(*vt), 'G', -1, 32)
        case uintptr:
                return fmt.Sprintf("%#x", uintptr(vt))
        case *uintptr:
                if vt == nil {
                        return nilstr
                }
                return fmt.Sprintf("%#x", uintptr(*vt))

        case int8:
                return strconv.FormatInt(int64(vt), 10)
        case *int8:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(int64(*vt), 10)
        case int16:
                return strconv.FormatInt(int64(vt), 10)
        case *int16:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(int64(*vt), 10)
        case uint:
                return strconv.FormatInt(int64(vt), 10)
        case *uint:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(int64(*vt), 10)
        case uint16:
                return strconv.FormatInt(int64(vt), 10)
        case *uint16:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(int64(*vt), 10)
        case uint32:
                return strconv.FormatInt(int64(vt), 10)
        case *uint32:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(int64(*vt), 10)
        case uint64:
                return strconv.FormatInt(int64(vt), 10)
        case *uint64:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatInt(int64(*vt), 10)
        case complex64:
                return strconv.FormatFloat(float64(real(vt)), 'G', -1, 32) + "," + strconv.FormatFloat(float64(imag(vt)), 'G', -1, 32)
        case *complex64:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatFloat(float64(real(*vt)), 'G', -1, 32) + "," + strconv.FormatFloat(float64(imag(*vt)), 'G', -1, 32)
        case complex128:
                return strconv.FormatFloat(real(vt), 'G', -1, 64) + "," + strconv.FormatFloat(imag(vt), 'G', -1, 64)
        case *complex128:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatFloat(real(*vt), 'G', -1, 64) + "," + strconv.FormatFloat(imag(*vt), 'G', -1, 64)
        }

        // then fall back on reflection
        uv := Underlying(rv)
        if IsNil(uv) {
                return nilstr
        }
        vk := uv.Kind()
        switch {
        case vk >= reflect.Int && vk <= reflect.Int64:
                return strconv.FormatInt(uv.Int(), 10)
        case vk >= reflect.Uint && vk <= reflect.Uint64:
                return strconv.FormatUint(uv.Uint(), 10)
        case vk == reflect.Bool:
                return strconv.FormatBool(uv.Bool())
        case vk >= reflect.Float32 && vk <= reflect.Float64:
                return strconv.FormatFloat(uv.Float(), 'G', -1, 64)
        case vk >= reflect.Complex64 && vk <= reflect.Complex128:
                cv := uv.Complex()
                rv := strconv.FormatFloat(real(cv), 'G', -1, 64) + "," + strconv.FormatFloat(imag(cv), 'G', -1, 64)
                return rv
        case vk == reflect.String:
                return uv.String()
        case vk == reflect.Slice:
                eltyp := SliceElementType(v)
                if eltyp.Kind() == reflect.Uint8 { // []byte
                        return string(v.([]byte))
                }
                fallthrough
        default:
                return fmt.Sprintf("%v", v)
        }
}

// ToStringPrec robustly converts anything to a String using given precision
// for converting floating values; using a value like 6 truncates the
// nuisance random imprecision of actual floating point values due to the
// fact that they are represented with binary bits.
// Otherwise is identical to ToString for any other cases.
func ToStringPrec(v any, prec int) string {
        nilstr := "nil"
        switch vt := v.(type) {
        case string:
                return vt
        case *string:
                if vt == nil {
                        return nilstr
                }
                return *vt
        case []byte:
                return string(vt)
        case *[]byte:
                if vt == nil {
                        return nilstr
                }
                return string(*vt)
        }

        if stringer, ok := v.(fmt.Stringer); ok {
                return stringer.String()
        }

        switch vt := v.(type) {
        case float64:
                return strconv.FormatFloat(vt, 'G', prec, 64)
        case *float64:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatFloat(*vt, 'G', prec, 64)
        case float32:
                return strconv.FormatFloat(float64(vt), 'G', prec, 32)
        case *float32:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatFloat(float64(*vt), 'G', prec, 32)
        case complex64:
                return strconv.FormatFloat(float64(real(vt)), 'G', prec, 32) + "," + strconv.FormatFloat(float64(imag(vt)), 'G', prec, 32)
        case *complex64:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatFloat(float64(real(*vt)), 'G', prec, 32) + "," + strconv.FormatFloat(float64(imag(*vt)), 'G', prec, 32)
        case complex128:
                return strconv.FormatFloat(real(vt), 'G', prec, 64) + "," + strconv.FormatFloat(imag(vt), 'G', prec, 64)
        case *complex128:
                if vt == nil {
                        return nilstr
                }
                return strconv.FormatFloat(real(*vt), 'G', prec, 64) + "," + strconv.FormatFloat(imag(*vt), 'G', prec, 64)
        }
        return ToString(v)
}

// SetRobust robustly sets the 'to' value from the 'from' value.
// The 'to' value must be a pointer. It copies slices and maps robustly,
// and it can set a struct, slice, or map from a JSON-formatted string
// value. It also handles many other cases, so it is unlikely to fail.
//
// Note that maps are not reset prior to setting, whereas slices are
// set to be fully equivalent to the source slice.
func SetRobust(to, from any) error {
        rto := reflect.ValueOf(to)
        pto := UnderlyingPointer(rto)
        if IsNil(pto) {
                // If the original value is a non-nil pointer, we can just use it
                // even though the underlying pointer is nil (this happens when there
                // is a pointer to a nil pointer; see #1365).
                if !IsNil(rto) && rto.Kind() == reflect.Pointer {
                        pto = rto
                } else {
                        // Otherwise, we cannot recover any meaningful value.
                        return errors.New("got nil destination value")
                }
        }
        pito := pto.Interface()

        totyp := pto.Elem().Type()
        tokind := totyp.Kind()
        if !pto.Elem().CanSet() {
                return fmt.Errorf("destination value cannot be set; it must be a variable or field, not a const or tmp or other value that cannot be set (value: %v of type %T)", pto, pto)
        }

        // images should not be copied per content: just set the pointer!
        // otherwise the original images (esp colors!) are altered.
        // TODO: #1394 notes the more general ambiguity about deep vs. shallow pointer copy.
        if img, ok := to.(*image.Image); ok {
                if fimg, ok := from.(image.Image); ok {
                        *img = fimg
                        return nil
                }
        }

        // first we do the generic AssignableTo case
        if rto.Kind() == reflect.Pointer {
                fv := reflect.ValueOf(from)
                if fv.IsValid() {
                        if fv.Type().AssignableTo(totyp) {
                                pto.Elem().Set(fv)
                                return nil
                        }
                        ufvp := UnderlyingPointer(fv)
                        if ufvp.IsValid() && ufvp.Type().AssignableTo(totyp) {
                                pto.Elem().Set(ufvp)
                                return nil
                        }
                        ufv := ufvp.Elem()
                        if ufv.IsValid() && ufv.Type().AssignableTo(totyp) {
                                pto.Elem().Set(ufv)
                                return nil
                        }
                } else {
                        return nil
                }
        }

        if sa, ok := pito.(SetAnyer); ok {
                err := sa.SetAny(from)
                if err != nil {
                        return err
                }
                return nil
        }
        if ss, ok := pito.(SetStringer); ok {
                if s, ok := from.(string); ok {
                        err := ss.SetString(s)
                        if err != nil {
                                return err
                        }
                        return nil
                }
        }
        if es, ok := pito.(enums.EnumSetter); ok {
                if en, ok := from.(enums.Enum); ok {
                        es.SetInt64(en.Int64())
                        return nil
                }
                if str, ok := from.(string); ok {
                        return es.SetString(str)
                }
                fm, err := ToInt(from)
                if err != nil {
                        return err
                }
                es.SetInt64(fm)
                return nil
        }

        if bv, ok := pito.(bools.BoolSetter); ok {
                fb, err := ToBool(from)
                if err != nil {
                        return err
                }
                bv.SetBool(fb)
                return nil
        }
        if td, ok := pito.(*time.Duration); ok {
                if fs, ok := from.(string); ok {
                        fd, err := time.ParseDuration(fs)
                        if err != nil {
                                return err
                        }
                        *td = fd
                        return nil
                }
        }

        if fc, err := colors.FromAny(from); err == nil {
                switch c := pito.(type) {
                case *color.RGBA:
                        *c = fc
                        return nil
                case *image.Uniform:
                        c.C = fc
                        return nil
                case SetColorer:
                        c.SetColor(fc)
                        return nil
                case *image.Image:
                        *c = colors.Uniform(fc)
                        return nil
                }
        }

        ftyp := NonPointerType(reflect.TypeOf(from))

        switch {
        case tokind >= reflect.Int && tokind <= reflect.Int64:
                fm, err := ToInt(from)
                if err != nil {
                        return err
                }
                pto.Elem().Set(reflect.ValueOf(fm).Convert(totyp))
                return nil
        case tokind >= reflect.Uint && tokind <= reflect.Uint64:
                fm, err := ToInt(from)
                if err != nil {
                        return err
                }
                pto.Elem().Set(reflect.ValueOf(fm).Convert(totyp))
                return nil
        case tokind == reflect.Bool:
                fm, err := ToBool(from)
                if err != nil {
                        return err
                }
                pto.Elem().Set(reflect.ValueOf(fm).Convert(totyp))
                return nil
        case tokind >= reflect.Float32 && tokind <= reflect.Float64:
                fm, err := ToFloat(from)
                if err != nil {
                        return err
                }
                pto.Elem().Set(reflect.ValueOf(fm).Convert(totyp))
                return nil
        case tokind == reflect.String:
                fm := ToString(from)
                pto.Elem().Set(reflect.ValueOf(fm).Convert(totyp))
                return nil
        case tokind == reflect.Struct:
                if ftyp.Kind() == reflect.String {
                        err := json.Unmarshal([]byte(ToString(from)), to) // todo: this is not working -- see what marshal says, etc
                        if err != nil {
                                marsh, _ := json.Marshal(to)
                                return fmt.Errorf("error setting struct from string: %w (example format for string: %s)", err, string(marsh))
                        }
                        return nil
                }
        case tokind == reflect.Slice:
                if ftyp.Kind() == reflect.String {
                        err := json.Unmarshal([]byte(ToString(from)), to)
                        if err != nil {
                                marsh, _ := json.Marshal(to)
                                return fmt.Errorf("error setting slice from string: %w (example format for string: %s)", err, string(marsh))
                        }
                        return nil
                }
                return CopySliceRobust(to, from)
        case tokind == reflect.Map:
                if ftyp.Kind() == reflect.String {
                        err := json.Unmarshal([]byte(ToString(from)), to)
                        if err != nil {
                                marsh, _ := json.Marshal(to)
                                return fmt.Errorf("error setting map from string: %w (example format for string: %s)", err, string(marsh))
                        }
                        return nil
                }
                return CopyMapRobust(to, from)
        }

        tos := elide.End(fmt.Sprintf("%v", to), 40)
        fms := elide.End(fmt.Sprintf("%v", from), 40)
        return fmt.Errorf("unable to set value %s of type %T (using underlying type: %s) from value %s of type %T (using underlying type: %s): not a supported type pair and direct assigning is not possible", tos, to, totyp.String(), fms, from, LongTypeName(Underlying(reflect.ValueOf(from)).Type()))
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package slicesx provides additional slice functions
// beyond those in the standard [slices] package.
package slicesx

import (
        "slices"
        "unsafe"
)

// GrowTo increases the slice's capacity, if necessary,
// so that it can hold at least n elements.
func GrowTo[S ~[]E, E any](s S, n int) S {
        if n < 0 {
                panic("cannot be negative")
        }
        if n -= cap(s); n > 0 {
                s = append(s[:cap(s)], make([]E, n)...)[:len(s)]
        }
        return s
}

// SetLength sets the length of the given slice,
// re-using and preserving existing values to the extent possible.
func SetLength[E any](s []E, n int) []E {
        if len(s) == n {
                return s
        }
        if s == nil {
                return make([]E, n)
        }
        if cap(s) < n {
                s = GrowTo(s, n)
        }
        s = s[:n]
        return s
}

// CopyFrom efficiently copies from src into dest, using SetLength
// to ensure the destination has sufficient capacity, and returns
// the destination (which may have changed location as a result).
func CopyFrom[E any](dest []E, src []E) []E {
        dest = SetLength(dest, len(src))
        copy(dest, src)
        return dest
}

// Move moves the element in the given slice at the given
// old position to the given new position and returns the
// resulting slice.
func Move[E any](s []E, from, to int) []E {
        temp := s[from]
        s = slices.Delete(s, from, from+1)
        s = slices.Insert(s, to, temp)
        return s
}

// Swap swaps the elements at the given two indices in the given slice.
func Swap[E any](s []E, i, j int) {
        s[i], s[j] = s[j], s[i]
}

// As converts a slice of the given type to a slice of the other given type.
// The underlying types of the slice elements must be equivalent.
func As[F, T any](s []F) []T {
        as := make([]T, len(s))
        for i, v := range s {
                as[i] = any(v).(T)
        }
        return as
}

// Search returns the index of the item in the given slice that matches the target
// according to the given match function, using the given optional starting index
// to optimize the search by searching bidirectionally outward from given index.
// This is much faster when you have some idea about where the item might be.
// If no start index is given, it starts in the middle, which is a good default.
// It returns -1 if no item matching the match function is found.
func Search[E any](slice []E, match func(e E) bool, startIndex ...int) int {
        n := len(slice)
        if n == 0 {
                return -1
        }
        si := -1
        if len(startIndex) > 0 {
                si = startIndex[0]
        }
        if si < 0 {
                si = n / 2
        }
        if si == 0 {
                for idx, e := range slice {
                        if match(e) {
                                return idx
                        }
                }
        } else {
                if si >= n {
                        si = n - 1
                }
                ui := si + 1
                di := si
                upo := false
                for {
                        if !upo && ui < n {
                                if match(slice[ui]) {
                                        return ui
                                }
                                ui++
                        } else {
                                upo = true
                        }
                        if di >= 0 {
                                if match(slice[di]) {
                                        return di
                                }
                                di--
                        } else if upo {
                                break
                        }
                }
        }
        return -1
}

// ToBytes returns the underlying bytes of given slice.
// for items not in a slice, make one of length 1.
// This is copied from webgpu.
func ToBytes[E any](src []E) []byte {
        l := uintptr(len(src))
        if l == 0 {
                return nil
        }
        elmSize := unsafe.Sizeof(src[0])
        return unsafe.Slice((*byte)(unsafe.Pointer(&src[0])), l*elmSize)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sshclient

import (
        "bytes"
        "errors"
        "fmt"
        "log"
        "log/slog"
        "os"
        "path/filepath"
        "strings"

        "github.com/bramvdbogaerde/go-scp"
        "golang.org/x/crypto/ssh"
        "golang.org/x/crypto/ssh/knownhosts"
)

// Client represents a persistent connection to an ssh host.
// Commands are run by creating [ssh.Session]s from this client.
type Client struct {
        Config

        // ssh client is present (non-nil) after a successful Connect
        Client *ssh.Client

        // keeps track of sessions that are being waited upon
        Sessions map[string]*ssh.Session

        // sessionCounter increments number of Sessions added
        // over the lifetime of the Client.
        sessionCounter int

        // scpClient manages scp file copying
        scpClient *scp.Client
}

// NewClient returns a new Client using given [Config] configuration
// parameters.
func NewClient(cfg *Config) *Client {
        cl := &Client{Config: *cfg}
        return cl
}

// Close terminates any open Sessions and then closes
// the Client connection.
func (cl *Client) Close() {
        cl.CloseSessions()
        if cl.Client != nil {
                cl.Client.Close()
        }
        cl.scpClient = nil
        cl.Client = nil
}

// CloseSessions terminates any open Sessions that are
// still Waiting for the associated process to finish.
func (cl *Client) CloseSessions() {
        if cl.Sessions == nil {
                return
        }
        for _, ses := range cl.Sessions {
                ses.Close()
        }
        cl.Sessions = nil
}

// Connect connects to given host, which can either be just the host
// or user@host. If host is empty, the Config default host will be used
// if non-empty, or an error is returned.
// If successful, creates a Client that can be used for
// future sessions.  Otherwise, returns error.
// This updates the Host (and User) fields in the config, for future
// reference.
func (cl *Client) Connect(host string) error {
        if host == "" {
                if cl.Host == "" {
                        return errors.New("ssh: Connect host is empty and no default host set in Config")
                }
                host = cl.Host
        }
        atidx := strings.Index(host, "@")
        if atidx > 0 {
                cl.User.User = host[:atidx]
                cl.Host = host[atidx+1:]
                host = cl.Host
        } else {
                cl.Host = host
        }

        if cl.User.KeyPath == "" {
                return fmt.Errorf("ssh: key path (%q) is empty -- must be set", cl.User.KeyPath)
        }
        fn := filepath.Join(cl.User.KeyPath, cl.User.KeyFile)
        key, err := os.ReadFile(fn)
        if err != nil {
                return fmt.Errorf("ssh: unable to read private key from: %q %v", fn, err)
        }

        // Create the Signer for this private key.
        signer, err := ssh.ParsePrivateKey(key)
        if err != nil {
                return fmt.Errorf("ssh: unable to parse private key from: %q %v", fn, err)
        }

        // more info: https://gist.github.com/Skarlso/34321a230cf0245018288686c9e70b2d
        hostKeyCallback, err := knownhosts.New(filepath.Join(cl.User.KeyPath, "known_hosts"))
        if err != nil {
                log.Fatal("ssh: could not create hostkeycallback function: ", err)
        }

        config := &ssh.ClientConfig{
                User: cl.User.User,
                Auth: []ssh.AuthMethod{
                        // Use the PublicKeys method for remote authentication.
                        ssh.PublicKeys(signer),
                },
                HostKeyCallback: hostKeyCallback,
        }

        // Connect to the remote server and perform the SSH handshake.
        client, err := ssh.Dial("tcp", host+":22", config)
        if err != nil {
                err = fmt.Errorf("ssh: unable to connect to %s as user %s: %v", host, cl.User, err)
                return err
        }

        cl.Sessions = make(map[string]*ssh.Session)
        cl.Client = client
        cl.GetHomeDir()
        return nil
}

// NewSession creates a new session, sets its input / outputs based on
// config.  Only works if Client already connected.
func (cl *Client) NewSession(interact bool) (*ssh.Session, error) {
        if cl.Client == nil {
                return nil, errors.New("ssh: no client, must Connect first")
        }
        ses, err := cl.Client.NewSession()
        if err != nil {
                return nil, err
        }
        ses.Stdout = cl.StdIO.Out
        ses.Stderr = cl.StdIO.Err
        // ses.Stdin = nil // cl.StdIO.In // todo: cannot set this like this!

        if interact {
                modes := ssh.TerminalModes{
                        ssh.ECHO:          0,     // disable echoing
                        ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
                        ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
                }
                err := ses.RequestPty("xterm", 40, 80, modes)
                if err != nil {
                        slog.Error(err.Error())
                }
        }

        return ses, nil
}

// WaitSession adds the session to list of open sessions,
// and calls Wait on it.
// It should be called in a goroutine, and will only return
// when the command is completed or terminated.
// The given name is used to save the session
// in a map, for later reference. If left blank,
// the name will be a number that increases with each
// such session created.
func (cl *Client) WaitSession(name string, ses *ssh.Session) error {
        if name == "" {
                name = fmt.Sprintf("%d", cl.sessionCounter)
        }
        cl.Sessions[name] = ses
        cl.sessionCounter++
        return ses.Wait()
}

// GetHomeDir runs "pwd" on the host to get the users home dir,
// called right after connecting.
func (cl *Client) GetHomeDir() error {
        ses, err := cl.NewSession(false)
        if err != nil {
                return err
        }
        defer ses.Close()
        buf := &bytes.Buffer{}
        ses.Stdout = buf
        err = ses.Run("pwd")
        if err != nil {
                return fmt.Errorf("ssh: unable to get home directory through pwd: %v", err)
        }
        cl.HomeDir = strings.TrimSpace(buf.String())
        cl.Dir = cl.HomeDir
        fmt.Println("home directory:", cl.HomeDir)
        return nil
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sshclient

import (
        "os/user"
        "path/filepath"

        "cogentcore.org/core/base/exec"
)

// User holds user-specific ssh connection configuration settings,
// including Key info.
type User struct {
        // user name to connect with
        User string

        // path to ssh keys: ~/.ssh by default
        KeyPath string

        // name of ssh key file in KeyPath: .pub is appended for public key
        KeyFile string `default:"id_rsa"`
}

func (us *User) Defaults() {
        us.KeyFile = "id_rsa"
        usr, err := user.Current()
        if err == nil {
                us.User = usr.Username
                us.KeyPath = filepath.Join(usr.HomeDir, ".ssh")
        }
}

// Config contains the configuration information that controls
// the behavior of ssh connections and commands. It is used
// to establish a Client connection to a remote host.
// It builds on the shared settings in [exec.Config]
type Config struct {
        exec.Config

        // user name and ssh key info
        User User

        // host name / ip address to connect to. can be blank, in which
        // case it must be specified in the Client.Connect call.
        Host string

        // home directory of user on remote host,
        // which is captured at initial connection time.
        HomeDir string

        // ScpPath is the path to the `scp` executable on the host,
        // for copying files between local and remote host.
        // Defaults to /usr/bin/scp
        ScpPath string `default:"/usr/bin/scp"`
}

// NewConfig returns a new ssh Config based on given
// [exec.Config] parameters.
func NewConfig(cfg *exec.Config) *Config {
        c := &Config{Config: *cfg}
        c.User.Defaults()
        c.Dir = "" // start empty until we get homedir
        c.ScpPath = "/usr/bin/scp"
        return c
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sshclient

import (
        "bytes"
        "os"
        "path/filepath"
        "strings"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/logx"
        "golang.org/x/crypto/ssh"
)

// Exec executes the command, piping its stdout and stderr to the config
// writers. If the command fails, it will return an error with the command output.
// The given cmd and args may include references
// to environment variables in $FOO format, in which case these will be
// expanded before the command is run.
//
// Ran reports if the command ran (rather than was not found or not executable).
// Code reports the exit code the command returned if it ran. If err == nil, ran
// is always true and code is always 0.
func (cl *Client) Exec(sio *exec.StdIOState, start, output bool, cmd string, args ...string) (string, error) {
        ses, err := cl.NewSession(true)
        if err != nil {
                return "", err
        }
        defer ses.Close()

        expand := func(s string) string {
                s2, ok := cl.Env[s]
                if ok {
                        return s2
                }
                switch s {
                case "!", "?":
                        return "$" + s
                }
                return os.Getenv(s)
        }
        cmd = os.Expand(cmd, expand)
        for i := range args {
                args[i] = os.Expand(args[i], expand)
        }
        return cl.run(ses, sio, start, output, cmd, args...)
}

func (cl *Client) run(ses *ssh.Session, sio *exec.StdIOState, start, output bool, cmd string, args ...string) (string, error) {
        for k, v := range cl.Env {
                ses.Setenv(k, v)
        }
        var err error
        out := ""
        ses.Stderr = sio.Err // note: no need to save previous b/c not retained
        ses.Stdout = sio.Out
        if cl.Echo != nil {
                cl.PrintCmd(cmd+" "+strings.Join(args, " "), err)
        }
        if exec.IsPipe(sio.In) {
                ses.Stdin = sio.In
        }

        cdto := ""
        cmds := cmd + " " + strings.Join(args, " ")
        if cl.Dir != "" {
                if cmd == "cd" {
                        if len(args) > 0 {
                                cdto = args[0]
                        } else {
                                cdto = cl.HomeDir
                        }
                }
                cmds = `cd '` + cl.Dir + `'; ` + cmds
        }

        if !cl.PrintOnly {
                switch {
                case start:
                        err = ses.Start(cmds)
                        go func() {
                                ses.Wait()
                                sio.PopToStart()
                        }()
                case output:
                        buf := &bytes.Buffer{}
                        ses.Stdout = buf
                        err = ses.Run(cmds)
                        if sio.Out != nil {
                                sio.Out.Write(buf.Bytes())
                        }
                        out = strings.TrimSuffix(buf.String(), "\n")
                default:
                        err = ses.Run(cmds)
                }

                // we must call InitColor after calling a system command
                // TODO(kai): maybe figure out a better solution to this
                // or expand this list
                if cmd == "cp" || cmd == "ls" || cmd == "mv" {
                        logx.InitColor()
                }

                if cdto != "" {
                        if filepath.IsAbs(cdto) {
                                cl.Dir = filepath.Clean(cdto)
                        } else {
                                cl.Dir = filepath.Clean(filepath.Join(cl.Dir, cdto))
                        }
                }
        }
        return out, err
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sshclient

import (
        "cogentcore.org/core/base/exec"
)

// Run runs given command, using config input / outputs.
// Must have already made a successful Connect.
func (cl *Client) Run(sio *exec.StdIOState, cmd string, args ...string) error {
        _, err := cl.Exec(sio, false, false, cmd, args...)
        return err
}

// Start starts the given command with arguments.
func (cl *Client) Start(sio *exec.StdIOState, cmd string, args ...string) error {
        _, err := cl.Exec(sio, true, false, cmd, args...)
        return err
}

// Output runs the command and returns the text from stdout.
func (cl *Client) Output(sio *exec.StdIOState, cmd string, args ...string) (string, error) {
        return cl.Exec(sio, false, true, cmd, args...)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sshclient

import (
        "context"
        "io"
        "log/slog"
        "os"
        "path/filepath"

        "github.com/bramvdbogaerde/go-scp"
)

// CopyLocalFileToHost copies given local file to given host file
// on the already-connected remote host, using the 'scp' protocol.
// See ScpPath in Config for path to scp on remote host.
// If the host filename is not absolute (i.e, doesn't start with /)
// then the current Dir path on the Client is prepended to the target path.
// Use context.Background() for a basic context if none otherwise in use.
func (cl *Client) CopyLocalFileToHost(ctx context.Context, localFilename, hostFilename string) error {
        f, err := os.Open(localFilename)
        if err != nil {
                return err
        }
        defer f.Close()
        stat, err := f.Stat()
        if err != nil {
                return err
        }
        return cl.CopyLocalToHost(ctx, f, stat.Size(), hostFilename)
}

// CopyLocalToHost copies given io.Reader source data to given filename
// on the already-connected remote host, using the 'scp' protocol.
// See ScpPath in Config for path to scp on remote host.
// The size must be given in advance for the scp protocol.
// If the host filename is not absolute (i.e, doesn't start with /)
// then the current Dir path on the Client is prepended to the target path.
// Use context.Background() for a basic context if none otherwise in use.
func (cl *Client) CopyLocalToHost(ctx context.Context, r io.Reader, size int64, hostFilename string) error {
        if err := cl.mustScpClient(); err != nil {
                return err
        }
        if !filepath.IsAbs(hostFilename) {
                hostFilename = filepath.Join(cl.Dir, hostFilename)
        }
        return cl.scpClient.CopyPassThru(ctx, r, hostFilename, "0666", size, nil)
}

// CopyHostToLocalFile copies given filename on the already-connected remote host,
// to the local file using the 'scp' protocol.
// See ScpPath in Config for path to scp on remote host.
// If the host filename is not absolute (i.e, doesn't start with /)
// then the current Dir path on the Client is prepended to the target path.
// Use context.Background() for a basic context if none otherwise in use.
func (cl *Client) CopyHostToLocalFile(ctx context.Context, hostFilename, localFilename string) error {
        f, err := os.Create(localFilename)
        if err != nil {
                return err
        }
        defer f.Close()
        return cl.CopyHostToLocal(ctx, hostFilename, f)
}

// CopyHostToLocal copies given filename on the already-connected remote host,
// to the local io.Writer using the 'scp' protocol.
// See ScpPath in Config for path to scp on remote host.
// If the host filename is not absolute (i.e, doesn't start with /)
// then the current Dir path on the Client is prepended to the target path.
// Use context.Background() for a basic context if none otherwise in use.
func (cl *Client) CopyHostToLocal(ctx context.Context, hostFilename string, w io.Writer) error {
        if err := cl.mustScpClient(); err != nil {
                return err
        }
        if !filepath.IsAbs(hostFilename) {
                hostFilename = filepath.Join(cl.Dir, hostFilename)
        }
        return cl.scpClient.CopyFromRemotePassThru(ctx, w, hostFilename, nil)
}

func (cl *Client) mustScpClient() error {
        if cl.scpClient != nil {
                return nil
        }
        scl, err := scp.NewClientBySSH(cl.Client)
        if err != nil {
                slog.Error(err.Error())
        } else {
                cl.scpClient = &scl
        }
        return err
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package stack provides a generic stack implementation.
package stack

// Stack provides a generic stack using a slice.
type Stack[T any] []T

// Push pushes item(s) onto the stack.
func (st *Stack[T]) Push(it ...T) {
        *st = append(*st, it...)
}

// Pop pops the top item off the stack.
// Returns nil / zero value if stack is empty.
func (st *Stack[T]) Pop() T {
        n := len(*st)
        if n == 0 {
                var zv T
                return zv
        }
        li := (*st)[n-1]
        *st = (*st)[:n-1]
        return li
}

// Peek returns the last element on the stack.
// Returns nil / zero value if stack is empty.
func (st *Stack[T]) Peek() T {
        n := len(*st)
        if n == 0 {
                var zv T
                return zv
        }
        return (*st)[n-1]
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/ettle/strcase
// Copyright (c) 2020 Liyan David Chang under the MIT License

package strcase

import (
        "strings"
)

// Cases is an enum with all of the different string cases.
type Cases int32 //enums:enum

const (
        // LowerCase is all lower case
        LowerCase Cases = iota

        // UpperCase is all UPPER CASE
        UpperCase

        // SnakeCase is lower_case_words_with_underscores
        SnakeCase

        // SNAKECase is UPPER_CASE_WORDS_WITH_UNDERSCORES
        SNAKECase

        // KebabCase is lower-case-words-with-dashes
        KebabCase

        // KEBABCase is UPPER-CASE-WORDS-WITH-DASHES
        KEBABCase

        // CamelCase is CapitalizedWordsConcatenatedTogether
        CamelCase

        // LowerCamelCase is capitalizedWordsConcatenatedTogether, with the first word lower case
        LowerCamelCase

        // TitleCase is Captitalized Words With Spaces
        TitleCase

        // SentenceCase is Lower case words with spaces, with the first word capitalized
        SentenceCase
)

// To converts the given string to the given case.
func To(s string, c Cases) string {
        switch c {
        case LowerCase:
                return strings.ToLower(s)
        case UpperCase:
                return strings.ToUpper(s)
        case SnakeCase:
                return ToSnake(s)
        case SNAKECase:
                return ToSNAKE(s)
        case KebabCase:
                return ToKebab(s)
        case KEBABCase:
                return ToKEBAB(s)
        case CamelCase:
                return ToCamel(s)
        case LowerCamelCase:
                return ToLowerCamel(s)
        case TitleCase:
                return ToTitle(s)
        case SentenceCase:
                return ToSentence(s)
        }
        return s
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/ettle/strcase
// Copyright (c) 2020 Liyan David Chang under the MIT License

package strcase

import (
        "strings"
        "unicode"
)

// WordCases is an enumeration of the ways to format a word.
type WordCases int32 //enums:enum -trim-prefix Word

const (
        // WordOriginal indicates to preserve the original input case.
        WordOriginal WordCases = iota

        // WordLowerCase indicates to make all letters lower case (example).
        WordLowerCase

        // WordUpperCase indicates to make all letters upper case (EXAMPLE).
        WordUpperCase

        // WordTitleCase indicates to make only the first letter upper case (Example).
        WordTitleCase

        // WordCamelCase indicates to make only the first letter upper case, except
        // in the first word, in which all letters are lower case (exampleText).
        WordCamelCase

        // WordSentenceCase indicates to make only the first letter upper case, and
        // only for the first word (all other words have fully lower case letters).
        WordSentenceCase
)

// ToWordCase converts the given input string to the given word case with the given delimiter.
// Pass 0 for delimeter to use no delimiter.
//
//nolint:gocyclo
func ToWordCase(input string, wordCase WordCases, delimiter rune) string {
        input = strings.TrimSpace(input)
        runes := []rune(input)
        if len(runes) == 0 {
                return ""
        }

        var b strings.Builder
        b.Grow(len(input) + 4) // In case we need to write delimiters where they weren't before

        firstWord := true
        var skipIndexes []int

        addWord := func(start, end int) {
                // If you have nothing good to say, say nothing at all
                if start == end || len(skipIndexes) == end-start {
                        skipIndexes = nil
                        return
                }

                // If you have something to say, start with a delimiter
                if !firstWord && delimiter != 0 {
                        b.WriteRune(delimiter)
                }

                // Check to see if the entire word is an initialism for preserving initialism.
                // Note we don't support preserving initialisms if they are followed
                // by a number and we're not spliting before numbers.
                if wordCase == WordTitleCase || wordCase == WordSentenceCase || (wordCase == WordCamelCase && !firstWord) {
                        allCaps := true
                        for i := start; i < end; i++ {
                                allCaps = allCaps && (isUpper(runes[i]) || !unicode.IsLetter(runes[i]))
                        }
                        if allCaps {
                                b.WriteString(string(runes[start:end]))
                                firstWord = false
                                return
                        }
                }

                skipIndex := 0
                for i := start; i < end; i++ {
                        if len(skipIndexes) > 0 && skipIndex < len(skipIndexes) && i == skipIndexes[skipIndex] {
                                skipIndex++
                                continue
                        }
                        r := runes[i]
                        switch wordCase {
                        case WordUpperCase:
                                b.WriteRune(toUpper(r))
                        case WordLowerCase:
                                b.WriteRune(toLower(r))
                        case WordTitleCase:
                                if i == start {
                                        b.WriteRune(toUpper(r))
                                } else {
                                        b.WriteRune(toLower(r))
                                }
                        case WordCamelCase:
                                if !firstWord && i == start {
                                        b.WriteRune(toUpper(r))
                                } else {
                                        b.WriteRune(toLower(r))
                                }
                        case WordSentenceCase:
                                if firstWord && i == start {
                                        b.WriteRune(toUpper(r))
                                } else {
                                        b.WriteRune(toLower(r))
                                }
                        default:
                                b.WriteRune(r)
                        }
                }
                firstWord = false
                skipIndexes = nil
        }

        var prev, curr rune
        next := runes[0] // 0 length will have already returned so safe to index
        wordStart := 0
        for i := 0; i < len(runes); i++ {
                prev = curr
                curr = next
                if i+1 == len(runes) {
                        next = 0
                } else {
                        next = runes[i+1]
                }

                switch defaultSplitFn(prev, curr, next) {
                case Skip:
                        skipIndexes = append(skipIndexes, i)
                case Split:
                        addWord(wordStart, i)
                        wordStart = i
                case SkipSplit:
                        addWord(wordStart, i)
                        wordStart = i + 1
                }
        }

        if wordStart != len(runes) {
                addWord(wordStart, len(runes))
        }
        return b.String()
}

// Code generated by "core generate"; DO NOT EDIT.

package strcase

import (
        "cogentcore.org/core/enums"
)

var _CasesValues = []Cases{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

// CasesN is the highest valid value for type Cases, plus one.
const CasesN Cases = 10

var _CasesValueMap = map[string]Cases{`LowerCase`: 0, `UpperCase`: 1, `SnakeCase`: 2, `SNAKECase`: 3, `KebabCase`: 4, `KEBABCase`: 5, `CamelCase`: 6, `LowerCamelCase`: 7, `TitleCase`: 8, `SentenceCase`: 9}

var _CasesDescMap = map[Cases]string{0: `LowerCase is all lower case`, 1: `UpperCase is all UPPER CASE`, 2: `SnakeCase is lower_case_words_with_underscores`, 3: `SNAKECase is UPPER_CASE_WORDS_WITH_UNDERSCORES`, 4: `KebabCase is lower-case-words-with-dashes`, 5: `KEBABCase is UPPER-CASE-WORDS-WITH-DASHES`, 6: `CamelCase is CapitalizedWordsConcatenatedTogether`, 7: `LowerCamelCase is capitalizedWordsConcatenatedTogether, with the first word lower case`, 8: `TitleCase is Captitalized Words With Spaces`, 9: `SentenceCase is Lower case words with spaces, with the first word capitalized`}

var _CasesMap = map[Cases]string{0: `LowerCase`, 1: `UpperCase`, 2: `SnakeCase`, 3: `SNAKECase`, 4: `KebabCase`, 5: `KEBABCase`, 6: `CamelCase`, 7: `LowerCamelCase`, 8: `TitleCase`, 9: `SentenceCase`}

// String returns the string representation of this Cases value.
func (i Cases) String() string { return enums.String(i, _CasesMap) }

// SetString sets the Cases value from its string representation,
// and returns an error if the string is invalid.
func (i *Cases) SetString(s string) error { return enums.SetString(i, s, _CasesValueMap, "Cases") }

// Int64 returns the Cases value as an int64.
func (i Cases) Int64() int64 { return int64(i) }

// SetInt64 sets the Cases value from an int64.
func (i *Cases) SetInt64(in int64) { *i = Cases(in) }

// Desc returns the description of the Cases value.
func (i Cases) Desc() string { return enums.Desc(i, _CasesDescMap) }

// CasesValues returns all possible values for the type Cases.
func CasesValues() []Cases { return _CasesValues }

// Values returns all possible values for the type Cases.
func (i Cases) Values() []enums.Enum { return enums.Values(_CasesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Cases) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Cases) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Cases") }

var _WordCasesValues = []WordCases{0, 1, 2, 3, 4, 5}

// WordCasesN is the highest valid value for type WordCases, plus one.
const WordCasesN WordCases = 6

var _WordCasesValueMap = map[string]WordCases{`Original`: 0, `LowerCase`: 1, `UpperCase`: 2, `TitleCase`: 3, `CamelCase`: 4, `SentenceCase`: 5}

var _WordCasesDescMap = map[WordCases]string{0: `WordOriginal indicates to preserve the original input case.`, 1: `WordLowerCase indicates to make all letters lower case (example).`, 2: `WordUpperCase indicates to make all letters upper case (EXAMPLE).`, 3: `WordTitleCase indicates to make only the first letter upper case (Example).`, 4: `WordCamelCase indicates to make only the first letter upper case, except in the first word, in which all letters are lower case (exampleText).`, 5: `WordSentenceCase indicates to make only the first letter upper case, and only for the first word (all other words have fully lower case letters).`}

var _WordCasesMap = map[WordCases]string{0: `Original`, 1: `LowerCase`, 2: `UpperCase`, 3: `TitleCase`, 4: `CamelCase`, 5: `SentenceCase`}

// String returns the string representation of this WordCases value.
func (i WordCases) String() string { return enums.String(i, _WordCasesMap) }

// SetString sets the WordCases value from its string representation,
// and returns an error if the string is invalid.
func (i *WordCases) SetString(s string) error {
        return enums.SetString(i, s, _WordCasesValueMap, "WordCases")
}

// Int64 returns the WordCases value as an int64.
func (i WordCases) Int64() int64 { return int64(i) }

// SetInt64 sets the WordCases value from an int64.
func (i *WordCases) SetInt64(in int64) { *i = WordCases(in) }

// Desc returns the description of the WordCases value.
func (i WordCases) Desc() string { return enums.Desc(i, _WordCasesDescMap) }

// WordCasesValues returns all possible values for the type WordCases.
func WordCasesValues() []WordCases { return _WordCasesValues }

// Values returns all possible values for the type WordCases.
func (i WordCases) Values() []enums.Enum { return enums.Values(_WordCasesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i WordCases) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *WordCases) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "WordCases")
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package strcase

// FormatList returns a formatted version of the given list of items following these rules:
//   - nil => ""
//   - "Go" => "Go"
//   - "Go", "Python" => "Go and Python"
//   - "Go", "Python", "JavaScript" => "Go, Python, and JavaScript"
//   - "Go", "Python", "JavaScript", "C" => "Go, Python, JavaScript, and C"
func FormatList(items ...string) string {
        switch len(items) {
        case 0:
                return ""
        case 1:
                return items[0]
        case 2:
                return items[0] + " and " + items[1]
        }
        res := ""
        for i, match := range items {
                res += match
                if i == len(items)-1 {
                        // last one, so do nothing
                } else if i == len(items)-2 {
                        res += ", and "
                } else {
                        res += ", "
                }
        }
        return res
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/ettle/strcase
// Copyright (c) 2020 Liyan David Chang under the MIT License

package strcase

import "unicode"

// SplitAction defines if and how to split a string
type SplitAction int

const (
        // Noop - Continue to next character
        Noop SplitAction = iota
        // Split - Split between words
        // e.g. to split between wordsWithoutDelimiters
        Split
        // SkipSplit - Split the word and drop the character
        // e.g. to split words with delimiters
        SkipSplit
        // Skip - Remove the character completely
        Skip
)

//nolint:gocyclo
func defaultSplitFn(prev, curr, next rune) SplitAction {
        // The most common case will be that it's just a letter so let lowercase letters return early since we know what they should do
        if isLower(curr) {
                return Noop
        }
        // Delimiters are _, -, ., and unicode spaces
        // Handle . lower down as it needs to happen after number exceptions
        if curr == '_' || curr == '-' || isSpace(curr) {
                return SkipSplit
        }

        if isUpper(curr) {
                if isLower(prev) {
                        // fooBar
                        return Split
                } else if isUpper(prev) && isLower(next) {
                        // FOOBar
                        return Split
                }
        }

        // Do numeric exceptions last to avoid perf penalty
        if unicode.IsNumber(prev) {
                // v4.3 is not split
                if (curr == '.' || curr == ',') && unicode.IsNumber(next) {
                        return Noop
                }
                if !unicode.IsNumber(curr) && curr != '.' {
                        return Split
                }
        }
        // While period is a default delimiter, keep it down here to avoid
        // penalty for other delimiters
        if curr == '.' {
                return SkipSplit
        }

        return Noop
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/ettle/strcase
// Copyright (c) 2020 Liyan David Chang under the MIT License

// Package strcase provides functions for manipulating the case of strings (CamelCase, kebab-case,
// snake_case, Sentence case, etc). It is based on https://github.com/ettle/strcase, which is Copyright
// (c) 2020 Liyan David Chang under the MIT License. Its principle difference from other strcase packages
// is that it preserves acronyms in input text for CamelCase. Therefore, you must call [strings.ToLower]
// on any SCREAMING_INPUT_STRINGS before passing them to [ToCamel], [ToLowerCamel], [ToTitle], and [ToSentence].
package strcase

//go:generate core generate

// ToSnake returns words in snake_case (lower case words with underscores).
func ToSnake(s string) string {
        return ToWordCase(s, WordLowerCase, '_')
}

// ToSNAKE returns words in SNAKE_CASE (upper case words with underscores).
// Also known as SCREAMING_SNAKE_CASE or UPPER_CASE.
func ToSNAKE(s string) string {
        return ToWordCase(s, WordUpperCase, '_')
}

// ToKebab returns words in kebab-case (lower case words with dashes).
// Also known as dash-case.
func ToKebab(s string) string {
        return ToWordCase(s, WordLowerCase, '-')
}

// ToKEBAB returns words in KEBAB-CASE (upper case words with dashes).
// Also known as SCREAMING-KEBAB-CASE or SCREAMING-DASH-CASE.
func ToKEBAB(s string) string {
        return ToWordCase(s, WordUpperCase, '-')
}

// ToCamel returns words in CamelCase (capitalized words concatenated together).
// Also known as UpperCamelCase.
func ToCamel(s string) string {
        return ToWordCase(s, WordTitleCase, 0)
}

// ToLowerCamel returns words in lowerCamelCase (capitalized words concatenated together,
// with first word lower case). Also known as camelCase or mixedCase.
func ToLowerCamel(s string) string {
        return ToWordCase(s, WordCamelCase, 0)
}

// ToTitle returns words in Title Case (capitalized words with spaces).
func ToTitle(s string) string {
        return ToWordCase(s, WordTitleCase, ' ')
}

// ToSentence returns words in Sentence case (lower case words with spaces, with the first word capitalized).
func ToSentence(s string) string {
        return ToWordCase(s, WordSentenceCase, ' ')
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/ettle/strcase
// Copyright (c) 2020 Liyan David Chang under the MIT License

package strcase

import "unicode"

// Unicode functions, optimized for the common case of ascii
// No performance lost by wrapping since these functions get inlined by the compiler

func isUpper(r rune) bool {
        return unicode.IsUpper(r)
}

func isLower(r rune) bool {
        return unicode.IsLower(r)
}

func isNumber(r rune) bool {
        if r >= '0' && r <= '9' {
                return true
        }
        return unicode.IsNumber(r)
}

func isSpace(r rune) bool {
        if r == ' ' || r == '\t' || r == '\n' || r == '\r' {
                return true
        } else if r < 128 {
                return false
        }
        return unicode.IsSpace(r)
}

func toUpper(r rune) rune {
        if r >= 'a' && r <= 'z' {
                return r - 32
        } else if r < 128 {
                return r
        }
        return unicode.ToUpper(r)
}

func toLower(r rune) rune {
        if r >= 'A' && r <= 'Z' {
                return r + 32
        } else if r < 128 {
                return r
        }
        return unicode.ToLower(r)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package stringsx provides additional string functions
// beyond those in the standard [strings] package.
package stringsx

import (
        "bytes"
        "slices"
        "strings"
)

// TrimCR returns the string without any trailing \r carriage return
func TrimCR(s string) string {
        n := len(s)
        if n == 0 {
                return s
        }
        if s[n-1] == '\r' {
                return s[:n-1]
        }
        return s
}

// ByteTrimCR returns the byte string without any trailing \r carriage return
func ByteTrimCR(s []byte) []byte {
        n := len(s)
        if n == 0 {
                return s
        }
        if s[n-1] == '\r' {
                return s[:n-1]
        }
        return s
}

// SplitLines is a windows-safe version of [strings.Split](s, "\n")
// that removes any trailing \r carriage returns from the split lines.
func SplitLines(s string) []string {
        ls := strings.Split(s, "\n")
        for i, l := range ls {
                ls[i] = TrimCR(l)
        }
        return ls
}

// ByteSplitLines is a windows-safe version of [bytes.Split](s, "\n")
// that removes any trailing \r carriage returns from the split lines.
func ByteSplitLines(s []byte) [][]byte {
        ls := bytes.Split(s, []byte("\n"))
        for i, l := range ls {
                ls[i] = ByteTrimCR(l)
        }
        return ls
}

// InsertFirstUnique inserts the given string at the start of the given string slice
// while keeping the overall length to the given max value. If the item is already on
// the list, then it is moved to the top and not re-added (unique items only). This is
// useful for a list of recent items.
func InsertFirstUnique(strs *[]string, str string, max int) {
        if *strs == nil {
                *strs = make([]string, 0, max)
        }
        sz := len(*strs)
        if sz > max {
                *strs = (*strs)[:max]
        }
        for i, s := range *strs {
                if s == str {
                        if i == 0 {
                                return
                        }
                        copy((*strs)[1:i+1], (*strs)[0:i])
                        (*strs)[0] = str
                        return
                }
        }
        if sz >= max {
                copy((*strs)[1:max], (*strs)[0:max-1])
                (*strs)[0] = str
        } else {
                *strs = append(*strs, "")
                if sz > 0 {
                        copy((*strs)[1:], (*strs)[0:sz])
                }
                (*strs)[0] = str
        }
}

// UniqueList removes duplicates from given string list,
// preserving the order.
func UniqueList(strs []string) []string {
        n := len(strs)
        for i := n - 1; i >= 0; i-- {
                p := strs[i]
                for j, s := range strs {
                        if p == s && i != j {
                                strs = slices.Delete(strs, i, i+1)
                        }
                }
        }
        return strs
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package tiered provides a type for a tiered set of objects.
package tiered

// Tiered represents a tiered set of objects of the same type.
// For example, this is frequently used to represent slices of
// functions that can be run at the first, normal, or final time.
type Tiered[T any] struct {

        // First is the object that will be used first,
        // before [Tiered.Normal] and [Tiered.Final].
        First T

        // Normal is the object that will be used at the normal
        // time, after [Tiered.First] and before [Tiered.Final].
        Normal T

        // Final is the object that will be used last,
        // after [Tiered.First] and [Tiered.Normal].
        Final T
}

// Do calls the given function for each tier,
// going through first, then normal, then final.
func (t *Tiered[T]) Do(f func(T)) {
        f(t.First)
        f(t.Normal)
        f(t.Final)
}

// DoWith calls the given function with each tier of this tiered
// set and the other given tiered set, going through first, then
// normal, then final.
func (t *Tiered[T]) DoWith(other *Tiered[T], f func(*T, *T)) {
        f(&t.First, &other.First)
        f(&t.Normal, &other.Normal)
        f(&t.Final, &other.Final)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package timer provides a simple wall-clock duration timer based on standard
// [time]. It accumulates total and average over multiple Start / Stop intervals.
package timer

import "time"

// Time manages the timer accumulated time and count
type Time struct {

        // the most recent starting time
        St time.Time

        // the total accumulated time
        Total time.Duration

        // the number of start/stops
        N int
}

// Reset resets the overall accumulated Total and N counters and start time to zero
func (t *Time) Reset() {
        t.St = time.Time{}
        t.Total = 0
        t.N = 0
}

// Start starts the timer
func (t *Time) Start() {
        t.St = time.Now()
}

// ResetStart reset then start the timer
func (t *Time) ResetStart() {
        t.Reset()
        t.Start()
}

// Stop stops the timer and accumulates the latest start - stop interval, and also returns it
func (t *Time) Stop() time.Duration {
        if t.St.IsZero() {
                t.Total = 0
                t.N = 0
                return 0
        }
        iv := time.Since(t.St)
        t.Total += iv
        t.N++
        return iv
}

// Avg returns the average start / stop interval (assumes each was measuring the same thing).
func (t *Time) Avg() time.Duration {
        if t.N == 0 {
                return 0
        }
        return t.Total / time.Duration(t.N)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package tolassert provides functions for asserting the equality of numbers
// with tolerance (in other words, it checks whether numbers are about equal).
package tolassert

import (
        "fmt"

        "cogentcore.org/core/base/num"
        "github.com/stretchr/testify/assert"
)

// Equal asserts that the given two numbers are about equal to each other,
// using a default tolerance of 0.001.
func Equal[T num.Float](t assert.TestingT, expected T, actual T, msgAndArgs ...any) bool {
        if h, ok := t.(interface{ Helper() }); ok {
                h.Helper()
        }
        return EqualTol(t, expected, actual, 0.001, msgAndArgs...)
}

// EqualTol asserts that the given two numbers are about equal to each other,
// using the given tolerance value.
func EqualTol[T num.Float](t assert.TestingT, expected T, actual, tolerance T, msgAndArgs ...any) bool {
        if h, ok := t.(interface{ Helper() }); ok {
                h.Helper()
        }
        if num.Abs(actual-expected) > tolerance {
                return assert.Equal(t, expected, actual, msgAndArgs...)
        }
        return true
}

// EqualTolSlice asserts that the given two slices of numbers are about equal to each other,
// using the given tolerance value.
func EqualTolSlice[T num.Float](t assert.TestingT, expected, actual []T, tolerance T, msgAndArgs ...any) bool {
        if h, ok := t.(interface{ Helper() }); ok {
                h.Helper()
        }
        errs := false
        for i, ex := range expected {
                a := actual[i]
                if num.Abs(a-ex) > tolerance {
                        assert.Equal(t, expected, actual, fmt.Sprintf("index: %d", i))
                        errs = true
                }
        }
        return errs
}

// Code generated by "core generate"; DO NOT EDIT.

package vcs

import (
        "cogentcore.org/core/enums"
)

var _FileStatusValues = []FileStatus{0, 1, 2, 3, 4, 5, 6}

// FileStatusN is the highest valid value for type FileStatus, plus one.
const FileStatusN FileStatus = 7

var _FileStatusValueMap = map[string]FileStatus{`Untracked`: 0, `Stored`: 1, `Modified`: 2, `Added`: 3, `Deleted`: 4, `Conflicted`: 5, `Updated`: 6}

var _FileStatusDescMap = map[FileStatus]string{0: `Untracked means file is not under VCS control`, 1: `Stored means file is stored under VCS control, and has not been modified in working copy`, 2: `Modified means file is under VCS control, and has been modified in working copy`, 3: `Added means file has just been added to VCS but is not yet committed`, 4: `Deleted means file has been deleted from VCS`, 5: `Conflicted means file is in conflict -- has not been merged`, 6: `Updated means file has been updated in the remote but not locally`}

var _FileStatusMap = map[FileStatus]string{0: `Untracked`, 1: `Stored`, 2: `Modified`, 3: `Added`, 4: `Deleted`, 5: `Conflicted`, 6: `Updated`}

// String returns the string representation of this FileStatus value.
func (i FileStatus) String() string { return enums.String(i, _FileStatusMap) }

// SetString sets the FileStatus value from its string representation,
// and returns an error if the string is invalid.
func (i *FileStatus) SetString(s string) error {
        return enums.SetString(i, s, _FileStatusValueMap, "FileStatus")
}

// Int64 returns the FileStatus value as an int64.
func (i FileStatus) Int64() int64 { return int64(i) }

// SetInt64 sets the FileStatus value from an int64.
func (i *FileStatus) SetInt64(in int64) { *i = FileStatus(in) }

// Desc returns the description of the FileStatus value.
func (i FileStatus) Desc() string { return enums.Desc(i, _FileStatusDescMap) }

// FileStatusValues returns all possible values for the type FileStatus.
func FileStatusValues() []FileStatus { return _FileStatusValues }

// Values returns all possible values for the type FileStatus.
func (i FileStatus) Values() []enums.Enum { return enums.Values(_FileStatusValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i FileStatus) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *FileStatus) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "FileStatus")
}

var _TypesValues = []Types{0, 1, 2, 3, 4}

// TypesN is the highest valid value for type Types, plus one.
const TypesN Types = 5

var _TypesValueMap = map[string]Types{`NoVCS`: 0, `novcs`: 0, `Git`: 1, `git`: 1, `Svn`: 2, `svn`: 2, `Bzr`: 3, `bzr`: 3, `Hg`: 4, `hg`: 4}

var _TypesDescMap = map[Types]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``}

var _TypesMap = map[Types]string{0: `NoVCS`, 1: `Git`, 2: `Svn`, 3: `Bzr`, 4: `Hg`}

// String returns the string representation of this Types value.
func (i Types) String() string { return enums.String(i, _TypesMap) }

// SetString sets the Types value from its string representation,
// and returns an error if the string is invalid.
func (i *Types) SetString(s string) error { return enums.SetStringLower(i, s, _TypesValueMap, "Types") }

// Int64 returns the Types value as an int64.
func (i Types) Int64() int64 { return int64(i) }

// SetInt64 sets the Types value from an int64.
func (i *Types) SetInt64(in int64) { *i = Types(in) }

// Desc returns the description of the Types value.
func (i Types) Desc() string { return enums.Desc(i, _TypesDescMap) }

// TypesValues returns all possible values for the type Types.
func TypesValues() []Types { return _TypesValues }

// Values returns all possible values for the type Types.
func (i Types) Values() []enums.Enum { return enums.Values(_TypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Types) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Types) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Types") }

// Copyright (c) 2020, The Cogent Core Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vcs

import (
        "os"
        "path/filepath"
)

// Files is a map used for storing files in a repository along with their status
type Files map[string]FileStatus

// Status returns the VCS file status associated with given filename,
// returning Untracked if not found and safe to empty map.
func (fl *Files) Status(repo Repo, fname string) FileStatus {
        if *fl == nil || len(*fl) == 0 {
                return Untracked
        }
        st, ok := (*fl)[relPath(repo, fname)]
        if !ok {
                return Untracked
        }
        return st
}

// allFiles returns a slice of all the files, recursively, within a given directory
func allFiles(path string) ([]string, error) {
        var fnms []string
        er := filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
                if err != nil {
                        return err
                }
                fnms = append(fnms, path)
                return nil
        })
        return fnms, er
}

// FileStatus indicates the status of files in the repository
type FileStatus int32 //enums:enum

const (
        // Untracked means file is not under VCS control
        Untracked FileStatus = iota

        // Stored means file is stored under VCS control, and has not been modified in working copy
        Stored

        // Modified means file is under VCS control, and has been modified in working copy
        Modified

        // Added means file has just been added to VCS but is not yet committed
        Added

        // Deleted means file has been deleted from VCS
        Deleted

        // Conflicted means file is in conflict -- has not been merged
        Conflicted

        // Updated means file has been updated in the remote but not locally
        Updated
)

// Copyright (c) 2019, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vcs

import (
        "bufio"
        "bytes"
        "fmt"
        "log"
        "os"
        "path/filepath"
        "strconv"
        "strings"
        "sync"

        "github.com/Masterminds/vcs"
)

type GitRepo struct {
        vcs.GitRepo
        files        Files
        gettingFiles bool
        sync.Mutex
}

func (gr *GitRepo) Type() Types {
        return Git
}

// Files returns a map of the current files and their status,
// using a cached version of the file list if available.
// nil will be returned immediately if no cache is available.
// The given onUpdated function will be called from a separate
// goroutine when the updated list of the files is available,
// if an update is not already under way. An update is always triggered
// if no files have yet been cached, even if the function is nil.
func (gr *GitRepo) Files(onUpdated func(f Files)) (Files, error) {
        gr.Lock()
        if gr.files != nil {
                f := gr.files
                gr.Unlock()
                if onUpdated != nil {
                        go gr.updateFiles(onUpdated)
                }
                return f, nil
        }
        gr.Unlock()
        go gr.updateFiles(onUpdated)
        return nil, nil
}

func (gr *GitRepo) updateFiles(onUpdated func(f Files)) {
        gr.Lock()
        if gr.gettingFiles {
                gr.Unlock()
                return
        }
        gr.gettingFiles = true
        gr.Unlock()

        nf := max(len(gr.files), 64)
        f := make(Files, nf)

        out, err := gr.RunFromDir("git", "ls-files", "-o") // other -- untracked
        if err == nil {
                scan := bufio.NewScanner(bytes.NewReader(out))
                for scan.Scan() {
                        fn := filepath.FromSlash(string(scan.Bytes()))
                        f[fn] = Untracked
                }
        }

        out, err = gr.RunFromDir("git", "ls-files", "-c") // cached = all in repo
        if err == nil {
                scan := bufio.NewScanner(bytes.NewReader(out))
                for scan.Scan() {
                        fn := filepath.FromSlash(string(scan.Bytes()))
                        f[fn] = Stored
                }
        }

        out, err = gr.RunFromDir("git", "ls-files", "-m") // modified
        if err == nil {
                scan := bufio.NewScanner(bytes.NewReader(out))
                for scan.Scan() {
                        fn := filepath.FromSlash(string(scan.Bytes()))
                        f[fn] = Modified
                }
        }

        out, err = gr.RunFromDir("git", "ls-files", "-d") // deleted
        if err == nil {
                scan := bufio.NewScanner(bytes.NewReader(out))
                for scan.Scan() {
                        fn := filepath.FromSlash(string(scan.Bytes()))
                        f[fn] = Deleted
                }
        }

        out, err = gr.RunFromDir("git", "ls-files", "-u") // unmerged
        if err == nil {
                scan := bufio.NewScanner(bytes.NewReader(out))
                for scan.Scan() {
                        fn := filepath.FromSlash(string(scan.Bytes()))
                        f[fn] = Conflicted
                }
        }

        out, err = gr.RunFromDir("git", "diff", "--name-only", "--diff-filter=A", "HEAD") // deleted
        if err == nil {
                scan := bufio.NewScanner(bytes.NewReader(out))
                for scan.Scan() {
                        fn := filepath.FromSlash(string(scan.Bytes()))
                        f[fn] = Added
                }
        }

        gr.Lock()
        gr.files = f
        gr.Unlock()
        if onUpdated != nil {
                onUpdated(f)
        }
        gr.Lock()
        gr.gettingFiles = false
        gr.Unlock()
}

func (gr *GitRepo) charToStat(stat byte) FileStatus {
        switch stat {
        case 'M':
                return Modified
        case 'A':
                return Added
        case 'D':
                return Deleted
        case 'U':
                return Conflicted
        case '?', '!':
                return Untracked
        }
        return Untracked
}

// StatusFast returns file status based on the cached file info,
// which might be slightly stale. Much faster than Status.
// Returns Untracked if no cached files.
func (gr *GitRepo) StatusFast(fname string) FileStatus {
        var ff Files
        gr.Lock()
        ff = gr.files
        gr.Unlock()
        if ff != nil {
                return ff.Status(gr, fname)
        }
        return Untracked
}

// Status returns status of given file; returns Untracked on any error.
func (gr *GitRepo) Status(fname string) (FileStatus, string) {
        out, err := gr.RunFromDir("git", "status", "--porcelain", relPath(gr, fname))
        if err != nil {
                return Untracked, err.Error()
        }
        ostr := string(out)
        if ostr == "" {
                return Stored, ""
        }
        sf := strings.Fields(ostr)
        if len(sf) < 2 {
                return Stored, ostr
        }
        stat := sf[0][0]
        return gr.charToStat(stat), ostr
}

// Add adds the file to the repo
func (gr *GitRepo) Add(fname string) error {
        fname = relPath(gr, fname)
        out, err := gr.RunFromDir("git", "add", fname)
        if err != nil {
                log.Println(string(out))
                return err
        }
        gr.Lock()
        if gr.files != nil {
                gr.files[fname] = Added
        }
        gr.Unlock()
        return nil
}

// Move moves updates the repo with the rename
func (gr *GitRepo) Move(oldpath, newpath string) error {
        out, err := gr.RunFromDir("git", "mv", relPath(gr, oldpath), relPath(gr, newpath))
        if err != nil {
                log.Println(string(out))
                return err
        }
        out, err = gr.RunFromDir("git", "add", relPath(gr, newpath))
        if err != nil {
                log.Println(string(out))
                return err
        }
        return nil
}

// Delete removes the file from the repo; uses "force" option to ensure deletion
func (gr *GitRepo) Delete(fname string) error {
        out, err := gr.RunFromDir("git", "rm", "-f", relPath(gr, fname))
        if err != nil {
                log.Println(string(out))
                fmt.Printf("%s\n", out)
                return err
        }
        return nil
}

// Delete removes the file from the repo
func (gr *GitRepo) DeleteRemote(fname string) error {
        out, err := gr.RunFromDir("git", "rm", "--cached", relPath(gr, fname))
        if err != nil {
                log.Println(string(out))
                return err
        }
        return nil
}

// CommitFile commits single file to repo staging
func (gr *GitRepo) CommitFile(fname string, message string) error {
        out, err := gr.RunFromDir("git", "commit", relPath(gr, fname), "-m", message)
        if err != nil {
                log.Println(string(out))
                return err
        }
        return nil
}

// RevertFile reverts a single file to last commit of master
func (gr *GitRepo) RevertFile(fname string) error {
        out, err := gr.RunFromDir("git", "checkout", relPath(gr, fname))
        if err != nil {
                log.Println(string(out))
                return err
        }
        return nil
}

// UpdateVersion sets the version of a package currently checked out via Git.
func (s *GitRepo) UpdateVersion(version string) error {
        out, err := s.RunFromDir("git", "switch", "--detach", version)
        if err != nil {
                return vcs.NewLocalError("Unable to update checked out version", err, string(out))
        }
        return nil
}

// FileContents returns the contents of given file, as a []byte array
// at given revision specifier. -1, -2 etc also work as universal
// ways of specifying prior revisions.
func (gr *GitRepo) FileContents(fname string, rev string) ([]byte, error) {
        if rev == "" {
                out, err := os.ReadFile(fname)
                if err != nil {
                        log.Println(err.Error())
                }
                return out, err
        } else if rev[0] == '-' {
                rsp, err := strconv.Atoi(rev)
                if err == nil && rsp < 0 {
                        rev = fmt.Sprintf("HEAD~%d:", -rsp)
                }
        } else {
                rev += ":"
        }
        fspec := rev + relPath(gr, fname)
        out, err := gr.RunFromDir("git", "show", fspec)
        if err != nil {
                log.Println(string(out))
                return nil, err
        }
        return out, nil
}

// fieldsThroughDelim gets the concatenated byte through to point where
// field ends with given delimiter, starting at given index
func fieldsThroughDelim(flds [][]byte, delim byte, idx int) (int, string) {
        ln := len(flds)
        for i := idx; i < ln; i++ {
                fld := flds[i]
                fsz := len(fld)
                if fld[fsz-1] == delim {
                        str := string(bytes.Join(flds[idx:i+1], []byte(" ")))
                        return i + 1, str[:len(str)-1]
                }
        }
        return ln, string(bytes.Join(flds[idx:ln], []byte(" ")))
}

// Log returns the log history of commits for given filename
// (or all files if empty).  If since is non-empty, it should be
// a date-like expression that the VCS will understand, such as
// 1/1/2020, yesterday, last year, etc
func (gr *GitRepo) Log(fname string, since string) (Log, error) {
        args := []string{"log", "--all"}
        if since != "" {
                args = append(args, `--since="`+since+`"`)
        }
        args = append(args, `--pretty=format:%h %ad} %an} %ae} %s`)
        if fname != "" {
                args = append(args, fname)
        }
        out, err := gr.RunFromDir("git", args...)
        if err != nil {
                return nil, err
        }
        var lg Log
        scan := bufio.NewScanner(bytes.NewReader(out))
        for scan.Scan() {
                ln := scan.Bytes()
                flds := bytes.Fields(ln)
                if len(flds) < 4 {
                        continue
                }
                rev := string(flds[0])
                ni, date := fieldsThroughDelim(flds, '}', 1)
                ni, author := fieldsThroughDelim(flds, '}', ni)
                ni, email := fieldsThroughDelim(flds, '}', ni)
                msg := string(bytes.Join(flds[ni:], []byte(" ")))
                lg.Add(rev, date, author, email, msg)
        }
        return lg, nil
}

// CommitDesc returns the full textual description of the given commit,
// if rev is empty, defaults to current HEAD, -1, -2 etc also work as universal
// ways of specifying prior revisions.
// Optionally includes diffs for the changes (otherwise just a list of files
// with modification status).
func (gr *GitRepo) CommitDesc(rev string, diffs bool) ([]byte, error) {
        if rev == "" {
                rev = "HEAD"
        } else if rev[0] == '-' {
                rsp, err := strconv.Atoi(rev)
                if err == nil && rsp < 0 {
                        rev = fmt.Sprintf("HEAD~%d", -rsp)
                }
        }
        var out []byte
        var err error
        if diffs {
                out, err = gr.RunFromDir("git", "show", rev)
        } else {
                out, err = gr.RunFromDir("git", "show", "--name-status", rev)
        }
        if err != nil {
                log.Println(string(out))
                return nil, err
        }
        return out, nil
}

// FilesChanged returns the list of files changed and their statuses,
// between two revisions.
// If revA is empty, defaults to current HEAD; revB defaults to HEAD-1.
// -1, -2 etc also work as universal ways of specifying prior revisions.
// Optionally includes diffs for the changes.
func (gr *GitRepo) FilesChanged(revA, revB string, diffs bool) ([]byte, error) {
        if revA == "" {
                revA = "HEAD"
        } else if revA[0] == '-' {
                rsp, err := strconv.Atoi(revA)
                if err == nil && rsp < 0 {
                        revA = fmt.Sprintf("HEAD~%d", -rsp)
                }
        }
        if revB != "" && revB[0] == '-' {
                rsp, err := strconv.Atoi(revB)
                if err == nil && rsp < 0 {
                        revB = fmt.Sprintf("HEAD~%d", -rsp)
                }
        }
        var out []byte
        var err error
        if diffs {
                out, err = gr.RunFromDir("git", "diff", "-u", revA, revB)
        } else {
                if revB == "" {
                        out, err = gr.RunFromDir("git", "diff", "--name-status", revA)
                } else {
                        out, err = gr.RunFromDir("git", "diff", "--name-status", revA, revB)
                }
        }
        if err != nil {
                log.Println(string(out))
                return nil, err
        }
        return out, nil
}

// Blame returns an annotated report about the file, showing which revision last
// modified each line.
func (gr *GitRepo) Blame(fname string) ([]byte, error) {
        out, err := gr.RunFromDir("git", "blame", fname)
        if err != nil {
                log.Println(string(out))
                return nil, err
        }
        return out, nil
}

// Copyright (c) 2018, The Cogent Core Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vcs

// Commit is one VCS commit entry, as returned in a [Log].
type Commit struct {

        // revision number / hash code / unique id
        Rev string

        // date (author's time) when committed
        Date string

        // author's name
        Author string

        // author's email
        Email string

        // message / subject line for commit
        Message string `width:"100"`
}

// Log is a listing of commits.
type Log []*Commit

// Add adds a new [Commit] to the [Log], returning the [Commit].
func (lg *Log) Add(rev, date, author, email, message string) *Commit {
        cm := &Commit{Rev: rev, Date: date, Author: author, Email: email, Message: message}
        *lg = append(*lg, cm)
        return cm
}

// Copyright (c) 2019, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vcs

import (
        "bufio"
        "bytes"
        "fmt"
        "log"
        "os/exec"
        "path/filepath"
        "strconv"
        "strings"
        "sync"

        "github.com/Masterminds/vcs"
)

type SvnRepo struct {
        vcs.SvnRepo
        files        Files
        gettingFiles bool
        sync.Mutex
}

func (gr *SvnRepo) Type() Types {
        return Svn
}

func (gr *SvnRepo) CharToStat(stat byte) FileStatus {
        switch stat {
        case 'M', 'R':
                return Modified
        case 'A':
                return Added
        case 'D', '!':
                return Deleted
        case 'C':
                return Conflicted
        case '?', 'I':
                return Untracked
        case '*':
                return Updated
        default:
                return Stored
        }
}

// Files returns a map of the current files and their status,
// using a cached version of the file list if available.
// nil will be returned immediately if no cache is available.
// The given onUpdated function will be called from a separate
// goroutine when the updated list of the files is available,
// if an update is not already under way. An update is always triggered
// if no files have yet been cached, even if the function is nil.
func (gr *SvnRepo) Files(onUpdated func(f Files)) (Files, error) {
        gr.Lock()
        if gr.files != nil {
                f := gr.files
                gr.Unlock()
                if onUpdated != nil {
                        go gr.updateFiles(onUpdated)
                }
                return f, nil
        }
        gr.Unlock()
        go gr.updateFiles(onUpdated)
        return nil, nil
}

func (gr *SvnRepo) updateFiles(onUpdated func(f Files)) {
        gr.Lock()
        if gr.gettingFiles {
                gr.Unlock()
                return
        }
        gr.gettingFiles = true
        gr.Unlock()

        f := make(Files)

        lpath := gr.LocalPath()
        allfs, err := allFiles(lpath) // much faster than svn list --recursive
        if err == nil {
                for _, fn := range allfs {
                        rpath, _ := filepath.Rel(lpath, fn)
                        f[rpath] = Stored
                }
        }

        out, err := gr.RunFromDir("svn", "status", "-u")
        if err == nil {
                scan := bufio.NewScanner(bytes.NewReader(out))
                for scan.Scan() {
                        ln := string(scan.Bytes())
                        flds := strings.Fields(ln)
                        if len(flds) < 2 {
                                continue // shouldn't happend
                        }
                        stat := flds[0][0]
                        fn := flds[len(flds)-1]
                        f[fn] = gr.CharToStat(stat)
                }
        }
        gr.Lock()
        gr.files = f
        gr.gettingFiles = false
        gr.Unlock()
        if onUpdated != nil {
                onUpdated(f)
        }
}

// StatusFast returns file status based on the cached file info,
// which might be slightly stale. Much faster than Status.
// Returns Untracked if no cached files.
func (gr *SvnRepo) StatusFast(fname string) FileStatus {
        var ff Files
        gr.Lock()
        ff = gr.files
        gr.Unlock()
        if ff != nil {
                return ff.Status(gr, fname)
        }
        return Untracked
}

// Status returns status of given file; returns Untracked on any error
func (gr *SvnRepo) Status(fname string) (FileStatus, string) {
        out, err := gr.RunFromDir("svn", "status", relPath(gr, fname))
        if err != nil {
                return Untracked, err.Error()
        }
        ostr := string(out)
        if ostr == "" {
                return Stored, ""
        }
        sf := strings.Fields(ostr)
        if len(sf) < 2 {
                return Stored, ostr
        }
        stat := sf[0][0]
        return gr.CharToStat(stat), ostr
}

// Add adds the file to the repo
func (gr *SvnRepo) Add(fname string) error {
        oscmd := exec.Command("svn", "add", relPath(gr, fname))
        stdoutStderr, err := oscmd.CombinedOutput()
        if err != nil {
                log.Println(string(stdoutStderr))
                return err
        }
        gr.Lock()
        if gr.files != nil {
                gr.files[fname] = Added
        }
        gr.Unlock()
        return nil
}

// Move moves updates the repo with the rename
func (gr *SvnRepo) Move(oldpath, newpath string) error {
        oscmd := exec.Command("svn", "mv", oldpath, newpath)
        stdoutStderr, err := oscmd.CombinedOutput()
        if err != nil {
                log.Println(string(stdoutStderr))
                return err
        }
        return nil
}

// Delete removes the file from the repo -- uses "force" option to ensure deletion
func (gr *SvnRepo) Delete(fname string) error {
        oscmd := exec.Command("svn", "rm", "-f", relPath(gr, fname))
        stdoutStderr, err := oscmd.CombinedOutput()
        if err != nil {
                log.Println(string(stdoutStderr))
                return err
        }
        return nil
}

// DeleteRemote removes the file from the repo, but keeps local copy
func (gr *SvnRepo) DeleteRemote(fname string) error {
        oscmd := exec.Command("svn", "delete", "--keep-local", relPath(gr, fname))
        stdoutStderr, err := oscmd.CombinedOutput()
        if err != nil {
                log.Println(string(stdoutStderr))
                return err
        }
        return nil
}

// CommitFile commits single file to repo staging
func (gr *SvnRepo) CommitFile(fname string, message string) error {
        oscmd := exec.Command("svn", "commit", relPath(gr, fname), "-m", message)
        stdoutStderr, err := oscmd.CombinedOutput()
        if err != nil {
                log.Println(string(stdoutStderr))
                return err
        }
        return nil
}

// RevertFile reverts a single file to last commit of master
func (gr *SvnRepo) RevertFile(fname string) error {
        oscmd := exec.Command("svn", "revert", relPath(gr, fname))
        stdoutStderr, err := oscmd.CombinedOutput()
        if err != nil {
                log.Println(string(stdoutStderr))
                return err
        }
        return nil
}

// FileContents returns the contents of given file, as a []byte array
// at given revision specifier (if empty, defaults to current HEAD).
// -1, -2 etc also work as universal ways of specifying prior revisions.
func (gr *SvnRepo) FileContents(fname string, rev string) ([]byte, error) {
        if rev == "" {
                rev = "HEAD"
                // } else if rev[0] == '-' { // no support at this point..
                //         rsp, err := strconv.Atoi(rev)
                //         if err == nil && rsp < 0 {
                //                 rev = fmt.Sprintf("HEAD~%d:", rsp)
                //         }
        }
        out, err := gr.RunFromDir("svn", "-r", "rev", "cat", relPath(gr, fname))
        if err != nil {
                log.Println(string(out))
                return nil, err
        }
        return out, nil
}

// Log returns the log history of commits for given filename
// (or all files if empty).  If since is non-empty, it is the
// maximum number of entries to return (a number).
func (gr *SvnRepo) Log(fname string, since string) (Log, error) {
        // todo: parse -- requires parsing over multiple lines..
        args := []string{"log"}
        if since != "" {
                args = append(args, `--limit=`+since)
        }
        if fname != "" {
                args = append(args, fname)
        }
        out, err := gr.RunFromDir("svn", args...)
        if err != nil {
                return nil, err
        }
        var lg Log
        rev := ""
        date := ""
        author := ""
        email := ""
        msg := ""
        newStart := false
        scan := bufio.NewScanner(bytes.NewReader(out))
        for scan.Scan() {
                ln := scan.Bytes()
                if string(ln[:10]) == "----------" {
                        if rev != "" {
                                lg.Add(rev, date, author, email, msg)
                        }
                        newStart = true
                        msg = ""
                        continue
                }
                if newStart {
                        flds := bytes.Split(ln, []byte("|"))
                        if len(flds) < 4 {
                                continue
                        }
                        rev = strings.TrimSpace(string(flds[0]))
                        author = strings.TrimSpace(string(flds[1]))
                        date = strings.TrimSpace(string(flds[2]))
                        msg = ""
                        newStart = false
                } else {
                        nosp := bytes.TrimSpace(ln)
                        if msg == "" && len(nosp) == 0 {
                                continue
                        }
                        msg += string(ln) + "\n"
                }
        }
        return lg, nil
}

// CommitDesc returns the full textual description of the given commit,
// if rev is empty, defaults to current HEAD, -1, -2 etc also work as universal
// ways of specifying prior revisions.
// Optionally includes diffs for the changes (otherwise just a list of files
// with modification status).
func (gr *SvnRepo) CommitDesc(rev string, diffs bool) ([]byte, error) {
        if rev == "" {
                rev = "HEAD"
        } else if rev[0] == '-' {
                rsp, err := strconv.Atoi(rev)
                if err == nil && rsp < 0 {
                        rev = fmt.Sprintf("HEAD~%d", -rsp)
                }
        }
        var out []byte
        var err error
        if diffs {
                out, err = gr.RunFromDir("svn", "log", "-v", "--diff", "-r", rev)
        } else {
                out, err = gr.RunFromDir("svn", "log", "-v", "-r", rev)
        }
        if err != nil {
                log.Println(string(out))
                return nil, err
        }

        return out, err
}

func (gr *SvnRepo) FilesChanged(revA, revB string, diffs bool) ([]byte, error) {
        return nil, nil // todo:
}

// Blame returns an annotated report about the file, showing which revision last
// modified each line.
func (gr *SvnRepo) Blame(fname string) ([]byte, error) {
        out, err := gr.RunFromDir("svn", "blame", fname)
        if err != nil {
                log.Println(string(out))
                return nil, err
        }
        return out, nil
}

// Copyright (c) 2018, The Cogent Core Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package vcs provides a more complete version control system (ex: git)
// interface, building on https://github.com/Masterminds/vcs.
package vcs

//go:generate core generate

import (
        "errors"
        "path/filepath"

        "cogentcore.org/core/base/fsx"
        "github.com/Masterminds/vcs"
)

type Types int32 //enums:enum -accept-lower

const (
        NoVCS Types = iota
        Git
        Svn
        Bzr
        Hg
)

// Repo provides an interface extending [vcs.Repo]
// (https://github.com/Masterminds/vcs)
// with support for file status information and operations.
type Repo interface {
        vcs.Repo

        // Type returns the type of repo we are using
        Type() Types

        // Files returns a map of the current files and their status,
        // using a cached version of the file list if available.
        // nil will be returned immediately if no cache is available.
        // The given onUpdated function will be called from a separate
        // goroutine when the updated list of the files is available
        // (an update is always triggered even if the function is nil).
        Files(onUpdated func(f Files)) (Files, error)

        // StatusFast returns file status based on the cached file info,
        // which might be slightly stale. Much faster than Status.
        // Returns Untracked if no cached files.
        StatusFast(fname string) FileStatus

        // Status returns status of given file -- returns Untracked and error
        // message on any error. FileStatus is a summary status category,
        // and string return value is more detailed status information formatted
        // according to standard conventions of given VCS.
        Status(fname string) (FileStatus, string)

        // Add adds the file to the repo
        Add(fname string) error

        // Move moves the file using VCS command to keep it updated
        Move(oldpath, newpath string) error

        // Delete removes the file from the repo and working copy.
        // Uses "force" option to ensure deletion.
        Delete(fname string) error

        // DeleteRemote removes the file from the repo but keeps the local file itself
        DeleteRemote(fname string) error

        // CommitFile commits a single file
        CommitFile(fname string, message string) error

        // RevertFile reverts a single file to the version that it was last in VCS,
        // losing any local changes (destructive!)
        RevertFile(fname string) error

        // FileContents returns the contents of given file, as a []byte array
        // at given revision specifier (if empty, defaults to current HEAD).
        // -1, -2 etc also work as universal ways of specifying prior revisions.
        FileContents(fname string, rev string) ([]byte, error)

        // Log returns the log history of commits for given filename
        // (or all files if empty).  If since is non-empty, it should be
        // a date-like expression that the VCS will understand, such as
        // 1/1/2020, yesterday, last year, etc.  SVN only understands a
        // number as a maximum number of items to return.
        Log(fname string, since string) (Log, error)

        // CommitDesc returns the full textual description of the given commit,
        // if rev is empty, defaults to current HEAD, -1, -2 etc also work as universal
        // ways of specifying prior revisions.
        // Optionally includes diffs for the changes (otherwise just a list of files
        // with modification status).
        CommitDesc(rev string, diffs bool) ([]byte, error)

        // FilesChanged returns the list of files changed and their statuses,
        // between two revisions.
        // If revA is empty, defaults to current HEAD; revB defaults to HEAD-1.
        // -1, -2 etc also work as universal ways of specifying prior revisions.
        // Optionally includes diffs for the changes.
        FilesChanged(revA, revB string, diffs bool) ([]byte, error)

        // Blame returns an annotated report about the file, showing which revision last
        // modified each line.
        Blame(fname string) ([]byte, error)
}

func NewRepo(remote, local string) (Repo, error) {
        repo, err := vcs.NewRepo(remote, local)
        if err == nil {
                switch repo.Vcs() {
                case vcs.Git:
                        r := &GitRepo{}
                        r.GitRepo = *(repo.(*vcs.GitRepo))
                        return r, err
                case vcs.Svn:
                        r := &SvnRepo{}
                        r.SvnRepo = *(repo.(*vcs.SvnRepo))
                        return r, err
                case vcs.Hg:
                        err = errors.New("hg version control not yet supported")
                case vcs.Bzr:
                        err = errors.New("bzr version control not yet supported")
                }
        }
        return nil, err
}

// DetectRepo attempts to detect the presence of a repository at the given
// directory path -- returns type of repository if found, else NoVCS.
// Very quickly just looks for signature file name:
// .git for git
// .svn for svn -- but note that this will find any subdir in svn rep.o
func DetectRepo(path string) Types {
        if fsx.HasFile(path, ".git") {
                return Git
        }
        if fsx.HasFile(path, ".svn") {
                return Svn
        }
        // todo: rest later..
        return NoVCS
}

// relPath return the path relative to the repository LocalPath()
func relPath(repo Repo, path string) string {
        relpath, _ := filepath.Rel(repo.LocalPath(), path)
        return relpath
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// note: parsing code adapted from pflag package https://github.com/spf13/pflag
// Copyright (c) 2012 Alex Ogier. All rights reserved.
// Copyright (c) 2012 The Go Authors. All rights reserved.

package cli

import (
        "fmt"
        "reflect"
        "strconv"
        "strings"

        "maps"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/strcase"
)

const (
        // ErrNotFound can be passed to [SetFromArgs] and [ParseFlags]
        // to indicate that they should return an error for a flag that
        // is set but not found in the configuration struct.
        ErrNotFound = true
        // ErrNotFound can be passed to [SetFromArgs] and [ParseFlags]
        // to indicate that they should NOT return an error for a flag that
        // is set but not found in the configuration struct.
        NoErrNotFound = false
)

// SetFromArgs sets config values on the given config object from
// the given from command-line args, based on the field names in
// the config struct and the given list of available commands.
// It returns the command, if any, that was passed in the arguments,
// and any error than occurs during the parsing and setting process.
// If errNotFound is set to true, it is assumed that all flags
// (arguments starting with a "-") must refer to fields in the
// config struct, so any that fail to match trigger an error.
// It is recommended that the [ErrNotFound] and [NoErrNotFound]
// constants be used for the value of errNotFound for clearer code.
func SetFromArgs[T any](cfg T, args []string, errNotFound bool, cmds ...*Cmd[T]) (string, error) {
        bf := boolFlags(cfg)
        // if we are not already a meta config object, we have to add
        // all of the bool flags of the meta config object so that we
        // correctly handle the short (no value) versions of things like
        // verbose and quiet.
        if _, ok := any(cfg).(*metaConfig); !ok {
                mcf := boolFlags(&metaConfigFields{})
                maps.Copy(bf, mcf)
        }
        nfargs, flags, err := getArgs(args, bf)
        if err != nil {
                return "", err
        }
        cmd, allFlags, err := parseArgs(cfg, nfargs, flags, cmds...)
        if err != nil {
                return "", err
        }
        err = parseFlags(flags, allFlags, errNotFound)
        if err != nil {
                return "", err
        }
        return cmd, nil
}

// boolFlags returns a map with a true value for every flag name
// that maps to a boolean field. This is needed so that bool
// flags can be properly set with their shorthand syntax.
func boolFlags(obj any) map[string]bool {
        fields := &fields{}
        addFields(obj, fields, addAllFields)

        res := map[string]bool{}

        for _, kv := range fields.Order {
                f := kv.Value

                if f.Field.Type.Kind() != reflect.Bool { // we only care about bools here
                        continue
                }

                // we need all cases of both normal and "no" version for all names
                for _, name := range f.Names {
                        for _, cnms := range allCases(name) {
                                res[cnms] = true
                        }
                        for _, cnms := range allCases("No" + name) {
                                res[cnms] = true
                        }
                }
        }
        return res
}

// getArgs processes the given args using the given map of bool flags,
// which should be obtained through [boolFlags]. It returns the leftover
// (positional) args, the flags, and any error.
func getArgs(args []string, boolFlags map[string]bool) ([]string, map[string]string, error) {
        var nonFlags []string
        flags := map[string]string{}
        for len(args) > 0 {
                s := args[0]
                args = args[1:]
                if len(s) == 0 || s[0] != '-' || len(s) == 1 { // if we are not a flag, just add to non-flags
                        nonFlags = append(nonFlags, s)
                        continue
                }

                if s[1] == '-' && len(s) == 2 { // "--" terminates the flags
                        // f.argsLenAtDash = len(f.args)
                        nonFlags = append(nonFlags, args...)
                        break
                }
                name, value, nargs, err := getFlag(s, args, boolFlags)
                if err != nil {
                        return nonFlags, flags, err
                }
                // we need to updated remaining args with latest
                args = nargs
                if name != "" { // we ignore no-names so that we can skip things like test args
                        flags[name] = value
                }
        }
        return nonFlags, flags, nil
}

// getFlag parses the given flag arg string in the context of the given
// remaining arguments and bool flags. It returns the name of the flag,
// the value of the flag, the remaining arguments updated with any changes
// caused by getting this flag, and any error.
func getFlag(s string, args []string, boolFlags map[string]bool) (name, value string, a []string, err error) {
        // we start out with the remaining args we were passed
        a = args
        // we know the first character is a dash, so we can trim it directly
        name = s[1:]
        // then we trim double dash if there is one
        name = strings.TrimPrefix(name, "-")

        // we can't start with a dash or equal, as those are reserved characters
        if len(name) == 0 || name[0] == '-' || name[0] == '=' {
                err = fmt.Errorf("bad flag syntax: %q", s)
                return
        }

        // go test passes args, so we ignore them
        if strings.HasPrefix(name, "test.") {
                name = ""
                return
        }

        // split on equal (we could be in the form flag=value)
        split := strings.SplitN(name, "=", 2)
        name = split[0]
        if len(split) == 2 {
                // if we are in the form flag=value, we are done
                value = split[1]
        } else if len(a) > 0 && !boolFlags[name] { // otherwise, if we still have more remaining args and are not a bool, our value could be the next arg (if we are a bool, we don't care about the next value)
                value = a[0]
                // if the next arg starts with a dash, it can't be our value, so we are just a bool arg and we exit with an empty value
                if strings.HasPrefix(value, "-") {
                        value = ""
                        return
                }
                // if it doesn't start with a dash, it is our value, so we remove it from the remaining args (we have already set value to it above)
                a = a[1:]
                return

        }
        return
}

// parseArgs parses the given non-flag arguments in the context of the given
// configuration struct, flags, and commands. The non-flag arguments and flags
// should be gotten through [getArgs] first. It returns the command specified by
// the arguments, an ordered map of all of the flag names and their associated
// field objects, and any error.
func parseArgs[T any](cfg T, args []string, flags map[string]string, cmds ...*Cmd[T]) (cmd string, allFlags *fields, err error) {
        newArgs, newCmd, err := parseArgsImpl(cfg, args, "", cmds...)
        if err != nil {
                return newCmd, allFlags, err
        }

        // if the command is blank, then it is the root command
        if newCmd == "" {
                for _, c := range cmds {
                        if c.Root && c.Name != "help" {
                                newCmd = c.Name
                                break
                        }
                }
        }

        allFields := &fields{}
        addMetaConfigFields(allFields)
        addFields(cfg, allFields, newCmd)

        allFlags = &fields{}
        newArgs, err = addFlags(allFields, allFlags, newArgs, flags)
        if err != nil {
                return newCmd, allFields, err
        }
        if len(newArgs) > 0 {
                return newCmd, allFields, fmt.Errorf("got unused arguments: %v", newArgs)
        }
        return newCmd, allFlags, nil
}

// parseArgsImpl is the underlying implementation of [parseArgs] that is called
// recursively and takes most of what [parseArgs] does, plus the current command state,
// and returns most of what [parseArgs] does, plus the args state.
func parseArgsImpl[T any](cfg T, baseArgs []string, baseCmd string, cmds ...*Cmd[T]) (args []string, cmd string, err error) {
        // we start with our base args and command
        args = baseArgs
        cmd = baseCmd

        // if we have no additional args, we have nothing to do
        if len(args) == 0 {
                return
        }

        // we only care about one arg at a time (everything else is handled recursively)
        arg := args[0]
        // get all of the (sub)commands in our base command
        baseCmdStrs := strings.Fields(baseCmd)
        for _, c := range cmds {
                // get all of the (sub)commands in this command
                cmdStrs := strings.Fields(c.Name)
                // find the (sub)commands that our base command shares with the command we are checking
                gotTo := 0
                hasMismatch := false
                for i, cstr := range cmdStrs {
                        // if we have no more (sub)commands on our base, mark our location and break
                        if i >= len(baseCmdStrs) {
                                gotTo = i
                                break
                        }
                        // if we have a different thing than our base, it is a mismatch
                        if baseCmdStrs[i] != cstr {
                                hasMismatch = true
                                break
                        }
                }
                // if we have a different sub(command) for something, this isn't the right command
                if hasMismatch {
                        continue
                }
                // if the thing after we ran out of (sub)commands on our base isn't our next arg, this isn't the right command
                if gotTo >= len(cmdStrs) || arg != cmdStrs[gotTo] {
                        continue
                }
                // otherwise, it is the right command, and our new command is our base plus our next arg
                cmd = arg
                if baseCmd != "" {
                        cmd = baseCmd + " " + arg
                }
                // we have consumed our next arg, so we get rid of it
                args = args[1:]
                // then, we recursively parse again with our new command as context
                oargs, ocmd, err := parseArgsImpl(cfg, args, cmd, cmds...)
                if err != nil {
                        return nil, "", err
                }
                // our new args and command are now whatever the recursive call returned, building upon what we passed it
                args = oargs
                cmd = ocmd
                // we got the command we wanted, so we can break
                break
        }
        return
}

// parseFlags parses the given flags using the given ordered map of all of the
// available flags, setting the values from that map accordingly.
// Setting errNotFound to true causes flags that are not in allFlags to
// trigger an error; otherwise, it just skips those. It is recommended
// that the [ErrNotFound] and [NoErrNotFound] constants be used for the
// value of errNotFound for clearer code. Also, the flags should be
// gotten through [getArgs] first, and the map of available flags should
// be gotten through [parseArgs] first.
func parseFlags(flags map[string]string, allFlags *fields, errNotFound bool) error {
        for name, value := range flags {
                err := parseFlag(name, value, allFlags, errNotFound)
                if err != nil {
                        return err
                }
        }
        return nil
}

// parseFlag parses the flag with the given name and the given value
// using the given map of all of the available flags, setting the value
// in that map corresponding to the flag name accordingly. Setting
// errNotFound = true causes passing a flag name that is not in allFlags
// to trigger an error; otherwise, it just does nothing and returns no error.
// It is recommended that the [ErrNotFound] and [NoErrNotFound]
// constants be used for the value of errNotFound for clearer code.
func parseFlag(name string, value string, allFlags *fields, errNotFound bool) error {
        f, exists := allFlags.ValueByKeyTry(name)
        if !exists {
                if errNotFound {
                        return fmt.Errorf("flag name %q not recognized", name)
                }
                return nil
        }

        isBool := reflectx.NonPointerValue(f.Value).Kind() == reflect.Bool

        if isBool {
                // check if we have a "no" prefix and set negate based on that
                lcnm := strings.ToLower(name)
                negate := false
                if len(lcnm) > 3 {
                        if lcnm[:3] == "no_" || lcnm[:3] == "no-" {
                                negate = true
                        } else if lcnm[:2] == "no" {
                                if _, has := allFlags.ValueByKeyTry(lcnm[2:]); has { // e.g., nogui and gui is on list
                                        negate = true
                                }
                        }
                }
                // the value could be explicitly set to a bool value,
                // so we check that; if it is not set, it is true
                b := true
                if value != "" {
                        var err error
                        b, err = strconv.ParseBool(value)
                        if err != nil {
                                return fmt.Errorf("error parsing bool flag %q: %w", name, err)
                        }
                }
                // if we are negating and true (ex: -no-something), or not negating
                // and false (ex: -something=false), we are false
                if negate && b || !negate && !b {
                        value = "false"
                } else { // otherwise, we are true
                        value = "true"
                }
        }
        if value == "" {
                // got '--flag' but arg was required
                return fmt.Errorf("flag %q needs an argument", name)
        }

        return setFieldValue(f, value)
}

// setFieldValue sets the value of the given configuration field
// to the given string argument value.
func setFieldValue(f *field, value string) error {
        nptyp := reflectx.NonPointerType(f.Value.Type())
        vk := nptyp.Kind()
        switch {
        // TODO: more robust parsing of maps and slices
        case vk == reflect.Map:
                strs := strings.Split(value, ",")
                mval := map[string]string{}
                for _, str := range strs {
                        k, v, found := strings.Cut(str, "=")
                        if !found {
                                return fmt.Errorf("missing key-value pair for setting map flag %q from flag value %q (element %q has no %q)", f.Names[0], value, str, "=")
                        }
                        mval[k] = v
                }
                err := reflectx.CopyMapRobust(f.Value.Interface(), mval)
                if err != nil {
                        return fmt.Errorf("unable to set map flag %q from flag value %q: %w", f.Names[0], value, err)
                }
        case vk == reflect.Slice:
                err := reflectx.CopySliceRobust(f.Value.Interface(), strings.Split(value, ","))
                if err != nil {
                        return fmt.Errorf("unable to set slice flag %q from flag value %q: %w", f.Names[0], value, err)
                }
        default:
                // initialize nil fields to prevent panics
                // (don't do for maps and slices, as new doesn't work for them)
                if f.Value.IsNil() {
                        f.Value.Set(reflect.New(nptyp))
                }
                err := reflectx.SetRobust(f.Value.Interface(), value) // overkill but whatever
                if err != nil {
                        return fmt.Errorf("error setting set flag %q from flag value %q: %w", f.Names[0], value, err)
                }
        }
        return nil
}

// addAllCases adds all string cases (kebab-case, snake_case, etc)
// of the given field with the given name to the given set of flags.
func addAllCases(nm string, field *field, allFlags *fields) {
        if nm == "Includes" {
                return // skip Includes
        }
        for _, nm := range allCases(nm) {
                allFlags.Add(nm, field)
        }
}

// allCases returns all of the string cases (kebab-case,
// snake_case, etc) of the given name.
func allCases(nm string) []string {
        return []string{nm, strings.ToLower(nm), strcase.ToKebab(nm), strcase.ToSnake(nm), strcase.ToSNAKE(nm)}
}

// addFlags adds to given the given ordered flags map all of the different ways
// all of the given fields can can be specified as flags. It also uses the given
// positional arguments to set the values of the object based on any posarg struct
// tags that fields have. The posarg struct tag must either be "all", "leftover",
// or a valid uint. Finally, it also uses the given map of flags passed to the
// command as context.
func addFlags(allFields *fields, allFlags *fields, args []string, flags map[string]string) ([]string, error) {
        consumed := map[int]bool{} // which args we have consumed via pos args
        var leftoverField *field
        for _, kv := range allFields.Order {
                v := kv.Value
                f := v.Field

                for _, name := range v.Names {
                        addAllCases(name, v, allFlags)
                        if f.Type.Kind() == reflect.Bool {
                                addAllCases("No"+name, v, allFlags)
                        }
                }

                // set based on pos arg
                posArgTag, ok := f.Tag.Lookup("posarg")
                if ok {
                        switch posArgTag {
                        case "all":
                                err := reflectx.SetRobust(v.Value.Interface(), args)
                                if err != nil {
                                        return nil, fmt.Errorf("error setting field %q to all positional arguments: %v: %w", f.Name, args, err)
                                }
                                // everybody has been consumed
                                for i := range args {
                                        consumed[i] = true
                                }
                        case "leftover":
                                leftoverField = v // must be handled later once we have all of the leftovers
                        default:
                                ui, err := strconv.ParseUint(posArgTag, 10, 64)
                                if err != nil {
                                        return nil, fmt.Errorf("programmer error: invalid value %q for posarg struct tag on field %q: %w", posArgTag, f.Name, err)
                                }
                                // if this is true, the pos arg is missing
                                if ui >= uint64(len(args)) {
                                        // if it isn't required, it doesn't matter if it's missing
                                        req, has := f.Tag.Lookup("required")
                                        if req != "+" && req != "true" && has { // default is required, so !has => required
                                                continue
                                        }
                                        // check if we have set this pos arg as a flag; if we have,
                                        // it makes up for the missing pos arg and there is no error,
                                        // but otherwise there is an error
                                        got := false
                                        for _, fnm := range v.Names { // TODO: is there a more efficient way to do this?
                                                for _, cnm := range allCases(fnm) {
                                                        _, ok := flags[cnm]
                                                        if ok {
                                                                got = true
                                                                break
                                                        }
                                                }
                                                if got {
                                                        break
                                                }
                                        }
                                        if got {
                                                continue // if we got the pos arg through the flag, we skip the rest of the pos arg stuff and go onto the next field
                                        }
                                        return nil, fmt.Errorf("missing positional argument %d (%s)", ui, strcase.ToKebab(v.Names[0]))
                                }
                                err = setFieldValue(v, args[ui]) // must be pointer to be settable
                                if err != nil {
                                        return nil, fmt.Errorf("error setting field %q to positional argument %d (%q): %w", f.Name, ui, args[ui], err)
                                }
                                consumed[int(ui)] = true // we have consumed this argument
                        }
                }
        }
        // get leftovers based on who was consumed
        leftovers := []string{}
        for i, a := range args {
                if !consumed[i] {
                        leftovers = append(leftovers, a)
                }
        }
        if leftoverField != nil {
                err := reflectx.SetRobust(leftoverField.Value.Interface(), leftovers)
                if err != nil {
                        return nil, fmt.Errorf("error setting field %q to all leftover arguments: %v: %w", leftoverField.Name, leftovers, err)
                }
                return nil, nil // no more leftovers
        }
        return leftovers, nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package cli generates powerful CLIs from Go struct types and functions.
// See package clicore to create a GUI representation of a CLI.
package cli

//go:generate core generate

import (
        "fmt"
        "log/slog"
        "os"
        "path/filepath"
        "strings"

        "cogentcore.org/core/base/logx"
)

// Run runs an app with the given options, configuration struct,
// and commands. It does not run the GUI; see [cogentcore.org/core/cli/clicore.Run]
// for that. The configuration struct should be passed as a pointer, and
// configuration options should be defined as fields on the configuration
// struct. The commands can be specified as either functions or struct
// objects; the functions are more concise but require using [types].
// In addition to the given commands, Run adds a "help" command that
// prints the result of [usage], which will also be the root command if
// no other root command is specified. Also, it adds the fields in
// [metaConfig] as configuration options. If [Options.Fatal] is set to
// true, the error result of Run does not need to be handled. Run uses
// [os.Args] for its arguments.
func Run[T any, C CmdOrFunc[T]](opts *Options, cfg T, cmds ...C) error {
        cs, err := CmdsFromCmdOrFuncs[T, C](cmds)
        if err != nil {
                err := fmt.Errorf("internal/programmer error: error getting commands from given commands: %w", err)
                if opts.Fatal {
                        logx.PrintError(err)
                        os.Exit(1)
                }
                return err
        }
        if len(cmds) == 1 { // one command is always the root
                cs[0].Root = true
        }
        cmd, err := config(opts, cfg, cs...)
        if err != nil {
                if opts.Fatal {
                        logx.PrintlnError("error: ", err)
                        os.Exit(1)
                }
                return err
        }
        err = runCmd(opts, cfg, cmd, cs...)
        if err != nil {
                if opts.Fatal {
                        fmt.Println(logx.CmdColor(cmdString(cmd)) + logx.ErrorColor(" failed: "+err.Error()))
                        os.Exit(1)
                }
                return fmt.Errorf("%s failed: %w", cmdName()+" "+cmd, err)
        }
        // if the user sets level to error (via -q), we don't show the success message
        if opts.PrintSuccess && logx.UserLevel <= slog.LevelWarn {
                fmt.Println(logx.CmdColor(cmdString(cmd)) + logx.SuccessColor(" succeeded"))
        }
        return nil
}

// runCmd runs the command with the given name using the given options,
// configuration information, and available commands. If the given
// command name is "", it runs the root command.
func runCmd[T any](opts *Options, cfg T, cmd string, cmds ...*Cmd[T]) error {
        for _, c := range cmds {
                if c.Name == cmd || c.Root && cmd == "" {
                        err := c.Func(cfg)
                        if err != nil {
                                return err
                        }
                        return nil
                }
        }
        if cmd == "" { // if we couldn't find the command and we are looking for the root command, we fall back on help
                fmt.Println(usage(opts, cfg, cmd, cmds...))
                os.Exit(0)
        }
        return fmt.Errorf("command %q not found", cmd)
}

// cmdName returns the name of the command currently being run.
func cmdName() string {
        base := filepath.Base(os.Args[0])
        return strings.TrimSuffix(base, filepath.Ext(base))
}

// cmdString is a simple helper function that returns a string
// with [cmdName] and the given command name string combined
// to form a string representing the complete command being run.
func cmdString(cmd string) string {
        if cmd == "" {
                return cmdName()
        }
        return cmdName() + " " + cmd
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package clicore extends package cli by generating Cogent Core GUIs.
package clicore

import (
        "fmt"
        "os"

        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/cli"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/tree"
)

// Run runs the given app with the given default
// configuration file paths. It is similar to
// [cli.Run], but it also runs the GUI if no
// arguments were provided. The app should be
// a pointer, and configuration options should
// be defined as fields on the app type. Also,
// commands should be defined as methods on the
// app type with the suffix "Cmd"; for example,
// for a command named "build", there should be
// the method:
//
//        func (a *App) BuildCmd() error
//
// Run uses [os.Args] for its arguments.
func Run[T any, C cli.CmdOrFunc[T]](opts *cli.Options, cfg T, cmds ...C) error {
        cs, err := cli.CmdsFromCmdOrFuncs[T, C](cmds)
        if err != nil {
                err := fmt.Errorf("error getting commands from given commands: %w", err)
                if opts.Fatal {
                        logx.PrintlnError(err)
                        os.Exit(1)
                }
                return err
        }
        cs = cli.AddCmd(cs, &cli.Cmd[T]{
                Func: func(t T) error {
                        gui(opts, t, cs...)
                        return nil
                },
                Name: "gui",
                Doc:  "gui runs the GUI version of the " + opts.AppName + " tool",
                Root: true, // if root isn't already taken, we take it
        })
        return cli.Run(opts, cfg, cs...)
}

// gui starts the gui for the given cli app, which must be passed as
// a pointer.
func gui[T any](opts *cli.Options, cfg T, cmds ...*cli.Cmd[T]) {
        b := core.NewBody(opts.AppName)

        b.AddTopBar(func(bar *core.Frame) {
                core.NewToolbar(bar).Maker(func(p *tree.Plan) {
                        for _, cmd := range cmds {
                                if cmd.Name == "gui" { // we are already in GUI so that command is irrelevant
                                        continue
                                }
                                tree.AddAt(p, cmd.Name, func(w *core.Button) {
                                        w.SetText(strcase.ToSentence(cmd.Name)).SetTooltip(cmd.Doc).
                                                OnClick(func(e events.Event) {
                                                        err := cmd.Func(cfg)
                                                        if err != nil {
                                                                // TODO: snackbar
                                                                logx.PrintlnError(err)
                                                        }
                                                })
                                })
                        }
                })
        })

        sv := core.NewForm(b)
        sv.SetStruct(cfg)

        b.RunMainWindow()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "fmt"

        "cogentcore.org/core/cli"
        "cogentcore.org/core/cli/clicore"
)

//go:generate core generate -add-types -add-methods

type Config struct {

        // the name of the user
        Name string

        // the age of the user
        Age int

        // whether the user likes Go
        LikesGo bool

        // the target platform to build for
        BuildTarget string
}

// Build builds the app for the config build target.
func Build(c *Config) error {
        fmt.Println("Building for platform", c.BuildTarget)
        return nil
}

// Run runs the app for the user with the config name.
func Run(c *Config) error {
        fmt.Println("Running for user", c.Name)
        return nil
}

func main() { //types:skip
        opts := cli.DefaultOptions("Basic", "Basic is a basic example application made with clicore.")
        clicore.Run(opts, &Config{}, Build, Run)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cli

import (
        "fmt"
        "strings"

        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/types"
)

// Cmd represents a runnable command with configuration options.
// The type constraint is the type of the configuration
// information passed to the command.
type Cmd[T any] struct {
        // Func is the actual function that runs the command.
        // It takes configuration information and returns an error.
        Func func(T) error
        // Name is the name of the command.
        Name string
        // Doc is the documentation for the command.
        Doc string
        // Root is whether the command is the root command
        // (what is called when no subcommands are passed)
        Root bool
        // Icon is the icon of the command in the tool bar
        // when running in the GUI via clicore
        Icon string
        // SepBefore is whether to add a separator before the
        // command in the tool bar when running in the GUI via clicore
        SepBefore bool
        // SepAfter is whether to add a separator after the
        // command in the tool bar when running in the GUI via clicore
        SepAfter bool
}

// CmdOrFunc is a generic type constraint that represents either
// a [*Cmd] with the given config type or a command function that
// takes the given config type and returns an error.
type CmdOrFunc[T any] interface {
        *Cmd[T] | func(T) error
}

// cmdFromFunc returns a new [Cmd] object from the given function
// and any information specified on it using comment directives,
// which requires the use of [types].
func cmdFromFunc[T any](fun func(T) error) (*Cmd[T], error) {
        cmd := &Cmd[T]{
                Func: fun,
        }

        fn := types.FuncName(fun)

        // we need to get rid of package name and then convert to kebab
        strs := strings.Split(fn, ".")
        cfn := strs[len(strs)-1] // camel function name
        cmd.Name = strcase.ToKebab(cfn)

        if f := types.FuncByName(fn); f != nil {
                cmd.Doc = f.Doc
                for _, dir := range f.Directives {
                        if dir.Tool != "cli" {
                                continue
                        }
                        if dir.Directive != "cmd" {
                                return cmd, fmt.Errorf("unrecognized comment directive %q (from comment %q)", dir.Directive, dir.String())
                        }
                        _, err := SetFromArgs(cmd, dir.Args, ErrNotFound)
                        if err != nil {
                                return cmd, fmt.Errorf("error setting command from directive arguments (from comment %q): %w", dir.String(), err)
                        }
                }
                // we format the doc after the directives so that we have the up-to-date documentation and name
                cmd.Doc = types.FormatDoc(cmd.Doc, cfn, strcase.ToSentence(cmd.Name))
        }
        return cmd, nil
}

// cmdFromCmdOrFunc returns a new [Cmd] object from the given
// [CmdOrFunc] object, using [cmdFromFunc] if it is a function.
func cmdFromCmdOrFunc[T any, C CmdOrFunc[T]](cmd C) (*Cmd[T], error) {
        switch c := any(cmd).(type) {
        case *Cmd[T]:
                return c, nil
        case func(T) error:
                return cmdFromFunc(c)
        default:
                panic(fmt.Errorf("internal/programmer error: cli.CmdFromCmdOrFunc: impossible type %T for command %v", cmd, cmd))
        }
}

// CmdsFromCmdOrFuncs is a helper function that returns a slice
// of command objects from the given slice of [CmdOrFunc] objects,
// using [cmdFromCmdOrFunc].
func CmdsFromCmdOrFuncs[T any, C CmdOrFunc[T]](cmds []C) ([]*Cmd[T], error) {
        res := make([]*Cmd[T], len(cmds))
        for i, cmd := range cmds {
                cmd, err := cmdFromCmdOrFunc[T, C](cmd)
                if err != nil {
                        return nil, err
                }
                res[i] = cmd
        }
        return res, nil
}

// AddCmd adds the given command to the given set of commands
// if there is not already a command with the same name in the
// set of commands. Also, if [Cmd.Root] is set to true on the
// passed command, and there are no other root commands in the
// given set of commands, the passed command will be made the
// root command; otherwise, it will be made not the root command.
func AddCmd[T any](cmds []*Cmd[T], cmd *Cmd[T]) []*Cmd[T] {
        hasCmd := false
        hasRoot := false
        for _, c := range cmds {
                if c.Name == cmd.Name {
                        hasCmd = true
                }
                if c.Root {
                        hasRoot = true
                }
        }
        if hasCmd {
                return cmds
        }
        cmd.Root = cmd.Root && !hasRoot // we must both want root and be able to take root
        cmds = append(cmds, cmd)
        return cmds
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cli

import (
        "errors"
        "fmt"
        "os"
        "path/filepath"
        "slices"
        "strings"

        "cogentcore.org/core/base/logx"
)

// IMPORTANT: all changes to [metaConfig] must be updated in [metaConfigFields]

// metaConfig contains meta configuration information specified
// via command line arguments that controls the initial behavior
// of cli for all apps before anything else is loaded. Its
// main purpose is to support the help command and flag and
// the specification of custom config files on the command line.
type metaConfig struct {
        // the file name of the config file to load
        Config string `flag:"cfg,config"`

        // whether to display a help message
        Help bool `flag:"h,help"`

        // the name of the command to display
        // help information for. It is only applicable to the
        // help command, but it is enabled for all commands so
        // that it can consume all positional arguments to prevent
        // errors about unused arguments.
        HelpCmd string `posarg:"all"`

        // whether to run the command in verbose mode
        // and print more information
        Verbose bool `flag:"v,verbose"`

        // whether to run the command in very verbose mode
        // and print as much information as possible
        VeryVerbose bool `flag:"vv,very-verbose"`

        // whether to run the command in quiet mode
        // and print less information
        Quiet bool `flag:"q,quiet"`
}

// metaConfigFields is the struct used for the implementation
// of [addMetaConfigFields], and for the usage information for
// meta configuration options in [usage].
// NOTE: we could do this through [metaConfig], but that
// causes problems with the HelpCmd field capturing
// everything, so it easier to just add through a separate struct.
// TODO: maybe improve the structure of this.
// TODO: can we get HelpCmd to display correctly in usage?
type metaConfigFields struct { //types:add
        // the file name of the config file to load
        Config string `flag:"cfg,config"`

        // whether to display a help message
        Help bool `flag:"h,help"`

        // the name of the command to display
        // help information for.
        HelpCmd string `cmd:"help" posarg:"all"`

        // whether to run the command in verbose mode
        // and print more information
        Verbose bool `flag:"v,verbose"`

        // whether to run the command in very verbose mode
        // and print as much information as possible
        VeryVerbose bool `flag:"vv,very-verbose"`

        // whether to run the command in quiet mode
        // and print less information
        Quiet bool `flag:"q,quiet"`
}

// addMetaConfigFields adds meta fields that control the config process
// to the given map of fields. These fields have no actual effect and
// map to a placeholder value because they are handled elsewhere, but
// they must be set to prevent errors about missing flags. The flags
// that it adds are those in [metaConfig].
func addMetaConfigFields(allFields *fields) {
        addFields(&metaConfigFields{}, allFields, "")
}

// metaCmds is a set of commands based on [metaConfig] that
// contains a shell implementation of the help command.
var metaCmds = []*Cmd[*metaConfig]{
        {
                Func: func(mc *metaConfig) error { return nil }, // this gets handled seperately in [Config], so we don't actually need to do anything here
                Name: "help",
                Doc:  "show usage information for a command",
                Root: true,
        },
}

// OnConfigurer represents a configuration object that specifies a method to
// be called at the end of the [config] function, with the command that has
// been parsed as an argument.
type OnConfigurer interface {
        OnConfig(cmd string) error
}

// config is the main, high-level configuration setting function,
// processing config files and command-line arguments in the following order:
//   - Apply any `default:` field tag default values.
//   - Look for `--config`, `--cfg`, or `-c` arg, specifying a config file on the command line.
//   - Fall back on default config file name passed to `config` function, if arg not found.
//   - Read any `Include[s]` files in config file in deepest-first (natural) order,
//     then the specified config file last.
//   - If multiple config files are found, then they are applied in reverse order, meaning
//     that the first specified file takes the highest precedence.
//   - Process command-line args based on config field names.
//   - Boolean flags are set on with plain -flag; use No prefix to turn off
//     (or explicitly set values to true or false).
//
// config also processes -help and -h by printing the [usage] and quitting immediately.
// It takes [Options] that control its behavior, the configuration struct, which is
// what it sets, and the commands, which it uses for context. Also, it uses [os.Args]
// for its command-line arguments. It returns the command, if any, that was passed in
// [os.Args], and any error that ocurred during the configuration process.
func config[T any](opts *Options, cfg T, cmds ...*Cmd[T]) (string, error) {
        var errs []error
        err := SetFromDefaults(cfg)
        if err != nil {
                errs = append(errs, err)
        }

        args := os.Args[1:]

        // first, we do a pass to get the meta command flags
        // (help and config), which we need to know before
        // we can do other configuration.
        mc := &metaConfig{}
        // we ignore not found flags in meta config, because we only care about meta config and not anything else being passed to the command
        cmd, err := SetFromArgs(mc, args, NoErrNotFound, metaCmds...)
        if err != nil {
                // if we can't do first set for meta flags, we return immediately (we only do AllErrors for more specific errors)
                return cmd, fmt.Errorf("error doing meta configuration: %w", err)
        }
        logx.UserLevel = logx.LevelFromFlags(mc.VeryVerbose, mc.Verbose, mc.Quiet)

        // both flag and command trigger help
        if mc.Help || cmd == "help" {
                // string version of args slice has [] on the side, so need to get rid of them
                mc.HelpCmd = strings.TrimPrefix(strings.TrimSuffix(mc.HelpCmd, "]"), "[")
                // if flag and no posargs, will be nil
                if mc.HelpCmd == "nil" {
                        mc.HelpCmd = ""
                }
                fmt.Println(usage(opts, cfg, mc.HelpCmd, cmds...))
                os.Exit(0)
        }

        var cfgFiles []string
        if mc.Config != "" {
                cfgFiles = append(cfgFiles, mc.Config)
        }
        cfgFiles = append(cfgFiles, opts.DefaultFiles...)

        if opts.SearchUp {
                wd, err := os.Getwd()
                if err != nil {
                        return "", fmt.Errorf("error getting current directory: %w", err)
                }
                pwd := wd
                for {
                        pwd = wd
                        wd = filepath.Dir(pwd)
                        if wd == pwd { // if there is no change, we have reached the root of the filesystem
                                break
                        }
                        opts.IncludePaths = append(opts.IncludePaths, wd)
                }
        }

        if opts.NeedConfigFile && len(cfgFiles) == 0 {
                return "", errors.New("cli.Config: no config file or default files specified")
        }

        slices.Reverse(opts.IncludePaths)

        gotAny := false
        for _, fn := range cfgFiles {
                err = openWithIncludes(opts, cfg, fn)
                if err == nil {
                        logx.PrintlnDebug("loaded config file:", fn)
                        gotAny = true
                }
        }
        if !gotAny && opts.NeedConfigFile {
                return "", errors.New("cli.Config: no config files found")
        }

        cmd, err = SetFromArgs(cfg, args, ErrNotFound, cmds...)
        if err != nil {
                errs = append(errs, err)
        }
        if cfer, ok := any(cfg).(OnConfigurer); ok {
                err := cfer.OnConfig(cmd)
                if err != nil {
                        errs = append(errs, err)
                }
        }
        return cmd, errors.Join(errs...)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cli

import (
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
)

// SetFromDefaults sets the values of the given config object
// from `default:` struct field tag values. Errors are automatically
// logged in addition to being returned.
func SetFromDefaults(cfg any) error {
        return errors.Log(reflectx.SetFromDefaultTags(cfg))
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cli

import (
        "fmt"
        "strings"
        "unicode"

        "cogentcore.org/core/types"
        "github.com/mattn/go-shellwords"
)

// ParseDirective parses and returns a comment directive from
// the given comment string. The returned directive will be nil
// if there is no directive contained in the given comment.
// Directives are of the following form (the slashes are optional):
//
//        //tool:directive args...
func ParseDirective(comment string) (*types.Directive, error) {
        comment = strings.TrimPrefix(comment, "//")
        rs := []rune(comment)
        if len(rs) == 0 || unicode.IsSpace(rs[0]) { // directives must not have whitespace as their first character
                return nil, nil
        }
        // directives can not have newlines
        if strings.Contains(comment, "\n") {
                return nil, nil
        }
        before, after, found := strings.Cut(comment, ":")
        if !found {
                return nil, nil
        }
        directive := &types.Directive{}
        directive.Tool = before
        args, err := shellwords.Parse(after)
        if err != nil {
                return nil, fmt.Errorf("error parsing args: %w", err)
        }
        directive.Args = args
        if len(args) > 0 {
                directive.Directive = directive.Args[0]
                directive.Args = directive.Args[1:]
        }
        if len(directive.Args) == 0 {
                directive.Args = nil
        }
        return directive, nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "fmt"

        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/cli"
)

//go:generate core generate -add-types -add-funcs

type Config struct {

        // the name of the user
        Name string `flag:"name,nm,n"`

        // the age of the user
        Age int

        // whether the user likes Go
        LikesGo bool

        Build BuildConfig `cmd:"build"`

        Server Server
        Client Client

        // the directory to build in
        Dir string
}

type BuildConfig struct {

        // the target platform to build for
        Target string `flag:"target,build-target" posarg:"0"`

        // the platform to build the executable for
        Platform string `posarg:"1" required:"-"`
}

type Server struct {

        // the server platform
        Platform string
}

type Client struct {

        // the client platform
        Platform string `nest:"-"`
}

// Build builds the app for the config platform and target. It builds apps
// across platforms using the GOOS and GOARCH environment variables and a
// suitable C compiler located on the system.
//
// It is the main command used during a local development workflow, and
// it serves as a direct replacement for go build when building Cogent Core
// apps. In addition to the basic capacities of go build, Build supports
// cross-compiling CGO applications with ease. Also, it handles the
// bundling of icons and fonts into the executable.
//
// Build also uses GoMobile to support the building of .apk and .app
// files for Android and iOS mobile platforms, respectively. Its simple,
// unified, and configurable API for building applications makes it
// the best way to build applications, whether for local debug versions
// or production releases.
func Build(c *Config) error {
        fmt.Println("Building for target", c.Build.Target, "and platform", c.Build.Platform, "- user likes go:", c.LikesGo)
        return nil
}

// Run runs the app for the given user.
func Run(c *Config) error {
        fmt.Println("Running for user", c.Name, "- likes go:", c.LikesGo, "- user level:", logx.UserLevel)
        return nil
}

// Mod configures module information.
func Mod(c *Config) error {
        fmt.Println("running mod")
        return nil
}

// ModTidy tidies module information.
//
//cli:cmd -name "mod tidy"
func ModTidy(c *Config) error {
        fmt.Println("running mod tidy")
        return nil
}

// ModTidyRemote tidies module information for the remote.
//
//cli:cmd -name "mod tidy remote"
func ModTidyRemote(c *Config) error {
        fmt.Println("running mod tidy remote")
        return nil
}

// ModTidyRemoteSetURL tidies module information for the remote
// and sets its URL.
//
//cli:cmd -name "mod tidy remote set-url"
func ModTidyRemoteSetURL(c *Config) error {
        fmt.Println("running mod tidy remote set-url")
        return nil
}

func main() { //types:skip
        opts := cli.DefaultOptions("Basic", "Basic is a basic example application made with cli.")
        cli.Run(opts, &Config{}, Build, Run, Mod, ModTidy, ModTidyRemote, ModTidyRemoteSetURL)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cli

import (
        "log/slog"
        "os"
        "reflect"
        "strings"

        "slices"

        "cogentcore.org/core/base/ordmap"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/strcase"
)

// field represents a struct field in a configuration struct.
type field struct {
        // Field is the reflect struct field object for this field
        Field reflect.StructField
        // Value is the reflect value of the settable pointer to this field
        Value reflect.Value
        // Struct is the parent struct that contains this field
        Struct reflect.Value
        // Name is the fully qualified, nested name of this field (eg: A.B.C).
        // It is as it appears in code, and is NOT transformed something like kebab-case.
        Name string
        // Names contains all of the possible end-user names for this field as a flag.
        // It defaults to the name of the field, but custom names can be specified via
        // the cli struct tag.
        Names []string
}

// fields is a simple type alias for an ordered map of [field] objects.
type fields = ordmap.Map[string, *field]

// addAllFields, when passed as the command to [addFields], indicates
// to add all fields, regardless of their command association.
const addAllFields = "*"

// addFields adds to the given fields map all of the fields of the given
// object, in the context of the given command name. A value of [addAllFields]
// for cmd indicates to add all fields, regardless of their command association.
func addFields(obj any, allFields *fields, cmd string) {
        addFieldsImpl(obj, "", "", allFields, map[string]*field{}, cmd)
}

// addFieldsImpl is the underlying implementation of [addFields].
// The path is the current path state, the cmdPath is the
// current path state without command-associated names,
// and usedNames is a map keyed by used CamelCase names with values
// of their associated fields, used to track naming conflicts. The
// [field.Name]s of the fields are set based on the path, whereas the
// names of the flags are set based on the command path. The difference
// between the two is that the path is always fully qualified, whereas the
// command path omits the names of structs associated with commands via
// the "cmd" struct tag, as the user already knows what command they are
// running, so they do not need that duplicated specificity for every flag.
func addFieldsImpl(obj any, path string, cmdPath string, allFields *fields, usedNames map[string]*field, cmd string) {
        ov := reflect.ValueOf(obj)
        if reflectx.IsNil(ov) {
                return
        }
        val := reflectx.NonPointerValue(ov)
        typ := val.Type()

        for i := 0; i < typ.NumField(); i++ {
                f := typ.Field(i)
                if !f.IsExported() {
                        continue
                }
                fv := val.Field(i)
                pval := reflectx.PointerValue(fv)
                cmdTag, hct := f.Tag.Lookup("cmd")
                cmds := strings.Split(cmdTag, ",")
                if hct && !slices.Contains(cmds, cmd) && !slices.Contains(cmds, addAllFields) { // if we are associated with a different command, skip
                        continue
                }
                if reflectx.NonPointerType(f.Type).Kind() == reflect.Struct {
                        nwPath := f.Name
                        if path != "" {
                                nwPath = path + "." + nwPath
                        }
                        nwCmdPath := f.Name
                        // if we have a command tag, we don't scope our command path with our name,
                        // as we don't need it because we ran that command and know we are in it
                        if hct {
                                nwCmdPath = ""
                        }
                        if cmdPath != "" {
                                nwCmdPath = cmdPath + "." + nwCmdPath
                        }

                        addFieldsImpl(reflectx.PointerValue(fv).Interface(), nwPath, nwCmdPath, allFields, usedNames, cmd)
                        // we still add ourself if we are a struct, so we keep going,
                        // unless we are associated with a command, in which case there
                        // is no point in adding ourself
                        if hct {
                                continue
                        }
                }
                // we first add our unqualified command name, which is the best case scenario
                name := f.Name
                names := []string{name}
                // then, we set our future [Field.Name] to the fully path scoped version (but we don't add it as a command name)
                if path != "" {
                        name = path + "." + name
                }
                // then, we set add our command path scoped name as a command name
                if cmdPath != "" {
                        names = append(names, cmdPath+"."+f.Name)
                }

                flagTag, ok := f.Tag.Lookup("flag")
                if ok {
                        names = strings.Split(flagTag, ",")
                        if len(names) == 0 {
                                slog.Error("programmer error: expected at least one name in flag struct tag, but got none")
                        }
                }

                nf := &field{
                        Field:  f,
                        Value:  pval,
                        Struct: ov,
                        Name:   name,
                        Names:  names,
                }
                for i, name := range nf.Names {
                        // duplicate deletion can cause us to get out of range
                        if i >= len(nf.Names) {
                                break
                        }
                        name := strcase.ToCamel(name)        // everybody is in camel for naming conflict check
                        if of, has := usedNames[name]; has { // we have a conflict
                                // if we have a naming conflict between two fields with the same base
                                // (in the same parent struct), then there is no nesting and they have
                                // been directly given conflicting names, so there is a simple programmer error
                                nbase := ""
                                nli := strings.LastIndex(nf.Name, ".")
                                if nli >= 0 {
                                        nbase = nf.Name[:nli]
                                }
                                obase := ""
                                oli := strings.LastIndex(of.Name, ".")
                                if oli >= 0 {
                                        obase = of.Name[:oli]
                                }
                                if nbase == obase {
                                        slog.Error("programmer error: cli: two fields were assigned the same name", "name", name, "field0", of.Name, "field1", nf.Name)
                                        os.Exit(1)
                                }

                                // if that isn't the case, they are in different parent structs and
                                // it is a nesting problem, so we use the nest tags to resolve the conflict.
                                // the basic rule is that whoever specifies the nest:"-" tag gets to
                                // be non-nested, and if no one specifies it, everyone is nested.
                                // if both want to be non-nested, that is a programmer error.

                                // nest field tag values for new and other
                                nfns := nf.Field.Tag.Get("nest")
                                ofns := of.Field.Tag.Get("nest")

                                // whether new and other get to have non-nested version
                                nfn := nfns == "-" || nfns == "false"
                                ofn := ofns == "-" || ofns == "false"

                                if nfn && ofn {
                                        slog.Error(`programmer error: cli: nest:"-" specified on two config fields with the same name; keep nest:"-" on the field you want to be able to access without nesting and remove it from the other one`, "name", name, "field0", of.Name, "field1", nf.Name, "exampleFlagWithoutNesting", "-"+name, "exampleFlagWithNesting", "-"+strcase.ToKebab(nf.Name))
                                        os.Exit(1)
                                } else if !nfn && !ofn {
                                        // neither one gets it, so we replace both with fully qualified name
                                        applyShortestUniqueName(nf, i, usedNames)
                                        for i, on := range of.Names {
                                                if on == name {
                                                        applyShortestUniqueName(of, i, usedNames)
                                                }
                                        }
                                } else if nfn && !ofn {
                                        // we get it, so we keep ours as is and replace them with fully qualified name
                                        for i, on := range of.Names {
                                                if on == name {
                                                        applyShortestUniqueName(of, i, usedNames)
                                                }
                                        }
                                        // we also need to update the field for our name to us
                                        usedNames[name] = nf
                                } else if !nfn && ofn {
                                        // they get it, so we replace ours with fully qualified name
                                        applyShortestUniqueName(nf, i, usedNames)
                                }
                        } else {
                                // if no conflict, we get the name
                                usedNames[name] = nf
                        }
                }
                allFields.Add(name, nf)
        }
}

// applyShortestUniqueName uses [shortestUniqueName] to apply the shortest
// unique name for the given field, in the context of the given
// used names, at the given index.
func applyShortestUniqueName(field *field, idx int, usedNames map[string]*field) {
        nm := shortestUniqueName(field.Name, usedNames)
        // if we already have this name, we don't need to add it, so we just delete this entry
        if slices.Contains(field.Names, nm) {
                field.Names = slices.Delete(field.Names, idx, idx+1)
        } else {
                field.Names[idx] = nm
                usedNames[nm] = field
        }
}

// shortestUniqueName returns the shortest unique camel-case name for
// the given fully qualified nest name of a field, using the given
// map of used names. It works backwards, so, for example, if given "A.B.C.D",
// it would check "D", then "C.D", then "B.C.D", and finally "A.B.C.D".
func shortestUniqueName(name string, usedNames map[string]*field) string {
        strs := strings.Split(name, ".")
        cur := ""
        for i := len(strs) - 1; i >= 0; i-- {
                if cur == "" {
                        cur = strs[i]
                } else {
                        cur = strs[i] + "." + cur
                }
                if _, has := usedNames[cur]; !has {
                        return cur
                }
        }
        return cur // TODO: this should never happen, but if it does, we might want to print an error
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// note: FindFileOnPaths adapted from viper package https://github.com/spf13/viper
// Copyright (c) 2014 Steve Francia

package cli

import (
        "errors"
        "reflect"

        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/iox/tomlx"
        "cogentcore.org/core/base/reflectx"
)

// TODO(kai): this seems bad

// includer is an interface that facilitates processing
// include files in configuration objects.
type includer interface {
        // IncludesPtr returns a pointer to the "Includes []string"
        // field containing file(s) to include before processing
        // the current config file.
        IncludesPtr() *[]string
}

// includeStack returns the stack of include files in the natural
// order in which they are encountered (nil if none).
// Files should then be read in reverse order of the slice.
// Returns an error if any of the include files cannot be found on IncludePath.
// Does not alter cfg.
func includeStack(opts *Options, cfg includer) ([]string, error) {
        clone := reflect.New(reflectx.NonPointerType(reflect.TypeOf(cfg))).Interface().(includer)
        *clone.IncludesPtr() = *cfg.IncludesPtr()
        return includeStackImpl(opts, clone, nil)
}

// includeStackImpl implements IncludeStack, operating on cloned cfg
// todo: could use a more efficient method to just extract the include field..
func includeStackImpl(opts *Options, clone includer, includes []string) ([]string, error) {
        incs := *clone.IncludesPtr()
        ni := len(incs)
        if ni == 0 {
                return includes, nil
        }
        for i := ni - 1; i >= 0; i-- {
                includes = append(includes, incs[i]) // reverse order so later overwrite earlier
        }
        var errs []error
        for _, inc := range incs {
                *clone.IncludesPtr() = nil
                err := tomlx.OpenFiles(clone, fsx.FindFilesOnPaths(opts.IncludePaths, inc)...)
                if err == nil {
                        includes, err = includeStackImpl(opts, clone, includes)
                        if err != nil {
                                errs = append(errs, err)
                        }
                } else {
                        errs = append(errs, err)
                }
        }
        return includes, errors.Join(errs...)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cli

import (
        "fmt"

        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/iox/tomlx"
)

// openWithIncludes reads the config struct from the given config file
// using the given options, looking on [Options.IncludePaths] for the file.
// It opens any Includes specified in the given config file in the natural
// include order so that includers overwrite included settings.
// Is equivalent to Open if there are no Includes. It returns an error if
// any of the include files cannot be found on [Options.IncludePaths].
func openWithIncludes(opts *Options, cfg any, file string) error {
        files := fsx.FindFilesOnPaths(opts.IncludePaths, file)
        if len(files) == 0 {
                return fmt.Errorf("OpenWithIncludes: no files found for %q", file)
        }
        err := tomlx.OpenFiles(cfg, files...)
        if err != nil {
                return err
        }
        incfg, ok := cfg.(includer)
        if !ok {
                return err
        }
        incs, err := includeStack(opts, incfg)
        ni := len(incs)
        if ni == 0 {
                return err
        }
        for i := ni - 1; i >= 0; i-- {
                inc := incs[i]
                err = tomlx.OpenFiles(cfg, fsx.FindFilesOnPaths(opts.IncludePaths, inc)...)
                if err != nil {
                        fmt.Println(err)
                }
        }
        // reopen original
        err = tomlx.OpenFiles(cfg, fsx.FindFilesOnPaths(opts.IncludePaths, file)...)
        if err != nil {
                return err
        }
        *incfg.IncludesPtr() = incs
        return err
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cli

import "cogentcore.org/core/base/strcase"

// Options contains the options passed to cli
// that control its behavior.
type Options struct {

        // AppName is the name of the cli app.
        AppName string

        // AppAbout is the description of the cli app.
        AppAbout string

        // Fatal is whether to, if there is an error in [Run],
        // print it and fatally exit the program through [os.Exit]
        // with an exit code of 1.
        Fatal bool

        // PrintSuccess is whether to print a message indicating
        // that a command was successful after it is run, unless
        // the user passes -q or -quiet to the command, in which
        // case the success message will always not be printed.
        PrintSuccess bool

        // DefaultEncoding is the default encoding format for config files.
        // currently toml is the only supported format, but others could be added
        // if needed.
        DefaultEncoding string

        // DefaultFiles are the default configuration file paths
        DefaultFiles []string

        // IncludePaths is a list of file paths to try for finding config files
        // specified in Include field or via the command line --config --cfg or -c args.
        // Set this prior to calling Config; default is current directory '.' and 'configs'.
        // The include paths are searched in reverse order such that first specified include
        // paths get the highest precedence (config files found in earlier include paths
        // override those found in later ones).
        IncludePaths []string

        // SearchUp indicates whether to search up the filesystem
        // for the default config file by checking the provided default
        // config file location relative to each directory up the tree
        SearchUp bool

        // NeedConfigFile indicates whether a configuration file
        // must be provided for the command to run
        NeedConfigFile bool
}

// DefaultOptions returns a new [Options] value
// with standard default values, based on the given
// app name and optional app about info.
func DefaultOptions(name string, about ...string) *Options {
        abt := ""
        if len(about) > 0 {
                abt = about[0]
        }
        return &Options{
                AppName:         name,
                AppAbout:        abt,
                Fatal:           true,
                PrintSuccess:    true,
                DefaultEncoding: "toml",
                DefaultFiles:    []string{strcase.ToKebab(name) + ".toml"},
                IncludePaths:    []string{".", "configs"},
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cli

import (
        "fmt"
        "log/slog"
        "os"
        "runtime/debug"
        "slices"
        "strconv"
        "strings"

        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/types"
)

// indent is the value used for indentation in [usage].
var indent = "    "

// usage returns a usage string based on the given options,
// configuration struct, current command, and available commands.
// It contains [AppAbout], a list of commands and their descriptions,
// and a list of flags and their descriptions, scoped based on the
// current command and its associated commands and configuration.
// The resulting string contains color escape codes.
func usage[T any](opts *Options, cfg T, cmd string, cmds ...*Cmd[T]) string {
        var b strings.Builder
        if cmd == "" {
                if opts.AppAbout != "" {
                        b.WriteString("\n" + opts.AppAbout + "\n\n")
                }
        } else {
                gotCmd := false
                for _, c := range cmds {
                        if c.Name == cmd {
                                if c.Doc != "" {
                                        b.WriteString("\n" + c.Doc + "\n\n")
                                }
                                gotCmd = true
                                break
                        }
                }
                if !gotCmd {
                        fmt.Println(logx.CmdColor(cmdName()+" help") + logx.ErrorColor(fmt.Sprintf(" failed: command %q not found", cmd)))
                        os.Exit(1)
                }
        }

        if bi, ok := debug.ReadBuildInfo(); ok {
                revision, time := "dev", "unknown"
                for _, set := range bi.Settings {
                        if set.Key == "vcs.revision" {
                                revision = set.Value
                        }
                        if set.Key == "vcs.time" {
                                time = set.Value
                        }
                }
                b.WriteString(logx.TitleColor("Version: ") + fmt.Sprintf("%s (%s)\n\n", revision, time))
        }

        fs := &fields{}
        addFields(cfg, fs, cmd)

        cmdName := cmdName()
        if cmd != "" {
                cmdName += " " + cmd
        }
        b.WriteString(logx.TitleColor("Usage:\n") + indent + logx.CmdColor(cmdName+" "))

        posArgStrs := []string{}

        for _, kv := range fs.Order {
                v := kv.Value
                f := v.Field

                posArgTag, ok := f.Tag.Lookup("posarg")
                if ok {
                        ui := uint64(0)
                        if posArgTag == "all" || posArgTag == "leftover" {
                                ui = uint64(len(posArgStrs))
                        } else {
                                var err error
                                ui, err = strconv.ParseUint(posArgTag, 10, 64)
                                if err != nil {
                                        slog.Error("programmer error: invalid value for posarg struct tag", "field", f.Name, "posArgTag", posArgTag, "err", err)
                                }
                        }
                        // if the slice isn't big enough, grow it to fit this posarg
                        if ui >= uint64(len(posArgStrs)) {
                                posArgStrs = slices.Grow(posArgStrs, len(posArgStrs)-int(ui)+1) // increase capacity
                                posArgStrs = posArgStrs[:ui+1]                                  // extend to capacity
                        }
                        nm := strcase.ToKebab(v.Names[0])
                        req, has := f.Tag.Lookup("required")
                        if req == "+" || req == "true" || !has { // default is required, so !has => required
                                posArgStrs[ui] = logx.CmdColor("<" + nm + ">")
                        } else {
                                posArgStrs[ui] = logx.SuccessColor("[" + nm + "]")
                        }
                }
        }
        b.WriteString(strings.Join(posArgStrs, " "))
        if len(posArgStrs) > 0 {
                b.WriteString(" ")
        }
        b.WriteString(logx.SuccessColor("[flags]\n"))

        commandUsage(&b, cmdName, cmd, cmds...)

        b.WriteString(logx.TitleColor("\nFlags:\n") + indent + logx.TitleColor("Flags are case-insensitive, can be in kebab-case, snake_case,\n"))
        b.WriteString(indent + logx.TitleColor("or CamelCase, and can have one or two leading dashes. Use a\n"))
        b.WriteString(indent + logx.TitleColor("\"no\" prefix to turn off a bool flag.\n\n"))

        // add meta ones (help, config, verbose, etc) first
        mcfields := &fields{}
        addMetaConfigFields(mcfields)
        flagUsage(mcfields, &b)

        flagUsage(fs, &b)
        return b.String()
}

// commandUsage adds the command usage info for the given commands to the
// given [strings.Builder].
// It also takes the full name of our command as it appears in the terminal (cmdName),
// (eg: "core build"), and the name of the command we are running (eg: "build").
//
// To be a command that is included in the usage, we must be one command
// nesting depth (subcommand) deeper than the current command (ie, if we
// are on "x", we can see usage for commands of the form "x y"), and all
// of our commands must be consistent with the current command. For example,
// "" could generate usage for "help", "build", and "run", and "mod" could
// generate usage for "mod init", "mod tidy", and "mod edit". This ensures
// that only relevant commands are shown in the usage.
func commandUsage[T any](b *strings.Builder, cmdName string, cmd string, cmds ...*Cmd[T]) {
        acmds := []*Cmd[T]{}           // actual commands we care about
        var rcmd *Cmd[T]               // root command
        cmdstrs := strings.Fields(cmd) // subcommand strings in passed command

        // need this label so that we can continue outer loop when we have non-matching cmdstr
outer:
        for _, c := range cmds {
                cstrs := strings.Fields(c.Name)   // subcommand strings in command we are checking
                if len(cstrs) != len(cmdstrs)+1 { // we must be one deeper
                        continue
                }
                for i, cmdstr := range cmdstrs {
                        if cmdstr != cstrs[i] { // every subcommand so far must match
                                continue outer
                        }
                }
                if c.Root {
                        rcmd = c
                } else if c.Name != cmd { // if it is the same subcommand we are already on, we handle it above in main Usage
                        acmds = append(acmds, c)
                }
        }

        if len(acmds) != 0 {
                b.WriteString(indent + logx.CmdColor(cmdName+" <subcommand> ") + logx.SuccessColor("[flags]\n"))
        }

        if rcmd != nil {
                b.WriteString(logx.TitleColor("\nDefault command:\n"))
                b.WriteString(indent + logx.CmdColor(rcmd.Name) + "\n" + indent + indent + strings.ReplaceAll(rcmd.Doc, "\n", "\n"+indent+indent) + "\n") // need to put two indents on every newline for formatting
        }

        if len(acmds) == 0 && cmd != "" { // nothing to do
                return
        }

        b.WriteString(logx.TitleColor("\nSubcommands:\n"))

        // if we are in root, we also add help
        if cmd == "" {
                b.WriteString(indent + logx.CmdColor("help") + "\n" + indent + indent + "Help shows usage information for a command\n")
        }

        for _, c := range acmds {
                b.WriteString(indent + logx.CmdColor(c.Name))
                if c.Doc != "" {
                        // we only want the first paragraph of text for subcommand usage; after that is where more specific details can go
                        doc, _, _ := strings.Cut(c.Doc, "\n\n")
                        b.WriteString("\n" + indent + indent + strings.ReplaceAll(doc, "\n", "\n"+indent+indent)) // need to put two indents on every newline for formatting
                }
                b.WriteString("\n")
        }
}

// flagUsage adds the flag usage info for the given fields
// to the given [strings.Builder].
func flagUsage(fields *fields, b *strings.Builder) {
        for _, kv := range fields.Order {
                f := kv.Value
                b.WriteString(indent)
                for i, name := range f.Names {
                        b.WriteString(logx.CmdColor("-" + strcase.ToKebab(name)))
                        if i != len(f.Names)-1 {
                                b.WriteString(", ")
                        }
                }
                b.WriteString(" " + logx.SuccessColor(f.Field.Type.String()))
                b.WriteString("\n")
                field := types.GetField(f.Struct, f.Field.Name)
                if field != nil {
                        b.WriteString(indent + indent + strings.ReplaceAll(field.Doc, "\n", "\n"+indent+indent)) // need to put two indents on every newline for formatting
                }
                def, ok := f.Field.Tag.Lookup("default")
                if ok && def != "" {
                        b.WriteString(fmt.Sprintf(" (default: %s)", def))
                }
                b.WriteString("\n")
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package cmd provides utilities for managing
// apps and packages that use the Cogent Core framework.
package cmd

//go:generate core generate

import (
        "errors"
        "fmt"
        "os"
        "path/filepath"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/mobile"
        "cogentcore.org/core/cmd/core/web"
)

// Build builds an executable for the package
// at the config path for the config platforms.
func Build(c *config.Config) error { //types:add
        if len(c.Build.Target) == 0 {
                return errors.New("build: expected at least 1 platform")
        }
        for _, platform := range c.Build.Target {
                err := config.OSSupported(platform.OS)
                if err != nil {
                        return err
                }
                if platform.Arch != "*" {
                        err := config.ArchSupported(platform.Arch)
                        if err != nil {
                                return err
                        }
                }
                if platform.OS == "android" || platform.OS == "ios" {
                        return mobile.Build(c)
                }
                if platform.OS == "web" {
                        err := os.MkdirAll(c.Build.Output, 0777)
                        if err != nil {
                                return err
                        }
                        return web.Build(c)
                }
                err = buildDesktop(c, platform)
                if err != nil {
                        return fmt.Errorf("build: %w", err)
                }
        }
        return nil
}

// buildDesktop builds an executable for the config package for the given desktop platform.
func buildDesktop(c *config.Config, platform config.Platform) error {
        xc := exec.Major()
        xc.Env["GOOS"] = platform.OS
        xc.Env["GOARCH"] = platform.Arch

        args := []string{"build"}
        if c.Build.Debug {
                args = append(args, "-tags", "debug")
        }
        if c.Build.Trimpath {
                args = append(args, "-trimpath")
        }
        ldflags := ""
        output := filepath.Base(c.Build.Output)
        if platform.OS == "windows" {
                output += ".exe"
                // see https://stackoverflow.com/questions/23250505/how-do-i-create-an-executable-from-golang-that-doesnt-open-a-console-window-whe
                if c.Build.Windowsgui {
                        ldflags += " -H=windowsgui"
                }
        }
        ldflags += " " + config.LinkerFlags(c)
        args = append(args, "-ldflags", ldflags, "-o", filepath.Join(c.Build.Output, output))

        err := xc.Run("go", args...)
        if err != nil {
                return fmt.Errorf("error building for platform %s/%s: %w", platform.OS, platform.Arch, err)
        }

        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cmd

import (
        "errors"
        "fmt"
        "io/fs"
        "os"
        "path/filepath"
        "strings"
        "sync"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/cmd/core/config"
)

// Changed concurrently prints all of the repositories within this directory
// that have been changed and need to be updated in Git.
func Changed(c *config.Config) error { //types:add
        wg := sync.WaitGroup{}
        errs := []error{}
        fs.WalkDir(os.DirFS("."), ".", func(path string, d fs.DirEntry, err error) error {
                wg.Add(1)
                go func() {
                        defer wg.Done()
                        if d.Name() != ".git" {
                                return
                        }
                        dir := filepath.Dir(path)
                        out, err := exec.Major().SetDir(dir).Output("git", "diff")
                        if err != nil {
                                errs = append(errs, fmt.Errorf("error getting diff of %q: %w", dir, err))
                                return
                        }
                        if out != "" { // if we have a diff, we have been changed
                                fmt.Println(logx.CmdColor(dir))
                                return
                        }
                        // if we don't have a diff, we also check to make sure we aren't ahead of the remote
                        out, err = exec.Minor().SetDir(dir).Output("git", "status")
                        if err != nil {
                                errs = append(errs, fmt.Errorf("error getting status of %q: %w", dir, err))
                                return
                        }
                        if strings.Contains(out, "Your branch is ahead") { // if we are ahead, we have been changed
                                fmt.Println(logx.CmdColor(dir))
                        }
                }()
                return nil
        })
        wg.Wait()
        fmt.Println("")
        return errors.Join(errs...)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cmd

import (
        "errors"
        "fmt"
        "path/filepath"
        "runtime"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/mobile"
)

// Install installs the package on the local system.
// It uses the same config info as build.
func Install(c *config.Config) error { //types:add
        for i, p := range c.Build.Target {
                err := config.OSSupported(p.OS)
                if err != nil {
                        return fmt.Errorf("install: %w", err)
                }
                if p.Arch == "*" {
                        if p.OS == "android" || p.OS == "ios" {
                                p.Arch = "arm64"
                        } else {
                                p.Arch = runtime.GOARCH
                        }
                        c.Build.Target[i] = p
                }

                switch p.OS {
                case "android", "ios":
                        err := Build(c)
                        if err != nil {
                                return fmt.Errorf("error building: %w", err)
                        }
                        // we only want this target for install
                        ot := c.Build.Target
                        c.Build.Target = []config.Platform{p}
                        err = mobile.Install(c)
                        c.Build.Target = ot
                        if err != nil {
                                return fmt.Errorf("install: %w", err)
                        }
                case "web":
                        return errors.New("can not install on platform web; use build or run instead")
                case "darwin":
                        c.Pack.DMG = false
                        err := Pack(c)
                        if err != nil {
                                return err
                        }
                        return exec.Run("cp", "-a", filepath.Join(c.Build.Output, c.Name+".app"), "/Applications")
                default:
                        return exec.Major().SetEnv("GOOS", p.OS).SetEnv("GOARCH", runtime.GOARCH).Run("go", "install")
                }
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cmd

import (
        "errors"
        "fmt"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/cmd/core/config"
)

// Log prints the logs from your app running on Android to the terminal.
// Android is the only supported platform for log; use the -debug flag on
// run for other platforms.
func Log(c *config.Config) error { //types:add
        if c.Log.Target != "android" {
                return errors.New("only android is supported for log; use the -debug flag on run for other platforms")
        }
        if !c.Log.Keep {
                err := exec.Run("adb", "logcat", "-c")
                if err != nil {
                        return fmt.Errorf("error clearing logs: %w", err)
                }
        }
        // we are logging continiously so we can't buffer, and we must be verbose
        err := exec.Verbose().SetBuffer(false).Run("adb", "logcat", "*:"+c.Log.All, "Go:D", "GoLog:D", "GoLogWGPU:D")
        if err != nil {
                return fmt.Errorf("erroring getting logs: %w", err)
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cmd

import (
        _ "embed"
        "os"
        "path/filepath"
        "strings"
        "text/template"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/rendericon"
        "github.com/jackmordaunt/icns/v2"
)

// Pack builds and packages the app for the target platform.
// For android, ios, and web, it is equivalent to build.
func Pack(c *config.Config) error { //types:add
        err := Build(c)
        if err != nil {
                return err
        }
        for _, platform := range c.Build.Target {
                switch platform.OS {
                case "android", "ios", "web": // build already packages
                        continue
                case "linux":
                        err := packLinux(c)
                        if err != nil {
                                return err
                        }
                case "darwin":
                        err := packDarwin(c)
                        if err != nil {
                                return err
                        }
                case "windows":
                        err := packWindows(c)
                        if err != nil {
                                return err
                        }
                }
        }
        return nil
}

// packLinux packages the app for Linux by generating a .deb file.
func packLinux(c *config.Config) error {
        // based on https://ubuntuforums.org/showthread.php?t=910717

        anm := strcase.ToKebab(c.Name)
        vnm := strings.TrimPrefix(c.Version, "v")
        avnm := anm + "_" + vnm

        bpath := c.Build.Output
        apath := filepath.Join(bpath, avnm)
        ulbpath := filepath.Join(apath, "usr", "local", "bin")
        usipath := filepath.Join(apath, "usr", "share", "icons", "hicolor")
        usapath := filepath.Join(apath, "usr", "share", "applications")
        dpath := filepath.Join(apath, "DEBIAN")

        err := os.MkdirAll(ulbpath, 0777)
        if err != nil {
                return err
        }
        err = exec.Run("cp", "-p", filepath.Base(c.Build.Output), filepath.Join(ulbpath, anm))
        if err != nil {
                return err
        }

        // see https://martin.hoppenheit.info/blog/2016/where-to-put-application-icons-on-linux/
        // TODO(kai): consider rendering more icon sizes and/or an XPM icon
        ic, err := rendericon.Render(48)
        if err != nil {
                return err
        }
        i48path := filepath.Join(usipath, "48x48", "apps")
        err = os.MkdirAll(i48path, 0777)
        if err != nil {
                return err
        }
        err = imagex.Save(ic, filepath.Join(i48path, anm+".png"))
        if err != nil {
                return err
        }
        iscpath := filepath.Join(usipath, "scalable", "apps")
        err = os.MkdirAll(iscpath, 0777)
        if err != nil {
                return err
        }
        err = exec.Run("cp", "icon.svg", filepath.Join(iscpath, anm+".svg"))
        if err != nil {
                return err
        }

        // we need a description
        if c.About == "" {
                c.About = c.Name
        }

        err = os.MkdirAll(usapath, 0777)
        if err != nil {
                return err
        }
        fapp, err := os.Create(filepath.Join(usapath, anm+".desktop"))
        if err != nil {
                return err
        }
        defer fapp.Close()
        dfd := &desktopFileData{
                Name: c.Name,
                Desc: c.About,
                Exec: anm,
        }
        err = desktopFileTmpl.Execute(fapp, dfd)
        if err != nil {
                return err
        }

        err = os.MkdirAll(dpath, 0777)
        if err != nil {
                return err
        }
        fctrl, err := os.Create(filepath.Join(dpath, "control"))
        if err != nil {
                return err
        }
        defer fctrl.Close()
        dcd := &debianControlData{
                Name:    anm,
                Version: vnm,
                Desc:    c.About,
        }
        err = debianControlTmpl.Execute(fctrl, dcd)
        if err != nil {
                return err
        }
        return exec.Run("dpkg-deb", "--build", apath)
}

// desktopFileData is the data passed to [desktopFileTmpl]
type desktopFileData struct {
        Name string
        Desc string
        Exec string
}

// TODO(kai): project website

// desktopFileTmpl is the template for the Linux .desktop file
var desktopFileTmpl = template.Must(template.New("desktopFileTmpl").Parse(
        `[Desktop Entry]
Type=Application
Version=1.0
Name={{.Name}}
Comment={{.Desc}}
Exec={{.Exec}}
Icon={{.Exec}}
Terminal=false
`))

// debianControlData is the data passed to [debianControlTmpl]
type debianControlData struct {
        Name    string
        Version string
        Desc    string
}

// TODO(kai): architecture, maintainer, dependencies

// debianControlTmpl is the template for the Linux DEBIAN/control file
var debianControlTmpl = template.Must(template.New("debianControlTmpl").Parse(
        `Package: {{.Name}}
Version: {{.Version}}
Section: base
Priority: optional
Architecture: all
Maintainer: Your Name <you@email.com>
Description: {{.Desc}}
`))

// packDarwin packages the app for macOS by generating a .app and .dmg file.
func packDarwin(c *config.Config) error {
        // based on https://github.com/machinebox/appify

        anm := c.Name + ".app"

        bpath := c.Build.Output
        apath := filepath.Join(bpath, anm)
        cpath := filepath.Join(apath, "Contents")
        mpath := filepath.Join(cpath, "MacOS")
        rpath := filepath.Join(cpath, "Resources")

        err := os.MkdirAll(mpath, 0777)
        if err != nil {
                return err
        }
        err = os.MkdirAll(rpath, 0777)
        if err != nil {
                return err
        }

        err = exec.Run("cp", "-p", filepath.Base(c.Build.Output), filepath.Join(mpath, anm))
        if err != nil {
                return err
        }
        err = exec.Run("chmod", "+x", mpath)
        if err != nil {
                return err
        }

        inm := filepath.Join(rpath, "icon.icns")
        fdsi, err := os.Create(inm)
        if err != nil {
                return err
        }
        defer fdsi.Close()
        // 1024x1024 is the largest icon size on macOS
        sic, err := rendericon.Render(1024)
        if err != nil {
                return err
        }
        err = icns.Encode(fdsi, sic)
        if err != nil {
                return err
        }

        fplist, err := os.Create(filepath.Join(cpath, "Info.plist"))
        if err != nil {
                return err
        }
        defer fplist.Close()
        ipd := &infoPlistData{
                Name:               c.Name,
                Executable:         filepath.Join("MacOS", anm),
                Identifier:         c.ID,
                Version:            c.Version,
                InfoString:         c.About,
                ShortVersionString: c.Version,
                IconFile:           filepath.Join("Contents", "Resources", "icon.icns"),
        }
        err = infoPlistTmpl.Execute(fplist, ipd)
        if err != nil {
                return err
        }

        if !c.Pack.DMG {
                return nil
        }
        // install dmgbuild if we don't already have it
        if _, err := exec.LookPath("dmgbuild"); err != nil {
                err = exec.Verbose().SetBuffer(false).Run("pip", "install", "dmgbuild")
                if err != nil {
                        return err
                }
        }
        dmgsnm := filepath.Join(bpath, ".tempDmgBuildSettings.py")
        fdmg, err := os.Create(dmgsnm)
        if err != nil {
                return err
        }
        defer fdmg.Close()
        dmgbd := &dmgBuildData{
                AppPath:  apath,
                AppName:  anm,
                IconPath: inm,
        }
        err = dmgBuildTmpl.Execute(fdmg, dmgbd)
        if err != nil {
                return err
        }
        err = exec.Run("dmgbuild",
                "-s", dmgsnm,
                c.Name, filepath.Join(bpath, c.Name+".dmg"))
        if err != nil {
                return err
        }
        return os.Remove(dmgsnm)
}

// infoPlistData is the data passed to [infoPlistTmpl]
type infoPlistData struct {
        Name               string
        Executable         string
        Identifier         string
        Version            string
        InfoString         string
        ShortVersionString string
        IconFile           string
}

// infoPlistTmpl is the template for the macOS .app Info.plist
var infoPlistTmpl = template.Must(template.New("infoPlistTmpl").Parse(
        `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
        <dict>
                <key>CFBundlePackageType</key>
                <string>APPL</string>
                <key>CFBundleInfoDictionaryVersion</key>
                <string>6.0</string>
                <key>CFBundleName</key>
                <string>{{ .Name }}</string>
                <key>CFBundleExecutable</key>
                <string>{{ .Executable }}</string>
                <key>CFBundleIdentifier</key>
                <string>{{ .Identifier }}</string>
                <key>CFBundleVersion</key>
                <string>{{ .Version }}</string>
                <key>CFBundleGetInfoString</key>
                <string>{{ .InfoString }}</string>
                <key>CFBundleShortVersionString</key>
                <string>{{ .ShortVersionString }}</string>
                <key>CFBundleIconFile</key>
                <string>{{ .IconFile }}</string>
        </dict>
</plist>
`))

// dmgBuildData is the data passed to [dmgBuildTmpl]
type dmgBuildData struct {
        AppPath  string
        AppName  string
        IconPath string
}

// dmgBuildTmpl is the template for the dmgbuild python settings file
var dmgBuildTmpl = template.Must(template.New("dmgBuildTmpl").Parse(
        `files = ['{{.AppPath}}']
symlinks = {"Applications": "/Applications"}
icon = '{{.IconPath}}'
icon_locations = {'{{.AppName}}': (140, 120), "Applications": (500, 120)}
background = "builtin-arrow"
`))

// packWindows packages the app for Windows by generating a .msi file.
func packWindows(c *config.Config) error {
        opath := c.Build.Output
        ipath := filepath.Join(opath, "tempWindowsInstaller")
        gpath := filepath.Join(ipath, "installer.go")
        epath := filepath.Join(opath, c.Name+" Installer.exe")

        err := os.MkdirAll(ipath, 0777)
        if err != nil {
                return err
        }

        fman, err := os.Create(gpath)
        if err != nil {
                return err
        }
        wmd := &windowsInstallerData{
                Name: c.Name,
                Desc: c.About,
        }
        err = windowsInstallerTmpl.Execute(fman, wmd)
        fman.Close()
        if err != nil {
                return err
        }

        err = exec.Run("cp", filepath.Base(c.Build.Output)+".exe", filepath.Join(ipath, "app.exe"))
        if err != nil {
                return err
        }
        err = exec.Run("cp", "icon.svg", filepath.Join(ipath, "icon.svg"))
        if err != nil {
                return err
        }

        err = exec.Run("go", "build", "-o", epath, gpath)
        if err != nil {
                return err
        }

        return os.RemoveAll(ipath)
}

// windowsInstallerData is the data passed to [windowsInstallerTmpl]
type windowsInstallerData struct {
        Name string
        Desc string
}

//go:embed windowsinstaller.go.tmpl
var windowsInstallerTmplString string

// windowsInstallerTmpl is the template for the Windows installer Go file
var windowsInstallerTmpl = template.Must(template.New("windowsInstallerTmpl").Parse(windowsInstallerTmplString))

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cmd

import (
        "errors"
        "fmt"
        "io/fs"
        "os"
        "path/filepath"
        "sync"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/cmd/core/config"
)

// Pull concurrently pulls all of the Git repositories within the current directory.
func Pull(c *config.Config) error { //types:add
        wg := sync.WaitGroup{}
        errs := []error{}
        fs.WalkDir(os.DirFS("."), ".", func(path string, d fs.DirEntry, err error) error {
                wg.Add(1)
                go func() {
                        defer wg.Done()
                        if d.Name() != ".git" {
                                return
                        }
                        dir := filepath.Dir(path)
                        err := exec.Major().SetDir(dir).Run("git", "pull")
                        if err != nil {
                                errs = append(errs, fmt.Errorf("error pulling %q: %w", dir, err))
                        }
                }()
                return nil
        })
        wg.Wait()
        return errors.Join(errs...)
}

//go:build !windows

package cmd

func windowsRegistryAddPath(path string) error {
        return nil // no-op
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cmd

import (
        "fmt"
        "strings"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/cmd/core/config"
        "github.com/Masterminds/semver/v3"
)

// Release releases the project with the specified git version tag.
func Release(c *config.Config) error { //types:add
        err := exec.Run("git", "tag", "-a", c.Version, "-m", c.Version+" release")
        if err != nil {
                return fmt.Errorf("error tagging release: %w", err)
        }
        err = exec.Run("git", "push", "origin", "--tags")
        if err != nil {
                return fmt.Errorf("error pushing tags: %w", err)
        }
        return nil
}

// NextRelease releases the project with the current git version
// tag incremented by one patch version.
func NextRelease(c *config.Config) error { //types:add
        ver, err := nextVersion(c)
        if err != nil {
                return err
        }
        c.Version = ver
        return Release(c)
}

// nextVersion returns the version of the project
// incremented by one patch version.
func nextVersion(c *config.Config) (string, error) {
        cur, err := exec.Output("git", "describe", "--tags", "--abbrev=0")
        if err != nil {
                return "", err
        }
        ver, err := semver.NewVersion(cur)
        if err != nil {
                return "", fmt.Errorf("error getting semver version from version %q: %w", c.Version, err)
        }

        if !strings.HasPrefix(ver.Prerelease(), "dev") { // if no dev pre-release, we can just do standard increment
                *ver = ver.IncPatch()
        } else { // otherwise, we have to increment pre-release version instead
                pvn := strings.TrimPrefix(ver.Prerelease(), "dev")
                pver, err := semver.NewVersion(pvn)
                if err != nil {
                        return "", fmt.Errorf("error parsing dev version %q from version %q: %w", pvn, c.Version, err)
                }
                *pver = pver.IncPatch()
                // apply incremented pre-release version to main version
                nv, err := ver.SetPrerelease("dev" + pver.String())
                if err != nil {
                        return "", fmt.Errorf("error setting pre-release of new version to %q from repository version %q: %w", "dev"+pver.String(), c.Version, err)
                }
                *ver = nv
        }
        return "v" + ver.String(), nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cmd

import (
        "fmt"
        "path/filepath"
        "runtime"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/mobile"
        "cogentcore.org/core/cmd/core/web"
)

// Run builds and runs the config package. It also displays the logs generated
// by the app. It uses the same config info as build.
func Run(c *config.Config) error { //types:add
        if len(c.Build.Target) != 1 {
                return fmt.Errorf("expected 1 target platform, but got %d (%v)", len(c.Build.Target), c.Build.Target)
        }
        t := c.Build.Target[0]
        if t.Arch == "*" {
                if t.OS == "android" || t.OS == "ios" {
                        t.Arch = "arm64"
                } else {
                        t.Arch = runtime.GOARCH
                }
                c.Build.Target[0] = t
        }

        if t.OS == "ios" && !c.Build.Debug {
                // TODO: is there a way to launch without running the debugger?
                logx.PrintlnWarn("warning: only installing, not running, because there is no effective way to just launch an app on iOS from the terminal without debugging; pass the -d flag to run and debug")
        }

        if t.OS == "web" {
                // needed for changes to show during local development
                c.Web.RandomVersion = true
        }

        err := Build(c)
        if err != nil {
                return fmt.Errorf("error building app: %w", err)
        }
        // Build may have added iossimulator, so we get rid of it for
        // the running stage (we already confirmed we were passed 1 up above)
        if len(c.Build.Target) > 1 {
                c.Build.Target = []config.Platform{t}
        }
        switch t.OS {
        case "darwin", "windows", "linux":
                return exec.Verbose().SetBuffer(false).Run(filepath.Join(c.Build.Output, filepath.Base(c.Build.Output)))
        case "android":
                err := exec.Run("adb", "install", "-r", filepath.Join(c.Build.Output, c.Name+".apk"))
                if err != nil {
                        return fmt.Errorf("error installing app: %w", err)
                }
                // see https://stackoverflow.com/a/4567928
                args := []string{"shell", "am", "start", "-n", c.ID + "/org.golang.app.GoNativeActivity"}
                // TODO: get adb am debug on Android working
                // if c.Build.Debug {
                // args = append(args, "-D")
                // }
                err = exec.Run("adb", args...)
                if err != nil {
                        return fmt.Errorf("error starting app: %w", err)
                }
                if c.Build.Debug {
                        return Log(c)
                }
                return nil
        case "ios":
                if !c.Build.Debug {
                        return mobile.Install(c)
                }
                return exec.Verbose().SetBuffer(false).Run("ios-deploy", "-b", filepath.Join(c.Build.Output, c.Name+".app"), "-d")
        case "web":
                return web.Serve(c)
        }
        return nil
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cmd

import (
        "errors"
        "fmt"
        "os"
        "path/filepath"
        "runtime"
        "strings"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/cmd/core/config"
        "github.com/mitchellh/go-homedir"
)

// Setup installs platform-specific dependencies for the current platform.
// It only needs to be called once per system.
func Setup(c *config.Config) error { //types:add
        vc := exec.Verbose().SetBuffer(false)
        switch runtime.GOOS {
        case "darwin":
                p, err := exec.Output("xcode-select", "-p")
                if err != nil || p == "" {
                        err := vc.Run("xcode-select", "--install")
                        if err != nil {
                                return err
                        }
                } else {
                        logx.PrintlnWarn("xcode tools already installed")
                }
                return nil
        case "linux":
                for _, ld := range linuxDistros {
                        _, err := exec.LookPath(ld.tool)
                        if err != nil {
                                continue // package manager not found
                        }
                        cmd, args := ld.cmd()
                        err = vc.Run(cmd, args...)
                        if err != nil {
                                return err // package installation failed
                        }
                        return nil // success
                }
                return errors.New("unknown Linux distro; please file a bug report at https://github.com/cogentcore/core/issues")
        case "windows":
                // We must be in the home directory to avoid permission issues with file downloading.
                hd, err := homedir.Dir()
                if err != nil {
                        return err
                }
                err = os.Chdir(hd)
                if err != nil {
                        return err
                }
                if _, err := exec.LookPath("gcc"); err != nil {
                        err := vc.Run("curl", "-OL", "https://github.com/skeeto/w64devkit/releases/download/v2.0.0/w64devkit-x64-2.0.0.exe")
                        if err != nil {
                                return err
                        }
                        path, err := filepath.Abs("w64devkit-x64-2.0.0.exe")
                        if err != nil {
                                return err
                        }
                        err = vc.Run(path, "x", "-oC:", "-aoa")
                        if err != nil {
                                return err
                        }
                        err = windowsRegistryAddPath(`C:\w64devkit\bin`)
                        if err != nil {
                                return err
                        }
                } else {
                        logx.PrintlnWarn("gcc already installed")
                }
                if _, err := exec.LookPath("git"); err != nil {
                        err := vc.Run("curl", "-OL", "https://github.com/git-for-windows/git/releases/download/v2.45.2.windows.1/Git-2.45.2-64-bit.exe")
                        if err != nil {
                                return err
                        }
                        path, err := filepath.Abs("Git-2.45.2-64-bit.exe")
                        if err != nil {
                                return err
                        }
                        err = vc.Run(path)
                        if err != nil {
                                return err
                        }
                } else {
                        logx.PrintlnWarn("git already installed")
                }
                return nil
        }
        return fmt.Errorf("platform %q not supported for core setup", runtime.GOOS)
}

// linuxDistro represents the data needed to install dependencies for a specific Linux
// distribution family with the same installation steps.
type linuxDistro struct {

        // name contains the user-friendly name(s) of the Linux distribution(s).
        name string

        // sudo is whether the package manager requires sudo.
        sudo bool

        // tool is the name of the package manager used for installation.
        tool string

        // command contains the subcommand(s) in the package manager used to install packages.
        command []string

        // packages are the packages that need to be installed.
        packages []string
}

// cmd returns the command and arguments to install the packages for the Linux distribution.
func (ld *linuxDistro) cmd() (cmd string, args []string) {
        if ld.sudo {
                cmd = "sudo"
                args = append(args, ld.tool)
        } else {
                cmd = ld.tool
        }
        args = append(args, ld.command...)
        args = append(args, ld.packages...)
        return
}

func (ld *linuxDistro) String() string {
        cmd, args := ld.cmd()
        return fmt.Sprintf("%-15s %s %s", ld.name+":", cmd, strings.Join(args, " "))
}

// linuxDistros contains the supported Linux distributions,
// based on https://docs.fyne.io/started.
var linuxDistros = []*linuxDistro{
        {name: "Debian/Ubuntu", sudo: true, tool: "apt", command: []string{"install"}, packages: []string{
                "gcc", "libgl1-mesa-dev", "libegl1-mesa-dev", "mesa-vulkan-drivers", "xorg-dev",
        }},
        {name: "Fedora", sudo: true, tool: "dnf", command: []string{"install"}, packages: []string{
                "gcc", "libX11-devel", "libXcursor-devel", "libXrandr-devel", "libXinerama-devel", "mesa-libGL-devel", "libXi-devel", "libXxf86vm-devel", "mesa-vulkan-drivers",
        }},
        {name: "Arch", sudo: true, tool: "pacman", command: []string{"-S"}, packages: []string{
                "xorg-server-devel", "libxcursor", "libxrandr", "libxinerama", "libxi", "vulkan-swrast",
        }},
        {name: "Solus", sudo: true, tool: "eopkg", command: []string{"it", "-c"}, packages: []string{
                "system.devel", "mesalib-devel", "libxrandr-devel", "libxcursor-devel", "libxi-devel", "libxinerama-devel", "vulkan",
        }},
        {name: "openSUSE", sudo: true, tool: "zypper", command: []string{"install"}, packages: []string{
                "gcc", "libXcursor-devel", "libXrandr-devel", "Mesa-libGL-devel", "libXi-devel", "libXinerama-devel", "libXxf86vm-devel", "libvulkan1",
        }},
        {name: "Void", sudo: true, tool: "xbps-install", command: []string{"-S"}, packages: []string{
                "base-devel", "xorg-server-devel", "libXrandr-devel", "libXcursor-devel", "libXinerama-devel", "vulkan-loader",
        }},
        {name: "Alpine", sudo: true, tool: "apk", command: []string{"add"}, packages: []string{
                "gcc", "libxcursor-dev", "libxrandr-dev", "libxinerama-dev", "libxi-dev", "linux-headers", "mesa-dev", "vulkan-loader",
        }},
        {name: "NixOS", sudo: false, tool: "nix-shell", command: []string{"-p"}, packages: []string{
                "libGL", "pkg-config", "xorg.libX11.dev", "xorg.libXcursor", "xorg.libXi", "xorg.libXinerama", "xorg.libXrandr", "xorg.libXxf86vm", "mesa.drivers", "vulkan-loader",
        }},
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package config contains the configuration
// structs for the Cogent Core tool.
package config

//go:generate core generate

import (
        "fmt"
        "io/fs"
        "os"
        "path/filepath"
        "runtime"
        "strings"
        "unicode"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/iox/tomlx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/enums/enumgen"
        "cogentcore.org/core/types/typegen"
)

// Config is the main config struct that contains all of the configuration
// options for the Cogent Core command line tool.
type Config struct { //types:add

        // Name is the user-friendly name of the project.
        // The default is based on the current directory name.
        Name string

        // NamePrefix is the prefix to add to the default name of the project
        // and any projects nested below it. A separating space is automatically included.
        NamePrefix string

        // ID is the bundle / package ID to use for the project
        // (required for building for mobile platforms and packaging
        // for desktop platforms). It is typically in the format com.org.app
        // (eg: com.cogent.mail). It defaults to com.parentDirectory.currentDirectory.
        ID string

        // About is the about information for the project, which can be viewed via
        // the "About" button in the app bar. It is also used when packaging the app.
        About string

        // the version of the project to release
        Version string `cmd:"release" posarg:"0" save:"-"`

        // Content, if specified, indicates that the app has core content pages
        // located at this directory. If so, a directory tree will be made for all
        // of the pages when building for platform web. This defaults to "content"
        // when building an app for platform web that imports content.
        Content string

        // the configuration options for the build, install, run, and pack commands
        Build Build `cmd:"build,install,run,pack"`

        // the configuration information for the pack command
        Pack Pack `cmd:"pack"`

        // the configuration information for web
        Web Web `cmd:"build,install,run,pack"`

        // the configuration options for the log and run commands
        Log Log `cmd:"log,run"`

        // the configuration options for the generate command
        Generate Generate `cmd:"generate"`
}

type Build struct { //types:add

        // the target platforms to build executables for
        Target []Platform `flag:"t,target" posarg:"0" required:"-" save:"-"`

        // Dir is the directory to build the app from.
        // It defaults to the current directory.
        Dir string

        // Output is the directory to output the built app to.
        // It defaults to the current directory for desktop executables
        // and "bin/{platform}" for all other platforms and command "pack".
        Output string `flag:"o,output"`

        // Debug is whether to build/run the app in debug mode, which sets
        // the "debug" tag when building and prevents the default stripping
        // of debug symbols. On iOS and Android, this also prints the program output.
        Debug bool `flag:"d,debug"`

        // Ldflags are optional additional linker flags to pass to go build commands.
        Ldflags string

        // Trimpath is whether to replace file system paths with module paths
        // in the resulting executable. It is on by default for commands other
        // than core run.
        Trimpath bool `default:"true"`

        // Windowsgui is whether to make this a "Windows GUI" application that
        // opens without a terminal window on Windows. It is on by default for
        // commands other than core run.
        Windowsgui bool `default:"true"`

        // the minimum version of the iOS SDK to compile against
        IOSVersion string `default:"13.0"`

        // the minimum supported Android SDK (uses-sdk/android:minSdkVersion in AndroidManifest.xml)
        AndroidMinSDK int `default:"23" min:"23"`

        // the target Android SDK version (uses-sdk/android:targetSdkVersion in AndroidManifest.xml)
        AndroidTargetSDK int `default:"29"`
}

type Pack struct { //types:add

        // whether to build a .dmg file on macOS in addition to a .app file.
        // This is automatically disabled for the install command.
        DMG bool `default:"true"`
}

type Log struct { //types:add

        // the target platform to view the logs for (ios or android)
        Target string `default:"android"`

        // whether to keep the previous log messages or clear them
        Keep bool `default:"false"`

        // messages not generated from your app equal to or above this log level will be shown
        All string `default:"F"`
}

type Generate struct { //types:add

        // the enum generation configuration options passed to enumgen
        Enumgen enumgen.Config

        // the generation configuration options passed to typegen
        Typegen typegen.Config

        // the source directory to run generate on (can be multiple through ./...)
        Dir string `default:"." posarg:"0" required:"-" nest:"-"`

        // Icons, if specified, indicates to generate an icongen.go file with
        // icon variables for the icon svg files in the specified folder.
        Icons string
}

func (c *Config) OnConfig(cmd string) error {
        // if we have no target, we assume it is our current platform,
        // unless we are in init, in which case we do not want to set
        // the config file to be specific to our platform
        if len(c.Build.Target) == 0 && cmd != "init" {
                c.Build.Target = []Platform{{OS: runtime.GOOS, Arch: runtime.GOARCH}}
        }
        if c.Build.Output == "" && len(c.Build.Target) > 0 {
                t := c.Build.Target[0]
                if cmd == "pack" || t.OS == "web" || t.OS == "android" || t.OS == "ios" {
                        c.Build.Output = filepath.Join("bin", t.OS)
                }
        }
        // we must make the output dir absolute before changing the current directory
        out, err := filepath.Abs(c.Build.Output)
        if err != nil {
                return err
        }
        c.Build.Output = out
        if c.Build.Dir != "" {
                err := os.Chdir(c.Build.Dir)
                if err != nil {
                        return err
                }
                // re-read the config file from the new location if it exists
                err = tomlx.Open(c, "core.toml")
                if err != nil && !errors.Is(err, fs.ErrNotExist) {
                        return err
                }
        }
        // we must do auto-naming after we apply any directory change above
        if c.Name == "" || c.ID == "" {
                cdir, err := os.Getwd()
                if err != nil {
                        return fmt.Errorf("error finding current directory: %w", err)
                }
                base := filepath.Base(cdir)
                if c.Name == "" {
                        c.Name = strcase.ToTitle(base)
                        if c.NamePrefix != "" {
                                c.Name = c.NamePrefix + " " + c.Name
                        }
                }

                if c.ID == "" {
                        dir := filepath.Dir(cdir)
                        // if our directory starts with a v and then has only digits, it is a version directory
                        // so we go up another directory to get to the actual directory
                        if len(dir) > 1 && dir[0] == 'v' && !strings.ContainsFunc(dir[1:], func(r rune) bool {
                                return !unicode.IsDigit(r)
                        }) {
                                dir = filepath.Dir(dir)
                        }
                        dir = filepath.Base(dir)
                        // we ignore anything after any dot in the directory name
                        dir, _, _ = strings.Cut(dir, ".")
                        // the default ID is "com.dir.base", which is relatively likely
                        // to be close to "com.org.app", the intended format
                        c.ID = "com." + dir + "." + base
                }
        }
        if cmd == "run" {
                c.Build.Trimpath = false
                c.Build.Windowsgui = false
        }
        return nil
}

// LinkerFlags returns the ld linker flags that specify the app and core version,
// the app about information, the app icon, and the optional [Build.Ldflags].
func LinkerFlags(c *Config) string {
        res := ""

        if c.Build.Ldflags != "" {
                res += c.Build.Ldflags + " "
        }

        if !c.Build.Debug {
                // See https://stackoverflow.com/questions/30005878/avoid-debugging-information-on-golang and go.dev/issues/25148.
                res += "-s -w "
        }

        if c.About != "" {
                res += "-X 'cogentcore.org/core/core.AppAbout=" + strings.ReplaceAll(c.About, "'", `\'`) + "' "
        }

        b, err := os.ReadFile("icon.svg")
        if err != nil {
                if !errors.Is(err, fs.ErrNotExist) {
                        errors.Log(err)
                }
        } else {
                res += "-X 'cogentcore.org/core/core.AppIcon=" + strings.ReplaceAll(string(b), "'", `\'`) + "' "
        }

        // TODO: maybe replace this linker flag version injection logic with
        // [debug.ReadBuildInfo] at some point; we currently support it as a
        // backup in system/app.go, but it is less reliable and formats worse,
        // so we won't use it as a full replacement yet (see
        // https://github.com/cogentcore/core/issues/1370).

        av, err := exec.Silent().Output("git", "describe", "--tags")
        if err == nil {
                res += "-X cogentcore.org/core/system.AppVersion=" + av + " "
        }

        // workspaces can interfere with getting the right version
        cv, err := exec.Silent().SetEnv("GOWORK", "off").Output("go", "list", "-m", "-f", "{{.Version}}", "cogentcore.org/core")
        if err == nil {
                // we must be in core itself if it is blank
                if cv == "" {
                        cv = av
                }
                res += "-X cogentcore.org/core/system.CoreVersion=" + cv
        }
        return res
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package config

import (
        "fmt"
        "strings"
)

// Note: the maps in this file are derived from https://github.com/golang/go/blob/master/src/go/build/syslist.go

// Platform is a platform with an operating system and an architecture
type Platform struct {
        OS   string
        Arch string
}

// String returns the platform as a string in the form "os/arch"
func (p Platform) String() string {
        return p.OS + "/" + p.Arch
}

// OSSupported determines whether the given operating system is supported by Cogent Core. If it is, it returns nil.
// If it isn't, it returns an error detailing the issue with the operating system (not found or not supported).
func OSSupported(os string) error {
        supported, ok := supportedOS[os]
        if !ok {
                return fmt.Errorf("could not find operating system %s; please check that you spelled it correctly", os)
        }
        if !supported {
                return fmt.Errorf("operating system %s exists but is not supported by Cogent Core", os)
        }
        return nil
}

// ArchSupported determines whether the given architecture is supported by Cogent Core. If it is, it returns nil.
// If it isn't, it also returns an error detailing the issue with the architecture (not found or not supported).
func ArchSupported(arch string) error {
        supported, ok := supportedArch[arch]
        if !ok {
                return fmt.Errorf("could not find architecture %s; please check that you spelled it correctly", arch)
        }
        if !supported {
                return fmt.Errorf("architecture %s exists but is not supported by Cogent Core", arch)
        }
        return nil
}

// SetString sets the platform from the given string of format os[/arch]
func (p *Platform) SetString(platform string) error {
        before, after, found := strings.Cut(platform, "/")
        p.OS = before
        err := OSSupported(before)
        if err != nil {
                return fmt.Errorf("error parsing platform: %w", err)
        }
        if !found {
                p.Arch = "*"
                return nil
        }
        p.Arch = after
        err = ArchSupported(after)
        if err != nil {
                return fmt.Errorf("error parsing platform: %w", err)
        }
        return nil
}

// ArchsForOS returns contains all of the architectures supported for
// each operating system.
var ArchsForOS = map[string][]string{
        "darwin":  {"386", "amd64", "arm", "arm64"},
        "windows": {"386", "amd64", "arm", "arm64"},
        "linux":   {"386", "amd64", "arm", "arm64"},
        "android": {"386", "amd64", "arm", "arm64"},
        "ios":     {"arm64"},
}

// supportedOS is a map containing all operating systems and whether they are supported by Cogent Core.
var supportedOS = map[string]bool{
        "aix":       false,
        "android":   true,
        "darwin":    true,
        "dragonfly": false,
        "freebsd":   false,
        "hurd":      false,
        "illumos":   false,
        "ios":       true,
        "web":       true,
        "linux":     true,
        "nacl":      false,
        "netbsd":    false,
        "openbsd":   false,
        "plan9":     false,
        "solaris":   false,
        "wasip1":    false,
        "windows":   true,
        "zos":       false,
}

// supportedArch is a map containing all computer architectures and whether they are supported by Cogent Core.
var supportedArch = map[string]bool{
        "386":         true,
        "amd64":       true,
        "amd64p32":    true,
        "arm":         true,
        "armbe":       true,
        "arm64":       true,
        "arm64be":     true,
        "loong64":     false,
        "mips":        false,
        "mipsle":      false,
        "mips64":      false,
        "mips64le":    false,
        "mips64p32":   false,
        "mips64p32le": false,
        "ppc":         false,
        "ppc64":       false,
        "ppc64le":     false,
        "riscv":       false,
        "riscv64":     false,
        "s390":        false,
        "s390x":       false,
        "sparc":       false,
        "sparc64":     false,
        "wasm":        true,
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Command core provides command line tools for developing apps
// and libraries using the Cogent Core framework.
package main

import (
        "cogentcore.org/core/cli"
        "cogentcore.org/core/cmd/core/cmd"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/generate"
)

func main() {
        opts := cli.DefaultOptions("Cogent Core", "Command line tools for developing apps and libraries using the Cogent Core framework.")
        opts.DefaultFiles = []string{"core.toml"}
        opts.SearchUp = true
        cli.Run(opts, &config.Config{}, cmd.Setup, cmd.Build, cmd.Run, cmd.Pack, cmd.Install, generate.Generate, cmd.Changed, cmd.Pull, cmd.Log, cmd.Release, cmd.NextRelease)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package generate provides the generation
// of useful methods, variables, and constants
// for Cogent Core code.
package generate

//go:generate core generate

import (
        "fmt"
        "slices"
        "text/template"

        "cogentcore.org/core/base/generate"
        "cogentcore.org/core/base/ordmap"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/enums/enumgen"
        "cogentcore.org/core/types"
        "cogentcore.org/core/types/typegen"
        "golang.org/x/tools/go/packages"
)

// treeMethodsTmpl is a template that contains the methods
// and functions specific to [tree.Node] types.
var treeMethodsTmpl = template.Must(template.New("TreeMethods").
        Funcs(template.FuncMap{
                "HasEmbedDirective": hasEmbedDirective,
                "HasNoNewDirective": hasNoNewDirective,
                "DocToComment":      typegen.DocToComment,
                "TreePkg":           treePkg,
        }).Parse(
        `
        {{if not (HasNoNewDirective .)}}
        // New{{.LocalName}} returns a new [{{.LocalName}}] with the given optional parent:
        {{DocToComment .Doc}}
        func New{{.LocalName}}(parent ...{{TreePkg .}}Node) *{{.LocalName}} { return {{TreePkg .}}New[{{.LocalName}}](parent...) }
        {{end}}
        
        {{if HasEmbedDirective .}}
        // {{.LocalName}}Embedder is an interface that all types that embed {{.LocalName}} satisfy
        type {{.LocalName}}Embedder interface {
                As{{.LocalName}}() *{{.LocalName}}
        }
        
        // As{{.LocalName}} returns the given value as a value of type {{.LocalName}} if the type
        // of the given value embeds {{.LocalName}}, or nil otherwise
        func As{{.LocalName}}(n {{TreePkg .}}Node) *{{.LocalName}} {
                if t, ok := n.({{.LocalName}}Embedder); ok {
                        return t.As{{.LocalName}}()
                }
                return nil
        }
        
        // As{{.LocalName}} satisfies the [{{.LocalName}}Embedder] interface
        func (t *{{.LocalName}}) As{{.LocalName}}() *{{.LocalName}} { return t }
        {{end}}
        `,
))

// treePkg returns the package identifier for the tree package in
// the context of the given type ("" if it is already in the tree
// package, and "tree." otherwise)
func treePkg(typ *typegen.Type) string {
        if typ.Pkg == "tree" { // we are already in tree
                return ""
        }
        return "tree."
}

// hasEmbedDirective returns whether the given [typegen.Type] has a "core:embedder"
// comment directive. This function is used in [treeMethodsTmpl].
func hasEmbedDirective(typ *typegen.Type) bool {
        return slices.ContainsFunc(typ.Directives, func(d types.Directive) bool {
                return d.Tool == "core" && d.Directive == "embedder"
        })
}

// hasNoNewDirective returns whether the given [typegen.Type] has a "core:no-new"
// comment directive. This function is used in [treeMethodsTmpl].
func hasNoNewDirective(typ *typegen.Type) bool {
        return slices.ContainsFunc(typ.Directives, func(d types.Directive) bool {
                return d.Tool == "core" && d.Directive == "no-new"
        })
}

// Generate is the main entry point to code generation
// that does all of the generation according to the
// given config info. It overrides the
// [config.Config.Generate.Typegen.InterfaceConfigs] info.
func Generate(c *config.Config) error { //types:add
        c.Generate.Typegen.InterfaceConfigs = &ordmap.Map[string, *typegen.Config]{}

        c.Generate.Typegen.InterfaceConfigs.Add("cogentcore.org/core/tree.Node", &typegen.Config{
                AddTypes:  true,
                Setters:   true,
                Templates: []*template.Template{treeMethodsTmpl},
        })

        pkgs, err := parsePackages(c)
        if err != nil {
                return fmt.Errorf("Generate: error parsing package: %w", err)
        }

        err = enumgen.GeneratePkgs(&c.Generate.Enumgen, pkgs)
        if err != nil {
                return fmt.Errorf("error running enumgen: %w", err)
        }
        err = typegen.GeneratePkgs(&c.Generate.Typegen, pkgs)
        if err != nil {
                return fmt.Errorf("error running typegen: %w", err)
        }
        err = Icons(c)
        if err != nil {
                return fmt.Errorf("error running icongen: %w", err)
        }
        return nil
}

// parsePackages parses the package(s) based on the given config info.
func parsePackages(cfg *config.Config) ([]*packages.Package, error) {
        pcfg := &packages.Config{
                Mode: enumgen.PackageModes() | typegen.PackageModes(&cfg.Generate.Typegen), // need superset of both
                // TODO: Need to think about constants in test files. Maybe write type_string_test.go
                // in a separate pass? For later.
                Tests: false,
        }
        return generate.Load(pcfg, cfg.Generate.Dir)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package generate

import (
        "bytes"
        "io/fs"
        "os"
        "path/filepath"
        "strings"
        "text/template"
        "unicode"

        "cogentcore.org/core/base/generate"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/cmd/core/config"
)

// iconData contains the data for an icon
type iconData struct {
        Dir          string // Dir is the directory in which the icon is contained
        Snake        string // Snake is the snake_case name of the icon
        Camel        string // Camel is the CamelCase name of the icon
        IconsPackage string // IconsPackage is "icons." or ""
}

var iconTmpl = template.Must(template.New("icon").Parse(
        `
        //go:embed {{.Dir}}{{.Snake}}.svg
        {{.Camel}} {{.IconsPackage}}Icon`,
))

// Icons does any necessary generation for icons.
func Icons(c *config.Config) error {
        if c.Generate.Icons == "" {
                return nil
        }
        b := &bytes.Buffer{}
        wd, err := os.Getwd()
        if err != nil {
                return err
        }
        generate.PrintHeader(b, filepath.Base(wd))
        b.WriteString(`import _ "embed"

var (`)

        fs.WalkDir(os.DirFS(c.Generate.Icons), ".", func(path string, d fs.DirEntry, err error) error {
                if d.IsDir() || filepath.Ext(path) != ".svg" {
                        return nil
                }
                name := strings.TrimSuffix(path, ".svg")
                // ignore blank icon, as we define the constant for that separately
                if name == "blank" {
                        return nil
                }
                camel := strcase.ToCamel(name)
                // identifier names can't start with a digit
                if unicode.IsDigit([]rune(camel)[0]) {
                        camel = "X" + camel
                }
                data := iconData{
                        Snake: name,
                        Camel: camel,
                }
                data.Dir = c.Generate.Icons + "/"
                if data.Dir == "./" {
                        data.Dir = ""
                }
                if !strings.HasSuffix(wd, filepath.Join("core", "icons")) {
                        data.IconsPackage = "icons."
                }
                return iconTmpl.Execute(b, data)
        })
        b.WriteString("\n)\n")
        return generate.Write("icongen.go", b.Bytes(), nil)
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:generate go run genarsc.go
//go:generate stringer -output binres_string.go -type ResType,DataType

// Package binres implements encoding and decoding of android binary resources.
//
// Binary resource structs support unmarshalling the binary output of aapt.
// Implementations of marshalling for each struct must produce the exact input
// sent to unmarshalling. This allows tests to validate each struct representation
// of the binary format as follows:
//
//   - unmarshal the output of aapt
//   - marshal the struct representation
//   - perform byte-to-byte comparison with aapt output per chunk header and body
//
// This process should strive to make structs idiomatic to make parsing xml text
// into structs trivial.
//
// Once the struct representation is validated, tests for parsing xml text
// into structs can become self-referential as the following holds true:
//
//   - the unmarshalled input of aapt output is the only valid target
//   - the unmarshalled input of xml text may be compared to the unmarshalled
//     input of aapt output to identify errors, e.g. text-trims, wrong flags, etc
//
// This provides validation, byte-for-byte, for producing binary xml resources.
//
// It should be made clear that unmarshalling binary resources is currently only
// in scope for proving that the BinaryMarshaler works correctly. Any other use
// is currently out of scope.
//
// A simple view of binary xml document structure:
//
//        XML
//          Pool
//          Map
//          Namespace
//          [...node]
//
// Additional resources:
// https://android.googlesource.com/platform/frameworks/base/+/master/libs/androidfw/include/androidfw/ResourceTypes.h
// https://justanapplication.wordpress.com/2011/09/13/ (a series of articles, increment date)
package binres

import (
        "encoding"
        "encoding/binary"
        "encoding/xml"
        "errors"
        "fmt"
        "io"
        "sort"
        "strconv"
        "strings"
        "unicode"
)

func errWrongType(have ResType, want ...ResType) error {
        return fmt.Errorf("wrong resource type %s, want one of %v", have, want)
}

type ResType uint16

func (t ResType) IsSupported() bool {
        return t != ResNull
}

// explicitly defined for clarity and resolvability with apt source
const (
        ResNull       ResType = 0x0000
        ResStringPool ResType = 0x0001
        ResTable      ResType = 0x0002
        ResXML        ResType = 0x0003

        ResXMLStartNamespace ResType = 0x0100
        ResXMLEndNamespace   ResType = 0x0101
        ResXMLStartElement   ResType = 0x0102
        ResXMLEndElement     ResType = 0x0103
        ResXMLCharData       ResType = 0x0104

        ResXMLResourceMap ResType = 0x0180

        ResTablePackage           ResType = 0x0200
        ResTableType              ResType = 0x0201
        ResTableTypeSpec          ResType = 0x0202
        ResTableLibrary           ResType = 0x0203
        ResTableOverlayable       ResType = 0x0204
        ResTableOverlayablePolicy ResType = 0x0205
        ResTableStagedAlias       ResType = 0x0206
)

var (
        btou16 = binary.LittleEndian.Uint16
        btou32 = binary.LittleEndian.Uint32
        putu16 = binary.LittleEndian.PutUint16
        putu32 = binary.LittleEndian.PutUint32
)

// unmarshaler wraps BinaryUnmarshaler to provide byte size of decoded chunks.
type unmarshaler interface {
        encoding.BinaryUnmarshaler

        // size returns the byte size unmarshalled after a call to
        // UnmarshalBinary, or otherwise zero.
        size() int
}

// chunkHeader appears at the front of every data chunk in a resource.
type chunkHeader struct {
        // Type of data that follows this header.
        typ ResType

        // Advance slice index by this value to find its associated data, if any.
        headerByteSize uint16

        // This is the header size plus the size of any data associated with the chunk.
        // Advance slice index by this value to completely skip its contents, including
        // any child chunks. If this value is the same as headerByteSize, there is
        // no data associated with the chunk.
        byteSize uint32
}

// size implements unmarshaler.
func (hdr chunkHeader) size() int { return int(hdr.byteSize) }

func (hdr *chunkHeader) UnmarshalBinary(bin []byte) error {
        hdr.typ = ResType(btou16(bin))
        if !hdr.typ.IsSupported() {
                return fmt.Errorf("%s not supported", hdr.typ)
        }
        hdr.headerByteSize = btou16(bin[2:])
        hdr.byteSize = btou32(bin[4:])
        if len(bin) < int(hdr.byteSize) {
                return fmt.Errorf("too few bytes to unmarshal chunk body, have %v, need at-least %v", len(bin), hdr.byteSize)
        }
        return nil
}

func (hdr chunkHeader) MarshalBinary() ([]byte, error) {
        if !hdr.typ.IsSupported() {
                return nil, fmt.Errorf("%s not supported", hdr.typ)
        }

        bin := make([]byte, 8)
        putu16(bin, uint16(hdr.typ))
        putu16(bin[2:], hdr.headerByteSize)
        putu32(bin[4:], hdr.byteSize)
        return bin, nil
}

type XML struct {
        chunkHeader

        Pool *Pool
        Map  *Map

        Namespace *Namespace
        Children  []*Element

        // tmp field used when unmarshalling binary
        stack []*Element
}

// RawValueByName returns the original raw string value of first matching element attribute, or error if not exists.
// Given <manifest package="VAL" ...> then RawValueByName("manifest", xml.Name{Local: "package"}) returns "VAL".
func (bx *XML) RawValueByName(elname string, attrname xml.Name) (string, error) {
        elref, err := bx.Pool.RefByName(elname)
        if err != nil {
                return "", err
        }
        nref, err := bx.Pool.RefByName(attrname.Local)
        if err != nil {
                return "", err
        }
        nsref := PoolRef(NoEntry)
        if attrname.Space != "" {
                nsref, err = bx.Pool.RefByName(attrname.Space)
                if err != nil {
                        return "", err
                }
        }

        for el := range bx.iterElements() {
                if el.Name == elref {
                        for _, attr := range el.attrs {
                                // TODO enforce TypedValue DataString constraint?
                                if nsref == attr.NS && nref == attr.Name {
                                        return bx.Pool.strings[int(attr.RawValue)], nil
                                }
                        }
                }
        }
        return "", fmt.Errorf("no matching element %q for attribute %+v found", elname, attrname)
}

const (
        androidSchema = "http://schemas.android.com/apk/res/android"
        toolsSchema   = "http://schemas.android.com/tools"
)

// skipSynthesize is set true for tests to avoid synthesis of additional nodes and attributes.
var skipSynthesize bool

// UnmarshalXML decodes an AndroidManifest.xml document returning type XML
// containing decoded resources with the given minimum and target Android SDK / API version.
func UnmarshalXML(r io.Reader, withIcon bool, minSdkVersion, targetSdkVersion int) (*XML, error) {
        tbl, err := OpenTable()
        if err != nil {
                return nil, err
        }

        lr := &lineReader{r: r}
        dec := xml.NewDecoder(lr)
        bx := new(XML)

        // temporary pool to resolve real poolref later
        pool := new(Pool)

        type ltoken struct {
                xml.Token
                line int
        }
        var q []ltoken

        for {
                line := lr.line(dec.InputOffset())
                tkn, err := dec.Token()
                if err != nil {
                        if err == io.EOF {
                                break
                        }
                        return nil, err
                }
                tkn = xml.CopyToken(tkn)
                switch tkn := tkn.(type) {
                case xml.StartElement:
                        switch tkn.Name.Local {
                        default:
                                q = append(q, ltoken{tkn, line})
                        case "uses-sdk":
                                return nil, errors.New("manual declaration of uses-sdk in AndroidManifest.xml not supported")
                        case "manifest":
                                // synthesize additional attributes and nodes for use during encode.
                                tkn.Attr = append(tkn.Attr, xml.Attr{
                                        Name: xml.Name{
                                                Space: "",
                                                Local: "platformBuildVersionCode",
                                        },
                                        Value: strconv.Itoa(targetSdkVersion),
                                },
                                        xml.Attr{
                                                Name: xml.Name{
                                                        Space: "",
                                                        Local: "platformBuildVersionName",
                                                },
                                                Value: "4.1.2-1425332",
                                        },
                                )

                                q = append(q, ltoken{tkn, line})

                                if !skipSynthesize {
                                        s := xml.StartElement{
                                                Name: xml.Name{
                                                        Space: "",
                                                        Local: "uses-sdk",
                                                },
                                                Attr: []xml.Attr{
                                                        {
                                                                Name: xml.Name{
                                                                        Space: androidSchema,
                                                                        Local: "minSdkVersion",
                                                                },
                                                                Value: strconv.Itoa(minSdkVersion),
                                                        },
                                                        {
                                                                Name: xml.Name{
                                                                        Space: androidSchema,
                                                                        Local: "targetSdkVersion",
                                                                },
                                                                Value: strconv.Itoa(targetSdkVersion),
                                                        },
                                                },
                                        }
                                        e := xml.EndElement{Name: xml.Name{Local: "uses-sdk"}}

                                        q = append(q, ltoken{s, line}, ltoken{e, line})
                                }
                        case "application":
                                if !skipSynthesize {
                                        for _, attr := range tkn.Attr {
                                                if attr.Name.Space == androidSchema && attr.Name.Local == "icon" {
                                                        return nil, errors.New("manual declaration of android:icon in AndroidManifest.xml not supported")
                                                }
                                        }
                                        if withIcon {
                                                tkn.Attr = append(tkn.Attr,
                                                        xml.Attr{
                                                                Name: xml.Name{
                                                                        Space: androidSchema,
                                                                        Local: "icon",
                                                                },
                                                                Value: "@mipmap/icon",
                                                        })
                                        }
                                }
                                q = append(q, ltoken{tkn, line})
                        case "activity", "intent-filter", "action", "category", "service", "meta-data":
                                // need android:exported="true" for activities in android sdk version 31 and above (still not working so testing with other things also set to exported)
                                if !skipSynthesize && targetSdkVersion >= 31 {
                                        tkn.Attr = append(tkn.Attr,
                                                xml.Attr{
                                                        Name: xml.Name{
                                                                Space: androidSchema,
                                                                Local: "exported",
                                                        },
                                                        Value: "true",
                                                },
                                        )
                                }
                                q = append(q, ltoken{tkn, line})
                        }
                default:
                        q = append(q, ltoken{tkn, line})
                }
        }

        for _, ltkn := range q {
                tkn, line := ltkn.Token, ltkn.line
                switch tkn := tkn.(type) {
                case xml.StartElement:
                        el := &Element{
                                NodeHeader: NodeHeader{
                                        LineNumber: uint32(line),
                                        Comment:    0xFFFFFFFF,
                                },
                                NS:   NoEntry,
                                Name: pool.ref(tkn.Name.Local),
                        }
                        if len(bx.stack) == 0 {
                                bx.Children = append(bx.Children, el)
                        } else {
                                n := len(bx.stack)
                                var p *Element
                                p, bx.stack = bx.stack[n-1], bx.stack[:n-1]
                                p.Children = append(p.Children, el)
                                bx.stack = append(bx.stack, p)
                        }
                        bx.stack = append(bx.stack, el)

                        for _, attr := range tkn.Attr {
                                if (attr.Name.Space == "xmlns" && attr.Name.Local == "tools") || attr.Name.Space == toolsSchema {
                                        continue // TODO can tbl be queried for schemas to determine validity instead?
                                }

                                if attr.Name.Space == "xmlns" && attr.Name.Local == "android" {
                                        if bx.Namespace != nil {
                                                return nil, errors.New("multiple declarations of xmlns:android encountered")
                                        }
                                        bx.Namespace = &Namespace{
                                                NodeHeader: NodeHeader{
                                                        LineNumber: uint32(line),
                                                        Comment:    NoEntry,
                                                },
                                                prefix: 0,
                                                uri:    0,
                                        }
                                        continue
                                }

                                nattr := &Attribute{
                                        NS:       pool.ref(attr.Name.Space),
                                        Name:     pool.ref(attr.Name.Local),
                                        RawValue: NoEntry,
                                }
                                el.attrs = append(el.attrs, nattr)

                                if attr.Name.Space == "" {
                                        nattr.NS = NoEntry
                                        // TODO it's unclear how to query these
                                        switch attr.Name.Local {
                                        case "platformBuildVersionCode":
                                                nattr.TypedValue.Type = DataIntDec
                                                i, err := strconv.Atoi(attr.Value)
                                                if err != nil {
                                                        return nil, err
                                                }
                                                nattr.TypedValue.Value = uint32(i)
                                        default: // "package", "platformBuildVersionName", and any invalid
                                                nattr.RawValue = pool.ref(attr.Value)
                                                nattr.TypedValue.Type = DataString
                                        }
                                } else {
                                        // get type spec and value data type
                                        ref, err := tbl.RefByName("attr/" + attr.Name.Local)
                                        if err != nil {
                                                return nil, err
                                        }
                                        nt, err := ref.Resolve(tbl)
                                        if err != nil {
                                                return nil, err
                                        }
                                        if len(nt.values) == 0 {
                                                panic("encountered empty values slice")
                                        }

                                        if len(nt.values) == 1 {
                                                val := nt.values[0]
                                                if val.data.Type != DataIntDec {
                                                        panic("TODO only know how to handle DataIntDec type here")
                                                }

                                                t := DataType(val.data.Value)
                                                switch t {
                                                case DataString, DataAttribute, DataType(0x3e):
                                                        // TODO identify 0x3e, in bootstrap.xml this is the native lib name
                                                        nattr.RawValue = pool.ref(attr.Value)
                                                        nattr.TypedValue.Type = DataString
                                                        nattr.TypedValue.Value = uint32(nattr.RawValue)
                                                case DataIntBool, DataType(0x08):
                                                        nattr.TypedValue.Type = DataIntBool
                                                        switch attr.Value {
                                                        case "true":
                                                                nattr.TypedValue.Value = 0xFFFFFFFF
                                                        case "false":
                                                                nattr.TypedValue.Value = 0
                                                        default:
                                                                return nil, fmt.Errorf("invalid bool value %q", attr.Value)
                                                        }
                                                case DataIntDec, DataFloat, DataFraction:
                                                        // TODO DataFraction needs it's own case statement. minSdkVersion identifies as DataFraction
                                                        // but has accepted input in the past such as android:minSdkVersion="L"
                                                        // Other use-cases for DataFraction are currently unknown as applicable to manifest generation
                                                        // but this provides minimum support for writing out minSdkVersion="15" correctly.
                                                        nattr.TypedValue.Type = DataIntDec
                                                        i, err := strconv.Atoi(attr.Value)
                                                        if err != nil {
                                                                return nil, err
                                                        }
                                                        nattr.TypedValue.Value = uint32(i)
                                                case DataReference:
                                                        nattr.TypedValue.Type = DataReference
                                                        dref, err := tbl.RefByName(attr.Value)
                                                        if err != nil {
                                                                if strings.HasPrefix(attr.Value, "@mipmap") {
                                                                        // firstDrawableId is a TableRef matching first entry of mipmap spec initialized by NewMipmapTable.
                                                                        // 7f is default package, 02 is mipmap spec, 0000 is first entry; e.g. R.drawable.icon
                                                                        // TODO resource table should generate ids as required.
                                                                        const firstDrawableId = 0x7f020000
                                                                        nattr.TypedValue.Value = firstDrawableId
                                                                        continue
                                                                }
                                                                return nil, err
                                                        }
                                                        nattr.TypedValue.Value = uint32(dref)
                                                default:
                                                        return nil, fmt.Errorf("unhandled data type %0#2x: %s", uint8(t), t)
                                                }
                                        } else {
                                                // 0x01000000 is an unknown ref that doesn't point to anything, typically
                                                // located at the start of entry value lists, peek at last value to determine type.
                                                t := nt.values[len(nt.values)-1].data.Type
                                                switch t {
                                                case DataIntDec:
                                                        for _, val := range nt.values {
                                                                if val.name == 0x01000000 {
                                                                        continue
                                                                }
                                                                nr, err := val.name.Resolve(tbl)
                                                                if err != nil {
                                                                        return nil, err
                                                                }
                                                                if attr.Value == nr.key.Resolve(tbl.pkgs[0].keyPool) { // TODO hard-coded pkg ref
                                                                        nattr.TypedValue = *val.data
                                                                        break
                                                                }
                                                        }
                                                case DataIntHex:
                                                        nattr.TypedValue.Type = t
                                                        for _, x := range strings.Split(attr.Value, "|") {
                                                                for _, val := range nt.values {
                                                                        if val.name == 0x01000000 {
                                                                                continue
                                                                        }
                                                                        nr, err := val.name.Resolve(tbl)
                                                                        if err != nil {
                                                                                return nil, err
                                                                        }
                                                                        if x == nr.key.Resolve(tbl.pkgs[0].keyPool) { // TODO hard-coded pkg ref
                                                                                nattr.TypedValue.Value |= val.data.Value
                                                                                break
                                                                        }
                                                                }
                                                        }
                                                default:
                                                        return nil, fmt.Errorf("unhandled data type for configuration %0#2x: %s", uint8(t), t)
                                                }
                                        }
                                }
                        }
                case xml.CharData:
                        if s := poolTrim(string(tkn)); s != "" {
                                cdt := &CharData{
                                        NodeHeader: NodeHeader{
                                                LineNumber: uint32(line),
                                                Comment:    NoEntry,
                                        },
                                        RawData: pool.ref(s),
                                }
                                el := bx.stack[len(bx.stack)-1]
                                if el.head == nil {
                                        el.head = cdt
                                } else if el.tail == nil {
                                        el.tail = cdt
                                } else {
                                        return nil, errors.New("element head and tail already contain chardata")
                                }
                        }
                case xml.EndElement:
                        if tkn.Name.Local == "manifest" {
                                bx.Namespace.end = &Namespace{
                                        NodeHeader: NodeHeader{
                                                LineNumber: uint32(line),
                                                Comment:    NoEntry,
                                        },
                                        prefix: 0,
                                        uri:    0,
                                }
                        }
                        n := len(bx.stack)
                        var el *Element
                        el, bx.stack = bx.stack[n-1], bx.stack[:n-1]
                        if el.end != nil {
                                return nil, errors.New("element end already exists")
                        }
                        el.end = &ElementEnd{
                                NodeHeader: NodeHeader{
                                        LineNumber: uint32(line),
                                        Comment:    NoEntry,
                                },
                                NS:   el.NS,
                                Name: el.Name,
                        }
                case xml.Comment, xml.ProcInst:
                        // discard
                default:
                        panic(fmt.Errorf("unhandled token type: %T %+v", tkn, tkn))
                }
        }

        // pools appear to be sorted as follows:
        // * attribute names prefixed with android:
        // * "android", [schema-url], [empty-string]
        // * for each node:
        //   * attribute names with no prefix
        //   * node name
        //   * attribute value if data type of name is DataString, DataAttribute, or 0x3e (an unknown)
        bx.Pool = new(Pool)

        var arecurse func(*Element)
        arecurse = func(el *Element) {
                for _, attr := range el.attrs {
                        if attr.NS == NoEntry {
                                continue
                        }
                        if attr.NS.Resolve(pool) == androidSchema {
                                bx.Pool.strings = append(bx.Pool.strings, attr.Name.Resolve(pool))
                        }
                }
                for _, child := range el.Children {
                        arecurse(child)
                }
        }
        for _, el := range bx.Children {
                arecurse(el)
        }

        // TODO encoding/xml does not enforce namespace prefix and manifest encoding in aapt
        // appears to ignore all other prefixes. Inserting this manually is not strictly correct
        // for the general case, but the effort to do otherwise currently offers nothing.
        bx.Pool.strings = append(bx.Pool.strings, "android", androidSchema)

        // there always appears to be an empty string located after schema, even if one is
        // not present in manifest.
        bx.Pool.strings = append(bx.Pool.strings, "")

        var brecurse func(*Element)
        brecurse = func(el *Element) {
                for _, attr := range el.attrs {
                        if attr.NS == NoEntry {
                                bx.Pool.strings = append(bx.Pool.strings, attr.Name.Resolve(pool))
                        }
                }

                bx.Pool.strings = append(bx.Pool.strings, el.Name.Resolve(pool))

                for _, attr := range el.attrs {
                        if attr.RawValue != NoEntry {
                                bx.Pool.strings = append(bx.Pool.strings, attr.RawValue.Resolve(pool))
                        } else if attr.NS == NoEntry {
                                bx.Pool.strings = append(bx.Pool.strings, fmt.Sprintf("%+v", attr.TypedValue.Value))
                        }
                }

                if el.head != nil {
                        bx.Pool.strings = append(bx.Pool.strings, el.head.RawData.Resolve(pool))
                }
                if el.tail != nil {
                        bx.Pool.strings = append(bx.Pool.strings, el.tail.RawData.Resolve(pool))
                }

                for _, child := range el.Children {
                        brecurse(child)
                }
        }
        for _, el := range bx.Children {
                brecurse(el)
        }

        // do not eliminate duplicates until the entire slice has been composed.
        // consider <activity android:label="label" .../>
        // all attribute names come first followed by values; in such a case, the value "label"
        // would be a reference to the same "android:label" in the string pool which will occur
        // within the beginning of the pool where other attr names are located.
        bx.Pool.strings = asSet(bx.Pool.strings)

        // TODO consider cases of multiple declarations of the same attr name that should return error
        // before ever reaching this point.
        bx.Map = new(Map)
        for _, s := range bx.Pool.strings {
                ref, err := tbl.RefByName("attr/" + s)
                if err != nil {
                        break // break after first non-ref as all strings after are also non-refs.
                }
                bx.Map.rs = append(bx.Map.rs, ref)
        }

        // resolve tmp pool refs to final pool refs
        // TODO drop this in favor of sort directly on Table
        var resolve func(el *Element)
        resolve = func(el *Element) {
                if el.NS != NoEntry {
                        el.NS = bx.Pool.ref(el.NS.Resolve(pool))
                        el.end.NS = el.NS
                }
                el.Name = bx.Pool.ref(el.Name.Resolve(pool))
                el.end.Name = el.Name
                for _, attr := range el.attrs {
                        if attr.NS != NoEntry {
                                attr.NS = bx.Pool.ref(attr.NS.Resolve(pool))
                        }
                        attr.Name = bx.Pool.ref(attr.Name.Resolve(pool))
                        if attr.RawValue != NoEntry {
                                attr.RawValue = bx.Pool.ref(attr.RawValue.Resolve(pool))
                                if attr.TypedValue.Type == DataString {
                                        attr.TypedValue.Value = uint32(attr.RawValue)
                                }
                        }
                }
                for _, child := range el.Children {
                        resolve(child)
                }
        }
        for _, el := range bx.Children {
                resolve(el)
        }

        var asort func(*Element)
        asort = func(el *Element) {
                sort.Sort(byType(el.attrs))
                sort.Sort(byNamespace(el.attrs))
                sort.Sort(byName(el.attrs))
                for _, child := range el.Children {
                        asort(child)
                }
        }
        for _, el := range bx.Children {
                asort(el)
        }

        for i, s := range bx.Pool.strings {
                switch s {
                case androidSchema:
                        bx.Namespace.uri = PoolRef(i)
                        bx.Namespace.end.uri = PoolRef(i)
                case "android":
                        bx.Namespace.prefix = PoolRef(i)
                        bx.Namespace.end.prefix = PoolRef(i)
                }
        }

        return bx, nil
}

// UnmarshalBinary decodes all resource chunks in buf returning any error encountered.
func (bx *XML) UnmarshalBinary(buf []byte) error {
        if err := (&bx.chunkHeader).UnmarshalBinary(buf); err != nil {
                return err
        }
        buf = buf[8:]
        for len(buf) > 0 {
                k, err := bx.unmarshalBinaryKind(buf)
                if err != nil {
                        return err
                }
                buf = buf[k.size():]
        }
        return nil
}

// unmarshalBinaryKind decodes and stores the first resource chunk of bin.
// It returns the unmarshaler interface and any error encountered.
// If k.size() < len(bin), subsequent chunks can be decoded at bin[k.size():].
func (bx *XML) unmarshalBinaryKind(bin []byte) (k unmarshaler, err error) {
        k, err = bx.kind(ResType(btou16(bin)))
        if err != nil {
                return nil, err
        }
        if err = k.UnmarshalBinary(bin); err != nil {
                return nil, err
        }
        return k, nil
}

func (bx *XML) kind(t ResType) (unmarshaler, error) {
        switch t {
        case ResStringPool:
                if bx.Pool != nil {
                        return nil, errors.New("pool already exists")
                }
                bx.Pool = new(Pool)
                return bx.Pool, nil
        case ResXMLResourceMap:
                if bx.Map != nil {
                        return nil, errors.New("resource map already exists")
                }
                bx.Map = new(Map)
                return bx.Map, nil
        case ResXMLStartNamespace:
                if bx.Namespace != nil {
                        return nil, errors.New("namespace start already exists")
                }
                bx.Namespace = new(Namespace)
                return bx.Namespace, nil
        case ResXMLEndNamespace:
                if bx.Namespace.end != nil {
                        return nil, errors.New("namespace end already exists")
                }
                bx.Namespace.end = new(Namespace)
                return bx.Namespace.end, nil
        case ResXMLStartElement:
                el := new(Element)
                if len(bx.stack) == 0 {
                        bx.Children = append(bx.Children, el)
                } else {
                        n := len(bx.stack)
                        var p *Element
                        p, bx.stack = bx.stack[n-1], bx.stack[:n-1]
                        p.Children = append(p.Children, el)
                        bx.stack = append(bx.stack, p)
                }
                bx.stack = append(bx.stack, el)
                return el, nil
        case ResXMLEndElement:
                n := len(bx.stack)
                var el *Element
                el, bx.stack = bx.stack[n-1], bx.stack[:n-1]
                if el.end != nil {
                        return nil, errors.New("element end already exists")
                }
                el.end = new(ElementEnd)
                return el.end, nil
        case ResXMLCharData: // TODO assure correctness
                cdt := new(CharData)
                el := bx.stack[len(bx.stack)-1]
                if el.head == nil {
                        el.head = cdt
                } else if el.tail == nil {
                        el.tail = cdt
                } else {
                        return nil, errors.New("element head and tail already contain chardata")
                }
                return cdt, nil
        default:
                return nil, fmt.Errorf("unexpected type %s", t)
        }
}

func (bx *XML) MarshalBinary() ([]byte, error) {
        bx.typ = ResXML
        bx.headerByteSize = 8

        var (
                bin, b []byte
                err    error
        )
        b, err = bx.chunkHeader.MarshalBinary()
        if err != nil {
                return nil, err
        }
        bin = append(bin, b...)

        b, err = bx.Pool.MarshalBinary()
        if err != nil {
                return nil, err
        }
        bin = append(bin, b...)

        b, err = bx.Map.MarshalBinary()
        if err != nil {
                return nil, err
        }
        bin = append(bin, b...)

        b, err = bx.Namespace.MarshalBinary()
        if err != nil {
                return nil, err
        }
        bin = append(bin, b...)

        for _, child := range bx.Children {
                if err := marshalRecurse(child, &bin); err != nil {
                        return nil, err
                }
        }

        b, err = bx.Namespace.end.MarshalBinary()
        if err != nil {
                return nil, err
        }
        bin = append(bin, b...)

        putu32(bin[4:], uint32(len(bin)))
        return bin, nil
}

func marshalRecurse(el *Element, bin *[]byte) error {
        b, err := el.MarshalBinary()
        if err != nil {
                return err
        }
        *bin = append(*bin, b...)

        if el.head != nil {
                b, err := el.head.MarshalBinary()
                if err != nil {
                        return err
                }
                *bin = append(*bin, b...)
        }

        for _, child := range el.Children {
                if err := marshalRecurse(child, bin); err != nil {
                        return err
                }
        }

        b, err = el.end.MarshalBinary()
        if err != nil {
                return err
        }
        *bin = append(*bin, b...)

        return nil
}

func (bx *XML) iterElements() <-chan *Element {
        ch := make(chan *Element, 1)
        go func() {
                for _, el := range bx.Children {
                        iterElementsRecurse(el, ch)
                }
                close(ch)
        }()
        return ch
}

func iterElementsRecurse(el *Element, ch chan *Element) {
        ch <- el
        for _, e := range el.Children {
                iterElementsRecurse(e, ch)
        }
}

// asSet returns a set from a slice of strings.
func asSet(xs []string) []string {
        m := make(map[string]bool)
        fo := xs[:0]
        for _, x := range xs {
                if !m[x] {
                        m[x] = true
                        fo = append(fo, x)
                }
        }
        return fo
}

// poolTrim trims all but immediately surrounding space.
// \n\t\tfoobar\n\t\t becomes \tfoobar\n
func poolTrim(s string) string {
        var start, end int
        for i, r := range s {
                if !unicode.IsSpace(r) {
                        if i != 0 {
                                start = i - 1 // preserve preceding space
                        }
                        break
                }
        }

        for i := len(s) - 1; i >= 0; i-- {
                r := rune(s[i])
                if !unicode.IsSpace(r) {
                        if i != len(s)-1 {
                                end = i + 2
                        }
                        break
                }
        }

        if start == 0 && end == 0 {
                return "" // every char was a space
        }

        return s[start:end]
}

// byNamespace sorts attributes based on string pool position of namespace.
// Given that "android" always proceeds "" in the pool, this results in the
// correct ordering of attributes.
type byNamespace []*Attribute

func (a byNamespace) Len() int { return len(a) }
func (a byNamespace) Less(i, j int) bool {
        return a[i].NS < a[j].NS
}
func (a byNamespace) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

// byType sorts attributes by the uint8 value of the type.
type byType []*Attribute

func (a byType) Len() int { return len(a) }
func (a byType) Less(i, j int) bool {
        return a[i].TypedValue.Type < a[j].TypedValue.Type
}
func (a byType) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

// byName sorts attributes that have matching types based on string pool position of name.
type byName []*Attribute

func (a byName) Len() int { return len(a) }
func (a byName) Less(i, j int) bool {
        return (a[i].TypedValue.Type == DataString || a[i].TypedValue.Type == DataIntDec) &&
                (a[j].TypedValue.Type == DataString || a[j].TypedValue.Type == DataIntDec) &&
                a[i].Name < a[j].Name
}
func (a byName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

type lineReader struct {
        off   int64
        lines []int64
        r     io.Reader
}

func (r *lineReader) Read(p []byte) (n int, err error) {
        n, err = r.r.Read(p)
        for i := 0; i < n; i++ {
                if p[i] == '\n' {
                        r.lines = append(r.lines, r.off+int64(i))
                }
        }
        r.off += int64(n)
        return n, err
}

func (r *lineReader) line(pos int64) int {
        return sort.Search(len(r.lines), func(i int) bool {
                return pos < r.lines[i]
        }) + 1
}

// Code generated by "stringer -output binres_string.go -type ResType,DataType"; DO NOT EDIT.

package binres

import "strconv"

const (
        _ResType_name_0 = "ResNullResStringPoolResTableResXML"
        _ResType_name_1 = "ResXMLStartNamespaceResXMLEndNamespaceResXMLStartElementResXMLEndElementResXMLCharData"
        _ResType_name_2 = "ResXMLResourceMap"
        _ResType_name_3 = "ResTablePackageResTableTypeResTableTypeSpecResTableLibrary"
)

var (
        _ResType_index_0 = [...]uint8{0, 7, 20, 28, 34}
        _ResType_index_1 = [...]uint8{0, 20, 38, 56, 72, 86}
        _ResType_index_3 = [...]uint8{0, 15, 27, 43, 58}
)

func (i ResType) String() string {
        switch {
        case 0 <= i && i <= 3:
                return _ResType_name_0[_ResType_index_0[i]:_ResType_index_0[i+1]]
        case 256 <= i && i <= 260:
                i -= 256
                return _ResType_name_1[_ResType_index_1[i]:_ResType_index_1[i+1]]
        case i == 384:
                return _ResType_name_2
        case 512 <= i && i <= 515:
                i -= 512
                return _ResType_name_3[_ResType_index_3[i]:_ResType_index_3[i+1]]
        default:
                return "ResType(" + strconv.FormatInt(int64(i), 10) + ")"
        }
}

const (
        _DataType_name_0 = "DataNullDataReferenceDataAttributeDataStringDataFloatDataDimensionDataFractionDataDynamicReference"
        _DataType_name_1 = "DataIntDecDataIntHexDataIntBool"
        _DataType_name_2 = "DataIntColorARGB8DataIntColorRGB8DataIntColorARGB4DataIntColorRGB4"
)

var (
        _DataType_index_0 = [...]uint8{0, 8, 21, 34, 44, 53, 66, 78, 98}
        _DataType_index_1 = [...]uint8{0, 10, 20, 31}
        _DataType_index_2 = [...]uint8{0, 17, 33, 50, 66}
)

func (i DataType) String() string {
        switch {
        case 0 <= i && i <= 7:
                return _DataType_name_0[_DataType_index_0[i]:_DataType_index_0[i+1]]
        case 16 <= i && i <= 18:
                i -= 16
                return _DataType_name_1[_DataType_index_1[i]:_DataType_index_1[i+1]]
        case 28 <= i && i <= 31:
                i -= 28
                return _DataType_name_2[_DataType_index_2[i]:_DataType_index_2[i+1]]
        default:
                return "DataType(" + strconv.FormatInt(int64(i), 10) + ")"
        }
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package binres

// NodeHeader is header all xml node types have, providing additional
// information regarding an xml node over binChunkHeader.
type NodeHeader struct {
        chunkHeader
        LineNumber uint32  // line number in source file this element appears
        Comment    PoolRef // optional xml comment associated with element, MaxUint32 if none
}

func (hdr *NodeHeader) UnmarshalBinary(bin []byte) error {
        if err := (&hdr.chunkHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        hdr.LineNumber = btou32(bin[8:])
        hdr.Comment = PoolRef(btou32(bin[12:]))
        return nil
}

func (hdr *NodeHeader) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 16)
        b, err := hdr.chunkHeader.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin, b)
        putu32(bin[8:], hdr.LineNumber)
        putu32(bin[12:], uint32(hdr.Comment))
        return bin, nil
}

type Namespace struct {
        NodeHeader
        prefix PoolRef
        uri    PoolRef

        end *Namespace // TODO don't let this type be recursive
}

func (ns *Namespace) UnmarshalBinary(bin []byte) error {
        if err := (&ns.NodeHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        buf := bin[ns.headerByteSize:]
        ns.prefix = PoolRef(btou32(buf))
        ns.uri = PoolRef(btou32(buf[4:]))
        return nil
}

func (ns *Namespace) MarshalBinary() ([]byte, error) {
        if ns.end == nil {
                ns.typ = ResXMLEndNamespace
        } else {
                ns.typ = ResXMLStartNamespace
        }
        ns.headerByteSize = 16
        ns.byteSize = 24

        bin := make([]byte, ns.byteSize)
        b, err := ns.NodeHeader.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin, b)
        putu32(bin[16:], uint32(ns.prefix))
        putu32(bin[20:], uint32(ns.uri))
        return bin, nil
}

type Element struct {
        NodeHeader
        NS             PoolRef
        Name           PoolRef // name of node if element, otherwise chardata if CDATA
        AttributeStart uint16  // byte offset where attrs start
        AttributeSize  uint16  // byte size of attrs
        AttributeCount uint16  // length of attrs
        IdIndex        uint16  // Index (1-based) of the "id" attribute. 0 if none.
        ClassIndex     uint16  // Index (1-based) of the "class" attribute. 0 if none.
        StyleIndex     uint16  // Index (1-based) of the "style" attribute. 0 if none.

        attrs    []*Attribute
        Children []*Element
        end      *ElementEnd

        head, tail *CharData
}

func (el *Element) UnmarshalBinary(buf []byte) error {
        if err := (&el.NodeHeader).UnmarshalBinary(buf); err != nil {
                return err
        }
        buf = buf[el.headerByteSize:]
        el.NS = PoolRef(btou32(buf))
        el.Name = PoolRef(btou32(buf[4:]))

        el.AttributeStart = btou16(buf[8:])
        el.AttributeSize = btou16(buf[10:])
        el.AttributeCount = btou16(buf[12:])
        el.IdIndex = btou16(buf[14:])
        el.ClassIndex = btou16(buf[16:])
        el.StyleIndex = btou16(buf[18:])

        buf = buf[el.AttributeStart:]
        el.attrs = make([]*Attribute, int(el.AttributeCount))
        for i := range el.attrs {
                attr := new(Attribute)
                if err := attr.UnmarshalBinary(buf); err != nil {
                        return err
                }
                el.attrs[i] = attr
                buf = buf[el.AttributeSize:]
        }

        return nil
}

func (el *Element) MarshalBinary() ([]byte, error) {
        el.typ = ResXMLStartElement
        el.headerByteSize = 16
        el.AttributeSize = 20
        el.AttributeStart = 20
        el.AttributeCount = uint16(len(el.attrs))
        el.IdIndex = 0
        el.ClassIndex = 0
        el.StyleIndex = 0
        el.byteSize = uint32(el.headerByteSize) + uint32(el.AttributeStart) + uint32(len(el.attrs)*int(el.AttributeSize))

        bin := make([]byte, el.byteSize)
        b, err := el.NodeHeader.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin, b)
        putu32(bin[16:], uint32(el.NS))
        putu32(bin[20:], uint32(el.Name))
        putu16(bin[24:], el.AttributeStart)
        putu16(bin[26:], el.AttributeSize)
        putu16(bin[28:], el.AttributeCount)
        putu16(bin[30:], el.IdIndex)
        putu16(bin[32:], el.ClassIndex)
        putu16(bin[34:], el.StyleIndex)

        buf := bin[36:]
        for _, attr := range el.attrs {
                b, err := attr.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                copy(buf, b)
                buf = buf[int(el.AttributeSize):]
        }

        return bin, nil
}

// ElementEnd marks the end of an element node, either Element or CharData.
type ElementEnd struct {
        NodeHeader
        NS   PoolRef
        Name PoolRef // name of node if binElement, raw chardata if binCharData
}

func (el *ElementEnd) UnmarshalBinary(bin []byte) error {
        (&el.NodeHeader).UnmarshalBinary(bin)
        buf := bin[el.headerByteSize:]
        el.NS = PoolRef(btou32(buf))
        el.Name = PoolRef(btou32(buf[4:]))
        return nil
}

func (el *ElementEnd) MarshalBinary() ([]byte, error) {
        el.typ = ResXMLEndElement
        el.headerByteSize = 16
        el.byteSize = 24

        bin := make([]byte, 24)
        b, err := el.NodeHeader.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin, b)
        putu32(bin[16:], uint32(el.NS))
        putu32(bin[20:], uint32(el.Name))
        return bin, nil
}

type Attribute struct {
        NS         PoolRef
        Name       PoolRef
        RawValue   PoolRef // The original raw string value of this attribute.
        TypedValue Data    // Processesd typed value of this attribute.
}

func (attr *Attribute) UnmarshalBinary(bin []byte) error {
        attr.NS = PoolRef(btou32(bin))
        attr.Name = PoolRef(btou32(bin[4:]))
        attr.RawValue = PoolRef(btou32(bin[8:]))
        return (&attr.TypedValue).UnmarshalBinary(bin[12:])
}

func (attr *Attribute) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 20)
        putu32(bin, uint32(attr.NS))
        putu32(bin[4:], uint32(attr.Name))
        putu32(bin[8:], uint32(attr.RawValue))
        b, err := attr.TypedValue.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin[12:], b)
        return bin, nil
}

// CharData represents a CDATA node and includes ref to node's text value.
type CharData struct {
        NodeHeader
        RawData   PoolRef // raw character data
        TypedData Data    // typed value of character data
}

func (cdt *CharData) UnmarshalBinary(bin []byte) error {
        if err := (&cdt.NodeHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        buf := bin[cdt.headerByteSize:]
        cdt.RawData = PoolRef(btou32(buf))
        return (&cdt.TypedData).UnmarshalBinary(buf[4:])
}

func (cdt *CharData) MarshalBinary() ([]byte, error) {
        cdt.typ = ResXMLCharData
        cdt.headerByteSize = 16
        cdt.byteSize = 28

        bin := make([]byte, cdt.byteSize)
        b, err := cdt.NodeHeader.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin, b)
        putu32(bin[16:], uint32(cdt.RawData))
        b, err = cdt.TypedData.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin[20:], b)
        return bin, nil
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package binres

import (
        "errors"
        "fmt"
        "unicode/utf16"
)

const (
        SortedFlag uint32 = 1 << 0
        UTF8Flag          = 1 << 8
)

// PoolRef is the i'th string in a pool.
type PoolRef uint32

// Resolve returns the string entry of PoolRef in pl.
func (ref PoolRef) Resolve(pl *Pool) string {
        return pl.strings[ref]
}

// Pool is a container for string and style span collections.
//
// Pool has the following structure marshalled:
//
//                chunkHeader
//         uint32 number of strings in this pool
//         uint32 number of style spans in pool
//         uint32 SortedFlag, UTF8Flag
//         uint32 index of string data from header
//         uint32 index of style data from header
//         []uint32 string indices starting at zero
//         []uint16 or []uint8 concatenation of string entries
//
// UTF-16 entries are as follows:
//
//        uint16 string length, exclusive
//        uint16 [optional] low word if high bit of length set
//        [n]byte data
//        uint16 0x0000 terminator
//
// UTF-8 entries are as follows:
//
//        uint8 character length, exclusive
//        uint8 [optional] low word if high bit of character length set
//        uint8 byte length, exclusive
//        uint8 [optional] low word if high bit of byte length set
//        [n]byte data
//        uint8 0x00 terminator
type Pool struct {
        chunkHeader
        strings []string
        styles  []*Span
        flags   uint32 // SortedFlag, UTF8Flag
}

// ref returns the PoolRef of s, inserting s if it doesn't exist.
func (pl *Pool) ref(s string) PoolRef {
        for i, x := range pl.strings {
                if s == x {
                        return PoolRef(i)
                }
        }
        pl.strings = append(pl.strings, s)
        return PoolRef(len(pl.strings) - 1)
}

// RefByName returns the PoolRef of s, or error if not exists.
func (pl *Pool) RefByName(s string) (PoolRef, error) {
        for i, x := range pl.strings {
                if s == x {
                        return PoolRef(i), nil
                }
        }
        return 0, fmt.Errorf("PoolRef by name %q does not exist", s)
}

func (pl *Pool) IsSorted() bool { return pl.flags&SortedFlag == SortedFlag }
func (pl *Pool) IsUTF8() bool   { return pl.flags&UTF8Flag == UTF8Flag }

func (pl *Pool) UnmarshalBinary(bin []byte) error {
        if err := (&pl.chunkHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        if pl.typ != ResStringPool {
                return fmt.Errorf("have type %s, want %s", pl.typ, ResStringPool)
        }

        pl.strings = make([]string, btou32(bin[8:]))
        pl.styles = make([]*Span, btou32(bin[12:]))
        pl.flags = btou32(bin[16:])

        offstrings := btou32(bin[20:])
        offstyle := btou32(bin[24:])
        hdrlen := 28

        if pl.IsUTF8() {
                for i := range pl.strings {
                        offset := int(offstrings + btou32(bin[hdrlen+i*4:]))

                        // if leading bit set for nchars and nbytes,
                        // treat first byte as 7-bit high word and next as low word.
                        nchars := int(bin[offset])
                        offset++
                        if nchars&(1<<7) != 0 {
                                n0 := nchars ^ (1 << 7) // high word
                                n1 := int(bin[offset])  // low word
                                nchars = n0*(1<<8) + n1
                                offset++
                        }

                        // TODO(d) At least one case in android.jar (api-10) resource table has only
                        // highbit set, making 7-bit highword zero. The reason for this is currently
                        // unknown but would make tests that unmarshal-marshal to match bytes impossible.
                        // The values noted were high-word: 0 (after highbit unset), low-word: 141
                        // The size may be treated as an int8 triggering the use of two bytes to store size
                        // even though the implementation uses uint8.
                        nbytes := int(bin[offset])
                        offset++
                        if nbytes&(1<<7) != 0 {
                                n0 := nbytes ^ (1 << 7) // high word
                                n1 := int(bin[offset])  // low word
                                nbytes = n0*(1<<8) + n1
                                offset++
                        }

                        data := bin[offset : offset+nbytes]
                        if x := uint8(bin[offset+nbytes]); x != 0 {
                                return fmt.Errorf("expected zero terminator, got 0x%02X for nchars=%v nbytes=%v data=%q", x, nchars, nbytes, data)
                        }
                        pl.strings[i] = string(data)
                }
        } else {
                for i := range pl.strings {
                        offset := int(offstrings + btou32(bin[hdrlen+i*4:])) // read index of string

                        // if leading bit set for nchars, treat first byte as 7-bit high word and next as low word.
                        nchars := int(btou16(bin[offset:]))
                        offset += 2
                        if nchars&(1<<15) != 0 { // TODO(d) this is untested
                                n0 := nchars ^ (1 << 15)        // high word
                                n1 := int(btou16(bin[offset:])) // low word
                                nchars = n0*(1<<16) + n1
                                offset += 2
                        }

                        data := make([]uint16, nchars)
                        for i := range data {
                                data[i] = btou16(bin[offset+2*i:])
                        }

                        if x := btou16(bin[offset+nchars*2:]); x != 0 {
                                return fmt.Errorf("expected zero terminator, got 0x%04X for nchars=%v data=%q", x, nchars, data)
                        }
                        pl.strings[i] = string(utf16.Decode(data))
                }
        }

        // TODO decode styles
        _ = offstyle

        return nil
}

func (pl *Pool) MarshalBinary() ([]byte, error) {
        if pl.IsUTF8() {
                return nil, errors.New("encode utf8 not supported")
        }

        var (
                hdrlen = 28
                // indices of string indices
                iis    = make([]uint32, len(pl.strings))
                iislen = len(iis) * 4
                // utf16 encoded strings concatenated together
                strs []uint16
        )
        for i, x := range pl.strings {
                if len(x)>>16 > 0 {
                        panic(fmt.Errorf("string lengths over 1<<15 not yet supported, got len %d", len(x)))
                }
                p := utf16.Encode([]rune(x))
                if len(p) == 0 {
                        strs = append(strs, 0x0000, 0x0000)
                } else {
                        strs = append(strs, uint16(len(p))) // string length (implicitly includes zero terminator to follow)
                        strs = append(strs, p...)
                        strs = append(strs, 0) // zero terminated
                }
                // indices start at zero
                if i+1 != len(iis) {
                        iis[i+1] = uint32(len(strs) * 2) // utf16 byte index
                }
        }

        // check strings is 4-byte aligned, pad with zeros if not.
        for x := (len(strs) * 2) % 4; x != 0; x -= 2 {
                strs = append(strs, 0x0000)
        }

        strslen := len(strs) * 2

        hdr := chunkHeader{
                typ:            ResStringPool,
                headerByteSize: 28,
                byteSize:       uint32(28 + iislen + strslen),
        }

        bin := make([]byte, hdr.byteSize)

        hdrbin, err := hdr.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin, hdrbin)

        putu32(bin[8:], uint32(len(pl.strings)))
        putu32(bin[12:], uint32(len(pl.styles)))
        putu32(bin[16:], pl.flags)
        putu32(bin[20:], uint32(hdrlen+iislen))
        putu32(bin[24:], 0) // index of styles start, is 0 when styles length is 0

        buf := bin[28:]
        for _, x := range iis {
                putu32(buf, x)
                buf = buf[4:]
        }

        for _, x := range strs {
                putu16(buf, x)
                buf = buf[2:]
        }

        if len(buf) != 0 {
                panic(fmt.Errorf("failed to fill allocated buffer, %v bytes left over", len(buf)))
        }

        return bin, nil
}

type Span struct {
        name PoolRef

        firstChar, lastChar uint32
}

func (spn *Span) UnmarshalBinary(bin []byte) error {
        const end = 0xFFFFFFFF
        spn.name = PoolRef(btou32(bin))
        if spn.name == end {
                return nil
        }
        spn.firstChar = btou32(bin[4:])
        spn.lastChar = btou32(bin[8:])
        return nil
}

// Map contains a uint32 slice mapping strings in the string
// pool back to resource identifiers. The i'th element of the slice
// is also the same i'th element of the string pool.
type Map struct {
        chunkHeader
        rs []TableRef
}

func (m *Map) UnmarshalBinary(bin []byte) error {
        (&m.chunkHeader).UnmarshalBinary(bin)
        buf := bin[m.headerByteSize:m.byteSize]
        m.rs = make([]TableRef, len(buf)/4)
        for i := range m.rs {
                m.rs[i] = TableRef(btou32(buf[i*4:]))
        }
        return nil
}

func (m *Map) MarshalBinary() ([]byte, error) {
        m.typ = ResXMLResourceMap
        m.headerByteSize = 8
        m.byteSize = uint32(m.headerByteSize) + uint32(len(m.rs)*4)
        bin := make([]byte, m.byteSize)
        b, err := m.chunkHeader.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin, b)
        for i, r := range m.rs {
                putu32(bin[8+i*4:], uint32(r))
        }
        return bin, nil
}

package binres

import (
        "archive/zip"
        "bytes"
        "compress/gzip"
        "errors"
        "fmt"
        "io"
        "os"
        "path/filepath"

        "cogentcore.org/core/cmd/core/mobile/sdkpath"
)

// MinSDK is the targeted sdk version for support by package binres.
const MinSDK = 16

func apiResources() ([]byte, error) {
        apiResPath, err := apiResourcesPath()
        if err != nil {
                return nil, err
        }
        zr, err := zip.OpenReader(apiResPath)
        if err != nil {
                if os.IsNotExist(err) {
                        return nil, fmt.Errorf(`%v; consider installing with "android update sdk --all --no-ui --filter android-%d"`, err, MinSDK)
                }
                return nil, err
        }
        defer zr.Close()

        buf := new(bytes.Buffer)
        for _, f := range zr.File {
                if f.Name == "resources.arsc" {
                        rc, err := f.Open()
                        if err != nil {
                                return nil, err
                        }
                        _, err = io.Copy(buf, rc)
                        if err != nil {
                                return nil, err
                        }
                        rc.Close()
                        break
                }
        }
        if buf.Len() == 0 {
                return nil, errors.New("failed to read resources.arsc")
        }
        return buf.Bytes(), nil
}

func apiResourcesPath() (string, error) {
        platformDir, err := sdkpath.AndroidAPIPath(MinSDK)
        if err != nil {
                return "", err
        }
        return filepath.Join(platformDir, "android.jar"), nil
}

// PackResources produces a stripped down gzip version of the resources.arsc from api jar.
func PackResources() ([]byte, error) {
        tbl, err := OpenSDKTable()
        if err != nil {
                return nil, err
        }

        tbl.pool.strings = []string{} // should not be needed
        pkg := tbl.pkgs[0]

        // drop language string entries
        for _, typ := range pkg.specs[3].types {
                if typ.config.locale.language != 0 {
                        for j, nt := range typ.entries {
                                if nt == nil { // NoEntry
                                        continue
                                }
                                pkg.keyPool.strings[nt.key] = ""
                                typ.indices[j] = NoEntry
                                typ.entries[j] = nil
                        }
                }
        }

        // drop strings from pool for specs to be dropped
        for _, spec := range pkg.specs[4:] {
                for _, typ := range spec.types {
                        for _, nt := range typ.entries {
                                if nt == nil { // NoEntry
                                        continue
                                }
                                // don't drop if there's a collision
                                var collision bool
                                for _, xspec := range pkg.specs[:4] {
                                        for _, xtyp := range xspec.types {
                                                for _, xnt := range xtyp.entries {
                                                        if xnt == nil {
                                                                continue
                                                        }
                                                        if collision = nt.key == xnt.key; collision {
                                                                break
                                                        }
                                                }
                                        }
                                }
                                if !collision {
                                        pkg.keyPool.strings[nt.key] = ""
                                }
                        }
                }
        }

        // entries are densely packed but probably safe to drop nil entries off the end
        for _, spec := range pkg.specs[:4] {
                for _, typ := range spec.types {
                        var last int
                        for i, nt := range typ.entries {
                                if nt != nil {
                                        last = i
                                }
                        }
                        typ.entries = typ.entries[:last+1]
                        typ.indices = typ.indices[:last+1]
                }
        }

        // keeping 0:attr, 1:id, 2:style, 3:string
        pkg.typePool.strings = pkg.typePool.strings[:4]
        pkg.specs = pkg.specs[:4]

        bin, err := tbl.MarshalBinary()
        if err != nil {
                return nil, err
        }

        buf := new(bytes.Buffer)

        zw := gzip.NewWriter(buf)
        if _, err := zw.Write(bin); err != nil {
                return nil, err
        }
        if err := zw.Flush(); err != nil {
                return nil, err
        }
        if err := zw.Close(); err != nil {
                return nil, err
        }
        return buf.Bytes(), nil
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package binres

import (
        "bytes"
        "compress/gzip"
        "errors"
        "fmt"
        "io"
        "strings"
        "unicode/utf16"
)

const NoEntry = 0xFFFFFFFF

// TableRef uniquely identifies entries within a resource table.
type TableRef uint32

// Resolve returns the Entry of TableRef in the given table.
//
// A TableRef is structured as follows:
//
//        0xpptteeee
//        pp: package index
//        tt: type spec index in package
//        eeee: entry index in type spec
//
// The package and type spec values start at 1 for the first item,
// to help catch cases where they have not been supplied.
func (ref TableRef) Resolve(tbl *Table) (*Entry, error) {
        pkg := tbl.pkgs[uint8(ref>>24)-1]
        spec := pkg.specs[uint8(ref>>16)-1]
        idx := uint16(ref)

        for _, typ := range spec.types {
                if idx < uint16(len(typ.entries)) {
                        nt := typ.entries[idx]
                        if nt == nil {
                                return nil, errors.New("nil entry match")
                        }
                        return nt, nil
                }
        }

        return nil, errors.New("failed to resolve table reference")
}

// Table is a container for packaged resources. Resource values within a package
// are obtained through pool while resource names and identifiers are obtained
// through each package's type and key pools respectively.
type Table struct {
        chunkHeader
        pool *Pool
        pkgs []*Package
}

// NewMipmapTable returns a resource table initialized for a single xxxhdpi mipmap resource
// and the path to write resource data to.
func NewMipmapTable(pkgname string) (*Table, string) {
        pkg := &Package{id: 127, name: pkgname, typePool: &Pool{}, keyPool: &Pool{}}

        attr := pkg.typePool.ref("attr")
        mipmap := pkg.typePool.ref("mipmap")
        icon := pkg.keyPool.ref("icon")

        nt := &Entry{values: []*Value{{data: &Data{Type: DataString}}}}
        typ := &Type{id: 2, indices: []uint32{0}, entries: []*Entry{nt}}
        typ.config.screenType.density = 640
        typ.config.version.sdk = 4

        pkg.specs = append(pkg.specs,
                &TypeSpec{
                        id: uint8(attr) + 1, //1,
                },
                &TypeSpec{
                        id:         uint8(mipmap) + 1, //2,
                        entryCount: 1,
                        entries:    []uint32{uint32(icon)}, // {0}
                        types:      []*Type{typ},
                })

        pkg.lastPublicType = uint32(len(pkg.typePool.strings)) // 2
        pkg.lastPublicKey = uint32(len(pkg.keyPool.strings))   // 1

        name := "res/mipmap-xxxhdpi-v4/icon.png"
        tbl := &Table{pool: &Pool{}, pkgs: []*Package{pkg}}
        tbl.pool.ref(name)
        return tbl, name
}

// OpenSDKTable decodes resources.arsc from sdk platform jar.
func OpenSDKTable() (*Table, error) {
        bin, err := apiResources()
        if err != nil {
                return nil, err
        }
        tbl := new(Table)
        if err := tbl.UnmarshalBinary(bin); err != nil {
                return nil, err
        }
        return tbl, nil
}

// OpenTable decodes the prepacked resources.arsc for the supported sdk platform.
func OpenTable() (*Table, error) {
        zr, err := gzip.NewReader(bytes.NewReader(arsc))
        if err != nil {
                return nil, fmt.Errorf("gzip: %v", err)
        }
        defer zr.Close()

        var buf bytes.Buffer
        if _, err := io.Copy(&buf, zr); err != nil {
                return nil, fmt.Errorf("io: %v", err)
        }
        tbl := new(Table)
        if err := tbl.UnmarshalBinary(buf.Bytes()); err != nil {
                return nil, err
        }
        return tbl, nil
}

// SpecByName parses the spec name from an entry string if necessary and returns
// the Package and TypeSpec associated with that name along with their respective
// indices.
//
// For example:
//
//        tbl.SpecByName("@android:style/Theme.NoTitleBar")
//        tbl.SpecByName("style")
//
// Both locate the spec by name "style".
func (tbl *Table) SpecByName(name string) (int, *Package, int, *TypeSpec, error) {
        n := strings.TrimPrefix(name, "@android:")
        n = strings.Split(n, "/")[0]
        for pp, pkg := range tbl.pkgs {
                for tt, spec := range pkg.specs {
                        if n == pkg.typePool.strings[spec.id-1] {
                                return pp, pkg, tt, spec, nil
                        }
                }
        }
        return 0, nil, 0, nil, fmt.Errorf("spec by name not found: %q", name)
}

// RefByName returns the TableRef by a given name. The ref may be used to resolve the
// associated Entry and is used for the generation of binary manifest files.
func (tbl *Table) RefByName(name string) (TableRef, error) {
        pp, pkg, tt, spec, err := tbl.SpecByName(name)
        if err != nil {
                return 0, err
        }

        q := strings.Split(name, "/")
        if len(q) != 2 {
                return 0, fmt.Errorf("invalid entry format, missing forward-slash: %q", name)
        }
        n := q[1]

        for _, t := range spec.types {
                for eeee, nt := range t.entries {
                        if nt == nil { // NoEntry
                                continue
                        }
                        if n == pkg.keyPool.strings[nt.key] {
                                return TableRef(uint32(eeee) | uint32(tt+1)<<16 | uint32(pp+1)<<24), nil
                        }
                }
        }
        return 0, fmt.Errorf("failed to find table ref by %q", name)
}

func (tbl *Table) UnmarshalBinary(bin []byte) error {
        if err := (&tbl.chunkHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        if tbl.typ != ResTable {
                return fmt.Errorf("unexpected resource type %s, want %s", tbl.typ, ResTable)
        }

        npkgs := btou32(bin[8:])
        tbl.pkgs = make([]*Package, npkgs)

        buf := bin[tbl.headerByteSize:]

        tbl.pool = new(Pool)
        if err := tbl.pool.UnmarshalBinary(buf); err != nil {
                return err
        }
        buf = buf[tbl.pool.size():]
        for i := range tbl.pkgs {
                pkg := new(Package)
                if err := pkg.UnmarshalBinary(buf); err != nil {
                        return err
                }
                tbl.pkgs[i] = pkg
                buf = buf[pkg.byteSize:]
        }

        return nil
}

func (tbl *Table) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 12)
        putu16(bin, uint16(ResTable))
        putu16(bin[2:], 12)
        putu32(bin[8:], uint32(len(tbl.pkgs)))

        if tbl.pool.IsUTF8() {
                tbl.pool.flags ^= UTF8Flag
                defer func() {
                        tbl.pool.flags |= UTF8Flag
                }()
        }

        b, err := tbl.pool.MarshalBinary()
        if err != nil {
                return nil, err
        }
        bin = append(bin, b...)

        for _, pkg := range tbl.pkgs {
                b, err = pkg.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                bin = append(bin, b...)
        }

        putu32(bin[4:], uint32(len(bin)))

        return bin, nil
}

// Package contains a collection of resource data types.
type Package struct {
        chunkHeader

        id   uint32
        name string

        lastPublicType uint32 // last index into typePool that is for public use
        lastPublicKey  uint32 // last index into keyPool that is for public use

        typePool *Pool // type names; e.g. theme
        keyPool  *Pool // resource names; e.g. Theme.NoTitleBar

        aliases []*StagedAlias
        specs   []*TypeSpec
}

func (pkg *Package) UnmarshalBinary(bin []byte) error {
        if err := (&pkg.chunkHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        if pkg.typ != ResTablePackage {
                return errWrongType(pkg.typ, ResTablePackage)
        }

        pkg.id = btou32(bin[8:])

        var name []uint16
        for i := 0; i < 128; i++ {
                x := btou16(bin[12+i*2:])
                if x == 0 {
                        break
                }
                name = append(name, x)
        }
        pkg.name = string(utf16.Decode(name))

        typeOffset := btou32(bin[268:]) // 0 if inheriting from another package
        pkg.lastPublicType = btou32(bin[272:])
        keyOffset := btou32(bin[276:]) // 0 if inheriting from another package
        pkg.lastPublicKey = btou32(bin[280:])

        var idOffset uint32 // value determined by either typePool or keyPool below

        if typeOffset != 0 {
                pkg.typePool = new(Pool)
                if err := pkg.typePool.UnmarshalBinary(bin[typeOffset:]); err != nil {
                        return err
                }
                idOffset = typeOffset + pkg.typePool.byteSize
        }

        if keyOffset != 0 {
                pkg.keyPool = new(Pool)
                if err := pkg.keyPool.UnmarshalBinary(bin[keyOffset:]); err != nil {
                        return err
                }
                idOffset = keyOffset + pkg.keyPool.byteSize
        }

        if idOffset == 0 {
                return nil
        }

        buf := bin[idOffset:pkg.byteSize]
        for len(buf) > 0 {
                t := ResType(btou16(buf))
                switch t {
                case ResTableTypeSpec:
                        spec := new(TypeSpec)
                        if err := spec.UnmarshalBinary(buf); err != nil {
                                return err
                        }
                        pkg.specs = append(pkg.specs, spec)
                        buf = buf[spec.byteSize:]
                case ResTableType:
                        typ := new(Type)
                        if err := typ.UnmarshalBinary(buf); err != nil {
                                return err
                        }
                        last := pkg.specs[len(pkg.specs)-1]
                        last.types = append(last.types, typ)
                        buf = buf[typ.byteSize:]
                case ResTableStagedAlias:
                        alias := new(StagedAlias)
                        if err := alias.UnmarshalBinary(buf); err != nil {
                                return err
                        }
                        pkg.aliases = append(pkg.aliases, alias)
                        buf = buf[alias.byteSize:]
                default:
                        return errWrongType(t, ResTableTypeSpec, ResTableType, ResTableStagedAlias)
                }
        }

        return nil
}

func (pkg *Package) MarshalBinary() ([]byte, error) {
        // Package header size is determined by C++ struct ResTable_package
        // see frameworks/base/include/ResourceTypes.h
        bin := make([]byte, 288)
        putu16(bin, uint16(ResTablePackage))
        putu16(bin[2:], 288)

        putu32(bin[8:], pkg.id)
        p := utf16.Encode([]rune(pkg.name))
        for i, x := range p {
                putu16(bin[12+i*2:], x)
        }

        if pkg.typePool != nil {
                if pkg.typePool.IsUTF8() {
                        pkg.typePool.flags ^= UTF8Flag
                        defer func() {
                                pkg.typePool.flags |= UTF8Flag
                        }()
                }

                b, err := pkg.typePool.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                putu32(bin[268:], uint32(len(bin)))
                putu32(bin[272:], pkg.lastPublicType)
                bin = append(bin, b...)
        }

        if pkg.keyPool != nil {
                if pkg.keyPool.IsUTF8() {
                        pkg.keyPool.flags ^= UTF8Flag
                        defer func() {
                                pkg.keyPool.flags |= UTF8Flag
                        }()
                }
                b, err := pkg.keyPool.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                putu32(bin[276:], uint32(len(bin)))
                putu32(bin[280:], pkg.lastPublicKey)
                bin = append(bin, b...)
        }

        for _, alias := range pkg.aliases {
                b, err := alias.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                bin = append(bin, b...)
        }

        for _, spec := range pkg.specs {
                b, err := spec.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                bin = append(bin, b...)
        }

        putu32(bin[4:], uint32(len(bin)))
        return bin, nil
}

// TypeSpec provides a specification for the resources defined by a particular type.
type TypeSpec struct {
        chunkHeader
        id         uint8  // id-1 is name index in Package.typePool
        res0       uint8  // must be 0
        res1       uint16 // must be 0
        entryCount uint32 // number of uint32 entry configuration masks that follow

        entries []uint32 // entry configuration masks
        types   []*Type
}

func (spec *TypeSpec) UnmarshalBinary(bin []byte) error {
        if err := (&spec.chunkHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        if spec.typ != ResTableTypeSpec {
                return errWrongType(spec.typ, ResTableTypeSpec)
        }
        spec.id = uint8(bin[8])
        spec.res0 = uint8(bin[9])
        spec.res1 = btou16(bin[10:])
        spec.entryCount = btou32(bin[12:])

        spec.entries = make([]uint32, spec.entryCount)
        for i := range spec.entries {
                spec.entries[i] = btou32(bin[16+i*4:])
        }

        return nil
}

func (spec *TypeSpec) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 16+len(spec.entries)*4)
        putu16(bin, uint16(ResTableTypeSpec))
        putu16(bin[2:], 16)
        putu32(bin[4:], uint32(len(bin)))

        bin[8] = byte(spec.id)
        // [9] = 0
        // [10:12] = 0
        putu32(bin[12:], uint32(len(spec.entries)))
        for i, x := range spec.entries {
                putu32(bin[16+i*4:], x)
        }

        for _, typ := range spec.types {
                b, err := typ.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                bin = append(bin, b...)
        }

        return bin, nil
}

// Type provides a collection of entries for a specific device configuration.
type Type struct {
        chunkHeader
        id           uint8
        res0         uint8  // must be 0
        res1         uint16 // must be 0
        entryCount   uint32 // number of uint32 entry configuration masks that follow
        entriesStart uint32 // offset from header where Entry data starts

        // configuration this collection of entries is designed for
        config struct {
                size uint32
                imsi struct {
                        mcc uint16 // mobile country code
                        mnc uint16 // mobile network code
                }
                locale struct {
                        language uint16
                        country  uint16
                }
                screenType struct {
                        orientation uint8
                        touchscreen uint8
                        density     uint16
                }
                input struct {
                        keyboard   uint8
                        navigation uint8
                        inputFlags uint8
                        inputPad0  uint8
                }
                screenSize struct {
                        width  uint16
                        height uint16
                }
                version struct {
                        sdk   uint16
                        minor uint16 // always 0
                }
                screenConfig struct {
                        layout          uint8
                        uiMode          uint8
                        smallestWidthDP uint16
                }
                screenSizeDP struct {
                        width  uint16
                        height uint16
                }
        }

        indices []uint32 // values that map to typePool
        entries []*Entry
}

func (typ *Type) UnmarshalBinary(bin []byte) error {
        if err := (&typ.chunkHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        if typ.typ != ResTableType {
                return errWrongType(typ.typ, ResTableType)
        }

        typ.id = uint8(bin[8])
        typ.res0 = uint8(bin[9])
        typ.res1 = btou16(bin[10:])
        typ.entryCount = btou32(bin[12:])
        typ.entriesStart = btou32(bin[16:])

        if typ.res0 != 0 || typ.res1 != 0 {
                return errors.New("res0 res1 not zero")
        }

        typ.config.size = btou32(bin[20:])
        typ.config.imsi.mcc = btou16(bin[24:])
        typ.config.imsi.mnc = btou16(bin[26:])
        typ.config.locale.language = btou16(bin[28:])
        typ.config.locale.country = btou16(bin[30:])
        typ.config.screenType.orientation = uint8(bin[32])
        typ.config.screenType.touchscreen = uint8(bin[33])
        typ.config.screenType.density = btou16(bin[34:])
        typ.config.input.keyboard = uint8(bin[36])
        typ.config.input.navigation = uint8(bin[37])
        typ.config.input.inputFlags = uint8(bin[38])
        typ.config.input.inputPad0 = uint8(bin[39])
        typ.config.screenSize.width = btou16(bin[40:])
        typ.config.screenSize.height = btou16(bin[42:])
        typ.config.version.sdk = btou16(bin[44:])
        typ.config.version.minor = btou16(bin[46:])
        typ.config.screenConfig.layout = uint8(bin[48])
        typ.config.screenConfig.uiMode = uint8(bin[49])
        typ.config.screenConfig.smallestWidthDP = btou16(bin[50:])
        typ.config.screenSizeDP.width = btou16(bin[52:])
        typ.config.screenSizeDP.height = btou16(bin[54:])

        // fmt.Println("language/country:", u16tos(typ.config.locale.language), u16tos(typ.config.locale.country))

        buf := bin[typ.headerByteSize:typ.entriesStart]
        if len(buf) != 4*int(typ.entryCount) {
                return fmt.Errorf("index buffer len[%v] doesn't match entryCount[%v]", len(buf), typ.entryCount)
        }

        typ.indices = make([]uint32, typ.entryCount)
        for i := range typ.indices {
                typ.indices[i] = btou32(buf[i*4:])
        }

        typ.entries = make([]*Entry, typ.entryCount)

        for i, x := range typ.indices {
                if x == NoEntry {
                        continue
                }
                nt := &Entry{}
                if err := nt.UnmarshalBinary(bin[typ.entriesStart+x:]); err != nil {
                        return err
                }
                typ.entries[i] = nt
        }

        return nil
}

func (typ *Type) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 56+len(typ.entries)*4)
        putu16(bin, uint16(ResTableType))
        putu16(bin[2:], 56)

        bin[8] = byte(typ.id)
        // [9] = 0
        // [10:12] = 0
        putu32(bin[12:], uint32(len(typ.entries)))
        putu32(bin[16:], uint32(56+len(typ.entries)*4))

        // assure typ.config.size is always written as 36; extended configuration beyond supported
        // API level is not supported by this marshal implementation but will be forward-compatible.
        putu32(bin[20:], 36)

        putu16(bin[24:], typ.config.imsi.mcc)
        putu16(bin[26:], typ.config.imsi.mnc)
        putu16(bin[28:], typ.config.locale.language)
        putu16(bin[30:], typ.config.locale.country)
        bin[32] = typ.config.screenType.orientation
        bin[33] = typ.config.screenType.touchscreen
        putu16(bin[34:], typ.config.screenType.density)
        bin[36] = typ.config.input.keyboard
        bin[37] = typ.config.input.navigation
        bin[38] = typ.config.input.inputFlags
        bin[39] = typ.config.input.inputPad0
        putu16(bin[40:], typ.config.screenSize.width)
        putu16(bin[42:], typ.config.screenSize.height)
        putu16(bin[44:], typ.config.version.sdk)
        putu16(bin[46:], typ.config.version.minor)
        bin[48] = typ.config.screenConfig.layout
        bin[49] = typ.config.screenConfig.uiMode
        putu16(bin[50:], typ.config.screenConfig.smallestWidthDP)
        putu16(bin[52:], typ.config.screenSizeDP.width)
        putu16(bin[54:], typ.config.screenSizeDP.height)

        var ntbin []byte
        for i, nt := range typ.entries {
                if nt == nil { // NoEntry
                        putu32(bin[56+i*4:], NoEntry)
                        continue
                }
                putu32(bin[56+i*4:], uint32(len(ntbin)))
                b, err := nt.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                ntbin = append(ntbin, b...)
        }
        bin = append(bin, ntbin...)

        putu32(bin[4:], uint32(len(bin)))
        return bin, nil
}

type StagedAliasEntry struct {
        stagedID    uint32
        finalizedID uint32
}

func (ae *StagedAliasEntry) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 8)
        putu32(bin, ae.stagedID)
        putu32(bin[4:], ae.finalizedID)
        return bin, nil
}

func (ae *StagedAliasEntry) UnmarshalBinary(bin []byte) error {
        ae.stagedID = btou32(bin)
        ae.finalizedID = btou32(bin[4:])
        return nil
}

type StagedAlias struct {
        chunkHeader
        count   uint32
        entries []StagedAliasEntry
}

func (a *StagedAlias) UnmarshalBinary(bin []byte) error {
        if err := (&a.chunkHeader).UnmarshalBinary(bin); err != nil {
                return err
        }
        if a.typ != ResTableStagedAlias {
                return errWrongType(a.typ, ResTableStagedAlias)
        }
        a.count = btou32(bin[8:])
        a.entries = make([]StagedAliasEntry, a.count)
        for i := range a.entries {
                if err := a.entries[i].UnmarshalBinary(bin[12+i*8:]); err != nil {
                        return err
                }
        }
        return nil
}

func (a *StagedAlias) MarshalBinary() ([]byte, error) {
        chunkHeaderBin, err := a.chunkHeader.MarshalBinary()
        if err != nil {
                return nil, err
        }
        countBin := make([]byte, 4)
        putu32(countBin, a.count)
        bin := append(chunkHeaderBin, countBin...)
        for _, entry := range a.entries {
                entryBin, err := entry.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                bin = append(bin, entryBin...)
        }
        return bin, nil
}

// Entry is a resource key typically followed by a value or resource map.
type Entry struct {
        size  uint16
        flags uint16
        key   PoolRef // ref into key pool

        // only filled if this is a map entry; when size is 16
        parent TableRef // id of parent mapping or zero if none
        count  uint32   // name and value pairs that follow for FlagComplex

        values []*Value
}

func (nt *Entry) UnmarshalBinary(bin []byte) error {
        nt.size = btou16(bin)
        nt.flags = btou16(bin[2:])
        nt.key = PoolRef(btou32(bin[4:]))

        if nt.size == 16 {
                nt.parent = TableRef(btou32(bin[8:]))
                nt.count = btou32(bin[12:])
                nt.values = make([]*Value, nt.count)
                for i := range nt.values {
                        val := &Value{}
                        if err := val.UnmarshalBinary(bin[16+i*12:]); err != nil {
                                return err
                        }
                        nt.values[i] = val
                }
        } else {
                data := &Data{}
                if err := data.UnmarshalBinary(bin[8:]); err != nil {
                        return err
                }
                // TODO boxing data not strictly correct as binary repr isn't of Value.
                nt.values = append(nt.values, &Value{0, data})
        }

        return nil
}

func (nt *Entry) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 8)
        sz := nt.size
        if sz == 0 {
                sz = 8
        }
        putu16(bin, sz)
        putu16(bin[2:], nt.flags)
        putu32(bin[4:], uint32(nt.key))

        if sz == 16 {
                bin = append(bin, make([]byte, 8+len(nt.values)*12)...)
                putu32(bin[8:], uint32(nt.parent))
                putu32(bin[12:], uint32(len(nt.values)))
                for i, val := range nt.values {
                        b, err := val.MarshalBinary()
                        if err != nil {
                                return nil, err
                        }
                        copy(bin[16+i*12:], b)
                }
        } else {
                b, err := nt.values[0].data.MarshalBinary()
                if err != nil {
                        return nil, err
                }
                bin = append(bin, b...)
        }

        return bin, nil
}

type Value struct {
        name TableRef
        data *Data
}

func (val *Value) UnmarshalBinary(bin []byte) error {
        val.name = TableRef(btou32(bin))
        val.data = &Data{}
        return val.data.UnmarshalBinary(bin[4:])
}

func (val *Value) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 12)
        putu32(bin, uint32(val.name))
        b, err := val.data.MarshalBinary()
        if err != nil {
                return nil, err
        }
        copy(bin[4:], b)
        return bin, nil
}

type DataType uint8

// explicitly defined for clarity and resolvability with apt source
const (
        DataNull             DataType = 0x00 // either 0 or 1 for resource undefined or empty
        DataReference        DataType = 0x01 // ResTable_ref, a reference to another resource table entry
        DataAttribute        DataType = 0x02 // attribute resource identifier
        DataString           DataType = 0x03 // index into the containing resource table's global value string pool
        DataFloat            DataType = 0x04 // single-precision floating point number
        DataDimension        DataType = 0x05 // complex number encoding a dimension value, such as "100in"
        DataFraction         DataType = 0x06 // complex number encoding a fraction of a container
        DataDynamicReference DataType = 0x07 // dynamic ResTable_ref, which needs to be resolved before it can be used like a TYPE_REFERENCE.
        DataIntDec           DataType = 0x10 // raw integer value of the form n..n
        DataIntHex           DataType = 0x11 // raw integer value of the form 0xn..n
        DataIntBool          DataType = 0x12 // either 0 or 1, for input "false" or "true"
        DataIntColorARGB8    DataType = 0x1c // raw integer value of the form #aarrggbb
        DataIntColorRGB8     DataType = 0x1d // raw integer value of the form #rrggbb
        DataIntColorARGB4    DataType = 0x1e // raw integer value of the form #argb
        DataIntColorRGB4     DataType = 0x1f // raw integer value of the form #rgb
)

type Data struct {
        ByteSize uint16
        Res0     uint8 // always 0, useful for debugging bad read offsets
        Type     DataType
        Value    uint32
}

func (d *Data) UnmarshalBinary(bin []byte) error {
        d.ByteSize = btou16(bin)
        d.Res0 = uint8(bin[2])
        d.Type = DataType(bin[3])
        d.Value = btou32(bin[4:])
        return nil
}

func (d *Data) MarshalBinary() ([]byte, error) {
        bin := make([]byte, 8)
        putu16(bin, 8)
        bin[2] = byte(d.Res0)
        bin[3] = byte(d.Type)
        putu32(bin[4:], d.Value)
        return bin, nil
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package mobile provides functions for building Cogent Core apps for mobile devices.
package mobile

//go:generate go run gendex.go -o dex.go

import (
        "bufio"
        "errors"
        "fmt"
        "io"
        "regexp"
        "strconv"
        "strings"

        "slices"

        "log/slog"

        "maps"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/cmd/core/config"
        "golang.org/x/tools/go/packages"
)

var tmpDir string

// Build compiles and encodes the app named by the import path.
//
// The named package must define a main function.
//
// The -target flag takes either android (the default), or one or more
// comma-delimited Apple platforms (TODO: apple platforms list).
//
// For -target android, if an AndroidManifest.xml is defined in the
// package directory, it is added to the APK output. Otherwise, a default
// manifest is generated. By default, this builds a fat APK for all supported
// instruction sets (arm, 386, amd64, arm64). A subset of instruction sets can
// be selected by specifying target type with the architecture name. E.g.
// -target=android/arm,android/386.
//
// For Apple -target platforms, gomobile must be run on an OS X machine with
// Xcode installed.
//
// By default, -target ios will generate an XCFramework for both ios
// and iossimulator. Multiple Apple targets can be specified, creating a "fat"
// XCFramework with each slice. To generate a fat XCFramework that supports
// iOS, macOS, and macCatalyst for all supportec architectures (amd64 and arm64),
// specify -target ios,macos,maccatalyst. A subset of instruction sets can be
// selectged by specifying the platform with an architecture name. E.g.
// -target=ios/arm64,maccatalyst/arm64.
//
// If the package directory contains an assets subdirectory, its contents
// are copied into the output.
func Build(c *config.Config) error {
        _, err := buildImpl(c)
        return err
}

// buildImpl builds a package for mobiles based on the given config info.
// buildImpl returns a built package information and an error if exists.
func buildImpl(c *config.Config) (*packages.Package, error) {
        cleanup, err := buildEnvInit(c)
        if err != nil {
                return nil, err
        }
        defer cleanup()

        for _, platform := range c.Build.Target {
                if platform.Arch == "*" {
                        archs := config.ArchsForOS[platform.OS]
                        c.Build.Target = make([]config.Platform, len(archs))
                        for i, arch := range archs {
                                c.Build.Target[i] = config.Platform{OS: platform.OS, Arch: arch}
                        }
                }
        }

        // Special case to add iossimulator if we don't already have it and we have ios
        hasIOSSimulator := slices.ContainsFunc(c.Build.Target,
                func(p config.Platform) bool { return p.OS == "iossimulator" })
        hasIOS := slices.ContainsFunc(c.Build.Target,
                func(p config.Platform) bool { return p.OS == "ios" })
        if !hasIOSSimulator && hasIOS {
                c.Build.Target = append(c.Build.Target, config.Platform{OS: "iossimulator", Arch: "arm64"}) // TODO: set arch better here
        }

        // TODO(ydnar): this should work, unless build tags affect loading a single package.
        // Should we try to import packages with different build tags per platform?
        pkgs, err := packages.Load(packagesConfig(&c.Build.Target[0]), ".")
        if err != nil {
                return nil, err
        }

        // len(pkgs) can be more than 1 e.g., when the specified path includes `...`.
        if len(pkgs) != 1 {
                return nil, fmt.Errorf("expected 1 package but got %d", len(pkgs))
        }

        pkg := pkgs[0]

        if pkg.Name != "main" {
                return nil, errors.New("cannot build non-main package")
        }

        if c.ID == "" {
                return nil, errors.New("id must be set when building for mobile")
        }

        switch {
        case isAndroidPlatform(c.Build.Target[0].OS):
                if pkg.Name != "main" {
                        for _, t := range c.Build.Target {
                                if err := goBuild(c, pkg.PkgPath, androidEnv[t.Arch]); err != nil {
                                        return nil, err
                                }
                        }
                        return pkg, nil
                }
                _, err = goAndroidBuild(c, pkg, c.Build.Target)
                if err != nil {
                        return nil, err
                }
        case isApplePlatform(c.Build.Target[0].OS):
                if !xCodeAvailable() {
                        return nil, fmt.Errorf("-target=%s requires XCode", c.Build.Target)
                }
                if pkg.Name != "main" {
                        for _, t := range c.Build.Target {
                                // Catalyst support requires iOS 13+
                                v, _ := strconv.ParseFloat(c.Build.IOSVersion, 64)
                                if t.OS == "maccatalyst" && v < 13.0 {
                                        return nil, errors.New("catalyst requires -iosversion=13 or higher")
                                }
                                if err := goBuild(c, pkg.PkgPath, appleEnv[t.String()]); err != nil {
                                        return nil, err
                                }
                        }
                        return pkg, nil
                }
                _, err = goAppleBuild(c, pkg, c.Build.Target)
                if err != nil {
                        return nil, err
                }
        }

        return pkg, nil
}

var nmRE = regexp.MustCompile(`[0-9a-f]{8} t _?(?:.*/vendor/)?(golang.org/x.*/[^.]*)`)

func extractPkgs(nm string, path string) (map[string]bool, error) {
        r, w := io.Pipe()

        nmpkgs := make(map[string]bool)
        errc := make(chan error, 1)
        go func() {
                s := bufio.NewScanner(r)
                for s.Scan() {
                        if res := nmRE.FindStringSubmatch(s.Text()); res != nil {
                                nmpkgs[res[1]] = true
                        }
                }
                errc <- s.Err()
        }()

        err := exec.Major().SetStdout(w).Run(nm, path)
        w.Close()
        if err != nil {
                return nil, fmt.Errorf("%s %s: %v", nm, path, err)
        }
        if err := <-errc; err != nil {
                return nil, fmt.Errorf("%s %s: %v", nm, path, err)
        }
        return nmpkgs, nil
}

func goBuild(c *config.Config, src string, env map[string]string, args ...string) error {
        return goCmd(c, "build", []string{src}, env, args...)
}

func goCmd(c *config.Config, subcmd string, srcs []string, env map[string]string, args ...string) error {
        return goCmdAt(c, "", subcmd, srcs, env, args...)
}

func goCmdAt(c *config.Config, at string, subcmd string, srcs []string, env map[string]string, args ...string) error {
        cargs := []string{subcmd}
        // cmd := exec.Command("go", subcmd)
        var tags []string
        if c.Build.Debug {
                tags = append(tags, "debug")
        }
        if len(tags) > 0 {
                cargs = append(cargs, "-tags", strings.Join(tags, ","))
        }
        if logx.UserLevel <= slog.LevelInfo {
                cargs = append(cargs, "-v")
        }
        cargs = append(cargs, args...)
        cargs = append(cargs, srcs...)

        xc := exec.Major().SetDir(at)
        maps.Copy(xc.Env, env)

        // Specify GOMODCACHE explicitly. The default cache path is GOPATH[0]/pkg/mod,
        // but the path varies when GOPATH is specified at env, which results in cold cache.
        if gmc, err := goModCachePath(); err == nil {
                xc.SetEnv("GOMODCACHE", gmc)
        }
        return xc.Run("go", cargs...)
}

func goModCachePath() (string, error) {
        out, err := exec.Output("go", "env", "GOMODCACHE")
        if err != nil {
                return "", err
        }
        return strings.TrimSpace(string(out)), nil
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package mobile

import (
        "bytes"
        "crypto/x509"
        "encoding/base64"
        "encoding/pem"
        "encoding/xml"
        "errors"
        "fmt"
        "image/png"
        "io"
        "log"
        "os"
        "path/filepath"

        "cogentcore.org/core/base/elide"
        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/mobile/binres"
        "cogentcore.org/core/cmd/core/rendericon"
        "golang.org/x/tools/go/packages"
)

const (
        minAndroidSDK           = 23
        defaultAndroidTargetSDK = 29
)

// goAndroidBuild builds the given package for the given Android targets.
func goAndroidBuild(c *config.Config, pkg *packages.Package, targets []config.Platform) (map[string]bool, error) {
        ndkRoot, err := ndkRoot(c, targets...)
        if err != nil {
                return nil, err
        }
        libName := androidPkgName(c.Name)

        // TODO(hajimehoshi): This works only with Go tools that assume all source files are in one directory.
        // Fix this to work with other Go tools.
        dir := filepath.Dir(pkg.GoFiles[0])

        manifestPath := filepath.Join(dir, "AndroidManifest.xml")
        manifestData, err := os.ReadFile(manifestPath)
        if err != nil {
                if !os.IsNotExist(err) {
                        return nil, err
                }

                buf := new(bytes.Buffer)
                buf.WriteString(`<?xml version="1.0" encoding="utf-8"?>`)
                err := manifestTmpl.Execute(buf, manifestTmplData{
                        JavaPkgPath: c.ID,
                        Name:        elide.AppName(c.Name),
                        LibName:     libName,
                })
                if err != nil {
                        return nil, err
                }
                manifestData = buf.Bytes()
                logx.PrintfDebug("generated AndroidManifest.xml:\n%s\n", manifestData)
        } else {
                libName, err = manifestLibName(manifestData)
                if err != nil {
                        return nil, fmt.Errorf("error parsing %s: %v", manifestPath, err)
                }
        }

        libFiles := []string{}
        nmpkgs := make(map[string]map[string]bool) // map: arch -> extractPkgs' output

        for _, t := range targets {
                toolchain := ndk.toolchain(t.Arch)
                libPath := "lib/" + toolchain.ABI + "/lib" + libName + ".so"
                libAbsPath := filepath.Join(tmpDir, libPath)
                if err := exec.MkdirAll(filepath.Dir(libAbsPath), 0755); err != nil {
                        return nil, err
                }
                args := []string{
                        "-buildmode=c-shared",
                        "-ldflags", config.LinkerFlags(c),
                        "-o", libAbsPath,
                }
                if c.Build.Trimpath {
                        args = append(args, "-trimpath")
                }
                err = goBuild(
                        c,
                        pkg.PkgPath,
                        androidEnv[t.Arch],
                        args...,
                )
                if err != nil {
                        return nil, err
                }
                nmpkgs[t.Arch], err = extractPkgs(toolchain.path(c, ndkRoot, "nm"), libAbsPath)
                if err != nil {
                        return nil, err
                }
                libFiles = append(libFiles, libPath)
        }

        block, _ := pem.Decode([]byte(debugCert))
        if block == nil {
                return nil, errors.New("no debug cert")
        }
        privKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
        if err != nil {
                return nil, err
        }

        err = os.MkdirAll(c.Build.Output, 0777)
        if err != nil {
                return nil, err
        }
        var out io.Writer
        f, err := os.Create(filepath.Join(c.Build.Output, c.Name+".apk"))
        if err != nil {
                return nil, err
        }
        defer func() {
                if cerr := f.Close(); err == nil {
                        err = cerr
                }
        }()
        out = f

        apkw := newWriter(out, privKey)
        apkwCreate := func(name string) (io.Writer, error) {
                logx.PrintfInfo("apk: %s\n", name)
                return apkw.Create(name)
        }
        apkwWriteFile := func(dst, src string) error {
                w, err := apkwCreate(dst)
                if err != nil {
                        return err
                }
                f, err := os.Open(src)
                if err != nil {
                        return err
                }
                defer f.Close()
                if _, err := io.Copy(w, f); err != nil {
                        return err
                }
                return nil
        }

        // TODO: do we need this writer stuff?
        w, err := apkwCreate("classes.dex")
        if err != nil {
                return nil, err
        }
        dexData, err := base64.StdEncoding.DecodeString(dexStr)
        if err != nil {
                log.Fatalf("internal error: bad dexStr: %v", err)
        }
        if _, err := w.Write(dexData); err != nil {
                return nil, err
        }

        for _, libFile := range libFiles {
                if err := apkwWriteFile(libFile, filepath.Join(tmpDir, libFile)); err != nil {
                        return nil, err
                }
        }

        // TODO: what should we do about OpenAL?
        for _, t := range targets {
                toolchain := ndk.toolchain(t.Arch)
                if nmpkgs[t.Arch]["cogentcore.org/core/mobile/exp/audio/al"] {
                        dst := "lib/" + toolchain.ABI + "/libopenal.so"
                        src := filepath.Join(goMobilePath, dst)
                        if _, err := os.Stat(src); err != nil {
                                return nil, errors.New("the Android requires the golang.org/x/mobile/exp/audio/al, but the OpenAL libraries was not found. Please run gomobile init with the -openal flag pointing to an OpenAL source directory")
                        }
                        if err := apkwWriteFile(dst, src); err != nil {
                                return nil, err
                        }
                }
        }

        // Add the icon. 512 is the largest icon size on Android
        // (for the Google Play Store icon).
        ic, err := rendericon.Render(512)
        if err != nil {
                return nil, err
        }

        bxml, err := binres.UnmarshalXML(bytes.NewReader(manifestData), true, c.Build.AndroidMinSDK, c.Build.AndroidTargetSDK)
        if err != nil {
                return nil, err
        }

        // generate resources.arsc identifying single xxxhdpi icon resource.
        pkgname, err := bxml.RawValueByName("manifest", xml.Name{Local: "package"})
        if err != nil {
                return nil, err
        }
        tbl, name := binres.NewMipmapTable(pkgname)
        iw, err := apkwCreate(name)
        if err != nil {
                return nil, err
        }
        err = png.Encode(iw, ic)
        if err != nil {
                return nil, err
        }
        resw, err := apkwCreate("resources.arsc")
        if err != nil {
                return nil, err
        }
        rbin, err := tbl.MarshalBinary()
        if err != nil {
                return nil, err
        }
        if _, err := resw.Write(rbin); err != nil {
                return nil, err
        }

        w, err = apkwCreate("AndroidManifest.xml")
        if err != nil {
                return nil, err
        }
        bin, err := bxml.MarshalBinary()
        if err != nil {
                return nil, err
        }
        if _, err := w.Write(bin); err != nil {
                return nil, err
        }

        // TODO: add gdbserver to apk?

        if err := apkw.Close(); err != nil {
                return nil, err
        }

        // TODO: return nmpkgs
        return nmpkgs[targets[0].Arch], nil
}

// androidPkgName sanitizes the go package name to be acceptable as a android
// package name part. The android package name convention is similar to the
// java package name convention described in
// https://docs.oracle.com/javase/specs/jls/se8/html/jls-6.html#jls-6.5.3.1
// but not exactly same.
func androidPkgName(name string) string {
        var res []rune
        for _, r := range name {
                switch {
                case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z', '0' <= r && r <= '9':
                        res = append(res, r)
                default:
                        res = append(res, '_')
                }
        }
        if len(res) == 0 || res[0] == '_' || ('0' <= res[0] && res[0] <= '9') {
                // Android does not seem to allow the package part starting with _.
                res = append([]rune{'g', 'o'}, res...)
        }
        s := string(res)
        // Look for Java keywords that are not Go keywords, and avoid using
        // them as a package name.
        //
        // This is not a problem for normal Go identifiers as we only expose
        // exported symbols. The upper case first letter saves everything
        // from accidentally matching except for the package name.
        //
        // Note that basic type names (like int) are not keywords in Go.
        switch s {
        case "abstract", "assert", "boolean", "byte", "catch", "char", "class",
                "do", "double", "enum", "extends", "final", "finally", "float",
                "implements", "instanceof", "int", "long", "native", "private",
                "protected", "public", "short", "static", "strictfp", "super",
                "synchronized", "this", "throw", "throws", "transient", "try",
                "void", "volatile", "while":
                s += "_"
        }
        return s
}

// A random uninteresting private key.
// Must be consistent across builds so newer app versions can be installed.
const debugCert = `
-----BEGIN RSA PRIVATE KEY-----
MIIEowIBAAKCAQEAy6ItnWZJ8DpX9R5FdWbS9Kr1U8Z7mKgqNByGU7No99JUnmyu
NQ6Uy6Nj0Gz3o3c0BXESECblOC13WdzjsH1Pi7/L9QV8jXOXX8cvkG5SJAyj6hcO
LOapjDiN89NXjXtyv206JWYvRtpexyVrmHJgRAw3fiFI+m4g4Qop1CxcIF/EgYh7
rYrqh4wbCM1OGaCleQWaOCXxZGm+J5YNKQcWpjZRrDrb35IZmlT0bK46CXUKvCqK
x7YXHgfhC8ZsXCtsScKJVHs7gEsNxz7A0XoibFw6DoxtjKzUCktnT0w3wxdY7OTj
9AR8mobFlM9W3yirX8TtwekWhDNTYEu8dwwykwIDAQABAoIBAA2hjpIhvcNR9H9Z
BmdEecydAQ0ZlT5zy1dvrWI++UDVmIp+Ve8BSd6T0mOqV61elmHi3sWsBN4M1Rdz
3N38lW2SajG9q0fAvBpSOBHgAKmfGv3Ziz5gNmtHgeEXfZ3f7J95zVGhlHqWtY95
JsmuplkHxFMyITN6WcMWrhQg4A3enKLhJLlaGLJf9PeBrvVxHR1/txrfENd2iJBH
FmxVGILL09fIIktJvoScbzVOneeWXj5vJGzWVhB17DHBbANGvVPdD5f+k/s5aooh
hWAy/yLKocr294C4J+gkO5h2zjjjSGcmVHfrhlXQoEPX+iW1TGoF8BMtl4Llc+jw
lKWKfpECgYEA9C428Z6CvAn+KJ2yhbAtuRo41kkOVoiQPtlPeRYs91Pq4+NBlfKO
2nWLkyavVrLx4YQeCeaEU2Xoieo9msfLZGTVxgRlztylOUR+zz2FzDBYGicuUD3s
EqC0Wv7tiX6dumpWyOcVVLmR9aKlOUzA9xemzIsWUwL3PpyONhKSq7kCgYEA1X2F
f2jKjoOVzglhtuX4/SP9GxS4gRf9rOQ1Q8DzZhyH2LZ6Dnb1uEQvGhiqJTU8CXxb
7odI0fgyNXq425Nlxc1Tu0G38TtJhwrx7HWHuFcbI/QpRtDYLWil8Zr7Q3BT9rdh
moo4m937hLMvqOG9pyIbyjOEPK2WBCtKW5yabqsCgYEAu9DkUBr1Qf+Jr+IEU9I8
iRkDSMeusJ6gHMd32pJVCfRRQvIlG1oTyTMKpafmzBAd/rFpjYHynFdRcutqcShm
aJUq3QG68U9EAvWNeIhA5tr0mUEz3WKTt4xGzYsyWES8u4tZr3QXMzD9dOuinJ1N
+4EEumXtSPKKDG3M8Qh+KnkCgYBUEVSTYmF5EynXc2xOCGsuy5AsrNEmzJqxDUBI
SN/P0uZPmTOhJIkIIZlmrlW5xye4GIde+1jajeC/nG7U0EsgRAV31J4pWQ5QJigz
0+g419wxIUFryGuIHhBSfpP472+w1G+T2mAGSLh1fdYDq7jx6oWE7xpghn5vb9id
EKLjdwKBgBtz9mzbzutIfAW0Y8F23T60nKvQ0gibE92rnUbjPnw8HjL3AZLU05N+
cSL5bhq0N5XHK77sscxW9vXjG0LJMXmFZPp9F6aV6ejkMIXyJ/Yz/EqeaJFwilTq
Mc6xR47qkdzu0dQ1aPm4XD7AWDtIvPo/GG2DKOucLBbQc2cOWtKS
-----END RSA PRIVATE KEY-----
`

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package mobile

import (
        "bytes"
        "crypto/x509"
        "encoding/pem"
        "errors"
        "fmt"
        "os"
        "path/filepath"
        "text/template"

        "cogentcore.org/core/base/elide"
        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/rendericon"
        "github.com/jackmordaunt/icns/v2"
        "golang.org/x/tools/go/packages"
)

// goAppleBuild builds the given package with the given bundle ID for the given iOS targets.
func goAppleBuild(c *config.Config, pkg *packages.Package, targets []config.Platform) (map[string]bool, error) {
        src := pkg.PkgPath
        infoplist := new(bytes.Buffer)
        if err := infoPlistTmpl.Execute(infoplist, infoPlistTmplData{
                BundleID:           c.ID,
                Name:               elide.AppName(c.Name),
                Version:            c.Version,
                InfoString:         c.About,
                ShortVersionString: c.Version,
                IconFile:           "icon.icns",
        }); err != nil {
                return nil, err
        }

        // Detect the team ID
        teamID, err := detectTeamID()
        if err != nil {
                return nil, err
        }

        projPbxproj := new(bytes.Buffer)
        if err := projPbxprojTmpl.Execute(projPbxproj, projPbxprojTmplData{
                TeamID: teamID,
        }); err != nil {
                return nil, err
        }

        files := []struct {
                name     string
                contents []byte
        }{
                {tmpDir + "/main.xcodeproj/project.pbxproj", projPbxproj.Bytes()},
                {tmpDir + "/main/Info.plist", infoplist.Bytes()},
                {tmpDir + "/main/Images.xcassets/AppIcon.appiconset/Contents.json", []byte(contentsJSON)},
        }

        for _, file := range files {
                if err := exec.MkdirAll(filepath.Dir(file.name), 0755); err != nil {
                        return nil, err
                }
                exec.PrintCmd(fmt.Sprintf("echo \"%s\" > %s", file.contents, file.name), nil)
                if err := os.WriteFile(file.name, file.contents, 0644); err != nil {
                        return nil, err
                }
        }

        // We are using lipo tool to build multiarchitecture binaries.
        args := []string{"lipo", "-o", filepath.Join(tmpDir, "main/main"), "-create"}

        var nmpkgs map[string]bool
        builtArch := map[string]bool{}
        for _, t := range targets {
                // Only one binary per arch allowed
                // e.g. ios/arm64 + iossimulator/amd64
                if builtArch[t.Arch] {
                        continue
                }
                builtArch[t.Arch] = true

                path := filepath.Join(tmpDir, t.OS, t.Arch)

                buildArgs := []string{
                        "-ldflags", config.LinkerFlags(c), "-o=" + path,
                }
                if c.Build.Trimpath {
                        buildArgs = append(buildArgs, "-trimpath")
                }
                if err := goBuild(c, src, appleEnv[t.String()], buildArgs...); err != nil {
                        return nil, err
                }
                if nmpkgs == nil {
                        var err error
                        nmpkgs, err = extractPkgs(appleNM, path)
                        if err != nil {
                                return nil, err
                        }
                }
                args = append(args, path)

        }

        if err := exec.Run("xcrun", args...); err != nil {
                return nil, err
        }

        if err := appleCopyAssets(tmpDir); err != nil {
                return nil, err
        }

        // Build and move the release build to the output directory.
        err = exec.Run("xcrun", "xcodebuild",
                "-configuration", "Release",
                "-project", tmpDir+"/main.xcodeproj",
                "-allowProvisioningUpdates",
                "DEVELOPMENT_TEAM="+teamID)
        if err != nil {
                return nil, err
        }

        inm := filepath.Join(tmpDir+"/build/Release-iphoneos/main.app", "icon.icns")
        fdsi, err := os.Create(inm)
        if err != nil {
                return nil, err
        }
        defer fdsi.Close()
        // 1024x1024 is the largest icon size on iOS
        // (for the App Store)
        sic, err := rendericon.Render(1024)
        if err != nil {
                return nil, err
        }
        err = icns.Encode(fdsi, sic)
        if err != nil {
                return nil, err
        }

        // TODO(jbd): Fallback to copying if renaming fails.
        err = os.MkdirAll(c.Build.Output, 0777)
        if err != nil {
                return nil, err
        }
        output := filepath.Join(c.Build.Output, c.Name+".app")
        exec.PrintCmd(fmt.Sprintf("mv %s %s", tmpDir+"/build/Release-iphoneos/main.app", output), nil)
        // if output already exists, remove.
        if err := exec.RemoveAll(output); err != nil {
                return nil, err
        }
        if err := os.Rename(tmpDir+"/build/Release-iphoneos/main.app", output); err != nil {
                return nil, err
        }

        return nmpkgs, nil
}

// detectTeamID determines the Apple Development Team ID on the system.
func detectTeamID() (string, error) {
        // Grabs the first certificate for "Apple Development"; will not work if there
        // are multiple certificates and the first is not desired.
        pemString, err := exec.Output(
                "security", "find-certificate",
                "-c", "Apple Development", "-p",
        )
        if err != nil {
                err = fmt.Errorf("failed to pull the signing certificate to determine your team ID: %v", err)
                return "", err
        }

        block, _ := pem.Decode([]byte(pemString))
        if block == nil {
                err = fmt.Errorf("failed to decode the PEM to determine your team ID: %s", pemString)
                return "", err
        }

        cert, err := x509.ParseCertificate(block.Bytes)
        if err != nil {
                err = fmt.Errorf("failed to parse your signing certificate to determine your team ID: %v", err)
                return "", err
        }

        if len(cert.Subject.OrganizationalUnit) == 0 {
                err = errors.New("the signing certificate has no organizational unit (team ID)")
                return "", err
        }

        return cert.Subject.OrganizationalUnit[0], nil
}

func appleCopyAssets(xcodeProjDir string) error {
        dstAssets := xcodeProjDir + "/main/assets"
        return exec.MkdirAll(dstAssets, 0755)
}

type infoPlistTmplData struct {
        BundleID           string
        Name               string
        Version            string
        InfoString         string
        ShortVersionString string
        IconFile           string
}

var infoPlistTmpl = template.Must(template.New("infoPlist").Parse(`<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
        <key>CFBundleDevelopmentRegion</key>
        <string>en</string>
        <key>CFBundleExecutable</key>
        <string>main</string>
        <key>CFBundleIdentifier</key>
        <string>{{.BundleID}}</string>
        <key>CFBundleInfoDictionaryVersion</key>
        <string>6.0</string>
        <key>CFBundleName</key>
        <string>{{.Name}}</string>
        <key>CFBundlePackageType</key>
        <string>APPL</string>
        <key>CFBundleSignature</key>
        <string>????</string>
        <key>CFBundleVersion</key>
        <string>{{ .Version }}</string>
        <key>CFBundleGetInfoString</key>
        <string>{{ .InfoString }}</string>
        <key>CFBundleShortVersionString</key>
        <string>{{ .ShortVersionString }}</string>
        <key>CFBundleIconFile</key>
        <string>{{ .IconFile }}</string>
        <key>LSRequiresIPhoneOS</key>
        <true/>
        <key>UILaunchStoryboardName</key>
        <string>LaunchScreen</string>
        <key>UIRequiredDeviceCapabilities</key>
        <array>
                <string>armv7</string>
        </array>
        <key>UISupportedInterfaceOrientations</key>
        <array>
                <string>UIInterfaceOrientationPortrait</string>
                <string>UIInterfaceOrientationLandscapeLeft</string>
                <string>UIInterfaceOrientationLandscapeRight</string>
        </array>
        <key>UISupportedInterfaceOrientations~ipad</key>
        <array>
                <string>UIInterfaceOrientationPortrait</string>
                <string>UIInterfaceOrientationPortraitUpsideDown</string>
                <string>UIInterfaceOrientationLandscapeLeft</string>
                <string>UIInterfaceOrientationLandscapeRight</string>
        </array>
</dict>
</plist>
`))

type projPbxprojTmplData struct {
        TeamID string
}

var projPbxprojTmpl = template.Must(template.New("projPbxproj").Parse(`// !$*UTF8*$!
{
        archiveVersion = 1;
        classes = {
        };
        objectVersion = 46;
        objects = {

/* Begin PBXBuildFile section */
                254BB84F1B1FD08900C56DE9 /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 254BB84E1B1FD08900C56DE9 /* Images.xcassets */; };
                254BB8681B1FD16500C56DE9 /* main in Resources */ = {isa = PBXBuildFile; fileRef = 254BB8671B1FD16500C56DE9 /* main */; };
                25FB30331B30FDEE0005924C /* assets in Resources */ = {isa = PBXBuildFile; fileRef = 25FB30321B30FDEE0005924C /* assets */; };
/* End PBXBuildFile section */

/* Begin PBXFileReference section */
                254BB83E1B1FD08900C56DE9 /* main.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = main.app; sourceTree = BUILT_PRODUCTS_DIR; };
                254BB8421B1FD08900C56DE9 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
                254BB84E1B1FD08900C56DE9 /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Images.xcassets; sourceTree = "<group>"; };
                254BB8671B1FD16500C56DE9 /* main */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.executable"; path = main; sourceTree = "<group>"; };
                25FB30321B30FDEE0005924C /* assets */ = {isa = PBXFileReference; lastKnownFileType = folder; name = assets; path = main/assets; sourceTree = "<group>"; };
/* End PBXFileReference section */

/* Begin PBXGroup section */
                254BB8351B1FD08900C56DE9 = {
                        isa = PBXGroup;
                        children = (
                                25FB30321B30FDEE0005924C /* assets */,
                                254BB8401B1FD08900C56DE9 /* main */,
                                254BB83F1B1FD08900C56DE9 /* Products */,
                        );
                        sourceTree = "<group>";
                        usesTabs = 0;
                };
                254BB83F1B1FD08900C56DE9 /* Products */ = {
                        isa = PBXGroup;
                        children = (
                                254BB83E1B1FD08900C56DE9 /* main.app */,
                        );
                        name = Products;
                        sourceTree = "<group>";
                };
                254BB8401B1FD08900C56DE9 /* main */ = {
                        isa = PBXGroup;
                        children = (
                                254BB8671B1FD16500C56DE9 /* main */,
                                254BB84E1B1FD08900C56DE9 /* Images.xcassets */,
                                254BB8411B1FD08900C56DE9 /* Supporting Files */,
                        );
                        path = main;
                        sourceTree = "<group>";
                };
                254BB8411B1FD08900C56DE9 /* Supporting Files */ = {
                        isa = PBXGroup;
                        children = (
                                254BB8421B1FD08900C56DE9 /* Info.plist */,
                        );
                        name = "Supporting Files";
                        sourceTree = "<group>";
                };
/* End PBXGroup section */

/* Begin PBXNativeTarget section */
                254BB83D1B1FD08900C56DE9 /* main */ = {
                        isa = PBXNativeTarget;
                        buildConfigurationList = 254BB8611B1FD08900C56DE9 /* Build configuration list for PBXNativeTarget "main" */;
                        buildPhases = (
                                254BB83C1B1FD08900C56DE9 /* Resources */,
                        );
                        buildRules = (
                        );
                        dependencies = (
                        );
                        name = main;
                        productName = main;
                        productReference = 254BB83E1B1FD08900C56DE9 /* main.app */;
                        productType = "com.apple.product-type.application";
                };
/* End PBXNativeTarget section */

/* Begin PBXProject section */
                254BB8361B1FD08900C56DE9 /* Project object */ = {
                        isa = PBXProject;
                        attributes = {
                                LastUpgradeCheck = 0630;
                                ORGANIZATIONNAME = Developer;
                                TargetAttributes = {
                                        254BB83D1B1FD08900C56DE9 = {
                                                CreatedOnToolsVersion = 6.3.1;
                                                DevelopmentTeam = {{.TeamID}};
                                        };
                                };
                        };
                        buildConfigurationList = 254BB8391B1FD08900C56DE9 /* Build configuration list for PBXProject "main" */;
                        compatibilityVersion = "Xcode 3.2";
                        developmentRegion = English;
                        hasScannedForEncodings = 0;
                        knownRegions = (
                                en,
                                Base,
                        );
                        mainGroup = 254BB8351B1FD08900C56DE9;
                        productRefGroup = 254BB83F1B1FD08900C56DE9 /* Products */;
                        projectDirPath = "";
                        projectRoot = "";
                        targets = (
                                254BB83D1B1FD08900C56DE9 /* main */,
                        );
                };
/* End PBXProject section */

/* Begin PBXResourcesBuildPhase section */
                254BB83C1B1FD08900C56DE9 /* Resources */ = {
                        isa = PBXResourcesBuildPhase;
                        buildActionMask = 2147483647;
                        files = (
                                25FB30331B30FDEE0005924C /* assets in Resources */,
                                254BB8681B1FD16500C56DE9 /* main in Resources */,
                                254BB84F1B1FD08900C56DE9 /* Images.xcassets in Resources */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
/* End PBXResourcesBuildPhase section */

/* Begin XCBuildConfiguration section */
                254BB8601B1FD08900C56DE9 /* Release */ = {
                        isa = XCBuildConfiguration;
                        buildSettings = {
                                ALWAYS_SEARCH_USER_PATHS = NO;
                                CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
                                CLANG_CXX_LIBRARY = "libc++";
                                CLANG_ENABLE_MODULES = YES;
                                CLANG_ENABLE_OBJC_ARC = YES;
                                CLANG_WARN_BOOL_CONVERSION = YES;
                                CLANG_WARN_CONSTANT_CONVERSION = YES;
                                CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
                                CLANG_WARN_EMPTY_BODY = YES;
                                CLANG_WARN_ENUM_CONVERSION = YES;
                                CLANG_WARN_INT_CONVERSION = YES;
                                CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
                                CLANG_WARN_UNREACHABLE_CODE = YES;
                                CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
                                "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "Apple Development";
                                COPY_PHASE_STRIP = NO;
                                DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
                                ENABLE_NS_ASSERTIONS = NO;
                                ENABLE_STRICT_OBJC_MSGSEND = YES;
                                GCC_C_LANGUAGE_STANDARD = gnu99;
                                GCC_NO_COMMON_BLOCKS = YES;
                                GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
                                GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
                                GCC_WARN_UNDECLARED_SELECTOR = YES;
                                GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
                                GCC_WARN_UNUSED_FUNCTION = YES;
                                GCC_WARN_UNUSED_VARIABLE = YES;
                                MTL_ENABLE_DEBUG_INFO = NO;
                                SDKROOT = iphoneos;
                                TARGETED_DEVICE_FAMILY = "1,2";
                                VALIDATE_PRODUCT = YES;
                                ENABLE_BITCODE = NO;
                                IPHONEOS_DEPLOYMENT_TARGET = 15.0;
                        };
                        name = Release;
                };
                254BB8631B1FD08900C56DE9 /* Release */ = {
                        isa = XCBuildConfiguration;
                        buildSettings = {
                                ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
                                INFOPLIST_FILE = main/Info.plist;
                                LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
                                PRODUCT_NAME = "$(TARGET_NAME)";
                        };
                        name = Release;
                };
/* End XCBuildConfiguration section */

/* Begin XCConfigurationList section */
                254BB8391B1FD08900C56DE9 /* Build configuration list for PBXProject "main" */ = {
                        isa = XCConfigurationList;
                        buildConfigurations = (
                                254BB8601B1FD08900C56DE9 /* Release */,
                        );
                        defaultConfigurationIsVisible = 0;
                        defaultConfigurationName = Release;
                };
                254BB8611B1FD08900C56DE9 /* Build configuration list for PBXNativeTarget "main" */ = {
                        isa = XCConfigurationList;
                        buildConfigurations = (
                                254BB8631B1FD08900C56DE9 /* Release */,
                        );
                        defaultConfigurationIsVisible = 0;
                        defaultConfigurationName = Release;
                };
/* End XCConfigurationList section */
        };
        rootObject = 254BB8361B1FD08900C56DE9 /* Project object */;
}
`))

const contentsJSON = `{
        "images" : [
                {
                        "idiom" : "iphone",
                        "size" : "29x29",
                        "scale" : "2x"
                },
                {
                        "idiom" : "iphone",
                        "size" : "29x29",
                        "scale" : "3x"
                },
                {
                        "idiom" : "iphone",
                        "size" : "40x40",
                        "scale" : "2x"
                },
                {
                        "idiom" : "iphone",
                        "size" : "40x40",
                        "scale" : "3x"
                },
                {
                        "idiom" : "iphone",
                        "size" : "60x60",
                        "scale" : "2x"
                },
                {
                        "idiom" : "iphone",
                        "size" : "60x60",
                        "scale" : "3x"
                },
                {
                        "idiom" : "ipad",
                        "size" : "29x29",
                        "scale" : "1x"
                },
                {
                        "idiom" : "ipad",
                        "size" : "29x29",
                        "scale" : "2x"
                },
                {
                        "idiom" : "ipad",
                        "size" : "40x40",
                        "scale" : "1x"
                },
                {
                        "idiom" : "ipad",
                        "size" : "40x40",
                        "scale" : "2x"
                },
                {
                        "idiom" : "ipad",
                        "size" : "76x76",
                        "scale" : "1x"
                },
                {
                        "idiom" : "ipad",
                        "size" : "76x76",
                        "scale" : "2x"
                }
        ],
        "info" : {
                "version" : 1,
                "author" : "xcode"
        }
}
`

// rfc1034Label sanitizes the name to be usable in a uniform type identifier.
// The sanitization is similar to xcode's rfc1034identifier macro that
// replaces illegal characters (not conforming the rfc1034 label rule) with '-'.
func rfc1034Label(name string) string {
        // * Uniform type identifier:
        //
        // According to
        // https://developer.apple.com/library/ios/documentation/FileManagement/Conceptual/understanding_utis/understand_utis_conc/understand_utis_conc.html
        //
        // A uniform type identifier is a Unicode string that usually contains characters
        // in the ASCII character set. However, only a subset of the ASCII characters are
        // permitted. You may use the Roman alphabet in upper and lower case (A–Z, a–z),
        // the digits 0 through 9, the dot (“.”), and the hyphen (“-”). This restriction
        // is based on DNS name restrictions, set forth in RFC 1035.
        //
        // Uniform type identifiers may also contain any of the Unicode characters greater
        // than U+007F.
        //
        // Note: the actual implementation of xcode does not allow some unicode characters
        // greater than U+007f. In this implementation, we just replace everything non
        // alphanumeric with "-" like the rfc1034identifier macro.
        //
        // * RFC1034 Label
        //
        // <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
        // <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
        // <let-dig-hyp> ::= <let-dig> | "-"
        // <let-dig> ::= <letter> | <digit>
        const surrSelf = 0x10000
        begin := false

        var res []rune
        for i, r := range name {
                if r == '.' && !begin {
                        continue
                }
                begin = true

                switch {
                case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z':
                        res = append(res, r)
                case '0' <= r && r <= '9':
                        if i == 0 {
                                res = append(res, '-')
                        } else {
                                res = append(res, r)
                        }
                default:
                        if r < surrSelf {
                                res = append(res, '-')
                        } else {
                                res = append(res, '-', '-')
                        }
                }
        }
        return string(res)
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package mobile

import (
        "crypto"
        "crypto/rsa"
        "crypto/sha1"
        "crypto/x509"
        "crypto/x509/pkix"
        "encoding/asn1"
        "io"
        "math/big"
        "time"
)

// signPKCS7 does the minimal amount of work necessary to embed an RSA
// signature into a PKCS#7 certificate.
//
// We prepare the certificate using the x509 package, read it back in
// to our custom data type and then write it back out with the signature.
func signPKCS7(rand io.Reader, priv *rsa.PrivateKey, msg []byte) ([]byte, error) {
        const serialNumber = 0x5462c4dd // arbitrary
        name := pkix.Name{CommonName: "gomobile"}

        template := &x509.Certificate{
                SerialNumber:       big.NewInt(serialNumber),
                SignatureAlgorithm: x509.SHA1WithRSA,
                Subject:            name,
        }

        b, err := x509.CreateCertificate(rand, template, template, priv.Public(), priv)
        if err != nil {
                return nil, err
        }

        c := certificate{}
        if _, err := asn1.Unmarshal(b, &c); err != nil {
                return nil, err
        }

        h := sha1.New()
        h.Write(msg)
        hashed := h.Sum(nil)

        signed, err := rsa.SignPKCS1v15(rand, priv, crypto.SHA1, hashed)
        if err != nil {
                return nil, err
        }

        content := pkcs7SignedData{
                ContentType: oidSignedData,
                Content: signedData{
                        Version: 1,
                        DigestAlgorithms: []pkix.AlgorithmIdentifier{{
                                Algorithm:  oidSHA1,
                                Parameters: asn1.RawValue{Tag: 5},
                        }},
                        ContentInfo:  contentInfo{Type: oidData},
                        Certificates: c,
                        SignerInfos: []signerInfo{{
                                Version: 1,
                                IssuerAndSerialNumber: issuerAndSerialNumber{
                                        Issuer:       name.ToRDNSequence(),
                                        SerialNumber: serialNumber,
                                },
                                DigestAlgorithm: pkix.AlgorithmIdentifier{
                                        Algorithm:  oidSHA1,
                                        Parameters: asn1.RawValue{Tag: 5},
                                },
                                DigestEncryptionAlgorithm: pkix.AlgorithmIdentifier{
                                        Algorithm:  oidRSAEncryption,
                                        Parameters: asn1.RawValue{Tag: 5},
                                },
                                EncryptedDigest: signed,
                        }},
                },
        }

        return asn1.Marshal(content)
}

type pkcs7SignedData struct {
        ContentType asn1.ObjectIdentifier
        Content     signedData `asn1:"tag:0,explicit"`
}

// signedData is defined in rfc2315, section 9.1.
type signedData struct {
        Version          int
        DigestAlgorithms []pkix.AlgorithmIdentifier `asn1:"set"`
        ContentInfo      contentInfo
        Certificates     certificate  `asn1:"tag0,explicit"`
        SignerInfos      []signerInfo `asn1:"set"`
}

type contentInfo struct {
        Type asn1.ObjectIdentifier
        // Content is optional in PKCS#7 and not provided here.
}

// certificate is defined in rfc2459, section 4.1.
type certificate struct {
        TBSCertificate     tbsCertificate
        SignatureAlgorithm pkix.AlgorithmIdentifier
        SignatureValue     asn1.BitString
}

// tbsCertificate is defined in rfc2459, section 4.1.
type tbsCertificate struct {
        Version      int `asn1:"tag:0,default:2,explicit"`
        SerialNumber int
        Signature    pkix.AlgorithmIdentifier
        Issuer       pkix.RDNSequence // pkix.Name
        Validity     validity
        Subject      pkix.RDNSequence // pkix.Name
        SubjectPKI   subjectPublicKeyInfo
}

// validity is defined in rfc2459, section 4.1.
type validity struct {
        NotBefore time.Time
        NotAfter  time.Time
}

// subjectPublicKeyInfo is defined in rfc2459, section 4.1.
type subjectPublicKeyInfo struct {
        Algorithm        pkix.AlgorithmIdentifier
        SubjectPublicKey asn1.BitString
}

type signerInfo struct {
        Version                   int
        IssuerAndSerialNumber     issuerAndSerialNumber
        DigestAlgorithm           pkix.AlgorithmIdentifier
        DigestEncryptionAlgorithm pkix.AlgorithmIdentifier
        EncryptedDigest           []byte
}

type issuerAndSerialNumber struct {
        Issuer       pkix.RDNSequence // pkix.Name
        SerialNumber int
}

// Various ASN.1 Object Identifies, mostly from rfc3852.
var (
        // oidPKCS7         = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 7}
        oidData          = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 7, 1}
        oidSignedData    = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 7, 2}
        oidSHA1          = asn1.ObjectIdentifier{1, 3, 14, 3, 2, 26}
        oidRSAEncryption = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1}
)

package mobile

import (
        "bufio"
        "encoding/json"
        "errors"
        "fmt"
        "io/fs"
        "os"
        "path/filepath"
        "runtime"
        "strings"

        "slices"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/mobile/sdkpath"
)

// General mobile build environment. Initialized by envInit.
var (
        goMobilePath string                       // $GOPATH/pkg/gomobile
        androidEnv   map[string]map[string]string // android arch -> map[string]string
        appleEnv     map[string]map[string]string // platform/arch -> map[string]string
        appleNM      string
)

func isAndroidPlatform(platform string) bool {
        return platform == "android"
}

func isApplePlatform(platform string) bool {
        return slices.Contains(applePlatforms, platform)
}

var applePlatforms = []string{"ios", "iossimulator", "macos", "maccatalyst"}

func platformArchs(platform string) []string {
        switch platform {
        case "ios":
                return []string{"arm64"}
        case "iossimulator":
                return []string{"arm64", "amd64"}
        case "macos", "maccatalyst":
                return []string{"arm64", "amd64"}
        case "android":
                return []string{"arm", "arm64", "386", "amd64"}
        default:
                panic(fmt.Sprintf("unexpected platform: %s", platform))
        }
}

// platformOS returns the correct GOOS value for platform.
func platformOS(platform string) string {
        switch platform {
        case "android":
                return "android"
        case "ios", "iossimulator":
                return "ios"
        case "macos", "maccatalyst":
                // For "maccatalyst", Go packages should be built with GOOS=darwin,
                // not GOOS=ios, since the underlying OS (and kernel, runtime) is macOS.
                // We also apply a "macos" or "maccatalyst" build tag, respectively.
                // See below for additional context.
                return "darwin"
        default:
                panic(fmt.Sprintf("unexpected platform: %s", platform))
        }
}

func platformTags(platform string) []string {
        switch platform {
        case "android":
                return []string{"android"}
        case "ios", "iossimulator":
                return []string{"ios"}
        case "macos":
                return []string{"macos"}
        case "maccatalyst":
                // Mac Catalyst is a subset of iOS APIs made available on macOS
                // designed to ease porting apps developed for iPad to macOS.
                // See https://developer.apple.com/mac-catalyst/.
                // Because of this, when building a Go package targeting maccatalyst,
                // GOOS=darwin (not ios). To bridge the gap and enable maccatalyst
                // packages to be compiled, we also specify the "ios" build tag.
                // To help discriminate between darwin, ios, macos, and maccatalyst
                // targets, there is also a "maccatalyst" tag.
                // Some additional context on this can be found here:
                // https://stackoverflow.com/questions/12132933/preprocessor-macro-for-os-x-targets/49560690#49560690
                // TODO(ydnar): remove tag "ios" when cgo supports Catalyst
                // See golang.org/issues/47228
                return []string{"ios", "macos", "maccatalyst"}
        default:
                panic(fmt.Sprintf("unexpected platform: %s", platform))
        }
}

func buildEnvInit(c *config.Config) (cleanup func(), err error) {
        // Find gomobilepath.
        gopath := goEnv("GOPATH")
        for _, p := range filepath.SplitList(gopath) {
                goMobilePath = filepath.Join(p, "pkg", "gomobile")
                if _, err := os.Stat(goMobilePath); err == nil {
                        break
                }
        }

        logx.PrintlnInfo("GOMOBILE=" + goMobilePath)

        // Check the toolchain is in a good state.
        // Pick a temporary directory for assembling an apk/app.
        if goMobilePath == "" {
                return nil, errors.New("toolchain not installed, run `gomobile init`")
        }

        cleanupFn := func() {
                exec.RemoveAll(tmpDir)
        }
        tmpDir, err = os.MkdirTemp("", "gomobile-work-")
        if err != nil {
                return nil, err
        }
        logx.PrintlnInfo("WORK=" + tmpDir)

        if err := envInit(c); err != nil {
                return nil, err
        }

        return cleanupFn, nil
}

func envInit(c *config.Config) (err error) {
        // Setup the cross-compiler environments.
        if ndkRoot, err := ndkRoot(c); err == nil {
                androidEnv = make(map[string]map[string]string)
                if c.Build.AndroidMinSDK < minAndroidSDK {
                        return fmt.Errorf("gomobile requires Android API level >= %d", minAndroidSDK)
                }
                for arch, toolchain := range ndk {
                        clang := toolchain.path(c, ndkRoot, "clang")
                        clangpp := toolchain.path(c, ndkRoot, "clang++")
                        tools := []string{clang, clangpp}
                        if runtime.GOOS == "windows" {
                                // Because of https://github.com/android-ndk/ndk/issues/920,
                                // we require r19c, not just r19b. Fortunately, the clang++.cmd
                                // script only exists in r19c.
                                tools = append(tools, clangpp+".cmd")
                        }
                        for _, tool := range tools {
                                _, err = os.Stat(tool)
                                if err != nil {
                                        return fmt.Errorf("no compiler for %s was found in the NDK (tried %s). Make sure your NDK version is >= r19c. Use `sdkmanager --update` to update it", arch, tool)
                                }
                        }
                        androidEnv[arch] = map[string]string{
                                "GOOS":        "android",
                                "GOARCH":      arch,
                                "CC":          clang,
                                "CXX":         clangpp,
                                "CGO_ENABLED": "1",
                        }
                        if arch == "arm" {
                                androidEnv[arch]["GOARM"] = "7"
                        }
                }
        }

        if !xCodeAvailable() {
                return nil
        }

        appleNM = "nm"
        appleEnv = make(map[string]map[string]string)
        for _, platform := range applePlatforms {
                for _, arch := range platformArchs(platform) {
                        var goos, sdk, clang, cflags string
                        var err error
                        switch platform {
                        case "ios":
                                goos = "ios"
                                sdk = "iphoneos"
                                clang, cflags, err = envClang(sdk)
                                cflags += " -mios-version-min=" + c.Build.IOSVersion
                        case "iossimulator":
                                goos = "ios"
                                sdk = "iphonesimulator"
                                clang, cflags, err = envClang(sdk)
                                cflags += " -mios-simulator-version-min=" + c.Build.IOSVersion
                        case "maccatalyst":
                                // Mac Catalyst is a subset of iOS APIs made available on macOS
                                // designed to ease porting apps developed for iPad to macOS.
                                // See https://developer.apple.com/mac-catalyst/.
                                // Because of this, when building a Go package targeting maccatalyst,
                                // GOOS=darwin (not ios). To bridge the gap and enable maccatalyst
                                // packages to be compiled, we also specify the "ios" build tag.
                                // To help discriminate between darwin, ios, macos, and maccatalyst
                                // targets, there is also a "maccatalyst" tag.
                                // Some additional context on this can be found here:
                                // https://stackoverflow.com/questions/12132933/preprocessor-macro-for-os-x-targets/49560690#49560690
                                goos = "darwin"
                                sdk = "macosx"
                                clang, cflags, err = envClang(sdk)
                                // TODO(ydnar): the following 3 lines MAY be needed to compile
                                // packages or apps for maccatalyst. Commenting them out now in case
                                // it turns out they are necessary. Currently none of the example
                                // apps will build for macos or maccatalyst because they have a
                                // GLKit dependency, which is deprecated on all Apple platforms, and
                                // broken on maccatalyst (GLKView isn’t available).
                                // sysroot := strings.SplitN(cflags, " ", 2)[1]
                                // cflags += " -isystem " + sysroot + "/System/iOSSupport/usr/include"
                                // cflags += " -iframework " + sysroot + "/System/iOSSupport/System/Library/Frameworks"
                                switch arch {
                                case "amd64":
                                        cflags += " -target x86_64-apple-ios" + c.Build.IOSVersion + "-macabi"
                                case "arm64":
                                        cflags += " -target arm64-apple-ios" + c.Build.IOSVersion + "-macabi"
                                }
                        case "macos":
                                goos = "darwin"
                                sdk = "macosx" // Note: the SDK is called "macosx", not "macos"
                                clang, cflags, err = envClang(sdk)
                        default:
                                panic(fmt.Errorf("unknown Apple target: %s/%s", platform, arch))
                        }

                        if err != nil {
                                return err
                        }

                        appleEnv[platform+"/"+arch] = map[string]string{
                                "GOOS":         goos,
                                "GOARCH":       arch,
                                "GOFLAGS":      "-tags=" + strings.Join(platformTags(platform), ","),
                                "CC":           clang,
                                "CXX":          clang + "++",
                                "CGO_CFLAGS":   cflags + " -arch " + archClang(arch),
                                "CGO_CXXFLAGS": cflags + " -arch " + archClang(arch),
                                "CGO_LDFLAGS":  cflags + " -arch " + archClang(arch),
                                "CGO_ENABLED":  "1",
                                "DARWIN_SDK":   sdk,
                        }
                }
        }

        return nil
}

// abi maps GOARCH values to Android abi strings.
// See https://developer.android.com/ndk/guides/abis
func abi(goarch string) string {
        switch goarch {
        case "arm":
                return "armeabi-v7a"
        case "arm64":
                return "arm64-v8a"
        case "386":
                return "x86"
        case "amd64":
                return "x86_64"
        default:
                return ""
        }
}

// checkNDKRoot returns nil if the NDK in `ndkRoot` supports the current configured
// API version and all the specified Android targets.
func checkNDKRoot(c *config.Config, ndkRoot string, targets []config.Platform) error {
        platformsJson, err := os.Open(filepath.Join(ndkRoot, "meta", "platforms.json"))
        if err != nil {
                return err
        }
        defer platformsJson.Close()
        decoder := json.NewDecoder(platformsJson)
        supportedVersions := struct {
                Min int
                Max int
        }{}
        if err := decoder.Decode(&supportedVersions); err != nil {
                return err
        }
        if supportedVersions.Min > c.Build.AndroidMinSDK ||
                supportedVersions.Max < c.Build.AndroidMinSDK {
                return fmt.Errorf("unsupported API version %d (not in %d..%d)", c.Build.AndroidMinSDK, supportedVersions.Min, supportedVersions.Max)
        }
        abisJson, err := os.Open(filepath.Join(ndkRoot, "meta", "abis.json"))
        if err != nil {
                return err
        }
        defer abisJson.Close()
        decoder = json.NewDecoder(abisJson)
        abis := make(map[string]struct{})
        if err := decoder.Decode(&abis); err != nil {
                return err
        }
        for _, target := range targets {
                if !isAndroidPlatform(target.OS) {
                        continue
                }
                if _, found := abis[abi(target.Arch)]; !found {
                        return fmt.Errorf("ndk does not support %s", target.OS)
                }
        }
        return nil
}

// compatibleNDKRoots searches the side-by-side NDK dirs for compatible SDKs.
func compatibleNDKRoots(c *config.Config, ndkForest string, targets []config.Platform) ([]string, error) {
        ndkDirs, err := os.ReadDir(ndkForest)
        if err != nil {
                return nil, err
        }
        compatibleNDKRoots := []string{}
        var lastErr error
        for _, dirent := range ndkDirs {
                ndkRoot := filepath.Join(ndkForest, dirent.Name())
                lastErr = checkNDKRoot(c, ndkRoot, targets)
                if lastErr == nil {
                        compatibleNDKRoots = append(compatibleNDKRoots, ndkRoot)
                }
        }
        if len(compatibleNDKRoots) > 0 {
                return compatibleNDKRoots, nil
        }
        return nil, lastErr
}

// ndkVersion returns the full version number of an installed copy of the NDK,
// or "" if it cannot be determined.
func ndkVersion(ndkRoot string) string {
        properties, err := os.Open(filepath.Join(ndkRoot, "source.properties"))
        if err != nil {
                return ""
        }
        defer properties.Close()
        // Parse the version number out of the .properties file.
        // See https://en.wikipedia.org/wiki/.properties
        scanner := bufio.NewScanner(properties)
        for scanner.Scan() {
                line := scanner.Text()
                tokens := strings.SplitN(line, "=", 2)
                if len(tokens) != 2 {
                        continue
                }
                if strings.TrimSpace(tokens[0]) == "Pkg.Revision" {
                        return strings.TrimSpace(tokens[1])
                }
        }
        return ""
}

// ndkRoot returns the root path of an installed NDK that supports all the
// specified Android targets. For details of NDK locations, see
// https://github.com/android/ndk-samples/wiki/Configure-NDK-Path
func ndkRoot(c *config.Config, targets ...config.Platform) (string, error) {
        // Try the ANDROID_NDK_HOME variable.  This approach is deprecated, but it
        // has the highest priority because it represents an explicit user choice.
        if ndkRoot := os.Getenv("ANDROID_NDK_HOME"); ndkRoot != "" {
                if err := checkNDKRoot(c, ndkRoot, targets); err != nil {
                        return "", fmt.Errorf("ANDROID_NDK_HOME specifies %s, which is unusable: %w", ndkRoot, err)
                }
                return ndkRoot, nil
        }

        androidHome, err := sdkpath.AndroidHome()
        if err != nil {
                return "", fmt.Errorf("could not locate Android SDK: %w", err)
        }

        // Use the newest compatible NDK under the side-by-side path arrangement.
        ndkForest := filepath.Join(androidHome, "ndk")
        ndkRoots, sideBySideErr := compatibleNDKRoots(c, ndkForest, targets)
        if len(ndkRoots) != 0 {
                // Choose the latest version that supports the build configuration.
                // NDKs whose version cannot be determined will be least preferred.
                // In the event of a tie, the later ndkRoot will win.
                maxVersion := ""
                var selected string
                for _, ndkRoot := range ndkRoots {
                        version := ndkVersion(ndkRoot)
                        if version >= maxVersion {
                                maxVersion = version
                                selected = ndkRoot
                        }
                }
                return selected, nil
        }
        // Try the deprecated NDK location.
        ndkRoot := filepath.Join(androidHome, "ndk-bundle")
        if legacyErr := checkNDKRoot(c, ndkRoot, targets); legacyErr != nil {
                return "", fmt.Errorf("no usable NDK in %s: %w, %v", androidHome, sideBySideErr, legacyErr)
        }
        return ndkRoot, nil
}

func envClang(sdkName string) (clang, cflags string, err error) {
        out, err := exec.Minor().Output("xcrun", "--sdk", sdkName, "--find", "clang")
        if err != nil {
                return "", "", fmt.Errorf("xcrun --find: %v\n%s", err, out)
        }
        clang = strings.TrimSpace(string(out))

        out, err = exec.Minor().Output("xcrun", "--sdk", sdkName, "--show-sdk-path")
        if err != nil {
                return "", "", fmt.Errorf("xcrun --show-sdk-path: %v\n%s", err, out)
        }
        sdk := strings.TrimSpace(string(out))
        return clang, "-isysroot " + sdk, nil
}

func archClang(goarch string) string {
        switch goarch {
        case "arm":
                return "armv7"
        case "arm64":
                return "arm64"
        case "386":
                return "i386"
        case "amd64":
                return "x86_64"
        default:
                panic(fmt.Sprintf("unknown GOARCH: %q", goarch))
        }
}

func archNDK() string {
        if runtime.GOOS == "windows" && runtime.GOARCH == "386" {
                return "windows"
        }

        var arch string
        switch runtime.GOARCH {
        case "386":
                arch = "x86"
        case "amd64":
                arch = "x86_64"
        case "arm64":
                // Android NDK does not contain arm64 toolchains (until and
                // including NDK 23), use use x86_64 instead. See:
                // https://github.com/android/ndk/issues/1299
                if runtime.GOOS == "darwin" {
                        arch = "x86_64"
                        break
                }
                if runtime.GOOS == "android" { // termux
                        return "linux-aarch64"
                }
                fallthrough
        default:
                panic("unsupported GOARCH: " + runtime.GOARCH)
        }
        return runtime.GOOS + "-" + arch
}

type ndkToolchain struct {
        Arch           string
        ABI            string
        MinAPI         int
        ToolPrefix     string
        ClangPrefixVal string // ClangPrefix is taken by a method
}

func (tc *ndkToolchain) clangPrefix(c *config.Config) string {
        if c.Build.AndroidMinSDK < tc.MinAPI {
                return fmt.Sprintf("%s%d", tc.ClangPrefixVal, tc.MinAPI)
        }
        return fmt.Sprintf("%s%d", tc.ClangPrefixVal, c.Build.AndroidMinSDK)
}

func (tc *ndkToolchain) path(c *config.Config, ndkRoot, toolName string) string {
        cmdFromPref := func(pref string) string {
                return filepath.Join(ndkRoot, "toolchains", "llvm", "prebuilt", archNDK(), "bin", pref+"-"+toolName)
        }

        var cmd string
        switch toolName {
        case "clang", "clang++":
                cmd = cmdFromPref(tc.clangPrefix(c))
        default:
                cmd = cmdFromPref(tc.ToolPrefix)
                // Starting from NDK 23, GNU binutils are fully migrated to LLVM binutils.
                // See https://android.googlesource.com/platform/ndk/+/master/docs/Roadmap.md#ndk-r23
                if _, err := os.Stat(cmd); errors.Is(err, fs.ErrNotExist) {
                        cmd = cmdFromPref("llvm")
                }
        }
        return cmd
}

type ndkConfig map[string]ndkToolchain // map: GOOS->androidConfig.

func (nc ndkConfig) toolchain(arch string) ndkToolchain {
        tc, ok := nc[arch]
        if !ok {
                panic(`unsupported architecture: ` + arch)
        }
        return tc
}

var ndk = ndkConfig{
        "arm": {
                Arch:           "arm",
                ABI:            "armeabi-v7a",
                MinAPI:         16,
                ToolPrefix:     "arm-linux-androideabi",
                ClangPrefixVal: "armv7a-linux-androideabi",
        },
        "arm64": {
                Arch:           "arm64",
                ABI:            "arm64-v8a",
                MinAPI:         21,
                ToolPrefix:     "aarch64-linux-android",
                ClangPrefixVal: "aarch64-linux-android",
        },

        "386": {
                Arch:           "x86",
                ABI:            "x86",
                MinAPI:         16,
                ToolPrefix:     "i686-linux-android",
                ClangPrefixVal: "i686-linux-android",
        },
        "amd64": {
                Arch:           "x86_64",
                ABI:            "x86_64",
                MinAPI:         21,
                ToolPrefix:     "x86_64-linux-android",
                ClangPrefixVal: "x86_64-linux-android",
        },
}

func xCodeAvailable() bool {
        err := exec.Run("xcrun", "xcodebuild", "-version")
        return err == nil
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package mobile

import (
        "fmt"
        "path/filepath"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/cmd/core/config"
)

// Install installs the app named by the import path on the attached mobile device.
// It assumes that it has already been built.
//
// On Android, the 'adb' tool must be on the PATH.
func Install(c *config.Config) error {
        if len(c.Build.Target) != 1 {
                return fmt.Errorf("expected 1 target platform, but got %d (%v)", len(c.Build.Target), c.Build.Target)
        }
        t := c.Build.Target[0]
        switch t.OS {
        case "android":
                return exec.Run("adb", "install", "-r", filepath.Join(c.Build.Output, c.Name+".apk"))
        case "ios":
                return exec.Major().SetBuffer(false).Run("ios-deploy", "-b", filepath.Join(c.Build.Output, c.Name+".app"))
        default:
                return fmt.Errorf("mobile.Install only supports target platforms android and ios, but got %q", t.OS)
        }
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package mobile

import (
        "encoding/xml"
        "errors"
        "fmt"
        "html/template"
)

type manifestXML struct {
        Activity activityXML `xml:"application>activity"`
}

type activityXML struct {
        Name     string        `xml:"name,attr"`
        MetaData []metaDataXML `xml:"meta-data"`
}

type metaDataXML struct {
        Name  string `xml:"name,attr"`
        Value string `xml:"value,attr"`
}

// manifestLibName parses the AndroidManifest.xml and finds the library
// name of the NativeActivity.
func manifestLibName(data []byte) (string, error) {
        manifest := new(manifestXML)
        if err := xml.Unmarshal(data, manifest); err != nil {
                return "", err
        }
        if manifest.Activity.Name != "org.golang.app.GoNativeActivity" {
                return "", fmt.Errorf("can only build an .apk for GoNativeActivity, not %q", manifest.Activity.Name)
        }
        libName := ""
        for _, md := range manifest.Activity.MetaData {
                if md.Name == "android.app.lib_name" {
                        libName = md.Value
                        break
                }
        }
        if libName == "" {
                return "", errors.New("AndroidManifest.xml missing meta-data android.app.lib_name")
        }
        return libName, nil
}

type manifestTmplData struct {
        JavaPkgPath string
        Name        string
        LibName     string
}

var manifestTmpl = template.Must(template.New("manifest").Parse(`
<manifest
        xmlns:android="http://schemas.android.com/apk/res/android"
        package="{{.JavaPkgPath}}"
        android:versionCode="1"
        android:versionName="1.0">

        <application android:label="{{.Name}}" android:debuggable="true">
        <activity android:name="org.golang.app.GoNativeActivity"
                android:label="{{.Name}}"
                android:configChanges="orientation|screenSize|keyboardHidden">
                <meta-data android:name="android.app.lib_name" android:value="{{.LibName}}" />
                <intent-filter>
                        <action android:name="android.intent.action.MAIN" />
                        <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
        </activity>
        </application>
</manifest>`))

// Copyright 2022 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package sdkpath provides functions for locating the Android SDK.
// These functions respect the ANDROID_HOME environment variable, and
// otherwise use the default SDK location.
package sdkpath

import (
        "fmt"
        "os"
        "path/filepath"
        "runtime"
        "strconv"
        "strings"
)

// AndroidHome returns the absolute path of the selected Android SDK,
// if one can be found.
func AndroidHome() (string, error) {
        androidHome := os.Getenv("ANDROID_HOME")
        if androidHome == "" {
                home, err := os.UserHomeDir()
                if err != nil {
                        return "", err
                }
                switch runtime.GOOS {
                case "windows":
                        // See https://android.googlesource.com/platform/tools/adt/idea/+/85b4bfb7a10ad858a30ffa4003085b54f9424087/native/installer/win/setup_android_studio.nsi#100
                        androidHome = filepath.Join(home, "AppData", "Local", "Android", "sdk")
                case "darwin":
                        // See https://android.googlesource.com/platform/tools/asuite/+/67e0cd9604379e9663df57f16a318d76423c0aa8/aidegen/lib/ide_util.py#88
                        androidHome = filepath.Join(home, "Library", "Android", "sdk")
                default: // Linux, BSDs, etc.
                        // See LINUX_ANDROID_SDK_PATH in ide_util.py above.
                        androidHome = filepath.Join(home, "Android", "Sdk")
                }
        }
        if info, err := os.Stat(androidHome); err != nil {
                return "", fmt.Errorf("%w; Android SDK was not found at %s", err, androidHome)
        } else if !info.IsDir() {
                return "", fmt.Errorf("%s is not a directory", androidHome)
        }
        return androidHome, nil
}

// AndroidAPIPath returns an android SDK platform directory within the configured SDK.
// If there are multiple platforms that satisfy the minimum version requirement,
// AndroidAPIPath returns the latest one among them.
func AndroidAPIPath(api int) (string, error) {
        sdk, err := AndroidHome()
        if err != nil {
                return "", err
        }
        sdkDir, err := os.Open(filepath.Join(sdk, "platforms"))
        if err != nil {
                return "", fmt.Errorf("failed to find android SDK platform: %w", err)
        }
        defer sdkDir.Close()
        fis, err := sdkDir.Readdir(-1)
        if err != nil {
                return "", fmt.Errorf("failed to find android SDK platform (API level: %d): %w", api, err)
        }

        var apiPath string
        var apiVer int
        for _, fi := range fis {
                name := fi.Name()
                if !strings.HasPrefix(name, "android-") {
                        continue
                }
                n, err := strconv.Atoi(name[len("android-"):])
                if err != nil || n < api {
                        continue
                }
                p := filepath.Join(sdkDir.Name(), name)
                _, err = os.Stat(filepath.Join(p, "android.jar"))
                if err == nil && apiVer < n {
                        apiPath = p
                        apiVer = n
                }
        }
        if apiVer == 0 {
                return "", fmt.Errorf("failed to find android SDK platform (API level: %d) in %s",
                        api, sdkDir.Name())
        }
        return apiPath, nil
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package mobile

import (
        "os"
        "runtime"
        "strings"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/cmd/core/config"
        "golang.org/x/tools/go/packages"
)

var (
        goos   = runtime.GOOS
        goarch = runtime.GOARCH
)

func packagesConfig(t *config.Platform) *packages.Config {
        config := &packages.Config{}
        // Add CGO_ENABLED=1 explicitly since Cgo is disabled when GOOS is different from host OS.
        config.Env = append(os.Environ(), "GOARCH="+t.Arch, "GOOS="+platformOS(t.OS), "CGO_ENABLED=1")
        tags := platformTags(t.OS)

        if len(tags) > 0 {
                config.BuildFlags = []string{"-tags=" + strings.Join(tags, ",")}
        }
        return config
}

func goEnv(name string) string {
        if val := os.Getenv(name); val != "" {
                return val
        }
        val, err := exec.Minor().Output("go", "env", name)
        if err != nil {
                panic(err) // the Go tool was tested to work earlier
        }
        return strings.TrimSpace(string(val))
}

// Copyright 2015 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package mobile

// TODO: do we need this writer stuff?

// APK is the archival format used for Android apps. It is a ZIP archive with
// three extra files:
//
//        META-INF/MANIFEST.MF
//        META-INF/CERT.SF
//        META-INF/CERT.RSA
//
// The MANIFEST.MF comes from the Java JAR archive format. It is a list of
// files included in the archive along with a SHA1 hash, for example:
//
//        Name: lib/armeabi/libbasic.so
//        SHA1-Digest: ntLSc1eLCS2Tq1oB4Vw6jvkranw=
//
// For debugging, the equivalent SHA1-Digest can be generated with OpenSSL:
//
//        cat lib/armeabi/libbasic.so | openssl sha1 -binary | openssl base64
//
// CERT.SF is a similar manifest. It begins with a SHA1 digest of the entire
// manifest file:
//
//        Signature-Version: 1.0
//        Created-By: 1.0 (Android)
//        SHA1-Digest-Manifest: aJw+u+10C3Enbg8XRCN6jepluYA=
//
// Then for each entry in the manifest it has a SHA1 digest of the manfiest's
// hash combined with the file name:
//
//        Name: lib/armeabi/libbasic.so
//        SHA1-Digest: Q7NAS6uzrJr6WjePXSGT+vvmdiw=
//
// This can also be generated with openssl:
//
//        echo -en "Name: lib/armeabi/libbasic.so\r\nSHA1-Digest: ntLSc1eLCS2Tq1oB4Vw6jvkranw=\r\n\r\n" | openssl sha1 -binary | openssl base64
//
// Note the \r\n line breaks.
//
// CERT.RSA is an RSA signature block made of CERT.SF. Verify it with:
//
//        openssl smime -verify -in CERT.RSA -inform DER -content CERT.SF cert.pem
//
// The APK format imposes two extra restrictions on the ZIP format. First,
// it is uncompressed. Second, each contained file is 4-byte aligned. This
// allows the Android OS to mmap contents without unpacking the archive.

// Note: to make life a little harder, Android Studio stores the RSA key used
// for signing in an Oracle Java proprietary keystore format, JKS. For example,
// the generated debug key is in ~/.android/debug.keystore, and can be
// extracted using the JDK's keytool utility:
//
//        keytool -importkeystore -srckeystore ~/.android/debug.keystore -destkeystore ~/.android/debug.p12 -deststoretype PKCS12
//
// Once in standard PKCS12, the key can be converted to PEM for use in the
// Go crypto packages:
//
//        openssl pkcs12 -in ~/.android/debug.p12 -nocerts -nodes -out ~/.android/debug.pem
//
// Fortunately for debug builds, all that matters is that the APK is signed.
// The choice of key is unimportant, so we can generate one for normal builds.
// For production builds, we can ask users to provide a PEM file.

import (
        "archive/zip"
        "bytes"
        "crypto/rand"
        "crypto/rsa"
        "crypto/sha1"
        "encoding/base64"
        "fmt"
        "hash"
        "io"
)

// newWriter returns a new Writer writing an APK file to w.
// The APK will be signed with key.
func newWriter(w io.Writer, priv *rsa.PrivateKey) *writer {
        apkw := &writer{priv: priv}
        apkw.w = zip.NewWriter(&countWriter{apkw: apkw, w: w})
        return apkw
}

// writer implements an APK file writer.
type writer struct {
        offset   int
        w        *zip.Writer
        priv     *rsa.PrivateKey
        manifest []manifestEntry
        cur      *fileWriter
}

// Create adds a file to the APK archive using the provided name.
//
// The name must be a relative path. The file's contents must be written to
// the returned io.Writer before the next call to Create or Close.
func (w *writer) Create(name string) (io.Writer, error) {
        if err := w.clearCur(); err != nil {
                return nil, fmt.Errorf("apk: Create(%s): %v", name, err)
        }
        res, err := w.create(name)
        if err != nil {
                return nil, fmt.Errorf("apk: Create(%s): %v", name, err)
        }
        return res, nil
}

func (w *writer) create(name string) (io.Writer, error) {
        // Align start of file contents by using Extra as padding.
        if err := w.w.Flush(); err != nil { // for exact offset
                return nil, err
        }
        const fileHeaderLen = 30 // + filename + extra
        start := w.offset + fileHeaderLen + len(name)
        extra := (-start) & 3

        zipfw, err := w.w.CreateHeader(&zip.FileHeader{
                Name:  name,
                Extra: make([]byte, extra),
        })
        if err != nil {
                return nil, err
        }
        w.cur = &fileWriter{
                name: name,
                w:    zipfw,
                sha1: sha1.New(),
        }
        return w.cur, nil
}

// Close finishes writing the APK. This includes writing the manifest and
// signing the archive, and writing the ZIP central directory.
//
// It does not close the underlying writer.
func (w *writer) Close() error {
        if err := w.clearCur(); err != nil {
                return fmt.Errorf("apk: %v", err)
        }

        hasDex := false
        for _, entry := range w.manifest {
                if entry.name == "classes.dex" {
                        hasDex = true
                        break
                }
        }

        manifest := new(bytes.Buffer)
        if hasDex {
                fmt.Fprint(manifest, manifestDexHeader)
        } else {
                fmt.Fprint(manifest, manifestHeader)
        }
        certBody := new(bytes.Buffer)

        for _, entry := range w.manifest {
                n := entry.name
                h := base64.StdEncoding.EncodeToString(entry.sha1.Sum(nil))
                fmt.Fprintf(manifest, "Name: %s\nSHA1-Digest: %s\n\n", n, h)
                cHash := sha1.New()
                fmt.Fprintf(cHash, "Name: %s\r\nSHA1-Digest: %s\r\n\r\n", n, h)
                ch := base64.StdEncoding.EncodeToString(cHash.Sum(nil))
                fmt.Fprintf(certBody, "Name: %s\nSHA1-Digest: %s\n\n", n, ch)
        }

        mHash := sha1.New()
        mHash.Write(manifest.Bytes())
        cert := new(bytes.Buffer)
        fmt.Fprint(cert, certHeader)
        fmt.Fprintf(cert, "SHA1-Digest-Manifest: %s\n\n", base64.StdEncoding.EncodeToString(mHash.Sum(nil)))
        cert.Write(certBody.Bytes())

        mw, err := w.Create("META-INF/MANIFEST.MF")
        if err != nil {
                return err
        }
        if _, err := mw.Write(manifest.Bytes()); err != nil {
                return err
        }

        cw, err := w.Create("META-INF/CERT.SF")
        if err != nil {
                return err
        }
        if _, err := cw.Write(cert.Bytes()); err != nil {
                return err
        }

        rsa, err := signPKCS7(rand.Reader, w.priv, cert.Bytes())
        if err != nil {
                return fmt.Errorf("apk: %v", err)
        }
        rw, err := w.Create("META-INF/CERT.RSA")
        if err != nil {
                return err
        }
        if _, err := rw.Write(rsa); err != nil {
                return err
        }

        return w.w.Close()
}

const manifestHeader = `Manifest-Version: 1.0
Created-By: 1.0 (Go)

`

const manifestDexHeader = `Manifest-Version: 1.0
Dex-Location: classes.dex
Created-By: 1.0 (Go)

`

const certHeader = `Signature-Version: 1.0
Created-By: 1.0 (Go)
`

func (w *writer) clearCur() error {
        if w.cur == nil {
                return nil
        }
        w.manifest = append(w.manifest, manifestEntry{
                name: w.cur.name,
                sha1: w.cur.sha1,
        })
        w.cur.closed = true
        w.cur = nil
        return nil
}

type manifestEntry struct {
        name string
        sha1 hash.Hash
}

type countWriter struct {
        apkw *writer
        w    io.Writer
}

func (c *countWriter) Write(p []byte) (n int, err error) {
        n, err = c.w.Write(p)
        c.apkw.offset += n
        return n, err
}

type fileWriter struct {
        name   string
        w      io.Writer
        sha1   hash.Hash
        closed bool
}

func (w *fileWriter) Write(p []byte) (n int, err error) {
        if w.closed {
                return 0, fmt.Errorf("apk: write to closed file %q", w.name)
        }
        w.sha1.Write(p)
        n, err = w.w.Write(p)
        if err != nil {
                err = fmt.Errorf("apk: %v", err)
        }
        return n, err
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rendericon

import (
        "errors"
        "fmt"
        "image"
        "io/fs"
        "os"
        "strings"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/math32"
        _ "cogentcore.org/core/paint/renderers"
        "cogentcore.org/core/svg"
)

// Render renders the icon located at icon.svg at the given size.
// If no such icon exists, it sets it to a placeholder icon, [icons.DefaultAppIcon].
func Render(size int) (*image.RGBA, error) {
        sv := svg.NewSVG(math32.Vec2(float32(size), float32(size)))

        spath := "icon.svg"
        err := sv.OpenXML(spath)
        if err != nil {
                if !errors.Is(err, fs.ErrNotExist) {
                        return nil, fmt.Errorf("error opening svg icon file: %w", err)
                }
                err = os.WriteFile(spath, []byte(icons.CogentCore), 0666)
                if err != nil {
                        return nil, err
                }
                err = sv.ReadXML(strings.NewReader(string(icons.CogentCore)))
                if err != nil {
                        return nil, err
                }
        }

        return imagex.AsRGBA(sv.RenderImage()), nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package web provides functions for building Cogent Core apps for the web.
package web

import (
        "crypto/sha1"
        "fmt"
        "os"
        "path/filepath"
        "strconv"
        "strings"
        "time"

        "cogentcore.org/core/base/exec"
        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/base/iox/jsonx"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/cmd/core/rendericon"
        "cogentcore.org/core/content/bcontent"
        strip "github.com/grokify/html-strip-tags-go"
)

// Build builds an app for web using the given configuration information.
func Build(c *config.Config) error {
        output := filepath.Join(c.Build.Output, "app.wasm")
        opath := output
        if c.Web.Gzip {
                opath += ".orig"
        }
        args := []string{"build", "-o", opath, "-ldflags", config.LinkerFlags(c)}
        if c.Build.Trimpath {
                args = append(args, "-trimpath")
        }
        err := exec.Major().SetEnv("GOOS", "js").SetEnv("GOARCH", "wasm").Run("go", args...)
        if err != nil {
                return err
        }
        if c.Web.Gzip {
                err = exec.RemoveAll(output + ".orig.gz")
                if err != nil {
                        return err
                }
                err = exec.Run("gzip", output+".orig")
                if err != nil {
                        return err
                }
                err = os.Rename(output+".orig.gz", output)
                if err != nil {
                        return err
                }
        }
        return makeFiles(c)
}

// makeFiles makes the necessary static web files based on the given configuration information.
func makeFiles(c *config.Config) error {
        odir := c.Build.Output

        if c.Web.RandomVersion {
                t := time.Now().UTC().String()
                c.Version = fmt.Sprintf(`%x`, sha1.Sum([]byte(t)))
        }

        // The about text may contain HTML, which we need to get rid of.
        // It is trusted, so we do not need a more advanced sanitizer.
        c.About = strip.StripTags(c.About)

        wej := []byte(wasmExecJS)
        err := os.WriteFile(filepath.Join(odir, "wasm_exec.js"), wej, 0666)
        if err != nil {
                return err
        }

        ajs, err := makeAppJS(c)
        if err != nil {
                return err
        }
        err = os.WriteFile(filepath.Join(odir, "app.js"), ajs, 0666)
        if err != nil {
                return err
        }

        awjs, err := makeAppWorkerJS(c)
        if err != nil {
                return err
        }
        err = os.WriteFile(filepath.Join(odir, "app-worker.js"), awjs, 0666)
        if err != nil {
                return err
        }

        man, err := makeManifestJSON(c)
        if err != nil {
                return err
        }
        err = os.WriteFile(filepath.Join(odir, "manifest.webmanifest"), man, 0666)
        if err != nil {
                return err
        }

        acs := []byte(appCSS)
        err = os.WriteFile(filepath.Join(odir, "app.css"), acs, 0666)
        if err != nil {
                return err
        }

        preRenderHTML := ""
        if c.Web.GenerateHTML {
                preRenderHTML, err = exec.Output("go", "run", "-tags", "offscreen,generatehtml", ".")
                if err != nil {
                        return err
                }
        }
        prindex := &bcontent.PreRenderPage{
                HTML: preRenderHTML,
        }
        prps := []*bcontent.PreRenderPage{}
        if strings.HasPrefix(preRenderHTML, "[{") {
                err := jsonx.Read(&prps, strings.NewReader(preRenderHTML))
                if err != nil {
                        return err
                }
                if c.Content == "" {
                        c.Content = "content"
                }
        }
        for _, prp := range prps {
                if prp.URL == "" {
                        prindex = prp
                        break
                }
        }
        prindex.Name = c.Name
        if c.About != "" {
                prindex.Description = c.About
        }
        iht, err := makeIndexHTML(c, "", prindex)
        if err != nil {
                return err
        }
        err = os.WriteFile(filepath.Join(odir, "index.html"), iht, 0666)
        if err != nil {
                return err
        }

        // The 404 page is just the same as the index page, with an updated base path.
        // The logic in the home page can then handle the error appropriately.
        bpath404 := "../"
        // TODO: this is a temporary hack to fix the 404 page for multi-nested old URLs in the Cogent Core Docs.
        if c.Name == "Cogent Core Docs" {
                if c.Build.Trimpath {
                        bpath404 = "https://www.cogentcore.org/core/" // production
                } else {
                        bpath404 = "http://localhost:8080/" // dev
                }
        }
        notFound, err := makeIndexHTML(c, bpath404, prindex)
        if err != nil {
                return err
        }
        err = os.WriteFile(filepath.Join(odir, "404.html"), notFound, 0666)
        if err != nil {
                return nil
        }

        if c.Content != "" {
                err := makePages(c, prps)
                if err != nil {
                        return err
                }
        }

        err = os.MkdirAll(filepath.Join(odir, "icons"), 0777)
        if err != nil {
                return err
        }
        sizes := []int{32, 192, 512}
        for _, size := range sizes {
                ic, err := rendericon.Render(size)
                if err != nil {
                        return err
                }
                err = imagex.Save(ic, filepath.Join(odir, "icons", strconv.Itoa(size)+".png"))
                if err != nil {
                        return err
                }
        }
        err = exec.Run("cp", "icon.svg", filepath.Join(odir, "icons", "svg.svg"))
        if err != nil {
                return err
        }

        return nil
}

// makePages makes a directory structure of pages for
// the core pages located at [config.Config.Pages].
func makePages(c *config.Config, prps []*bcontent.PreRenderPage) error {
        for _, prp := range prps {
                if prp.URL == "" { // exclude root index (already handled)
                        continue
                }
                opath := filepath.Join(c.Build.Output, prp.URL)
                err := os.MkdirAll(opath, 0777)
                if err != nil {
                        return err
                }
                b, err := makeIndexHTML(c, "../", prp)
                if err != nil {
                        return err
                }
                err = os.WriteFile(filepath.Join(opath, "index.html"), b, 0666)
                if err != nil {
                        return err
                }
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package web

import (
        "net/http"
        "os"
        "path/filepath"
        "strings"

        "cogentcore.org/core/base/logx"
        "cogentcore.org/core/cmd/core/config"
)

// Serve serves the build output directory on the default network address at the config port.
func Serve(c *config.Config) error {
        hfs := http.FileServer(http.Dir(c.Build.Output))
        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
                trim := strings.Trim(r.URL.Path, "/")
                _, err := os.Stat(filepath.Join(c.Build.Output, trim))
                if err != nil {
                        r.URL.Path = "/404.html"
                        trim = "404.html"
                        w.WriteHeader(http.StatusNotFound)
                }
                if trim == "app.wasm" {
                        w.Header().Set("Content-Type", "application/wasm")
                        if c.Web.Gzip {
                                w.Header().Set("Content-Encoding", "gzip")
                        }
                }
                hfs.ServeHTTP(w, r)
        })

        logx.PrintlnWarn("Serving at http://localhost:" + c.Web.Port)
        return http.ListenAndServe(":"+c.Web.Port, nil)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package web

import (
        "bytes"
        "encoding/json"
        "log/slog"
        "os"
        "text/template"

        "cogentcore.org/core/base/elide"
        "cogentcore.org/core/cmd/core/config"
        "cogentcore.org/core/content/bcontent"
        strip "github.com/grokify/html-strip-tags-go"
)

// appJSTmpl is the template used in [makeAppJS] to build the app.js file
var appJSTmpl = template.Must(template.New("app.js").Parse(appJS))

// appJSData is the data passed to [appJSTmpl]
type appJSData struct {
        Env                     string
        WasmContentLengthHeader string
        AutoUpdateInterval      int64
}

// makeAppJS exectues [appJSTmpl] based on the given configuration information.
func makeAppJS(c *config.Config) ([]byte, error) {
        if c.Web.Env == nil {
                c.Web.Env = make(map[string]string)
        }
        c.Web.Env["GOAPP_STATIC_RESOURCES_URL"] = "/"
        c.Web.Env["GOAPP_ROOT_PREFIX"] = "."

        for k, v := range c.Web.Env {
                if err := os.Setenv(k, v); err != nil {
                        slog.Error("setting app env variable failed", "name", k, "value", v, "err", err)
                }
        }

        wenv, err := json.Marshal(c.Web.Env)
        if err != nil {
                return nil, err
        }

        d := appJSData{
                Env:                     string(wenv),
                WasmContentLengthHeader: c.Web.WasmContentLengthHeader,
                AutoUpdateInterval:      c.Web.AutoUpdateInterval.Milliseconds(),
        }
        b := &bytes.Buffer{}
        err = appJSTmpl.Execute(b, d)
        if err != nil {
                return nil, err
        }
        return b.Bytes(), nil
}

// appWorkerJSData is the data passed to [config.Config.Web.ServiceWorkerTemplate]
type appWorkerJSData struct {
        Version          string
        ResourcesToCache string
}

// makeAppWorkerJS executes [config.Config.Web.ServiceWorkerTemplate]. If it empty, it
// sets it to [appWorkerJS].
func makeAppWorkerJS(c *config.Config) ([]byte, error) {
        resources := []string{
                "app.css",
                "app.js",
                "app.wasm",
                "manifest.webmanifest",
                "wasm_exec.js",
                "index.html",
        }

        tmpl, err := template.New("app-worker.js").Parse(appWorkerJS)
        if err != nil {
                return nil, err
        }

        rstr, err := json.Marshal(resources)
        if err != nil {
                return nil, err
        }

        d := appWorkerJSData{
                Version:          c.Version,
                ResourcesToCache: string(rstr),
        }

        b := &bytes.Buffer{}
        err = tmpl.Execute(b, d)
        if err != nil {
                return nil, err
        }
        return b.Bytes(), nil
}

// manifestJSONTmpl is the template used in [makeManifestJSON] to build the mainfest.webmanifest file
var manifestJSONTmpl = template.Must(template.New("manifest.webmanifest").Parse(manifestJSON))

// manifestJSONData is the data passed to [manifestJSONTmpl]
type manifestJSONData struct {
        ShortName   string
        Name        string
        Description string
}

// makeManifestJSON exectues [manifestJSONTmpl] based on the given configuration information.
func makeManifestJSON(c *config.Config) ([]byte, error) {
        d := manifestJSONData{
                ShortName:   elide.AppName(c.Name),
                Name:        c.Name,
                Description: c.About,
        }

        b := &bytes.Buffer{}
        err := manifestJSONTmpl.Execute(b, d)
        if err != nil {
                return nil, err
        }
        return b.Bytes(), nil
}

// indexHTMLTmpl is the template used in [makeIndexHTML] to build the index.html file
var indexHTMLTmpl = template.Must(template.New("index.html").Parse(indexHTML))

// indexHTMLData is the data passed to [indexHTMLTmpl]
type indexHTMLData struct {
        BasePath               string
        Author                 string
        Description            string
        Keywords               []string
        Title                  string
        SiteName               string
        Image                  string
        Styles                 []string
        VanityURL              string
        GithubVanityRepository string
        PreRenderHTML          string
}

// makeIndexHTML exectues [indexHTMLTmpl] based on the given configuration information,
// base path for app resources (used in [makePages]), optional title (used in [makePages],
// defaults to [config.Config.Name] otherwise), optional page-specific description (used
// in [makePages], defaults to [config.Config.About]), and pre-render HTML representation
// of app content.
func makeIndexHTML(c *config.Config, basePath string, prp *bcontent.PreRenderPage) ([]byte, error) {
        if prp.Description == "" {
                prp.Description = c.About
        } else {
                // c.About is already stripped earlier, so only necessary
                // for page-specific description here.
                prp.Description = strip.StripTags(prp.Description)
        }
        d := indexHTMLData{
                BasePath:               basePath,
                Author:                 c.Web.Author,
                Description:            prp.Description,
                Keywords:               c.Web.Keywords,
                Title:                  prp.Name,
                SiteName:               c.Name,
                Image:                  c.Web.Image,
                Styles:                 c.Web.Styles,
                VanityURL:              c.Web.VanityURL,
                GithubVanityRepository: c.Web.GithubVanityRepository,
                PreRenderHTML:          prp.HTML,
        }

        b := &bytes.Buffer{}
        err := indexHTMLTmpl.Execute(b, d)
        if err != nil {
                return nil, err
        }
        return b.Bytes(), nil
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package colors

import (
        "image/color"

        "cogentcore.org/core/colors/cam/hct"
        "cogentcore.org/core/colors/matcolor"
)

// Based on matcolor/accent.go

// ToBase returns the base accent color for the given color
// based on the current scheme (light or dark), which is
// typically used for high emphasis objects or text.
func ToBase(c color.Color) color.RGBA {
        if matcolor.SchemeIsDark {
                return hct.FromColor(c).WithTone(80).AsRGBA()
        }
        return hct.FromColor(c).WithTone(40).AsRGBA()
}

// ToOn returns the accent color for the given color
// that should be placed on top of [ToBase] based on
// the current scheme (light or dark).
func ToOn(c color.Color) color.RGBA {
        if matcolor.SchemeIsDark {
                return hct.FromColor(c).WithTone(20).AsRGBA()
        }
        return hct.FromColor(c).WithTone(100).AsRGBA()
}

// ToContainer returns the container accent color for the given color
// based on the current scheme (light or dark), which is
// typically used for lower emphasis content.
func ToContainer(c color.Color) color.RGBA {
        if matcolor.SchemeIsDark {
                return hct.FromColor(c).WithTone(30).AsRGBA()
        }
        return hct.FromColor(c).WithTone(90).AsRGBA()
}

// ToOnContainer returns the accent color for the given color
// that should be placed on top of [ToContainer] based on
// the current scheme (light or dark).
func ToOnContainer(c color.Color) color.RGBA {
        if matcolor.SchemeIsDark {
                return hct.FromColor(c).WithTone(90).AsRGBA()
        }
        return hct.FromColor(c).WithTone(10).AsRGBA()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package colors

import (
        "image/color"
        "log/slog"

        "cogentcore.org/core/colors/cam/cam16"
        "cogentcore.org/core/colors/cam/hct"
        "cogentcore.org/core/math32"
)

// BlendTypes are different algorithms (colorspaces) to use for blending
// the color stop values in generating the gradients.
type BlendTypes int32 //enums:enum

const (
        // HCT uses the hue, chroma, and tone space and generally produces the best results,
        // but at a slight performance cost.
        HCT BlendTypes = iota

        // RGB uses raw RGB space, which is the standard space that most other programs use.
        // It produces decent results with maximum performance.
        RGB

        // CAM16 is an alternative colorspace, similar to HCT, but not quite as good.
        CAM16
)

// Blend returns a color that is the given proportion between the first
// and second color. For example, 0.1 indicates to blend 10% of the first
// color and 90% of the second. Blending is done using the given blending
// algorithm.
func Blend(bt BlendTypes, p float32, x, y color.Color) color.RGBA {
        switch bt {
        case HCT:
                return hct.Blend(p, x, y)
        case RGB:
                return BlendRGB(p, x, y)
        case CAM16:
                return cam16.Blend(p, x, y)
        }
        slog.Error("got unexpected blend type", "type", bt)
        return color.RGBA{}
}

// BlendRGB returns a color that is the given proportion between the first
// and second color in RGB colorspace. For example, 0.1 indicates to blend
// 10% of the first color and 90% of the second. Blending is done directly
// on non-premultiplied
// RGB values, and a correctly premultiplied color is returned.
func BlendRGB(pct float32, x, y color.Color) color.RGBA {
        fx := NRGBAF32Model.Convert(x).(NRGBAF32)
        fy := NRGBAF32Model.Convert(y).(NRGBAF32)
        pct = math32.Clamp(pct, 0, 100.0)
        px := pct / 100
        py := 1.0 - px
        fx.R = px*fx.R + py*fy.R
        fx.G = px*fx.G + py*fy.G
        fx.B = px*fx.B + py*fy.B
        fx.A = px*fx.A + py*fy.A
        return AsRGBA(fx)
}

// m is the maximum color value returned by [image.Color.RGBA]
const m = 1<<16 - 1

// AlphaBlend blends the two colors, handling alpha blending correctly.
// The source color is figuratively placed "on top of" the destination color.
func AlphaBlend(dst, src color.Color) color.RGBA {
        res := color.RGBA{}

        dr, dg, db, da := dst.RGBA()
        sr, sg, sb, sa := src.RGBA()
        a := (m - sa)

        res.R = uint8((uint32(dr)*a/m + sr) >> 8)
        res.G = uint8((uint32(dg)*a/m + sg) >> 8)
        res.B = uint8((uint32(db)*a/m + sb) >> 8)
        res.A = uint8((uint32(da)*a/m + sa) >> 8)
        return res
}

// Copyright (c) 2021, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cam02

import (
        "cogentcore.org/core/colors/cam/cie"
        "cogentcore.org/core/math32"
)

// XYZToLMS converts XYZ to Long, Medium, Short cone-based responses,
// using the CAT02 transform from CIECAM02 color appearance model
// (MoroneyFairchildHuntEtAl02)
func XYZToLMS(x, y, z float32) (l, m, s float32) {
        l = 0.7328*x + 0.4296*y + -0.1624*z
        m = -0.7036*x + 1.6975*y + 0.0061*z
        s = 0.0030*x + 0.0136*y + 0.9834*z
        return
}

// SRGBLinToLMS converts sRGB linear to Long, Medium, Short
// cone-based responses, using the CAT02 transform from CIECAM02
// color appearance model (MoroneyFairchildHuntEtAl02)
// this is good for representing adaptation but NOT apparently
// good for representing appearances
func SRGBLinToLMS(rl, gl, bl float32) (l, m, s float32) {
        l = 0.3904054*rl + 0.54994122*gl + 0.00892632*bl
        m = 0.0708416*rl + 0.96317176*gl + 0.00135775*bl
        s = 0.0491304*rl + 0.21556128*gl + 0.9450824*bl
        return
}

// SRGBToLMS converts sRGB to Long, Medium, Short cone-based responses,
// using the CAT02 transform from CIECAM02 color appearance model
// (MoroneyFairchildHuntEtAl02)
func SRGBToLMS(r, g, b float32) (l, m, s float32) {
        rl, gl, bl := cie.SRGBToLinear(r, g, b)
        l, m, s = SRGBLinToLMS(rl, gl, bl)
        return
}

/*
// convert Long, Medium, Short cone-based responses to XYZ, using the CAT02 transform from CIECAM02 color appearance model (MoroneyFairchildHuntEtAl02)
func LMSToXYZ(l, m, s float32) (x, y, z float32) {
    x = 1.096124 * l + 0.4296f * Y + -0.1624f * Z;
    y = -0.7036f * X + 1.6975f * Y + 0.0061f * Z;
    z = 0.0030f * X + 0.0136f * Y + 0.9834 * Z;
  }
*/

///////////////////////////////////
// HPE versions

// LuminanceAdapt implements the luminance adaptation function
// equals 1 at background luminance of 200 so we generally ignore it..
// bgLum is background luminance -- 200 default.
func LuminanceAdapt(bgLum float32) float32 {
        lum5 := 5.0 * bgLum
        k := 1.0 / (lum5 + 1)
        k4 := k * k * k * k
        k4m1 := 1 - k4
        fl := 0.2*k4*lum5 + .1*k4m1*k4m1*math32.Pow(lum5, 1.0/3.0)
        return fl
}

// ResponseCompression takes a 0-1 normalized LMS value
// and performs hyperbolic response compression.
// val must ALREADY have the luminance adaptation applied to it
// using the luminance adaptation function, which is 1 at a
// background luminance level of 200 = 2, so you can skip that
// step if you assume that level of background.
func ResponseCompression(val float32) float32 {
        pval := math32.Pow(val, 0.42)
        rc := 0.1 + 4.0*pval/(27.13+pval)
        return rc
}

// LMSToResp converts Long, Medium, Short cone-based values to
// values that more closely reflect neural responses,
// including a combined long-medium (yellow) channel (lmc).
// Uses the CIECAM02 color appearance model (MoroneyFairchildHuntEtAl02)
// https://en.wikipedia.org/wiki/CIECAM02
func LMSToResp(l, m, s float32) (lc, mc, sc, lmc, grey float32) {
        lA := ResponseCompression(l)
        mA := ResponseCompression(m)
        sA := ResponseCompression(s)
        // subtract min and mult by 6 gets values roughly into 1-0 range for L,M
        lc = 6 * ((lA + (float32(1)/11)*sA) - 0.109091)
        mc = 6 * (((float32(12) / 11) * mA) - 0.109091)
        sc = 6 * (((float32(2) / 9) * sA) - 0.0222222)
        lmc = 6 * (((float32(1) / 9) * (lA + mA)) - 0.0222222)
        grey = (1 / 0.431787) * (2*lA + mA + .05*sA - 0.305)
        // note: last term should be: 0.725 * (1/5)^-0.2 = grey background assumption (Yb/Yw = 1/5) = 1
        return
}

// SRGBToLMSResp converts sRGB to LMS neural response cone values,
// that more closely reflect neural responses,
// including a combined long-medium (yellow) channel (lmc).
// Uses the CIECAM02 color appearance model (MoroneyFairchildHuntEtAl02)
// https://en.wikipedia.org/wiki/CIECAM02
func SRGBToLMSResp(r, g, b float32) (lc, mc, sc, lmc, grey float32) {
        l, m, s := SRGBToLMS(r, g, b)
        lc, mc, sc, lmc, grey = LMSToResp(l, m, s)
        return
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted from https://github.com/material-foundation/material-color-utilities
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cam16

import (
        "image/color"

        "cogentcore.org/core/base/num"
        "cogentcore.org/core/colors/cam/cie"
        "cogentcore.org/core/math32"
)

// CAM represents a point in the cam16 color model along 6 dimensions
// representing the perceived hue, colorfulness, and brightness,
// similar to HSL but much more well-calibrated to actual human subjective judgments.
type CAM struct {

        // hue (h) is the spectral identity of the color (red, green, blue etc) in degrees (0-360)
        Hue float32

        // chroma (C) is the colorfulness or saturation of the color -- greyscale colors have no chroma, and fully saturated ones have high chroma
        Chroma float32

        // colorfulness (M) is the absolute chromatic intensity
        Colorfulness float32

        // saturation (s) is the colorfulness relative to brightness
        Saturation float32

        // brightness (Q) is the apparent amount of light from the color, which is not a simple function of actual light energy emitted
        Brightness float32

        // lightness (J) is the brightness relative to a reference white, which varies as a function of chroma and hue
        Lightness float32
}

// RGBA implements the color.Color interface.
func (cam *CAM) RGBA() (r, g, b, a uint32) {
        x, y, z := cam.XYZ()
        rf, gf, bf := cie.XYZ100ToSRGB(x, y, z)
        return cie.SRGBFloatToUint32(rf, gf, bf, 1)
}

// AsRGBA returns the color as a [color.RGBA].
func (cam *CAM) AsRGBA() color.RGBA {
        x, y, z := cam.XYZ()
        rf, gf, bf := cie.XYZ100ToSRGB(x, y, z)
        r, g, b, a := cie.SRGBFloatToUint8(rf, gf, bf, 1)
        return color.RGBA{r, g, b, a}
}

// UCS returns the CAM16-UCS components based on the the CAM values
func (cam *CAM) UCS() (j, m, a, b float32) {
        j = (1 + 100*0.007) * cam.Lightness / (1 + 0.007*cam.Lightness)
        m = math32.Log(1+0.0228*cam.Colorfulness) / 0.0228
        hr := math32.DegToRad(cam.Hue)
        a = m * math32.Cos(hr)
        b = m * math32.Sin(hr)
        return
}

// FromUCS returns CAM values from the given CAM16-UCS coordinates
// (jstar, astar, and bstar), under standard viewing conditions
func FromUCS(j, a, b float32) *CAM {
        return FromUCSView(j, a, b, NewStdView())
}

// FromUCS returns CAM values from the given CAM16-UCS coordinates
// (jstar, astar, and bstar), using the given viewing conditions
func FromUCSView(j, a, b float32, vw *View) *CAM {
        m := math32.Sqrt(a*a + b*b)
        M := (math32.Exp(m*0.0228) - 1) / 0.0228
        c := M / vw.FLRoot
        h := math32.RadToDeg(math32.Atan2(b, a))
        if h < 0 {
                h += 360
        }
        j /= 1 - (j-100)*0.007

        return FromJCHView(j, c, h, vw)
}

// FromJCH returns CAM values from the given lightness (j), chroma (c),
// and hue (h) values under standard viewing condition
func FromJCH(j, c, h float32) *CAM {
        return FromJCHView(j, c, h, NewStdView())
}

// FromJCHView returns CAM values from the given lightness (j), chroma (c),
// and hue (h) values under the given viewing conditions
func FromJCHView(j, c, h float32, vw *View) *CAM {
        cam := &CAM{Lightness: j, Chroma: c, Hue: h}
        cam.Brightness = (4 / vw.C) *
                math32.Sqrt(cam.Lightness/100) *
                (vw.AW + 4) *
                (vw.FLRoot)
        cam.Colorfulness = cam.Chroma * vw.FLRoot
        alpha := cam.Chroma / math32.Sqrt(cam.Lightness/100)
        cam.Saturation = 50 * math32.Sqrt((alpha*vw.C)/(vw.AW+4))
        return cam
}

// FromSRGB returns CAM values from given SRGB color coordinates,
// under standard viewing conditions.  The RGB value range is 0-1,
// and RGB values have gamma correction.
func FromSRGB(r, g, b float32) *CAM {
        return FromXYZ(cie.SRGBToXYZ100(r, g, b))
}

// FromXYZ returns CAM values from given XYZ color coordinate,
// under standard viewing conditions
func FromXYZ(x, y, z float32) *CAM {
        return FromXYZView(x, y, z, NewStdView())
}

// FromXYZView returns CAM values from given XYZ color coordinate,
// under given viewing conditions.  Requires 100-base XYZ coordinates.
func FromXYZView(x, y, z float32, vw *View) *CAM {
        l, m, s := XYZToLMS(x, y, z)
        redVgreen, yellowVblue, grey, greyNorm := LMSToOps(l, m, s, vw)

        hue := SanitizeDegrees(math32.RadToDeg(math32.Atan2(yellowVblue, redVgreen)))
        // achromatic response to color
        ac := grey * vw.NBB

        // CAM16 lightness and brightness
        J := 100 * math32.Pow(ac/vw.AW, vw.C*vw.Z)
        Q := (4 / vw.C) * math32.Sqrt(J/100) * (vw.AW + 4) * (vw.FLRoot)

        huePrime := hue
        if hue < 20.14 {
                huePrime += 360
        }
        eHue := 0.25 * (math32.Cos(huePrime*math32.Pi/180+2) + 3.8)
        p1 := 50000 / 13 * eHue * vw.NC * vw.NCB
        t := p1 * math32.Sqrt(redVgreen*redVgreen+yellowVblue*yellowVblue) / (greyNorm + 0.305)
        alpha := math32.Pow(t, 0.9) * math32.Pow(1.64-math32.Pow(0.29, vw.BgYToWhiteY), 0.73)

        // CAM16 chroma, colorfulness, chroma
        C := alpha * math32.Sqrt(J/100)
        M := C * vw.FLRoot
        s = 50 * math32.Sqrt((alpha*vw.C)/(vw.AW+4))
        return &CAM{Hue: hue, Chroma: C, Colorfulness: M, Saturation: s, Brightness: Q, Lightness: J}
}

// XYZ returns the CAM color as XYZ coordinates
// under standard viewing conditions.
// Returns 100-base XYZ coordinates.
func (cam *CAM) XYZ() (x, y, z float32) {
        return cam.XYZView(NewStdView())
}

// XYZ returns the CAM color as XYZ coordinates
// under the given viewing conditions.
// Returns 100-base XYZ coordinates.
func (cam *CAM) XYZView(vw *View) (x, y, z float32) {
        alpha := float32(0)
        if cam.Chroma != 0 || cam.Lightness != 0 {
                alpha = cam.Chroma / math32.Sqrt(cam.Lightness/100)
        }

        t := math32.Pow(
                alpha/
                        math32.Pow(
                                1.64-
                                        math32.Pow(0.29, vw.BgYToWhiteY),
                                0.73),
                1.0/0.9)

        hRad := math32.DegToRad(cam.Hue)

        eHue := 0.25 * (math32.Cos(hRad+2) + 3.8)
        ac := vw.AW * math32.Pow(cam.Lightness/100, 1/vw.C/vw.Z)
        p1 := eHue * (50000 / 13) * vw.NC * vw.NCB

        p2 := ac / vw.NBB

        hSin := math32.Sin(hRad)
        hCos := math32.Cos(hRad)

        gamma := 23 *
                (p2 + 0.305) *
                t /
                (23*p1 + 11*t*hCos + 108*t*hSin)
        a := gamma * hCos
        b := gamma * hSin
        rA := (460*p2 + 451*a + 288*b) / 1403
        gA := (460*p2 - 891*a - 261*b) / 1403
        bA := (460*p2 - 220*a - 6300*b) / 1403

        rCBase := max(0, (27.13*num.Abs(rA))/(400-num.Abs(rA)))
        // TODO(kai): their sign function returns 0 for 0, but we return 1, so this might break
        rC := math32.Sign(rA) *
                (100 / vw.FL) *
                math32.Pow(rCBase, 1/0.42)
        gCBase := max(0, (27.13*num.Abs(gA))/(400-num.Abs(gA)))
        gC := math32.Sign(gA) *
                (100 / vw.FL) *
                math32.Pow(gCBase, 1/0.42)
        bCBase := max(0, (27.13*num.Abs(bA))/(400-num.Abs(bA)))
        bC := math32.Sign(bA) *
                (100 / vw.FL) *
                math32.Pow(bCBase, 1/0.42)
        rF := rC / vw.RGBD.X
        gF := gC / vw.RGBD.Y
        bF := bC / vw.RGBD.Z

        x = 1.86206786*rF - 1.01125463*gF + 0.14918677*bF
        y = 0.38752654*rF + 0.62144744*gF - 0.00897398*bF
        z = -0.01584150*rF - 0.03412294*gF + 1.04996444*bF
        return
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cam16

import (
        "cogentcore.org/core/math32"
)

// XYZToLMS converts XYZ to Long, Medium, Short cone-based responses,
// using the CAT16 transform from CIECAM16 color appearance model
// (LiLiWangEtAl17)
func XYZToLMS(x, y, z float32) (l, m, s float32) {
        l = x*0.401288 + y*0.650173 + z*-0.051461
        m = x*-0.250268 + y*1.204414 + z*0.045854
        s = x*-0.002079 + y*0.048952 + z*0.953127
        return
}

// LMSToXYZ converts Long, Medium, Short cone-based responses to XYZ
// using the CAT16 transform from CIECAM16 color appearance model
// (LiLiWangEtAl17)
func LMSToXYZ(l, m, s float32) (x, y, z float32) {
        x = l*1.86206787 + m*-1.0112563 + s*0.14918667
        y = l*0.38752654 + m*0.62144744 + s*-0.00897398
        z = l*-0.01584150 + m*-0.03412294 + s*1.04996444
        return
}

// LuminanceAdaptComp performs luminance adaptation
// and response compression according to the CAM16 model,
// on one component, using equations from HuntLiLuo03
// d = discount factor
// fl = luminance adaptation factor
func LuminanceAdaptComp(v, d, fl float32) float32 {
        vd := v * d
        f := math32.Pow((fl*math32.Abs(vd))/100, 0.42)
        return (math32.Sign(vd) * 400 * f) / (f + 27.13)
}

func InverseChromaticAdapt(adapted float32) float32 {
        adaptedAbs := math32.Abs(adapted)
        base := math32.Max(0, 27.13*adaptedAbs/(400.0-adaptedAbs))
        return math32.Sign(adapted) * math32.Pow(base, 1.0/0.42)
}

// LuminanceAdapt performs luminance adaptation
// and response compression according to the CAM16 model,
// on given r,g,b components, using equations from HuntLiLuo03
// and parameters on given viewing conditions
func LuminanceAdapt(l, m, s float32, vw *View) (lA, mA, sA float32) {
        lA = LuminanceAdaptComp(l, vw.RGBD.X, vw.FL)
        mA = LuminanceAdaptComp(m, vw.RGBD.Y, vw.FL)
        sA = LuminanceAdaptComp(s, vw.RGBD.Z, vw.FL)
        return
}

// LMSToOps converts Long, Medium, Short cone-based values to
// opponent redVgreen (a) and yellowVblue (b), and grey (achromatic) values,
// that more closely reflect neural responses.
// greyNorm is a normalizing grey factor used in the CAM16 model.
// l, m, s values must be in 100-base units.
// Uses the CIECAM16 color appearance model.
func LMSToOps(l, m, s float32, vw *View) (redVgreen, yellowVblue, grey, greyNorm float32) {
        // Discount illuminant and adapt
        lA, mA, sA := LuminanceAdapt(l, m, s, vw)
        redVgreen = (11*lA + -12*mA + sA) / 11
        yellowVblue = (lA + mA - 2*sA) / 9
        // auxiliary components
        grey = (40*lA + 20*mA + sA) / 20        // achromatic response, multiplied * view.NBB
        greyNorm = (20*lA + 20*mA + 21*sA) / 20 // normalizing factor
        return
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted from https://github.com/material-foundation/material-color-utilities
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cam16

import "cogentcore.org/core/math32"

// SanitizeDegrees ensures that degrees is in [0-360) range
func SanitizeDegrees(deg float32) float32 {
        if deg < 0 {
                return math32.Mod(deg, 360) + 360
        } else if deg >= 360 {
                return math32.Mod(deg, 360)
        }

        return deg
}

// SanitizeRadians sanitizes a small enough angle in radians.
// Takes an angle in radians; must not deviate too much from 0,
// and returns a coterminal angle between 0 and 2pi.
func SanitizeRadians(angle float32) float32 {
        return math32.Mod(angle+math32.Pi*8, math32.Pi*2)
}

// InCyclicOrder returns true a, b, c are in order around a circle
func InCyclicOrder(a, b, c float32) bool {
        delta_a_b := SanitizeRadians(b - a)
        delta_a_c := SanitizeRadians(c - a)
        return delta_a_b < delta_a_c
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cam16

import (
        "image/color"

        "cogentcore.org/core/colors/cam/cie"
        "cogentcore.org/core/math32"
)

// Blend returns a color that is the given percent blend between the first
// and second color; 10 = 10% of the first and 90% of the second, etc;
// blending is done directly on non-premultiplied CAM16-UCS values, and
// a correctly premultiplied color is returned.
func Blend(pct float32, x, y color.Color) color.RGBA {
        pct = math32.Clamp(pct, 0, 100)
        amt := pct / 100

        xsr, xsg, xsb, _ := cie.SRGBUint32ToFloat(x.RGBA())
        ysr, ysg, ysb, _ := cie.SRGBUint32ToFloat(y.RGBA())

        cx := FromSRGB(xsr, xsg, xsb)
        cy := FromSRGB(ysr, ysg, ysb)

        xj, _, xa, xb := cx.UCS()
        yj, _, ya, yb := cy.UCS()

        j := yj + (xj-yj)*amt
        a := ya + (xa-ya)*amt
        b := yb + (xb-yb)*amt

        cam := FromUCS(j, a, b)
        return cam.AsRGBA()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted from https://github.com/material-foundation/material-color-utilities
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cam16

import (
        "cogentcore.org/core/colors/cam/cie"
        "cogentcore.org/core/math32"
)

// View represents viewing conditions under which a color is being perceived,
// which greatly affects the subjective perception.  Defaults represent the
// standard defined such conditions, under which the CAM16 computations operate.
type View struct {

        // white point illumination -- typically cie.WhiteD65
        WhitePoint math32.Vector3

        // the ambient light strength in lux
        Luminance float32 `default:"200"`

        // the average luminance of 10 degrees around the color in question
        BgLuminance float32 `default:"50"`

        // the brightness of the entire environment
        Surround float32 `default:"2"`

        // whether the person's eyes have adapted to the lighting
        Adapted bool `default:"false"`

        // computed from Luminance
        AdaptingLuminance float32 `display:"-"`

        //
        BgYToWhiteY float32 `display:"-"`

        //
        AW float32 `display:"-"`

        // luminance level induction factor
        NBB float32 `display:"-"`

        // luminance level induction factor
        NCB float32 `display:"-"`

        // exponential nonlinearity
        C float32 `display:"-"`

        // chromatic induction factor
        NC float32 `display:"-"`

        // luminance-level adaptation factor, based on the HuntLiLuo03 equations
        FL float32 `display:"-"`

        // FL to the 1/4 power
        FLRoot float32 `display:"-"`

        // base exponential nonlinearity
        Z float32 `display:"-"`

        // inverse of the RGBD factors
        DRGBInverse math32.Vector3 `display:"-"`

        // cone responses to white point, adjusted for discounting
        RGBD math32.Vector3 `display:"-"`
}

// NewView returns a new view with all parameters initialized based on given major params
func NewView(whitePoint math32.Vector3, lum, bgLum, surround float32, adapt bool) *View {
        vw := &View{WhitePoint: whitePoint, Luminance: lum, BgLuminance: bgLum, Surround: surround, Adapted: adapt}
        vw.Update()
        return vw
}

// TheStdView is the standard viewing conditions view
// returned by NewStdView if already created.
var TheStdView *View

// NewStdView returns a new standard viewing conditions model
// returns TheStdView if already created
func NewStdView() *View {
        if TheStdView != nil {
                return TheStdView
        }
        TheStdView = NewView(cie.WhiteD65, 200, 50, 2, false)
        return TheStdView
}

// Update updates all the computed values based on main parameters
func (vw *View) Update() {
        vw.AdaptingLuminance = (vw.Luminance / math32.Pi) * (cie.LToY(50) / 100)
        // A background of pure black is non-physical and leads to infinities that
        // represent the idea that any color viewed in pure black can't be seen.
        vw.BgLuminance = math32.Max(0.1, vw.BgLuminance)

        // Transform test illuminant white in XYZ to 'cone'/'rgb' responses
        rW, gW, bW := XYZToLMS(vw.WhitePoint.X, vw.WhitePoint.Y, vw.WhitePoint.Z)

        // Scale input surround, domain (0, 2), to CAM16 surround, domain (0.8, 1.0)
        vw.Surround = math32.Clamp(vw.Surround, 0, 2)
        f := 0.8 + (vw.Surround / 10)
        // "Exponential non-linearity"
        if f >= 0.9 {
                vw.C = math32.Lerp(0.59, 0.69, ((f - 0.9) * 10))
        } else {
                vw.C = math32.Lerp(0.525, 0.59, ((f - 0.8) * 10))
        }
        // Calculate degree of adaptation to illuminant
        d := float32(1)
        if !vw.Adapted {
                d = f * (1 - ((1 / 3.6) * math32.Exp((-vw.AdaptingLuminance-42)/92)))
        }

        // Per Li et al, if D is greater than 1 or less than 0, set it to 1 or 0.
        d = math32.Clamp(d, 0, 1)

        // chromatic induction factor
        vw.NC = f

        // Cone responses to the whitePoint, r/g/b/W, adjusted for discounting.
        //
        // Why use 100 instead of the white point's relative luminance?
        //
        // Some papers and implementations, for both CAM02 and CAM16, use the Y
        // value of the reference white instead of 100. Fairchild's Color Appearance
        // Models (3rd edition) notes that this is in error: it was included in the
        // CIE 2004a report on CIECAM02, but, later parts of the conversion process
        // account for scaling of appearance relative to the white point relative
        // luminance. This part should simply use 100 as luminance.
        vw.RGBD.X = d*(100/rW) + 1 - d
        vw.RGBD.Y = d*(100/gW) + 1 - d
        vw.RGBD.Z = d*(100/bW) + 1 - d

        // Factor used in calculating meaningful factors
        k := 1 / (5*vw.AdaptingLuminance + 1)
        k4 := k * k * k * k
        k4F := 1 - k4

        // Luminance-level adaptation factor
        vw.FL = (k4 * vw.AdaptingLuminance) +
                (0.1 * k4F * k4F * math32.Pow(5*vw.AdaptingLuminance, 1.0/3.0))

        vw.FLRoot = math32.Pow(vw.FL, 0.25)

        // Intermediate factor, ratio of background relative luminance to white relative luminance
        n := cie.LToY(vw.BgLuminance) / vw.WhitePoint.Y
        vw.BgYToWhiteY = n

        // Base exponential nonlinearity
        // note Schlomer 2018 has a typo and uses 1.58, the correct factor is 1.48
        vw.Z = 1.48 + math32.Sqrt(n)

        // Luminance-level induction factors
        vw.NBB = 0.725 / math32.Pow(n, 0.2)
        vw.NCB = vw.NBB

        // Discounted cone responses to the white point, adjusted for post-saturation
        // adaptation perceptual nonlinearities.
        rA, gA, bA := LuminanceAdapt(rW, gW, bW, vw)

        vw.AW = ((40*rA + 20*gA + bA) / 20) * vw.NBB
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cie

import "cogentcore.org/core/math32"

// LABCompress does cube-root compression of the X, Y, Z components
// prior to performing the LAB conversion
func LABCompress(t float32) float32 {
        e := float32(216.0 / 24389.0)
        if t > e {
                return math32.Pow(t, 1.0/3.0)
        }
        kappa := float32(24389.0 / 27.0)
        return (kappa*t + 16) / 116
}

func LABUncompress(ft float32) float32 {
        e := float32(216.0 / 24389.0)
        ft3 := ft * ft * ft
        if ft3 > e {
                return ft3
        }
        kappa := float32(24389.0 / 27.0)
        return (116*ft - 16) / kappa
}

// XYZToLAB converts a color from XYZ to L*a*b* coordinates
// using the standard D65 illuminant
func XYZToLAB(x, y, z float32) (l, a, b float32) {
        x, y, z = XYZNormD65(x, y, z)
        fx := LABCompress(x)
        fy := LABCompress(y)
        fz := LABCompress(z)
        l = 116*fy - 16
        a = 500 * (fx - fy)
        b = 200 * (fy - fz)
        return
}

// LABToXYZ converts a color from L*a*b* to XYZ coordinates
// using the standard D65 illuminant
func LABToXYZ(l, a, b float32) (x, y, z float32) {
        fy := (l + 16) / 116
        fx := a/500 + fy
        fz := fy - b/200
        x = LABUncompress(fx)
        y = LABUncompress(fy)
        z = LABUncompress(fz)
        x, y, z = XYZDenormD65(x, y, z)
        return
}

// LToY Converts an L* value to a Y value.
// L* in L*a*b* and Y in XYZ measure the same quantity, luminance.
// L* measures perceptual luminance, a linear scale. Y in XYZ
// measures relative luminance, a logarithmic scale.
func LToY(l float32) float32 {
        return 100 * LABUncompress((l+16)/116)
}

// YToL Converts a Y value to an L* value.
// L* in L*a*b* and Y in XYZ measure the same quantity, luminance.
// L* measures perceptual luminance, a linear scale. Y in XYZ
// measures relative luminance, a logarithmic scale.
func YToL(y float32) float32 {
        return LABCompress(y/100)*116 - 16
}

// Copyright (c) 2021, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cie

import "cogentcore.org/core/math32"

// SRGBToLinearComp converts an sRGB rgb component to linear space (removes gamma).
// Used in converting from sRGB to XYZ colors.
func SRGBToLinearComp(srgb float32) float32 {
        if srgb <= 0.04045 {
                return srgb / 12.92
        }
        return math32.Pow((srgb+0.055)/1.055, 2.4)
}

// SRGBFromLinearComp converts an sRGB rgb linear component
// to non-linear (gamma corrected) sRGB value
// Used in converting from XYZ to sRGB.
func SRGBFromLinearComp(lin float32) float32 {
        var gv float32
        if lin <= 0.0031308 {
                gv = 12.92 * lin
        } else {
                gv = (1.055*math32.Pow(lin, 1.0/2.4) - 0.055)
        }
        return math32.Clamp(gv, 0, 1)
}

// SRGBToLinear converts set of sRGB components to linear values,
// removing gamma correction.
func SRGBToLinear(r, g, b float32) (rl, gl, bl float32) {
        rl = SRGBToLinearComp(r)
        gl = SRGBToLinearComp(g)
        bl = SRGBToLinearComp(b)
        return
}

// SRGB100ToLinear converts set of sRGB components to linear values,
// removing gamma correction.  returns 100-base RGB values
func SRGB100ToLinear(r, g, b float32) (rl, gl, bl float32) {
        rl = 100 * SRGBToLinearComp(r)
        gl = 100 * SRGBToLinearComp(g)
        bl = 100 * SRGBToLinearComp(b)
        return
}

// SRGBFromLinear converts set of sRGB components from linear values,
// adding gamma correction.
func SRGBFromLinear(rl, gl, bl float32) (r, g, b float32) {
        r = SRGBFromLinearComp(rl)
        g = SRGBFromLinearComp(gl)
        b = SRGBFromLinearComp(bl)
        return
}

// SRGBFromLinear100 converts set of sRGB components from linear values in 0-100 range,
// adding gamma correction.
func SRGBFromLinear100(rl, gl, bl float32) (r, g, b float32) {
        r = SRGBFromLinearComp(rl / 100)
        g = SRGBFromLinearComp(gl / 100)
        b = SRGBFromLinearComp(bl / 100)
        return
}

// SRGBFloatToUint8 converts the given non-alpha-premuntiplied sRGB float32
// values to alpha-premultiplied sRGB uint8 values.
func SRGBFloatToUint8(rf, gf, bf, af float32) (r, g, b, a uint8) {
        r = uint8(rf*af*255 + 0.5)
        g = uint8(gf*af*255 + 0.5)
        b = uint8(bf*af*255 + 0.5)
        a = uint8(af*255 + 0.5)
        return
}

// SRGBFloatToUint32 converts the given non-alpha-premuntiplied sRGB float32
// values to alpha-premultiplied sRGB uint32 values.
func SRGBFloatToUint32(rf, gf, bf, af float32) (r, g, b, a uint32) {
        r = uint32(rf*af*65535 + 0.5)
        g = uint32(gf*af*65535 + 0.5)
        b = uint32(bf*af*65535 + 0.5)
        a = uint32(af*65535 + 0.5)
        return
}

// SRGBUint8ToFloat converts the given alpha-premultiplied sRGB uint8 values
// to non-alpha-premuntiplied sRGB float32 values.
func SRGBUint8ToFloat(r, g, b, a uint8) (fr, fg, fb, fa float32) {
        fa = float32(a) / 255
        fr = (float32(r) / 255) / fa
        fg = (float32(g) / 255) / fa
        fb = (float32(b) / 255) / fa
        return
}

// SRGBUint32ToFloat converts the given alpha-premultiplied sRGB uint32 values
// to non-alpha-premuntiplied sRGB float32 values.
func SRGBUint32ToFloat(r, g, b, a uint32) (fr, fg, fb, fa float32) {
        fa = float32(a) / 65535
        fr = (float32(r) / 65535) / fa
        fg = (float32(g) / 65535) / fa
        fb = (float32(b) / 65535) / fa
        return
}

// Copyright (c) 2021, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cie

// SRGBLinToXYZ converts sRGB linear into XYZ CIE standard color space
func SRGBLinToXYZ(rl, gl, bl float32) (x, y, z float32) {
        x = 0.41233895*rl + 0.35762064*gl + 0.18051042*bl
        y = 0.2126*rl + 0.7152*gl + 0.0722*bl
        z = 0.01932141*rl + 0.11916382*gl + 0.95034478*bl
        return
}

// XYZToSRGBLin converts XYZ CIE standard color space to sRGB linear
func XYZToSRGBLin(x, y, z float32) (rl, gl, bl float32) {
        rl = 3.2406*x + -1.5372*y + -0.4986*z
        gl = -0.9689*x + 1.8758*y + 0.0415*z
        bl = 0.0557*x + -0.2040*y + 1.0570*z
        return
}

// SRGBToXYZ converts sRGB into XYZ CIE standard color space
func SRGBToXYZ(r, g, b float32) (x, y, z float32) {
        rl, gl, bl := SRGBToLinear(r, g, b)
        x, y, z = SRGBLinToXYZ(rl, gl, bl)
        return
}

// SRGBToXYZ100 converts sRGB into XYZ CIE standard color space
// with 100-base sRGB values -- used for CAM16 but not CAM02
func SRGBToXYZ100(r, g, b float32) (x, y, z float32) {
        rl, gl, bl := SRGB100ToLinear(r, g, b)
        x, y, z = SRGBLinToXYZ(rl, gl, bl)
        return
}

// XYZToSRGB converts XYZ CIE standard color space into sRGB
func XYZToSRGB(x, y, z float32) (r, g, b float32) {
        rl, bl, gl := XYZToSRGBLin(x, y, z)
        r, g, b = SRGBFromLinear(rl, bl, gl)
        return
}

// XYZ100ToSRGB converts XYZ CIE standard color space, 100 base units,
// into sRGB
func XYZ100ToSRGB(x, y, z float32) (r, g, b float32) {
        rl, bl, gl := XYZToSRGBLin(x/100, y/100, z/100)
        r, g, b = SRGBFromLinear(rl, bl, gl)
        return
}

// XYZNormD65 normalizes XZY values relative to the D65 outdoor white light values
func XYZNormD65(x, y, z float32) (xr, yr, zr float32) {
        xr = x / 0.95047
        zr = z / 1.08883
        yr = y
        return
}

// XYZDenormD65 de-normalizes XZY values relative to the D65 outdoor white light values
func XYZDenormD65(x, y, z float32) (xr, yr, zr float32) {
        xr = x * 0.95047
        zr = z * 1.08883
        yr = y
        return
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted from https://github.com/material-foundation/material-color-utilities
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package hct

import (
        "cogentcore.org/core/base/num"
        "cogentcore.org/core/colors/cam/cam16"
        "cogentcore.org/core/math32"
)

// double ChromaticAdaptation(double component) {
//   double af = pow(abs(component), 0.42);
//   return Signum(component) * 400.0 * af / (af + 27.13);
// }

func MatMul(v math32.Vector3, mat [3][3]float32) math32.Vector3 {
        x := v.X*mat[0][0] + v.Y*mat[0][1] + v.Z*mat[0][2]
        y := v.X*mat[1][0] + v.Y*mat[1][1] + v.Z*mat[1][2]
        z := v.X*mat[2][0] + v.Y*mat[2][1] + v.Z*mat[2][2]
        return math32.Vec3(x, y, z)
}

// HueOf Returns the hue of a linear RGB color in CAM16.
func HueOf(linrgb math32.Vector3) float32 {
        sd := MatMul(linrgb, kScaledDiscountFromLinrgb)
        rA := cam16.LuminanceAdaptComp(sd.X, 1, 1)
        gA := cam16.LuminanceAdaptComp(sd.Y, 1, 1)
        bA := cam16.LuminanceAdaptComp(sd.Z, 1, 1)

        // redness-greenness
        a := (11*rA + -12*gA + bA) / 11
        // yellowness-blueness
        b := (rA + gA - 2*bA) / 9
        return math32.Atan2(b, a)
}

// Solves the lerp equation.
// @param source The starting number.
// @param mid The number in the middle.
// @param target The ending number.
// @return A number t such that lerp(source, target, t) = mid.
func Intercept(source, mid, target float32) float32 {
        return (mid - source) / (target - source)
}

// GetAxis returns value along axis 0,1,2 -- result is divided by 100
// so that resulting numbers are in 0-1 range.
func GetAxis(v math32.Vector3, axis int) float32 {
        switch axis {
        case 0:
                return v.X
        case 1:
                return v.Y
        case 2:
                return v.Z
        default:
                return -1
        }
}

/**
 * Intersects a segment with a plane.
 *
 * @param source The coordinates of point A.
 * @param coordinate The R-, G-, or B-coordinate of the plane.
 * @param target The coordinates of point B.
 * @param axis The axis the plane is perpendicular with. (0: R, 1: G, 2: B)
 * @return The intersection point of the segment AB with the plane R=coordinate,
 * G=coordinate, or B=coordinate
 */
func SetCoordinate(source, target math32.Vector3, coord float32, axis int) math32.Vector3 {
        t := Intercept(GetAxis(source, axis), coord, GetAxis(target, axis))
        return source.Lerp(target, t)
}

func IsBounded(x float32) bool {
        return 0 <= x && x <= 100
}

// Returns the nth possible vertex of the polygonal intersection.
// @param y The Y value of the plane.
// @param n The zero-based index of the point. 0 <= n <= 11.
// @return The nth possible vertex of the polygonal intersection of the y plane
// and the RGB cube, in linear RGB coordinates, if it exists. If this possible
// vertex lies outside of the cube,
//
//        [-1.0, -1.0, -1.0] is returned.
func NthVertex(y float32, n int) math32.Vector3 {
        k_r := kYFromLinrgb[0]
        k_g := kYFromLinrgb[1]
        k_b := kYFromLinrgb[2]
        coord_a := float32(0)
        if n%4 > 1 {
                coord_a = 100
        }
        coord_b := float32(0)
        if n%2 != 0 {
                coord_b = 100
        }
        if n < 4 {
                g := coord_a
                b := coord_b
                r := (y - g*k_g - b*k_b) / k_r
                if IsBounded(r) {
                        return math32.Vec3(r, g, b)
                }
                return math32.Vec3(-1.0, -1.0, -1.0)

        } else if n < 8 {
                b := coord_a
                r := coord_b
                g := (y - r*k_r - b*k_b) / k_g
                if IsBounded(g) {
                        return math32.Vec3(r, g, b)
                }
                return math32.Vec3(-1.0, -1.0, -1.0)
        }
        r := coord_a
        g := coord_b
        b := (y - r*k_r - g*k_g) / k_b
        if IsBounded(b) {
                return math32.Vec3(r, g, b)
        }
        return math32.Vec3(-1.0, -1.0, -1.0)
}

// Finds the segment containing the desired color.
// @param y The Y value of the color.
// @param target_hue The hue of the color.
// @return A list of two sets of linear RGB coordinates, each corresponding to
// an endpoint of the segment containing the desired color.
func BisectToSegment(y, target_hue float32) [2]math32.Vector3 {
        left := math32.Vec3(-1.0, -1.0, -1.0)
        right := left
        left_hue := float32(0.0)
        right_hue := float32(0.0)
        initialized := false
        uncut := true
        for n := 0; n < 12; n++ {
                mid := NthVertex(y, n)
                if mid.X < 0 {
                        continue
                }
                mid_hue := HueOf(mid)
                if !initialized {
                        left = mid
                        right = mid
                        left_hue = mid_hue
                        right_hue = mid_hue
                        initialized = true
                        continue
                }
                if uncut || cam16.InCyclicOrder(left_hue, mid_hue, right_hue) {
                        uncut = false
                        if cam16.InCyclicOrder(left_hue, target_hue, mid_hue) {
                                right = mid
                                right_hue = mid_hue
                        } else {
                                left = mid
                                left_hue = mid_hue
                        }
                }
        }
        var out [2]math32.Vector3
        out[0] = left
        out[1] = right
        return out
}

func Midpoint(a, b math32.Vector3) math32.Vector3 {
        return math32.Vec3((a.X+b.X)/2, (a.Y+b.Y)/2, (a.Z+b.Z)/2)
}

func CriticalPlaneBelow(x float32) int { return int(math32.Floor(x - 0.5)) }

func CriticalPlaneAbove(x float32) int { return int(math32.Ceil(x - 0.5)) }

// Delinearizes an RGB component, returning a floating-point number.
// @param rgb_component 0.0 <= rgb_component <= 100.0, represents linear R/G/B
// channel
// @return 0.0 <= output <= 255.0, color channel converted to regular RGB space
func TrueDelinearized(comp float32) float32 {
        normalized := comp / 100
        delinearized := float32(0.0)
        if normalized <= 0.0031308 {
                delinearized = normalized * 12.92
        } else {
                delinearized = 1.055*math32.Pow(normalized, 1.0/2.4) - 0.055
        }
        return delinearized * 255
}

// Finds a color with the given Y and hue on the boundary of the cube.
// @param y The Y value of the color.
// @param target_hue The hue of the color.
// @return The desired color, in linear RGB coordinates.
func BisectToLimit(y, target_hue float32) math32.Vector3 {
        segment := BisectToSegment(y, target_hue)
        left := segment[0]
        left_hue := HueOf(left)
        right := segment[1]
        for axis := 0; axis < 3; axis++ {
                if GetAxis(left, axis) != GetAxis(right, axis) {
                        l_plane := -1
                        r_plane := 255
                        if GetAxis(left, axis) < GetAxis(right, axis) {
                                l_plane = CriticalPlaneBelow(TrueDelinearized(GetAxis(left, axis)))
                                r_plane = CriticalPlaneAbove(TrueDelinearized(GetAxis(right, axis)))
                        } else {
                                l_plane = CriticalPlaneAbove(TrueDelinearized(GetAxis(left, axis)))
                                r_plane = CriticalPlaneBelow(TrueDelinearized(GetAxis(right, axis)))
                        }
                        for i := 0; i < 8; i++ {
                                if num.Abs(r_plane-l_plane) <= 1 {
                                        break
                                }
                                m_plane := int(math32.Floor(float32(l_plane+r_plane) / 2.0))
                                mid_plane_coordinate := kCriticalPlanes[m_plane]
                                mid := SetCoordinate(left, right, mid_plane_coordinate, axis)
                                mid_hue := HueOf(mid)
                                if cam16.InCyclicOrder(left_hue, target_hue, mid_hue) {
                                        right = mid
                                        r_plane = m_plane
                                } else {
                                        left = mid
                                        left_hue = mid_hue
                                        l_plane = m_plane
                                }
                        }
                }
        }
        return Midpoint(left, right)
}

/////////////////////////////////////////////

var kScaledDiscountFromLinrgb = [3][3]float32{
        {
                0.001200833568784504,
                0.002389694492170889,
                0.0002795742885861124,
        },
        {
                0.0005891086651375999,
                0.0029785502573438758,
                0.0003270666104008398,
        },
        {
                0.00010146692491640572,
                0.0005364214359186694,
                0.0032979401770712076,
        },
}

var kLinrgbFromScaledDiscount = [3][3]float32{
        {
                1373.2198709594231,
                -1100.4251190754821,
                -7.278681089101213,
        },
        {
                -271.815969077903,
                559.6580465940733,
                -32.46047482791194,
        },
        {
                1.9622899599665666,
                -57.173814538844006,
                308.7233197812385,
        },
}

var kYFromLinrgb = [3]float32{0.2126, 0.7152, 0.0722}

var kCriticalPlanes = [255]float32{
        0.015176349177441876, 0.045529047532325624, 0.07588174588720938,
        0.10623444424209313, 0.13658714259697685, 0.16693984095186062,
        0.19729253930674434, 0.2276452376616281, 0.2579979360165119,
        0.28835063437139563, 0.3188300904430532, 0.350925934958123,
        0.3848314933096426, 0.42057480301049466, 0.458183274052838,
        0.4976837250274023, 0.5391024159806381, 0.5824650784040898,
        0.6277969426914107, 0.6751227633498623, 0.7244668422128921,
        0.775853049866786, 0.829304845476233, 0.8848452951698498,
        0.942497089126609, 1.0022825574869039, 1.0642236851973577,
        1.1283421258858297, 1.1946592148522128, 1.2631959812511864,
        1.3339731595349034, 1.407011200216447, 1.4823302800086415,
        1.5599503113873272, 1.6398909516233677, 1.7221716113234105,
        1.8068114625156377, 1.8938294463134073, 1.9832442801866852,
        2.075074464868551, 2.1693382909216234, 2.2660538449872063,
        2.36523901573795, 2.4669114995532007, 2.5710888059345764,
        2.6777882626779785, 2.7870270208169257, 2.898822059350997,
        3.0131901897720907, 3.1301480604002863, 3.2497121605402226,
        3.3718988244681087, 3.4967242352587946, 3.624204428461639,
        3.754355295633311, 3.887192587735158, 4.022731918402185,
        4.160988767090289, 4.301978482107941, 4.445716283538092,
        4.592217266055746, 4.741496401646282, 4.893568542229298,
        5.048448422192488, 5.20615066083972, 5.3666897647573375,
        5.5300801301023865, 5.696336044816294, 5.865471690767354,
        6.037501145825082, 6.212438385869475, 6.390297286737924,
        6.571091626112461, 6.7548350853498045, 6.941541251256611,
        7.131223617812143, 7.323895587840543, 7.5195704746346665,
        7.7182615035334345, 7.919981813454504, 8.124744458384042,
        8.332562408825165, 8.543448553206703, 8.757415699253682,
        8.974476575321063, 9.194643831691977, 9.417930041841839,
        9.644347703669503, 9.873909240696694, 10.106627003236781,
        10.342513269534024, 10.58158024687427, 10.8238400726681,
        11.069304815507364, 11.317986476196008, 11.569896988756009,
        11.825048221409341, 12.083451977536606, 12.345119996613247,
        12.610063955123938, 12.878295467455942, 13.149826086772048,
        13.42466730586372, 13.702830557985108, 13.984327217668513,
        14.269168601521828, 14.55736596900856, 14.848930523210871,
        15.143873411576273, 15.44220572664832, 15.743938506781891,
        16.04908273684337, 16.35764934889634, 16.66964922287304,
        16.985093187232053, 17.30399201960269, 17.62635644741625,
        17.95219714852476, 18.281524751807332, 18.614349837764564,
        18.95068293910138, 19.290534541298456, 19.633915083172692,
        19.98083495742689, 20.331304511189067, 20.685334046541502,
        21.042933821039977, 21.404114048223256, 21.76888489811322,
        22.137256497705877, 22.50923893145328, 22.884842241736916,
        23.264076429332462, 23.6469514538663, 24.033477234264016,
        24.42366364919083, 24.817520537484558, 25.21505769858089,
        25.61628489293138, 26.021211842414342, 26.429848230738664,
        26.842203703840827, 27.258287870275353, 27.678110301598522,
        28.10168053274597, 28.529008062403893, 28.96010235337422,
        29.39497283293396, 29.83362889318845, 30.276079891419332,
        30.722335150426627, 31.172403958865512, 31.62629557157785,
        32.08401920991837, 32.54558406207592, 33.010999283389665,
        33.4802739966603, 33.953417292456834, 34.430438229418264,
        34.911345834551085, 35.39614910352207, 35.88485700094671,
        36.37747846067349, 36.87402238606382, 37.37449765026789,
        37.87891309649659, 38.38727753828926, 38.89959975977785,
        39.41588851594697, 39.93615253289054, 40.460400508064545,
        40.98864111053629, 41.520882981230194, 42.05713473317016,
        42.597404951718396, 43.141702194811224, 43.6900349931913,
        44.24241185063697, 44.798841244188324, 45.35933162437017,
        45.92389141541209, 46.49252901546552, 47.065252796817916,
        47.64207110610409, 48.22299226451468, 48.808024568002054,
        49.3971762874833, 49.9904556690408, 50.587870934119984,
        51.189430279724725, 51.79514187861014, 52.40501387947288,
        53.0190544071392, 53.637271562750364, 54.259673423945976,
        54.88626804504493, 55.517063457223934, 56.15206766869424,
        56.79128866487574, 57.43473440856916, 58.08241284012621,
        58.734331877617365, 59.39049941699807, 60.05092333227251,
        60.715611475655585, 61.38457167773311, 62.057811747619894,
        62.7353394731159, 63.417162620860914, 64.10328893648692,
        64.79372614476921, 65.48848194977529, 66.18756403501224,
        66.89098006357258, 67.59873767827808, 68.31084450182222,
        69.02730813691093, 69.74813616640164, 70.47333615344107,
        71.20291564160104, 71.93688215501312, 72.67524319850172,
        73.41800625771542, 74.16517879925733, 74.9167682708136,
        75.67278210128072, 76.43322770089146, 77.1981124613393,
        77.96744375590167, 78.74122893956174, 79.51947534912904,
        80.30219030335869, 81.08938110306934, 81.88105503125999,
        82.67721935322541, 83.4778813166706, 84.28304815182372,
        85.09272707154808, 85.90692527145302, 86.72564993000343,
        87.54890820862819, 88.3767072518277, 89.2090541872801,
        90.04595612594655, 90.88742016217518, 91.73345337380438,
        92.58406282226491, 93.43925555268066, 94.29903859396902,
        95.16341895893969, 96.03240364439274, 96.9059996312159,
        97.78421388448044, 98.6670533535366, 99.55452497210776,
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted from https://github.com/material-foundation/material-color-utilities
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package hct

import (
        "image/color"

        "cogentcore.org/core/colors/cam/cie"
        "cogentcore.org/core/math32"
)

const (
        // ContrastAA is the contrast ratio required by WCAG AA for body text
        ContrastAA float32 = 4.5

        // ContrastLargeAA is the contrast ratio required by WCAG AA for large text
        // (at least 120-150% larger than the body text)
        ContrastLargeAA float32 = 3

        // ContrastGraphicsAA is the contrast ratio required by WCAG AA for graphical objects
        // and active user interface components like graphs, icons, and form input borders
        ContrastGraphicsAA float32 = 3

        // ContrastAAA is the contrast ratio required by WCAG AAA for body text
        ContrastAAA float32 = 7

        // ContrastLargeAAA is the contrast ratio required by WCAG AAA for large text
        // (at least 120-150% larger than the body text)
        ContrastLargeAAA float32 = 4.5
)

// ContrastRatio returns the contrast ratio between the given two colors.
// The contrast ratio will be between 1 and 21.
func ContrastRatio(a, b color.Color) float32 {
        ah := FromColor(a)
        bh := FromColor(b)
        return ToneContrastRatio(ah.Tone, bh.Tone)
}

// ToneContrastRatio returns the contrast ratio between the given two tones.
// The contrast ratio will be between 1 and 21, and the tones should be
// between 0 and 100 and will be clamped to such.
func ToneContrastRatio(a, b float32) float32 {
        a = math32.Clamp(a, 0, 100)
        b = math32.Clamp(b, 0, 100)
        return ContrastRatioOfYs(cie.LToY(a), cie.LToY(b))
}

// ContrastColor returns the color that will ensure that the given contrast ratio
// between the given color and the resulting color is met. If the given ratio can
// not be achieved with the given color, it returns the color that would result in
// the highest contrast ratio. The ratio must be between 1 and 21. If the tone of
// the given color is greater than 50, it tries darker tones first, and otherwise
// it tries lighter tones first.
func ContrastColor(c color.Color, ratio float32) color.RGBA {
        h := FromColor(c)
        ct := ContrastTone(h.Tone, ratio)
        return h.WithTone(ct).AsRGBA()
}

// ContrastColorTry returns the color that will ensure that the given contrast ratio
// between the given color and the resulting color is met. It returns color.RGBA{}, false if
// the given ratio can not be achieved with the given color. The ratio must be between
// 1 and 21. If the tone of the given color is greater than 50, it tries darker tones first,
// and otherwise it tries lighter tones first.
func ContrastColorTry(c color.Color, ratio float32) (color.RGBA, bool) {
        h := FromColor(c)
        ct, ok := ContrastToneTry(h.Tone, ratio)
        if !ok {
                return color.RGBA{}, false
        }
        return h.WithTone(ct).AsRGBA(), true
}

// ContrastTone returns the tone that will ensure that the given contrast ratio
// between the given tone and the resulting tone is met. If the given ratio can
// not be achieved with the given tone, it returns the tone that would result in
// the highest contrast ratio. The tone must be between 0 and 100 and the ratio must be
// between 1 and 21. If the given tone is greater than 50, it tries darker tones first,
// and otherwise it tries lighter tones first.
func ContrastTone(tone, ratio float32) float32 {
        ct, ok := ContrastToneTry(tone, ratio)
        if ok {
                return ct
        }
        dcr := ToneContrastRatio(tone, 0)
        lcr := ToneContrastRatio(tone, 100)
        if dcr > lcr {
                return 0
        }
        return 100
}

// ContrastToneTry returns the tone that will ensure that the given contrast ratio
// between the given tone and the resulting tone is met. It returns -1, false if
// the given ratio can not be achieved with the given tone. The tone must be between 0
// and 100 and the ratio must be between 1 and 21. If the given tone is greater than 50,
// it tries darker tones first, and otherwise it tries lighter tones first.
func ContrastToneTry(tone, ratio float32) (float32, bool) {
        if tone > 50 {
                d, ok := ContrastToneDarkerTry(tone, ratio)
                if ok {
                        return d, true
                }
                l, ok := ContrastToneLighterTry(tone, ratio)
                if ok {
                        return l, true
                }
                return -1, false
        }

        l, ok := ContrastToneLighterTry(tone, ratio)
        if ok {
                return l, true
        }
        d, ok := ContrastToneDarkerTry(tone, ratio)
        if ok {
                return d, true
        }
        return -1, false
}

// ContrastToneLighter returns a tone greater than or equal to the given tone
// that ensures that given contrast ratio between the two tones is met.
// It returns 100 if the given ratio can not be achieved with the
// given tone. The tone must be between 0 and 100 and the ratio must be
// between 1 and 21.
func ContrastToneLighter(tone, ratio float32) float32 {
        safe, ok := ContrastToneLighterTry(tone, ratio)
        if ok {
                return safe
        }
        return 100
}

// ContrastToneDarker returns a tone less than or equal to the given tone
// that ensures that given contrast ratio between the two tones is met.
// It returns 0 if the given ratio can not be achieved with the
// given tone. The tone must be between 0 and 100 and the ratio must be
// between 1 and 21.
func ContrastToneDarker(tone, ratio float32) float32 {
        safe, ok := ContrastToneDarkerTry(tone, ratio)
        if ok {
                return safe
        }
        return 0
}

// ContrastToneLighterTry returns a tone greater than or equal to the given tone
// that ensures that given contrast ratio between the two tones is met.
// It returns -1, false if the given ratio can not be achieved with the
// given tone. The tone must be between 0 and 100 and the ratio must be
// between 1 and 21.
func ContrastToneLighterTry(tone, ratio float32) (float32, bool) {
        if tone < 0 || tone > 100 {
                return -1, false
        }

        darkY := cie.LToY(tone)
        lightY := ratio*(darkY+5) - 5
        realContrast := ContrastRatioOfYs(lightY, darkY)
        delta := math32.Abs(realContrast - ratio)
        if realContrast < ratio && delta > 0.04 {
                return -1, false
        }

        // TODO(kai/cam): this +0.4 explained by the comment below only seems to cause problems
        // Ensure gamut mapping, which requires a 'range' on tone, will still result
        // the correct ratio by darkening slightly.
        ret := cie.YToL(lightY) // + 0.4
        if ret < 0 || ret > 100 {
                return -1, false
        }
        return ret, true
}

// ContrastToneDarkerTry returns a tone less than or equal to the given tone
// that ensures that given contrast ratio between the two tones is met.
// It returns -1, false if the given ratio can not be achieved with the
// given tone. The tone must be between 0 and 100 and the ratio must be
// between 1 and 21.
func ContrastToneDarkerTry(tone, ratio float32) (float32, bool) {
        if tone < 0 || tone > 100 {
                return -1, false
        }

        lightY := cie.LToY(tone)
        darkY := ((lightY + 5) / ratio) - 5
        realContrast := ContrastRatioOfYs(lightY, darkY)
        delta := math32.Abs(realContrast - ratio)
        if realContrast < ratio && delta > 0.04 {
                return -1, false
        }

        // TODO(kai/cam): this -0.4 explained by the comment below only seems to cause problems
        // Ensure gamut mapping, which requires a 'range' on tone, will still result
        // the correct ratio by darkening slightly.
        ret := cie.YToL(darkY) // - 0.4
        if ret < 0 || ret > 100 {
                return -1, false
        }
        return ret, true
}

// ContrastRatioOfYs returns the contrast ratio of two XYZ Y values.
func ContrastRatioOfYs(a, b float32) float32 {
        lighter := max(a, b)
        darker := min(a, b)
        return (lighter + 5) / (darker + 5)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted from https://github.com/material-foundation/material-color-utilities
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package hct

import (
        "fmt"
        "image/color"

        "cogentcore.org/core/colors/cam/cam16"
        "cogentcore.org/core/colors/cam/cie"
)

// HCT represents a color as hue, chroma, and tone. HCT is a color system
// that provides a perceptually accurate color measurement system that can
// also accurately render what colors will appear as in different lighting
// environments. Directly setting the values of the HCT and RGB fields will
// have no effect on the underlying color; instead, use the Set methods
// ([HCT.SetHue], etc). The A field (transparency) can be set directly.
type HCT struct {

        // Hue (h) is the spectral identity of the color
        // (red, green, blue etc) in degrees (0-360)
        Hue float32 `min:"0" max:"360"`

        // Chroma (C) is the colorfulness/saturation of the color.
        // Grayscale colors have no chroma, and fully saturated ones
        // have high chroma. The maximum varies as a function of hue
        // and tone, but 120 is a general upper bound (see
        // [HCT.MaximumChroma] to get a specific value).
        Chroma float32 `min:"0" max:"120"`

        // Tone is the L* component from the LAB (L*a*b*) color system,
        // which is linear in human perception of lightness.
        // It ranges from 0 to 100.
        Tone float32 `min:"0" max:"100"`

        // sRGB standard gamma-corrected 0-1 normalized RGB representation
        // of the color. Critically, components are not premultiplied by alpha.
        R, G, B, A float32
}

// New returns a new HCT representation for given parameters:
// hue = 0..360
// chroma = 0..? depends on other params
// tone = 0..100
// also computes and sets the sRGB normalized, gamma corrected RGB values
// while keeping the sRGB representation within its gamut,
// which may cause the chroma to decrease until it is inside the gamut.
func New(hue, chroma, tone float32) HCT {
        r, g, b := SolveToRGB(hue, chroma, tone)
        return SRGBToHCT(r, g, b)
}

// FromColor constructs a new HCT color from a standard [color.Color].
func FromColor(c color.Color) HCT {
        return Uint32ToHCT(c.RGBA())
}

// SetColor sets the HCT color from a standard [color.Color].
func (h *HCT) SetColor(c color.Color) {
        *h = FromColor(c)
}

// Model is the standard [color.Model] that converts colors to HCT.
var Model = color.ModelFunc(model)

func model(c color.Color) color.Color {
        if h, ok := c.(HCT); ok {
                return h
        }
        return FromColor(c)
}

// RGBA implements the color.Color interface.
// Performs the premultiplication of the RGB components by alpha at this point.
func (h HCT) RGBA() (r, g, b, a uint32) {
        return cie.SRGBFloatToUint32(h.R, h.G, h.B, h.A)
}

// AsRGBA returns a standard color.RGBA type
func (h HCT) AsRGBA() color.RGBA {
        r, g, b, a := cie.SRGBFloatToUint8(h.R, h.G, h.B, h.A)
        return color.RGBA{r, g, b, a}
}

// SetUint32 sets components from unsigned 32bit integers (alpha-premultiplied)
func (h *HCT) SetUint32(r, g, b, a uint32) {
        fr, fg, fb, fa := cie.SRGBUint32ToFloat(r, g, b, a)
        *h = SRGBAToHCT(fr, fg, fb, fa)
}

// SetHue sets the hue of this color. Chroma may decrease because chroma has a
// different maximum for any given hue and tone.
// 0 <= hue < 360; invalid values are corrected.
func (h *HCT) SetHue(hue float32) *HCT {
        r, g, b := SolveToRGB(hue, h.Chroma, h.Tone)
        *h = SRGBAToHCT(r, g, b, h.A)
        return h
}

// WithHue is like [SetHue] except it returns a new color
// instead of setting the existing one.
func (h HCT) WithHue(hue float32) HCT {
        r, g, b := SolveToRGB(hue, h.Chroma, h.Tone)
        return SRGBAToHCT(r, g, b, h.A)
}

// SetChroma sets the chroma of this color (0 to max that depends on other params),
// while keeping the sRGB representation within its gamut,
// which may cause the chroma to decrease until it is inside the gamut.
func (h *HCT) SetChroma(chroma float32) *HCT {
        r, g, b := SolveToRGB(h.Hue, chroma, h.Tone)
        *h = SRGBAToHCT(r, g, b, h.A)
        return h
}

// WithChroma is like [SetChroma] except it returns a new color
// instead of setting the existing one.
func (h HCT) WithChroma(chroma float32) HCT {
        r, g, b := SolveToRGB(h.Hue, chroma, h.Tone)
        return SRGBAToHCT(r, g, b, h.A)
}

// SetTone sets the tone of this color (0 < tone < 100),
// while keeping the sRGB representation within its gamut,
// which may cause the chroma to decrease until it is inside the gamut.
func (h *HCT) SetTone(tone float32) *HCT {
        r, g, b := SolveToRGB(h.Hue, h.Chroma, tone)
        *h = SRGBAToHCT(r, g, b, h.A)
        return h
}

// WithTone is like [SetTone] except it returns a new color
// instead of setting the existing one.
func (h HCT) WithTone(tone float32) HCT {
        r, g, b := SolveToRGB(h.Hue, h.Chroma, tone)
        return SRGBAToHCT(r, g, b, h.A)
}

// MaximumChroma returns the maximum [HCT.Chroma] value for the hue
// and tone of this color. This will always be between 0 and 120.
func (h HCT) MaximumChroma() float32 {
        // WithChroma does a round trip, so the resultant chroma will only
        // be as high as the maximum chroma.
        return h.WithChroma(120).Chroma
}

// SRGBAToHCT returns an HCT from the given SRGBA color coordinates
// under standard viewing conditions. The RGB value range is 0-1,
// and RGB values have gamma correction. The RGB values must not be
// premultiplied by the given alpha value. See [SRGBToHCT] for
// a version that does not take the alpha value.
func SRGBAToHCT(r, g, b, a float32) HCT {
        h := SRGBToHCT(r, g, b)
        h.A = a
        return h
}

// SRGBToHCT returns an HCT from the given SRGB color coordinates
// under standard viewing conditions. The RGB value range is 0-1,
// and RGB values have gamma correction. Alpha is always 1; see
// [SRGBAToHCT] for a version that takes the alpha value.
func SRGBToHCT(r, g, b float32) HCT {
        x, y, z := cie.SRGBToXYZ(r, g, b)
        cam := cam16.FromXYZ(100*x, 100*y, 100*z)
        l, _, _ := cie.XYZToLAB(x, y, z)
        return HCT{Hue: cam.Hue, Chroma: cam.Chroma, Tone: l, R: r, G: g, B: b, A: 1}
}

// Uint32ToHCT returns an HCT from given SRGBA uint32 color coordinates,
// which are used for interchange among image.Color types.
// Uses standard viewing conditions, and RGB values already have gamma correction
// (i.e., they are SRGB values).
func Uint32ToHCT(r, g, b, a uint32) HCT {
        h := HCT{}
        h.SetUint32(r, g, b, a)
        return h
}

func (h HCT) String() string {
        return fmt.Sprintf("hct(%g, %g, %g)", h.Hue, h.Chroma, h.Tone)
}

/*
  // Translate a color into different [ViewingConditions].
  //
  // Colors change appearance. They look different with lights on versus off,
  // the same color, as in hex code, on white looks different when on black.
  // This is called color relativity, most famously explicated by Josef Albers
  // in Interaction of Color.
  //
  // In color science, color appearance models can account for this and
  // calculate the appearance of a color in different settings. HCT is based on
  // CAM16, a color appearance model, and uses it to make these calculations.
  //
  // See [ViewingConditions.make] for parameters affecting color appearance.
  Hct inViewingConditions(ViewingConditions vc) {
    // 1. Use CAM16 to find XYZ coordinates of color in specified VC.
    final cam16 = Cam16.fromInt(toInt());
    final viewedInVc = cam16.xyzInViewingConditions(vc);

    // 2. Create CAM16 of those XYZ coordinates in default VC.
    final recastInVc = Cam16.fromXyzInViewingConditions(
      viewedInVc[0],
      viewedInVc[1],
      viewedInVc[2],
      ViewingConditions.make(),
    );

    // 3. Create HCT from:
    // - CAM16 using default VC with XYZ coordinates in specified VC.
    // - L* converted from Y in XYZ coordinates in specified VC.
    final recastHct = Hct.from(
      recastInVc.hue,
      recastInVc.chroma,
      ColorUtils.lstarFromY(viewedInVc[1]),
    );
    return recastHct;
  }
}

*/

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Adapted from https://github.com/material-foundation/material-color-utilities
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package hct

import (
        "cogentcore.org/core/colors/cam/cam16"
        "cogentcore.org/core/colors/cam/cie"
        "cogentcore.org/core/math32"
)

// SolveToRGBLin Finds an sRGB linear color (represented by math32.Vector3, 0-100 range)
// with the given hue, chroma, and tone, if possible.
// if not possible to represent the target values, the hue and tone will be
// sufficiently close, and chroma will be maximized.
func SolveToRGBLin(hue, chroma, tone float32) math32.Vector3 {
        if chroma < 0.0001 || tone < 0.0001 || tone > 99.9999 {
                y := cie.LToY(tone)
                return math32.Vec3(y, y, y)
        }
        tone = math32.Clamp(tone, 0, 100)
        hue_deg := cam16.SanitizeDegrees(hue)
        hue_rad := math32.DegToRad(hue_deg)
        y := cie.LToY(tone)
        exact := FindResultByJ(hue_rad, chroma, y)
        if exact != nil {
                return *exact
        }
        return BisectToLimit(y, hue_rad)
}

// SolveToRGB Finds an sRGB (gamma corrected, 0-1 range) color
// with the given hue, chroma, and tone, if possible.
// if not possible to represent the target values, the hue and tone will be
// sufficiently close, and chroma will be maximized.
func SolveToRGB(hue, chroma, tone float32) (r, g, b float32) {
        lin := SolveToRGBLin(hue, chroma, tone)
        r, g, b = cie.SRGBFromLinear100(lin.X, lin.Y, lin.Z)
        return
}

// Finds a color with the given hue, chroma, and Y.
// @param hue_radians The desired hue in radians.
// @param chroma The desired chroma.
// @param y The desired Y.
// @return The desired color as linear sRGB values.
func FindResultByJ(hue_rad, chroma, y float32) *math32.Vector3 {
        // Initial estimate of j.
        j := math32.Sqrt(y) * 11

        // ===========================================================
        // Operations inlined from Cam16 to avoid repeated calculation
        // ===========================================================
        vw := cam16.NewStdView()
        t_inner_coeff := 1 / math32.Pow(1.64-math32.Pow(0.29, vw.BgYToWhiteY), 0.73)
        e_hue := 0.25 * (math32.Cos(hue_rad+2) + 3.8)
        p1 := e_hue * (50000 / 13) * vw.NC * vw.NCB
        h_sin := math32.Sin(hue_rad)
        h_cos := math32.Cos(hue_rad)
        for itr := 0; itr < 5; itr++ {
                j_norm := j / 100
                alpha := float32(0)
                if !(chroma == 0 || j == 0) {
                        alpha = chroma / math32.Sqrt(j_norm)
                }
                t := math32.Pow(alpha*t_inner_coeff, 1/0.9)
                ac := vw.AW * math32.Pow(j_norm, 1/vw.C/vw.Z)
                p2 := ac / vw.NBB
                gamma := 23 * (p2 + 0.305) * t / (23*p1 + 11*t*h_cos + 108*t*h_sin)
                a := gamma * h_cos
                b := gamma * h_sin
                r_a := (460*p2 + 451*a + 288*b) / 1403
                g_a := (460*p2 - 891*a - 261*b) / 1403
                b_a := (460*p2 - 220*a - 6300*b) / 1403
                r_c_scaled := cam16.InverseChromaticAdapt(r_a)
                g_c_scaled := cam16.InverseChromaticAdapt(g_a)
                b_c_scaled := cam16.InverseChromaticAdapt(b_a)
                scaled := math32.Vec3(r_c_scaled, g_c_scaled, b_c_scaled)
                linrgb := MatMul(scaled, kLinrgbFromScaledDiscount)

                if linrgb.X < 0 || linrgb.Y < 0 || linrgb.Z < 0 {
                        return nil
                }
                k_r := kYFromLinrgb[0]
                k_g := kYFromLinrgb[1]
                k_b := kYFromLinrgb[2]
                fnj := k_r*linrgb.X + k_g*linrgb.Y + k_b*linrgb.Z
                if fnj <= 0 {
                        return nil
                }
                if itr == 4 || math32.Abs(fnj-y) < 0.002 {
                        if linrgb.X > 100.01 || linrgb.Y > 100.01 || linrgb.Z > 100.01 {
                                return nil
                        }
                        return &linrgb
                }
                // Iterates with Newton method,
                // Using 2 * fn(j) / j as the approximation of fn'(j)
                j = j - (fnj-y)*j/(2*fnj)
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package hct

import (
        "image/color"

        "cogentcore.org/core/math32"
)

// Lighten returns a color that is lighter by the
// given absolute HCT tone amount (0-100, ranges enforced)
func Lighten(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.SetTone(h.Tone + amount)
        return h.AsRGBA()
}

// Darken returns a color that is darker by the
// given absolute HCT tone amount (0-100, ranges enforced)
func Darken(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.SetTone(h.Tone - amount)
        return h.AsRGBA()
}

// Highlight returns a color that is lighter or darker by the
// given absolute HCT tone amount (0-100, ranges enforced),
// making the color darker if it is light (tone >= 50) and
// lighter otherwise. It is the opposite of [Samelight].
func Highlight(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        if h.Tone >= 50 {
                h.SetTone(h.Tone - amount)
        } else {
                h.SetTone(h.Tone + amount)
        }
        return h.AsRGBA()
}

// Samelight returns a color that is lighter or darker by the
// given absolute HCT tone amount (0-100, ranges enforced),
// making the color lighter if it is light (tone >= 50) and
// darker otherwise. It is the opposite of [Highlight].
func Samelight(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        if h.Tone >= 50 {
                h.SetTone(h.Tone + amount)
        } else {
                h.SetTone(h.Tone - amount)
        }
        return h.AsRGBA()
}

// Saturate returns a color that is more saturated by the
// given absolute HCT chroma amount (0-max that depends
// on other params but is around 150, ranges enforced)
func Saturate(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.SetChroma(h.Chroma + amount)
        return h.AsRGBA()
}

// Desaturate returns a color that is less saturated by the
// given absolute HCT chroma amount (0-max that depends
// on other params but is around 150, ranges enforced)
func Desaturate(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.SetChroma(h.Chroma - amount)
        return h.AsRGBA()
}

// Spin returns a color that has a different hue by the
// given absolute HCT hue amount (±0-360, ranges enforced)
func Spin(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.SetHue(h.Hue + amount)
        return h.AsRGBA()
}

// MinHueDistance finds the minimum distance between two hues.
// A positive number means add to a to get to b.
// A negative number means subtract from a to get to b.
func MinHueDistance(a, b float32) float32 {
        d1 := b - a
        d2 := (b + 360) - a
        d3 := (b - (a + 360))
        d1a := math32.Abs(d1)
        d2a := math32.Abs(d2)
        d3a := math32.Abs(d3)
        if d1a < d2a && d1a < d3a {
                return d1
        }
        if d2a < d1a && d2a < d3a {
                return d2
        }
        return d3
}

// Blend returns a color that is the given percent blend between the first
// and second color; 10 = 10% of the first and 90% of the second, etc;
// blending is done directly on non-premultiplied HCT values, and
// a correctly premultiplied color is returned.
func Blend(pct float32, x, y color.Color) color.RGBA {
        hx := FromColor(x)
        hy := FromColor(y)
        pct = math32.Clamp(pct, 0, 100)
        px := pct / 100
        py := 1 - px

        dhue := MinHueDistance(hx.Hue, hy.Hue)

        // weight as a function of chroma strength: if near grey, hue is unreliable
        cpy := py * hy.Chroma / (px*hx.Chroma + py*hy.Chroma)
        hue := hx.Hue + cpy*dhue

        chroma := px*hx.Chroma + py*hy.Chroma
        tone := px*hx.Tone + py*hy.Tone
        hr := New(hue, chroma, tone)
        hr.A = px*hx.A + py*hy.A
        return hr.AsRGBA()
}

// IsLight returns whether the given color is light
// (has an HCT tone greater than or equal to 50)
func IsLight(c color.Color) bool {
        h := FromColor(c)
        return h.Tone >= 50
}

// IsDark returns whether the given color is dark
// (has an HCT tone less than 50)
func IsDark(c color.Color) bool {
        h := FromColor(c)
        return h.Tone < 50
}

// Copyright (c) 2021, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package hpe

import "cogentcore.org/core/colors/cam/cie"

// XYZToLMS convert XYZ to Long, Medium, Short cone-based responses,
// using the Hunt-Pointer-Estevez transform.
// This is closer to the actual response functions of the L,M,S cones apparently.
func XYZToLMS(x, y, z float32) (l, m, s float32) {
        l = 0.38971*x + 0.68898*y + -0.07868*z
        m = -0.22981*x + 1.18340*y + 0.04641*z
        s = z
        return
}

// SRGBLinToLMS converts sRGB linear to Long, Medium, Short cone-based responses,
// using the Hunt-Pointer-Estevez transform.
// This is closer to the actual response functions of the L,M,S cones apparently.
func SRGBLinToLMS(rl, gl, bl float32) (l, m, s float32) {
        l = 0.30567503*rl + 0.62274014*gl + 0.04530167*bl
        m = 0.15771291*rl + 0.7697197*gl + 0.08807348*bl
        s = 0.0193*rl + 0.1192*gl + 0.9505*bl
        return
}

// SRGBToLMS converts sRGB to Long, Medium, Short cone-based responses,
// using the Hunt-Pointer-Estevez transform.
// This is closer to the actual response functions of the L,M,S cones apparently.
func SRGBToLMS(r, g, b float32) (l, m, s float32) {
        rl, gl, bl := cie.SRGBToLinear(r, g, b)
        l, m, s = SRGBLinToLMS(rl, gl, bl)
        return
}

/*
  func LMStoXYZ(float& X, float& Y, float& Z,
                                    L, M, S) {
    X = 1.096124f * L + 0.4296f * Y + -0.1624f * Z;
    Y = -0.7036f * X + 1.6975f * Y + 0.0061f * Z;
    Z = 0.0030f * X + 0.0136f * Y + 0.9834 * Z;
  }
  // convert Long, Medium, Short cone-based responses to XYZ, using the Hunt-Pointer-Estevez transform -- this is closer to the actual response functions of the L,M,S cones apparently
*/

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package hsl

import (
        "fmt"
        "image/color"

        "cogentcore.org/core/math32"
)

// HSL represents the Hue [0..360], Saturation [0..1], and Luminance
// (lightness) [0..1] of the color using float32 values
// In general the Alpha channel is not used for HSL but is maintained
// so it can be used to fully represent an RGBA color value.
// When converting to RGBA, alpha multiplies the RGB components.
type HSL struct {

        // the hue of the color
        H float32 `min:"0" max:"360" step:"5"`

        // the saturation of the color
        S float32 `min:"0" max:"1" step:"0.05"`

        // the luminance (lightness) of the color
        L float32 `min:"0" max:"1" step:"0.05"`

        // the transparency of the color
        A float32 `min:"0" max:"1" step:"0.05"`
}

// New returns a new HSL representation for given parameters:
// hue = 0..360
// saturation = 0..1
// lightness = 0..1
// A is automatically set to 1
func New(hue, saturation, lightness float32) HSL {
        return HSL{hue, saturation, lightness, 1}
}

// FromColor constructs a new HSL color from a standard [color.Color]
func FromColor(c color.Color) HSL {
        h := HSL{}
        h.SetColor(c)
        return h
}

// Model is the standard [color.Model] that converts colors to HSL.
var Model = color.ModelFunc(model)

func model(c color.Color) color.Color {
        if h, ok := c.(HSL); ok {
                return h
        }
        return FromColor(c)
}

// Implements the [color.Color] interface
// Performs the premultiplication of the RGB components by alpha at this point.
func (h HSL) RGBA() (r, g, b, a uint32) {
        fr, fg, fb := HSLtoRGBF32(h.H, h.S, h.L)
        r = uint32(fr*h.A*65535.0 + 0.5)
        g = uint32(fg*h.A*65535.0 + 0.5)
        b = uint32(fb*h.A*65535.0 + 0.5)
        a = uint32(h.A*65535.0 + 0.5)
        return
}

// AsRGBA returns a standard color.RGBA type
func (h HSL) AsRGBA() color.RGBA {
        fr, fg, fb := HSLtoRGBF32(h.H, h.S, h.L)
        return color.RGBA{uint8(fr*h.A*255.0 + 0.5), uint8(fg*h.A*255.0 + 0.5), uint8(fb*h.A*255.0 + 0.5), uint8(h.A*255.0 + 0.5)}
}

// SetUint32 sets components from unsigned 32bit integers (alpha-premultiplied)
func (h *HSL) SetUint32(r, g, b, a uint32) {
        fa := float32(a) / 65535.0
        fr := (float32(r) / 65535.0) / fa
        fg := (float32(g) / 65535.0) / fa
        fb := (float32(b) / 65535.0) / fa

        h.H, h.S, h.L = RGBtoHSLF32(fr, fg, fb)
        h.A = fa
}

// SetColor sets from a standard color.Color
func (h *HSL) SetColor(ci color.Color) {
        if ci == nil {
                *h = HSL{}
                return
        }
        r, g, b, a := ci.RGBA()
        h.SetUint32(r, g, b, a)
}

// HSLtoRGBF32 converts HSL values to RGB float32 0..1 values (non alpha-premultiplied) -- based on https://stackoverflow.com/questions/2353211/hsl-to-rgb-color-conversion, https://www.w3.org/TR/css-color-3/ and github.com/lucasb-eyer/go-colorful
func HSLtoRGBF32(h, s, l float32) (r, g, b float32) {
        if s == 0 {
                r = l
                g = l
                b = l
                return
        }

        h = h / 360.0 // convert to normalized 0-1 h
        var q float32
        if l < 0.5 {
                q = l * (1.0 + s)
        } else {
                q = l + s - l*s
        }
        p := 2.0*l - q
        r = HueToRGBF32(p, q, h+1.0/3.0)
        g = HueToRGBF32(p, q, h)
        b = HueToRGBF32(p, q, h-1.0/3.0)
        return
}

func HueToRGBF32(p, q, t float32) float32 {
        if t < 0 {
                t++
        }
        if t > 1 {
                t--
        }
        if t < 1.0/6.0 {
                return p + (q-p)*6.0*t
        }
        if t < .5 {
                return q
        }
        if t < 2.0/3.0 {
                return p + (q-p)*(2.0/3.0-t)*6.0
        }
        return p
}

// RGBtoHSLF32 converts RGB 0..1 values (non alpha-premultiplied) to HSL -- based on https://stackoverflow.com/questions/2353211/hsl-to-rgb-color-conversion, https://www.w3.org/TR/css-color-3/ and github.com/lucasb-eyer/go-colorful
func RGBtoHSLF32(r, g, b float32) (h, s, l float32) {
        min := math32.Min(math32.Min(r, g), b)
        max := math32.Max(math32.Max(r, g), b)

        l = (max + min) / 2.0

        if min == max {
                s = 0
                h = 0
        } else {
                d := max - min
                if l > 0.5 {
                        s = d / (2.0 - max - min)
                } else {
                        s = d / (max + min)
                }
                switch max {
                case r:
                        h = (g - b) / d
                        if g < b {
                                h += 6.0
                        }
                case g:
                        h = 2.0 + (b-r)/d
                case b:
                        h = 4.0 + (r-g)/d
                }

                h *= 60

                if h < 0 {
                        h += 360
                }
        }
        return
}

func (h HSL) String() string {
        return fmt.Sprintf("hsl(%g, %g, %g)", h.H, h.S, h.L)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package hsl

import (
        "image/color"

        "cogentcore.org/core/math32"
)

// Lighten returns a color that is lighter by the
// given absolute HSL lightness amount (0-100, ranges enforced)
func Lighten(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.L += amount / 100
        h.L = math32.Clamp(h.L, 0, 1)
        return h.AsRGBA()
}

// Darken returns a color that is darker by the
// given absolute HSL lightness amount (0-100, ranges enforced)
func Darken(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.L -= amount / 100
        h.L = math32.Clamp(h.L, 0, 1)
        return h.AsRGBA()
}

// Highlight returns a color that is lighter or darker by the
// given absolute HSL lightness amount (0-100, ranges enforced),
// making the color darker if it is light (tone >= 0.5) and
// lighter otherwise. It is the opposite of [Samelight].
func Highlight(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        if h.L >= 0.5 {
                h.L -= amount / 100
        } else {
                h.L += amount / 100
        }
        h.L = math32.Clamp(h.L, 0, 1)
        return h.AsRGBA()
}

// Samelight returns a color that is lighter or darker by the
// given absolute HSL lightness amount (0-100, ranges enforced),
// making the color lighter if it is light (tone >= 0.5) and
// darker otherwise. It is the opposite of [Highlight].
func Samelight(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        if h.L >= 0.5 {
                h.L += amount / 100
        } else {
                h.L -= amount / 100
        }
        h.L = math32.Clamp(h.L, 0, 1)
        return h.AsRGBA()
}

// Saturate returns a color that is more saturated by the
// given absolute HSL saturation amount (0-100, ranges enforced)
func Saturate(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.S += amount / 100
        h.S = math32.Clamp(h.S, 0, 1)
        return h.AsRGBA()
}

// Desaturate returns a color that is less saturated by the
// given absolute HSL saturation amount (0-100, ranges enforced)
func Desaturate(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.S -= amount / 100
        h.S = math32.Clamp(h.S, 0, 1)
        return h.AsRGBA()
}

// Spin returns a color that has a different hue by the
// given absolute HSL hue amount (0-360, ranges enforced)
func Spin(c color.Color, amount float32) color.RGBA {
        h := FromColor(c)
        h.H += amount
        h.H = math32.Clamp(h.H, 0, 360)
        return h.AsRGBA()
}

// IsLight returns whether the given color is light
// (has an HSL lightness greater than or equal to 0.6)
func IsLight(c color.Color) bool {
        h := FromColor(c)
        return h.L >= 0.6
}

// IsDark returns whether the given color is dark
// (has an HSL lightness less than 0.6)
func IsDark(c color.Color) bool {
        h := FromColor(c)
        return h.L < 0.6
}

// ContrastColor returns the color that should
// be used to contrast this color (white or black),
// based on the result of [IsLight].
func ContrastColor(c color.Color) color.RGBA {
        if IsLight(c) {
                return color.RGBA{0, 0, 0, 255}
        }
        return color.RGBA{255, 255, 255, 255}
}

// Code generated by "core generate"; DO NOT EDIT.

package lms

import (
        "cogentcore.org/core/enums"
)

var _OpponentsValues = []Opponents{0, 1, 2}

// OpponentsN is the highest valid value for type Opponents, plus one.
const OpponentsN Opponents = 3

var _OpponentsValueMap = map[string]Opponents{`WhiteBlack`: 0, `RedGreen`: 1, `BlueYellow`: 2}

var _OpponentsDescMap = map[Opponents]string{0: `White vs. Black greyscale`, 1: `Red vs. Green`, 2: `Blue vs. Yellow`}

var _OpponentsMap = map[Opponents]string{0: `WhiteBlack`, 1: `RedGreen`, 2: `BlueYellow`}

// String returns the string representation of this Opponents value.
func (i Opponents) String() string { return enums.String(i, _OpponentsMap) }

// SetString sets the Opponents value from its string representation,
// and returns an error if the string is invalid.
func (i *Opponents) SetString(s string) error {
        return enums.SetString(i, s, _OpponentsValueMap, "Opponents")
}

// Int64 returns the Opponents value as an int64.
func (i Opponents) Int64() int64 { return int64(i) }

// SetInt64 sets the Opponents value from an int64.
func (i *Opponents) SetInt64(in int64) { *i = Opponents(in) }

// Desc returns the description of the Opponents value.
func (i Opponents) Desc() string { return enums.Desc(i, _OpponentsDescMap) }

// OpponentsValues returns all possible values for the type Opponents.
func OpponentsValues() []Opponents { return _OpponentsValues }

// Values returns all possible values for the type Opponents.
func (i Opponents) Values() []enums.Enum { return enums.Values(_OpponentsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Opponents) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Opponents) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Opponents")
}

// Copyright (c) 2021, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lms

//go:generate core generate

// OpponentValues holds color opponent values based on cone-like L,M,S inputs
// These values are useful for generating inputs to vision models that
// simulate color opponency representations in the brain.
type OpponentValues struct {

        // red vs. green (long vs. medium)
        RedGreen float32

        // blue vs. yellow (short vs. avg(long, medium))
        BlueYellow float32

        // greyscale luminance channel -- typically use L* from LAB as best
        Grey float32
}

// NewOpponentValues returns a new [OpponentValues] from values representing
// the LMS long, medium, short cone responses, and an overall grey value.
func NewOpponentValues(l, m, s, lm, grey float32) OpponentValues {
        return OpponentValues{RedGreen: l - m, BlueYellow: s - lm, Grey: grey}
}

// Opponents enumerates the three primary opponency channels:
// [WhiteBlack], [RedGreen], and [BlueYellow] using colloquial
// "everyday" terms.
type Opponents int32 //enums:enum

const (
        // White vs. Black greyscale
        WhiteBlack Opponents = iota

        // Red vs. Green
        RedGreen

        // Blue vs. Yellow
        BlueYellow
)

// Copyright (c) 2019, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package colormap

import (
        "image/color"
        "maps"
        "sort"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
)

// Map maps a value onto a color by interpolating between a list of colors
// defining a spectrum, or optionally as an indexed list of colors.
type Map struct {
        // Name is the name of the color map
        Name string

        // if true, this map should be used as an indexed list instead of interpolating a normalized floating point value: requires caller to check this flag and pass int indexes instead of normalized values to MapIndex
        Indexed bool

        // the colorspace algorithm to use for blending colors
        Blend colors.BlendTypes

        // color to display for invalid numbers (e.g., NaN)
        NoColor color.RGBA

        // list of colors to interpolate between
        Colors []color.RGBA
}

func (cm *Map) String() string {
        return cm.Name
}

// Map returns color for normalized value in range 0-1.  NaN returns NoColor
// which can be used to indicate missing values.
func (cm *Map) Map(val float32) color.RGBA {
        nc := len(cm.Colors)
        if nc == 0 {
                return color.RGBA{}
        }
        if nc == 1 {
                return cm.Colors[0]
        }
        if math32.IsNaN(val) {
                return cm.NoColor
        }
        if val <= 0 {
                return cm.Colors[0]
        } else if val >= 1 {
                return cm.Colors[nc-1]
        }
        ival := val * float32(nc-1)
        lidx := math32.Floor(ival)
        uidx := math32.Ceil(ival)
        if lidx == uidx {
                return cm.Colors[int(lidx)]
        }
        cmix := 100 * (1 - (ival - lidx))
        lclr := cm.Colors[int(lidx)]
        uclr := cm.Colors[int(uidx)]
        return colors.Blend(cm.Blend, cmix, lclr, uclr)
}

// MapIndex returns color for given index, for scale in Indexed mode.
// NoColor is returned for values out of range of available colors.
// It is responsibility of the caller to use this method instead of Map
// based on the Indexed flag.
func (cm *Map) MapIndex(val int) color.RGBA {
        nc := len(cm.Colors)
        if val < 0 || val >= nc {
                return cm.NoColor
        }
        return cm.Colors[val]
}

// see https://matplotlib.org/tutorials/colors/colormap-manipulation.html
// for how to read out matplotlib scales -- still don't understand segmented ones!

// StandardMaps is a list of standard color maps
var StandardMaps = map[string]*Map{
        "ColdHot": {
                Name:    "ColdHot",
                NoColor: colors.FromRGB(200, 200, 200),
                Colors: []color.RGBA{
                        {0, 255, 255, 255},
                        {0, 0, 255, 255},
                        {127, 127, 127, 255},
                        {255, 0, 0, 255},
                        {255, 255, 0, 255},
                },
        },
        "Jet": {
                Name:    "Jet",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {0, 0, 127, 255},
                        {0, 0, 255, 255},
                        {0, 127, 255, 255},
                        {0, 255, 255, 255},
                        {127, 255, 127, 255},
                        {255, 255, 0, 255},
                        {255, 127, 0, 255},
                        {255, 0, 0, 255},
                        {127, 0, 0, 255},
                },
        },
        "JetMuted": {
                Name:    "JetMuted",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {25, 25, 153, 255},
                        {25, 102, 230, 255},
                        {0, 230, 230, 255},
                        {0, 179, 0, 255},
                        {230, 230, 0, 255},
                        {230, 102, 25, 255},
                        {153, 25, 25, 255},
                },
        },
        "Viridis": {
                Name:    "Viridis",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {72, 33, 114, 255},
                        {67, 62, 133, 255},
                        {56, 87, 140, 255},
                        {45, 111, 142, 255},
                        {36, 133, 142, 255},
                        {30, 155, 138, 255},
                        {42, 176, 127, 255},
                        {81, 197, 105, 255},
                        {134, 212, 73, 255},
                        {194, 223, 35, 255},
                        {253, 231, 37, 255},
                },
        },
        "Plasma": {
                Name:    "Plasma",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {61, 4, 155, 255},
                        {99, 0, 167, 255},
                        {133, 6, 166, 255},
                        {166, 32, 152, 255},
                        {192, 58, 131, 255},
                        {213, 84, 110, 255},
                        {231, 111, 90, 255},
                        {246, 141, 69, 255},
                        {253, 174, 50, 255},
                        {252, 210, 36, 255},
                        {240, 248, 33, 255},
                },
        },
        "Inferno": {
                Name:    "Inferno",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {37, 12, 3, 255},
                        {19, 11, 52, 255},
                        {57, 9, 99, 255},
                        {95, 19, 110, 255},
                        {133, 33, 107, 255},
                        {169, 46, 94, 255},
                        {203, 65, 73, 255},
                        {230, 93, 47, 255},
                        {247, 131, 17, 255},
                        {252, 174, 19, 255},
                        {245, 219, 76, 255},
                        {252, 254, 164, 255},
                },
        },
        "BlueRed": {
                Name:    "BlueRed",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {0, 0, 255, 255},
                        {255, 0, 0, 255},
                },
        },
        "BlueBlackRed": {
                Name:    "BlueBlackRed",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {0, 0, 255, 255},
                        {76, 76, 76, 255},
                        {255, 0, 0, 255},
                },
        },
        "BlueGreyRed": {
                Name:    "BlueGreyRed",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {0, 0, 255, 255},
                        {127, 127, 127, 255},
                        {255, 0, 0, 255},
                },
        },
        "BlueWhiteRed": {
                Name:    "BlueWhiteRed",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {0, 0, 255, 255},
                        {230, 230, 230, 255},
                        {255, 0, 0, 255},
                },
        },
        "BlueGreenRed": {
                Name:    "BlueGreenRed",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {0, 0, 255, 255},
                        {0, 230, 0, 255},
                        {255, 0, 0, 255},
                },
        },
        "Rainbow": {
                Name:    "Rainbow",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {255, 0, 255, 255},
                        {0, 0, 255, 255},
                        {0, 255, 0, 255},
                        {255, 255, 0, 255},
                        {255, 0, 0, 255},
                },
        },
        "ROYGBIV": {
                Name:    "ROYGBIV",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {255, 0, 255, 255},
                        {0, 0, 127, 255},
                        {0, 0, 255, 255},
                        {0, 255, 0, 255},
                        {255, 255, 0, 255},
                        {255, 0, 0, 255},
                },
        },
        "DarkLight": {
                Name:    "DarkLight",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {0, 0, 0, 255},
                        {250, 250, 250, 255},
                },
        },
        "DarkLightDark": {
                Name:    "DarkLightDark",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {0, 0, 0, 255},
                        {250, 250, 250, 255},
                        {0, 0, 0, 255},
                },
        },
        "LightDarkLight": {
                Name:    "DarkLightDark",
                NoColor: color.RGBA{200, 200, 200, 255},
                Colors: []color.RGBA{
                        {250, 250, 250, 255},
                        {0, 0, 0, 255},
                        {250, 250, 250, 255},
                },
        },
}

// AvailableMaps is the list of all available color maps
var AvailableMaps = map[string]*Map{}

func init() {
        maps.Copy(AvailableMaps, StandardMaps)
}

// AvailableMapsList returns a sorted list of color map names, e.g., for choosers
func AvailableMapsList() []string {
        sl := make([]string, len(AvailableMaps))
        ctr := 0
        for k := range AvailableMaps {
                sl[ctr] = k
                ctr++
        }
        sort.Strings(sl)
        return sl
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package colors provides named colors, utilities for manipulating colors,
// and Material Design 3 color schemes, palettes, and keys in Go.
package colors

//go:generate core generate

import (
        "errors"
        "fmt"
        "image"
        "image/color"
        "strconv"
        "strings"

        "cogentcore.org/core/colors/cam/hct"
        "cogentcore.org/core/colors/cam/hsl"
        "cogentcore.org/core/math32"
)

// IsNil returns whether the color is the nil initial default color
func IsNil(c color.Color) bool {
        return AsRGBA(c) == color.RGBA{}
}

// FromRGB makes a new RGBA color from the given
// RGB uint8 values, using 255 for A.
func FromRGB(r, g, b uint8) color.RGBA {
        return color.RGBA{r, g, b, 255}
}

// FromNRGBA makes a new RGBA color from the given
// non-alpha-premultiplied RGBA uint8 values.
func FromNRGBA(r, g, b, a uint8) color.RGBA {
        return AsRGBA(color.NRGBA{r, g, b, a})
}

// AsRGBA returns the given color as an RGBA color
func AsRGBA(c color.Color) color.RGBA {
        if c == nil {
                return color.RGBA{}
        }
        return color.RGBAModel.Convert(c).(color.RGBA)
}

// FromFloat64 makes a new RGBA color from the given 0-1
// normalized floating point numbers (alpha-premultiplied)
func FromFloat64(r, g, b, a float64) color.RGBA {
        return color.RGBA{uint8(r * 255), uint8(g * 255), uint8(b * 255), uint8(a * 255)}
}

// FromFloat32 makes a new RGBA color from the given 0-1
// normalized floating point numbers (alpha-premultiplied)
func FromFloat32(r, g, b, a float32) color.RGBA {
        return color.RGBA{uint8(r * 255), uint8(g * 255), uint8(b * 255), uint8(a * 255)}
}

// ToFloat32 returns 0-1 normalized floating point numbers from given color
// (alpha-premultiplied)
func ToFloat32(c color.Color) (r, g, b, a float32) {
        f := NRGBAF32Model.Convert(c).(NRGBAF32)
        r = f.R
        g = f.G
        b = f.B
        a = f.A
        return
}

// ToFloat64 returns 0-1 normalized floating point numbers from given color
// (alpha-premultiplied)
func ToFloat64(c color.Color) (r, g, b, a float64) {
        f := NRGBAF32Model.Convert(c).(NRGBAF32)
        r = float64(f.R)
        g = float64(f.G)
        b = float64(f.B)
        a = float64(f.A)
        return
}

// AsString returns the given color as a string,
// using its String method if it exists, and formatting
// it as rgba(r, g, b, a) otherwise.
func AsString(c color.Color) string {
        if s, ok := c.(fmt.Stringer); ok {
                return s.String()
        }
        r := AsRGBA(c)
        return fmt.Sprintf("rgba(%d, %d, %d, %d)", r.R, r.G, r.B, r.A)
}

// FromName returns the color value specified
// by the given CSS standard color name.
func FromName(name string) (color.RGBA, error) {
        c, ok := Map[name]
        if !ok {
                return color.RGBA{}, errors.New("colors.FromName: name not found: " + name)
        }
        return c, nil
}

// FromString returns a color value from the given string.
// FromString accepts the following types of strings: standard
// color names, hex, rgb, rgba, hsl, hsla, hct, and hcta values,
// "none" or "off", or any of the transformations listed below.
// The transformations use the given single base color as their starting
// point; if you do not provide a base color, they will use [Transparent]
// as their starting point. The transformations are:
//
//   - currentcolor = base color
//   - inverse = inverse of base color
//   - lighten-VAL or darken-VAL: VAL is amount to lighten or darken (using HCT), e.g., lighter-10 is 10 higher tone
//   - saturate-VAL or desaturate-VAL: manipulates the chroma level in HCT by VAL
//   - spin-VAL: manipulates the hue level in HCT by VAL
//   - clearer-VAL or opaquer-VAL: manipulates the alpha level by VAL
//   - blend-VAL-color: blends given percent of given color relative to base in RGB space
func FromString(str string, base ...color.Color) (color.RGBA, error) {
        if len(str) == 0 { // consider it null
                return color.RGBA{}, nil
        }
        lstr := strings.ToLower(str)
        switch {
        case lstr[0] == '#':
                return FromHex(str)
        case strings.HasPrefix(lstr, "rgb("), strings.HasPrefix(lstr, "rgba("):
                val := lstr[strings.Index(lstr, "(")+1:]
                val = strings.TrimRight(val, ")")
                val = strings.Trim(val, "%")
                var r, g, b, a int
                a = 255
                if strings.Count(val, ",") == 3 {
                        format := "%d,%d,%d,%d"
                        fmt.Sscanf(val, format, &r, &g, &b, &a)
                } else {
                        format := "%d,%d,%d"
                        fmt.Sscanf(val, format, &r, &g, &b)
                }
                return FromNRGBA(uint8(r), uint8(g), uint8(b), uint8(a)), nil
        case strings.HasPrefix(lstr, "hsl("), strings.HasPrefix(lstr, "hsla("):
                val := lstr[strings.Index(lstr, "(")+1:]
                val = strings.TrimRight(val, ")")
                val = strings.Trim(val, "%")
                var h, s, l, a int
                a = 255
                if strings.Count(val, ",") == 3 {
                        format := "%d,%d,%d,%d"
                        fmt.Sscanf(val, format, &h, &s, &l, &a)
                } else {
                        format := "%d,%d,%d"
                        fmt.Sscanf(val, format, &h, &s, &l)
                }
                return WithA(hsl.New(float32(h), float32(s)/100.0, float32(l)/100.0), uint8(a)), nil
        case strings.HasPrefix(lstr, "hct("), strings.HasPrefix(lstr, "hcta("):
                val := lstr[strings.Index(lstr, "(")+1:]
                val = strings.TrimRight(val, ")")
                val = strings.Trim(val, "%")
                var h, c, t, a int
                a = 255
                if strings.Count(val, ",") == 3 {
                        format := "%d,%d,%d,%d"
                        fmt.Sscanf(val, format, &h, &c, &t, &a)
                } else {
                        format := "%d,%d,%d"
                        fmt.Sscanf(val, format, &h, &c, &t)
                }
                return WithA(hct.New(float32(h), float32(c), float32(t)), uint8(a)), nil
        default:
                var bc color.Color = Transparent
                if len(base) > 0 {
                        bc = base[0]
                }

                if hidx := strings.Index(lstr, "-"); hidx > 0 {
                        cmd := lstr[:hidx]
                        valstr := lstr[hidx+1:]
                        val64, err := strconv.ParseFloat(valstr, 32)
                        if err != nil && cmd != "blend" { // blend handles separately
                                return color.RGBA{}, fmt.Errorf("colors.FromString: error getting numeric value from %q: %w", valstr, err)
                        }
                        val := float32(val64)
                        switch cmd {
                        case "lighten":
                                return hct.Lighten(bc, val), nil
                        case "darken":
                                return hct.Darken(bc, val), nil
                        case "highlight":
                                return hct.Highlight(bc, val), nil
                        case "samelight":
                                return hct.Samelight(bc, val), nil
                        case "saturate":
                                return hct.Saturate(bc, val), nil
                        case "desaturate":
                                return hct.Desaturate(bc, val), nil
                        case "spin":
                                return hct.Spin(bc, val), nil
                        case "clearer":
                                return Clearer(bc, val), nil
                        case "opaquer":
                                return Opaquer(bc, val), nil
                        case "blend":
                                clridx := strings.Index(valstr, "-")
                                if clridx < 0 {
                                        return color.RGBA{}, fmt.Errorf("colors.FromString: blend color spec not found; format is: blend-PCT-color, got: %v; PCT-color is: %v", lstr, valstr)
                                }
                                bvalstr := valstr[:clridx]
                                val64, err := strconv.ParseFloat(bvalstr, 32)
                                if err != nil {
                                        return color.RGBA{}, fmt.Errorf("colors.FromString: error getting numeric value from %q: %w", bvalstr, err)
                                }
                                val := float32(val64)
                                clrstr := valstr[clridx+1:]
                                othc, err := FromString(clrstr, bc)
                                return BlendRGB(val, bc, othc), err
                        }
                }
                switch lstr {
                case "none", "off":
                        return color.RGBA{}, nil
                case "transparent":
                        return Transparent, nil
                case "currentcolor":
                        return AsRGBA(bc), nil
                case "inverse":
                        return Inverse(bc), nil
                default:
                        return FromName(lstr)
                }
        }
}

// FromAny returns a color from the given value of any type.
// It handles values of types string, [color.Color], [*color.Color],
// [image.Image], and [*image.Image]. It takes an optional base color
// for relative transformations
// (see [FromString]).
func FromAny(val any, base ...color.Color) (color.RGBA, error) {
        switch vv := val.(type) {
        case string:
                return FromString(vv, base...)
        case color.Color:
                return AsRGBA(vv), nil
        case *color.Color:
                return AsRGBA(*vv), nil
        case image.Image:
                return ToUniform(vv), nil
        case *image.Image:
                return ToUniform(*vv), nil
        default:
                return color.RGBA{}, fmt.Errorf("colors.FromAny: could not get color from value %v of type %T", val, val)
        }
}

// FromHex parses the given non-alpha-premultiplied hex color string
// and returns the resulting alpha-premultiplied color.
func FromHex(hex string) (color.RGBA, error) {
        hex = strings.TrimPrefix(hex, "#")
        var r, g, b, a int
        a = 255
        if len(hex) == 3 {
                format := "%1x%1x%1x"
                fmt.Sscanf(hex, format, &r, &g, &b)
                r |= r << 4
                g |= g << 4
                b |= b << 4
        } else if len(hex) == 6 {
                format := "%02x%02x%02x"
                fmt.Sscanf(hex, format, &r, &g, &b)
        } else if len(hex) == 8 {
                format := "%02x%02x%02x%02x"
                fmt.Sscanf(hex, format, &r, &g, &b, &a)
        } else {
                return color.RGBA{}, fmt.Errorf("colors.FromHex: could not process %q", hex)
        }
        return AsRGBA(color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(a)}), nil
}

// AsHex returns the color as a standard 2-hexadecimal-digits-per-component
// non-alpha-premultiplied hex color string.
func AsHex(c color.Color) string {
        if c == nil {
                return "nil"
        }
        r := color.NRGBAModel.Convert(c).(color.NRGBA)
        if r.A == 255 {
                return fmt.Sprintf("#%02X%02X%02X", r.R, r.G, r.B)
        }
        return fmt.Sprintf("#%02X%02X%02X%02X", r.R, r.G, r.B, r.A)
}

// WithR returns the given color with the red
// component (R) set to the given alpha-premultiplied value
func WithR(c color.Color, r uint8) color.RGBA {
        rc := AsRGBA(c)
        rc.R = r
        return rc
}

// WithG returns the given color with the green
// component (G) set to the given alpha-premultiplied value
func WithG(c color.Color, g uint8) color.RGBA {
        rc := AsRGBA(c)
        rc.G = g
        return rc
}

// WithB returns the given color with the blue
// component (B) set to the given alpha-premultiplied value
func WithB(c color.Color, b uint8) color.RGBA {
        rc := AsRGBA(c)
        rc.B = b
        return rc
}

// WithA returns the given color with the
// transparency (A) set to the given value,
// with the color premultiplication updated.
func WithA(c color.Color, a uint8) color.RGBA {
        n := color.NRGBAModel.Convert(c).(color.NRGBA)
        n.A = a
        return AsRGBA(n)
}

// WithAF32 returns the given color with the
// transparency (A) set to the given float32 value
// between 0 and 1, with the color premultiplication updated.
func WithAF32(c color.Color, a float32) color.RGBA {
        n := color.NRGBAModel.Convert(c).(color.NRGBA)
        a = math32.Clamp(a, 0, 1)
        n.A = uint8(a * 255)
        return AsRGBA(n)
}

// ApplyOpacity applies the given opacity (0-1) to the given color
// and returns the result. It is different from [WithAF32] in that it
// sets the transparency (A) value of the color to the current value
// times the given value instead of just directly overriding it.
func ApplyOpacity(c color.Color, opacity float32) color.RGBA {
        r := AsRGBA(c)
        if opacity >= 1 {
                return r
        }
        a := r.A
        // new A is current A times opacity
        return WithA(c, uint8(float32(a)*opacity))
}

// ApplyOpacityNRGBA applies the given opacity (0-1) to the given color
// and returns the result. It is different from [WithAF32] in that it
// sets the transparency (A) value of the color to the current value
// times the given value instead of just directly overriding it.
// It is the [color.NRGBA] version of [ApplyOpacity].
func ApplyOpacityNRGBA(c color.Color, opacity float32) color.NRGBA {
        r := color.NRGBAModel.Convert(c).(color.NRGBA)
        if opacity >= 1 {
                return r
        }
        a := r.A
        // new A is current A times opacity
        return color.NRGBA{r.R, r.G, r.B, uint8(float32(a) * opacity)}
}

// Clearer returns a color that is the given amount
// more transparent (lower alpha value) in terms of
// RGBA absolute alpha from 0 to 100, with the color
// premultiplication updated.
func Clearer(c color.Color, amount float32) color.RGBA {
        f32 := NRGBAF32Model.Convert(c).(NRGBAF32)
        f32.A -= amount / 100
        f32.A = math32.Clamp(f32.A, 0, 1)
        return AsRGBA(f32)
}

// Opaquer returns a color that is the given amount
// more opaque (higher alpha value) in terms of
// RGBA absolute alpha from 0 to 100,
// with the color premultiplication updated.
func Opaquer(c color.Color, amount float32) color.RGBA {
        f32 := NRGBAF32Model.Convert(c).(NRGBAF32)
        f32.A += amount / 100
        f32.A = math32.Clamp(f32.A, 0, 1)
        return AsRGBA(f32)
}

// Inverse returns the inverse of the given color
// (255 - each component). It does not change the
// alpha channel.
func Inverse(c color.Color) color.RGBA {
        r := AsRGBA(c)
        return color.RGBA{255 - r.R, 255 - r.G, 255 - r.B, r.A}
}

// Add adds given color deltas to this color, safely avoiding overflow > 255
func Add(c, dc color.Color) color.RGBA {
        r, g, b, a := c.RGBA()      // uint32
        dr, dg, db, da := dc.RGBA() // uint32
        r = (r + dr) >> 8
        g = (g + dg) >> 8
        b = (b + db) >> 8
        a = (a + da) >> 8
        if r > 255 {
                r = 255
        }
        if g > 255 {
                g = 255
        }
        if b > 255 {
                b = 255
        }
        if a > 255 {
                a = 255
        }
        return color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)}
}

// Sub subtracts given color deltas from this color, safely avoiding underflow < 0
func Sub(c, dc color.Color) color.RGBA {
        r, g, b, a := c.RGBA()      // uint32
        dr, dg, db, da := dc.RGBA() // uint32
        r = (r - dr) >> 8
        g = (g - dg) >> 8
        b = (b - db) >> 8
        a = (a - da) >> 8
        if r > 255 { // overflow
                r = 0
        }
        if g > 255 {
                g = 0
        }
        if b > 255 {
                b = 0
        }
        if a > 255 {
                a = 0
        }
        return color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)}
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package colors

import (
        "image"
        "image/color"
)

// Context contains information about the context in which color parsing occurs.
type Context interface {
        // Base returns the base color that the color parsing is relative top
        Base() color.RGBA
        // ImageByURL returns the [image.Image] associated with the given URL.
        // Typical URL formats are HTTP URLs like "https://example.com" and node
        // URLs like "#name". If it returns nil, that indicats that there is no
        // [image.Image] color associated with the given URL.
        ImageByURL(url string) image.Image
}

// BaseContext returns a basic [Context] based on the given base color.
func BaseContext(base color.RGBA) Context {
        return &baseContext{base}
}

type baseContext struct {
        base color.RGBA
}

func (bc *baseContext) Base() color.RGBA {
        return bc.base
}

func (bc *baseContext) ImageByURL(url string) image.Image {
        return nil
}

// Code generated by "core generate"; DO NOT EDIT.

package colors

import (
        "cogentcore.org/core/enums"
)

var _BlendTypesValues = []BlendTypes{0, 1, 2}

// BlendTypesN is the highest valid value for type BlendTypes, plus one.
const BlendTypesN BlendTypes = 3

var _BlendTypesValueMap = map[string]BlendTypes{`HCT`: 0, `RGB`: 1, `CAM16`: 2}

var _BlendTypesDescMap = map[BlendTypes]string{0: `HCT uses the hue, chroma, and tone space and generally produces the best results, but at a slight performance cost.`, 1: `RGB uses raw RGB space, which is the standard space that most other programs use. It produces decent results with maximum performance.`, 2: `CAM16 is an alternative colorspace, similar to HCT, but not quite as good.`}

var _BlendTypesMap = map[BlendTypes]string{0: `HCT`, 1: `RGB`, 2: `CAM16`}

// String returns the string representation of this BlendTypes value.
func (i BlendTypes) String() string { return enums.String(i, _BlendTypesMap) }

// SetString sets the BlendTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *BlendTypes) SetString(s string) error {
        return enums.SetString(i, s, _BlendTypesValueMap, "BlendTypes")
}

// Int64 returns the BlendTypes value as an int64.
func (i BlendTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the BlendTypes value from an int64.
func (i *BlendTypes) SetInt64(in int64) { *i = BlendTypes(in) }

// Desc returns the description of the BlendTypes value.
func (i BlendTypes) Desc() string { return enums.Desc(i, _BlendTypesDescMap) }

// BlendTypesValues returns all possible values for the type BlendTypes.
func BlendTypesValues() []BlendTypes { return _BlendTypesValues }

// Values returns all possible values for the type BlendTypes.
func (i BlendTypes) Values() []enums.Enum { return enums.Values(_BlendTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i BlendTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *BlendTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "BlendTypes")
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gradient

import (
        "image"
        "image/color"

        "cogentcore.org/core/colors"
)

// ApplyFunc is a function that transforms input color to an output color.
type ApplyFunc func(c color.Color) color.Color

// ApplyFuncs is a slice of ApplyFunc color functions applied in order
type ApplyFuncs []ApplyFunc

// Add adds a new function
func (af *ApplyFuncs) Add(fun ApplyFunc) {
        *af = append(*af, fun)
}

// Apply applies all functions in order to given input color
func (af ApplyFuncs) Apply(c color.Color) color.Color {
        for _, f := range af {
                c = f(c)
        }
        return c
}

func (af ApplyFuncs) Clone() ApplyFuncs {
        n := len(af)
        if n == 0 {
                return nil
        }
        c := make(ApplyFuncs, n)
        copy(c, af)
        return c
}

// Applier is an image.Image wrapper that applies a color transformation
// to the output of a source image, using the given ApplyFunc
type Applier struct {
        image.Image
        Func ApplyFunc
}

// NewApplier returns a new applier for given image and apply function
func NewApplier(img image.Image, fun func(c color.Color) color.Color) *Applier {
        return &Applier{Image: img, Func: fun}
}

func (ap *Applier) At(x, y int) color.Color {
        return ap.Func(ap.Image.At(x, y))
}

// Apply returns a copy of the given image with the given color function
// applied to each pixel of the image, handling special cases:
// [image.Uniform] is optimized and must be preserved as such: color is directly updated.
// [gradient.Gradient] must have Update called prior to rendering, with
// the current bounding box.
func Apply(img image.Image, f ApplyFunc) image.Image {
        if img == nil {
                return nil
        }
        switch im := img.(type) {
        case *image.Uniform:
                return image.NewUniform(f(colors.AsRGBA(im)))
        case Gradient:
                cp := CopyOf(im)
                cp.AsBase().ApplyFuncs.Add(f)
                return cp
        default:
                return NewApplier(img, f)
        }
}

// ApplyOpacity applies the given opacity (0-1) to the given image,
// handling the following special cases, and using an Applier for the general case.
// [image.Uniform] is optimized and must be preserved as such: color is directly updated.
// [gradient.Gradient] must have Update called prior to rendering, with
// the current bounding box. Multiplies the opacity of the stops.
func ApplyOpacity(img image.Image, opacity float32) image.Image {
        if img == nil {
                return nil
        }
        if opacity == 1 {
                return img
        }
        switch im := img.(type) {
        case *image.Uniform:
                return image.NewUniform(colors.ApplyOpacity(colors.AsRGBA(im), opacity))
        case Gradient:
                cp := CopyOf(im)
                cp.AsBase().ApplyOpacityToStops(opacity)
                return cp
        default:
                return NewApplier(img, func(c color.Color) color.Color {
                        return colors.ApplyOpacity(c, opacity)
                })
        }
}

// Code generated by "core generate"; DO NOT EDIT.

package gradient

import (
        "cogentcore.org/core/enums"
)

var _SpreadsValues = []Spreads{0, 1, 2}

// SpreadsN is the highest valid value for type Spreads, plus one.
const SpreadsN Spreads = 3

var _SpreadsValueMap = map[string]Spreads{`pad`: 0, `reflect`: 1, `repeat`: 2}

var _SpreadsDescMap = map[Spreads]string{0: `Pad indicates to have the final color of the gradient fill the object beyond the end of the gradient.`, 1: `Reflect indicates to have a gradient repeat in reverse order (offset 1 to 0) to fully fill an object beyond the end of the gradient.`, 2: `Repeat indicates to have a gradient continue in its original order (offset 0 to 1) by jumping back to the start to fully fill an object beyond the end of the gradient.`}

var _SpreadsMap = map[Spreads]string{0: `pad`, 1: `reflect`, 2: `repeat`}

// String returns the string representation of this Spreads value.
func (i Spreads) String() string { return enums.String(i, _SpreadsMap) }

// SetString sets the Spreads value from its string representation,
// and returns an error if the string is invalid.
func (i *Spreads) SetString(s string) error {
        return enums.SetString(i, s, _SpreadsValueMap, "Spreads")
}

// Int64 returns the Spreads value as an int64.
func (i Spreads) Int64() int64 { return int64(i) }

// SetInt64 sets the Spreads value from an int64.
func (i *Spreads) SetInt64(in int64) { *i = Spreads(in) }

// Desc returns the description of the Spreads value.
func (i Spreads) Desc() string { return enums.Desc(i, _SpreadsDescMap) }

// SpreadsValues returns all possible values for the type Spreads.
func SpreadsValues() []Spreads { return _SpreadsValues }

// Values returns all possible values for the type Spreads.
func (i Spreads) Values() []enums.Enum { return enums.Values(_SpreadsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Spreads) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Spreads) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Spreads") }

var _UnitsValues = []Units{0, 1}

// UnitsN is the highest valid value for type Units, plus one.
const UnitsN Units = 2

var _UnitsValueMap = map[string]Units{`objectBoundingBox`: 0, `userSpaceOnUse`: 1}

var _UnitsDescMap = map[Units]string{0: `ObjectBoundingBox indicates that coordinate values are scaled relative to the size of the object and are specified in the normalized range of 0 to 1.`, 1: `UserSpaceOnUse indicates that coordinate values are specified in the current user coordinate system when the gradient is used (ie: actual SVG/core coordinates).`}

var _UnitsMap = map[Units]string{0: `objectBoundingBox`, 1: `userSpaceOnUse`}

// String returns the string representation of this Units value.
func (i Units) String() string { return enums.String(i, _UnitsMap) }

// SetString sets the Units value from its string representation,
// and returns an error if the string is invalid.
func (i *Units) SetString(s string) error { return enums.SetString(i, s, _UnitsValueMap, "Units") }

// Int64 returns the Units value as an int64.
func (i Units) Int64() int64 { return int64(i) }

// SetInt64 sets the Units value from an int64.
func (i *Units) SetInt64(in int64) { *i = Units(in) }

// Desc returns the description of the Units value.
func (i Units) Desc() string { return enums.Desc(i, _UnitsDescMap) }

// UnitsValues returns all possible values for the type Units.
func UnitsValues() []Units { return _UnitsValues }

// Values returns all possible values for the type Units.
func (i Units) Values() []enums.Enum { return enums.Values(_UnitsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Units) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Units) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Units") }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/rasterx:
// Copyright 2018 by the rasterx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

// Package gradient provides linear, radial, and conic color gradients.
package gradient

//go:generate core generate

import (
        "image"
        "image/color"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
)

// Gradient is the interface that all gradient types satisfy.
type Gradient interface {
        image.Image

        // AsBase returns the [Base] of the gradient
        AsBase() *Base

        // Update updates the computed fields of the gradient, using
        // the given object opacity, current bounding box, and additional
        // object-level transform (i.e., the current painting transform),
        // which is applied in addition to the gradient's own Transform.
        // This must be called before rendering the gradient, and it should only be called then.
        Update(opacity float32, box math32.Box2, objTransform math32.Matrix2)
}

// Base contains the data and logic common to all gradient types.
type Base struct { //types:add -setters

        // the stops for the gradient; use AddStop to add stops
        Stops []Stop `set:"-"`

        // the spread method used for the gradient if it stops before the end
        Spread Spreads

        // the colorspace algorithm to use for blending colors
        Blend colors.BlendTypes

        // the units to use for the gradient
        Units Units

        // the bounding box of the object with the gradient; this is used when rendering
        // gradients with [Units] of [ObjectBoundingBox].
        Box math32.Box2

        // Transform is the gradient's own transformation matrix applied to the gradient's points.
        // This is a property of the Gradient itself.
        Transform math32.Matrix2

        // Opacity is the overall object opacity multiplier, applied in conjunction with the
        // stop-level opacity blending.
        Opacity float32

        // ApplyFuncs contains functions that are applied to the color after gradient color is generated.
        // This allows for efficient StateLayer and other post-processing effects
        // to be applied.  The Applier handles other cases, but gradients always
        // must have the Update function called at render time, so they must
        // remain Gradient types.
        ApplyFuncs ApplyFuncs `set:"-"`

        // boxTransform is the Transform applied to the bounding Box,
        // only for [Units] == [ObjectBoundingBox].
        boxTransform math32.Matrix2 `set:"-"`

        // stopsRGB are the computed RGB stops for blend types other than RGB
        stopsRGB []Stop `set:"-"`

        // stopsRGBSrc are the source Stops when StopsRGB were last computed
        stopsRGBSrc []Stop `set:"-"`
}

// Stop represents a single stop in a gradient
type Stop struct {

        // the color of the stop. these should be fully opaque,
        // with opacity specified separately, for best results, as is done in SVG etc.
        Color color.Color

        // the position of the stop between 0 and 1
        Pos float32

        // Opacity is the 0-1 level of opacity for this stop
        Opacity float32
}

// OpacityColor returns the stop color with its opacity applied,
// along with a global opacity multiplier
func (st *Stop) OpacityColor(opacity float32, apply ApplyFuncs) color.Color {
        return apply.Apply(colors.ApplyOpacity(st.Color, st.Opacity*opacity))
}

// Spreads are the spread methods used when a gradient reaches
// its end but the object isn't yet fully filled.
type Spreads int32 //enums:enum -transform lower

const (
        // Pad indicates to have the final color of the gradient fill
        // the object beyond the end of the gradient.
        Pad Spreads = iota
        // Reflect indicates to have a gradient repeat in reverse order
        // (offset 1 to 0) to fully fill an object beyond the end of the gradient.
        Reflect
        // Repeat indicates to have a gradient continue in its original order
        // (offset 0 to 1) by jumping back to the start to fully fill an object beyond
        // the end of the gradient.
        Repeat
)

// Units are the types of units used for gradient coordinate values
type Units int32 //enums:enum -transform lower-camel

const (
        // ObjectBoundingBox indicates that coordinate values are scaled
        // relative to the size of the object and are specified in the
        // normalized range of 0 to 1.
        ObjectBoundingBox Units = iota
        // UserSpaceOnUse indicates that coordinate values are specified
        // in the current user coordinate system when the gradient is used
        // (ie: actual SVG/core coordinates).
        UserSpaceOnUse
)

// AddStop adds a new stop with the given color, position, and
// optional opacity to the gradient.
func (b *Base) AddStop(color color.RGBA, pos float32, opacity ...float32) *Base {
        op := float32(1)
        if len(opacity) > 0 {
                op = opacity[0]
        }
        b.Stops = append(b.Stops, Stop{Color: color, Pos: pos, Opacity: op})
        return b
}

// AsBase returns the [Base] of the gradient
func (b *Base) AsBase() *Base {
        return b
}

// NewBase returns a new [Base] with default values. It should
// only be used in the New functions of gradient types.
func NewBase() Base {
        return Base{
                Blend:     colors.RGB,
                Box:       math32.B2(0, 0, 100, 100),
                Opacity:   1,
                Transform: math32.Identity2(),
        }
}

// ColorModel returns the color model used by the gradient image, which is [color.RGBAModel]
func (b *Base) ColorModel() color.Model {
        return color.RGBAModel
}

// Bounds returns the bounds of the gradient image, which are infinite.
func (b *Base) Bounds() image.Rectangle {
        return image.Rect(-1e9, -1e9, 1e9, 1e9)
}

// CopyFrom copies from the given gradient (cp) onto this gradient (g),
// making new copies of the stops instead of re-using pointers.
// It assumes the gradients are of the same type.
func CopyFrom(g Gradient, cp Gradient) {
        switch g := g.(type) {
        case *Linear:
                *g = *cp.(*Linear)
        case *Radial:
                *g = *cp.(*Radial)
        }
        cb := cp.AsBase()
        gb := g.AsBase()
        gb.CopyStopsFrom(cb)
        gb.ApplyFuncs = cb.ApplyFuncs.Clone()
}

// CopyOf returns a copy of the given gradient, making copies of the stops
// instead of re-using pointers.
func CopyOf(g Gradient) Gradient {
        var res Gradient
        switch g := g.(type) {
        case *Linear:
                res = &Linear{}
                CopyFrom(res, g)
        case *Radial:
                res = &Radial{}
                CopyFrom(res, g)
        }
        return res
}

// CopyStopsFrom copies the base gradient stops from the given base gradient
func (b *Base) CopyStopsFrom(cp *Base) {
        b.Stops = make([]Stop, len(cp.Stops))
        copy(b.Stops, cp.Stops)

        if cp.stopsRGB == nil {
                b.stopsRGB = nil
                b.stopsRGBSrc = nil
        } else {
                b.stopsRGB = make([]Stop, len(cp.stopsRGB))
                copy(b.stopsRGB, cp.stopsRGB)
                b.stopsRGBSrc = make([]Stop, len(cp.stopsRGBSrc))
                copy(b.stopsRGBSrc, cp.stopsRGBSrc)
        }
}

// ApplyOpacityToStops multiplies all stop opacities by the given opacity.
func (b *Base) ApplyOpacityToStops(opacity float32) {
        for _, s := range b.Stops {
                s.Opacity *= opacity
        }
        for _, s := range b.stopsRGB {
                s.Opacity *= opacity
        }
        for _, s := range b.stopsRGBSrc {
                s.Opacity *= opacity
        }
}

// updateBase updates the computed fields of the base gradient. It should only be called
// by other gradient types in their [Gradient.Update] functions. It is named updateBase
// to avoid people accidentally calling it instead of [Gradient.Update].
func (b *Base) updateBase() {
        b.computeObjectMatrix()
        b.updateRGBStops()
}

// computeObjectMatrix computes the effective object transformation
// matrix for a gradient with [Units] of [ObjectBoundingBox], setting
// [Base.boxTransform].
func (b *Base) computeObjectMatrix() {
        w, h := b.Box.Size().X, b.Box.Size().Y
        oriX, oriY := b.Box.Min.X, b.Box.Min.Y
        b.boxTransform = math32.Identity2().Translate(oriX, oriY).Scale(w, h).Mul(b.Transform).
                Scale(1/w, 1/h).Translate(-oriX, -oriY).Inverse()
}

// getColor returns the color at the given normalized position along the
// gradient's stops using its spread method and blend algorithm.
func (b *Base) getColor(pos float32) color.Color {
        if b.Blend == colors.RGB {
                return b.getColorImpl(pos, b.Stops)
        }
        return b.getColorImpl(pos, b.stopsRGB)
}

// getColorImpl implements [Base.getColor] with given stops
func (b *Base) getColorImpl(pos float32, stops []Stop) color.Color {
        d := len(stops)
        // These cases can be taken care of early on
        if b.Spread == Pad {
                if pos >= 1 {
                        return stops[d-1].OpacityColor(b.Opacity, b.ApplyFuncs)
                }
                if pos <= 0 {
                        return stops[0].OpacityColor(b.Opacity, b.ApplyFuncs)
                }
        }

        modRange := float32(1)
        if b.Spread == Reflect {
                modRange = 2
        }
        mod := math32.Mod(pos, modRange)
        if mod < 0 {
                mod += modRange
        }

        place := 0 // Advance to place where mod is greater than the indicated stop
        for place != len(stops) && mod > stops[place].Pos {
                place++
        }
        switch b.Spread {
        case Repeat:
                var s1, s2 Stop
                switch place {
                case 0, d:
                        s1, s2 = stops[d-1], stops[0]
                default:
                        s1, s2 = stops[place-1], stops[place]
                }
                return b.blendStops(mod, s1, s2, false)
        case Reflect:
                switch place {
                case 0:
                        return stops[0].OpacityColor(b.Opacity, b.ApplyFuncs)
                case d:
                        // Advance to place where mod-1 is greater than the stop indicated by place in reverse of the stop slice.
                        // Since this is the reflect b.Spread mode, the mod interval is two, allowing the stop list to be
                        // iterated in reverse before repeating the sequence.
                        for place != d*2 && mod-1 > (1-stops[d*2-place-1].Pos) {
                                place++
                        }
                        switch place {
                        case d:
                                return stops[d-1].OpacityColor(b.Opacity, b.ApplyFuncs)
                        case d * 2:
                                return stops[0].OpacityColor(b.Opacity, b.ApplyFuncs)
                        default:
                                return b.blendStops(mod-1, stops[d*2-place], stops[d*2-place-1], true)
                        }
                default:
                        return b.blendStops(mod, stops[place-1], stops[place], false)
                }
        default: // PadSpread
                switch place {
                case 0:
                        return stops[0].OpacityColor(b.Opacity, b.ApplyFuncs)
                case d:
                        return stops[d-1].OpacityColor(b.Opacity, b.ApplyFuncs)
                default:
                        return b.blendStops(mod, stops[place-1], stops[place], false)
                }
        }
}

// blendStops blends the given two gradient stops together based on the given position,
// using the gradient's blending algorithm. If flip is true, it flips the given position.
func (b *Base) blendStops(pos float32, s1, s2 Stop, flip bool) color.Color {
        s1off := s1.Pos
        if s1.Pos > s2.Pos && !flip { // happens in repeat spread mode
                s1off--
                if pos > 1 {
                        pos--
                }
        }
        if s2.Pos == s1off {
                return s2.OpacityColor(b.Opacity, b.ApplyFuncs)
        }
        if flip {
                pos = 1 - pos
        }
        tp := (pos - s1off) / (s2.Pos - s1off)

        opacity := (s1.Opacity*(1-tp) + s2.Opacity*tp) * b.Opacity
        return b.ApplyFuncs.Apply(colors.ApplyOpacity(colors.Blend(colors.RGB, 100*(1-tp), s1.Color, s2.Color), opacity))
}

// updateRGBStops updates stopsRGB from original Stops, for other blend types
func (b *Base) updateRGBStops() {
        if b.Blend == colors.RGB || len(b.Stops) == 0 {
                b.stopsRGB = nil
                b.stopsRGBSrc = nil
                return
        }
        n := len(b.Stops)
        lenEq := false
        if len(b.stopsRGBSrc) == n {
                lenEq = true
                equal := true
                for i := range b.Stops {
                        if b.Stops[i] != b.stopsRGBSrc[i] {
                                equal = false
                                break
                        }
                }
                if equal {
                        return
                }
        }

        if !lenEq {
                b.stopsRGBSrc = make([]Stop, n)
        }
        copy(b.stopsRGBSrc, b.Stops)

        b.stopsRGB = make([]Stop, 0, n*4)

        tdp := float32(0.05)
        b.stopsRGB = append(b.stopsRGB, b.Stops[0])
        for i := 0; i < n-1; i++ {
                sp := b.Stops[i]
                s := b.Stops[i+1]
                dp := s.Pos - sp.Pos
                np := int(math32.Ceil(dp / tdp))
                if np == 1 {
                        b.stopsRGB = append(b.stopsRGB, s)
                        continue
                }
                pct := float32(1) / float32(np)
                dopa := s.Opacity - sp.Opacity
                for j := 0; j < np; j++ {
                        p := pct * float32(j)
                        c := colors.Blend(colors.RGB, 100*p, s.Color, sp.Color)
                        pos := sp.Pos + p*dp
                        opa := sp.Opacity + p*dopa
                        b.stopsRGB = append(b.stopsRGB, Stop{Color: c, Pos: pos, Opacity: opa})
                }
                b.stopsRGB = append(b.stopsRGB, s)
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/rasterx:
// Copyright 2018 by the rasterx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

package gradient

import (
        "image/color"

        "cogentcore.org/core/math32"
)

// Linear represents a linear gradient. It implements the [image.Image] interface.
type Linear struct { //types:add -setters
        Base

        // the starting point of the gradient (x1 and y1 in SVG)
        Start math32.Vector2

        // the ending point of the gradient (x2 and y2 in SVG)
        End math32.Vector2

        // computed current render versions transformed by object matrix
        rStart                math32.Vector2
        rEnd                  math32.Vector2
        distance              math32.Vector2
        distanceLengthSquared float32
}

var _ Gradient = &Linear{}

// NewLinear returns a new left-to-right [Linear] gradient.
func NewLinear() *Linear {
        return &Linear{
                Base: NewBase(),
                // default in SVG is LTR
                End: math32.Vec2(1, 0),
        }
}

// AddStop adds a new stop with the given color, position, and
// optional opacity to the gradient.
func (l *Linear) AddStop(color color.RGBA, pos float32, opacity ...float32) *Linear {
        l.Base.AddStop(color, pos, opacity...)
        return l
}

// Update updates the computed fields of the gradient, using
// the given current bounding box, and additional
// object-level transform (i.e., the current painting transform),
// which is applied in addition to the gradient's own Transform.
// This must be called before rendering the gradient, and it should only be called then.
func (l *Linear) Update(opacity float32, box math32.Box2, objTransform math32.Matrix2) {
        l.Box = box
        l.Opacity = opacity
        l.updateBase()

        if l.Units == ObjectBoundingBox {
                sz := l.Box.Size()
                l.rStart = l.Box.Min.Add(sz.Mul(l.Start))
                l.rEnd = l.Box.Min.Add(sz.Mul(l.End))
        } else {
                l.rStart = l.Transform.MulVector2AsPoint(l.Start)
                l.rEnd = l.Transform.MulVector2AsPoint(l.End)
                l.rStart = objTransform.MulVector2AsPoint(l.rStart)
                l.rEnd = objTransform.MulVector2AsPoint(l.rEnd)
        }

        l.distance = l.rEnd.Sub(l.rStart)
        l.distanceLengthSquared = l.distance.LengthSquared()
}

// At returns the color of the linear gradient at the given point
func (l *Linear) At(x, y int) color.Color {
        switch len(l.Stops) {
        case 0:
                return color.RGBA{}
        case 1:
                return l.Stops[0].OpacityColor(l.Opacity, l.ApplyFuncs)
        }

        pt := math32.Vec2(float32(x)+0.5, float32(y)+0.5)
        if l.Units == ObjectBoundingBox {
                pt = l.boxTransform.MulVector2AsPoint(pt)
        }
        df := pt.Sub(l.rStart)
        pos := (l.distance.X*df.X + l.distance.Y*df.Y) / l.distanceLengthSquared
        return l.getColor(pos)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// color parsing is adapted from github.com/srwiley/oksvg:
//
// Copyright 2017 The oksvg Authors. All rights reserved.
//
// created: 2/12/2017 by S.R.Wiley

package gradient

import (
        "encoding/xml"
        "fmt"
        "image"
        "image/color"
        "io"
        "strconv"
        "strings"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "golang.org/x/net/html/charset"
)

// XMLAttr searches for given attribute in slice of xml attributes;
// returns "" if not found.
func XMLAttr(name string, attrs []xml.Attr) string {
        for _, attr := range attrs {
                if attr.Name.Local == name {
                        return attr.Value
                }
        }
        return ""
}

// Cache is a cache of the [image.Image] results of [FromString] calls
// for each string passed to [FromString].
var Cache map[string]image.Image

// FromString parses the given CSS image/gradient/color string and returns the resulting image.
// FromString is based on https://www.w3schools.com/css/css3_gradients.asp.
// See [UnmarshalXML] for an XML-based version. If no Context is
// provied, FromString uses [BaseContext] with [Transparent].
func FromString(str string, ctx ...colors.Context) (image.Image, error) {
        var cc colors.Context
        if len(ctx) > 0 && ctx[0] != nil {
                cc = ctx[0]
        } else {
                cc = colors.BaseContext(colors.Transparent)
        }

        if Cache == nil {
                Cache = make(map[string]image.Image)
        }
        cnm := str
        if img, ok := Cache[cnm]; ok {
                // TODO(kai): do we need to clone?
                return img, nil
        }

        str = strings.TrimSpace(str)
        if strings.HasPrefix(str, "url(") {
                img := cc.ImageByURL(str)
                if img == nil {
                        return nil, fmt.Errorf("unable to find url %q", str)
                }
                return img, nil
        }
        str = strings.ToLower(str)
        grad := "-gradient"

        gidx := strings.Index(str, grad)
        if gidx <= 0 {
                s, err := colors.FromString(str, cc.Base())
                if err != nil {
                        return nil, err
                }
                return colors.Uniform(s), nil
        }

        gtyp := str[:gidx]
        rmdr := str[gidx+len(grad):]
        pidx := strings.IndexByte(rmdr, '(')
        if pidx < 0 {
                return nil, fmt.Errorf("gradient specified but parameters not found in string %q", str)
        }
        pars := rmdr[pidx+1:]
        pars = strings.TrimSuffix(pars, ");")
        pars = strings.TrimSuffix(pars, ")")

        switch gtyp {
        case "linear", "repeating-linear":
                l := NewLinear()
                if gtyp == "repeating-linear" {
                        l.SetSpread(Repeat)
                }
                err := l.SetString(pars)
                if err != nil {
                        return nil, err
                }
                fixGradientStops(l.Stops)
                Cache[cnm] = l
                return l, nil
        case "radial", "repeating-radial":
                r := NewRadial()
                if gtyp == "repeating-radial" {
                        r.SetSpread(Repeat)
                }
                err := r.SetString(pars)
                if err != nil {
                        return nil, err
                }
                fixGradientStops(r.Stops)
                Cache[cnm] = r
                return r, nil
        }
        return nil, fmt.Errorf("got unknown gradient type %q", gtyp)
}

// FromAny returns the color image specified by the given value of any type in the
// given Context. It handles values of types [color.Color], [image.Image], and string.
// If no Context is provided, it uses [BaseContext] with [Transparent].
func FromAny(val any, ctx ...colors.Context) (image.Image, error) {
        switch v := val.(type) {
        case color.Color:
                return colors.Uniform(v), nil
        case image.Image:
                return v, nil
        case string:
                return FromString(v, ctx...)
        }
        return nil, fmt.Errorf("gradient.FromAny: got unsupported type %T", val)
}

// gradientDegToSides maps gradient degree notation to side notation
var gradientDegToSides = map[string]string{
        "0deg":    "top",
        "360deg":  "top",
        "45deg":   "top right",
        "-315deg": "top right",
        "90deg":   "right",
        "-270deg": "right",
        "135deg":  "bottom right",
        "-225deg": "bottom right",
        "180deg":  "bottom",
        "-180deg": "bottom",
        "225deg":  "bottom left",
        "-135deg": "bottom left",
        "270deg":  "left",
        "-90deg":  "left",
        "315deg":  "top left",
        "-45deg":  "top left",
}

// SetString sets the linear gradient from the given CSS linear gradient string
// (only the part inside of "linear-gradient(...)") (see
// https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/linear-gradient)
func (l *Linear) SetString(str string) error {
        // TODO(kai): not fully following spec yet
        plist := strings.Split(str, ", ")
        var prevColor color.Color
        stopIndex := 0
outer:
        for pidx := 0; pidx < len(plist); pidx++ {
                par := strings.TrimRight(strings.TrimSpace(plist[pidx]), ",")
                origPar := par
                switch {
                case strings.Contains(par, "deg"):
                        // TODO(kai): this is not true and should be fixed to use trig
                        // can't use trig, b/c need to be full 1, 0 values -- just use map
                        var ok bool
                        par, ok = gradientDegToSides[par]
                        if !ok {
                                return fmt.Errorf("invalid gradient angle %q: must be at 45 degree increments", origPar)
                        }
                        par = "to " + par
                        fallthrough
                case strings.HasPrefix(par, "to "):
                        sides := strings.Split(par[3:], " ")
                        l.Start, l.End = math32.Vector2{}, math32.Vector2{}
                        for _, side := range sides {
                                switch side {
                                case "bottom":
                                        l.Start.Y = 0
                                        l.End.Y = 1
                                case "top":
                                        l.Start.Y = 1
                                        l.End.Y = 0
                                case "right":
                                        l.Start.X = 0
                                        l.End.X = 1
                                case "left":
                                        l.Start.X = 1
                                        l.End.X = 0
                                }
                        }
                case strings.HasPrefix(par, ")"):
                        break outer
                default: // must be a color stop
                        var stop *Stop
                        if len(l.Stops) > stopIndex {
                                stop = &(l.Stops[stopIndex])
                        } else {
                                stop = &Stop{Opacity: 1}
                        }
                        err := parseColorStop(stop, prevColor, par)
                        if err != nil {
                                return err
                        }
                        if len(l.Stops) <= stopIndex {
                                l.Stops = append(l.Stops, *stop)
                        }
                        prevColor = stop.Color
                        stopIndex++
                }
        }
        if len(l.Stops) > stopIndex {
                l.Stops = l.Stops[:stopIndex]
        }
        return nil
}

// SetString sets the radial gradient from the given CSS radial gradient string
// (only the part inside of "radial-gradient(...)") (see
// https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/radial-gradient)
func (r *Radial) SetString(str string) error {
        // TODO(kai): not fully following spec yet
        plist := strings.Split(str, ", ")
        var prevColor color.Color
        stopIndex := 0
outer:
        for pidx := 0; pidx < len(plist); pidx++ {
                par := strings.TrimRight(strings.TrimSpace(plist[pidx]), ",")

                // currently we just ignore circle and ellipse, but we should handle them at some point
                par = strings.TrimPrefix(par, "circle")
                par = strings.TrimPrefix(par, "ellipse")
                par = strings.TrimLeft(par, " ")
                switch {
                case strings.HasPrefix(par, "at "):
                        sides := strings.Split(par[3:], " ")
                        for _, side := range sides {
                                switch side {
                                case "bottom":
                                        r.Center.Set(0.5, 1)
                                case "top":
                                        r.Center.Set(0.5, 0)
                                case "right":
                                        r.Center.Set(1, 0.5)
                                case "left":
                                        r.Center.Set(0, 0.5)
                                case "center":
                                        r.Center.Set(0.5, 0.5)
                                }
                                r.Focal = r.Center
                        }
                case strings.HasPrefix(par, ")"):
                        break outer
                default: // must be a color stop
                        var stop *Stop
                        if len(r.Stops) > stopIndex {
                                stop = &r.Stops[stopIndex]
                        } else {
                                stop = &Stop{Opacity: 1}
                        }
                        err := parseColorStop(stop, prevColor, par)
                        if err != nil {
                                return err
                        }
                        if len(r.Stops) <= stopIndex {
                                r.Stops = append(r.Stops, *stop)
                        }
                        prevColor = stop.Color
                        stopIndex++
                }
        }
        if len(r.Stops) > stopIndex {
                r.Stops = r.Stops[:stopIndex]
        }
        return nil
}

// parseColorStop parses the given color stop based on the given previous color
// and parent gradient string.
func parseColorStop(stop *Stop, prev color.Color, par string) error {
        cnm := par
        if spcidx := strings.Index(par, " "); spcidx > 0 {
                cnm = par[:spcidx]
                offs := strings.TrimSpace(par[spcidx+1:])
                off, err := readFraction(offs)
                if err != nil {
                        return fmt.Errorf("invalid offset %q: %w", offs, err)
                }
                stop.Pos = off
        }
        clr, err := colors.FromString(cnm, prev)
        if err != nil {
                return fmt.Errorf("got invalid color string %q: %w", cnm, err)
        }
        stop.Color = clr
        return nil
}

// NOTE: XML marshalling functionality is at [cogentcore.org/core/svg.MarshalXMLGradient] instead of here
// because it uses a lot of SVG and XML infrastructure defined there.

// ReadXML reads an XML-formatted gradient color from the given io.Reader and
// sets the properties of the given gradient accordingly.
func ReadXML(g *Gradient, reader io.Reader) error {
        decoder := xml.NewDecoder(reader)
        decoder.CharsetReader = charset.NewReaderLabel

        for {
                t, err := decoder.Token()
                if err != nil {
                        if err == io.EOF {
                                break
                        }
                        return fmt.Errorf("error parsing color xml: %w", err)
                }
                switch se := t.(type) {
                case xml.StartElement:
                        return UnmarshalXML(g, decoder, se)
                        // todo: ignore rest?
                }
        }
        return nil
}

// UnmarshalXML parses the given XML gradient color data and sets the properties
// of the given gradient accordingly.
func UnmarshalXML(g *Gradient, decoder *xml.Decoder, se xml.StartElement) error {
        start := &se

        for {
                var t xml.Token
                var err error
                if start != nil {
                        t = *start
                        start = nil
                } else {
                        t, err = decoder.Token()
                }
                if err != nil {
                        if err == io.EOF {
                                break
                        }
                        return fmt.Errorf("error parsing color: %w", err)
                }
                switch se := t.(type) {
                case xml.StartElement:
                        switch se.Name.Local {
                        case "linearGradient":
                                l := NewLinear().SetEnd(math32.Vec2(1, 0)) // SVG is LTR by default

                                // if we don't already have a gradient, we use this one
                                if *g == nil {
                                        *g = l
                                } else if pl, ok := (*g).(*Linear); ok {
                                        // if our previous gradient is also linear, we build on it
                                        l = pl
                                }
                                // fmt.Printf("lingrad %v\n", cs.Gradient)
                                for _, attr := range se.Attr {
                                        // fmt.Printf("attr: %v val: %v\n", attr.Name.Local, attr.Value)
                                        switch attr.Name.Local {
                                        // note: id not processed here - must be done externally
                                        case "x1":
                                                l.Start.X, err = readFraction(attr.Value)
                                        case "y1":
                                                l.Start.Y, err = readFraction(attr.Value)
                                        case "x2":
                                                l.End.X, err = readFraction(attr.Value)
                                        case "y2":
                                                l.End.Y, err = readFraction(attr.Value)
                                        default:
                                                err = readGradAttr(*g, attr)
                                        }
                                        if err != nil {
                                                return fmt.Errorf("error parsing linear gradient: %w", err)
                                        }
                                }
                        case "radialGradient":
                                r := NewRadial()

                                // if we don't already have a gradient, we use this one
                                if *g == nil {
                                        *g = r
                                } else if pr, ok := (*g).(*Radial); ok {
                                        // if our previous gradient is also radial, we build on it
                                        r = pr
                                }
                                var setFx, setFy bool
                                for _, attr := range se.Attr {
                                        switch attr.Name.Local {
                                        // note: id not processed here - must be done externally
                                        case "r":
                                                var radius float32
                                                radius, err = readFraction(attr.Value)
                                                r.Radius.SetScalar(radius)
                                        case "cx":
                                                r.Center.X, err = readFraction(attr.Value)
                                        case "cy":
                                                r.Center.Y, err = readFraction(attr.Value)
                                        case "fx":
                                                setFx = true
                                                r.Focal.X, err = readFraction(attr.Value)
                                        case "fy":
                                                setFy = true
                                                r.Focal.Y, err = readFraction(attr.Value)
                                        default:
                                                err = readGradAttr(*g, attr)
                                        }
                                        if err != nil {
                                                return fmt.Errorf("error parsing radial gradient: %w", err)
                                        }
                                }
                                if !setFx { // set fx to cx by default
                                        r.Focal.X = r.Center.X
                                }
                                if !setFy { // set fy to cy by default
                                        r.Focal.Y = r.Center.Y
                                }
                        case "stop":
                                stop := Stop{Color: colors.Black, Opacity: 1}
                                ats := se.Attr
                                sty := XMLAttr("style", ats)
                                if sty != "" {
                                        spl := strings.Split(sty, ";")
                                        for _, s := range spl {
                                                s := strings.TrimSpace(s)
                                                ci := strings.IndexByte(s, ':')
                                                if ci < 0 {
                                                        continue
                                                }
                                                a := xml.Attr{}
                                                a.Name.Local = s[:ci]
                                                a.Value = s[ci+1:]
                                                ats = append(ats, a)
                                        }
                                }
                                for _, attr := range ats {
                                        switch attr.Name.Local {
                                        case "offset":
                                                stop.Pos, err = readFraction(attr.Value)
                                                if err != nil {
                                                        return err
                                                }
                                        case "stop-color":
                                                clr, err := colors.FromString(attr.Value)
                                                if err != nil {
                                                        return fmt.Errorf("invalid color string: %w", err)
                                                }
                                                stop.Color = clr
                                        case "stop-opacity":
                                                opacity, err := readFraction(attr.Value)
                                                if err != nil {
                                                        return fmt.Errorf("invalid stop opacity: %w", err)
                                                }
                                                stop.Opacity = opacity
                                        }
                                }
                                if g == nil {
                                        return fmt.Errorf("got stop outside of gradient: %v", stop)
                                }
                                gb := (*g).AsBase()
                                gb.Stops = append(gb.Stops, stop)

                        default:
                                return fmt.Errorf("cannot process svg element %q", se.Name.Local)
                        }
                case xml.EndElement:
                        if se.Name.Local == "linearGradient" || se.Name.Local == "radialGradient" {
                                return nil
                        }
                        if se.Name.Local != "stop" {
                                return fmt.Errorf("got unexpected end element: %v", se.Name.Local)
                        }
                case xml.CharData:
                }
        }
        return nil
}

// readFraction reads a decimal value from the given string.
func readFraction(v string) (float32, error) {
        v = strings.TrimSpace(v)
        d := float32(1)
        if strings.HasSuffix(v, "%") {
                d = 100
                v = strings.TrimSuffix(v, "%")
        }
        f64, err := strconv.ParseFloat(v, 32)
        if err != nil {
                return 0, err
        }
        f := float32(f64)
        f /= d
        if f < 0 {
                f = 0
        }
        return f, nil
}

// readGradAttr reads the given xml attribute onto the given gradient.
func readGradAttr(g Gradient, attr xml.Attr) error {
        gb := g.AsBase()
        switch attr.Name.Local {
        case "gradientTransform":
                err := gb.Transform.SetString(attr.Value)
                if err != nil {
                        return err
                }
        case "gradientUnits":
                return gb.Units.SetString(strings.TrimSpace(attr.Value))
        case "spreadMethod":
                return gb.Spread.SetString(strings.TrimSpace(attr.Value))
        }
        return nil
}

// fixGradientStops applies the CSS rules to regularize the given gradient stops:
// https://www.w3.org/TR/css3-images/#color-stop-syntax
func fixGradientStops(stops []Stop) {
        sz := len(stops)
        if sz == 0 {
                return
        }
        splitSt := -1
        last := float32(0)
        for i := 0; i < sz; i++ {
                st := &stops[i]
                if i == sz-1 && st.Pos == 0 {
                        if last < 1.0 {
                                st.Pos = 1.0
                        } else {
                                st.Pos = last
                        }
                }
                if i > 0 && st.Pos == 0 && splitSt < 0 {
                        splitSt = i
                        st.Pos = last
                        continue
                }
                if splitSt > 0 {
                        start := stops[splitSt].Pos
                        end := st.Pos
                        per := (end - start) / float32(1+(i-splitSt))
                        cur := start + per
                        for j := splitSt; j < i; j++ {
                                stops[j].Pos = cur
                                cur += per
                        }
                }
                last = st.Pos
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/rasterx:
// Copyright 2018 by the rasterx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

package gradient

import (
        "image/color"

        "cogentcore.org/core/math32"
)

// Radial represents a radial gradient. It implements the [image.Image] interface.
type Radial struct { //types:add -setters
        Base

        // the center point of the gradient (cx and cy in SVG)
        Center math32.Vector2

        // the focal point of the gradient (fx and fy in SVG)
        Focal math32.Vector2

        // the radius of the gradient (rx and ry in SVG)
        Radius math32.Vector2

        // computed current render versions transformed by object matrix
        rCenter math32.Vector2
        rFocal  math32.Vector2
        rRadius math32.Vector2
}

var _ Gradient = &Radial{}

// NewRadial returns a new centered [Radial] gradient.
func NewRadial() *Radial {
        return &Radial{
                Base: NewBase(),
                // default is fully centered
                Center: math32.Vector2Scalar(0.5),
                Focal:  math32.Vector2Scalar(0.5),
                Radius: math32.Vector2Scalar(0.5),
        }
}

// AddStop adds a new stop with the given color, position, and
// optional opacity to the gradient.
func (r *Radial) AddStop(color color.RGBA, pos float32, opacity ...float32) *Radial {
        r.Base.AddStop(color, pos, opacity...)
        return r
}

// Update updates the computed fields of the gradient, using
// the given current bounding box, and additional
// object-level transform (i.e., the current painting transform),
// which is applied in addition to the gradient's own Transform.
// This must be called before rendering the gradient, and it should only be called then.
func (r *Radial) Update(opacity float32, box math32.Box2, objTransform math32.Matrix2) {
        r.Box = box
        r.Opacity = opacity
        r.updateBase()

        c, f, rs := r.Center, r.Focal, r.Radius
        sz := r.Box.Size()
        if r.Units == ObjectBoundingBox {
                c = r.Box.Min.Add(sz.Mul(c))
                f = r.Box.Min.Add(sz.Mul(f))
                rs.SetMul(sz)
        } else {
                c = r.Transform.MulVector2AsPoint(c)
                f = r.Transform.MulVector2AsPoint(f)
                rs = r.Transform.MulVector2AsVector(rs)
                c = objTransform.MulVector2AsPoint(c)
                f = objTransform.MulVector2AsPoint(f)
                rs = objTransform.MulVector2AsVector(rs)
        }
        if c != f {
                f.SetDiv(rs)
                c.SetDiv(rs)
                df := f.Sub(c)
                if df.X*df.X+df.Y*df.Y > 1 { // Focus outside of circle; use intersection
                        // point of line from center to focus and circle as per SVG specs.
                        nf, intersects := rayCircleIntersectionF(f, c, c, 1-epsilonF)
                        f = nf
                        if !intersects {
                                f.Set(0, 0)
                        }
                }
        }
        r.rCenter, r.rFocal, r.rRadius = c, f, rs
}

const epsilonF = 1e-5

// At returns the color of the radial gradient at the given point
func (r *Radial) At(x, y int) color.Color {
        switch len(r.Stops) {
        case 0:
                return color.RGBA{}
        case 1:
                return r.Stops[0].Color
        }

        if r.rCenter == r.rFocal {
                // When the center and focal are the same things are much simpler;
                // pos is just distance from center scaled by radius
                pt := math32.Vec2(float32(x)+0.5, float32(y)+0.5)
                if r.Units == ObjectBoundingBox {
                        pt = r.boxTransform.MulVector2AsPoint(pt)
                }
                d := pt.Sub(r.rCenter)
                pos := math32.Sqrt(d.X*d.X/(r.rRadius.X*r.rRadius.X) + (d.Y*d.Y)/(r.rRadius.Y*r.rRadius.Y))
                return r.getColor(pos)
        }
        if r.rFocal == math32.Vec2(0, 0) {
                return color.RGBA{} // should not happen
        }

        pt := math32.Vec2(float32(x)+0.5, float32(y)+0.5)
        if r.Units == ObjectBoundingBox {
                pt = r.boxTransform.MulVector2AsPoint(pt)
        }
        e := pt.Div(r.rRadius)

        t1, intersects := rayCircleIntersectionF(e, r.rFocal, r.rCenter, 1)
        if !intersects { // In this case, use the last stop color
                s := r.Stops[len(r.Stops)-1]
                return s.Color
        }

        td := t1.Sub(r.rFocal)
        d := e.Sub(r.rFocal)
        if td.X*td.X+td.Y*td.Y < epsilonF {
                s := r.Stops[len(r.Stops)-1]
                return s.Color
        }

        pos := math32.Sqrt(d.X*d.X+d.Y*d.Y) / math32.Sqrt(td.X*td.X+td.Y*td.Y)
        return r.getColor(pos)
}

// rayCircleIntersectionF calculates in floating point the points of intersection of
// a ray starting at s2 passing through s1 and a circle in fixed point.
// Returns intersects == false if no solution is possible. If two
// solutions are possible, the point closest to s2 is returned.
func rayCircleIntersectionF(s1, s2, c math32.Vector2, r float32) (pt math32.Vector2, intersects bool) {
        n := s2.X - c.X // Calculating using 64* rather than divide
        m := s2.Y - c.Y

        e := s2.X - s1.X
        d := s2.Y - s1.Y

        // Quadratic normal form coefficients
        A, B, C := e*e+d*d, -2*(e*n+m*d), n*n+m*m-r*r

        D := B*B - 4*A*C

        if D <= 0 {
                return // No intersection or is tangent
        }

        D = math32.Sqrt(D)
        t1, t2 := (-B+D)/(2*A), (-B-D)/(2*A)
        p1OnSide := t1 > 0
        p2OnSide := t2 > 0

        switch {
        case p1OnSide && p2OnSide:
                if t2 < t1 { // both on ray, use closest to s2
                        t1 = t2
                }
        case p2OnSide: // Only p2 on ray
                t1 = t2
        case p1OnSide: // only p1 on ray
        default: // Neither solution is on the ray
                return
        }
        return math32.Vec2((n-e*t1)+c.X, (m-d*t1)+c.Y), true
}

// Code generated by "core generate"; DO NOT EDIT.

package gradient

import (
        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/colors/gradient.Base", IDName: "base", Doc: "Base contains the data and logic common to all gradient types.", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Fields: []types.Field{{Name: "Stops", Doc: "the stops for the gradient; use AddStop to add stops"}, {Name: "Spread", Doc: "the spread method used for the gradient if it stops before the end"}, {Name: "Blend", Doc: "the colorspace algorithm to use for blending colors"}, {Name: "Units", Doc: "the units to use for the gradient"}, {Name: "Box", Doc: "the bounding box of the object with the gradient; this is used when rendering\ngradients with [Units] of [ObjectBoundingBox]."}, {Name: "Transform", Doc: "Transform is the gradient's own transformation matrix applied to the gradient's points.\nThis is a property of the Gradient itself."}, {Name: "Opacity", Doc: "Opacity is the overall object opacity multiplier, applied in conjunction with the\nstop-level opacity blending."}, {Name: "ApplyFuncs", Doc: "ApplyFuncs contains functions that are applied to the color after gradient color is generated.\nThis allows for efficient StateLayer and other post-processing effects\nto be applied.  The Applier handles other cases, but gradients always\nmust have the Update function called at render time, so they must\nremain Gradient types."}, {Name: "boxTransform", Doc: "boxTransform is the Transform applied to the bounding Box,\nonly for [Units] == [ObjectBoundingBox]."}, {Name: "stopsRGB", Doc: "stopsRGB are the computed RGB stops for blend types other than RGB"}, {Name: "stopsRGBSrc", Doc: "stopsRGBSrc are the source Stops when StopsRGB were last computed"}}})

// SetSpread sets the [Base.Spread]:
// the spread method used for the gradient if it stops before the end
func (t *Base) SetSpread(v Spreads) *Base { t.Spread = v; return t }

// SetBlend sets the [Base.Blend]:
// the colorspace algorithm to use for blending colors
func (t *Base) SetBlend(v colors.BlendTypes) *Base { t.Blend = v; return t }

// SetUnits sets the [Base.Units]:
// the units to use for the gradient
func (t *Base) SetUnits(v Units) *Base { t.Units = v; return t }

// SetBox sets the [Base.Box]:
// the bounding box of the object with the gradient; this is used when rendering
// gradients with [Units] of [ObjectBoundingBox].
func (t *Base) SetBox(v math32.Box2) *Base { t.Box = v; return t }

// SetTransform sets the [Base.Transform]:
// Transform is the gradient's own transformation matrix applied to the gradient's points.
// This is a property of the Gradient itself.
func (t *Base) SetTransform(v math32.Matrix2) *Base { t.Transform = v; return t }

// SetOpacity sets the [Base.Opacity]:
// Opacity is the overall object opacity multiplier, applied in conjunction with the
// stop-level opacity blending.
func (t *Base) SetOpacity(v float32) *Base { t.Opacity = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/colors/gradient.Linear", IDName: "linear", Doc: "Linear represents a linear gradient. It implements the [image.Image] interface.", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Embeds: []types.Field{{Name: "Base"}}, Fields: []types.Field{{Name: "Start", Doc: "the starting point of the gradient (x1 and y1 in SVG)"}, {Name: "End", Doc: "the ending point of the gradient (x2 and y2 in SVG)"}, {Name: "rStart", Doc: "computed current render versions transformed by object matrix"}, {Name: "rEnd"}, {Name: "distance"}, {Name: "distanceLengthSquared"}}})

// SetStart sets the [Linear.Start]:
// the starting point of the gradient (x1 and y1 in SVG)
func (t *Linear) SetStart(v math32.Vector2) *Linear { t.Start = v; return t }

// SetEnd sets the [Linear.End]:
// the ending point of the gradient (x2 and y2 in SVG)
func (t *Linear) SetEnd(v math32.Vector2) *Linear { t.End = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/colors/gradient.Radial", IDName: "radial", Doc: "Radial represents a radial gradient. It implements the [image.Image] interface.", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Embeds: []types.Field{{Name: "Base"}}, Fields: []types.Field{{Name: "Center", Doc: "the center point of the gradient (cx and cy in SVG)"}, {Name: "Focal", Doc: "the focal point of the gradient (fx and fy in SVG)"}, {Name: "Radius", Doc: "the radius of the gradient (rx and ry in SVG)"}, {Name: "rCenter", Doc: "current render version -- transformed by object matrix"}, {Name: "rFocal", Doc: "current render version -- transformed by object matrix"}, {Name: "rRadius", Doc: "current render version -- transformed by object matrix"}}})

// SetCenter sets the [Radial.Center]:
// the center point of the gradient (cx and cy in SVG)
func (t *Radial) SetCenter(v math32.Vector2) *Radial { t.Center = v; return t }

// SetFocal sets the [Radial.Focal]:
// the focal point of the gradient (fx and fy in SVG)
func (t *Radial) SetFocal(v math32.Vector2) *Radial { t.Focal = v; return t }

// SetRadius sets the [Radial.Radius]:
// the radius of the gradient (rx and ry in SVG)
func (t *Radial) SetRadius(v math32.Vector2) *Radial { t.Radius = v; return t }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package colors

import (
        "image"
        "image/color"
)

// Uniform returns a new [image.Uniform] filled completely with the given color.
// See [ToUniform] for the converse.
func Uniform(c color.Color) image.Image {
        return image.NewUniform(c)
}

// ToUniform converts the given image to a uniform [color.RGBA] color.
// See [Uniform] for the converse.
func ToUniform(img image.Image) color.RGBA {
        if img == nil {
                return color.RGBA{}
        }
        return AsRGBA(img.At(0, 0))
}

// Pattern returns a new unbounded [image.Image] represented by the given pattern function.
func Pattern(f func(x, y int) color.Color) image.Image {
        return &pattern{f}
}

type pattern struct {
        f func(x, y int) color.Color
}

func (p *pattern) ColorModel() color.Model {
        return color.RGBAModel
}

func (p *pattern) Bounds() image.Rectangle {
        return image.Rect(-1e9, -1e9, 1e9, 1e9)
}

func (p *pattern) At(x, y int) color.Color {
        return p.f(x, y)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package colors

import (
        "image/color"

        "cogentcore.org/core/colors/matcolor"
)

// Palette contains the main, global [MatPalette]. It can
// be used by end-user code for accessing tonal palette values,
// although [Scheme] is a more typical way to access the color
// scheme values. It defaults to a palette based around a
// primary color of Google Blue (#4285f4)
var Palette = matcolor.NewPalette(matcolor.KeyFromPrimary(color.RGBA{66, 133, 244, 255}))

// Schemes are the main global Material Design 3 color schemes.
// They should not be used for accessing the current color scheme;
// see [Scheme] for that. Instead, they should be set if you want
// to define your own custom color schemes for your app. The recommended
// way to set the Schemes is through the [SetSchemes] function.
var Schemes = matcolor.NewSchemes(Palette)

// Scheme is the main currently active global Material Design 3
// color scheme. It is the main way that end-user code should
// access the color scheme; ideally, almost all color values should
// be set to something in here. For more specific tones of colors,
// see [Palette]. For setting the color schemes of your app, see
// [Schemes] and [SetSchemes]. For setting this scheme to
// be light or dark, see [SetScheme].
var Scheme = &Schemes.Light

// SetSchemes sets [Schemes], [Scheme], and [Palette] based on the
// given primary color. It is the main way that end-user code should
// set the color schemes to something custom. For more specific control,
// see [SetSchemesFromKey].
func SetSchemes(primary color.RGBA) {
        SetSchemesFromKey(matcolor.KeyFromPrimary(primary))
}

// SetSchemes sets [Schemes], [Scheme], and [Palette] based on the
// given [matcolor.Key]. It should be used instead of [SetSchemes]
// if you want more specific control over the color scheme.
func SetSchemesFromKey(key *matcolor.Key) {
        Palette = matcolor.NewPalette(key)
        Schemes = matcolor.NewSchemes(Palette)
        SetScheme(matcolor.SchemeIsDark)
}

// SetScheme sets the value of [Scheme] to either [Schemes.Dark]
// or [Schemes.Light], based on the given value of whether the
// color scheme should be dark. It also sets the value of
// [matcolor.SchemeIsDark].
func SetScheme(isDark bool) {
        matcolor.SchemeIsDark = isDark
        if isDark {
                Scheme = &Schemes.Dark
        } else {
                Scheme = &Schemes.Light
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package matcolor

import (
        "image"
)

// Accent contains the four standard variations of a base accent color.
type Accent struct {

        // Base is the base color for typically high-emphasis content.
        Base image.Image

        // On is the color applied to content on top of [Accent.Base].
        On image.Image

        // Container is the color applied to elements with less emphasis than [Accent.Base].
        Container image.Image

        // OnContainer is the color applied to content on top of [Accent.Container].
        OnContainer image.Image
}

// NewAccentLight returns a new light theme [Accent] from the given [Tones].
func NewAccentLight(tones Tones) Accent {
        return Accent{
                Base:        tones.AbsToneUniform(40),
                On:          tones.AbsToneUniform(100),
                Container:   tones.AbsToneUniform(90),
                OnContainer: tones.AbsToneUniform(10),
        }
}

// NewAccentDark returns a new dark theme [Accent] from the given [Tones].
func NewAccentDark(tones Tones) Accent {
        return Accent{
                Base:        tones.AbsToneUniform(80),
                On:          tones.AbsToneUniform(20),
                Container:   tones.AbsToneUniform(30),
                OnContainer: tones.AbsToneUniform(90),
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/material-foundation/material-color-utilities/blob/main/dart/lib/palettes/core_palette.dart
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package matcolor

import (
        "image/color"

        "cogentcore.org/core/colors/cam/hct"
)

// Key contains the set of key colors used to generate
// a [Scheme] and [Palette]
type Key struct {

        // the primary accent key color
        Primary color.RGBA

        // the secondary accent key color
        Secondary color.RGBA

        // the tertiary accent key color
        Tertiary color.RGBA

        // the select accent key color
        Select color.RGBA

        // the error accent key color
        Error color.RGBA

        // the success accent key color
        Success color.RGBA

        // the warn accent key color
        Warn color.RGBA

        // the neutral key color used to generate surface and surface container colors
        Neutral color.RGBA

        // the neutral variant key color used to generate surface variant and outline colors
        NeutralVariant color.RGBA

        // an optional map of custom accent key colors
        Custom map[string]color.RGBA
}

// Key returns a new [Key] from the given primary accent key color.
func KeyFromPrimary(primary color.RGBA) *Key {
        k := &Key{}
        p := hct.FromColor(primary)
        p.SetTone(40)

        k.Primary = p.WithChroma(max(p.Chroma, 48)).AsRGBA()
        k.Secondary = p.WithChroma(16).AsRGBA()
        // Material adds 60, but we subtract 60 to get green instead of pink when specifying
        // blue (TODO: is this a good idea, or should we just follow Material?)
        k.Tertiary = p.WithHue(p.Hue - 60).WithChroma(24).AsRGBA()
        k.Select = p.WithChroma(24).AsRGBA()
        k.Error = color.RGBA{179, 38, 30, 255}   // #B3261E (Material default error color)
        k.Success = color.RGBA{50, 168, 50, 255} // #32a832 (arbitrarily chosen; TODO: maybe come up with a better default success color)
        k.Warn = color.RGBA{168, 143, 50, 255}   // #a88f32 (arbitrarily chosen; TODO: maybe come up with a better default warn color)
        k.Neutral = p.WithChroma(4).AsRGBA()
        k.NeutralVariant = p.WithChroma(8).AsRGBA()
        return k
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package matcolor

// Palette contains a tonal palette with tonal values
// for each of the standard colors and any custom colors.
// Use [NewPalette] to create a new palette.
type Palette struct {

        // the tones for the primary key color
        Primary Tones

        // the tones for the secondary key color
        Secondary Tones

        // the tones for the tertiary key color
        Tertiary Tones

        // the tones for the select key color
        Select Tones

        // the tones for the error key color
        Error Tones

        // the tones for the success key color
        Success Tones

        // the tones for the warn key color
        Warn Tones

        // the tones for the neutral key color
        Neutral Tones

        // the tones for the neutral variant key color
        NeutralVariant Tones

        // an optional map of tones for custom accent key colors
        Custom map[string]Tones
}

// NewPalette creates a new [Palette] from the given key colors.
func NewPalette(key *Key) *Palette {
        p := &Palette{
                Primary:        NewTones(key.Primary),
                Secondary:      NewTones(key.Secondary),
                Tertiary:       NewTones(key.Tertiary),
                Select:         NewTones(key.Select),
                Error:          NewTones(key.Error),
                Success:        NewTones(key.Success),
                Warn:           NewTones(key.Warn),
                Neutral:        NewTones(key.Neutral),
                NeutralVariant: NewTones(key.NeutralVariant),
        }
        for name, c := range key.Custom {
                p.Custom[name] = NewTones(c)
        }
        return p
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package matcolor

import (
        "image"
        "image/color"
)

//go:generate core generate

// Scheme contains the colors for one color scheme (ex: light or dark).
// To generate a scheme, use [NewScheme].
type Scheme struct {

        // Primary is the primary color applied to important elements
        Primary Accent

        // Secondary is the secondary color applied to less important elements
        Secondary Accent

        // Tertiary is the tertiary color applied as an accent to highlight elements and create contrast between other colors
        Tertiary Accent

        // Select is the selection color applied to selected or highlighted elements and text
        Select Accent

        // Error is the error color applied to elements that indicate an error or danger
        Error Accent

        // Success is the color applied to elements that indicate success
        Success Accent

        // Warn is the color applied to elements that indicate a warning
        Warn Accent

        // an optional map of custom accent colors
        Custom map[string]Accent

        // SurfaceDim is the color applied to elements that will always have the dimmest surface color (see Surface for more information)
        SurfaceDim image.Image

        // Surface is the color applied to contained areas, like the background of an app
        Surface image.Image

        // SurfaceBright is the color applied to elements that will always have the brightest surface color (see Surface for more information)
        SurfaceBright image.Image

        // SurfaceContainerLowest is the color applied to surface container elements that have the lowest emphasis (see SurfaceContainer for more information)
        SurfaceContainerLowest image.Image

        // SurfaceContainerLow is the color applied to surface container elements that have lower emphasis (see SurfaceContainer for more information)
        SurfaceContainerLow image.Image

        // SurfaceContainer is the color applied to container elements that contrast elements with the surface color
        SurfaceContainer image.Image

        // SurfaceContainerHigh is the color applied to surface container elements that have higher emphasis (see SurfaceContainer for more information)
        SurfaceContainerHigh image.Image

        // SurfaceContainerHighest is the color applied to surface container elements that have the highest emphasis (see SurfaceContainer for more information)
        SurfaceContainerHighest image.Image

        // SurfaceVariant is the color applied to contained areas that contrast standard Surface elements
        SurfaceVariant image.Image

        // OnSurface is the color applied to content on top of Surface elements
        OnSurface image.Image

        // OnSurfaceVariant is the color applied to content on top of SurfaceVariant elements
        OnSurfaceVariant image.Image

        // InverseSurface is the color applied to elements to make them the reverse color of the surrounding elements and create a contrasting effect
        InverseSurface image.Image

        // InverseOnSurface is the color applied to content on top of InverseSurface
        InverseOnSurface image.Image

        // InversePrimary is the color applied to interactive elements on top of InverseSurface
        InversePrimary image.Image

        // Background is the color applied to the background of the app and other low-emphasis areas
        Background image.Image

        // OnBackground is the color applied to content on top of Background
        OnBackground image.Image

        // Outline is the color applied to borders to create emphasized boundaries that need to have sufficient contrast
        Outline image.Image

        // OutlineVariant is the color applied to create decorative boundaries
        OutlineVariant image.Image

        // Shadow is the color applied to shadows
        Shadow image.Image

        // SurfaceTint is the color applied to tint surfaces
        SurfaceTint image.Image

        // Scrim is the color applied to scrims (semi-transparent overlays)
        Scrim image.Image
}

// NewLightScheme returns a new light-themed [Scheme]
// based on the given [Palette].
func NewLightScheme(p *Palette) Scheme {
        s := Scheme{
                Primary:   NewAccentLight(p.Primary),
                Secondary: NewAccentLight(p.Secondary),
                Tertiary:  NewAccentLight(p.Tertiary),
                Select:    NewAccentLight(p.Select),
                Error:     NewAccentLight(p.Error),
                Success:   NewAccentLight(p.Success),
                Warn:      NewAccentLight(p.Warn),
                Custom:    map[string]Accent{},

                SurfaceDim:    p.Neutral.AbsToneUniform(87),
                Surface:       p.Neutral.AbsToneUniform(98),
                SurfaceBright: p.Neutral.AbsToneUniform(98),

                SurfaceContainerLowest:  p.Neutral.AbsToneUniform(100),
                SurfaceContainerLow:     p.Neutral.AbsToneUniform(96),
                SurfaceContainer:        p.Neutral.AbsToneUniform(94),
                SurfaceContainerHigh:    p.Neutral.AbsToneUniform(92),
                SurfaceContainerHighest: p.Neutral.AbsToneUniform(90),

                SurfaceVariant:   p.NeutralVariant.AbsToneUniform(90),
                OnSurface:        p.NeutralVariant.AbsToneUniform(10),
                OnSurfaceVariant: p.NeutralVariant.AbsToneUniform(30),

                InverseSurface:   p.Neutral.AbsToneUniform(20),
                InverseOnSurface: p.Neutral.AbsToneUniform(95),
                InversePrimary:   p.Primary.AbsToneUniform(80),

                Background:   p.Neutral.AbsToneUniform(98),
                OnBackground: p.Neutral.AbsToneUniform(10),

                Outline:        p.NeutralVariant.AbsToneUniform(50),
                OutlineVariant: p.NeutralVariant.AbsToneUniform(80),

                Shadow:      p.Neutral.AbsToneUniform(0),
                SurfaceTint: p.Primary.AbsToneUniform(40),
                Scrim:       p.Neutral.AbsToneUniform(0),
        }
        for nm, c := range p.Custom {
                s.Custom[nm] = NewAccentLight(c)
        }
        return s
        // TODO: maybe fixed colors
}

// NewDarkScheme returns a new dark-themed [Scheme]
// based on the given [Palette].
func NewDarkScheme(p *Palette) Scheme {
        s := Scheme{
                Primary:   NewAccentDark(p.Primary),
                Secondary: NewAccentDark(p.Secondary),
                Tertiary:  NewAccentDark(p.Tertiary),
                Select:    NewAccentDark(p.Select),
                Error:     NewAccentDark(p.Error),
                Success:   NewAccentDark(p.Success),
                Warn:      NewAccentDark(p.Warn),
                Custom:    map[string]Accent{},

                SurfaceDim:    p.Neutral.AbsToneUniform(6),
                Surface:       p.Neutral.AbsToneUniform(6),
                SurfaceBright: p.Neutral.AbsToneUniform(24),

                SurfaceContainerLowest:  p.Neutral.AbsToneUniform(4),
                SurfaceContainerLow:     p.Neutral.AbsToneUniform(10),
                SurfaceContainer:        p.Neutral.AbsToneUniform(12),
                SurfaceContainerHigh:    p.Neutral.AbsToneUniform(17),
                SurfaceContainerHighest: p.Neutral.AbsToneUniform(22),

                SurfaceVariant:   p.NeutralVariant.AbsToneUniform(30),
                OnSurface:        p.NeutralVariant.AbsToneUniform(90),
                OnSurfaceVariant: p.NeutralVariant.AbsToneUniform(80),

                InverseSurface:   p.Neutral.AbsToneUniform(90),
                InverseOnSurface: p.Neutral.AbsToneUniform(20),
                InversePrimary:   p.Primary.AbsToneUniform(40),

                Background:   p.Neutral.AbsToneUniform(6),
                OnBackground: p.Neutral.AbsToneUniform(90),

                Outline:        p.NeutralVariant.AbsToneUniform(60),
                OutlineVariant: p.NeutralVariant.AbsToneUniform(30),

                // We want some visible "glow" shadow, but not too much
                Shadow:      image.NewUniform(color.RGBA{127, 127, 127, 127}),
                SurfaceTint: p.Primary.AbsToneUniform(80),
                Scrim:       p.Neutral.AbsToneUniform(0),
        }
        for nm, c := range p.Custom {
                s.Custom[nm] = NewAccentDark(c)
        }
        return s
        // TODO: custom and fixed colors?
}

// SchemeIsDark is whether the currently active color scheme
// is a dark-themed or light-themed color scheme. In almost
// all cases, it should be set via [cogentcore.org/core/colors.SetScheme],
// not directly.
var SchemeIsDark = false

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package matcolor

// Schemes contains multiple color schemes
// (light, dark, and any custom ones).
type Schemes struct {
        Light Scheme
        Dark  Scheme
        // TODO: maybe custom schemes?
}

// NewSchemes returns new [Schemes] for the given
// [Palette] containing both light and dark schemes.
func NewSchemes(p *Palette) *Schemes {
        return &Schemes{
                Light: NewLightScheme(p),
                Dark:  NewDarkScheme(p),
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package matcolor

import (
        "image"
        "image/color"

        "cogentcore.org/core/colors/cam/hct"
)

// Tones contains cached color values for each tone
// of a seed color. To get a tonal value, use [Tones.Tone].
type Tones struct {

        // the key color used to generate these tones
        Key color.RGBA

        // the cached map of tonal color values
        Tones map[int]color.RGBA
}

// NewTones returns a new set of [Tones]
// for the given color.
func NewTones(c color.RGBA) Tones {
        return Tones{
                Key:   c,
                Tones: map[int]color.RGBA{},
        }
}

// AbsTone returns the color at the given absolute
// tone on a scale of 0 to 100. It uses the cached
// value if it exists, and it caches the value if
// it is not already.
func (t *Tones) AbsTone(tone int) color.RGBA {
        if c, ok := t.Tones[tone]; ok {
                return c
        }
        c := hct.FromColor(t.Key)
        c.SetTone(float32(tone))
        r := c.AsRGBA()
        t.Tones[tone] = r
        return r
}

// AbsToneUniform returns [image.Uniform] of [Tones.AbsTone].
func (t *Tones) AbsToneUniform(tone int) *image.Uniform {
        return image.NewUniform(t.AbsTone(tone))
}

// Tone returns the color at the given tone, relative to the "0" tone
// for the current color scheme (0 for light-themed schemes and 100 for
// dark-themed schemes).
func (t *Tones) Tone(tone int) color.RGBA {
        if SchemeIsDark {
                return t.AbsTone(100 - tone)
        }
        return t.AbsTone(tone)
}

// ToneUniform returns [image.Uniform] of [Tones.Tone].
func (t *Tones) ToneUniform(tone int) *image.Uniform {
        return image.NewUniform(t.Tone(tone))
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package colors

import "image/color"

// RGBAF32 stores alpha-premultiplied RGBA values in a float32 0 to 1
// normalized format, which is more useful for converting to other spaces
type RGBAF32 struct {
        R, G, B, A float32
}

// RGBA implements the color.Color interface
func (c RGBAF32) RGBA() (r, g, b, a uint32) {
        r = uint32(c.R*65535.0 + 0.5)
        g = uint32(c.G*65535.0 + 0.5)
        b = uint32(c.B*65535.0 + 0.5)
        a = uint32(c.A*65535.0 + 0.5)
        return
}

// FromRGBAF32 returns the color specified by the given float32
// alpha-premultiplied RGBA values in the range 0 to 1
func FromRGBAF32(r, g, b, a float32) color.RGBA {
        return AsRGBA(RGBAF32{r, g, b, a})
}

// NRGBAF32 stores non-alpha-premultiplied RGBA values in a float32 0 to 1
// normalized format, which is more useful for converting to other spaces
type NRGBAF32 struct {
        R, G, B, A float32
}

// RGBA implements the color.Color interface
func (c NRGBAF32) RGBA() (r, g, b, a uint32) {
        r = uint32(c.R*c.A*65535.0 + 0.5)
        g = uint32(c.G*c.A*65535.0 + 0.5)
        b = uint32(c.B*c.A*65535.0 + 0.5)
        a = uint32(c.A*65535.0 + 0.5)
        return
}

// FromNRGBAF32 returns the color specified by the given float32
// non alpha-premultiplied RGBA values in the range 0 to 1
func FromNRGBAF32(r, g, b, a float32) color.RGBA {
        return AsRGBA(NRGBAF32{r, g, b, a})
}

var (
        // RGBAF32Model is the model for converting colors to [RGBAF32] colors
        RGBAF32Model color.Model = color.ModelFunc(rgbaf32Model)
        // NRGBAF32Model is the model for converting colors to [NRGBAF32] colors
        NRGBAF32Model color.Model = color.ModelFunc(nrgbaf32Model)
)

func rgbaf32Model(c color.Color) color.Color {
        if _, ok := c.(RGBAF32); ok {
                return c
        }
        r, g, b, a := c.RGBA()
        return RGBAF32{float32(r) / 65535.0, float32(g) / 65535.0, float32(b) / 65535.0, float32(a) / 65535.0}
}

func nrgbaf32Model(c color.Color) color.Color {
        if _, ok := c.(NRGBAF32); ok {
                return c
        }
        r, g, b, a := c.RGBA()
        if a > 0 {
                // Since color.Color is alpha pre-multiplied, we need to divide the
                // RGB values by alpha again in order to get back the original RGB.
                r *= 0xffff
                r /= a
                g *= 0xffff
                g /= a
                b *= 0xffff
                b /= a
        }
        return NRGBAF32{float32(r) / 65535.0, float32(g) / 65535.0, float32(b) / 65535.0, float32(a) / 65535.0}
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package colors

import (
        "image/color"

        "cogentcore.org/core/colors/cam/hct"
        "cogentcore.org/core/colors/matcolor"
)

// Spaced returns a maximally widely spaced sequence of colors
// for progressive values of the index, using the HCT space.
// This is useful, for example, for assigning colors in graphs.
func Spaced(idx int) color.RGBA {
        if matcolor.SchemeIsDark {
                return spacedDark(idx)
        }
        return spacedLight(idx)
}

// spacedLight is the light mode version of [Spaced].
func spacedLight(idx int) color.RGBA {
        // blue, red, green, yellow, violet, aqua, orange, blueviolet
        // hues := []float32{30, 280, 140, 110, 330, 200, 70, 305}
        hues := []float32{255, 25, 150, 105, 340, 210, 60, 300}
        // even 45:       30, 75, 120, 165, 210, 255, 300, 345,
        toffs := []float32{0, -10, 0, 5, 0, 0, 5, 0}
        tones := []float32{65, 80, 45, 65, 80}
        chromas := []float32{90, 90, 90, 20, 20}
        ncats := len(hues)
        ntc := len(tones)
        hi := idx % ncats
        hr := idx / ncats
        tci := hr % ntc
        hue := hues[hi]
        tone := toffs[hi] + tones[tci]
        chroma := chromas[tci]
        return hct.New(hue, float32(chroma), tone).AsRGBA()
}

// spacedDark is the dark mode version of [Spaced].
func spacedDark(idx int) color.RGBA {
        // blue, red, green, yellow, violet, aqua, orange, blueviolet
        // hues := []float32{30, 280, 140, 110, 330, 200, 70, 305}
        hues := []float32{255, 25, 150, 105, 340, 210, 60, 300}
        // even 45:       30, 75, 120, 165, 210, 255, 300, 345,
        toffs := []float32{0, -10, 0, 10, 0, 0, 5, 0}
        tones := []float32{65, 80, 45, 65, 80}
        chromas := []float32{90, 90, 90, 20, 20}
        ncats := len(hues)
        ntc := len(tones)
        hi := idx % ncats
        hr := idx / ncats
        tci := hr % ntc
        hue := hues[hi]
        tone := toffs[hi] + tones[tci]
        chroma := chromas[tci]
        return hct.New(hue, float32(chroma), tone).AsRGBA()
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package bcontent ("base content") provides base types and functions
// shared by both content and the core build tool for content. This is
// necessary to ensure that the core build tool does not import GUI packages.
package bcontent

import (
        "bufio"
        "bytes"
        "fmt"
        "io/fs"
        "path/filepath"
        "slices"
        "strconv"
        "strings"
        "time"

        "cogentcore.org/core/base/iox/tomlx"
        "cogentcore.org/core/base/strcase"
)

// Page represents the metadata for a single page of content.
type Page struct {

        // Source is the filesystem that the page is stored in.
        Source fs.FS `toml:"-" json:"-"`

        // Filename is the name of the file in [Page.FS] that the content is stored in.
        Filename string `toml:"-" json:"-"`

        // Name is the user-friendly name of the page, defaulting to the
        // [strcase.ToSentence] of the [Page.Filename] without its extension.
        Name string

        // URL is the URL of the page relative to the root of the app, without
        // any leading slash. It defaults to [Page.Name] in kebab-case
        // (ex: "home" or "text-fields"). A blank URL ("") manually
        // specified in the front matter indicates that this the root page.
        URL string

        // Title is the title displayed at the top of the page. It defaults to [Page.Name].
        // Note that [Page.Name] is still used for the stage title and other such things; this
        // is only for the actual title widget.
        Title string

        // Date is the optional date that the page was published.
        Date time.Time

        // Authors are the optional authors of the page.
        Authors []string

        // Draft indicates that the page is a draft and should not be visible on the web.
        Draft bool

        // Categories are the categories that the page belongs to.
        Categories []string

        // Specials are special content elements for each page
        // that have names with an underscore-delimited key name,
        // such as figure_, table_, sim_ etc, and can be referred
        // to using the #id component of a wikilink. They are rendered
        // using the index of each such element (e.g., Figure 1) in the link.
        Specials map[string][]string
}

// PreRenderPage contains the data for each page printed in JSON by a content app
// run with the generatehtml tag, which is then handled by the core
// build tool.
type PreRenderPage struct {
        Page

        // Description is the automatic page description.
        Description string

        // HTML is the pre-rendered HTML for the page.
        HTML string
}

// NewPage makes a new page in the given filesystem with the given filename,
// sets default values, and reads metadata from the front matter of the page file.
func NewPage(source fs.FS, filename string) (*Page, error) {
        pg := &Page{Source: source, Filename: filename}
        pg.Defaults()
        err := pg.ReadMetadata()
        return pg, err
}

// Defaults sets default values for the page based on its filename.
func (pg *Page) Defaults() {
        pg.Name = strcase.ToSentence(strings.TrimSuffix(pg.Filename, filepath.Ext(pg.Filename)))
        pg.URL = strcase.ToKebab(pg.Name)
        pg.Title = pg.Name
}

// ReadMetadata reads the page metadata from the front matter of the page file,
// if there is any.
func (pg *Page) ReadMetadata() error {
        f, err := pg.Source.Open(pg.Filename)
        if err != nil {
                return err
        }
        defer f.Close()
        sc := bufio.NewScanner(f)
        var data []byte
        for sc.Scan() {
                b := sc.Bytes()
                if data == nil {
                        if string(b) != `+++` {
                                return nil
                        }
                        data = []byte{}
                        continue
                }
                if string(b) == `+++` {
                        break
                }
                data = append(data, append(b, '\n')...)
        }
        return tomlx.ReadBytes(pg, data)
}

// ReadContent returns the page content with any front matter removed.
// It also applies [Page.categoryLinks].
func (pg *Page) ReadContent(pagesByCategory map[string][]*Page) ([]byte, error) {
        b, err := fs.ReadFile(pg.Source, pg.Filename)
        if err != nil {
                return nil, err
        }
        b = append(b, pg.categoryLinks(pagesByCategory)...)
        if !bytes.HasPrefix(b, []byte(`+++`)) {
                return b, nil
        }
        b = bytes.TrimPrefix(b, []byte(`+++`))
        _, after, has := bytes.Cut(b, []byte(`+++`))
        if !has {
                return nil, fmt.Errorf("unclosed front matter")
        }
        return after, nil
}

// categoryLinks, if the page has the same names as one of the given categories,
// returns markdown containing a list of links to all pages in that category.
// Otherwise, it returns nil.
func (pg *Page) categoryLinks(pagesByCategory map[string][]*Page) []byte {
        if pagesByCategory == nil {
                return nil
        }
        cpages := pagesByCategory[pg.Name]
        if cpages == nil {
                return nil
        }
        res := []byte{'\n'}
        for _, cpage := range cpages {
                res = append(res, fmt.Sprintf("* [[%s]]\n", cpage.Name)...)
        }
        return res
}

// SpecialName extracts a special element type name from given element name,
// defined as the part before the first underscore _ character.
func SpecialName(name string) string {
        usi := strings.Index(name, "_")
        if usi < 0 {
                return ""
        }
        return name[:usi]
}

// SpecialToKebab does strcase.ToKebab on parts after specialName if present.
func SpecialToKebab(name string) string {
        usi := strings.Index(name, "_")
        if usi < 0 {
                return strcase.ToKebab(name)
        }
        spec := name[:usi+1]
        name = name[usi+1:]
        colon := strings.Index(name, ":")
        if colon > 0 {
                return spec + strcase.ToKebab(name[:colon]) + name[colon:]
        } else {
                return spec + strcase.ToKebab(name)
        }
}

// SpecialLabel returns the label for given special element, using
// the index of the element in the list of specials, e.g., "Figure 1"
func (pg *Page) SpecialLabel(name string) string {
        snm := SpecialName(name)
        if snm == "" {
                return ""
        }
        if pg.Specials == nil {
                b, err := pg.ReadContent(nil)
                if err != nil {
                        return ""
                }
                pg.ParseSpecials(b)
        }
        sl := pg.Specials[snm]
        if sl == nil {
                return ""
        }
        i := slices.Index(sl, name)
        if i < 0 {
                return ""
        }
        return strcase.ToSentence(snm) + " " + strconv.Itoa(i+1)
}

// ParseSpecials manually parses specials before rendering md
// because they are needed in advance of generating from md file,
// e.g., for wikilinks.
func (pg *Page) ParseSpecials(b []byte) {
        if pg.Specials != nil {
                return
        }
        pg.Specials = make(map[string][]string)
        scan := bufio.NewScanner(bytes.NewReader(b))
        idt := []byte(`{id="`)
        idn := len(idt)
        for scan.Scan() {
                ln := scan.Bytes()
                n := len(ln)
                if n < idn+1 {
                        continue
                }
                if !bytes.HasPrefix(ln, idt) {
                        continue
                }
                fs := bytes.Fields(ln) // multiple attributes possible
                ln = fs[0]             // only deal with first one
                id := bytes.TrimSpace(ln[idn:])
                n = len(id)
                if n < 2 {
                        continue
                }
                ed := n - 1 // quotes
                if len(fs) == 1 {
                        ed = n - 2 // brace
                }
                id = id[:ed]
                sid := string(id)
                snm := SpecialName(sid)
                if snm == "" {
                        continue
                }
                // fmt.Println("id:", snm, sid)
                sl := pg.Specials[snm]
                sl = append(sl, sid)
                pg.Specials[snm] = sl
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package content

import (
        "slices"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
)

func (ct *Content) MakeToolbar(p *tree.Plan) {
        if false && ct.SizeClass() == core.SizeCompact { // TODO: implement hamburger menu for compact
                tree.Add(p, func(w *core.Button) {
                        w.SetIcon(icons.Menu)
                        w.SetTooltip("Navigate pages and headings")
                        w.OnClick(func(e events.Event) {
                                d := core.NewBody("Navigate")
                                // tree.MoveToParent(ct.leftFrame, d)
                                d.AddBottomBar(func(bar *core.Frame) {
                                        d.AddCancel(bar)
                                })
                                d.RunDialog(w)
                        })
                })
        }
        tree.Add(p, func(w *core.Button) {
                w.SetIcon(icons.Icon(core.AppIcon))
                w.SetTooltip("Home")
                w.OnClick(func(e events.Event) {
                        ct.Open("")
                })
        })
        // Superseded by browser navigation on web.
        if core.TheApp.Platform() != system.Web {
                tree.Add(p, func(w *core.Button) {
                        w.SetIcon(icons.ArrowBack).SetKey(keymap.HistPrev)
                        w.SetTooltip("Back")
                        w.Updater(func() {
                                w.SetEnabled(ct.historyIndex > 0)
                        })
                        w.OnClick(func(e events.Event) {
                                ct.historyIndex--
                                ct.open(ct.history[ct.historyIndex].URL, false) // do not add to history while navigating history
                        })
                })
                tree.Add(p, func(w *core.Button) {
                        w.SetIcon(icons.ArrowForward).SetKey(keymap.HistNext)
                        w.SetTooltip("Forward")
                        w.Updater(func() {
                                w.SetEnabled(ct.historyIndex < len(ct.history)-1)
                        })
                        w.OnClick(func(e events.Event) {
                                ct.historyIndex++
                                ct.open(ct.history[ct.historyIndex].URL, false) // do not add to history while navigating history
                        })
                })
        }
        tree.Add(p, func(w *core.Button) {
                w.SetText("Search").SetIcon(icons.Search).SetKey(keymap.Menu)
                w.Styler(func(s *styles.Style) {
                        s.Background = colors.Scheme.SurfaceVariant
                        s.Padding.Right.Em(5)
                })
                w.OnClick(func(e events.Event) {
                        ct.Scene.MenuSearchDialog("Search", "Search "+core.TheApp.Name())
                })
        })
}

func (ct *Content) MenuSearch(items *[]core.ChooserItem) {
        newItems := make([]core.ChooserItem, len(ct.pages))
        for i, pg := range ct.pages {
                newItems[i] = core.ChooserItem{
                        Value: pg,
                        Text:  pg.Name,
                        Icon:  icons.Article,
                        Func: func() {
                                ct.Open(pg.URL)
                        },
                }
        }
        *items = append(newItems, *items...)
}

// makeBottomButtons makes the previous and next buttons if relevant.
func (ct *Content) makeBottomButtons(p *tree.Plan) {
        if len(ct.currentPage.Categories) == 0 {
                return
        }
        cat := ct.currentPage.Categories[0]
        pages := ct.pagesByCategory[cat]
        idx := slices.Index(pages, ct.currentPage)

        ct.prevPage, ct.nextPage = nil, nil

        if idx > 0 {
                ct.prevPage = pages[idx-1]
        }
        if idx < len(pages)-1 {
                ct.nextPage = pages[idx+1]
        }

        if ct.prevPage == nil && ct.nextPage == nil {
                return
        }

        tree.Add(p, func(w *core.Frame) {
                w.Styler(func(s *styles.Style) {
                        s.Align.Items = styles.Center
                        s.Grow.Set(1, 0)
                })
                w.Maker(func(p *tree.Plan) {
                        if ct.prevPage != nil {
                                tree.Add(p, func(w *core.Button) {
                                        w.SetText("Previous").SetIcon(icons.ArrowBack).SetType(core.ButtonTonal)
                                        ct.Context.LinkButtonUpdating(w, func() string { // needed to prevent stale URL variable
                                                return ct.prevPage.URL
                                        })
                                })
                        }
                        if ct.nextPage != nil {
                                tree.Add(p, func(w *core.Stretch) {})
                                tree.Add(p, func(w *core.Button) {
                                        w.SetText("Next").SetIcon(icons.ArrowForward).SetType(core.ButtonTonal)
                                        ct.Context.LinkButtonUpdating(w, func() string { // needed to prevent stale URL variable
                                                return ct.nextPage.URL
                                        })
                                })
                        }
                })
        })
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package content provides a system for making content-focused
// apps and websites consisting of Markdown, HTML, and Cogent Core.
package content

//go:generate core generate

import (
        "bytes"
        "cmp"
        "fmt"
        "io"
        "io/fs"
        "net/http"
        "path/filepath"
        "slices"
        "strconv"
        "strings"

        "github.com/gomarkdown/markdown/ast"
        "golang.org/x/exp/maps"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/content/bcontent"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/htmlcore"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/csl"
        "cogentcore.org/core/tree"
)

// Content manages and displays the content of a set of pages.
type Content struct {
        core.Splits

        // Source is the source filesystem for the content.
        // It should be set using [Content.SetSource] or [Content.SetContent].
        Source fs.FS `set:"-"`

        // Context is the [htmlcore.Context] used to render the content,
        // which can be modified for things such as adding wikilink handlers.
        Context *htmlcore.Context `set:"-"`

        // References is a list of references used for generating citation text
        // for literature reference wikilinks in the format [[@CiteKey]].
        References *csl.KeyList

        // pages are the pages that constitute the content.
        pages []*bcontent.Page

        // pagesByName has the [bcontent.Page] for each [bcontent.Page.Name]
        // transformed into lowercase. See [Content.pageByName] for a helper
        // function that automatically transforms into lowercase.
        pagesByName map[string]*bcontent.Page

        // pagesByURL has the [bcontent.Page] for each [bcontent.Page.URL].
        pagesByURL map[string]*bcontent.Page

        // pagesByCategory has the [bcontent.Page]s for each of all [bcontent.Page.Categories].
        pagesByCategory map[string][]*bcontent.Page

        // categories has all unique [bcontent.Page.Categories], sorted such that the categories
        // with the most pages are listed first.
        categories []string

        // history is the history of pages that have been visited.
        // The oldest page is first.
        history []*bcontent.Page

        // historyIndex is the current position in [Content.history].
        historyIndex int

        // currentPage is the currently open page.
        currentPage *bcontent.Page

        // renderedPage is the most recently rendered page.
        renderedPage *bcontent.Page

        // leftFrame is the frame on the left side of the widget,
        // used for displaying the table of contents and the categories.
        leftFrame *core.Frame

        // rightFrame is the frame on the right side of the widget,
        // used for displaying the page content.
        rightFrame *core.Frame

        // tocNodes are all of the tree nodes in the table of contents
        // by kebab-case heading name.
        tocNodes map[string]*core.Tree

        // currentHeading is the currently selected heading in the table of contents,
        // if any (in kebab-case).
        currentHeading string

        // The previous and next page, if applicable. They must be stored on this struct
        // to avoid stale local closure variables.
        prevPage, nextPage *bcontent.Page
}

func init() {
        // We want Command+[ and Command+] to work for browser back/forward navigation
        // in content, since we rely on that. They should still be intercepted by
        // Cogent Core for non-content apps for things such as full window dialogs,
        // so we only add these in content.
        system.ReservedWebShortcuts = append(system.ReservedWebShortcuts, "Command+[", "Command+]")
}

func (ct *Content) Init() {
        ct.Splits.Init()
        ct.SetSplits(0.2, 0.8)

        ct.Context = htmlcore.NewContext()
        ct.Context.OpenURL = func(url string) {
                ct.Open(url)
        }
        ct.Context.GetURL = func(url string) (*http.Response, error) {
                return htmlcore.GetURLFromFS(ct.Source, url)
        }
        ct.Context.AddWikilinkHandler(ct.citeWikilink)
        ct.Context.AddWikilinkHandler(ct.mainWikilink)
        ct.Context.ElementHandlers["embed-page"] = func(ctx *htmlcore.Context) bool {
                errors.Log(ct.embedPage(ctx))
                return true
        }
        ct.Context.AttributeHandlers["id"] = func(ctx *htmlcore.Context, w io.Writer, node ast.Node, entering bool, tag, value string) bool {
                if ct.currentPage == nil {
                        return false
                }
                lbl := ct.currentPage.SpecialLabel(value)
                ch := node.GetChildren()
                if len(ch) == 2 { // image or table
                        if entering {
                                sty := htmlcore.MDGetAttr(node, "style")
                                if sty != "" {
                                        if img, ok := ch[1].(*ast.Image); ok {
                                                htmlcore.MDSetAttr(img, "style", sty)
                                                delete(node.AsContainer().Attribute.Attrs, "style")
                                        }
                                }
                                return false
                        }
                        cp := "\n<p><b>" + lbl + ":</b>"
                        if img, ok := ch[1].(*ast.Image); ok {
                                // fmt.Printf("Image: %s\n", string(img.Destination))
                                // fmt.Printf("Image: %#v\n", img)
                                nc := len(img.Children)
                                if nc > 0 {
                                        if txt, ok := img.Children[0].(*ast.Text); ok {
                                                // fmt.Printf("text: %s\n", string(txt.Literal)) // not formatted!
                                                cp += " " + string(txt.Literal) // todo: not formatted!
                                        }
                                }
                        } else {
                                title := htmlcore.MDGetAttr(node, "title")
                                if title != "" {
                                        cp += " " + title
                                }
                        }
                        cp += "</p>\n"
                        w.Write([]byte(cp))
                } else if entering {
                        cp := "\n<span id=\"" + value + "\"><b>" + lbl + ":</b>"
                        title := htmlcore.MDGetAttr(node, "title")
                        if title != "" {
                                cp += " " + title
                        }
                        cp += "</span>\n"
                        w.Write([]byte(cp))
                        // fmt.Println("id:", value, lbl)
                        // fmt.Printf("%#v\n", node)
                }
                return false
        }

        ct.Maker(func(p *tree.Plan) {
                if ct.currentPage == nil {
                        return
                }
                tree.Add(p, func(w *core.Frame) {
                        ct.leftFrame = w
                })
                tree.Add(p, func(w *core.Frame) {
                        ct.rightFrame = w
                        w.Styler(func(s *styles.Style) {
                                switch w.SizeClass() {
                                case core.SizeCompact, core.SizeMedium:
                                        s.Padding.SetHorizontal(units.Em(0.5))
                                case core.SizeExpanded:
                                        s.Padding.SetHorizontal(units.Em(3))
                                }
                        })
                        w.Maker(func(p *tree.Plan) {
                                if ct.currentPage.Title != "" {
                                        tree.Add(p, func(w *core.Text) {
                                                w.SetType(core.TextDisplaySmall)
                                                w.Updater(func() {
                                                        w.SetText(ct.currentPage.Title)
                                                })
                                        })
                                }
                                tree.Add(p, func(w *core.Frame) {
                                        w.Styler(func(s *styles.Style) {
                                                s.Direction = styles.Column
                                                s.Grow.Set(1, 1)
                                        })
                                        w.Updater(func() {
                                                errors.Log(ct.loadPage(w))
                                        })
                                })
                                ct.makeBottomButtons(p)
                        })
                })
        })

        // Must be done after the default title is set elsewhere in normal OnShow
        ct.OnFinal(events.Show, func(e events.Event) {
                ct.setStageTitle()
        })
        ct.handleWebPopState()
}

// pageByName returns [Content.pagesByName] of the lowercase version of the given name.
func (ct *Content) pageByName(name string) *bcontent.Page {
        ln := strings.ToLower(name)
        if pg, ok := ct.pagesByName[ln]; ok {
                return pg
        }
        nd := strings.ReplaceAll(ln, "-", " ")
        if pg, ok := ct.pagesByName[nd]; ok {
                return pg
        }
        return nil
}

// SetSource sets the source filesystem for the content.
func (ct *Content) SetSource(source fs.FS) *Content {
        ct.Source = source
        ct.pages = []*bcontent.Page{}
        ct.pagesByName = map[string]*bcontent.Page{}
        ct.pagesByURL = map[string]*bcontent.Page{}
        ct.pagesByCategory = map[string][]*bcontent.Page{}
        errors.Log(fs.WalkDir(ct.Source, ".", func(path string, d fs.DirEntry, err error) error {
                if err != nil {
                        return err
                }
                if d.IsDir() {
                        return nil
                }
                if path == "" || path == "." {
                        return nil
                }
                ext := filepath.Ext(path)
                if !(ext == ".md" || ext == ".html") {
                        return nil
                }
                pg, err := bcontent.NewPage(ct.Source, path)
                if err != nil {
                        return err
                }
                ct.pages = append(ct.pages, pg)
                ct.pagesByName[strings.ToLower(pg.Name)] = pg
                ct.pagesByURL[pg.URL] = pg
                for _, cat := range pg.Categories {
                        ct.pagesByCategory[cat] = append(ct.pagesByCategory[cat], pg)
                }
                return nil
        }))
        ct.categories = maps.Keys(ct.pagesByCategory)
        slices.SortFunc(ct.categories, func(a, b string) int {
                v := cmp.Compare(len(ct.pagesByCategory[b]), len(ct.pagesByCategory[a]))
                if v != 0 {
                        return v
                }
                return cmp.Compare(a, b)
        })

        if url := ct.getWebURL(); url != "" {
                ct.Open(url)
                return ct
        }
        if root, ok := ct.pagesByURL[""]; ok {
                ct.Open(root.URL)
                return ct
        }
        ct.Open(ct.pages[0].URL)
        return ct
}

// SetContent is a helper function that calls [Content.SetSource]
// with the "content" subdirectory of the given filesystem.
func (ct *Content) SetContent(content fs.FS) *Content {
        return ct.SetSource(fsx.Sub(content, "content"))
}

// Open opens the page with the given URL and updates the display.
// If no pages correspond to the URL, it is opened in the default browser.
func (ct *Content) Open(url string) *Content {
        ct.open(url, true)
        return ct
}

func (ct *Content) addHistory(pg *bcontent.Page) {
        ct.historyIndex = len(ct.history)
        ct.history = append(ct.history, pg)
        ct.saveWebURL()
}

// loadPage loads the current page content into the given frame if it is not already loaded.
func (ct *Content) loadPage(w *core.Frame) error {
        if ct.renderedPage == ct.currentPage {
                return nil
        }
        w.DeleteChildren()
        b, err := ct.currentPage.ReadContent(ct.pagesByCategory)
        if err != nil {
                return err
        }
        ct.currentPage.ParseSpecials(b)
        err = htmlcore.ReadMD(ct.Context, w, b)
        if err != nil {
                return err
        }

        ct.leftFrame.DeleteChildren()
        ct.makeTableOfContents(w, ct.currentPage)
        ct.makeCategories()
        ct.leftFrame.Update()
        ct.renderedPage = ct.currentPage
        return nil
}

// makeTableOfContents makes the table of contents and adds it to [Content.leftFrame]
// based on the headings in the given frame.
func (ct *Content) makeTableOfContents(w *core.Frame, pg *bcontent.Page) {
        ct.tocNodes = map[string]*core.Tree{}
        contents := core.NewTree(ct.leftFrame).SetText("<b>Contents</b>")
        contents.OnSelect(func(e events.Event) {
                if contents.IsRootSelected() {
                        ct.rightFrame.ScrollDimToContentStart(math32.Y)
                        ct.currentHeading = ""
                        ct.saveWebURL()
                }
        })
        // last is the most recent tree node for each heading level, used for nesting.
        last := map[int]*core.Tree{}
        w.WidgetWalkDown(func(cw core.Widget, cwb *core.WidgetBase) bool {
                tx, ok := cw.(*core.Text)
                if !ok {
                        return tree.Continue
                }
                tag := tx.Property("tag")
                switch tag {
                case "h1", "h2", "h3", "h4", "h5", "h6":
                        num := errors.Log1(strconv.Atoi(tag.(string)[1:]))
                        parent := contents
                        // Our parent is the last heading with a lower level (closer to h1).
                        for i := num - 1; i >= 1; i-- {
                                if last[i] != nil {
                                        parent = last[i]
                                        break
                                }
                        }
                        tr := core.NewTree(parent).SetText(tx.Text)
                        last[num] = tr
                        kebab := strcase.ToKebab(tr.Text)
                        ct.tocNodes[kebab] = tr
                        tr.OnSelect(func(e events.Event) {
                                tx.ScrollThisToTop()
                                ct.currentHeading = kebab
                                ct.saveWebURL()
                        })
                }
                return tree.Continue
        })

        if contents.NumChildren() == 0 {
                contents.Delete()
        }
}

// makeCategories makes the categories tree for the current page and adds it to [Content.leftFrame].
func (ct *Content) makeCategories() {
        if len(ct.categories) == 0 {
                return
        }

        cats := core.NewTree(ct.leftFrame).SetText("<b>Categories</b>")
        cats.OnSelect(func(e events.Event) {
                if cats.IsRootSelected() {
                        ct.Open("")
                }
        })
        for _, cat := range ct.categories {
                catTree := core.NewTree(cats).SetText(cat).SetClosed(true)
                if ct.currentPage.Name == cat {
                        catTree.SetSelected(true)
                }
                catTree.OnSelect(func(e events.Event) {
                        if catPage := ct.pageByName(cat); catPage != nil {
                                ct.Open(catPage.URL)
                        }
                })
                for _, pg := range ct.pagesByCategory[cat] {
                        pgTree := core.NewTree(catTree).SetText(pg.Name)
                        if pg == ct.currentPage {
                                pgTree.SetSelected(true)
                                catTree.SetClosed(false)
                        }
                        pgTree.OnSelect(func(e events.Event) {
                                ct.Open(pg.URL)
                        })
                }
        }
}

// embedPage handles an <embed-page> element by embedding the lead section
// (content before the first heading) into the current page, with a heading
// and a *Main page: [[Name]]* link added at the start as well. The name of
// the embedded page is the case-insensitive src attribute of the current
// html element. A title attribute may also be specified to override the
// heading text.
func (ct *Content) embedPage(ctx *htmlcore.Context) error {
        src := htmlcore.GetAttr(ctx.Node, "src")
        if src == "" {
                return fmt.Errorf("missing src attribute in <embed-page>")
        }
        pg := ct.pageByName(src)
        if pg == nil {
                return fmt.Errorf("page %q not found in <embed-page>", src)
        }
        title := htmlcore.GetAttr(ctx.Node, "title")
        if title == "" {
                title = pg.Name
        }
        b, err := pg.ReadContent(ct.pagesByCategory)
        if err != nil {
                return err
        }
        lead, _, _ := bytes.Cut(b, []byte("\n#"))
        heading := fmt.Sprintf("## %s\n\n*Main page: [[%s]]*\n\n", title, pg.Name)
        res := append([]byte(heading), lead...)
        return htmlcore.ReadMD(ctx, ctx.BlockParent, res)
}

// setStageTitle sets the title of the stage based on the current page URL.
func (ct *Content) setStageTitle() {
        if rw := ct.Scene.RenderWindow(); rw != nil && ct.currentPage != nil {
                name := ct.currentPage.Name
                if ct.currentPage.URL == "" { // Root page just gets app name
                        name = core.TheApp.Name()
                }
                rw.SetStageTitle(name)
        }
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "embed"

        "cogentcore.org/core/content"
        "cogentcore.org/core/core"
        "cogentcore.org/core/htmlcore"
        _ "cogentcore.org/core/yaegicore"
)

//go:embed content
var econtent embed.FS

func main() {
        b := core.NewBody("Cogent Content Example")
        ct := content.NewContent(b).SetContent(econtent)
        ct.Context.AddWikilinkHandler(htmlcore.GoDocWikilink("doc", "cogentcore.org/core"))
        b.AddTopBar(func(bar *core.Frame) {
                core.NewToolbar(bar).Maker(ct.MakeToolbar)
        })
        b.RunMainWindow()
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package content

import (
        "fmt"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/content/bcontent"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/text/csl"
        "cogentcore.org/core/tree"
)

// citeWikilink processes citation links, which start with @
func (ct *Content) citeWikilink(text string) (url string, label string) {
        if len(text) == 0 || text[0] != '@' { // @CiteKey reference citations
                return "", ""
        }
        ref := text[1:]
        cs := csl.Parenthetical
        if len(ref) > 1 && ref[0] == '^' {
                cs = csl.Narrative
                ref = ref[1:]
        }
        url = "ref://" + ref
        if ct.References == nil {
                return url, ref
        }
        it, has := ct.References.AtTry(ref)
        if has {
                return url, csl.CiteDefault(cs, it)
        }
        return url, ref
}

// mainWikilink processes all other wikilinks.
// page -> Page, page
// page|label -> Page, label
// page#heading -> Page#heading, heading
// #heading -> ThisPage#heading, heading
// Page is the resolved page name.
// heading can be a special id, or id:element to find elements within a special,
// e.g., #sim_neuron:Run Cycles
func (ct *Content) mainWikilink(text string) (url string, label string) {
        name, label, _ := strings.Cut(text, "|")
        name, heading, _ := strings.Cut(name, "#")
        if name == "" { // A link with a blank page links to the current page
                name = ct.currentPage.Name
        } else if heading == "" {
                if pg := ct.pageByName(name); pg == ct.currentPage {
                        // if just a link to current page, don't render link
                        // this can happen for embedded pages that refer to embedder
                        return "", ""
                }
        }
        pg := ct.pageByName(name)
        if pg == nil {
                return "", ""
        }
        if label == "" {
                if heading != "" {
                        label = ct.wikilinkLabel(pg, heading)
                } else {
                        label = name
                }
        }
        if heading != "" {
                return pg.URL + "#" + heading, label
        }
        return pg.URL, label
}

// wikilinkLabel returns a label for given heading, for given page.
func (ct *Content) wikilinkLabel(pg *bcontent.Page, heading string) string {
        label := heading
        sl := pg.SpecialLabel(heading)
        if sl != "" {
                label = sl
        } else {
                colon := strings.Index(heading, ":")
                if colon > 0 {
                        sl = pg.SpecialLabel(heading[:colon])
                        if sl != "" {
                                label = sl + ":" + heading[colon+1:]
                        }
                }
        }
        return label
}

// open opens the page with the given URL and updates the display.
// It optionally adds the page to the history.
func (ct *Content) open(url string, history bool) {
        if strings.HasPrefix(url, "https://") || strings.HasPrefix(url, "http://") {
                core.TheApp.OpenURL(url)
                return
        }
        if strings.HasPrefix(url, "ref://") {
                ct.openRef(url)
                return
        }
        url = strings.ReplaceAll(url, "/#", "#")
        url, heading, _ := strings.Cut(url, "#")
        pg := ct.pagesByURL[url]
        if pg == nil {
                // We want only the URL after the last slash for automatic redirects
                // (old URLs could have nesting).
                last := url
                if li := strings.LastIndex(url, "/"); li >= 0 {
                        last = url[li+1:]
                }
                pg = ct.similarPage(last)
                if pg == nil {
                        core.ErrorSnackbar(ct, errors.New("no pages available"))
                } else {
                        core.MessageSnackbar(ct, fmt.Sprintf("Redirected from %s", url))
                }
        }
        heading = bcontent.SpecialToKebab(heading)
        ct.currentHeading = heading
        if ct.currentPage == pg {
                ct.openHeading(heading)
                return
        }
        ct.currentPage = pg
        if history {
                ct.addHistory(pg)
        }
        ct.Scene.Update() // need to update the whole scene to also update the toolbar
        // We can only scroll to the heading after the page layout has been updated, so we defer.
        ct.Defer(func() {
                ct.setStageTitle()
                ct.openHeading(heading)
        })
}

// openRef opens a ref:// reference url.
func (ct *Content) openRef(url string) {
        pg := ct.pagesByURL["references"]
        if pg == nil {
                core.MessageSnackbar(ct, "references page not generated, use mdcite in csl package")
                return
        }
        ref := strings.TrimPrefix(url, "ref://")
        ct.currentPage = pg
        ct.addHistory(pg)
        ct.Scene.Update()
        ct.Defer(func() {
                ct.setStageTitle()
                ct.openID(ref, "")
        })
}

func (ct *Content) openHeading(heading string) {
        if heading == "" {
                ct.rightFrame.ScrollDimToContentStart(math32.Y)
                return
        }
        idname := "" // in case of #id:element
        element := ""
        colon := strings.Index(heading, ":")
        if colon > 0 {
                idname = heading[:colon]
                element = heading[colon+1:]
        }
        tr := ct.tocNodes[strcase.ToKebab(heading)]
        if tr == nil {
                found := false
                if idname != "" && element != "" {
                        found = ct.openID(idname, element)
                        if !found {
                                found = ct.openID(heading, "")
                        }
                } else {
                        found = ct.openID(heading, "")
                }
                if !found {
                        errors.Log(fmt.Errorf("heading %q not found", heading))
                }
                return
        }
        tr.SelectEvent(events.SelectOne)
}

func (ct *Content) openID(id, element string) bool {
        if id == "" {
                ct.rightFrame.ScrollDimToContentStart(math32.Y)
                return true
        }
        var found *core.WidgetBase
        ct.rightFrame.WidgetWalkDown(func(cw core.Widget, cwb *core.WidgetBase) bool {
                // if found != nil {
                //         return tree.Break
                // }
                if cwb.Name != id {
                        return tree.Continue
                }
                found = cwb
                return tree.Break
        })
        if found == nil {
                return false
        }
        if element != "" {
                el := ct.elementInSpecial(found, element)
                if el != nil {
                        found = el
                }
        }
        found.SetFocus()
        found.SetState(true, states.Active)
        found.Style()
        found.NeedsRender()
        return true
}

// elementInSpecial looks for given element within a special item.
func (ct *Content) elementInSpecial(sp *core.WidgetBase, element string) *core.WidgetBase {
        pathPrefix := ""
        hasPath := false
        if strings.Contains(element, "/") {
                pathPrefix, element, hasPath = strings.Cut(element, "/")
        }
        if cl, ok := sp.Parent.(*core.Collapser); ok { // for code
                nxt := tree.NextSibling(cl)
                if nxt != nil {
                        sp = nxt.(core.Widget).AsWidget()
                } else {
                        sp = cl.Parent.(core.Widget).AsWidget() // todo: not sure when this is good
                }
        }

        var found *core.WidgetBase
        sp.WidgetWalkDown(func(cw core.Widget, cwb *core.WidgetBase) bool {
                if found != nil {
                        return tree.Break
                }
                if !cwb.IsDisplayable() {
                        return tree.Continue
                }
                if hasPath && !strings.Contains(cw.AsTree().Path(), pathPrefix) {
                        return tree.Continue
                }
                label := labels.ToLabel(cw)
                if !strings.EqualFold(label, element) {
                        return tree.Continue
                }
                if cwb.AbilityIs(abilities.Focusable) {
                        found = cwb
                        return tree.Break
                }
                next := core.AsWidget(tree.Next(cwb))
                if next.AbilityIs(abilities.Focusable) {
                        found = next
                        return tree.Break
                }
                return tree.Continue
        })
        return found
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package content

import (
        "cogentcore.org/core/content/bcontent"
        "github.com/adrg/strutil/metrics"
)

// similarPage returns the page most similar to the given URL, used for automatic 404 redirects.
func (ct *Content) similarPage(url string) *bcontent.Page {
        m := metrics.NewJaccard()
        m.CaseSensitive = false

        var best *bcontent.Page
        bestSimilarity := -1.0
        for _, page := range ct.pages {
                similarity := m.Compare(url, page.URL)
                if similarity > bestSimilarity {
                        best = page
                        bestSimilarity = similarity
                }
        }
        return best
}

// Code generated by "core generate"; DO NOT EDIT.

package content

import (
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/content.Content", IDName: "content", Doc: "Content manages and displays the content of a set of pages.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Source", Doc: "Source is the source filesystem for the content.\nIt should be set using [Content.SetSource] or [Content.SetContent]."}, {Name: "pages", Doc: "pages are the pages that constitute the content."}}})

// NewContent returns a new [Content] with the given optional parent:
// Content manages and displays the content of a set of pages.
func NewContent(parent ...tree.Node) *Content { return tree.New[Content](parent...) }

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !js

package content

func (ct *Content) getWebURL() string  { return "" }
func (ct *Content) saveWebURL()        {}
func (ct *Content) handleWebPopState() {}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "slices"
        "time"
)

// Animation represents the data for a widget animation.
// You can call [WidgetBase.Animate] to create a widget animation.
// Animations are stored on the [Scene].
type Animation struct {

        // Func is the animation function, which is run every time the [Scene]
        // receives a paint tick, which is usually at the same rate as the refresh
        // rate of the monitor. It receives the [Animation] object so that
        // it can references things such as [Animation.Dt] and set things such as
        // [Animation.Done].
        Func func(a *Animation)

        // Widget is the widget associated with the animation. The animation will
        // pause if the widget is not visible, and it will end if the widget is destroyed.
        Widget *WidgetBase

        // Dt is the amount of time in milliseconds that has passed since the
        // last animation frame/step/tick.
        Dt float32

        // Done can be set to true to permanently stop the animation; the [Animation] object
        // will be removed from the [Scene] at the next frame.
        Done bool

        // lastTime is the last time this animation was run.
        lastTime time.Time
}

// Animate adds a new [Animation] to the [Scene] for the widget. The given function is run
// at every tick, and it receives the [Animation] object so that it can reference and modify
// things on it; see the [Animation] docs for more information on things such as [Animation.Dt]
// and [Animation.Done].
func (wb *WidgetBase) Animate(f func(a *Animation)) {
        a := &Animation{
                Func:   f,
                Widget: wb,
        }
        wb.Scene.Animations = append(wb.Scene.Animations, a)
}

// runAnimations runs the [Scene.Animations].
func (sc *Scene) runAnimations() {
        if len(sc.Animations) == 0 {
                return
        }

        for _, a := range sc.Animations {
                if a.Widget == nil || a.Widget.This == nil {
                        a.Done = true
                }
                if a.Done || !a.Widget.IsVisible() {
                        continue
                }
                if a.lastTime.IsZero() {
                        a.Dt = 16.66666667 // 60 FPS fallback
                } else {
                        a.Dt = float32(time.Since(a.lastTime).Seconds()) * 1000
                }
                a.Func(a)
                a.lastTime = time.Now()
        }

        sc.Animations = slices.DeleteFunc(sc.Animations, func(a *Animation) bool {
                return a.Done
        })
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/svg"
        "cogentcore.org/core/system"
)

var (
        // TheApp is the current [App]; only one is ever in effect.
        TheApp = &App{App: system.TheApp}

        // AppAbout is the about information for the current app.
        // It is set by a linker flag in the core command line tool.
        AppAbout string

        // AppIcon is the svg icon for the current app.
        // It is set by a linker flag in the core command line tool.
        // It defaults to [icons.CogentCore] otherwise.
        AppIcon string = string(icons.CogentCore)
)

// App represents a Cogent Core app. It extends [system.App] to provide both system-level
// and high-level data and functions to do with the currently running application. The
// single instance of it is [TheApp], which embeds [system.TheApp].
type App struct { //types:add -setters
        system.App `set:"-"`

        // SceneInit is a function called on every newly created [Scene].
        // This can be used to set global configuration and styling for all
        // widgets in conjunction with [Scene.WidgetInit].
        SceneInit func(sc *Scene) `edit:"-"`
}

// appIconImagesCache is a cached version of [appIconImages].
var appIconImagesCache []image.Image

// appIconImages returns a slice of images of sizes 16x16, 32x32, and 48x48
// rendered from [AppIcon]. It returns nil if [AppIcon] is "" or if there is
// an error. It automatically logs any errors. It caches the result for future
// calls.
func appIconImages() []image.Image {
        if appIconImagesCache != nil {
                return appIconImagesCache
        }
        if AppIcon == "" {
                return nil
        }

        res := make([]image.Image, 3)

        sv := svg.NewSVG(math32.Vec2(16, 16))
        sv.Color = colors.Uniform(colors.FromRGB(66, 133, 244)) // Google Blue (#4285f4)
        err := sv.ReadXML(strings.NewReader(AppIcon))
        if errors.Log(err) != nil {
                return nil
        }

        res[0] = sv.RenderImage()

        sv.SetSize(math32.Vec2(32, 32))
        res[1] = sv.RenderImage()

        sv.SetSize(math32.Vec2(48, 48))
        res[2] = sv.RenderImage()

        appIconImagesCache = res
        return res
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "slices"

        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
)

// BarFuncs are functions for creating control bars,
// attached to different sides of a [Scene]. Functions
// are called in forward order so first added are called first.
type BarFuncs []func(bar *Frame)

// Add adds the given function for configuring a control bar
func (bf *BarFuncs) Add(fun func(bar *Frame)) *BarFuncs {
        *bf = append(*bf, fun)
        return bf
}

// call calls all the functions for configuring given widget
func (bf *BarFuncs) call(bar *Frame) {
        for _, fun := range *bf {
                fun(bar)
        }
}

// isEmpty returns true if there are no functions added
func (bf *BarFuncs) isEmpty() bool {
        return len(*bf) == 0
}

// makeSceneBars configures the side control bars, for main scenes.
func (sc *Scene) makeSceneBars() {
        sc.addDefaultBars()
        if !sc.Bars.Top.isEmpty() {
                head := NewFrame(sc)
                head.SetName("top-bar")
                head.Styler(func(s *styles.Style) {
                        s.Align.Items = styles.Center
                        s.Grow.Set(1, 0)
                })
                sc.Bars.Top.call(head)
        }
        if !sc.Bars.Left.isEmpty() || !sc.Bars.Right.isEmpty() {
                mid := NewFrame(sc)
                mid.SetName("body-area")
                if !sc.Bars.Left.isEmpty() {
                        left := NewFrame(mid)
                        left.SetName("left-bar")
                        left.Styler(func(s *styles.Style) {
                                s.Direction = styles.Column
                                s.Align.Items = styles.Center
                                s.Grow.Set(0, 1)
                        })
                        sc.Bars.Left.call(left)
                }
                if sc.Body != nil {
                        mid.AddChild(sc.Body)
                }
                if !sc.Bars.Right.isEmpty() {
                        right := NewFrame(mid)
                        right.SetName("right-bar")
                        right.Styler(func(s *styles.Style) {
                                s.Direction = styles.Column
                                s.Align.Items = styles.Center
                                s.Grow.Set(0, 1)
                        })
                        sc.Bars.Right.call(right)
                }
        } else {
                if sc.Body != nil {
                        sc.AddChild(sc.Body)
                }
        }
        if !sc.Bars.Bottom.isEmpty() {
                foot := NewFrame(sc)
                foot.SetName("bottom-bar")
                foot.Styler(func(s *styles.Style) {
                        s.Justify.Content = styles.End
                        s.Align.Items = styles.Center
                        s.Grow.Set(1, 0)
                })
                sc.Bars.Bottom.call(foot)
        }
}

func (sc *Scene) addDefaultBars() {
        st := sc.Stage
        addBack := st.BackButton.Or(st.FullWindow && !st.NewWindow && !(st.Mains != nil && st.Mains.stack.Len() == 0))
        if addBack || st.DisplayTitle {
                sc.Bars.Top = slices.Insert(sc.Bars.Top, 0, func(bar *Frame) {
                        if addBack {
                                back := NewButton(bar).SetIcon(icons.ArrowBack).SetKey(keymap.HistPrev)
                                back.SetType(ButtonAction).SetTooltip("Back")
                                back.OnClick(func(e events.Event) {
                                        sc.Close()
                                })
                        }
                        if st.DisplayTitle {
                                title := NewText(bar).SetType(TextHeadlineSmall)
                                title.Updater(func() {
                                        title.SetText(sc.Body.Title)
                                })
                        }
                })
        }
}

////////  Scene wrappers

// AddTopBar adds the given function for configuring a control bar
// at the top of the window
func (bd *Body) AddTopBar(fun func(bar *Frame)) {
        bd.Scene.Bars.Top.Add(fun)
}

// AddLeftBar adds the given function for configuring a control bar
// on the left of the window
func (bd *Body) AddLeftBar(fun func(bar *Frame)) {
        bd.Scene.Bars.Left.Add(fun)
}

// AddRightBar adds the given function for configuring a control bar
// on the right of the window
func (bd *Body) AddRightBar(fun func(bar *Frame)) {
        bd.Scene.Bars.Right.Add(fun)
}

// AddBottomBar adds the given function for configuring a control bar
// at the bottom of the window
func (bd *Body) AddBottomBar(fun func(bar *Frame)) {
        bd.Scene.Bars.Bottom.Add(fun)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "sync"
        "time"
)

// Blinker manages the logistics of blinking things, such as cursors.
type Blinker struct {

        // Ticker is the [time.Ticker] used to control the blinking.
        Ticker *time.Ticker

        // Widget is the current widget subject to blinking.
        Widget Widget

        // Func is the function called every tick.
        // The mutex is locked at the start but must be unlocked
        // when transitioning to locking the render context mutex.
        Func func()

        // Use Lock and Unlock on blinker directly.
        sync.Mutex
}

// Blink sets up the blinking; does nothing if already set up.
func (bl *Blinker) Blink(dur time.Duration) {
        bl.Lock()
        defer bl.Unlock()
        if bl.Ticker != nil {
                return
        }
        bl.Ticker = time.NewTicker(dur)
        go bl.blinkLoop()
}

// SetWidget sets the [Blinker.Widget] under mutex lock.
func (bl *Blinker) SetWidget(w Widget) {
        bl.Lock()
        defer bl.Unlock()
        bl.Widget = w
}

// ResetWidget sets [Blinker.Widget] to nil if it is currently set to the given one.
func (bl *Blinker) ResetWidget(w Widget) {
        bl.Lock()
        defer bl.Unlock()
        if bl.Widget == w {
                bl.Widget = nil
        }
}

// blinkLoop is the blinker's main control loop.
func (bl *Blinker) blinkLoop() {
        for {
                bl.Lock()
                if bl.Ticker == nil {
                        bl.Unlock()
                        return // shutdown..
                }
                bl.Unlock()
                <-bl.Ticker.C
                bl.Lock()
                if bl.Widget == nil {
                        bl.Unlock()
                        continue
                }
                wb := bl.Widget.AsWidget()
                if wb.Scene == nil || wb.Scene.Stage.Main == nil {
                        bl.Widget = nil
                        bl.Unlock()
                        continue
                }
                bl.Func() // we enter the function locked
        }

}

// QuitClean is a cleanup function to pass to [TheApp.AddQuitCleanFunc]
// that breaks out of the ticker loop.
func (bl *Blinker) QuitClean() {
        bl.Lock()
        defer bl.Unlock()
        if bl.Ticker != nil {
                tck := bl.Ticker
                bl.Ticker = nil
                bl.Widget = nil
                tck.Stop()
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/tree"
)

// Body holds the primary content of a [Scene].
// It is the main container for app content.
type Body struct { //core:no-new
        Frame

        // Title is the title of the body, which is also
        // used for the window title where relevant.
        Title string `set:"-"`
}

// NewBody creates a new [Body] that will serve as the content of a [Scene]
// (e.g., a Window, Dialog, etc). [Body] forms the central region
// of a [Scene], and has [styles.OverflowAuto] scrollbars by default.
// It will create its own parent [Scene] at this point, and has wrapper
// functions to transparently manage everything that the [Scene]
// typically manages during configuration, so you can usually avoid
// having to access the [Scene] directly. If a name is given, it will
// be used for the name of the window, and a title widget will be created
// with that text if [Stage.DisplayTitle] is true. Also, if the name of
// [TheApp] is unset, it sets it to the given name.
func NewBody(name ...string) *Body {
        bd := tree.New[Body]()
        nm := "body"
        if len(name) > 0 {
                nm = name[0]
        }
        if TheApp.Name() == "" {
                if len(name) == 0 {
                        nm = "Cogent Core" // first one is called Cogent Core by default
                }
                TheApp.SetName(nm)
        }
        if AppearanceSettings.Zoom == 0 {
                // we load the settings in NewBody so that people can
                // add their own settings to AllSettings first
                errors.Log(LoadAllSettings())
        }
        bd.SetName(nm)
        bd.Title = nm
        bd.Scene = newBodyScene(bd)
        return bd
}

func (bd *Body) Init() {
        bd.Frame.Init()
        bd.Styler(func(s *styles.Style) {
                s.Overflow.Set(styles.OverflowAuto)
                s.Direction = styles.Column
                s.Grow.Set(1, 1)
        })
}

// SetTitle sets the title in the [Body], [Scene], [Stage], [renderWindow],
// and title widget. This is the one place to change the title for everything.
func (bd *Body) SetTitle(title string) *Body {
        bd.Name = title
        bd.Title = title
        bd.Scene.Name = title
        if bd.Scene.Stage != nil {
                bd.Scene.Stage.Title = title
                win := bd.Scene.RenderWindow()
                if win != nil {
                        win.setName(title)
                        win.setTitle(title)
                }
        }
        // title widget is contained within the top bar
        if tb, ok := bd.Scene.ChildByName("top-bar").(Widget); ok {
                tb.AsWidget().Update()
        }
        return bd
}

// SetData sets the [Body]'s [Scene.Data].
func (bd *Body) SetData(data any) *Body {
        bd.Scene.SetData(data)
        return bd
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "log/slog"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// Button is an interactive button with text, an icon, an indicator, a shortcut,
// and/or a menu. The standard behavior is to register a click event handler with
// [WidgetBase.OnClick].
type Button struct { //core:embedder
        Frame

        // Type is the type of button.
        Type ButtonTypes

        // Text is the text for the button.
        // If it is blank, no text is shown.
        Text string

        // Icon is the icon for the button.
        // If it is "" or [icons.None], no icon is shown.
        Icon icons.Icon

        // Indicator is the menu indicator icon to present.
        // If it is "" or [icons.None],, no indicator is shown.
        // It is automatically set to [icons.KeyboardArrowDown]
        // when there is a Menu elements present unless it is
        // set to [icons.None].
        Indicator icons.Icon

        // Shortcut is an optional shortcut keyboard chord to trigger this button,
        // active in window-wide scope. Avoid conflicts with other shortcuts
        // (a log message will be emitted if so). Shortcuts are processed after
        // all other processing of keyboard input. Command is automatically translated
        // into Meta on macOS and Control on all other platforms. Also see [Button.SetKey].
        Shortcut key.Chord

        // Menu is a menu constructor function used to build and display
        // a menu whenever the button is clicked. There will be no menu
        // if it is nil. The constructor function should add buttons
        // to the Scene that it is passed.
        Menu func(m *Scene) `json:"-" xml:"-"`
}

// ButtonTypes is an enum containing the
// different possible types of buttons.
type ButtonTypes int32 //enums:enum -trim-prefix Button

const (
        // ButtonFilled is a filled button with a
        // contrasting background color. It should be
        // used for prominent actions, typically those
        // that are the final in a sequence. It is equivalent
        // to Material Design's filled button.
        ButtonFilled ButtonTypes = iota

        // ButtonTonal is a filled button, similar
        // to [ButtonFilled]. It is used for the same purposes,
        // but it has a lighter background color and less emphasis.
        // It is equivalent to Material Design's filled tonal button.
        ButtonTonal

        // ButtonElevated is an elevated button with
        // a light background color and a shadow.
        // It is equivalent to Material Design's elevated button.
        ButtonElevated

        // ButtonOutlined is an outlined button that is
        // used for secondary actions that are still important.
        // It is equivalent to Material Design's outlined button.
        ButtonOutlined

        // ButtonText is a low-importance button with no border,
        // background color, or shadow when not being interacted with.
        // It renders primary-colored text, and it renders a background
        // color and shadow when hovered/focused/active.
        // It should only be used for low emphasis
        // actions, and you must ensure it stands out from the
        // surrounding context sufficiently. It is equivalent
        // to Material Design's text button, but it can also
        // contain icons and other things.
        ButtonText

        // ButtonAction is a simple button that typically serves
        // as a simple action among a series of other buttons
        // (eg: in a toolbar), or as a part of another widget,
        // like a spinner or snackbar. It has no border, background color,
        // or shadow when not being interacted with. It inherits the text
        // color of its parent, and it renders a background when
        // hovered/focused/active. You must ensure it stands out from the
        // surrounding context sufficiently. It is equivalent to Material Design's
        // icon button, but it can also contain text and other things (and frequently does).
        ButtonAction

        // ButtonMenu is similar to [ButtonAction], but it is designed
        // for buttons located in popup menus.
        ButtonMenu
)

func (bt *Button) Init() {
        bt.Frame.Init()
        bt.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Activatable, abilities.Focusable, abilities.Hoverable, abilities.DoubleClickable, abilities.TripleClickable)
                if !bt.IsDisabled() {
                        s.Cursor = cursors.Pointer
                }
                s.Border.Radius = styles.BorderRadiusFull
                s.Padding.Set(units.Dp(10), units.Dp(24))
                if bt.Icon.IsSet() {
                        s.Padding.Left.Dp(16)
                        if bt.Text == "" {
                                s.Padding.Right.Dp(16)
                        }
                }
                s.Font.Size.Dp(14) // Button font size is used for text font size
                s.Gap.Zero()
                s.CenterAll()

                s.MaxBoxShadow = styles.BoxShadow1()
                switch bt.Type {
                case ButtonFilled:
                        s.Background = colors.Scheme.Primary.Base
                        s.Color = colors.Scheme.Primary.On
                        s.Border.Offset.Set(units.Dp(2))
                case ButtonTonal:
                        s.Background = colors.Scheme.Secondary.Container
                        s.Color = colors.Scheme.Secondary.OnContainer
                case ButtonElevated:
                        s.Background = colors.Scheme.SurfaceContainerLow
                        s.Color = colors.Scheme.Primary.Base
                        s.MaxBoxShadow = styles.BoxShadow2()
                        s.BoxShadow = styles.BoxShadow1()
                case ButtonOutlined:
                        s.Color = colors.Scheme.Primary.Base
                        s.Border.Style.Set(styles.BorderSolid)
                        s.Border.Width.Set(units.Dp(1))
                case ButtonText:
                        s.Color = colors.Scheme.Primary.Base
                case ButtonAction:
                        s.MaxBoxShadow = styles.BoxShadow0()
                case ButtonMenu:
                        s.Grow.Set(1, 0) // need to go to edge of menu
                        s.Justify.Content = styles.Start
                        s.Border.Radius.Zero()
                        s.Padding.Set(units.Dp(6), units.Dp(12))
                        s.MaxBoxShadow = styles.BoxShadow0()
                }
                if s.Is(states.Hovered) {
                        s.BoxShadow = s.MaxBoxShadow
                }
                if bt.IsDisabled() {
                        s.MaxBoxShadow = styles.BoxShadow0()
                        s.BoxShadow = s.MaxBoxShadow
                }
        })

        bt.SendClickOnEnter()
        bt.OnClick(func(e events.Event) {
                if bt.openMenu(e) {
                        e.SetHandled()
                }
        })
        bt.OnDoubleClick(func(e events.Event) {
                bt.Send(events.Click, e)
        })
        bt.On(events.TripleClick, func(e events.Event) {
                bt.Send(events.Click, e)
        })

        bt.Updater(func() {
                // We must get the shortcuts every time since buttons
                // may be added or removed dynamically.
                bt.Events().getShortcutsIn(bt)
        })
        bt.Maker(func(p *tree.Plan) {
                // we check if the icons are unset, not if they are nil, so
                // that people can manually set it to [icons.None]
                if bt.HasMenu() {
                        if bt.Type == ButtonMenu {
                                if bt.Indicator == "" {
                                        bt.Indicator = icons.KeyboardArrowRight
                                }
                        } else if bt.Text != "" {
                                if bt.Indicator == "" {
                                        bt.Indicator = icons.KeyboardArrowDown
                                }
                        } else {
                                if bt.Icon == "" {
                                        bt.Icon = icons.Menu
                                }
                        }
                }
                if bt.Icon.IsSet() {
                        tree.AddAt(p, "icon", func(w *Icon) {
                                w.Styler(func(s *styles.Style) {
                                        s.Font.Size.Dp(18)
                                })
                                w.Updater(func() {
                                        w.SetIcon(bt.Icon)
                                })
                        })
                        if bt.Text != "" {
                                tree.AddAt(p, "space", func(w *Space) {})
                        }
                }
                if bt.Text != "" {
                        tree.AddAt(p, "text", func(w *Text) {
                                w.Styler(func(s *styles.Style) {
                                        s.SetNonSelectable()
                                        s.SetTextWrap(false)
                                        s.FillMargin = false
                                        s.Font.Size = bt.Styles.Font.Size // Directly inherit to override the [Text.Type]-based default
                                })
                                w.Updater(func() {
                                        if bt.Type == ButtonMenu {
                                                w.SetType(TextBodyMedium)
                                        } else {
                                                w.SetType(TextLabelLarge)
                                        }
                                        w.SetText(bt.Text)
                                })
                        })
                }
                if bt.Indicator.IsSet() {
                        tree.AddAt(p, "indicator-stretch", func(w *Stretch) {
                                w.Styler(func(s *styles.Style) {
                                        s.Min.Set(units.Em(0.2))
                                        if bt.Type == ButtonMenu {
                                                s.Grow.Set(1, 0)
                                        } else {
                                                s.Grow.Set(0, 0)
                                        }
                                })
                        })
                        tree.AddAt(p, "indicator", func(w *Icon) {
                                w.Styler(func(s *styles.Style) {
                                        s.Min.X.Dp(18)
                                        s.Min.Y.Dp(18)
                                        s.Margin.Zero()
                                        s.Padding.Zero()
                                })
                                w.Updater(func() {
                                        w.SetIcon(bt.Indicator)
                                })
                        })
                }
                if bt.Type == ButtonMenu && !TheApp.SystemPlatform().IsMobile() {
                        if !bt.Indicator.IsSet() && bt.Shortcut != "" {
                                tree.AddAt(p, "shortcut-stretch", func(w *Stretch) {})
                                tree.AddAt(p, "shortcut", func(w *Text) {
                                        w.Styler(func(s *styles.Style) {
                                                s.SetNonSelectable()
                                                s.SetTextWrap(false)
                                                s.Color = colors.Scheme.OnSurfaceVariant
                                        })
                                        w.Updater(func() {
                                                if bt.Type == ButtonMenu {
                                                        w.SetType(TextBodyMedium)
                                                } else {
                                                        w.SetType(TextLabelLarge)
                                                }
                                                w.SetText(bt.Shortcut.Label())
                                        })
                                })
                        } else if bt.Shortcut != "" {
                                slog.Error("programmer error: Button: shortcut cannot be used on a sub-menu for", "button", bt)
                        }
                }
        })
}

// SetKey sets the shortcut of the button from the given [keymap.Functions].
func (bt *Button) SetKey(kf keymap.Functions) *Button {
        bt.SetShortcut(kf.Chord())
        return bt
}

// Label returns the text of the button if it is set; otherwise it returns the name.
func (bt *Button) Label() string {
        if bt.Text != "" {
                return bt.Text
        }
        return bt.Name
}

// HasMenu returns true if the button has a menu that pops up when it is clicked
// (not that it is in a menu itself; see [ButtonMenu])
func (bt *Button) HasMenu() bool {
        return bt.Menu != nil
}

// openMenu opens any menu associated with this element.
// It returns whether any menu was opened.
func (bt *Button) openMenu(e events.Event) bool {
        if !bt.HasMenu() {
                return false
        }
        pos := bt.ContextMenuPos(e)
        if indic := bt.ChildByName("indicator", 3); indic != nil {
                pos = indic.(Widget).ContextMenuPos(nil) // use the pos
        }
        m := NewMenu(bt.Menu, bt.This.(Widget), pos)
        if m == nil {
                return false
        }
        m.Run()
        return true
}

func (bt *Button) handleClickDismissMenu() {
        // note: must be called last so widgets aren't deleted when the click arrives
        bt.OnFinal(events.Click, func(e events.Event) {
                bt.Scene.Stage.closePopupAndBelow()
        })
}

func (bt *Button) WidgetTooltip(pos image.Point) (string, image.Point) {
        res := bt.Tooltip
        if bt.Shortcut != "" && !TheApp.SystemPlatform().IsMobile() {
                res = "[" + bt.Shortcut.Label() + "]"
                if bt.Tooltip != "" {
                        res += " " + bt.Tooltip
                }
        }
        return res, bt.DefaultTooltipPos()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
)

// Canvas is a widget that can be arbitrarily drawn to by setting
// its Draw function using [Canvas.SetDraw].
type Canvas struct {
        WidgetBase

        // Draw is the function used to draw the content of the
        // canvas every time that it is rendered. The paint context
        // is automatically normalized to the size of the canvas,
        // so you should specify points on a 0-1 scale.
        Draw func(pc *paint.Painter)

        // painter is the paint painter used for drawing.
        painter *paint.Painter
}

func (c *Canvas) Init() {
        c.WidgetBase.Init()
        c.Styler(func(s *styles.Style) {
                s.Min.Set(units.Dp(256))
        })
}

func (c *Canvas) Render() {
        c.WidgetBase.Render()

        sz := c.Geom.Size.Actual.Content
        c.painter = &c.Scene.Painter
        sty := styles.NewPaint()
        sty.Transform = math32.Translate2D(c.Geom.Pos.Content.X, c.Geom.Pos.Content.Y).Scale(sz.X, sz.Y)
        c.painter.PushContext(sty, nil)
        c.painter.VectorEffect = ppath.VectorEffectNonScalingStroke
        c.Draw(c.painter)
        c.painter.PopContext()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "errors"
        "fmt"
        "image"
        "log/slog"
        "reflect"
        "slices"
        "strings"
        "unicode"

        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

// Chooser is a dropdown selection widget that allows users to choose
// one option among a list of items.
type Chooser struct {
        Frame

        // Type is the styling type of the chooser.
        Type ChooserTypes

        // Items are the chooser items available for selection.
        Items []ChooserItem

        // Icon is an optional icon displayed on the left side of the chooser.
        Icon icons.Icon

        // Indicator is the icon to use for the indicator displayed on the
        // right side of the chooser.
        Indicator icons.Icon

        // Editable is whether provide a text field for editing the value,
        // or just a button for selecting items.
        Editable bool

        // AllowNew is whether to allow the user to add new items to the
        // chooser through the editable textfield (if Editable is set to
        // true) and a button at the end of the chooser menu. See also [DefaultNew].
        AllowNew bool

        // DefaultNew configures the chooser to accept new items, as in
        // [AllowNew], and also turns off completion popups and always
        // adds new items to the list of items, without prompting.
        // Use this for cases where the typical use-case is to enter new values,
        // but the history of prior values can also be useful.
        DefaultNew bool

        // placeholder, if Editable is set to true, is the text that is
        // displayed in the text field when it is empty. It must be set
        // using [Chooser.SetPlaceholder].
        placeholder string `set:"-"`

        // ItemsFuncs is a slice of functions to call before showing the items
        // of the chooser, which is typically used to configure them
        // (eg: if they are based on dynamic data). The functions are called
        // in ascending order such that the items added in the first function
        // will appear before those added in the last function. Use
        // [Chooser.AddItemsFunc] to add a new items function. If at least
        // one ItemsFunc is specified, the items of the chooser will be
        // cleared before calling the functions.
        ItemsFuncs []func() `copier:"-" json:"-" xml:"-" set:"-"`

        // CurrentItem is the currently selected item.
        CurrentItem ChooserItem `json:"-" xml:"-" set:"-"`

        // CurrentIndex is the index of the currently selected item
        // in [Chooser.Items].
        CurrentIndex int `json:"-" xml:"-" set:"-"`

        text      *Text
        textField *TextField
}

// ChooserItem is an item that can be used in a [Chooser].
type ChooserItem struct {

        // Value is the underlying value the chooser item represents.
        Value any

        // Text is the text displayed to the user for this item.
        // If it is empty, then [labels.ToLabel] of [ChooserItem.Value]
        // is used instead.
        Text string

        // Icon is the icon displayed to the user for this item.
        Icon icons.Icon

        // Tooltip is the tooltip displayed to the user for this item.
        Tooltip string

        // Func, if non-nil, is a function to call whenever this
        // item is selected as the current value of the chooser.
        Func func() `json:"-" xml:"-"`

        // SeparatorBefore is whether to add a separator before
        // this item in the chooser menu.
        SeparatorBefore bool
}

// GetText returns the effective text for this chooser item.
// If [ChooserItem.Text] is set, it returns that. Otherwise,
// it returns [labels.ToLabel] of [ChooserItem.Value].
func (ci *ChooserItem) GetText() string {
        if ci.Text != "" {
                return ci.Text
        }
        if ci.Value == nil {
                return ""
        }
        return labels.ToLabel(ci.Value)
}

// ChooserTypes is an enum containing the
// different possible types of combo boxes
type ChooserTypes int32 //enums:enum -trim-prefix Chooser

const (
        // ChooserFilled represents a filled
        // Chooser with a background color
        // and a bottom border
        ChooserFilled ChooserTypes = iota

        // ChooserOutlined represents an outlined
        // Chooser with a border on all sides
        // and no background color
        ChooserOutlined
)

func (ch *Chooser) WidgetValue() any { return ch.CurrentItem.Value }

func (ch *Chooser) SetWidgetValue(value any) error {
        rv := reflect.ValueOf(value)
        // If the first item is a pointer, we assume that our value should
        // be a pointer. Otherwise, it should be a non-pointer value.
        if len(ch.Items) > 0 && reflect.TypeOf(ch.Items[0].Value).Kind() == reflect.Pointer {
                rv = reflectx.UnderlyingPointer(rv)
        } else {
                rv = reflectx.Underlying(rv)
        }
        ch.SetCurrentValue(rv.Interface())
        return nil
}

func (ch *Chooser) OnBind(value any, tags reflect.StructTag) {
        if e, ok := value.(enums.Enum); ok {
                ch.SetEnum(e)
        }
}

func (ch *Chooser) Init() {
        ch.Frame.Init()
        ch.SetIcon(icons.None).SetIndicator(icons.KeyboardArrowDown)
        ch.CurrentIndex = -1
        ch.Styler(func(s *styles.Style) {
                if !s.IsReadOnly() {
                        s.SetAbilities(true, abilities.Activatable, abilities.Hoverable, abilities.LongHoverable)
                        if !ch.Editable {
                                s.SetAbilities(true, abilities.Focusable)
                        }
                }
                s.Text.Align = text.Center
                s.Border.Radius = styles.BorderRadiusSmall
                s.Padding.Set(units.Dp(8), units.Dp(16))
                s.CenterAll()
                // textfield handles everything
                if ch.Editable {
                        s.RenderBox = false
                        s.Border = styles.Border{}
                        s.MaxBorder = s.Border
                        s.Background = nil
                        s.StateLayer = 0
                        s.Padding.Zero()
                        s.Border.Radius.Zero()
                }
                if !s.IsReadOnly() {
                        s.Cursor = cursors.Pointer
                        switch ch.Type {
                        case ChooserFilled:
                                s.Background = colors.Scheme.Secondary.Container
                                s.Color = colors.Scheme.Secondary.OnContainer
                        case ChooserOutlined:
                                if !s.Is(states.Focused) {
                                        s.Border.Style.Set(styles.BorderSolid)
                                        s.Border.Width.Set(units.Dp(1))
                                        s.Border.Color.Set(colors.Scheme.OnSurfaceVariant)
                                }
                        }
                }
        })

        ch.OnClick(func(e events.Event) {
                if ch.IsReadOnly() {
                        return
                }
                if ch.openMenu(e) {
                        e.SetHandled()
                }
        })
        ch.OnChange(func(e events.Event) {
                if ch.CurrentItem.Func != nil {
                        ch.CurrentItem.Func()
                }
        })
        ch.OnFinal(events.KeyChord, func(e events.Event) {
                tf := ch.textField
                kf := keymap.Of(e.KeyChord())
                if DebugSettings.KeyEventTrace {
                        slog.Info("Chooser KeyChordEvent", "widget", ch, "keyFunction", kf)
                }
                switch {
                case kf == keymap.MoveUp:
                        e.SetHandled()
                        if len(ch.Items) > 0 {
                                index := ch.CurrentIndex - 1
                                if index < 0 {
                                        index += len(ch.Items)
                                }
                                ch.selectItemEvent(index)
                        }
                case kf == keymap.MoveDown:
                        e.SetHandled()
                        if len(ch.Items) > 0 {
                                index := ch.CurrentIndex + 1
                                if index >= len(ch.Items) {
                                        index -= len(ch.Items)
                                }
                                ch.selectItemEvent(index)
                        }
                case kf == keymap.PageUp:
                        e.SetHandled()
                        if len(ch.Items) > 10 {
                                index := ch.CurrentIndex - 10
                                for index < 0 {
                                        index += len(ch.Items)
                                }
                                ch.selectItemEvent(index)
                        }
                case kf == keymap.PageDown:
                        e.SetHandled()
                        if len(ch.Items) > 10 {
                                index := ch.CurrentIndex + 10
                                for index >= len(ch.Items) {
                                        index -= len(ch.Items)
                                }
                                ch.selectItemEvent(index)
                        }
                case kf == keymap.Enter || (!ch.Editable && e.KeyRune() == ' '):
                        // if !(kt.Rune == ' ' && chb.Sc.Type == ScCompleter) {
                        e.SetHandled()
                        ch.Send(events.Click, e)
                // }
                default:
                        if tf == nil {
                                break
                        }
                        // if we don't have anything special to do,
                        // we just give our key event to our textfield
                        tf.HandleEvent(e)
                }
        })

        ch.Maker(func(p *tree.Plan) {
                // automatically select the first item if we have nothing selected and no placeholder
                if !ch.Editable && ch.CurrentIndex < 0 && ch.CurrentItem.Text == "" {
                        ch.SetCurrentIndex(0)
                }

                // editable handles through TextField
                if ch.Icon.IsSet() && !ch.Editable {
                        tree.AddAt(p, "icon", func(w *Icon) {
                                w.Updater(func() {
                                        w.SetIcon(ch.Icon)
                                })
                        })
                }
                if ch.Editable {
                        tree.AddAt(p, "text-field", func(w *TextField) {
                                ch.textField = w
                                ch.text = nil
                                w.SetPlaceholder(ch.placeholder)
                                w.Styler(func(s *styles.Style) {
                                        s.Grow = ch.Styles.Grow // we grow like our parent
                                        s.Max.X.Zero()          // constrained by parent
                                        s.SetTextWrap(false)
                                })
                                w.SetValidator(func() error {
                                        err := ch.setCurrentText(w.Text())
                                        if err == nil {
                                                ch.SendChange()
                                        }
                                        return err
                                })
                                w.OnFocus(func(e events.Event) {
                                        if ch.IsReadOnly() {
                                                return
                                        }
                                        ch.CallItemsFuncs()
                                })
                                w.OnClick(func(e events.Event) {
                                        ch.CallItemsFuncs()
                                        w.offerComplete()
                                })
                                w.OnKeyChord(func(e events.Event) {
                                        kf := keymap.Of(e.KeyChord())
                                        if kf == keymap.Abort {
                                                if w.error != nil {
                                                        w.clear()
                                                        w.clearError()
                                                        e.SetHandled()
                                                }
                                        }
                                })
                                w.Updater(func() {
                                        if w.error != nil {
                                                return // don't override anything when we have an invalid value
                                        }
                                        w.SetText(ch.CurrentItem.GetText()).SetLeadingIcon(ch.Icon).
                                                SetTrailingIcon(ch.Indicator, func(e events.Event) {
                                                        ch.openMenu(e)
                                                })
                                        if ch.Type == ChooserFilled {
                                                w.SetType(TextFieldFilled)
                                        } else {
                                                w.SetType(TextFieldOutlined)
                                        }
                                        if ch.DefaultNew && w.complete != nil {
                                                w.complete = nil
                                        } else if !ch.DefaultNew && w.complete == nil {
                                                w.SetCompleter(w, ch.completeMatch, ch.completeEdit)
                                        }
                                })
                                w.Maker(func(p *tree.Plan) {
                                        tree.AddInit(p, "trail-icon", func(w *Button) {
                                                w.Styler(func(s *styles.Style) {
                                                        // indicator does not need to be focused
                                                        s.SetAbilities(false, abilities.Focusable)
                                                })
                                        })
                                })
                        })
                } else {
                        tree.AddAt(p, "text", func(w *Text) {
                                ch.text = w
                                ch.textField = nil
                                w.Styler(func(s *styles.Style) {
                                        s.SetNonSelectable()
                                        s.SetTextWrap(false)
                                })
                                w.Updater(func() {
                                        w.SetText(ch.CurrentItem.GetText())
                                })
                        })
                }
                if ch.Indicator == "" {
                        ch.Indicator = icons.KeyboardArrowRight
                }
                // editable handles through TextField
                if !ch.Editable && !ch.IsReadOnly() {
                        tree.AddAt(p, "indicator", func(w *Icon) {
                                w.Styler(func(s *styles.Style) {
                                        s.Justify.Self = styles.End
                                })
                                w.Updater(func() {
                                        w.SetIcon(ch.Indicator)
                                })
                        })
                }
        })
}

// AddItemsFunc adds the given function to [Chooser.ItemsFuncs].
// These functions are called before showing the items of the chooser,
// and they are typically used to configure them (eg: if they are based
// on dynamic data). The functions are called in ascending order such
// that the items added in the first function will appear before those
// added in the last function. If at least one ItemsFunc is specified,
// the items of the chooser will be cleared before calling the functions.
func (ch *Chooser) AddItemsFunc(f func()) *Chooser {
        ch.ItemsFuncs = append(ch.ItemsFuncs, f)
        return ch
}

// CallItemsFuncs calls [Chooser.ItemsFuncs].
func (ch *Chooser) CallItemsFuncs() {
        if len(ch.ItemsFuncs) == 0 {
                return
        }
        ch.Items = nil
        for _, f := range ch.ItemsFuncs {
                f()
        }
}

// SetTypes sets the [Chooser.Items] from the given types.
func (ch *Chooser) SetTypes(ts ...*types.Type) *Chooser {
        ch.Items = make([]ChooserItem, len(ts))
        for i, typ := range ts {
                ch.Items[i] = ChooserItem{Value: typ}
        }
        return ch
}

// SetStrings sets the [Chooser.Items] from the given strings.
func (ch *Chooser) SetStrings(ss ...string) *Chooser {
        ch.Items = make([]ChooserItem, len(ss))
        for i, s := range ss {
                ch.Items[i] = ChooserItem{Value: s}
        }
        return ch
}

// SetEnums sets the [Chooser.Items] from the given enums.
func (ch *Chooser) SetEnums(es ...enums.Enum) *Chooser {
        ch.Items = make([]ChooserItem, len(es))
        for i, enum := range es {
                str := enum.String()
                lbl := strcase.ToSentence(str)
                desc := enum.Desc()
                // If the documentation does not start with the transformed name, but it does
                // start with an uppercase letter, then we assume that the first word of the
                // documentation is the correct untransformed name. This fixes
                // https://github.com/cogentcore/core/issues/774 (also for Switches).
                if !strings.HasPrefix(desc, str) && len(desc) > 0 && unicode.IsUpper(rune(desc[0])) {
                        str, _, _ = strings.Cut(desc, " ")
                }
                tip := types.FormatDoc(desc, str, lbl)
                ch.Items[i] = ChooserItem{Value: enum, Text: lbl, Tooltip: tip}
        }
        return ch
}

// SetEnum sets the [Chooser.Items] from the [enums.Enum.Values] of the given enum.
func (ch *Chooser) SetEnum(enum enums.Enum) *Chooser {
        return ch.SetEnums(enum.Values()...)
}

// findItem finds the given item value on the list of items and returns its index.
func (ch *Chooser) findItem(it any) int {
        for i, v := range ch.Items {
                if it == v.Value {
                        return i
                }
        }
        return -1
}

// SetPlaceholder sets the given placeholder text and
// indicates that nothing has been selected.
func (ch *Chooser) SetPlaceholder(text string) *Chooser {
        ch.placeholder = text
        if !ch.Editable {
                ch.CurrentItem.Text = text
                ch.showCurrentItem()
        }
        ch.CurrentIndex = -1
        return ch
}

// SetCurrentValue sets the current item and index to those associated with the given value.
// If the given item is not found, it adds it to the items list if it is not "". It also
// sets the text of the chooser to the label of the item.
func (ch *Chooser) SetCurrentValue(value any) *Chooser {
        ch.CurrentIndex = ch.findItem(value)
        if value != "" && ch.CurrentIndex < 0 { // add to list if not found
                ch.CurrentIndex = len(ch.Items)
                ch.Items = append(ch.Items, ChooserItem{Value: value})
        }
        if ch.CurrentIndex >= 0 {
                ch.CurrentItem = ch.Items[ch.CurrentIndex]
        }
        ch.showCurrentItem()
        return ch
}

// SetCurrentIndex sets the current index and the item associated with it.
func (ch *Chooser) SetCurrentIndex(index int) *Chooser {
        if index < 0 || index >= len(ch.Items) {
                return ch
        }
        ch.CurrentIndex = index
        ch.CurrentItem = ch.Items[index]
        ch.showCurrentItem()
        return ch
}

// setCurrentText sets the current index and item based on the given text string.
// It can only be used for editable choosers.
func (ch *Chooser) setCurrentText(text string) error {
        for i, item := range ch.Items {
                if text == item.GetText() {
                        ch.SetCurrentIndex(i)
                        return nil
                }
        }
        if !(ch.AllowNew || ch.DefaultNew) {
                return errors.New("unknown value")
        }
        ch.Items = append(ch.Items, ChooserItem{Value: text})
        ch.SetCurrentIndex(len(ch.Items) - 1)
        return nil
}

// showCurrentItem updates the display to present the current item.
func (ch *Chooser) showCurrentItem() *Chooser {
        if ch.Editable {
                tf := ch.textField
                if tf != nil {
                        tf.SetText(ch.CurrentItem.GetText())
                }
        } else {
                text := ch.text
                if text != nil {
                        text.SetText(ch.CurrentItem.GetText()).UpdateWidget()
                }
        }
        if ch.CurrentItem.Icon.IsSet() {
                picon := ch.Icon
                ch.SetIcon(ch.CurrentItem.Icon)
                if ch.Icon != picon {
                        ch.Update()
                }
        }
        ch.NeedsRender()
        return ch
}

// selectItem selects the item at the given index and updates the chooser to display it.
func (ch *Chooser) selectItem(index int) *Chooser {
        if ch.This == nil {
                return ch
        }
        ch.SetCurrentIndex(index)
        ch.NeedsLayout()
        return ch
}

// selectItemEvent selects the item at the given index and updates the chooser to display it.
// It also sends an [events.Change] event to indicate that the value has changed.
func (ch *Chooser) selectItemEvent(index int) *Chooser {
        if ch.This == nil {
                return ch
        }
        ch.selectItem(index)
        if ch.textField != nil {
                ch.textField.validate()
        }
        ch.SendChange()
        return ch
}

// ClearError clears any existing validation error for an editable chooser.
func (ch *Chooser) ClearError() {
        tf := ch.textField
        if tf == nil {
                return
        }
        tf.clearError()
}

// makeItemsMenu constructs a menu of all the items.
// It is used when the chooser is clicked.
func (ch *Chooser) makeItemsMenu(m *Scene) {
        ch.CallItemsFuncs()
        for i, it := range ch.Items {
                if it.SeparatorBefore {
                        NewSeparator(m)
                }
                bt := NewButton(m).SetText(it.GetText()).SetIcon(it.Icon).SetTooltip(it.Tooltip)
                bt.SetSelected(i == ch.CurrentIndex)
                bt.OnClick(func(e events.Event) {
                        ch.selectItemEvent(i)
                })
        }
        if ch.AllowNew {
                NewSeparator(m)
                NewButton(m).SetText("New item").SetIcon(icons.Add).
                        SetTooltip("Add a new item to the chooser").
                        OnClick(func(e events.Event) {
                                d := NewBody("New item")
                                NewText(d).SetType(TextSupporting).SetText("Add a new item to the chooser")
                                tf := NewTextField(d)
                                d.AddBottomBar(func(bar *Frame) {
                                        d.AddCancel(bar)
                                        d.AddOK(bar).SetText("Add").SetIcon(icons.Add).OnClick(func(e events.Event) {
                                                ch.Items = append(ch.Items, ChooserItem{Value: tf.Text()})
                                                ch.selectItemEvent(len(ch.Items) - 1)
                                        })
                                })
                                d.RunDialog(ch)
                        })
        }
}

// openMenu opens the chooser menu that displays all of the items.
// It returns false if there are no items.
func (ch *Chooser) openMenu(e events.Event) bool {
        pos := ch.ContextMenuPos(e)
        if indicator, ok := ch.ChildByName("indicator").(Widget); ok {
                pos = indicator.ContextMenuPos(nil) // use the pos
        }
        m := NewMenu(ch.makeItemsMenu, ch.This.(Widget), pos)
        if m == nil {
                return false
        }
        m.Run()
        return true
}

func (ch *Chooser) WidgetTooltip(pos image.Point) (string, image.Point) {
        if ch.CurrentItem.Tooltip != "" {
                return ch.CurrentItem.Tooltip, ch.DefaultTooltipPos()
        }
        return ch.Tooltip, ch.DefaultTooltipPos()
}

// completeMatch is the [complete.MatchFunc] used for the
// editable text field part of the Chooser (if it exists).
func (ch *Chooser) completeMatch(data any, text string, posLine, posChar int) (md complete.Matches) {
        md.Seed = text
        comps := make(complete.Completions, len(ch.Items))
        for i, item := range ch.Items {
                comps[i] = complete.Completion{
                        Text: item.GetText(),
                        Desc: item.Tooltip,
                        Icon: item.Icon,
                }
        }
        md.Matches = complete.MatchSeedCompletion(comps, md.Seed)
        if ch.AllowNew && text != "" && !slices.ContainsFunc(md.Matches, func(c complete.Completion) bool {
                return c.Text == text
        }) {
                md.Matches = append(md.Matches, complete.Completion{
                        Text:  text,
                        Label: "Add " + text,
                        Icon:  icons.Add,
                        Desc:  fmt.Sprintf("Add %q to the chooser", text),
                })
        }
        return md
}

// completeEdit is the [complete.EditFunc] used for the
// editable textfield part of the Chooser (if it exists).
func (ch *Chooser) completeEdit(data any, text string, cursorPos int, completion complete.Completion, seed string) (ed complete.Edit) {
        return complete.Edit{
                NewText:       completion.Text,
                ForwardDelete: len([]rune(text)),
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/colors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
)

// Collapser is a widget that can be collapsed or expanded by a user.
// The [Collapser.Summary] is always visible, and the [Collapser.Details]
// are only visible when the [Collapser] is expanded with [Collapser.Open]
// equal to true.
//
// You can directly add any widgets to the [Collapser.Summary] and [Collapser.Details]
// by specifying one of them as the parent in calls to New{WidgetName}.
// Collapser is similar to HTML's <details> and <summary> tags.
type Collapser struct {
        Frame

        // Open is whether the collapser is currently expanded. It defaults to false.
        Open bool

        // Summary is the part of the collapser that is always visible.
        Summary *Frame `set:"-"`

        // Details is the part of the collapser that is only visible when
        // the collapser is expanded.
        Details *Frame `set:"-"`
}

func (cl *Collapser) Init() {
        cl.Frame.Init()

        cl.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
                s.Grow.Set(1, 0)
        })
}

func (cl *Collapser) OnAdd() {
        cl.Frame.OnAdd()

        cl.Summary = NewFrame(cl)
        cl.Summary.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 0)
                s.Align.Content = styles.Center
                s.Align.Items = styles.Center
                s.Gap.X.Em(0.1)
        })

        toggle := NewSwitch(cl.Summary).SetType(SwitchCheckbox).SetIconOn(icons.KeyboardArrowDown).SetIconOff(icons.KeyboardArrowRight)
        toggle.SetName("toggle")
        Bind(&cl.Open, toggle)
        toggle.Styler(func(s *styles.Style) {
                s.Color = colors.Scheme.Primary.Base
                s.Padding.Zero()
        })
        toggle.OnChange(func(e events.Event) {
                cl.Update()
        })

        cl.Details = NewFrame(cl)
        cl.Details.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 0)
                s.Direction = styles.Column
        })
        cl.Details.Updater(func() {
                cl.Details.SetState(!cl.Open, states.Invisible)
        })
}

// Copyright (c) 2019, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "log/slog"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/colormap"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
)

// ColorMapName represents the name of a [colormap.Map],
// which can be edited using a [ColorMapButton].
type ColorMapName string

func (cm ColorMapName) Value() Value { return NewColorMapButton() }

// ColorMapButton displays a [colormap.Map] and can be clicked on
// to display a dialog for selecting different color map options.
// It represents a [ColorMapName] value.
type ColorMapButton struct {
        Button
        MapName string
}

func (cm *ColorMapButton) WidgetValue() any { return &cm.MapName }

func (cm *ColorMapButton) Init() {
        cm.Button.Init()
        cm.Styler(func(s *styles.Style) {
                s.Padding.Zero()
                s.Min.Set(units.Em(10), units.Em(2))

                if cm.MapName == "" {
                        s.Background = colors.Scheme.OutlineVariant
                        return
                }
                cm, ok := colormap.AvailableMaps[cm.MapName]
                if !ok {
                        slog.Error("got invalid color map name", "name", cm.Name)
                        s.Background = colors.Scheme.OutlineVariant
                        return
                }
                g := gradient.NewLinear()
                for i := float32(0); i < 1; i += 0.01 {
                        gc := cm.Map(i)
                        g.AddStop(gc, i)
                }
                s.Background = g
        })

        InitValueButton(cm, false, func(d *Body) {
                d.SetTitle("Select a color map")
                sl := colormap.AvailableMapsList()
                si := 0
                ls := NewList(d).SetSlice(&sl).SetSelectedValue(cm.MapName).BindSelect(&si)
                ls.OnChange(func(e events.Event) {
                        cm.MapName = sl[si]
                })
        })
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image/color"

        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/cam/hct"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// ColorPicker represents a color value with an interactive color picker
// composed of history buttons, a hex input, three HCT sliders, and standard
// named color buttons.
type ColorPicker struct {
        Frame

        // Color is the current color.
        Color hct.HCT `set:"-"`
}

func (cp *ColorPicker) WidgetValue() any { return &cp.Color }

// SetColor sets the color of the color picker.
func (cp *ColorPicker) SetColor(c color.Color) *ColorPicker {
        cp.Color = hct.FromColor(c)
        return cp
}

var namedColors = []string{"red", "orange", "yellow", "green", "blue", "violet", "sienna"}

func (cp *ColorPicker) Init() {
        cp.Frame.Init()
        cp.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
                s.Grow.Set(1, 0)
        })

        colorButton := func(w *Button, c color.Color) {
                w.Styler(func(s *styles.Style) {
                        s.Background = colors.Uniform(c)
                        s.Padding.Set(units.Dp(ConstantSpacing(16)))
                })
                w.OnClick(func(e events.Event) {
                        cp.SetColor(c).UpdateChange()
                })
        }

        tree.AddChild(cp, func(w *Frame) {
                tree.AddChild(w, func(w *Button) {
                        w.SetTooltip("Current color")
                        colorButton(w, &cp.Color) // a pointer so it updates
                })
                tree.AddChild(w, func(w *Button) {
                        w.SetTooltip("Previous color")
                        colorButton(w, cp.Color) // not a pointer so it does not update
                })
                tree.AddChild(w, func(w *TextField) {
                        w.SetTooltip("Hex color")
                        w.Styler(func(s *styles.Style) {
                                s.Min.X.Em(5)
                                s.Max.X.Em(5)
                        })
                        w.Updater(func() {
                                w.SetText(colors.AsHex(cp.Color))
                        })
                        w.SetValidator(func() error {
                                c, err := colors.FromHex(w.Text())
                                if err != nil {
                                        return err
                                }
                                cp.SetColor(c).UpdateChange()
                                return nil
                        })
                })
        })

        sf := func(s *styles.Style) {
                s.Min.Y.Em(2)
                s.Min.X.Em(6)
                s.Max.X.Em(40)
                s.Grow.Set(1, 0)
        }
        tree.AddChild(cp, func(w *Slider) {
                Bind(&cp.Color.Hue, w)
                w.SetMin(0).SetMax(360)
                w.SetTooltip("The hue, which is the spectral identity of the color (red, green, blue, etc) in degrees")
                w.OnInput(func(e events.Event) {
                        cp.Color.SetHue(w.Value)
                        cp.UpdateChange()
                })
                w.Styler(func(s *styles.Style) {
                        w.ValueColor = nil
                        w.ThumbColor = colors.Uniform(cp.Color)
                        g := gradient.NewLinear()
                        for h := float32(0); h <= 360; h += 5 {
                                gc := cp.Color.WithHue(h)
                                g.AddStop(gc.AsRGBA(), h/360)
                        }
                        s.Background = g
                })
                w.FinalStyler(sf)
        })
        tree.AddChild(cp, func(w *Slider) {
                Bind(&cp.Color.Chroma, w)
                w.SetMin(0).SetMax(120)
                w.SetTooltip("The chroma, which is the colorfulness/saturation of the color")
                w.Updater(func() {
                        w.SetMax(cp.Color.MaximumChroma())
                })
                w.OnInput(func(e events.Event) {
                        cp.Color.SetChroma(w.Value)
                        cp.UpdateChange()
                })
                w.Styler(func(s *styles.Style) {
                        w.ValueColor = nil
                        w.ThumbColor = colors.Uniform(cp.Color)
                        g := gradient.NewLinear()
                        for c := float32(0); c <= w.Max; c += 5 {
                                gc := cp.Color.WithChroma(c)
                                g.AddStop(gc.AsRGBA(), c/w.Max)
                        }
                        s.Background = g
                })
                w.FinalStyler(sf)
        })
        tree.AddChild(cp, func(w *Slider) {
                Bind(&cp.Color.Tone, w)
                w.SetMin(0).SetMax(100)
                w.SetTooltip("The tone, which is the lightness of the color")
                w.OnInput(func(e events.Event) {
                        cp.Color.SetTone(w.Value)
                        cp.UpdateChange()
                })
                w.Styler(func(s *styles.Style) {
                        w.ValueColor = nil
                        w.ThumbColor = colors.Uniform(cp.Color)
                        g := gradient.NewLinear()
                        for c := float32(0); c <= 100; c += 5 {
                                gc := cp.Color.WithTone(c)
                                g.AddStop(gc.AsRGBA(), c/100)
                        }
                        s.Background = g
                })
                w.FinalStyler(sf)
        })
        tree.AddChild(cp, func(w *Slider) {
                Bind(&cp.Color.A, w)
                w.SetMin(0).SetMax(1)
                w.SetTooltip("The opacity of the color")
                w.OnInput(func(e events.Event) {
                        cp.Color.SetColor(colors.WithAF32(cp.Color, w.Value))
                        cp.UpdateChange()
                })
                w.Styler(func(s *styles.Style) {
                        w.ValueColor = nil
                        w.ThumbColor = colors.Uniform(cp.Color)
                        g := gradient.NewLinear()
                        for c := float32(0); c <= 1; c += 0.05 {
                                gc := colors.WithAF32(cp.Color, c)
                                g.AddStop(gc, c)
                        }
                        s.Background = g
                })
                w.FinalStyler(sf)
        })

        tree.AddChild(cp, func(w *Frame) {
                for _, name := range namedColors {
                        c := colors.Map[name]
                        tree.AddChildAt(w, name, func(w *Button) {
                                w.SetTooltip(strcase.ToSentence(name))
                                colorButton(w, c)
                        })
                }
        })
}

// ColorButton represents a color value with a button that opens a [ColorPicker].
type ColorButton struct {
        Button
        Color color.RGBA
}

func (cb *ColorButton) WidgetValue() any { return &cb.Color }

func (cb *ColorButton) Init() {
        cb.Button.Init()
        cb.SetType(ButtonTonal).SetText("Edit color").SetIcon(icons.Colors)
        cb.Styler(func(s *styles.Style) {
                // we need to display button as non-transparent
                // so that it can be seen
                dclr := colors.WithAF32(cb.Color, 1)
                s.Background = colors.Uniform(dclr)
                s.Color = colors.Uniform(hct.ContrastColor(dclr, hct.ContrastAAA))
        })
        InitValueButton(cb, false, func(d *Body) {
                d.SetTitle("Edit color")
                cp := NewColorPicker(d).SetColor(cb.Color)
                cp.OnChange(func(e events.Event) {
                        cb.Color = cp.Color.AsRGBA()
                })
        })
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "sync"
        "time"

        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/text/parse/complete"
)

// Complete holds the current completion data and functions to call for building
// the list of possible completions and for editing text after a completion is selected.
// It also holds the popup [Stage] associated with it.
type Complete struct { //types:add -setters

        // function to get the list of possible completions
        MatchFunc complete.MatchFunc

        // function to get the text to show for lookup
        LookupFunc complete.LookupFunc

        // function to edit text using the selected completion
        EditFunc complete.EditFunc

        // the context object that implements the completion functions
        Context any

        // line number in source that completion is operating on, if relevant
        SrcLn int

        // character position in source that completion is operating on
        SrcCh int

        // the list of potential completions
        completions complete.Completions

        // current completion seed
        Seed string

        // the user's completion selection
        Completion string

        // the event listeners for the completer (it sends [events.Select] events)
        listeners events.Listeners

        // stage is the popup [Stage] associated with the [Complete].
        stage *Stage

        delayTimer *time.Timer
        delayMu    sync.Mutex
        showMu     sync.Mutex
}

// NewComplete returns a new [Complete] object. It does not show it; see [Complete.Show].
func NewComplete() *Complete {
        return &Complete{}
}

// IsAboutToShow returns true if the DelayTimer is started for
// preparing to show a completion.  note: don't really need to lock
func (c *Complete) IsAboutToShow() bool {
        c.delayMu.Lock()
        defer c.delayMu.Unlock()
        return c.delayTimer != nil
}

// Show is the main call for listing completions.
// Has a builtin delay timer so completions are only shown after
// a delay, which resets every time it is called.
// After delay, Calls ShowNow, which calls MatchFunc
// to get a list of completions and builds the completion popup menu
func (c *Complete) Show(ctx Widget, pos image.Point, text string) {
        if c.MatchFunc == nil {
                return
        }
        wait := SystemSettings.CompleteWaitDuration
        if c.stage != nil {
                c.Cancel()
        }
        if wait == 0 {
                c.showNow(ctx, pos, text)
                return
        }
        c.delayMu.Lock()
        if c.delayTimer != nil {
                c.delayTimer.Stop()
        }
        c.delayTimer = time.AfterFunc(wait,
                func() {
                        c.showNowAsync(ctx, pos, text)
                        c.delayMu.Lock()
                        c.delayTimer = nil
                        c.delayMu.Unlock()
                })
        c.delayMu.Unlock()
}

// showNow actually calls MatchFunc to get a list of completions and builds the
// completion popup menu.  This is the sync version called from
func (c *Complete) showNow(ctx Widget, pos image.Point, text string) {
        if c.stage != nil {
                c.Cancel()
        }
        c.showMu.Lock()
        defer c.showMu.Unlock()
        if c.showNowImpl(ctx, pos, text) {
                c.stage.runPopup()
        }
}

// showNowAsync actually calls MatchFunc to get a list of completions and builds the
// completion popup menu.  This is the Async version for delayed AfterFunc call.
func (c *Complete) showNowAsync(ctx Widget, pos image.Point, text string) {
        if c.stage != nil {
                c.cancelAsync()
        }
        c.showMu.Lock()
        defer c.showMu.Unlock()
        if c.showNowImpl(ctx, pos, text) {
                c.stage.runPopupAsync()
        }
}

// showNowImpl is the implementation of ShowNow, presenting completions.
// Returns false if nothing to show.
func (c *Complete) showNowImpl(ctx Widget, pos image.Point, text string) bool {
        md := c.MatchFunc(c.Context, text, c.SrcLn, c.SrcCh)
        c.completions = md.Matches
        c.Seed = md.Seed
        if len(c.completions) == 0 {
                return false
        }
        if len(c.completions) > SystemSettings.CompleteMaxItems {
                c.completions = c.completions[0:SystemSettings.CompleteMaxItems]
        }

        sc := NewScene(ctx.AsTree().Name + "-complete")
        StyleMenuScene(sc)
        c.stage = NewPopupStage(CompleterStage, sc, ctx).SetPos(pos)
        // we forward our key events to the context object
        // so that you can keep typing while in a completer
        // sc.OnKeyChord(ctx.HandleEvent)

        for i := 0; i < len(c.completions); i++ {
                cmp := &c.completions[i]
                text := cmp.Text
                if cmp.Label != "" {
                        text = cmp.Label
                }
                icon := cmp.Icon
                mi := NewButton(sc).SetText(text).SetIcon(icons.Icon(icon))
                mi.SetTooltip(cmp.Desc)
                mi.OnClick(func(e events.Event) {
                        c.complete(cmp.Text)
                })
                mi.OnKeyChord(func(e events.Event) {
                        kf := keymap.Of(e.KeyChord())
                        if e.KeyRune() == ' ' {
                                ctx.AsWidget().HandleEvent(e) // bypass button handler!
                        }
                        if kf == keymap.Enter {
                                e.SetHandled()
                                c.complete(cmp.Text)
                        }
                })
                if i == 0 {
                        sc.Events.SetStartFocus(mi)
                }
        }
        return true
}

// Cancel cancels any existing or pending completion.
// Call when new events nullify prior completions.
// Returns true if canceled.
func (c *Complete) Cancel() bool {
        if c.stage == nil {
                return false
        }
        st := c.stage
        c.stage = nil
        st.ClosePopup()
        return true
}

// cancelAsync cancels any existing *or* pending completion,
// inside a delayed callback function (Async)
// Call when new events nullify prior completions.
// Returns true if canceled.
func (c *Complete) cancelAsync() bool {
        if c.stage == nil {
                return false
        }
        st := c.stage
        c.stage = nil
        st.closePopupAsync()
        return true
}

// Lookup is the main call for doing lookups.
func (c *Complete) Lookup(text string, posLine, posChar int, sc *Scene, pt image.Point) {
        if c.LookupFunc == nil || sc == nil {
                return
        }
        // c.Sc = nil
        c.LookupFunc(c.Context, text, posLine, posChar) // this processes result directly
}

// complete sends Select event to listeners, indicating that the user has made a
// selection from the list of possible completions.
// This is called inside the main event loop.
func (c *Complete) complete(s string) {
        c.Cancel()
        c.Completion = s
        c.listeners.Call(&events.Base{Typ: events.Select})
}

// OnSelect registers given listener function for [events.Select] events on Value.
// This is the primary notification event for all [Complete] elements.
func (c *Complete) OnSelect(fun func(e events.Event)) {
        c.On(events.Select, fun)
}

// On adds an event listener function for the given event type.
func (c *Complete) On(etype events.Types, fun func(e events.Event)) {
        c.listeners.Add(etype, fun)
}

// GetCompletion returns the completion with the given text.
func (c *Complete) GetCompletion(s string) complete.Completion {
        for _, cc := range c.completions {
                if s == cc.Text {
                        return cc
                }
        }
        return complete.Completion{}
}

// CompleteEditText is a chance to modify the completion selection before it is inserted.
func CompleteEditText(text string, cp int, completion string, seed string) (ed complete.Edit) {
        ed.NewText = completion
        return ed
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "log/slog"
        "reflect"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
)

// RunDialog returns and runs a new [DialogStage] that does not take up
// the full window it is created in, in the context of the given widget.
// See [Body.NewDialog] to make a new dialog without running it.
func (bd *Body) RunDialog(ctx Widget) *Stage {
        return bd.NewDialog(ctx).Run()
}

// NewDialog returns a new [DialogStage] that does not take up the
// full window it is created in, in the context of the given widget.
// You must call [Stage.Run] to run the dialog; see [Body.RunDialog]
// for a version that automatically runs it.
func (bd *Body) NewDialog(ctx Widget) *Stage {
        ctx = nonNilContext(ctx)
        bd.dialogStyles()
        bd.Scene.Stage = newMainStage(DialogStage, bd.Scene)
        bd.Scene.Stage.SetModal(true)
        bd.Scene.Stage.SetContext(ctx)
        bd.Scene.Stage.Pos = ctx.ContextMenuPos(nil)
        return bd.Scene.Stage
}

// RunFullDialog returns and runs a new [DialogStage] that takes up the full
// window it is created in, in the context of the given widget.
// See [Body.NewFullDialog] to make a full dialog without running it.
func (bd *Body) RunFullDialog(ctx Widget) *Stage {
        return bd.NewFullDialog(ctx).Run()
}

// NewFullDialog returns a new [DialogStage] that takes up the full
// window it is created in, in the context of the given widget.
// You must call [Stage.Run] to run the dialog; see [Body.RunFullDialog]
// for a version that automatically runs it.
func (bd *Body) NewFullDialog(ctx Widget) *Stage {
        bd.dialogStyles()
        bd.Scene.Stage = newMainStage(DialogStage, bd.Scene)
        bd.Scene.Stage.SetModal(true)
        bd.Scene.Stage.SetContext(ctx)
        bd.Scene.Stage.SetFullWindow(true)
        return bd.Scene.Stage
}

// RunWindowDialog returns and runs a new [DialogStage] that is placed in
// a new system window on multi-window platforms, in the context of the given widget.
// See [Body.NewWindowDialog] to make a dialog window without running it.
func (bd *Body) RunWindowDialog(ctx Widget) *Stage {
        return bd.NewWindowDialog(ctx).Run()
}

// NewWindowDialog returns a new [DialogStage] that is placed in
// a new system window on multi-window platforms, in the context of the given widget.
// You must call [Stage.Run] to run the dialog; see [Body.RunWindowDialog]
// for a version that automatically runs it.
func (bd *Body) NewWindowDialog(ctx Widget) *Stage {
        bd.NewFullDialog(ctx)
        bd.Scene.Stage.SetNewWindow(true)
        return bd.Scene.Stage
}

// RecycleDialog looks for a dialog with the given data. If it
// finds it, it shows it and returns true. Otherwise, it returns false.
// See [RecycleMainWindow] for a non-dialog window version.
func RecycleDialog(data any) bool {
        rw, got := dialogRenderWindows.findData(data)
        if !got {
                return false
        }
        rw.Raise()
        return true
}

// MessageDialog opens a new Dialog displaying the given message
// in the context of the given widget. An optional title can be provided.
func MessageDialog(ctx Widget, message string, title ...string) {
        ttl := ""
        if len(title) > 0 {
                ttl = title[0]
        }
        d := NewBody(ttl)
        NewText(d).SetType(TextSupporting).SetText(message)
        d.AddOKOnly().RunDialog(ctx)
}

// ErrorDialog opens a new dialog displaying the given error
// in the context of the given widget. An optional title can
// be provided; if it is not, the title will default to
// "There was an error". If the given error is nil, no dialog
// is created.
func ErrorDialog(ctx Widget, err error, title ...string) {
        if err == nil {
                return
        }
        ttl := "There was an error"
        if len(title) > 0 {
                ttl = title[0]
        }
        // we need to get [errors.CallerInfo] at this level
        slog.Error(ttl + ": " + err.Error() + " | " + errors.CallerInfo())
        d := NewBody(ttl)
        NewText(d).SetType(TextSupporting).SetText(err.Error())
        d.AddOKOnly().RunDialog(ctx)
}

// AddOK adds an OK button to the given parent widget (typically in
// [Body.AddBottomBar]), connecting to [keymap.Accept]. Clicking on
// the OK button automatically results in the dialog being closed;
// you can add your own [WidgetBase.OnClick] listener to do things
// beyond that. Also see [Body.AddOKOnly].
func (bd *Body) AddOK(parent Widget) *Button {
        bt := NewButton(parent).SetText("OK")
        bt.OnFinal(events.Click, func(e events.Event) { // then close
                e.SetHandled() // otherwise propagates to dead elements
                bd.Close()
        })
        bd.Scene.OnFirst(events.KeyChord, func(e events.Event) {
                kf := keymap.Of(e.KeyChord())
                if kf == keymap.Accept {
                        e.SetHandled()
                        bt.Send(events.Click, e)
                }
        })
        return bt
}

// AddOKOnly adds an OK button to the bottom bar of the [Body] through
// [Body.AddBottomBar], connecting to [keymap.Accept]. Clicking on the
// OK button automatically results in the dialog being closed. Also see
// [Body.AddOK].
func (bd *Body) AddOKOnly() *Body {
        bd.AddBottomBar(func(bar *Frame) { bd.AddOK(bar) })
        return bd
}

// AddCancel adds a cancel button to the given parent widget
// (typically in [Body.AddBottomBar]), connecting to [keymap.Abort].
// Clicking on the cancel button automatically results in the dialog
// being closed; you can add your own [WidgetBase.OnClick] listener
// to do things beyond that.
func (bd *Body) AddCancel(parent Widget) *Button {
        bt := NewButton(parent).SetType(ButtonOutlined).SetText("Cancel")
        bt.OnClick(func(e events.Event) {
                e.SetHandled() // otherwise propagates to dead elements
                bd.Close()
        })
        abort := func(e events.Event) {
                kf := keymap.Of(e.KeyChord())
                if kf == keymap.Abort {
                        e.SetHandled()
                        bt.Send(events.Click, e)
                        bd.Close()
                }
        }
        bd.OnFirst(events.KeyChord, abort)
        bt.OnFirst(events.KeyChord, abort)
        return bt
}

// Close closes the [Stage] associated with this [Body] (typically for dialogs).
func (bd *Body) Close() {
        bd.Scene.Close()
}

// dialogStyles sets default stylers for dialog bodies.
// It is automatically called in [Body.NewDialog].
func (bd *Body) dialogStyles() {
        bd.Scene.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
                s.Color = colors.Scheme.OnSurface
                if !bd.Scene.Stage.NewWindow && !bd.Scene.Stage.FullWindow {
                        s.Padding.Set(units.Dp(24))
                        s.Border.Radius = styles.BorderRadiusLarge
                        s.BoxShadow = styles.BoxShadow3()
                        s.Background = colors.Scheme.SurfaceContainerLow
                }
        })
}

// nonNilContext returns a non-nil context widget, falling back on the top
// scene of the current window.
func nonNilContext(ctx Widget) Widget {
        if !reflectx.IsNil(reflect.ValueOf(ctx)) {
                return ctx
        }
        return currentRenderWindow.mains.top().Scene
}

// Code generated by "core generate"; DO NOT EDIT.

package core

import (
        "cogentcore.org/core/enums"
)

var _ButtonTypesValues = []ButtonTypes{0, 1, 2, 3, 4, 5, 6}

// ButtonTypesN is the highest valid value for type ButtonTypes, plus one.
const ButtonTypesN ButtonTypes = 7

var _ButtonTypesValueMap = map[string]ButtonTypes{`Filled`: 0, `Tonal`: 1, `Elevated`: 2, `Outlined`: 3, `Text`: 4, `Action`: 5, `Menu`: 6}

var _ButtonTypesDescMap = map[ButtonTypes]string{0: `ButtonFilled is a filled button with a contrasting background color. It should be used for prominent actions, typically those that are the final in a sequence. It is equivalent to Material Design's filled button.`, 1: `ButtonTonal is a filled button, similar to [ButtonFilled]. It is used for the same purposes, but it has a lighter background color and less emphasis. It is equivalent to Material Design's filled tonal button.`, 2: `ButtonElevated is an elevated button with a light background color and a shadow. It is equivalent to Material Design's elevated button.`, 3: `ButtonOutlined is an outlined button that is used for secondary actions that are still important. It is equivalent to Material Design's outlined button.`, 4: `ButtonText is a low-importance button with no border, background color, or shadow when not being interacted with. It renders primary-colored text, and it renders a background color and shadow when hovered/focused/active. It should only be used for low emphasis actions, and you must ensure it stands out from the surrounding context sufficiently. It is equivalent to Material Design's text button, but it can also contain icons and other things.`, 5: `ButtonAction is a simple button that typically serves as a simple action among a series of other buttons (eg: in a toolbar), or as a part of another widget, like a spinner or snackbar. It has no border, background color, or shadow when not being interacted with. It inherits the text color of its parent, and it renders a background when hovered/focused/active. You must ensure it stands out from the surrounding context sufficiently. It is equivalent to Material Design's icon button, but it can also contain text and other things (and frequently does).`, 6: `ButtonMenu is similar to [ButtonAction], but it is designed for buttons located in popup menus.`}

var _ButtonTypesMap = map[ButtonTypes]string{0: `Filled`, 1: `Tonal`, 2: `Elevated`, 3: `Outlined`, 4: `Text`, 5: `Action`, 6: `Menu`}

// String returns the string representation of this ButtonTypes value.
func (i ButtonTypes) String() string { return enums.String(i, _ButtonTypesMap) }

// SetString sets the ButtonTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *ButtonTypes) SetString(s string) error {
        return enums.SetString(i, s, _ButtonTypesValueMap, "ButtonTypes")
}

// Int64 returns the ButtonTypes value as an int64.
func (i ButtonTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the ButtonTypes value from an int64.
func (i *ButtonTypes) SetInt64(in int64) { *i = ButtonTypes(in) }

// Desc returns the description of the ButtonTypes value.
func (i ButtonTypes) Desc() string { return enums.Desc(i, _ButtonTypesDescMap) }

// ButtonTypesValues returns all possible values for the type ButtonTypes.
func ButtonTypesValues() []ButtonTypes { return _ButtonTypesValues }

// Values returns all possible values for the type ButtonTypes.
func (i ButtonTypes) Values() []enums.Enum { return enums.Values(_ButtonTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i ButtonTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *ButtonTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "ButtonTypes")
}

var _ChooserTypesValues = []ChooserTypes{0, 1}

// ChooserTypesN is the highest valid value for type ChooserTypes, plus one.
const ChooserTypesN ChooserTypes = 2

var _ChooserTypesValueMap = map[string]ChooserTypes{`Filled`: 0, `Outlined`: 1}

var _ChooserTypesDescMap = map[ChooserTypes]string{0: `ChooserFilled represents a filled Chooser with a background color and a bottom border`, 1: `ChooserOutlined represents an outlined Chooser with a border on all sides and no background color`}

var _ChooserTypesMap = map[ChooserTypes]string{0: `Filled`, 1: `Outlined`}

// String returns the string representation of this ChooserTypes value.
func (i ChooserTypes) String() string { return enums.String(i, _ChooserTypesMap) }

// SetString sets the ChooserTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *ChooserTypes) SetString(s string) error {
        return enums.SetString(i, s, _ChooserTypesValueMap, "ChooserTypes")
}

// Int64 returns the ChooserTypes value as an int64.
func (i ChooserTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the ChooserTypes value from an int64.
func (i *ChooserTypes) SetInt64(in int64) { *i = ChooserTypes(in) }

// Desc returns the description of the ChooserTypes value.
func (i ChooserTypes) Desc() string { return enums.Desc(i, _ChooserTypesDescMap) }

// ChooserTypesValues returns all possible values for the type ChooserTypes.
func ChooserTypesValues() []ChooserTypes { return _ChooserTypesValues }

// Values returns all possible values for the type ChooserTypes.
func (i ChooserTypes) Values() []enums.Enum { return enums.Values(_ChooserTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i ChooserTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *ChooserTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "ChooserTypes")
}

var _LayoutPassesValues = []LayoutPasses{0, 1, 2}

// LayoutPassesN is the highest valid value for type LayoutPasses, plus one.
const LayoutPassesN LayoutPasses = 3

var _LayoutPassesValueMap = map[string]LayoutPasses{`SizeUpPass`: 0, `SizeDownPass`: 1, `SizeFinalPass`: 2}

var _LayoutPassesDescMap = map[LayoutPasses]string{0: ``, 1: ``, 2: ``}

var _LayoutPassesMap = map[LayoutPasses]string{0: `SizeUpPass`, 1: `SizeDownPass`, 2: `SizeFinalPass`}

// String returns the string representation of this LayoutPasses value.
func (i LayoutPasses) String() string { return enums.String(i, _LayoutPassesMap) }

// SetString sets the LayoutPasses value from its string representation,
// and returns an error if the string is invalid.
func (i *LayoutPasses) SetString(s string) error {
        return enums.SetString(i, s, _LayoutPassesValueMap, "LayoutPasses")
}

// Int64 returns the LayoutPasses value as an int64.
func (i LayoutPasses) Int64() int64 { return int64(i) }

// SetInt64 sets the LayoutPasses value from an int64.
func (i *LayoutPasses) SetInt64(in int64) { *i = LayoutPasses(in) }

// Desc returns the description of the LayoutPasses value.
func (i LayoutPasses) Desc() string { return enums.Desc(i, _LayoutPassesDescMap) }

// LayoutPassesValues returns all possible values for the type LayoutPasses.
func LayoutPassesValues() []LayoutPasses { return _LayoutPassesValues }

// Values returns all possible values for the type LayoutPasses.
func (i LayoutPasses) Values() []enums.Enum { return enums.Values(_LayoutPassesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i LayoutPasses) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *LayoutPasses) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "LayoutPasses")
}

var _MeterTypesValues = []MeterTypes{0, 1, 2}

// MeterTypesN is the highest valid value for type MeterTypes, plus one.
const MeterTypesN MeterTypes = 3

var _MeterTypesValueMap = map[string]MeterTypes{`Linear`: 0, `Circle`: 1, `Semicircle`: 2}

var _MeterTypesDescMap = map[MeterTypes]string{0: `MeterLinear indicates to render a meter that goes in a straight, linear direction, either horizontal or vertical, as specified by [styles.Style.Direction].`, 1: `MeterCircle indicates to render the meter as a circle.`, 2: `MeterSemicircle indicates to render the meter as a semicircle.`}

var _MeterTypesMap = map[MeterTypes]string{0: `Linear`, 1: `Circle`, 2: `Semicircle`}

// String returns the string representation of this MeterTypes value.
func (i MeterTypes) String() string { return enums.String(i, _MeterTypesMap) }

// SetString sets the MeterTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *MeterTypes) SetString(s string) error {
        return enums.SetString(i, s, _MeterTypesValueMap, "MeterTypes")
}

// Int64 returns the MeterTypes value as an int64.
func (i MeterTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the MeterTypes value from an int64.
func (i *MeterTypes) SetInt64(in int64) { *i = MeterTypes(in) }

// Desc returns the description of the MeterTypes value.
func (i MeterTypes) Desc() string { return enums.Desc(i, _MeterTypesDescMap) }

// MeterTypesValues returns all possible values for the type MeterTypes.
func MeterTypesValues() []MeterTypes { return _MeterTypesValues }

// Values returns all possible values for the type MeterTypes.
func (i MeterTypes) Values() []enums.Enum { return enums.Values(_MeterTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i MeterTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *MeterTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "MeterTypes")
}

var _renderWindowFlagsValues = []renderWindowFlags{0, 1, 2, 3, 4, 5}

// renderWindowFlagsN is the highest valid value for type renderWindowFlags, plus one.
const renderWindowFlagsN renderWindowFlags = 6

var _renderWindowFlagsValueMap = map[string]renderWindowFlags{`IsRendering`: 0, `RenderSkipped`: 1, `Resize`: 2, `StopEventLoop`: 3, `Closing`: 4, `GotFocus`: 5}

var _renderWindowFlagsDescMap = map[renderWindowFlags]string{0: `winIsRendering indicates that the renderAsync function is running.`, 1: `winRenderSkipped indicates that a render update was skipped, so another update will be run to ensure full updating.`, 2: `winResize indicates that the window was just resized.`, 3: `winStopEventLoop indicates that the event loop should be stopped.`, 4: `winClosing is whether the window is closing.`, 5: `winGotFocus indicates that have we received focus.`}

var _renderWindowFlagsMap = map[renderWindowFlags]string{0: `IsRendering`, 1: `RenderSkipped`, 2: `Resize`, 3: `StopEventLoop`, 4: `Closing`, 5: `GotFocus`}

// String returns the string representation of this renderWindowFlags value.
func (i renderWindowFlags) String() string { return enums.BitFlagString(i, _renderWindowFlagsValues) }

// BitIndexString returns the string representation of this renderWindowFlags value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i renderWindowFlags) BitIndexString() string { return enums.String(i, _renderWindowFlagsMap) }

// SetString sets the renderWindowFlags value from its string representation,
// and returns an error if the string is invalid.
func (i *renderWindowFlags) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the renderWindowFlags value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *renderWindowFlags) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _renderWindowFlagsValueMap, "renderWindowFlags")
}

// Int64 returns the renderWindowFlags value as an int64.
func (i renderWindowFlags) Int64() int64 { return int64(i) }

// SetInt64 sets the renderWindowFlags value from an int64.
func (i *renderWindowFlags) SetInt64(in int64) { *i = renderWindowFlags(in) }

// Desc returns the description of the renderWindowFlags value.
func (i renderWindowFlags) Desc() string { return enums.Desc(i, _renderWindowFlagsDescMap) }

// renderWindowFlagsValues returns all possible values for the type renderWindowFlags.
func renderWindowFlagsValues() []renderWindowFlags { return _renderWindowFlagsValues }

// Values returns all possible values for the type renderWindowFlags.
func (i renderWindowFlags) Values() []enums.Enum { return enums.Values(_renderWindowFlagsValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *renderWindowFlags) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *renderWindowFlags) SetFlag(on bool, f ...enums.BitFlag) {
        enums.SetFlag((*int64)(i), on, f...)
}

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i renderWindowFlags) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *renderWindowFlags) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "renderWindowFlags")
}

var _sceneFlagsValues = []sceneFlags{0, 1, 2, 3, 4, 5, 6}

// sceneFlagsN is the highest valid value for type sceneFlags, plus one.
const sceneFlagsN sceneFlags = 7

var _sceneFlagsValueMap = map[string]sceneFlags{`HasShown`: 0, `Updating`: 1, `NeedsRender`: 2, `NeedsLayout`: 3, `HasDeferred`: 4, `ImageUpdated`: 5, `ContentSizing`: 6}

var _sceneFlagsDescMap = map[sceneFlags]string{0: `sceneHasShown is whether this scene has been shown. This is used to ensure that [events.Show] is only sent once.`, 1: `sceneUpdating means the Scene is in the process of sceneUpdating. It is set for any kind of tree-level update. Skip any further update passes until it goes off.`, 2: `sceneNeedsRender is whether anything in the Scene needs to be re-rendered (but not necessarily the whole scene itself).`, 3: `sceneNeedsLayout is whether the Scene needs a new layout pass.`, 4: `sceneHasDeferred is whether the Scene has elements with Deferred functions.`, 5: `sceneImageUpdated indicates that the Scene's image has been updated e.g., due to a render or a resize. This is reset by the global [RenderWindow] rendering pass, so it knows whether it needs to copy the image up to the GPU or not.`, 6: `sceneContentSizing means that this scene is currently doing a contentSize computation to compute the size of the scene (for sizing window for example). Affects layout size computation.`}

var _sceneFlagsMap = map[sceneFlags]string{0: `HasShown`, 1: `Updating`, 2: `NeedsRender`, 3: `NeedsLayout`, 4: `HasDeferred`, 5: `ImageUpdated`, 6: `ContentSizing`}

// String returns the string representation of this sceneFlags value.
func (i sceneFlags) String() string { return enums.BitFlagString(i, _sceneFlagsValues) }

// BitIndexString returns the string representation of this sceneFlags value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i sceneFlags) BitIndexString() string { return enums.String(i, _sceneFlagsMap) }

// SetString sets the sceneFlags value from its string representation,
// and returns an error if the string is invalid.
func (i *sceneFlags) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the sceneFlags value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *sceneFlags) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _sceneFlagsValueMap, "sceneFlags")
}

// Int64 returns the sceneFlags value as an int64.
func (i sceneFlags) Int64() int64 { return int64(i) }

// SetInt64 sets the sceneFlags value from an int64.
func (i *sceneFlags) SetInt64(in int64) { *i = sceneFlags(in) }

// Desc returns the description of the sceneFlags value.
func (i sceneFlags) Desc() string { return enums.Desc(i, _sceneFlagsDescMap) }

// sceneFlagsValues returns all possible values for the type sceneFlags.
func sceneFlagsValues() []sceneFlags { return _sceneFlagsValues }

// Values returns all possible values for the type sceneFlags.
func (i sceneFlags) Values() []enums.Enum { return enums.Values(_sceneFlagsValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *sceneFlags) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *sceneFlags) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i sceneFlags) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *sceneFlags) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "sceneFlags")
}

var _ThemesValues = []Themes{0, 1, 2}

// ThemesN is the highest valid value for type Themes, plus one.
const ThemesN Themes = 3

var _ThemesValueMap = map[string]Themes{`Auto`: 0, `Light`: 1, `Dark`: 2}

var _ThemesDescMap = map[Themes]string{0: `ThemeAuto indicates to use the theme specified by the operating system`, 1: `ThemeLight indicates to use a light theme`, 2: `ThemeDark indicates to use a dark theme`}

var _ThemesMap = map[Themes]string{0: `Auto`, 1: `Light`, 2: `Dark`}

// String returns the string representation of this Themes value.
func (i Themes) String() string { return enums.String(i, _ThemesMap) }

// SetString sets the Themes value from its string representation,
// and returns an error if the string is invalid.
func (i *Themes) SetString(s string) error { return enums.SetString(i, s, _ThemesValueMap, "Themes") }

// Int64 returns the Themes value as an int64.
func (i Themes) Int64() int64 { return int64(i) }

// SetInt64 sets the Themes value from an int64.
func (i *Themes) SetInt64(in int64) { *i = Themes(in) }

// Desc returns the description of the Themes value.
func (i Themes) Desc() string { return enums.Desc(i, _ThemesDescMap) }

// ThemesValues returns all possible values for the type Themes.
func ThemesValues() []Themes { return _ThemesValues }

// Values returns all possible values for the type Themes.
func (i Themes) Values() []enums.Enum { return enums.Values(_ThemesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Themes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Themes) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Themes") }

var _SizeClassesValues = []SizeClasses{0, 1, 2}

// SizeClassesN is the highest valid value for type SizeClasses, plus one.
const SizeClassesN SizeClasses = 3

var _SizeClassesValueMap = map[string]SizeClasses{`Compact`: 0, `Medium`: 1, `Expanded`: 2}

var _SizeClassesDescMap = map[SizeClasses]string{0: `SizeCompact is the size class for windows with a width less than 600dp, which typically happens on phones.`, 1: `SizeMedium is the size class for windows with a width between 600dp and 840dp inclusive, which typically happens on tablets.`, 2: `SizeExpanded is the size class for windows with a width greater than 840dp, which typically happens on desktop and laptop computers.`}

var _SizeClassesMap = map[SizeClasses]string{0: `Compact`, 1: `Medium`, 2: `Expanded`}

// String returns the string representation of this SizeClasses value.
func (i SizeClasses) String() string { return enums.String(i, _SizeClassesMap) }

// SetString sets the SizeClasses value from its string representation,
// and returns an error if the string is invalid.
func (i *SizeClasses) SetString(s string) error {
        return enums.SetString(i, s, _SizeClassesValueMap, "SizeClasses")
}

// Int64 returns the SizeClasses value as an int64.
func (i SizeClasses) Int64() int64 { return int64(i) }

// SetInt64 sets the SizeClasses value from an int64.
func (i *SizeClasses) SetInt64(in int64) { *i = SizeClasses(in) }

// Desc returns the description of the SizeClasses value.
func (i SizeClasses) Desc() string { return enums.Desc(i, _SizeClassesDescMap) }

// SizeClassesValues returns all possible values for the type SizeClasses.
func SizeClassesValues() []SizeClasses { return _SizeClassesValues }

// Values returns all possible values for the type SizeClasses.
func (i SizeClasses) Values() []enums.Enum { return enums.Values(_SizeClassesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i SizeClasses) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *SizeClasses) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "SizeClasses")
}

var _SliderTypesValues = []SliderTypes{0, 1}

// SliderTypesN is the highest valid value for type SliderTypes, plus one.
const SliderTypesN SliderTypes = 2

var _SliderTypesValueMap = map[string]SliderTypes{`Slider`: 0, `Scrollbar`: 1}

var _SliderTypesDescMap = map[SliderTypes]string{0: `SliderSlider indicates a standard, user-controllable slider for setting a numeric value.`, 1: `SliderScrollbar indicates a slider acting as a scrollbar for content. It has a [Slider.visiblePercent] factor that specifies the percent of the content currently visible, which determines the size of the thumb, and thus the range of motion remaining for the thumb Value ([Slider.visiblePercent] = 1 means thumb is full size, and no remaining range of motion). The content size (inside the margin and padding) determines the outer bounds of the rendered area.`}

var _SliderTypesMap = map[SliderTypes]string{0: `Slider`, 1: `Scrollbar`}

// String returns the string representation of this SliderTypes value.
func (i SliderTypes) String() string { return enums.String(i, _SliderTypesMap) }

// SetString sets the SliderTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *SliderTypes) SetString(s string) error {
        return enums.SetString(i, s, _SliderTypesValueMap, "SliderTypes")
}

// Int64 returns the SliderTypes value as an int64.
func (i SliderTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the SliderTypes value from an int64.
func (i *SliderTypes) SetInt64(in int64) { *i = SliderTypes(in) }

// Desc returns the description of the SliderTypes value.
func (i SliderTypes) Desc() string { return enums.Desc(i, _SliderTypesDescMap) }

// SliderTypesValues returns all possible values for the type SliderTypes.
func SliderTypesValues() []SliderTypes { return _SliderTypesValues }

// Values returns all possible values for the type SliderTypes.
func (i SliderTypes) Values() []enums.Enum { return enums.Values(_SliderTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i SliderTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *SliderTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "SliderTypes")
}

var _SplitsTilesValues = []SplitsTiles{0, 1, 2, 3, 4}

// SplitsTilesN is the highest valid value for type SplitsTiles, plus one.
const SplitsTilesN SplitsTiles = 5

var _SplitsTilesValueMap = map[string]SplitsTiles{`Span`: 0, `Split`: 1, `FirstLong`: 2, `SecondLong`: 3, `Plus`: 4}

var _SplitsTilesDescMap = map[SplitsTiles]string{0: `Span has a single element spanning the cross dimension, i.e., a vertical span for a horizontal main axis, or a horizontal span for a vertical main axis. It is the only valid value for 1D Splits, where it specifies a single element per split. If all tiles are Span, then a 1D line is generated.`, 1: `Split has a split between elements along the cross dimension, with the first of 2 elements in the first main axis line and the second in the second line.`, 2: `FirstLong has a long span of first element along the first main axis line and a split between the next two elements along the second line, with a split between the two lines. Visually, the splits form a T shape for a horizontal main axis.`, 3: `SecondLong has the first two elements split along the first line, and the third with a long span along the second main axis line, with a split between the two lines. Visually, the splits form an inverted T shape for a horizontal main axis.`, 4: `Plus is arranged like a plus sign + with the main split along the main axis line, and then individual cross-axis splits between the first two and next two elements.`}

var _SplitsTilesMap = map[SplitsTiles]string{0: `Span`, 1: `Split`, 2: `FirstLong`, 3: `SecondLong`, 4: `Plus`}

// String returns the string representation of this SplitsTiles value.
func (i SplitsTiles) String() string { return enums.String(i, _SplitsTilesMap) }

// SetString sets the SplitsTiles value from its string representation,
// and returns an error if the string is invalid.
func (i *SplitsTiles) SetString(s string) error {
        return enums.SetString(i, s, _SplitsTilesValueMap, "SplitsTiles")
}

// Int64 returns the SplitsTiles value as an int64.
func (i SplitsTiles) Int64() int64 { return int64(i) }

// SetInt64 sets the SplitsTiles value from an int64.
func (i *SplitsTiles) SetInt64(in int64) { *i = SplitsTiles(in) }

// Desc returns the description of the SplitsTiles value.
func (i SplitsTiles) Desc() string { return enums.Desc(i, _SplitsTilesDescMap) }

// SplitsTilesValues returns all possible values for the type SplitsTiles.
func SplitsTilesValues() []SplitsTiles { return _SplitsTilesValues }

// Values returns all possible values for the type SplitsTiles.
func (i SplitsTiles) Values() []enums.Enum { return enums.Values(_SplitsTilesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i SplitsTiles) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *SplitsTiles) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "SplitsTiles")
}

var _StageTypesValues = []StageTypes{0, 1, 2, 3, 4, 5}

// StageTypesN is the highest valid value for type StageTypes, plus one.
const StageTypesN StageTypes = 6

var _StageTypesValueMap = map[string]StageTypes{`WindowStage`: 0, `DialogStage`: 1, `MenuStage`: 2, `TooltipStage`: 3, `SnackbarStage`: 4, `CompleterStage`: 5}

var _StageTypesDescMap = map[StageTypes]string{0: `WindowStage is a MainStage that displays a [Scene] in a full window. One of these must be created first, as the primary app content, and it typically persists throughout. It fills the [renderWindow]. Additional windows can be created either within the same [renderWindow] on all platforms or in separate [renderWindow]s on desktop platforms.`, 1: `DialogStage is a MainStage that displays a [Scene] in a smaller dialog window on top of a [WindowStage], or in a full or separate window. It can be [Stage.Modal] or not.`, 2: `MenuStage is a PopupStage that displays a [Scene] typically containing [Button]s overlaid on a MainStage. It is typically [Stage.Modal] and [Stage.ClickOff], and closes when an button is clicked.`, 3: `TooltipStage is a PopupStage that displays a [Scene] with extra text info for a widget overlaid on a MainStage. It is typically [Stage.ClickOff] and not [Stage.Modal].`, 4: `SnackbarStage is a PopupStage that displays a [Scene] with text info and an optional additional button. It is displayed at the bottom of the screen. It is typically not [Stage.ClickOff] or [Stage.Modal], but has a [Stage.Timeout].`, 5: `CompleterStage is a PopupStage that displays a [Scene] with text completion options, spelling corrections, or other such dynamic info. It is typically [Stage.ClickOff], not [Stage.Modal], dynamically updating, and closes when something is selected or typing renders it no longer relevant.`}

var _StageTypesMap = map[StageTypes]string{0: `WindowStage`, 1: `DialogStage`, 2: `MenuStage`, 3: `TooltipStage`, 4: `SnackbarStage`, 5: `CompleterStage`}

// String returns the string representation of this StageTypes value.
func (i StageTypes) String() string { return enums.String(i, _StageTypesMap) }

// SetString sets the StageTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *StageTypes) SetString(s string) error {
        return enums.SetString(i, s, _StageTypesValueMap, "StageTypes")
}

// Int64 returns the StageTypes value as an int64.
func (i StageTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the StageTypes value from an int64.
func (i *StageTypes) SetInt64(in int64) { *i = StageTypes(in) }

// Desc returns the description of the StageTypes value.
func (i StageTypes) Desc() string { return enums.Desc(i, _StageTypesDescMap) }

// StageTypesValues returns all possible values for the type StageTypes.
func StageTypesValues() []StageTypes { return _StageTypesValues }

// Values returns all possible values for the type StageTypes.
func (i StageTypes) Values() []enums.Enum { return enums.Values(_StageTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i StageTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *StageTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "StageTypes")
}

var _SwitchTypesValues = []SwitchTypes{0, 1, 2, 3, 4}

// SwitchTypesN is the highest valid value for type SwitchTypes, plus one.
const SwitchTypesN SwitchTypes = 5

var _SwitchTypesValueMap = map[string]SwitchTypes{`switch`: 0, `chip`: 1, `checkbox`: 2, `radio-button`: 3, `segmented-button`: 4}

var _SwitchTypesDescMap = map[SwitchTypes]string{0: `SwitchSwitch indicates to display a switch as a switch (toggle slider).`, 1: `SwitchChip indicates to display a switch as chip (like Material Design's filter chip), which is typically only used in the context of [Switches].`, 2: `SwitchCheckbox indicates to display a switch as a checkbox.`, 3: `SwitchRadioButton indicates to display a switch as a radio button.`, 4: `SwitchSegmentedButton indicates to display a segmented button, which is typically only used in the context of [Switches].`}

var _SwitchTypesMap = map[SwitchTypes]string{0: `switch`, 1: `chip`, 2: `checkbox`, 3: `radio-button`, 4: `segmented-button`}

// String returns the string representation of this SwitchTypes value.
func (i SwitchTypes) String() string { return enums.String(i, _SwitchTypesMap) }

// SetString sets the SwitchTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *SwitchTypes) SetString(s string) error {
        return enums.SetString(i, s, _SwitchTypesValueMap, "SwitchTypes")
}

// Int64 returns the SwitchTypes value as an int64.
func (i SwitchTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the SwitchTypes value from an int64.
func (i *SwitchTypes) SetInt64(in int64) { *i = SwitchTypes(in) }

// Desc returns the description of the SwitchTypes value.
func (i SwitchTypes) Desc() string { return enums.Desc(i, _SwitchTypesDescMap) }

// SwitchTypesValues returns all possible values for the type SwitchTypes.
func SwitchTypesValues() []SwitchTypes { return _SwitchTypesValues }

// Values returns all possible values for the type SwitchTypes.
func (i SwitchTypes) Values() []enums.Enum { return enums.Values(_SwitchTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i SwitchTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *SwitchTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "SwitchTypes")
}

var _TabTypesValues = []TabTypes{0, 1, 2, 3, 4}

// TabTypesN is the highest valid value for type TabTypes, plus one.
const TabTypesN TabTypes = 5

var _TabTypesValueMap = map[string]TabTypes{`StandardTabs`: 0, `FunctionalTabs`: 1, `NavigationAuto`: 2, `NavigationBar`: 3, `NavigationDrawer`: 4}

var _TabTypesDescMap = map[TabTypes]string{0: `StandardTabs indicates to render the standard type of Material Design style tabs.`, 1: `FunctionalTabs indicates to render functional tabs like those in Google Chrome. These tabs take up less space and are the only kind that can be closed. They will also support being moved at some point.`, 2: `NavigationAuto indicates to render the tabs as either [NavigationBar] or [NavigationDrawer] if [WidgetBase.SizeClass] is [SizeCompact] or not, respectively. NavigationAuto should typically be used instead of one of the specific navigation types for better cross-platform compatability.`, 3: `NavigationBar indicates to render the tabs as a bottom navigation bar with text and icons.`, 4: `NavigationDrawer indicates to render the tabs as a side navigation drawer with text and icons.`}

var _TabTypesMap = map[TabTypes]string{0: `StandardTabs`, 1: `FunctionalTabs`, 2: `NavigationAuto`, 3: `NavigationBar`, 4: `NavigationDrawer`}

// String returns the string representation of this TabTypes value.
func (i TabTypes) String() string { return enums.String(i, _TabTypesMap) }

// SetString sets the TabTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *TabTypes) SetString(s string) error {
        return enums.SetString(i, s, _TabTypesValueMap, "TabTypes")
}

// Int64 returns the TabTypes value as an int64.
func (i TabTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the TabTypes value from an int64.
func (i *TabTypes) SetInt64(in int64) { *i = TabTypes(in) }

// Desc returns the description of the TabTypes value.
func (i TabTypes) Desc() string { return enums.Desc(i, _TabTypesDescMap) }

// TabTypesValues returns all possible values for the type TabTypes.
func TabTypesValues() []TabTypes { return _TabTypesValues }

// Values returns all possible values for the type TabTypes.
func (i TabTypes) Values() []enums.Enum { return enums.Values(_TabTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i TabTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *TabTypes) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "TabTypes") }

var _TextTypesValues = []TextTypes{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}

// TextTypesN is the highest valid value for type TextTypes, plus one.
const TextTypesN TextTypes = 16

var _TextTypesValueMap = map[string]TextTypes{`DisplayLarge`: 0, `DisplayMedium`: 1, `DisplaySmall`: 2, `HeadlineLarge`: 3, `HeadlineMedium`: 4, `HeadlineSmall`: 5, `TitleLarge`: 6, `TitleMedium`: 7, `TitleSmall`: 8, `BodyLarge`: 9, `BodyMedium`: 10, `BodySmall`: 11, `LabelLarge`: 12, `LabelMedium`: 13, `LabelSmall`: 14, `Supporting`: 15}

var _TextTypesDescMap = map[TextTypes]string{0: `TextDisplayLarge is large, short, and important display text with a default font size of 57dp.`, 1: `TextDisplayMedium is medium-sized, short, and important display text with a default font size of 45dp.`, 2: `TextDisplaySmall is small, short, and important display text with a default font size of 36dp.`, 3: `TextHeadlineLarge is large, high-emphasis headline text with a default font size of 32dp.`, 4: `TextHeadlineMedium is medium-sized, high-emphasis headline text with a default font size of 28dp.`, 5: `TextHeadlineSmall is small, high-emphasis headline text with a default font size of 24dp.`, 6: `TextTitleLarge is large, medium-emphasis title text with a default font size of 22dp.`, 7: `TextTitleMedium is medium-sized, medium-emphasis title text with a default font size of 16dp.`, 8: `TextTitleSmall is small, medium-emphasis title text with a default font size of 14dp.`, 9: `TextBodyLarge is large body text used for longer passages of text with a default font size of 16dp.`, 10: `TextBodyMedium is medium-sized body text used for longer passages of text with a default font size of 14dp.`, 11: `TextBodySmall is small body text used for longer passages of text with a default font size of 12dp.`, 12: `TextLabelLarge is large text used for label text (like a caption or the text inside a button) with a default font size of 14dp.`, 13: `TextLabelMedium is medium-sized text used for label text (like a caption or the text inside a button) with a default font size of 12dp.`, 14: `TextLabelSmall is small text used for label text (like a caption or the text inside a button) with a default font size of 11dp.`, 15: `TextSupporting is medium-sized supporting text typically used for secondary dialog information below the title. It has a default font size of 14dp and color of [colors.Scheme.OnSurfaceVariant].`}

var _TextTypesMap = map[TextTypes]string{0: `DisplayLarge`, 1: `DisplayMedium`, 2: `DisplaySmall`, 3: `HeadlineLarge`, 4: `HeadlineMedium`, 5: `HeadlineSmall`, 6: `TitleLarge`, 7: `TitleMedium`, 8: `TitleSmall`, 9: `BodyLarge`, 10: `BodyMedium`, 11: `BodySmall`, 12: `LabelLarge`, 13: `LabelMedium`, 14: `LabelSmall`, 15: `Supporting`}

// String returns the string representation of this TextTypes value.
func (i TextTypes) String() string { return enums.String(i, _TextTypesMap) }

// SetString sets the TextTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *TextTypes) SetString(s string) error {
        return enums.SetString(i, s, _TextTypesValueMap, "TextTypes")
}

// Int64 returns the TextTypes value as an int64.
func (i TextTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the TextTypes value from an int64.
func (i *TextTypes) SetInt64(in int64) { *i = TextTypes(in) }

// Desc returns the description of the TextTypes value.
func (i TextTypes) Desc() string { return enums.Desc(i, _TextTypesDescMap) }

// TextTypesValues returns all possible values for the type TextTypes.
func TextTypesValues() []TextTypes { return _TextTypesValues }

// Values returns all possible values for the type TextTypes.
func (i TextTypes) Values() []enums.Enum { return enums.Values(_TextTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i TextTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *TextTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "TextTypes")
}

var _TextFieldTypesValues = []TextFieldTypes{0, 1}

// TextFieldTypesN is the highest valid value for type TextFieldTypes, plus one.
const TextFieldTypesN TextFieldTypes = 2

var _TextFieldTypesValueMap = map[string]TextFieldTypes{`Filled`: 0, `Outlined`: 1}

var _TextFieldTypesDescMap = map[TextFieldTypes]string{0: `TextFieldFilled represents a filled [TextField] with a background color and a bottom border.`, 1: `TextFieldOutlined represents an outlined [TextField] with a border on all sides and no background color.`}

var _TextFieldTypesMap = map[TextFieldTypes]string{0: `Filled`, 1: `Outlined`}

// String returns the string representation of this TextFieldTypes value.
func (i TextFieldTypes) String() string { return enums.String(i, _TextFieldTypesMap) }

// SetString sets the TextFieldTypes value from its string representation,
// and returns an error if the string is invalid.
func (i *TextFieldTypes) SetString(s string) error {
        return enums.SetString(i, s, _TextFieldTypesValueMap, "TextFieldTypes")
}

// Int64 returns the TextFieldTypes value as an int64.
func (i TextFieldTypes) Int64() int64 { return int64(i) }

// SetInt64 sets the TextFieldTypes value from an int64.
func (i *TextFieldTypes) SetInt64(in int64) { *i = TextFieldTypes(in) }

// Desc returns the description of the TextFieldTypes value.
func (i TextFieldTypes) Desc() string { return enums.Desc(i, _TextFieldTypesDescMap) }

// TextFieldTypesValues returns all possible values for the type TextFieldTypes.
func TextFieldTypesValues() []TextFieldTypes { return _TextFieldTypesValues }

// Values returns all possible values for the type TextFieldTypes.
func (i TextFieldTypes) Values() []enums.Enum { return enums.Values(_TextFieldTypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i TextFieldTypes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *TextFieldTypes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "TextFieldTypes")
}

var _widgetFlagsValues = []widgetFlags{0, 1}

// widgetFlagsN is the highest valid value for type widgetFlags, plus one.
const widgetFlagsN widgetFlags = 2

var _widgetFlagsValueMap = map[string]widgetFlags{`ValueNewWindow`: 0, `NeedsRender`: 1}

var _widgetFlagsDescMap = map[widgetFlags]string{0: `widgetValueNewWindow indicates that the dialog of a [Value] should be opened as a new window, instead of a typical full window in the same current window. This is set by [InitValueButton] and handled by [openValueDialog]. This is triggered by holding down the Shift key while clicking on a [Value] button. Certain values such as [FileButton] may set this to true in their [InitValueButton] function.`, 1: `widgetNeedsRender is whether the widget needs to be rendered on the next render iteration.`}

var _widgetFlagsMap = map[widgetFlags]string{0: `ValueNewWindow`, 1: `NeedsRender`}

// String returns the string representation of this widgetFlags value.
func (i widgetFlags) String() string { return enums.BitFlagString(i, _widgetFlagsValues) }

// BitIndexString returns the string representation of this widgetFlags value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i widgetFlags) BitIndexString() string { return enums.String(i, _widgetFlagsMap) }

// SetString sets the widgetFlags value from its string representation,
// and returns an error if the string is invalid.
func (i *widgetFlags) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the widgetFlags value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *widgetFlags) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _widgetFlagsValueMap, "widgetFlags")
}

// Int64 returns the widgetFlags value as an int64.
func (i widgetFlags) Int64() int64 { return int64(i) }

// SetInt64 sets the widgetFlags value from an int64.
func (i *widgetFlags) SetInt64(in int64) { *i = widgetFlags(in) }

// Desc returns the description of the widgetFlags value.
func (i widgetFlags) Desc() string { return enums.Desc(i, _widgetFlagsDescMap) }

// widgetFlagsValues returns all possible values for the type widgetFlags.
func widgetFlagsValues() []widgetFlags { return _widgetFlagsValues }

// Values returns all possible values for the type widgetFlags.
func (i widgetFlags) Values() []enums.Enum { return enums.Values(_widgetFlagsValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *widgetFlags) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *widgetFlags) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i widgetFlags) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *widgetFlags) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "widgetFlags")
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "log"
        "log/slog"
        "os"
        "path/filepath"
        "strings"
        "sync"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
        "github.com/anthonynsimon/bild/clone"
)

// dragSpriteName is the name of the sprite added when dragging an object.
const dragSpriteName = "__DragSprite__"

// note: Events should be in exclusive control of its own state
// and IF we end up needing a mutex, it should be global on main
// entry points (HandleEvent, anything else?)

// Events is an event manager that handles incoming events for a [Scene].
// It creates all the derived event types (Hover, Sliding, Dragging)
// and Focus management for keyboard events.
type Events struct {

        // scene is the scene that we manage events for.
        scene *Scene

        // mutex that protects timer variable updates (e.g., hover AfterFunc's).
        timerMu sync.Mutex

        // stack of sprites with mouse pointer in BBox, with any listeners present.
        spriteInBBox []*Sprite

        // currently pressing sprite.
        spritePress *Sprite

        // currently sliding (dragging) sprite.
        spriteSlide *Sprite

        // stack of widgets with mouse pointer in BBox, and are not Disabled.
        // Last item in the stack is the deepest nested widget (smallest BBox).
        mouseInBBox []Widget

        // stack of hovered widgets: have mouse pointer in BBox and have Hoverable flag.
        hovers []Widget

        // lastClickWidget is the last widget that has been clicked on.
        lastClickWidget Widget

        // lastDoubleClickWidget is the last widget that has been clicked on.
        lastDoubleClickWidget Widget

        // lastClickTime is the time the last widget was clicked on.
        lastClickTime time.Time

        // the current candidate for a long hover event.
        longHoverWidget Widget

        // the position of the mouse at the start of LongHoverTimer.
        longHoverPos image.Point

        // the timer for the LongHover event, started with time.AfterFunc.
        longHoverTimer *time.Timer

        // the current candidate for a long press event.
        longPressWidget Widget

        // the position of the mouse at the start of LongPressTimer.
        longPressPos image.Point

        // the timer for the LongPress event, started with time.AfterFunc.
        longPressTimer *time.Timer

        // stack of drag-hovered widgets: have mouse pointer in BBox and have Droppable flag.
        dragHovers []Widget

        // the deepest widget that was just pressed.
        press Widget

        // widget receiving mouse dragging events, for drag-n-drop.
        drag Widget

        // the deepest draggable widget that was just pressed.
        dragPress Widget

        // widget receiving mouse sliding events.
        slide Widget

        // the deepest slideable widget that was just pressed.
        slidePress Widget

        // widget receiving mouse scrolling events, has "scroll focus".
        scroll Widget

        lastScrollTime time.Time

        // widget being held down with RepeatClickable ability.
        repeatClick Widget

        // the timer for RepeatClickable items.
        repeatClickTimer *time.Timer

        // widget receiving keyboard events. Use SetFocus.
        focus Widget

        // currently attended widget. Use SetAttend.
        attended Widget

        // widget to focus on at start when no other focus has been
        // set yet. Use SetStartFocus.
        startFocus Widget

        // if StartFocus not set, activate starting focus on first element
        startFocusFirst bool

        // previously focused widget.  Was in Focus when FocusClear is called.
        prevFocus Widget

        // Currently active shortcuts for this window (shortcuts are always window-wide.
        // Use widget key event processing for more local key functions)
        shortcuts shortcuts

        // source data from DragStart event.
        dragData any
}

// mains returns the stack of main stages for our scene.
func (em *Events) mains() *stages {
        if em.scene == nil {
                return nil
        }
        return em.scene.Stage.Mains
}

// RenderWindow returns the overall render window in which we reside,
// which could be nil.
func (em *Events) RenderWindow() *renderWindow {
        mgr := em.mains()
        if mgr == nil {
                return nil
        }
        return mgr.renderWindow
}

func (em *Events) handleEvent(e events.Event) {
        if e.IsHandled() {
                return
        }
        switch {
        case e.HasPos():
                em.handlePosEvent(e)
        case e.NeedsFocus():
                em.handleFocusEvent(e)
        }
}

func (em *Events) handleFocusEvent(e events.Event) {
        // key down and key up can not give active focus, only key chord
        if tree.IsNil(em.focus) && e.Type() != events.KeyDown && e.Type() != events.KeyUp {
                switch {
                case !tree.IsNil(em.startFocus):
                        if DebugSettings.FocusTrace {
                                fmt.Println(em.scene, "StartFocus:", em.startFocus)
                        }
                        em.setFocus(em.startFocus)
                case !tree.IsNil(em.prevFocus):
                        if DebugSettings.FocusTrace {
                                fmt.Println(em.scene, "PrevFocus:", em.prevFocus)
                        }
                        em.setFocus(em.prevFocus)
                        em.prevFocus = nil
                }
        }
        if !tree.IsNil(em.focus) {
                em.focus.AsTree().WalkUpParent(func(k tree.Node) bool {
                        wb := AsWidget(k)
                        if !wb.IsDisplayable() {
                                return tree.Break
                        }
                        wb.firstHandleEvent(e)
                        return !e.IsHandled()
                })
                if !e.IsHandled() {
                        em.focus.AsWidget().HandleEvent(e)
                }
                if !e.IsHandled() {
                        em.focus.AsTree().WalkUpParent(func(k tree.Node) bool {
                                wb := AsWidget(k)
                                if !wb.IsDisplayable() {
                                        return tree.Break
                                }
                                wb.finalHandleEvent(e)
                                return !e.IsHandled()
                        })
                }
        }
        em.managerKeyChordEvents(e)
}

func (em *Events) resetOnMouseDown() {
        em.press = nil
        em.drag = nil
        em.dragPress = nil
        em.slide = nil
        em.slidePress = nil
        em.spriteSlide = nil
        em.spritePress = nil

        em.cancelRepeatClick()

        // if we have sent a long hover start event, we send an end
        // event (non-nil widget plus nil timer means we already sent)
        if !tree.IsNil(em.longHoverWidget) && em.longHoverTimer == nil {
                em.longHoverWidget.AsWidget().Send(events.LongHoverEnd)
        }
        em.longHoverWidget = nil
        em.longHoverPos = image.Point{}
        if em.longHoverTimer != nil {
                em.longHoverTimer.Stop()
                em.longHoverTimer = nil
        }
}

func (em *Events) handlePosEvent(e events.Event) {
        pos := e.Pos()
        et := e.Type()
        sc := em.scene

        switch et {
        case events.MouseDown:
                em.resetOnMouseDown()
        case events.MouseDrag:
                if em.spriteSlide != nil {
                        em.spriteSlide.handleEvent(e)
                        em.spriteSlide.send(events.SlideMove, e)
                        e.SetHandled()
                        return
                }
                if !tree.IsNil(em.slide) {
                        em.slide.AsWidget().HandleEvent(e)
                        em.slide.AsWidget().Send(events.SlideMove, e)
                        e.SetHandled()
                        return
                }
        case events.Scroll:
                if !tree.IsNil(em.scroll) {
                        scInTime := time.Since(em.lastScrollTime) < DeviceSettings.ScrollFocusTime
                        if scInTime {
                                em.scroll.AsWidget().HandleEvent(e)
                                if e.IsHandled() {
                                        em.lastScrollTime = time.Now()
                                }
                                return
                        }
                        em.scroll = nil
                }
        }

        em.spriteInBBox = nil
        if et != events.MouseMove {
                em.getSpriteInBBox(sc, e.WindowPos())

                if len(em.spriteInBBox) > 0 {
                        if em.handleSpriteEvent(e) {
                                return
                        }
                }
        }

        em.mouseInBBox = nil
        em.getMouseInBBox(sc, pos)

        n := len(em.mouseInBBox)
        if n == 0 {
                if DebugSettings.EventTrace && et != events.MouseMove {
                        log.Println("Nothing in bbox:", sc.Geom.TotalBBox, "pos:", pos)
                }
                return
        }

        var press, dragPress, slidePress, move, up, repeatClick Widget
        for i := n - 1; i >= 0; i-- {
                w := em.mouseInBBox[i]
                wb := w.AsWidget()

                // we need to handle this here and not in [Events.GetMouseInBBox] so that
                // we correctly process cursors for disabled elements.
                // in ScRenderBBoxes, everyone is effectively enabled
                if wb.StateIs(states.Disabled) && !sc.renderBBoxes {
                        continue
                }
                // everyone gets the primary event who is in scope, deepest first
                if et == events.Scroll {
                        if wb.AbilityIs(abilities.ScrollableUnattended) || (wb.StateIs(states.Focused) || wb.StateIs(states.Attended)) {
                                w.AsWidget().HandleEvent(e)
                        }
                } else {
                        w.AsWidget().HandleEvent(e)
                }
                if tree.IsNil(w) { // died while handling
                        continue
                }
                switch et {
                case events.MouseMove:
                        em.scroll = nil
                        if tree.IsNil(move) && wb.Styles.Abilities.IsHoverable() {
                                move = w
                        }
                case events.MouseDown:
                        em.scroll = nil
                        // in ScRenderBBoxes, everyone is effectively pressable
                        if tree.IsNil(press) && (wb.Styles.Abilities.IsPressable() || sc.renderBBoxes) {
                                press = w
                        }
                        if tree.IsNil(dragPress) && wb.AbilityIs(abilities.Draggable) {
                                dragPress = w
                        }
                        if tree.IsNil(slidePress) && wb.AbilityIs(abilities.Slideable) {
                                // On mobile, sliding results in scrolling, so we must have the appropriate
                                // scrolling attention to allow sliding.
                                if TheApp.SystemPlatform().IsMobile() && !wb.AbilityIs(abilities.ScrollableUnattended) && !(wb.StateIs(states.Focused) || wb.StateIs(states.Attended)) {
                                        continue
                                }
                                slidePress = w
                        }
                        if repeatClick == nil && wb.Styles.Abilities.Is(abilities.RepeatClickable) {
                                repeatClick = w
                        }
                case events.MouseUp:
                        em.scroll = nil
                        // in ScRenderBBoxes, everyone is effectively pressable
                        if tree.IsNil(up) && (wb.Styles.Abilities.IsPressable() || sc.renderBBoxes) {
                                up = w
                        }
                case events.Scroll:
                        if !wb.AbilityIs(abilities.ScrollableUnattended) && !(wb.StateIs(states.Focused) || wb.StateIs(states.Attended)) {
                                continue
                        }
                        if e.IsHandled() {
                                if tree.IsNil(em.scroll) {
                                        em.scroll = w
                                        em.lastScrollTime = time.Now()
                                }
                        }
                }
        }
        switch et {
        case events.MouseDown:
                if !tree.IsNil(press) {
                        em.press = press
                        em.setAttend(press)
                }
                if !tree.IsNil(dragPress) {
                        em.dragPress = dragPress
                }
                if !tree.IsNil(slidePress) {
                        em.slidePress = slidePress
                }
                if !tree.IsNil(repeatClick) {
                        em.repeatClick = repeatClick
                        em.startRepeatClickTimer()
                }
                em.handleLongPress(e)
        case events.MouseMove:
                hovs := make([]Widget, 0, len(em.mouseInBBox))
                for _, w := range em.mouseInBBox { // requires forward iter through em.MouseInBBox
                        wb := w.AsWidget()
                        // in ScRenderBBoxes, everyone is effectively hoverable
                        if wb.Styles.Abilities.IsHoverable() || sc.renderBBoxes {
                                hovs = append(hovs, w)
                        }
                }
                if !tree.IsNil(em.drag) { // this means we missed the drop
                        em.dragHovers = em.updateHovers(hovs, em.dragHovers, e, events.DragEnter, events.DragLeave)
                        em.dragDrop(em.drag, e)
                        break
                }
                if sc.renderBBoxes {
                        pselw := sc.selectedWidget
                        if len(em.hovers) > 0 {
                                sc.selectedWidget = em.hovers[len(em.hovers)-1]
                        } else {
                                sc.selectedWidget = nil
                        }
                        if sc.selectedWidget != pselw {
                                if !tree.IsNil(pselw) {
                                        pselw.AsWidget().NeedsRender()
                                }
                                if !tree.IsNil(sc.selectedWidget) {
                                        sc.selectedWidget.AsWidget().NeedsRender()
                                }
                        }
                }
                em.hovers = em.updateHovers(hovs, em.hovers, e, events.MouseEnter, events.MouseLeave)
                em.handleLongHover(e)
        case events.MouseDrag:
                if !tree.IsNil(em.drag) {
                        hovs := make([]Widget, 0, len(em.mouseInBBox))
                        for _, w := range em.mouseInBBox { // requires forward iter through em.MouseInBBox
                                wb := w.AsWidget()
                                if wb.AbilityIs(abilities.Droppable) {
                                        hovs = append(hovs, w)
                                }
                        }
                        em.dragHovers = em.updateHovers(hovs, em.dragHovers, e, events.DragEnter, events.DragLeave)
                        em.dragMove(e)                              // updates sprite position
                        em.drag.AsWidget().HandleEvent(e)           // raw drag
                        em.drag.AsWidget().Send(events.DragMove, e) // usually ignored
                        e.SetHandled()
                } else {
                        if !tree.IsNil(em.dragPress) && em.dragStartCheck(e, DeviceSettings.DragStartTime, DeviceSettings.DragStartDistance) {
                                em.cancelRepeatClick()
                                em.cancelLongPress()
                                em.dragPress.AsWidget().Send(events.DragStart, e)
                                e.SetHandled()
                        } else if !tree.IsNil(em.slidePress) && em.dragStartCheck(e, DeviceSettings.SlideStartTime, DeviceSettings.DragStartDistance) {
                                em.cancelRepeatClick()
                                em.cancelLongPress()
                                em.slide = em.slidePress
                                em.slide.AsWidget().Send(events.SlideStart, e)
                                e.SetHandled()
                        }
                }
                // if we already have a long press widget, we update it based on our dragging movement
                if !tree.IsNil(em.longPressWidget) {
                        em.handleLongPress(e)
                }
        case events.MouseUp:
                em.cancelRepeatClick()
                if !tree.IsNil(em.slide) {
                        em.slide.AsWidget().Send(events.SlideStop, e)
                        e.SetHandled()
                        em.slide = nil
                        em.press = nil
                }
                if !tree.IsNil(em.drag) {
                        em.dragDrop(em.drag, e)
                        em.press = nil
                }
                // if we have sent a long press start event, we don't send click
                // events (non-nil widget plus nil timer means we already sent)
                if em.press == up && !tree.IsNil(up) && !(!tree.IsNil(em.longPressWidget) && em.longPressTimer == nil) {
                        em.cancelLongPress()
                        switch e.MouseButton() {
                        case events.Left:
                                if sc.selectedWidgetChan != nil {
                                        sc.selectedWidgetChan <- up
                                        return
                                }
                                dcInTime := time.Since(em.lastClickTime) < DeviceSettings.DoubleClickInterval
                                em.lastClickTime = time.Now()
                                sentMulti := false
                                switch {
                                case em.lastDoubleClickWidget == up && dcInTime:
                                        tce := e.NewFromClone(events.TripleClick)
                                        for i := n - 1; i >= 0; i-- {
                                                w := em.mouseInBBox[i]
                                                wb := w.AsWidget()
                                                if !wb.StateIs(states.Disabled) && wb.AbilityIs(abilities.TripleClickable) {
                                                        sentMulti = true
                                                        w.AsWidget().HandleEvent(tce)
                                                        break
                                                }
                                        }
                                case em.lastClickWidget == up && dcInTime:
                                        dce := e.NewFromClone(events.DoubleClick)
                                        for i := n - 1; i >= 0; i-- {
                                                w := em.mouseInBBox[i]
                                                wb := w.AsWidget()
                                                if !wb.StateIs(states.Disabled) && wb.AbilityIs(abilities.DoubleClickable) {
                                                        em.lastDoubleClickWidget = up // not actually who gets the event
                                                        sentMulti = true
                                                        w.AsWidget().HandleEvent(dce)
                                                        break
                                                }
                                        }
                                }
                                if !sentMulti {
                                        em.lastDoubleClickWidget = nil
                                        em.lastClickWidget = up
                                        up.AsWidget().Send(events.Click, e)
                                }
                        case events.Right: // note: automatically gets Control+Left
                                up.AsWidget().Send(events.ContextMenu, e)
                        }
                }
                // if our original pressed widget is different from the one we are
                // going up on, then it has not gotten a mouse up event yet, so
                // we need to send it one
                if em.press != up && !tree.IsNil(em.press) {
                        em.press.AsWidget().HandleEvent(e)
                }
                em.press = nil

                em.cancelLongPress()
                // a mouse up event acts also acts as a mouse leave
                // event on mobile, as that is needed to clear any
                // hovered state
                if !tree.IsNil(up) && TheApp.Platform().IsMobile() {
                        up.AsWidget().Send(events.MouseLeave, e)
                }
        case events.Scroll:
                switch {
                case !tree.IsNil(em.slide):
                        em.slide.AsWidget().HandleEvent(e)
                case !tree.IsNil(em.drag):
                        em.drag.AsWidget().HandleEvent(e)
                case !tree.IsNil(em.press):
                        em.press.AsWidget().HandleEvent(e)
                default:
                        em.scene.HandleEvent(e)
                }
        }

        // we need to handle cursor after all of the events so that
        // we get the latest cursor if it changes based on the state

        cursorSet := false
        for i := n - 1; i >= 0; i-- {
                w := em.mouseInBBox[i]
                wb := w.AsWidget()
                if !cursorSet && wb.Styles.Cursor != cursors.None {
                        em.setCursor(wb.Styles.Cursor)
                        cursorSet = true
                }
        }
}

// updateHovers updates the hovered widgets based on current
// widgets in bounding box.
func (em *Events) updateHovers(hov, prev []Widget, e events.Event, enter, leave events.Types) []Widget {
        for _, prv := range prev {
                stillIn := false
                for _, cur := range hov {
                        if prv == cur {
                                stillIn = true
                                break
                        }
                }
                if !stillIn && !tree.IsNil(prv) {
                        prv.AsWidget().Send(leave, e)
                }
        }

        for _, cur := range hov {
                wasIn := false
                for _, prv := range prev {
                        if prv == cur {
                                wasIn = true
                                break
                        }
                }
                if !wasIn {
                        cur.AsWidget().Send(enter, e)
                }
        }
        // todo: detect change in top one, use to update cursor
        return hov
}

// topLongHover returns the top-most LongHoverable widget among the Hovers
func (em *Events) topLongHover() Widget {
        var deep Widget
        for i := len(em.hovers) - 1; i >= 0; i-- {
                h := em.hovers[i]
                if h.AsWidget().AbilityIs(abilities.LongHoverable) {
                        deep = h
                        break
                }
        }
        return deep
}

// handleLongHover handles long hover events
func (em *Events) handleLongHover(e events.Event) {
        em.handleLong(e, em.topLongHover(), &em.longHoverWidget, &em.longHoverPos, &em.longHoverTimer, events.LongHoverStart, events.LongHoverEnd, DeviceSettings.LongHoverTime, DeviceSettings.LongHoverStopDistance)
}

// handleLongPress handles long press events
func (em *Events) handleLongPress(e events.Event) {
        em.handleLong(e, em.press, &em.longPressWidget, &em.longPressPos, &em.longPressTimer, events.LongPressStart, events.LongPressEnd, DeviceSettings.LongPressTime, DeviceSettings.LongPressStopDistance)
}

// handleLong is the implementation of [Events.handleLongHover] and
// [EventManger.HandleLongPress]. It handles the logic to do with tracking
// long events using the given pointers to event manager fields and
// constant type, time, and distance properties. It should not need to
// be called by anything except for the aforementioned functions.
func (em *Events) handleLong(e events.Event, deep Widget, w *Widget, pos *image.Point, t **time.Timer, styp, etyp events.Types, stime time.Duration, sdist int) {
        em.timerMu.Lock()
        defer em.timerMu.Unlock()

        // fmt.Println("em:", em.Scene.Name)

        clearLong := func() {
                if *t != nil {
                        (*t).Stop() // TODO: do we need to close this?
                        *t = nil
                }
                *w = nil
                *pos = image.Point{}
                // fmt.Println("cleared hover")
        }

        cpos := e.WindowPos()
        dst := int(math32.Hypot(float32(pos.X-cpos.X), float32(pos.Y-cpos.Y)))
        // fmt.Println("dist:", dst)

        // we have no long hovers, so we must be done
        if tree.IsNil(deep) {
                // fmt.Println("no deep")
                if tree.IsNil(*w) {
                        // fmt.Println("no lhw")
                        return
                }
                // if we have already finished the timer, then we have already
                // sent the start event, so we have to send the end one
                if *t == nil {
                        (*w).AsWidget().Send(etyp, e)
                }
                clearLong()
                // fmt.Println("cleared")
                return
        }

        // we still have the current one, so there is nothing to do
        // but make sure our position hasn't changed too much
        if deep == *w {
                // if we haven't gone too far, we have nothing to do
                if dst <= sdist {
                        // fmt.Println("bail on dist:", dst)
                        return
                }
                // If we have gone too far, we are done with the long hover and
                // we must clear it. However, critically, we do not return, as
                // we must make a new tooltip immediately; otherwise, we may end
                // up not getting another mouse move event, so we will be on the
                // element with no tooltip, which is a bug. Not returning here is
                // the solution to https://github.com/cogentcore/core/issues/553
                (*w).AsWidget().Send(etyp, e)
                clearLong()
                // fmt.Println("fallthrough after clear")
        }

        // if we have changed and still have the timer, we never
        // sent a start event, so we just bail
        if *t != nil {
                clearLong()
                // fmt.Println("timer non-nil, cleared")
                return
        }

        // we now know we don't have the timer and thus sent the start
        // event already, so we need to send a end event
        if !tree.IsNil(*w) {
                (*w).AsWidget().Send(etyp, e)
                clearLong()
                // fmt.Println("lhw, send end, cleared")
                return
        }

        // now we can set it to our new widget
        *w = deep
        // fmt.Println("setting new:", deep)
        *pos = e.WindowPos()
        *t = time.AfterFunc(stime, func() {
                win := em.RenderWindow()
                if win == nil {
                        return
                }
                rc := win.renderContext() // have to get this one first
                rc.Lock()
                defer rc.Unlock()

                em.timerMu.Lock() // then can get this
                defer em.timerMu.Unlock()
                if tree.IsNil(*w) {
                        return
                }
                (*w).AsWidget().Send(styp, e)
                // we are done with the timer, and this indicates that
                // we have sent a start event
                *t = nil
        })
}

func (em *Events) getMouseInBBox(w Widget, pos image.Point) {
        wb := w.AsWidget()
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                // we do not handle disabled here so that
                // we correctly process cursors for disabled elements.
                // it needs to be handled downstream by anyone who needs it.
                if !cwb.IsVisible() {
                        return tree.Break
                }
                if !cwb.posInScBBox(pos) {
                        return tree.Break
                }
                em.mouseInBBox = append(em.mouseInBBox, cw)
                if cwb.Parts != nil {
                        em.getMouseInBBox(cwb.Parts, pos)
                }
                if ly := AsFrame(cw); ly != nil {
                        for d := math32.X; d <= math32.Y; d++ {
                                if ly.HasScroll[d] && ly.Scrolls[d] != nil {
                                        sb := ly.Scrolls[d]
                                        em.getMouseInBBox(sb, pos)
                                }
                        }
                }
                return tree.Continue
        })
}

func (em *Events) cancelLongPress() {
        // if we have sent a long press start event, we send an end
        // event (non-nil widget plus nil timer means we already sent)
        if !tree.IsNil(em.longPressWidget) && em.longPressTimer == nil {
                em.longPressWidget.AsWidget().Send(events.LongPressEnd)
        }
        em.longPressWidget = nil
        em.longPressPos = image.Point{}
        if em.longPressTimer != nil {
                em.longPressTimer.Stop()
                em.longPressTimer = nil
        }
}

func (em *Events) cancelRepeatClick() {
        em.repeatClick = nil
        if em.repeatClickTimer != nil {
                em.repeatClickTimer.Stop()
                em.repeatClickTimer = nil
        }
}

func (em *Events) startRepeatClickTimer() {
        if tree.IsNil(em.repeatClick) || !em.repeatClick.AsWidget().IsVisible() {
                return
        }
        delay := DeviceSettings.RepeatClickTime
        if em.repeatClickTimer == nil {
                delay *= 8
        }
        em.repeatClickTimer = time.AfterFunc(delay, func() {
                if tree.IsNil(em.repeatClick) || !em.repeatClick.AsWidget().IsVisible() {
                        return
                }
                em.repeatClick.AsWidget().Send(events.Click)
                em.startRepeatClickTimer()
        })
}

func (em *Events) dragStartCheck(e events.Event, dur time.Duration, dist int) bool {
        since := e.SinceStart()
        if since < dur {
                return false
        }
        dst := int(math32.FromPoint(e.StartDelta()).Length())
        return dst >= dist
}

// DragStart starts a drag event, capturing a sprite image of the given widget
// and storing the data for later use during Drop.
// A drag does not officially start until this is called.
func (em *Events) DragStart(w Widget, data any, e events.Event) {
        ms := em.scene.Stage.Main
        if ms == nil {
                return
        }
        em.drag = w
        em.dragData = data
        sp := NewSprite(dragSpriteName, image.Point{}, e.WindowPos())
        sp.grabRenderFrom(w) // TODO: maybe show the number of items being dragged
        sp.Pixels = clone.AsRGBA(gradient.ApplyOpacity(sp.Pixels, 0.5))
        sp.Active = true
        ms.Sprites.Add(sp)
}

// dragMove is generally handled entirely by the event manager
func (em *Events) dragMove(e events.Event) {
        ms := em.scene.Stage.Main
        if ms == nil {
                return
        }
        sp, ok := ms.Sprites.SpriteByName(dragSpriteName)
        if !ok {
                fmt.Println("Drag sprite not found")
                return
        }
        sp.Geom.Pos = e.WindowPos()
        for _, w := range em.dragHovers {
                w.AsWidget().ScrollToThis()
        }
        em.scene.NeedsRender()
}

func (em *Events) dragClearSprite() {
        ms := em.scene.Stage.Main
        if ms == nil {
                return
        }
        ms.Sprites.InactivateSprite(dragSpriteName)
}

// DragMenuAddModText adds info about key modifiers for a drag drop menu.
func (em *Events) DragMenuAddModText(m *Scene, mod events.DropMods) {
        text := ""
        switch mod {
        case events.DropCopy:
                text = "Copy (use Shift to move):"
        case events.DropMove:
                text = "Move:"
        }
        NewText(m).SetType(TextLabelLarge).SetText(text).Styler(func(s *styles.Style) {
                s.Margin.Set(units.Em(0.5))
        })
}

// dragDrop sends the [events.Drop] event to the top of the DragHovers stack.
// clearing the current dragging sprite before doing anything.
// It is up to the target to call
func (em *Events) dragDrop(drag Widget, e events.Event) {
        em.dragClearSprite()
        data := em.dragData
        em.drag = nil
        em.scene.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                cwb.dragStateReset()
                return tree.Continue
        })
        em.scene.Restyle()

        if len(em.dragHovers) == 0 {
                if DebugSettings.EventTrace {
                        fmt.Println(drag, "Drop has no target")
                }
                return
        }
        for _, dwi := range em.dragHovers {
                dwi.AsWidget().SetState(false, states.DragHovered)
        }
        targ := em.dragHovers[len(em.dragHovers)-1]
        de := events.NewDragDrop(events.Drop, e.(*events.Mouse)) // gets the actual mod at this point
        de.Data = data
        de.Source = drag
        de.Target = targ
        if DebugSettings.EventTrace {
                fmt.Println(targ, "Drop with mod:", de.DropMod, "source:", de.Source)
        }
        targ.AsWidget().HandleEvent(de)
}

// DropFinalize should be called as the last step in the Drop event processing,
// to send the DropDeleteSource event to the source in case of DropMod == DropMove.
// Otherwise, nothing actually happens.
func (em *Events) DropFinalize(de *events.DragDrop) {
        if de.DropMod != events.DropMove {
                return
        }
        de.Typ = events.DropDeleteSource
        de.ClearHandled()
        de.Source.(Widget).AsWidget().HandleEvent(de)
}

// Clipboard returns the [system.Clipboard], supplying the window context
// if available.
func (em *Events) Clipboard() system.Clipboard {
        var gwin system.Window
        if win := em.RenderWindow(); win != nil {
                gwin = win.SystemWindow
        }
        return system.TheApp.Clipboard(gwin)
}

// setCursor sets the window cursor to the given [cursors.Cursor].
func (em *Events) setCursor(cur cursors.Cursor) {
        win := em.RenderWindow()
        if win == nil {
                return
        }
        if !win.isVisible() {
                return
        }
        errors.Log(system.TheApp.Cursor(win.SystemWindow).Set(cur))
}

// focusClear saves current focus to FocusPrev
func (em *Events) focusClear() bool {
        if !tree.IsNil(em.focus) {
                if DebugSettings.FocusTrace {
                        fmt.Println(em.scene, "FocusClear:", em.focus)
                }
                em.prevFocus = em.focus
        }
        return em.setFocus(nil)
}

// setFocusQuiet sets focus to given item, and returns true if focus changed.
// If item is nil, then nothing has focus.
// This does NOT send the [events.Focus] event to the widget.
// See [Events.setFocus] for version that does send an event.
func (em *Events) setFocusQuiet(w Widget) bool {
        if DebugSettings.FocusTrace {
                fmt.Println(em.scene, "SetFocus:", w)
        }
        got := em.setFocusImpl(w, false) // no event
        if !got {
                if DebugSettings.FocusTrace {
                        fmt.Println(em.scene, "SetFocus: Failed", w)
                }
                return false
        }
        return got
}

// setFocus sets focus to given item, and returns true if focus changed.
// If item is nil, then nothing has focus.
// This sends the [events.Focus] event to the widget.
// See [Events.setFocusQuiet] for a version that does not.
func (em *Events) setFocus(w Widget) bool {
        if DebugSettings.FocusTrace {
                fmt.Println(em.scene, "SetFocusEvent:", w)
        }
        got := em.setFocusImpl(w, true) // sends event
        if !got {
                if DebugSettings.FocusTrace {
                        fmt.Println(em.scene, "SetFocusEvent: Failed", w)
                }
                return false
        }
        if !tree.IsNil(w) {
                w.AsWidget().ScrollToThis()
        }
        return got
}

// setFocusImpl sets focus to given item -- returns true if focus changed.
// If item is nil, then nothing has focus.
// sendEvent determines whether the events.Focus event is sent to the focused item.
func (em *Events) setFocusImpl(w Widget, sendEvent bool) bool {
        cfoc := em.focus
        if tree.IsNil(cfoc) {
                em.focus = nil
                cfoc = nil
        }
        if !tree.IsNil(cfoc) && !tree.IsNil(w) && cfoc == w {
                if DebugSettings.FocusTrace {
                        fmt.Println(em.scene, "Already Focus:", cfoc)
                }
                return false
        }
        if !tree.IsNil(cfoc) {
                if DebugSettings.FocusTrace {
                        fmt.Println(em.scene, "Losing focus:", cfoc)
                }
                cfoc.AsWidget().Send(events.FocusLost)
        }
        em.focus = w
        if sendEvent && !tree.IsNil(w) {
                w.AsWidget().Send(events.Focus)
        }
        return true
}

// focusNext sets the focus on the next item
// that can accept focus after the current Focus item.
// returns true if a focus item found.
func (em *Events) focusNext() bool {
        if tree.IsNil(em.focus) {
                return em.focusFirst()
        }
        return em.FocusNextFrom(em.focus)
}

// FocusNextFrom sets the focus on the next item
// that can accept focus after the given item.
// It returns true if a focus item is found.
func (em *Events) FocusNextFrom(from Widget) bool {
        next := widgetNextFunc(from, func(w Widget) bool {
                wb := w.AsWidget()
                return wb.IsDisplayable() && !wb.StateIs(states.Disabled) && wb.AbilityIs(abilities.Focusable)
        })
        em.setFocus(next)
        return !tree.IsNil(next)
}

// focusOnOrNext sets the focus on the given item, or the next one that can
// accept focus; returns true if a new focus item is found.
func (em *Events) focusOnOrNext(foc Widget) bool {
        cfoc := em.focus
        if cfoc == foc {
                return true
        }
        wb := AsWidget(foc)
        if !wb.IsDisplayable() {
                return false
        }
        if wb.AbilityIs(abilities.Focusable) {
                em.setFocus(foc)
                return true
        }
        return em.FocusNextFrom(foc)
}

// focusOnOrPrev sets the focus on the given item, or the previous one that can
// accept focus; returns true if a new focus item is found.
func (em *Events) focusOnOrPrev(foc Widget) bool {
        cfoc := em.focus
        if cfoc == foc {
                return true
        }
        wb := AsWidget(foc)
        if !wb.IsDisplayable() {
                return false
        }
        if wb.AbilityIs(abilities.Focusable) {
                em.setFocus(foc)
                return true
        }
        return em.focusPrevFrom(foc)
}

// focusPrev sets the focus on the previous item before the
// current focus item.
func (em *Events) focusPrev() bool {
        if tree.IsNil(em.focus) {
                return em.focusLast()
        }
        return em.focusPrevFrom(em.focus)
}

// focusPrevFrom sets the focus on the previous item before the given item
// (can be nil).
func (em *Events) focusPrevFrom(from Widget) bool {
        prev := widgetPrevFunc(from, func(w Widget) bool {
                wb := w.AsWidget()
                return wb.IsDisplayable() && !wb.StateIs(states.Disabled) && wb.AbilityIs(abilities.Focusable)
        })
        em.setFocus(prev)
        return !tree.IsNil(prev)
}

// focusFirst sets the focus on the first focusable item in the tree.
// returns true if a focusable item was found.
func (em *Events) focusFirst() bool {
        return em.FocusNextFrom(em.scene.This.(Widget))
}

// focusLast sets the focus on the last focusable item in the tree.
// returns true if a focusable item was found.
func (em *Events) focusLast() bool {
        return em.focusLastFrom(em.scene)
}

// focusLastFrom sets the focus on the last focusable item in the given tree.
// returns true if a focusable item was found.
func (em *Events) focusLastFrom(from Widget) bool {
        last := tree.Last(from).(Widget)
        return em.focusOnOrPrev(last)
}

// SetStartFocus sets the given item to be the first focus when the window opens.
func (em *Events) SetStartFocus(k Widget) {
        em.startFocus = k
}

// activateStartFocus activates start focus if there is no current focus
// and StartFocus is set -- returns true if activated
func (em *Events) activateStartFocus() bool {
        if tree.IsNil(em.startFocus) && !em.startFocusFirst {
                // fmt.Println("no start focus")
                return false
        }
        sf := em.startFocus
        em.startFocus = nil
        if tree.IsNil(sf) {
                em.focusFirst()
        } else {
                // fmt.Println("start focus on:", sf)
                em.setFocus(sf)
        }
        return true
}

// setAttend sets attended to given item, and returns true if attended changed.
// If item is nil, then nothing is attended.
// This sends the [events.Attend] event to the widget.
func (em *Events) setAttend(w Widget) bool {
        if DebugSettings.FocusTrace {
                fmt.Println(em.scene, "SetAttendEvent:", w)
        }
        got := em.setAttendImpl(w, true) // sends event
        if !got {
                if DebugSettings.FocusTrace {
                        fmt.Println(em.scene, "SetAttendEvent: Failed", w)
                }
                return false
        }
        return got
}

// setAttendImpl sets attended to given item, and returns true if attended changed.
// If item is nil, then nothing has attended.
// sendEvent determines whether the events.Attend event is sent to the focused item.
func (em *Events) setAttendImpl(w Widget, sendEvent bool) bool {
        catd := em.attended
        if tree.IsNil(catd) {
                em.attended = nil
                catd = nil
        }
        if catd != nil && !tree.IsNil(w) && catd == w {
                if DebugSettings.FocusTrace {
                        fmt.Println(em.scene, "Already Attend:", catd)
                }
                return false
        }
        if catd != nil {
                if DebugSettings.FocusTrace {
                        fmt.Println(em.scene, "Losing attend:", catd)
                }
                catd.AsWidget().Send(events.AttendLost)
        }
        em.attended = w
        if sendEvent && !tree.IsNil(w) {
                w.AsWidget().Send(events.Attend)
        }
        return true
}

// MangerKeyChordEvents handles lower-priority manager-level key events.
// Mainly tab, shift-tab, and Inspector and Settings.
// event will be marked as processed if handled here.
func (em *Events) managerKeyChordEvents(e events.Event) {
        if e.IsHandled() {
                return
        }
        if e.Type() != events.KeyChord {
                return
        }
        win := em.RenderWindow()
        if win == nil {
                return
        }
        sc := em.scene
        cs := e.KeyChord()
        kf := keymap.Of(cs)
        switch kf {
        case keymap.FocusNext: // tab
                if em.focusNext() {
                        e.SetHandled()
                }
        case keymap.FocusPrev: // shift-tab
                if em.focusPrev() {
                        e.SetHandled()
                }
        case keymap.WinSnapshot:
                img := sc.renderer.Image()
                dstr := time.Now().Format(time.DateOnly + "-" + "15-04-05")
                var sz string
                if img != nil {
                        sz = fmt.Sprint(img.Bounds().Size())
                        fnm := filepath.Join(TheApp.AppDataDir(), "screenshot-"+sc.Name+"-"+dstr+".png")
                        if errors.Log(imagex.Save(img, fnm)) == nil {
                                MessageSnackbar(sc, "Saved screenshot to: "+strings.ReplaceAll(fnm, " ", `\ `)+sz)
                        }
                } else {
                        MessageSnackbar(sc, "Save screenshot: no render image")
                }
                sc.RenderWidget()
                sv := paint.RenderToSVG(&sc.Painter)
                fnm := filepath.Join(TheApp.AppDataDir(), "screenshot-"+sc.Name+"-"+dstr+".svg")
                errors.Log(os.WriteFile(fnm, sv, 0666))
                MessageSnackbar(sc, "Saved SVG screenshot to: "+strings.ReplaceAll(fnm, " ", `\ `)+sz)
                e.SetHandled()
        case keymap.ZoomIn:
                win.stepZoom(1)
                e.SetHandled()
        case keymap.ZoomOut:
                win.stepZoom(-1)
                e.SetHandled()
        case keymap.Refresh:
                e.SetHandled()
                system.TheApp.GetScreens()
                UpdateAll()
                theWindowGeometrySaver.restoreAll()
        case keymap.WinFocusNext:
                e.SetHandled()
                AllRenderWindows.focusNext()
        }
        if !e.IsHandled() {
                em.triggerShortcut(cs)
        }
}

// getShortcutsIn gathers all [Button]s in the given parent widget with
// a shortcut specified. It recursively navigates [Button.Menu]s.
func (em *Events) getShortcutsIn(parent Widget) {
        parent.AsWidget().WidgetWalkDown(func(w Widget, wb *WidgetBase) bool {
                bt := AsButton(w)
                if bt == nil {
                        return tree.Continue
                }
                if bt.Shortcut != "" {
                        em.addShortcut(bt.Shortcut.PlatformChord(), bt)
                }
                if bt.HasMenu() {
                        tmps := NewScene()
                        bt.Menu(tmps)
                        em.getShortcutsIn(tmps)
                }
                return tree.Break // there are no buttons in buttons
        })
}

// shortcuts is a map between a key chord and a specific Button that can be
// triggered.  This mapping must be unique, in that each chord has unique
// Button, and generally each Button only has a single chord as well, though
// this is not strictly enforced.  shortcuts are evaluated *after* the
// standard KeyMap event processing, so any conflicts are resolved in favor of
// the local widget's key event processing, with the shortcut only operating
// when no conflicting widgets are in focus.  shortcuts are always window-wide
// and are intended for global window / toolbar buttons.  Widget-specific key
// functions should be handled directly within widget key event
// processing.
type shortcuts map[key.Chord]*Button

// addShortcut adds the given shortcut for the given button.
func (em *Events) addShortcut(chord key.Chord, bt *Button) {
        if chord == "" {
                return
        }
        if em.shortcuts == nil {
                em.shortcuts = shortcuts{}
        }
        chords := strings.Split(string(chord), "\n")
        for _, c := range chords {
                cc := key.Chord(c)
                if DebugSettings.KeyEventTrace {
                        old, exists := em.shortcuts[cc]
                        if exists && old != bt {
                                slog.Error("Events.AddShortcut: overwriting duplicate shortcut", "shortcut", cc, "originalButton", old, "newButton", bt)
                        }
                }
                em.shortcuts[cc] = bt
        }
}

// triggerShortcut attempts to trigger a shortcut, returning true if one was
// triggered, and false otherwise.  Also eliminates any shortcuts with deleted
// buttons, and does not trigger for Disabled buttons.
func (em *Events) triggerShortcut(chord key.Chord) bool {
        if DebugSettings.KeyEventTrace {
                fmt.Printf("Shortcut chord: %v -- looking for button\n", chord)
        }
        if em.shortcuts == nil {
                return false
        }
        sa, exists := em.shortcuts[chord]
        if !exists {
                return false
        }
        if tree.IsNil(sa) {
                delete(em.shortcuts, chord)
                return false
        }
        if sa.IsDisabled() {
                if DebugSettings.KeyEventTrace {
                        fmt.Printf("Shortcut chord: %v, button: %v -- is inactive, not fired\n", chord, sa.Text)
                }
                return false
        }

        if DebugSettings.KeyEventTrace {
                fmt.Printf("Shortcut chord: %v, button: %v triggered\n", chord, sa.Text)
        }
        sa.Send(events.Click)
        return true
}

func (em *Events) getSpriteInBBox(sc *Scene, pos image.Point) {
        st := sc.Stage
        for _, kv := range st.Sprites.Order {
                sp := kv.Value
                if !sp.Active {
                        continue
                }
                if sp.listeners == nil {
                        continue
                }
                r := sp.Geom.Bounds()
                if pos.In(r) {
                        em.spriteInBBox = append(em.spriteInBBox, sp)
                }
        }
}

// handleSpriteEvent handles the given event with sprites
// returns true if event was handled
func (em *Events) handleSpriteEvent(e events.Event) bool {
        et := e.Type()
loop:
        for _, sp := range em.spriteInBBox {
                if e.IsHandled() {
                        break
                }
                sp.listeners.Call(e) // everyone gets the primary event who is in scope, deepest first
                switch et {
                case events.MouseDown:
                        if sp.listeners.HandlesEventType(events.SlideMove) {
                                e.SetHandled()
                                em.spriteSlide = sp
                                em.spriteSlide.send(events.SlideStart, e)
                        }
                        if sp.listeners.HandlesEventType(events.Click) {
                                em.spritePress = sp
                        }
                        break loop
                case events.MouseUp:
                        sp.handleEvent(e)
                        if em.spriteSlide == sp {
                                sp.send(events.SlideStop, e)
                        }
                        if em.spritePress == sp {
                                sp.send(events.Click, e)
                        }
                }
        }
        return e.IsHandled()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "io/fs"
        "log"
        "log/slog"
        "os"
        "path/filepath"
        "reflect"
        "strings"

        "github.com/fsnotify/fsnotify"
        "github.com/mitchellh/go-homedir"

        "cogentcore.org/core/base/elide"
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/tree"
)

// todo:

// * search: use highlighting, not filtering -- < > arrows etc
// * also simple search-while typing in grid?
// * filepicker selector DND is a file:/// url

// FilePicker is a widget for selecting files.
type FilePicker struct {
        Frame

        // Filterer is an optional filtering function for which files to display.
        Filterer FilePickerFilterer `display:"-" json:"-" xml:"-"`

        // directory is the absolute path to the directory of files to display.
        directory string

        // selectedFilename is the name of the currently selected file,
        // not including the directory. See [FilePicker.SelectedFile]
        // for the full path.
        selectedFilename string

        // extensions is a list of the target file extensions.
        // If there are multiple, they must be comma separated.
        // The extensions must include the dot (".") at the start.
        // They must be set using [FilePicker.SetExtensions].
        extensions string

        // extensionMap is a map of lower-cased extensions from Extensions.
        // It used for highlighting files with one of these extensions;
        // maps onto original Extensions value.
        extensionMap map[string]string

        // files for current directory
        files []*fileinfo.FileInfo

        // index of currently selected file in Files list (-1 if none)
        selectedIndex int

        // change notify for current dir
        watcher *fsnotify.Watcher

        // channel to close watcher watcher
        doneWatcher chan bool

        // Previous path that was processed via UpdateFiles
        prevPath string

        favoritesTable, filesTable  *Table
        selectField, extensionField *TextField
}

func (fp *FilePicker) Init() {
        fp.Frame.Init()
        fp.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
                s.Grow.Set(1, 1)
        })

        fp.OnKeyChord(func(e events.Event) {
                kf := keymap.Of(e.KeyChord())
                if DebugSettings.KeyEventTrace {
                        slog.Info("FilePicker KeyInput", "widget", fp, "keyFunction", kf)
                }
                switch kf {
                case keymap.Jump, keymap.WordLeft:
                        e.SetHandled()
                        fp.directoryUp()
                case keymap.Insert, keymap.InsertAfter, keymap.Open, keymap.SelectMode:
                        e.SetHandled()
                        if fp.selectFile() {
                                fp.Send(events.DoubleClick, e) // will close dialog
                        }
                case keymap.Search:
                        e.SetHandled()
                        sf := fp.selectField
                        sf.SetFocus()
                }
        })

        fp.Maker(func(p *tree.Plan) {
                if fp.directory == "" {
                        fp.SetFilename("") // default to current directory
                }
                if len(recentPaths) == 0 {
                        openRecentPaths()
                }
                recentPaths.AddPath(fp.directory, SystemSettings.SavedPathsMax)
                saveRecentPaths()
                fp.readFiles()

                if fp.prevPath != fp.directory {
                        // TODO(#424): disable for all platforms for now; causing issues
                        if false && TheApp.Platform() != system.MacOS {
                                // mac is not supported in a high-capacity fashion at this point
                                if fp.prevPath == "" {
                                        fp.configWatcher()
                                } else {
                                        fp.watcher.Remove(fp.prevPath)
                                }
                                fp.watcher.Add(fp.directory)
                                if fp.prevPath == "" {
                                        fp.watchWatcher()
                                }
                        }
                        fp.prevPath = fp.directory
                }

                tree.AddAt(p, "path", func(w *Chooser) {
                        Bind(&fp.directory, w)
                        w.SetEditable(true).SetDefaultNew(true)
                        w.AddItemsFunc(func() {
                                fp.addRecentPathItems(&w.Items)
                        })
                        w.Styler(func(s *styles.Style) {
                                s.Grow.Set(1, 0)
                        })
                        w.OnChange(func(e events.Event) {
                                fp.updateFilesEvent()
                        })
                })
                tree.AddAt(p, "files", func(w *Frame) {
                        w.Styler(func(s *styles.Style) {
                                s.Grow.Set(1, 1)
                        })
                        w.Maker(fp.makeFilesRow)
                })
                tree.AddAt(p, "selected", func(w *Frame) {
                        w.Styler(func(s *styles.Style) {
                                s.Grow.Set(1, 0)
                                s.Gap.X.Dp(4)
                        })
                        w.Maker(fp.makeSelectedRow)
                })
        })
}

func (fp *FilePicker) Destroy() {
        fp.Frame.Destroy()
        if fp.watcher != nil {
                fp.watcher.Close()
                fp.watcher = nil
        }
        if fp.doneWatcher != nil {
                fp.doneWatcher <- true
                close(fp.doneWatcher)
                fp.doneWatcher = nil
        }
}

// FilePickerFilterer is a filtering function for files; returns true if the
// file should be visible in the picker, and false if not
type FilePickerFilterer func(fp *FilePicker, fi *fileinfo.FileInfo) bool

// FilePickerDirOnlyFilter is a [FilePickerFilterer] that only shows directories (folders).
func FilePickerDirOnlyFilter(fp *FilePicker, fi *fileinfo.FileInfo) bool {
        return fi.IsDir()
}

// FilePickerExtensionOnlyFilter is a [FilePickerFilterer] that only shows files that
// match the target extensions, and directories.
func FilePickerExtensionOnlyFilter(fp *FilePicker, fi *fileinfo.FileInfo) bool {
        if fi.IsDir() {
                return true
        }
        ext := strings.ToLower(filepath.Ext(fi.Name))
        _, has := fp.extensionMap[ext]
        return has
}

// SetFilename sets the directory and filename of the file picker
// from the given filepath.
func (fp *FilePicker) SetFilename(filename string) *FilePicker {
        fp.directory, fp.selectedFilename = filepath.Split(filename)
        fp.directory = errors.Log1(filepath.Abs(fp.directory))
        return fp
}

// SelectedFile returns the full path to the currently selected file.
func (fp *FilePicker) SelectedFile() string {
        sf := fp.selectField
        sf.editDone()
        return filepath.Join(fp.directory, fp.selectedFilename)
}

// SelectedFileInfo returns the currently selected [fileinfo.FileInfo] or nil.
func (fp *FilePicker) SelectedFileInfo() *fileinfo.FileInfo {
        if fp.selectedIndex < 0 || fp.selectedIndex >= len(fp.files) {
                return nil
        }
        return fp.files[fp.selectedIndex]
}

// selectFile selects the current file as the selection.
// if a directory it opens the directory and returns false.
// if a file it selects the file and returns true.
// if no selection, returns false.
func (fp *FilePicker) selectFile() bool {
        if fi := fp.SelectedFileInfo(); fi != nil {
                if fi.IsDir() {
                        fp.directory = filepath.Join(fp.directory, fi.Name)
                        fp.selectedFilename = ""
                        fp.selectedIndex = -1
                        fp.updateFilesEvent()
                        return false
                }
                return true
        }
        return false
}

func (fp *FilePicker) MakeToolbar(p *tree.Plan) {
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(fp.directoryUp).SetIcon(icons.ArrowUpward).SetKey(keymap.Jump).SetText("Up")
        })
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(fp.addPathToFavorites).SetIcon(icons.Favorite).SetText("Favorite")
        })
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(fp.updateFilesEvent).SetIcon(icons.Refresh).SetText("Update")
        })
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(fp.newFolder).SetIcon(icons.CreateNewFolder)
        })
}

func (fp *FilePicker) addRecentPathItems(items *[]ChooserItem) {
        for _, sp := range recentPaths {
                *items = append(*items, ChooserItem{
                        Value: sp,
                })
        }
        // TODO: file picker reset and edit recent paths buttons not working
        // *items = append(*items, ChooserItem{
        //         Value:           "Reset recent paths",
        //         Icon:            icons.Refresh,
        //         SeparatorBefore: true,
        //         Func: func() {
        //                 recentPaths = make(FilePaths, 1, SystemSettings.SavedPathsMax)
        //                 recentPaths[0] = fp.directory
        //                 fp.Update()
        //         },
        // })
        // *items = append(*items, ChooserItem{
        //         Value: "Edit recent paths",
        //         Icon:  icons.Edit,
        //         Func: func() {
        //                 fp.editRecentPaths()
        //         },
        // })
}

func (fp *FilePicker) makeFilesRow(p *tree.Plan) {
        tree.AddAt(p, "favorites", func(w *Table) {
                fp.favoritesTable = w
                w.SelectedIndex = -1
                w.SetReadOnly(true)
                w.ReadOnlyKeyNav = false // keys must go to files, not favorites
                w.Styler(func(s *styles.Style) {
                        s.Grow.Set(0, 1)
                        s.Min.X.Ch(25)
                        s.Overflow.X = styles.OverflowHidden
                })
                w.SetSlice(&SystemSettings.FavPaths)
                w.OnSelect(func(e events.Event) {
                        fp.favoritesSelect(w.SelectedIndex)
                })
                w.Updater(func() {
                        w.ResetSelectedIndexes()
                })
        })
        tree.AddAt(p, "files", func(w *Table) {
                fp.filesTable = w
                w.SetReadOnly(true)
                w.SetSlice(&fp.files)
                w.SelectedField = "Name"
                w.SelectedValue = fp.selectedFilename
                if SystemSettings.FilePickerSort != "" {
                        w.setSortFieldName(SystemSettings.FilePickerSort)
                }
                w.TableStyler = func(w Widget, s *styles.Style, row, col int) {
                        fn := fp.files[row].Name
                        ext := strings.ToLower(filepath.Ext(fn))
                        if _, has := fp.extensionMap[ext]; has {
                                s.Color = colors.Scheme.Primary.Base
                        } else {
                                s.Color = colors.Scheme.OnSurface
                        }
                }
                w.Styler(func(s *styles.Style) {
                        s.Cursor = cursors.Pointer
                })
                w.OnSelect(func(e events.Event) {
                        fp.fileSelect(w.SelectedIndex)
                })
                w.OnDoubleClick(func(e events.Event) {
                        if w.clickSelectEvent(e) {
                                if !fp.selectFile() {
                                        e.SetHandled() // don't pass along; keep dialog open
                                } else {
                                        fp.Scene.sendKey(keymap.Accept, e) // activates Ok button code
                                }
                        }
                })
                w.ContextMenus = nil
                w.AddContextMenu(func(m *Scene) {
                        open := NewButton(m).SetText("Open").SetIcon(icons.Open)
                        open.SetTooltip("Open the selected file using the default app")
                        open.OnClick(func(e events.Event) {
                                TheApp.OpenURL("file://" + fp.SelectedFile())
                        })
                        if TheApp.Platform() == system.Web {
                                open.SetText("Download").SetIcon(icons.Download).SetTooltip("Download this file to your device")
                        }
                        NewSeparator(m)
                        NewButton(m).SetText("Duplicate").SetIcon(icons.FileCopy).
                                SetTooltip("Make a copy of the selected file").
                                OnClick(func(e events.Event) {
                                        fn := fp.files[w.SelectedIndex]
                                        fn.Duplicate()
                                        fp.updateFilesEvent()
                                })
                        tip := "Delete moves the selected file to the trash / recycling bin"
                        if TheApp.Platform().IsMobile() {
                                tip = "Delete deletes the selected file"
                        }
                        NewButton(m).SetText("Delete").SetIcon(icons.Delete).
                                SetTooltip(tip).
                                OnClick(func(e events.Event) {
                                        fn := fp.files[w.SelectedIndex]
                                        fb := NewSoloFuncButton(w).SetFunc(fn.Delete).SetConfirm(true).SetAfterFunc(fp.updateFilesEvent)
                                        fb.SetTooltip(tip)
                                        fb.CallFunc()
                                })
                        NewButton(m).SetText("Rename").SetIcon(icons.EditNote).
                                SetTooltip("Rename the selected file").
                                OnClick(func(e events.Event) {
                                        fn := fp.files[w.SelectedIndex]
                                        NewSoloFuncButton(w).SetFunc(fn.Rename).SetAfterFunc(fp.updateFilesEvent).CallFunc()
                                })
                        NewButton(m).SetText("Info").SetIcon(icons.Info).
                                SetTooltip("View information about the selected file").
                                OnClick(func(e events.Event) {
                                        fn := fp.files[w.SelectedIndex]
                                        d := NewBody("Info: " + fn.Name)
                                        NewForm(d).SetStruct(&fn).SetReadOnly(true)
                                        d.AddOKOnly().RunWindowDialog(w)
                                })
                        NewSeparator(m)
                        NewFuncButton(m).SetFunc(fp.newFolder).SetIcon(icons.CreateNewFolder)
                })
                // w.Updater(func() {})
        })
}

func (fp *FilePicker) makeSelectedRow(selected *tree.Plan) {
        tree.AddAt(selected, "file-text", func(w *Text) {
                w.SetText("File: ")
                w.SetTooltip("Enter file name here (or select from list above)")
                w.Styler(func(s *styles.Style) {
                        s.SetTextWrap(false)
                })
        })

        tree.AddAt(selected, "file", func(w *TextField) {
                fp.selectField = w
                w.SetText(fp.selectedFilename)
                w.SetTooltip(fmt.Sprintf("Enter the file name. Special keys: up/down to move selection; %s or %s to go up to parent folder; %s or %s or %s or %s to select current file (if directory, goes into it, if file, selects and closes); %s or %s for prev / next history item; %s return to this field", keymap.WordLeft.Label(), keymap.Jump.Label(), keymap.SelectMode.Label(), keymap.Insert.Label(), keymap.InsertAfter.Label(), keymap.Open.Label(), keymap.HistPrev.Label(), keymap.HistNext.Label(), keymap.Search.Label()))
                w.SetCompleter(fp, fp.fileComplete, fp.fileCompleteEdit)
                w.Styler(func(s *styles.Style) {
                        s.Min.X.Ch(60)
                        s.Max.X.Zero()
                        s.Grow.Set(1, 0)
                })
                w.OnChange(func(e events.Event) {
                        fp.setSelectedFile(w.Text())
                })
                w.OnKeyChord(func(e events.Event) {
                        kf := keymap.Of(e.KeyChord())
                        if kf == keymap.Accept {
                                fp.setSelectedFile(w.Text())
                        }
                })
                w.StartFocus()
                w.Updater(func() {
                        w.SetText(fp.selectedFilename)
                })
        })

        tree.AddAt(selected, "extension-text", func(w *Text) {
                w.SetText("Extension(s):").SetTooltip("target extension(s) to highlight; if multiple, separate with commas, and include the . at the start")
                w.Styler(func(s *styles.Style) {
                        s.SetTextWrap(false)
                })
        })

        tree.AddAt(selected, "extension", func(w *TextField) {
                fp.extensionField = w
                w.SetText(fp.extensions)
                w.OnChange(func(e events.Event) {
                        fp.SetExtensions(w.Text()).Update()
                })
        })
}

func (fp *FilePicker) configWatcher() error {
        if fp.watcher != nil {
                return nil
        }
        var err error
        fp.watcher, err = fsnotify.NewWatcher()
        return err
}

func (fp *FilePicker) watchWatcher() {
        if fp.watcher == nil || fp.watcher.Events == nil {
                return
        }
        if fp.doneWatcher != nil {
                return
        }
        fp.doneWatcher = make(chan bool)
        go func() {
                watch := fp.watcher
                done := fp.doneWatcher
                for {
                        select {
                        case <-done:
                                return
                        case event := <-watch.Events:
                                switch {
                                case event.Op&fsnotify.Create == fsnotify.Create ||
                                        event.Op&fsnotify.Remove == fsnotify.Remove ||
                                        event.Op&fsnotify.Rename == fsnotify.Rename:
                                        fp.Update()
                                }
                        case err := <-watch.Errors:
                                _ = err
                        }
                }
        }()
}

// updateFilesEvent updates the list of files and other views for the current path.
func (fp *FilePicker) updateFilesEvent() { //types:add
        fp.readFiles()
        fp.Update()
        // sf := fv.SelectField()
        // sf.SetFocusEvent()
}

func (fp *FilePicker) readFiles() {
        effpath, err := filepath.EvalSymlinks(fp.directory)
        if err != nil {
                log.Printf("FilePicker Path: %v could not be opened -- error: %v\n", effpath, err)
                return
        }
        _, err = os.Lstat(effpath)
        if err != nil {
                log.Printf("FilePicker Path: %v could not be opened -- error: %v\n", effpath, err)
                return
        }

        fp.files = make([]*fileinfo.FileInfo, 0, 1000)
        filepath.Walk(effpath, func(path string, info fs.FileInfo, err error) error {
                if err != nil {
                        emsg := fmt.Sprintf("Path %q: Error: %v", effpath, err)
                        // if fv.Scene != nil {
                        //         PromptDialog(fv, DlgOpts{Title: "FilePicker UpdateFiles", emsg, Ok: true, Cancel: false}, nil)
                        // } else {
                        log.Printf("FilePicker error: %v\n", emsg)
                        // }
                        return nil // ignore
                }
                if path == effpath { // proceed..
                        return nil
                }
                fi, ferr := fileinfo.NewFileInfo(path)
                keep := ferr == nil
                if fp.Filterer != nil {
                        keep = fp.Filterer(fp, fi)
                }
                if keep {
                        fp.files = append(fp.files, fi)
                }
                if info.IsDir() {
                        return filepath.SkipDir
                }
                return nil
        })
}

// updateFavorites updates list of files and other views for current path
func (fp *FilePicker) updateFavorites() {
        sv := fp.favoritesTable
        sv.Update()
}

// addPathToFavorites adds the current path to favorites
func (fp *FilePicker) addPathToFavorites() { //types:add
        dp := fp.directory
        if dp == "" {
                return
        }
        _, fnm := filepath.Split(dp)
        hd, _ := homedir.Dir()
        hd += string(filepath.Separator)
        if strings.HasPrefix(dp, hd) {
                dp = filepath.Join("~", strings.TrimPrefix(dp, hd))
        }
        if fnm == "" {
                fnm = dp
        }
        if _, found := SystemSettings.FavPaths.findPath(dp); found {
                MessageSnackbar(fp, "Error: path is already on the favorites list")
                return
        }
        fi := favoritePathItem{"folder", fnm, dp}
        SystemSettings.FavPaths = append(SystemSettings.FavPaths, fi)
        ErrorSnackbar(fp, SaveSettings(SystemSettings), "Error saving settings")
        // fv.FileSig.Emit(fv.This, int64(FilePickerFavAdded), fi)
        fp.updateFavorites()
}

// directoryUp moves up one directory in the path
func (fp *FilePicker) directoryUp() { //types:add
        pdr := filepath.Dir(fp.directory)
        if pdr == "" {
                return
        }
        fp.directory = pdr
        fp.updateFilesEvent()
}

// newFolder creates a new folder with the given name in the current directory.
func (fp *FilePicker) newFolder(name string) error { //types:add
        dp := fp.directory
        if dp == "" {
                return nil
        }
        np := filepath.Join(dp, name)
        err := os.MkdirAll(np, 0775)
        if err != nil {
                return err
        }
        fp.updateFilesEvent()
        return nil
}

// setSelectedFile sets the currently selected file to the given name, sends
// a selection event, and updates the selection in the table.
func (fp *FilePicker) setSelectedFile(file string) {
        fp.selectedFilename = file
        sv := fp.filesTable
        ef := fp.extensionField
        exts := ef.Text()
        if !sv.selectFieldValue("Name", fp.selectedFilename) { // not found
                extl := strings.Split(exts, ",")
                if len(extl) == 1 {
                        if !strings.HasSuffix(fp.selectedFilename, extl[0]) {
                                fp.selectedFilename += extl[0]
                        }
                }
        }
        fp.selectedIndex = sv.SelectedIndex
        sf := fp.selectField
        sf.SetText(fp.selectedFilename) // make sure
        fp.Send(events.Select)          // receiver needs to get selectedFile
}

// fileSelect updates the selection with the given selected file index and
// sends a select event.
func (fp *FilePicker) fileSelect(idx int) {
        if idx < 0 {
                return
        }
        fp.saveSortSettings()
        fi := fp.files[idx]
        fp.selectedIndex = idx
        fp.selectedFilename = fi.Name
        sf := fp.selectField
        sf.SetText(fp.selectedFilename)
        fp.Send(events.Select)
}

// SetExtensions sets the [FilePicker.Extensions] to the given comma separated
// list of file extensions, which each must start with a dot (".").
func (fp *FilePicker) SetExtensions(ext string) *FilePicker {
        if ext == "" {
                if fp.selectedFilename != "" {
                        ext = strings.ToLower(filepath.Ext(fp.selectedFilename))
                }
        }
        fp.extensions = ext
        exts := strings.Split(fp.extensions, ",")
        fp.extensionMap = make(map[string]string, len(exts))
        for _, ex := range exts {
                ex = strings.TrimSpace(ex)
                if len(ex) == 0 {
                        continue
                }
                if ex[0] != '.' {
                        ex = "." + ex
                }
                fp.extensionMap[strings.ToLower(ex)] = ex
        }
        return fp
}

// favoritesSelect selects a favorite path and goes there
func (fp *FilePicker) favoritesSelect(idx int) {
        if idx < 0 || idx >= len(SystemSettings.FavPaths) {
                return
        }
        fi := SystemSettings.FavPaths[idx]
        fp.directory, _ = homedir.Expand(fi.Path)
        fp.updateFilesEvent()
}

// saveSortSettings saves current sorting preferences
func (fp *FilePicker) saveSortSettings() {
        sv := fp.filesTable
        if sv == nil {
                return
        }
        SystemSettings.FilePickerSort = sv.sortFieldName()
        // fmt.Printf("sort: %v\n", Settings.FilePickerSort)
        ErrorSnackbar(fp, SaveSettings(SystemSettings), "Error saving settings")
}

// fileComplete finds the possible completions for the file field
func (fp *FilePicker) fileComplete(data any, text string, posLine, posChar int) (md complete.Matches) {
        md.Seed = complete.SeedPath(text)

        var files = []string{}
        for _, f := range fp.files {
                files = append(files, f.Name)
        }

        if len(md.Seed) > 0 { // return all directories
                files = complete.MatchSeedString(files, md.Seed)
        }

        for _, d := range files {
                m := complete.Completion{Text: d}
                md.Matches = append(md.Matches, m)
        }
        return md
}

// fileCompleteEdit is the editing function called when inserting the completion selection in the file field
func (fp *FilePicker) fileCompleteEdit(data any, text string, cursorPos int, c complete.Completion, seed string) (ed complete.Edit) {
        ed = complete.EditWord(text, cursorPos, c.Text, seed)
        return ed
}

// editRecentPaths displays a dialog allowing the user to
// edit the recent paths list.
func (fp *FilePicker) editRecentPaths() {
        d := NewBody("Recent file paths")
        NewText(d).SetType(TextSupporting).SetText("You can delete paths you no longer use")
        NewList(d).SetSlice(&recentPaths)
        d.AddBottomBar(func(bar *Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).OnClick(func(e events.Event) {
                        saveRecentPaths()
                        fp.Update()
                })
        })
        d.RunDialog(fp)
}

// Filename is used to specify an file path.
// It results in a [FileButton] [Value].
type Filename = fsx.Filename

// FileButton represents a [Filename] value with a button
// that opens a [FilePicker].
type FileButton struct {
        Button
        Filename string

        // Extensions are the target file extensions for the file picker.
        Extensions string
}

func (fb *FileButton) WidgetValue() any { return &fb.Filename }

func (fb *FileButton) OnBind(value any, tags reflect.StructTag) {
        if ext, ok := tags.Lookup("extension"); ok {
                fb.SetExtensions(ext)
        }
}

func (fb *FileButton) Init() {
        fb.Button.Init()
        fb.SetType(ButtonTonal).SetIcon(icons.File)
        fb.Updater(func() {
                if fb.Filename == "" {
                        fb.SetText("Select file")
                } else {
                        fb.SetText(elide.Middle(fb.Filename, 38))
                }
        })
        var fp *FilePicker
        InitValueButton(fb, false, func(d *Body) {
                d.Title = "Select file"
                d.DeleteChildByName("body-title") // file picker has its own title
                fp = NewFilePicker(d).SetFilename(fb.Filename).SetExtensions(fb.Extensions)
                fb.setFlag(true, widgetValueNewWindow)
                d.AddTopBar(func(bar *Frame) {
                        NewToolbar(bar).Maker(fp.MakeToolbar)
                })
        }, func() {
                fb.Filename = fp.SelectedFile()
        })
}

func (fb *FileButton) WidgetTooltip(pos image.Point) (string, image.Point) {
        if fb.Filename == "" {
                return fb.Tooltip, fb.DefaultTooltipPos()
        }
        fnm := "(" + fb.Filename + ")"
        if fb.Tooltip == "" {
                return fnm, fb.DefaultTooltipPos()
        }
        return fnm + " " + fb.Tooltip, fb.DefaultTooltipPos()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/enums"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/tree"
)

// StateIs returns whether the widget has the given [states.States] flag set.
func (wb *WidgetBase) StateIs(state states.States) bool {
        return wb.Styles.State.HasFlag(state)
}

// AbilityIs returns whether the widget has the given [abilities.Abilities] flag set.
func (wb *WidgetBase) AbilityIs(able abilities.Abilities) bool {
        return wb.Styles.Abilities.HasFlag(able)
}

// SetState sets the given [states.State] flags to the given value.
func (wb *WidgetBase) SetState(on bool, state ...states.States) *WidgetBase {
        bfs := make([]enums.BitFlag, len(state))
        for i, st := range state {
                bfs[i] = st
        }
        wb.Styles.State.SetFlag(on, bfs...)
        return wb
}

// SetSelected sets the [states.Selected] flag to given value for the entire Widget
// and calls [WidgetBase.Restyle] to apply any resultant style changes.
func (wb *WidgetBase) SetSelected(sel bool) *WidgetBase {
        wb.SetState(sel, states.Selected)
        wb.Restyle()
        return wb
}

// CanFocus returns whether this node can receive keyboard focus.
func (wb *WidgetBase) CanFocus() bool {
        return wb.Styles.Abilities.HasFlag(abilities.Focusable)
}

// SetEnabled sets the [states.Disabled] flag to the opposite of the given value.
func (wb *WidgetBase) SetEnabled(enabled bool) *WidgetBase {
        return wb.SetState(!enabled, states.Disabled)
}

// IsDisabled returns whether this node is flagged as [states.Disabled].
// If so, behave and style appropriately.
func (wb *WidgetBase) IsDisabled() bool {
        return wb.StateIs(states.Disabled)
}

// IsReadOnly returns whether this widget is flagged as either [states.ReadOnly] or [states.Disabled].
func (wb *WidgetBase) IsReadOnly() bool {
        return wb.Styles.IsReadOnly()
}

// SetReadOnly sets the [states.ReadOnly] flag to the given value.
func (wb *WidgetBase) SetReadOnly(ro bool) *WidgetBase {
        return wb.SetState(ro, states.ReadOnly)
}

// HasStateWithin returns whether this widget or any
// of its children have the given state flag.
func (wb *WidgetBase) HasStateWithin(state states.States) bool {
        got := false
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                if cwb.StateIs(state) {
                        got = true
                        return tree.Break
                }
                return tree.Continue
        })
        return got
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "reflect"
        "slices"
        "strings"

        "cogentcore.org/core/base/keylist"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

// Form represents a struct with rows of field names and editable values.
type Form struct {
        Frame

        // Struct is the pointer to the struct that we are viewing.
        Struct any

        // Inline is whether to display the form in one line.
        Inline bool

        // Modified optionally highlights and tracks fields that have been modified
        // through an OnChange event. If present, it replaces the default value highlighting
        // and resetting logic. Ignored if nil.
        Modified map[string]bool

        // structFields are the fields of the current struct, keys are field paths.
        structFields keylist.List[string, *structField]

        // isShouldDisplayer is whether the struct implements [ShouldDisplayer], which results
        // in additional updating being done at certain points.
        isShouldDisplayer bool
}

// structField represents the values of one struct field being viewed.
type structField struct {
        path          string
        field         reflect.StructField
        value, parent reflect.Value
}

// NoSentenceCaseFor indicates to not transform field names in
// [Form]s into "Sentence case" for types whose full,
// package-path-qualified name contains any of these strings.
// For example, this can be used to disable sentence casing
// for types with scientific abbreviations in field names,
// which are more readable when not sentence cased. However,
// this should not be needed in most circumstances.
var NoSentenceCaseFor []string

// noSentenceCaseForType returns whether the given fully
// package-path-qualified name contains anything in the
// [NoSentenceCaseFor] list.
func noSentenceCaseForType(tnm string) bool {
        return slices.ContainsFunc(NoSentenceCaseFor, func(s string) bool {
                return strings.Contains(tnm, s)
        })
}

// ShouldDisplayer is an interface that determines whether a named field
// should be displayed in [Form].
type ShouldDisplayer interface {

        // ShouldDisplay returns whether the given named field should be displayed.
        ShouldDisplay(field string) bool
}

func (fm *Form) WidgetValue() any { return &fm.Struct }

func (fm *Form) getStructFields() {
        var fields keylist.List[string, *structField]

        shouldShow := func(parent reflect.Value, field reflect.StructField) bool {
                if field.Tag.Get("display") == "-" {
                        return false
                }
                if ss, ok := reflectx.UnderlyingPointer(parent).Interface().(ShouldDisplayer); ok {
                        fm.isShouldDisplayer = true
                        if !ss.ShouldDisplay(field.Name) {
                                return false
                        }
                }
                return true
        }

        reflectx.WalkFields(reflectx.Underlying(reflect.ValueOf(fm.Struct)),
                func(parent reflect.Value, field reflect.StructField, value reflect.Value) bool {
                        return shouldShow(parent, field)
                },
                func(parent reflect.Value, parentField *reflect.StructField, field reflect.StructField, value reflect.Value) {
                        if field.Tag.Get("display") == "add-fields" && field.Type.Kind() == reflect.Struct {
                                reflectx.WalkFields(value,
                                        func(parent reflect.Value, sfield reflect.StructField, value reflect.Value) bool {
                                                return shouldShow(parent, sfield)
                                        },
                                        func(parent reflect.Value, parentField *reflect.StructField, sfield reflect.StructField, value reflect.Value) {
                                                // if our parent field is read only, we must also be
                                                if field.Tag.Get("edit") == "-" && sfield.Tag.Get("edit") == "" {
                                                        sfield.Tag += ` edit:"-"`
                                                }
                                                path := field.Name + " • " + sfield.Name
                                                fields.Add(path, &structField{path: path, field: sfield, value: value, parent: parent})
                                        })
                        } else {
                                fields.Add(field.Name, &structField{path: field.Name, field: field, value: value, parent: parent})
                        }
                })
        fm.structFields = fields
}

func (fm *Form) Init() {
        fm.Frame.Init()
        fm.Styler(func(s *styles.Style) {
                s.Align.Items = styles.Center
                if fm.Inline {
                        return
                }
                s.Display = styles.Grid
                if fm.SizeClass() == SizeCompact {
                        s.Columns = 1
                } else {
                        s.Columns = 2
                }
        })

        fm.Maker(func(p *tree.Plan) {
                if reflectx.IsNil(reflect.ValueOf(fm.Struct)) {
                        return
                }

                fm.getStructFields()

                sc := true
                if len(NoSentenceCaseFor) > 0 {
                        sc = !noSentenceCaseForType(types.TypeNameValue(fm.Struct))
                }

                for i := range fm.structFields.Len() {
                        f := fm.structFields.Values[i]
                        fieldPath := fm.structFields.Keys[i]
                        label := f.path
                        if sc {
                                label = strcase.ToSentence(label)
                        }
                        if lt, ok := f.field.Tag.Lookup("label"); ok {
                                label = lt
                        }
                        labnm := fmt.Sprintf("label-%s", fieldPath)
                        // we must have a different name for different types
                        // so that the widget can be re-made for a new type
                        typnm := reflectx.ShortTypeName(f.field.Type)
                        // we must have a different name for invalid values
                        // so that the widget can be re-made for valid values
                        if !reflectx.Underlying(f.value).IsValid() {
                                typnm = "invalid"
                        }
                        // Using the type name ensures that widgets are specific to the type,
                        // even if they happen to have the same name. Using the path to index
                        // the structFields ensures safety against any [ShouldDisplayer]
                        // updates (see #1390).
                        valnm := fmt.Sprintf("value-%s-%s", fieldPath, typnm)
                        readOnlyTag := f.field.Tag.Get("edit") == "-"
                        def, hasDef := f.field.Tag.Lookup("default")

                        var labelWidget *Text
                        var valueWidget Value

                        tree.AddAt(p, labnm, func(w *Text) {
                                labelWidget = w
                                w.Styler(func(s *styles.Style) {
                                        s.SetTextWrap(false)
                                })
                                // TODO: technically we should recompute doc, readOnlyTag,
                                // def, hasDef, etc every time, as this is not fully robust
                                // (see https://github.com/cogentcore/core/issues/1098).
                                doc, _ := types.GetDoc(f.value, f.parent, f.field, label)
                                w.SetTooltip(doc)
                                if hasDef || fm.Modified != nil {
                                        if hasDef {
                                                w.SetTooltip("(Default: " + def + ") " + w.Tooltip)
                                        }
                                        var isDef bool
                                        w.Styler(func(s *styles.Style) {
                                                f := fm.structFields.At(fieldPath)
                                                dcr := "(Double click to reset to default) "
                                                if fm.Modified != nil {
                                                        isDef = !fm.Modified[f.path]
                                                        dcr = "(Double click to mark as not modified) "
                                                } else {
                                                        isDef = reflectx.ValueIsDefault(f.value, def)
                                                }
                                                if !isDef {
                                                        s.Color = colors.Scheme.Primary.Base
                                                        s.Cursor = cursors.Poof
                                                        if !strings.HasPrefix(w.Tooltip, dcr) {
                                                                w.SetTooltip(dcr + w.Tooltip)
                                                        }
                                                } else {
                                                        w.SetTooltip(strings.TrimPrefix(w.Tooltip, dcr))
                                                }
                                        })
                                        w.OnDoubleClick(func(e events.Event) {
                                                f := fm.structFields.At(fieldPath)
                                                if isDef {
                                                        return
                                                }
                                                e.SetHandled()
                                                var err error
                                                if fm.Modified != nil {
                                                        fm.Modified[f.path] = false
                                                } else {
                                                        err = reflectx.SetFromDefaultTag(f.value, def)
                                                }
                                                if err != nil {
                                                        ErrorSnackbar(w, err, "Error setting default value")
                                                } else {
                                                        w.Update()
                                                        valueWidget.AsWidget().Update()
                                                        if fm.Modified == nil {
                                                                valueWidget.AsWidget().SendChange(e)
                                                        }
                                                }
                                        })
                                }
                                w.Updater(func() {
                                        w.SetText(label)
                                })
                        })

                        tree.AddNew(p, valnm, func() Value {
                                return NewValue(reflectx.UnderlyingPointer(f.value).Interface(), f.field.Tag)
                        }, func(w Value) {
                                valueWidget = w
                                wb := w.AsWidget()
                                doc, _ := types.GetDoc(f.value, f.parent, f.field, label)
                                // InitValueButton may set starting wb.Tooltip in Init
                                if wb.Tooltip == "" {
                                        wb.SetTooltip(doc)
                                } else if doc == "" {
                                        wb.SetTooltip(wb.Tooltip)
                                } else {
                                        wb.SetTooltip(wb.Tooltip + " " + doc)
                                }
                                if hasDef {
                                        wb.SetTooltip("(Default: " + def + ") " + wb.Tooltip)
                                }
                                wb.OnInput(func(e events.Event) {
                                        f := fm.structFields.At(fieldPath)
                                        fm.Send(events.Input, e)
                                        if f.field.Tag.Get("immediate") == "+" {
                                                wb.SendChange(e)
                                        }
                                })
                                if !fm.IsReadOnly() && !readOnlyTag {
                                        wb.OnChange(func(e events.Event) {
                                                if fm.Modified != nil {
                                                        fm.Modified[f.path] = true
                                                }
                                                fm.SendChange(e)
                                                if hasDef || fm.Modified != nil {
                                                        labelWidget.Update()
                                                }
                                                if fm.isShouldDisplayer {
                                                        fm.Update()
                                                }
                                        })
                                }
                                wb.Updater(func() {
                                        wb.SetReadOnly(fm.IsReadOnly() || readOnlyTag)
                                        f := fm.structFields.At(fieldPath)
                                        Bind(reflectx.UnderlyingPointer(f.value).Interface(), w)
                                        vc := joinValueTitle(fm.ValueTitle, label)
                                        if vc != wb.ValueTitle {
                                                wb.ValueTitle = vc + " (" + wb.ValueTitle + ")"
                                        }
                                })
                        })
                }
        })
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "log/slog"
        "time"
        "unicode"

        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/events"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/tree"
)

// Frame is the primary node type responsible for organizing the sizes
// and positions of child widgets. It also renders the standard box model.
// All collections of widgets should generally be contained within a [Frame];
// otherwise, the parent widget must take over responsibility for positioning.
// Frames automatically can add scrollbars depending on the [styles.Style.Overflow].
//
// For a [styles.Grid] frame, the [styles.Style.Columns] property should
// generally be set to the desired number of columns, from which the number of rows
// is computed; otherwise, it uses the square root of number of
// elements.
type Frame struct {
        WidgetBase

        // StackTop, for a [styles.Stacked] frame, is the index of the node to use
        // as the top of the stack. Only the node at this index is rendered; if it is
        // not a valid index, nothing is rendered.
        StackTop int

        // LayoutStackTopOnly is whether to only layout the top widget
        // (specified by [Frame.StackTop]) for a [styles.Stacked] frame.
        // This is appropriate for widgets such as [Tabs], which do a full
        // redraw on stack changes, but not for widgets such as [Switch]es
        // which don't.
        LayoutStackTopOnly bool

        // layout contains implementation state info for doing layout
        layout layoutState

        // HasScroll is whether scrollbars exist for each dimension.
        HasScroll [2]bool `edit:"-" copier:"-" json:"-" xml:"-" set:"-"`

        // Scrolls are the scroll bars, which are fully managed as needed.
        Scrolls [2]*Slider `copier:"-" json:"-" xml:"-" set:"-"`

        // handleKeyNav indicates whether this frame should handle keyboard
        // navigation events using the default handlers. Set to false to allow
        // custom event handling.
        handleKeyNav bool

        // accumulated name to search for when keys are typed
        focusName string

        // time of last focus name event; for timeout
        focusNameTime time.Time

        // last element focused on; used as a starting point if name is the same
        focusNameLast tree.Node
}

func (fr *Frame) Init() {
        fr.WidgetBase.Init()
        fr.handleKeyNav = true
        fr.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.ScrollableUnattended)
        })
        fr.FinalStyler(func(s *styles.Style) {
                // we only enable, not disable, since some other widget like Slider may want to enable
                if s.Overflow.X == styles.OverflowAuto || s.Overflow.Y == styles.OverflowAuto {
                        s.SetAbilities(true, abilities.Scrollable)
                        if TheApp.SystemPlatform().IsMobile() {
                                s.SetAbilities(true, abilities.Slideable)
                        }
                }
        })
        fr.OnFinal(events.KeyChord, func(e events.Event) {
                if !fr.handleKeyNav {
                        return
                }
                kf := keymap.Of(e.KeyChord())
                if DebugSettings.KeyEventTrace {
                        slog.Info("Layout KeyInput", "widget", fr, "keyFunction", kf)
                }
                if kf == keymap.Abort {
                        if fr.Scene.Stage.closePopupAndBelow() {
                                e.SetHandled()
                        }
                        return
                }
                em := fr.Events()
                if em == nil {
                        return
                }
                grid := fr.Styles.Display == styles.Grid
                if fr.Styles.Direction == styles.Row || grid {
                        switch kf {
                        case keymap.MoveRight:
                                if fr.focusNextChild(false) {
                                        e.SetHandled()
                                }
                                return
                        case keymap.MoveLeft:
                                if fr.focusPreviousChild(false) {
                                        e.SetHandled()
                                }
                                return
                        }
                }
                if fr.Styles.Direction == styles.Column || grid {
                        switch kf {
                        case keymap.MoveDown:
                                if fr.focusNextChild(true) {
                                        e.SetHandled()
                                }
                                return
                        case keymap.MoveUp:
                                if fr.focusPreviousChild(true) {
                                        e.SetHandled()
                                }
                                return
                        case keymap.PageDown:
                                proc := false
                                for st := 0; st < SystemSettings.LayoutPageSteps; st++ {
                                        if !fr.focusNextChild(true) {
                                                break
                                        }
                                        proc = true
                                }
                                if proc {
                                        e.SetHandled()
                                }
                                return
                        case keymap.PageUp:
                                proc := false
                                for st := 0; st < SystemSettings.LayoutPageSteps; st++ {
                                        if !fr.focusPreviousChild(true) {
                                                break
                                        }
                                        proc = true
                                }
                                if proc {
                                        e.SetHandled()
                                }
                                return
                        }
                }
                fr.focusOnName(e)
        })
        fr.On(events.Scroll, func(e events.Event) {
                if fr.AbilityIs(abilities.ScrollableUnattended) || (fr.StateIs(states.Focused) || fr.StateIs(states.Attended)) {
                        fr.scrollDelta(e)
                }
        })
        // We treat slide events on frames as scroll events on mobile.
        prevVels := []math32.Vector2{}
        fr.On(events.SlideStart, func(e events.Event) {
                if !TheApp.SystemPlatform().IsMobile() {
                        return
                }

                // Stop any existing scroll animations for this frame.
                for _, anim := range fr.Scene.Animations {
                        if anim.Widget.This == fr.This {
                                anim.Done = true
                        }
                }
        })
        fr.On(events.SlideMove, func(e events.Event) {
                if !TheApp.SystemPlatform().IsMobile() {
                        return
                }

                // We must negate the delta for "natural" scrolling behavior.
                del := math32.FromPoint(e.PrevDelta()).Negate()
                fr.scrollDelta(events.NewScroll(e.WindowPos(), del, e.Modifiers()))

                time := float32(e.SincePrev().Seconds()) * 1000
                vel := del.DivScalar(time)
                if len(prevVels) >= 3 {
                        prevVels = append(prevVels[1:], vel)
                } else {
                        prevVels = append(prevVels, vel)
                }
        })
        fr.On(events.SlideStop, func(e events.Event) {
                if !TheApp.SystemPlatform().IsMobile() {
                        return
                }

                // If we have enough velocity over the last few slide events,
                // we continue scrolling in an animation while slowly decelerating
                // for a smoother experience.
                if len(prevVels) == 0 {
                        return
                }
                vel := math32.Vector2{}
                for _, vi := range prevVels {
                        vel.SetAdd(vi)
                }
                vel.SetDivScalar(float32(len(prevVels)))
                prevVels = prevVels[:0] // reset for next scroll

                if vel.Length() < 1 {
                        return
                }
                i := 0
                t := float32(0)
                fr.Animate(func(a *Animation) {
                        t += a.Dt
                        // See https://medium.com/@esskeetit/scrolling-mechanics-of-uiscrollview-142adee1142c
                        vel.SetMulScalar(math32.Pow(0.998, a.Dt)) // TODO: avoid computing Pow each time?
                        dx := vel.MulScalar(a.Dt)
                        fr.scrollDelta(events.NewScroll(e.WindowPos(), dx, e.Modifiers()))
                        i++
                        if t > 2000 {
                                a.Done = true
                        }
                })
        })
}

func (fr *Frame) Style() {
        fr.WidgetBase.Style()
        for d := math32.X; d <= math32.Y; d++ {
                if fr.HasScroll[d] && fr.Scrolls[d] != nil {
                        fr.Scrolls[d].Style()
                }
        }
}

func (fr *Frame) Destroy() {
        for d := math32.X; d <= math32.Y; d++ {
                fr.deleteScroll(d)
        }
        fr.WidgetBase.Destroy()
}

// deleteScroll deletes scrollbar along given dimesion.
func (fr *Frame) deleteScroll(d math32.Dims) {
        if fr.Scrolls[d] == nil {
                return
        }
        sb := fr.Scrolls[d]
        sb.This.Destroy()
        fr.Scrolls[d] = nil
}

func (fr *Frame) RenderChildren() {
        if fr.Styles.Display == styles.Stacked {
                wb := fr.StackTopWidget()
                if wb != nil {
                        wb.This.(Widget).RenderWidget()
                }
                return
        }
        fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cw.RenderWidget()
                return tree.Continue
        })
}

func (fr *Frame) RenderWidget() {
        if fr.StartRender() {
                fr.This.(Widget).Render()
                fr.RenderChildren()
                fr.renderParts()
                fr.RenderScrolls()
                fr.EndRender()
        }
}

// childWithFocus returns a direct child of this layout that either is the
// current window focus item, or contains that focus item (along with its
// index) -- nil, -1 if none.
func (fr *Frame) childWithFocus() (Widget, int) {
        em := fr.Events()
        if em == nil {
                return nil, -1
        }
        var foc Widget
        focIndex := -1
        fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                if cwb.ContainsFocus() {
                        foc = cw
                        focIndex = i
                        return tree.Break
                }
                return tree.Continue
        })
        return foc, focIndex
}

// focusNextChild attempts to move the focus into the next layout child
// (with wraparound to start); returns true if successful.
// if updn is true, then for Grid layouts, it moves down to next row
// instead of just the sequentially next item.
func (fr *Frame) focusNextChild(updn bool) bool {
        sz := len(fr.Children)
        if sz <= 1 {
                return false
        }
        foc, idx := fr.childWithFocus()
        if foc == nil {
                // fmt.Println("no child foc")
                return false
        }
        em := fr.Events()
        if em == nil {
                return false
        }
        cur := em.focus
        nxti := idx + 1
        if fr.Styles.Display == styles.Grid && updn {
                nxti = idx + fr.Styles.Columns
        }
        did := false
        if nxti < sz {
                nx := fr.Child(nxti).(Widget)
                did = em.focusOnOrNext(nx)
        } else {
                nx := fr.Child(0).(Widget)
                did = em.focusOnOrNext(nx)
        }
        if !did || em.focus == cur {
                return false
        }
        return true
}

// focusPreviousChild attempts to move the focus into the previous layout child
// (with wraparound to end); returns true if successful.
// If updn is true, then for Grid layouts, it moves up to next row
// instead of just the sequentially next item.
func (fr *Frame) focusPreviousChild(updn bool) bool {
        sz := len(fr.Children)
        if sz <= 1 {
                return false
        }
        foc, idx := fr.childWithFocus()
        if foc == nil {
                return false
        }
        em := fr.Events()
        if em == nil {
                return false
        }
        cur := em.focus
        nxti := idx - 1
        if fr.Styles.Display == styles.Grid && updn {
                nxti = idx - fr.Styles.Columns
        }
        did := false
        if nxti >= 0 {
                did = em.focusOnOrPrev(fr.Child(nxti).(Widget))
        } else {
                did = em.focusOnOrPrev(fr.Child(sz - 1).(Widget))
        }
        if !did || em.focus == cur {
                return false
        }
        return true
}

// focusOnName processes key events to look for an element starting with given name
func (fr *Frame) focusOnName(e events.Event) bool {
        kf := keymap.Of(e.KeyChord())
        if DebugSettings.KeyEventTrace {
                slog.Info("Layout FocusOnName", "widget", fr, "keyFunction", kf)
        }
        delay := e.Time().Sub(fr.focusNameTime)
        fr.focusNameTime = e.Time()
        if kf == keymap.FocusNext { // tab means go to next match -- don't worry about time
                if fr.focusName == "" || delay > SystemSettings.LayoutFocusNameTabTime {
                        fr.focusName = ""
                        fr.focusNameLast = nil
                        return false
                }
        } else {
                if delay > SystemSettings.LayoutFocusNameTimeout {
                        fr.focusName = ""
                }
                if !unicode.IsPrint(e.KeyRune()) || e.Modifiers() != 0 {
                        return false
                }
                sr := string(e.KeyRune())
                if fr.focusName == sr {
                        // re-search same letter
                } else {
                        fr.focusName += sr
                        fr.focusNameLast = nil // only use last if tabbing
                }
        }
        // e.SetHandled()
        // fmt.Printf("searching for: %v  last: %v\n", ly.FocusName, ly.FocusNameLast)
        focel := childByLabelCanFocus(fr, fr.focusName, fr.focusNameLast)
        if focel != nil {
                em := fr.Events()
                if em != nil {
                        em.setFocus(focel.(Widget)) // this will also scroll by default!
                }
                fr.focusNameLast = focel
                return true
        }
        if fr.focusNameLast == nil {
                fr.focusName = "" // nothing being found
        }
        fr.focusNameLast = nil // start over
        return false
}

// childByLabelCanFocus uses breadth-first search to find
// the first focusable element within the layout whose Label (using
// [ToLabel]) matches the given name using [complete.IsSeedMatching].
// If after is non-nil, it only finds after that element.
func childByLabelCanFocus(fr *Frame, name string, after tree.Node) tree.Node {
        gotAfter := false
        completions := []complete.Completion{}
        fr.WalkDownBreadth(func(n tree.Node) bool {
                if n == fr.This { // skip us
                        return tree.Continue
                }
                wb := AsWidget(n)
                if wb == nil || !wb.CanFocus() { // don't go any further
                        return tree.Continue
                }
                if after != nil && !gotAfter {
                        if n == after {
                                gotAfter = true
                        }
                        return tree.Continue // skip to next
                }
                completions = append(completions, complete.Completion{
                        Text: labels.ToLabel(n),
                        Desc: n.AsTree().PathFrom(fr),
                })
                return tree.Continue
        })
        matches := complete.MatchSeedCompletion(completions, name)
        if len(matches) > 0 {
                return fr.FindPath(matches[0].Desc)
        }
        return nil
}

// Stretch and Space: spacing elements

// Stretch adds a stretchy element that grows to fill all
// available space. You can set [styles.Style.Grow] to change
// how much it grows relative to other growing elements.
// It does not render anything.
type Stretch struct {
        WidgetBase
}

func (st *Stretch) Init() {
        st.WidgetBase.Init()
        st.Styler(func(s *styles.Style) {
                s.RenderBox = false
                s.Min.X.Ch(1)
                s.Min.Y.Em(1)
                s.Grow.Set(1, 1)
        })
}

// Space is a fixed size blank space, with
// a default width of 1ch and a height of 1em.
// You can set [styles.Style.Min] to change its size.
// It does not render anything.
type Space struct {
        WidgetBase
}

func (sp *Space) Init() {
        sp.WidgetBase.Init()
        sp.Styler(func(s *styles.Style) {
                s.RenderBox = false
                s.Min.X.Ch(1)
                s.Min.Y.Em(1)
                s.Padding.Zero()
                s.Margin.Zero()
                s.MaxBorder.Width.Zero()
                s.Border.Width.Zero()
        })
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "log/slog"
        "reflect"
        "strings"
        "unicode"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/types"
)

// CallFunc calls the given function in the context of the given widget,
// popping up a dialog to prompt for any arguments and show the return
// values of the function. It is a helper function that uses [NewSoloFuncButton]
// under the hood.
func CallFunc(ctx Widget, fun any) {
        NewSoloFuncButton(ctx).SetFunc(fun).CallFunc()
}

// NewSoloFuncButton returns a standalone [FuncButton] with a fake parent
// with the given context for popping up any dialogs.
func NewSoloFuncButton(ctx Widget) *FuncButton {
        return NewFuncButton(NewWidgetBase()).SetContext(ctx)
}

// FuncButton is a button that is set up to call a function when it
// is pressed, using a dialog to prompt the user for any arguments.
// Also, it automatically sets various properties of the button like
// the text and tooltip based on the properties of the function,
// using [reflect] and [types]. The function must be registered
// with [types] to get documentation information, but that is not
// required; add a `//types:add` comment directive and run `core generate`
// if you want tooltips. If the function is a method, both the method and
// its receiver type must be added to [types] to get documentation.
// The main function to call first is [FuncButton.SetFunc].
type FuncButton struct {
        Button

        // typesFunc is the [types.Func] associated with this button.
        // This function can also be a method, but it must be
        // converted to a [types.Func] first. It should typically
        // be set using [FuncButton.SetFunc].
        typesFunc *types.Func

        // reflectFunc is the [reflect.Value] of the function or
        // method associated with this button. It should typically
        // bet set using [FuncButton.SetFunc].
        reflectFunc reflect.Value

        // Args are the [FuncArg] objects associated with the
        // arguments of the function. They are automatically set in
        // [FuncButton.SetFunc], but they can be customized to configure
        // default values and other options.
        Args []FuncArg `set:"-"`

        // Returns are the [FuncArg] objects associated with the
        // return values of the function. They are automatically
        // set in [FuncButton.SetFunc], but they can be customized
        // to configure options. The [FuncArg.Value]s are not set until
        // the function is called, and are thus not typically applicable
        // to access.
        Returns []FuncArg `set:"-"`

        // Confirm is whether to prompt the user for confirmation
        // before calling the function.
        Confirm bool

        // ShowReturn is whether to display the return values of
        // the function (and a success message if there are none).
        // The way that the return values are shown is determined
        // by ShowReturnAsDialog. Non-nil error return values will
        // always be shown, even if ShowReturn is set to false.
        ShowReturn bool

        // ShowReturnAsDialog, if and only if ShowReturn is true,
        // indicates to show the return values of the function in
        // a dialog, instead of in a snackbar, as they are by default.
        // If there are multiple return values from the function, or if
        // one of them is a complex type (pointer, struct, slice,
        // array, map), then ShowReturnAsDialog will
        // automatically be set to true.
        ShowReturnAsDialog bool

        // NewWindow makes the return value dialog a NewWindow dialog.
        NewWindow bool

        // WarnUnadded is whether to log warnings when a function that
        // has not been added to [types] is used. It is on by default and
        // must be set before [FuncButton.SetFunc] is called for it to
        // have any effect. Warnings are never logged for anonymous functions.
        WarnUnadded bool `default:"true"`

        // Context is used for opening dialogs if non-nil.
        Context Widget

        // AfterFunc is an optional function called after the func button
        // function is executed.
        AfterFunc func()
}

// FuncArg represents one argument or return value of a function
// in the context of a [FuncButton].
type FuncArg struct { //types:add -setters

        // Name is the name of the argument or return value.
        Name string

        // Tag contains any tags associated with the argument or return value,
        // which can be added programmatically to customize [Value] behavior.
        Tag reflect.StructTag

        // Value is the actual value of the function argument or return value.
        // It can be modified when creating a [FuncButton] to set a default value.
        Value any
}

func (fb *FuncButton) WidgetValue() any {
        if !fb.reflectFunc.IsValid() {
                return nil
        }
        return fb.reflectFunc.Interface()
}

func (fb *FuncButton) SetWidgetValue(value any) error {
        fb.SetFunc(reflectx.Underlying(reflect.ValueOf(value)).Interface())
        return nil
}

func (fb *FuncButton) OnBind(value any, tags reflect.StructTag) {
        // If someone is viewing a function value, there is a good chance
        // that it is not added to types (and that is out of their control)
        // (eg: in the inspector), so we do not warn on unadded functions.
        fb.SetWarnUnadded(false).SetType(ButtonTonal)
}

func (fb *FuncButton) Init() {
        fb.Button.Init()
        fb.WarnUnadded = true
        fb.Styler(func(s *styles.Style) {
                // If Disabled, these steps are unnecessary and we want the default NotAllowed cursor, so only check for ReadOnly.
                if s.Is(states.ReadOnly) {
                        s.SetAbilities(false, abilities.Hoverable, abilities.Clickable, abilities.Activatable)
                        s.Cursor = cursors.None
                }
        })
        fb.OnClick(func(e events.Event) {
                if !fb.IsReadOnly() {
                        fb.CallFunc()
                }
        })
}

// SetText sets the [FuncButton.Text] and updates the tooltip to
// correspond to the new name.
func (fb *FuncButton) SetText(v string) *FuncButton {
        ptext := fb.Text
        fb.Text = v
        if fb.typesFunc != nil && fb.Text != ptext && ptext != "" {
                fb.typesFunc.Doc = types.FormatDoc(fb.typesFunc.Doc, ptext, fb.Text)
                fb.SetTooltip(fb.typesFunc.Doc)
        }
        return fb
}

// SetFunc sets the function associated with the FuncButton to the
// given function or method value. For documentation information for
// the function to be obtained, it must be added to [types].
func (fb *FuncButton) SetFunc(fun any) *FuncButton {
        fnm := types.FuncName(fun)
        if fnm == "" {
                return fb.SetText("None")
        }
        fnm = strings.ReplaceAll(fnm, "[...]", "") // remove any labeling for generics
        // the "-fm" suffix indicates that it is a method
        if strings.HasSuffix(fnm, "-fm") {
                fnm = strings.TrimSuffix(fnm, "-fm")
                // the last dot separates the function name
                li := strings.LastIndex(fnm, ".")
                metnm := fnm[li+1:]
                typnm := fnm[:li]
                // get rid of any parentheses and pointer receivers
                // that may surround the type name
                typnm = strings.ReplaceAll(typnm, "(*", "")
                typnm = strings.TrimSuffix(typnm, ")")
                gtyp := types.TypeByName(typnm)
                var met *types.Method
                if gtyp == nil {
                        if fb.WarnUnadded {
                                slog.Warn("core.FuncButton.SetFunc called with a method whose receiver type has not been added to types", "function", fnm)
                        }
                        met = &types.Method{Name: metnm}
                } else {
                        for _, m := range gtyp.Methods {
                                if m.Name == metnm {
                                        met = &m
                                        break
                                }
                        }
                        if met == nil {
                                if fb.WarnUnadded {
                                        slog.Warn("core.FuncButton.SetFunc called with a method that has not been added to types (even though the receiver type was, you still need to add the method itself)", "function", fnm)
                                }
                                met = &types.Method{Name: metnm}
                        }
                }
                return fb.setMethodImpl(met, reflect.ValueOf(fun))
        }

        if isAnonymousFunction(fnm) {
                f := &types.Func{Name: fnm, Doc: "Anonymous function " + fnm}
                return fb.setFuncImpl(f, reflect.ValueOf(fun))
        }

        f := types.FuncByName(fnm)
        if f == nil {
                if fb.WarnUnadded {
                        slog.Warn("core.FuncButton.SetFunc called with a function that has not been added to types", "function", fnm)
                }
                f = &types.Func{Name: fnm}
        }
        return fb.setFuncImpl(f, reflect.ValueOf(fun))
}

func isAnonymousFunction(fnm string) bool {
        // FuncName.funcN indicates that a function was defined anonymously
        funcN := len(fnm) > 0 && unicode.IsDigit(rune(fnm[len(fnm)-1])) && strings.Contains(fnm, ".func")
        return funcN || fnm == "reflect.makeFuncStub" // used for anonymous functions in yaegi
}

// setFuncImpl is the underlying implementation of [FuncButton.SetFunc].
// It should typically not be used by end-user code.
func (fb *FuncButton) setFuncImpl(gfun *types.Func, rfun reflect.Value) *FuncButton {
        fb.typesFunc = gfun
        fb.reflectFunc = rfun
        fb.setArgs()
        fb.setReturns()
        snm := fb.typesFunc.Name
        // get name without package
        li := strings.LastIndex(snm, ".")
        isAnonymous := isAnonymousFunction(snm)
        if snm == "reflect.makeFuncStub" { // used for anonymous functions in yaegi
                snm = "Anonymous function"
                li = -1
        } else if isAnonymous {
                snm = strings.TrimRightFunc(snm, func(r rune) bool {
                        return unicode.IsDigit(r) || r == '.'
                })
                snm = strings.TrimSuffix(snm, ".func")
                // we cut at the second to last period (we want to keep the
                // receiver / package for anonymous functions)
                li = strings.LastIndex(snm[:strings.LastIndex(snm, ".")], ".")
        }
        if li >= 0 {
                snm = snm[li+1:] // must also get rid of "."
                // if we are a global function, we may have gone too far with the second to last period,
                // so we go after the last slash if there still is one
                if strings.Contains(snm, "/") {
                        snm = snm[strings.LastIndex(snm, "/")+1:]
                }
        }
        snm = strings.Map(func(r rune) rune {
                if r == '(' || r == ')' || r == '*' {
                        return -1
                }
                return r
        }, snm)
        txt := strcase.ToSentence(snm)
        fb.SetText(txt)
        // doc formatting interferes with anonymous functions
        if !isAnonymous {
                fb.typesFunc.Doc = types.FormatDoc(fb.typesFunc.Doc, snm, txt)
        }
        fb.SetTooltip(fb.typesFunc.Doc)
        return fb
}

func (fb *FuncButton) goodContext() Widget {
        ctx := fb.Context
        if fb.Context == nil {
                if fb.This == nil {
                        return nil
                }
                ctx = fb.This.(Widget)
        }
        return ctx
}

func (fb *FuncButton) callFuncShowReturns() {
        if fb.AfterFunc != nil {
                defer fb.AfterFunc()
        }
        if len(fb.Args) == 0 {
                rets := fb.reflectFunc.Call(nil)
                fb.showReturnsDialog(rets)
                return
        }
        rargs := make([]reflect.Value, len(fb.Args))
        for i, arg := range fb.Args {
                rargs[i] = reflect.ValueOf(arg.Value)
        }
        rets := fb.reflectFunc.Call(rargs)
        fb.showReturnsDialog(rets)
}

// confirmDialog runs the confirm dialog.
func (fb *FuncButton) confirmDialog() {
        ctx := fb.goodContext()
        d := NewBody(fb.Text + "?")
        NewText(d).SetType(TextSupporting).SetText("Are you sure you want to " + strings.ToLower(fb.Text) + "? " + fb.Tooltip)
        d.AddBottomBar(func(bar *Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).SetText(fb.Text).OnClick(func(e events.Event) {
                        fb.callFuncShowReturns()
                })
        })
        d.RunDialog(ctx)
}

// CallFunc calls the function associated with this button,
// prompting the user for any arguments.
func (fb *FuncButton) CallFunc() {
        if !fb.reflectFunc.IsValid() {
                return
        }
        ctx := fb.goodContext()
        if len(fb.Args) == 0 {
                if !fb.Confirm {
                        fb.callFuncShowReturns()
                        return
                }
                fb.confirmDialog()
                return
        }
        d := NewBody(fb.Text)
        NewText(d).SetType(TextSupporting).SetText(fb.Tooltip)
        str := funcArgsToStruct(fb.Args)
        sv := NewForm(d).SetStruct(str.Addr().Interface())

        accept := func() {
                for i := range fb.Args {
                        fb.Args[i].Value = str.Field(i).Interface()
                }
                fb.callFuncShowReturns()
        }

        // If there is a single value button, automatically
        // open its dialog instead of this one
        if len(fb.Args) == 1 {
                sv.UpdateWidget() // need to update first
                bt := AsButton(sv.Child(1))
                if bt != nil {
                        bt.OnFinal(events.Change, func(e events.Event) {
                                // the dialog for the argument has been accepted, so we call the function
                                accept()
                        })
                        bt.Scene = fb.Scene // we must use this scene for context
                        bt.Send(events.Click)
                        return
                }
        }

        d.AddBottomBar(func(bar *Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).SetText(fb.Text).OnClick(func(e events.Event) {
                        d.Close() // note: the other Close event happens too late!
                        accept()
                })
        })
        d.RunDialog(ctx)
}

// funcArgsToStruct converts a slice of [FuncArg] objects
// to a new non-pointer struct [reflect.Value].
func funcArgsToStruct(args []FuncArg) reflect.Value {
        fields := make([]reflect.StructField, len(args))
        for i, arg := range args {
                fields[i] = reflect.StructField{
                        Name: strcase.ToCamel(arg.Name),
                        Type: reflect.TypeOf(arg.Value),
                        Tag:  arg.Tag,
                }
        }
        typ := reflect.StructOf(fields)
        value := reflect.New(typ).Elem()
        for i, arg := range args {
                value.Field(i).Set(reflect.ValueOf(arg.Value))
        }
        return value
}

// setMethodImpl is the underlying implementation of [FuncButton.SetFunc] for methods.
// It should typically not be used by end-user code.
func (fb *FuncButton) setMethodImpl(gmet *types.Method, rmet reflect.Value) *FuncButton {
        return fb.setFuncImpl(&types.Func{
                Name:       gmet.Name,
                Doc:        gmet.Doc,
                Directives: gmet.Directives,
                Args:       gmet.Args,
                Returns:    gmet.Returns,
        }, rmet)
}

// showReturnsDialog runs a dialog displaying the given function return
// values for the function associated with the function button. It does
// nothing if [FuncButton.ShowReturn] is false.
func (fb *FuncButton) showReturnsDialog(rets []reflect.Value) {
        if !fb.ShowReturn {
                for _, ret := range rets {
                        if err, ok := ret.Interface().(error); ok && err != nil {
                                ErrorSnackbar(fb, err, fb.Text+" failed")
                                return
                        }
                }
                return
        }
        ctx := fb.goodContext()
        if ctx == nil {
                return
        }
        for i, ret := range rets {
                fb.Returns[i].Value = ret.Interface()
        }
        main := "Result of " + fb.Text
        if len(rets) == 0 {
                main = fb.Text + " succeeded"
        }
        if !fb.ShowReturnAsDialog {
                txt := main
                if len(fb.Returns) > 0 {
                        txt += ": "
                        for i, ret := range fb.Returns {
                                txt += reflectx.ToString(ret.Value)
                                if i < len(fb.Returns)-1 {
                                        txt += ", "
                                }
                        }
                }
                MessageSnackbar(ctx, txt)
                return
        }

        d := NewBody(main)
        NewText(d).SetType(TextSupporting).SetText(fb.Tooltip)
        d.AddOKOnly()
        str := funcArgsToStruct(fb.Returns)
        sv := NewForm(d).SetStruct(str.Addr().Interface()).SetReadOnly(true)

        // If there is a single value button, automatically
        // open its dialog instead of this one
        if len(fb.Returns) == 1 {
                sv.UpdateWidget() // need to update first
                bt := AsButton(sv.Child(1))
                if bt != nil {
                        bt.Scene = fb.Scene // we must use this scene for context
                        bt.Send(events.Click)
                        return
                }
        }

        if fb.NewWindow {
                d.RunWindowDialog(ctx)
        } else {
                d.RunDialog(ctx)
        }
}

// setArgs sets the appropriate [Value] objects for the
// arguments of the function associated with the function button.
func (fb *FuncButton) setArgs() {
        narg := fb.reflectFunc.Type().NumIn()
        fb.Args = make([]FuncArg, narg)
        for i := range fb.Args {
                typ := fb.reflectFunc.Type().In(i)

                name := ""
                if fb.typesFunc.Args != nil && len(fb.typesFunc.Args) > i {
                        name = fb.typesFunc.Args[i]
                } else {
                        name = reflectx.NonPointerType(typ).Name()
                }

                fb.Args[i] = FuncArg{
                        Name:  name,
                        Value: reflect.New(typ).Elem().Interface(),
                }
        }
}

// setReturns sets the appropriate [Value] objects for the
// return values of the function associated with the function
// button.
func (fb *FuncButton) setReturns() {
        nret := fb.reflectFunc.Type().NumOut()
        fb.Returns = make([]FuncArg, nret)
        hasComplex := false
        for i := range fb.Returns {
                typ := fb.reflectFunc.Type().Out(i)
                if !hasComplex {
                        k := typ.Kind()
                        if k == reflect.Pointer || k == reflect.Struct || k == reflect.Slice || k == reflect.Array || k == reflect.Map {
                                hasComplex = true
                        }
                }

                name := ""
                if fb.typesFunc.Returns != nil && len(fb.typesFunc.Returns) > i {
                        name = fb.typesFunc.Returns[i]
                } else {
                        name = reflectx.NonPointerType(typ).Name()
                }

                fb.Returns[i] = FuncArg{
                        Name:  name,
                        Value: reflect.New(typ).Elem().Interface(),
                }
        }
        if nret > 1 || hasComplex {
                fb.ShowReturnAsDialog = true
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/units"
)

// Handle represents a draggable handle that can be used to
// control the size of an element. The [styles.Style.Direction]
// controls the direction in which the handle moves.
type Handle struct {
        WidgetBase

        // Min is the minimum value that the handle can go to
        // (typically the lower bound of the dialog/splits)
        Min float32

        // Max is the maximum value that the handle can go to
        // (typically the upper bound of the dialog/splits)
        Max float32

        // Pos is the current position of the handle on the
        // scale of [Handle.Min] to [Handle.Max].
        Pos float32
}

func (hl *Handle) Init() {
        hl.WidgetBase.Init()
        hl.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Clickable, abilities.Focusable, abilities.Hoverable, abilities.Slideable, abilities.ScrollableUnattended)

                s.Border.Radius = styles.BorderRadiusFull
                s.Background = colors.Scheme.OutlineVariant
        })
        hl.FinalStyler(func(s *styles.Style) {
                if s.Direction == styles.Row {
                        s.Min.X.Dp(6)
                        s.Min.Y.Em(2)
                        s.Margin.SetHorizontal(units.Dp(6))
                } else {
                        s.Min.X.Em(2)
                        s.Min.Y.Dp(6)
                        s.Margin.SetVertical(units.Dp(6))
                }

                if !hl.IsReadOnly() {
                        if s.Direction == styles.Row {
                                s.Cursor = cursors.ResizeEW
                        } else {
                                s.Cursor = cursors.ResizeNS
                        }
                }
        })

        hl.On(events.SlideMove, func(e events.Event) {
                e.SetHandled()
                pos := hl.parentWidget().PointToRelPos(e.Pos())
                hl.Pos = math32.FromPoint(pos).Dim(hl.Styles.Direction.Dim())
                hl.SendChange(e)
        })
}

// Value returns the value on a normalized scale of 0-1,
// based on [Handle.Pos], [Handle.Min], and [Handle.Max].
func (hl *Handle) Value() float32 {
        return (hl.Pos - hl.Min) / (hl.Max - hl.Min)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "bytes"
        "encoding/xml"
        "fmt"
        "reflect"
        "strconv"
        "strings"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/tree"
)

// ToHTML converts the given widget and all of its children to HTML.
// This is not guaranteed to be perfect HTML, and it should not be used as a
// replacement for a Cogent Core app. However, it is good enough to be used as
// a preview or for SEO purposes (see generatehtml.go).
func ToHTML(w Widget) ([]byte, error) {
        b := &bytes.Buffer{}
        e := xml.NewEncoder(b)
        err := toHTML(w, e, b)
        if err != nil {
                return nil, err
        }
        return b.Bytes(), nil
}

// htmlElementNames is a map from widget [types.Type.IDName]s to HTML element
// names for cases in which those differ.
var htmlElementNames = map[string]string{
        "body":       "main", // we are typically placed in a different outer body
        "frame":      "div",
        "text":       "p",
        "image":      "img",
        "icon":       "svg",
        "space":      "div",
        "separator":  "hr",
        "text-field": "input",
        "spinner":    "input",
        "slider":     "input",
        "meter":      "progress",
        "chooser":    "select",
        "pre":        "textarea",
        "switches":   "div",
        "switch":     "input",
        "splits":     "div",
        "tabs":       "div",
        "tab":        "button",
        "tree":       "div",
        "page":       "main",
}

func addAttr(se *xml.StartElement, name, value string) {
        if value == "" {
                return
        }
        se.Attr = append(se.Attr, xml.Attr{Name: xml.Name{Local: name}, Value: value})
}

// toHTML is the recursive implementation of [ToHTML].
func toHTML(w Widget, e *xml.Encoder, b *bytes.Buffer) error {
        wb := w.AsWidget()
        se := &xml.StartElement{}
        typ := wb.NodeType()
        idName := typ.IDName
        se.Name.Local = idName
        if tag, ok := wb.Property("tag").(string); ok {
                se.Name.Local = tag
        }
        if se.Name.Local == "tree" { // trees not supported yet
                return nil
        }
        if en, ok := htmlElementNames[se.Name.Local]; ok {
                se.Name.Local = en
        }

        switch typ.Name {
        case "cogentcore.org/cogent/canvas.Canvas", "cogentcore.org/cogent/code.Code":
                se.Name.Local = "div"
        case "cogentcore.org/core/textcore.Editor":
                se.Name.Local = "textarea"
        }
        if se.Name.Local == "textarea" {
                wb.Styles.Min.X.Pw(95)
        }

        addAttr(se, "id", wb.Name)
        if se.Name.Local != "img" { // images don't render yet
                addAttr(se, "style", styles.ToCSS(&wb.Styles, idName, se.Name.Local))
        }
        if href, ok := wb.Property("href").(string); ok {
                addAttr(se, "href", href)
        }

        handleChildren := true

        switch w := w.(type) {
        case *TextField:
                addAttr(se, "type", "text")
                addAttr(se, "value", w.text)
                handleChildren = false
        case *Spinner:
                addAttr(se, "type", "number")
                addAttr(se, "value", fmt.Sprintf("%g", w.Value))
                handleChildren = false
        case *Slider:
                addAttr(se, "type", "range")
                addAttr(se, "value", fmt.Sprintf("%g", w.Value))
                handleChildren = false
        case *Switch:
                addAttr(se, "type", "checkbox")
                addAttr(se, "value", strconv.FormatBool(w.IsChecked()))
        }
        if se.Name.Local == "textarea" {
                addAttr(se, "rows", "10")
                addAttr(se, "cols", "30")
        }

        err := e.EncodeToken(*se)
        if err != nil {
                return err
        }
        err = e.Flush()
        if err != nil {
                return err
        }

        switch w := w.(type) {
        case *Text:
                // We don't want any escaping of HTML-formatted text, so we write directly.
                b.WriteString(w.Text)
        case *Icon:
                // TODO: just remove the width and height attributes from the source SVGs?
                icon := strings.ReplaceAll(string(w.Icon), ` width="48" height="48"`, "")
                b.WriteString(icon)
        case *SVG:
                w.SVG.PhysicalWidth = wb.Styles.Min.X
                w.SVG.PhysicalHeight = wb.Styles.Min.Y
                err := w.SVG.WriteXML(b, false)
                if err != nil {
                        return err
                }
        }
        if se.Name.Local == "textarea" && idName == "editor" {
                b.WriteString(reflectx.Underlying(reflect.ValueOf(w)).FieldByName("Lines").Interface().(fmt.Stringer).String())
        }

        if handleChildren {
                wb.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                        if idName == "switch" && cwb.Name == "stack" {
                                return tree.Continue
                        }
                        err = toHTML(cw, e, b)
                        if err != nil {
                                return tree.Break
                        }
                        return tree.Continue
                })
                if err != nil {
                        return err
                }
        }
        err = e.EncodeToken(xml.EndElement{se.Name})
        if err != nil {
                return err
        }
        return e.Flush()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "image/color"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/svg"
        "golang.org/x/image/draw"
)

// Icon renders an [icons.Icon].
// The rendered version is cached for the current size.
// Icons do not render a background or border independent of their SVG object.
// The size of an Icon is determined by the [styles.Font.Size] property.
type Icon struct {
        WidgetBase

        // Icon is the [icons.Icon] used to render the [Icon].
        Icon icons.Icon

        // prevIcon is the previously rendered icon.
        prevIcon icons.Icon

        // prevColor is the previously rendered color, as uniform.
        prevColor color.RGBA

        // prevOpacity is the previously rendered opacity.
        prevOpacity float32

        // image representation of the icon, cached for faster drawing.
        pixels image.Image
}

func (ic *Icon) WidgetValue() any { return &ic.Icon }

func (ic *Icon) Init() {
        ic.WidgetBase.Init()
        ic.Styler(func(s *styles.Style) {
                s.Min.Set(units.Em(1))
        })
}

// RerenderSVG forcibly renders the icon, returning the [svg.SVG]
// used to render.
func (ic *Icon) RerenderSVG() *svg.SVG {
        ic.pixels = nil
        ic.prevIcon = ""
        return ic.renderSVG()
}

// renderSVG renders the icon if necessary, returning the [svg.SVG]
// used to render if it was rendered, otherwise nil.
func (ic *Icon) renderSVG() *svg.SVG {
        sz := ic.Geom.Size.Actual.Content.ToPoint()
        if sz == (image.Point{}) {
                return nil
        }
        var isz image.Point
        if ic.pixels != nil {
                isz = ic.pixels.Bounds().Size()
        }
        cc := colors.ToUniform(ic.Styles.Color)
        if ic.Icon == ic.prevIcon && sz == isz && ic.prevColor == cc && ic.prevOpacity == ic.Styles.Opacity && !ic.NeedsRebuild() {
                return nil
        }
        ic.pixels = nil
        if !ic.Icon.IsSet() {
                ic.prevIcon = ic.Icon
                return nil
        }
        sv := svg.NewSVG(ic.Geom.Size.Actual.Content)
        err := sv.ReadXML(strings.NewReader(string(ic.Icon)))
        if errors.Log(err) != nil || sv.Root == nil || !sv.Root.HasChildren() {
                return nil
        }
        icons.Used[ic.Icon] = struct{}{}
        ic.prevIcon = ic.Icon
        sv.Root.ViewBox.PreserveAspectRatio.SetFromStyle(&ic.Styles)
        sv.TextShaper = ic.Scene.TextShaper()
        clr := gradient.ApplyOpacity(ic.Styles.Color, ic.Styles.Opacity)
        sv.Color = clr
        sv.Scale = 1
        ic.pixels = sv.RenderImage()
        ic.prevColor = cc
        ic.prevOpacity = ic.Styles.Opacity
        return sv
}

func (ic *Icon) Render() {
        ic.renderSVG()
        if ic.pixels == nil {
                return
        }
        r := ic.Geom.ContentBBox
        sp := ic.Geom.ScrollOffset()
        ic.Scene.Painter.DrawImage(ic.pixels, r, sp, draw.Over)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "io/fs"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
        "golang.org/x/image/draw"
)

// Image is a widget that renders an [image.Image].
// See [styles.Style.ObjectFit] to control the image rendering within
// the allocated size. The default minimum requested size is the pixel
// size in [units.Dp] units (1/160th of an inch).
type Image struct {
        WidgetBase

        // Image is the [image.Image].
        Image image.Image `xml:"-" json:"-"`

        // prevImage is the cached last [Image.Image].
        prevImage image.Image

        // prevRenderImage is the cached last rendered image with any transformations applied.
        prevRenderImage image.Image

        // prevObjectFit is the cached [styles.Style.ObjectFit] of the last rendered image.
        prevObjectFit styles.ObjectFits

        // prevSize is the cached allocated size for the last rendered image.
        prevSize math32.Vector2
}

func (im *Image) WidgetValue() any { return &im.Image }

func (im *Image) Init() {
        im.WidgetBase.Init()
        im.Styler(func(s *styles.Style) {
                s.ObjectFit = styles.FitContain
                if im.Image != nil {
                        sz := im.Image.Bounds().Size()
                        s.Min.X.SetCustom(func(uc *units.Context) float32 {
                                return min(uc.Dp(float32(sz.X)), uc.Pw(95))
                        })
                        s.Min.Y.Dp(float32(sz.Y))
                }
        })
}

// Open sets the image to the image located at the given filename.
func (im *Image) Open(filename Filename) error { //types:add
        img, _, err := imagex.Open(string(filename))
        if err != nil {
                return err
        }
        im.SetImage(img)
        return nil
}

// OpenFS sets the image to the image located at the given filename in the given fs.
func (im *Image) OpenFS(fsys fs.FS, filename string) error {
        img, _, err := imagex.OpenFS(fsys, filename)
        if err != nil {
                return err
        }
        im.SetImage(img)
        return nil
}

func (im *Image) SizeUp() {
        im.WidgetBase.SizeUp()
        if im.Image != nil {
                sz := &im.Geom.Size
                obj := math32.FromPoint(im.Image.Bounds().Size())
                osz := styles.ObjectSizeFromFit(im.Styles.ObjectFit, obj, sz.Actual.Content)
                sz.Actual.Content = osz
                sz.setTotalFromContent(&sz.Actual)
        }
}

func (im *Image) Render() {
        im.WidgetBase.Render()

        if im.Image == nil {
                return
        }
        r := im.Geom.ContentBBox
        if r == (image.Rectangle{}) || im.Image.Bounds().Size() == (image.Point{}) {
                return
        }
        sp := im.Geom.ScrollOffset()

        var rimg image.Image
        if im.prevImage == im.Image && im.Styles.ObjectFit == im.prevObjectFit && im.Geom.Size.Actual.Content == im.prevSize {
                rimg = im.prevRenderImage
        } else {
                im.prevImage = im.Image
                im.prevObjectFit = im.Styles.ObjectFit
                im.prevSize = im.Geom.Size.Actual.Content
                rimg = imagex.WrapJS(im.Styles.ResizeImage(im.Image, im.Geom.Size.Actual.Content))
                im.prevRenderImage = rimg
        }
        im.Scene.Painter.DrawImage(rimg, r, sp, draw.Over)
}

func (im *Image) MakeToolbar(p *tree.Plan) {
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(im.Open).SetIcon(icons.Open)
        })
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/system"
)

func init() {
        system.HandleRecover = handleRecover
        system.InitScreenLogicalDPIFunc = AppearanceSettings.applyDPI // called when screens are initialized
        TheApp.CogentCoreDataDir()                                    // ensure it exists
        theWindowGeometrySaver.needToReload()                         // gets time stamp associated with open, so it doesn't re-open
        theWindowGeometrySaver.open()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "reflect"
        "strconv"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/tree"
)

// InlineList represents a slice within a single line of value widgets.
// This is typically used for smaller slices.
type InlineList struct {
        Frame

        // Slice is the slice that we are viewing.
        Slice any `set:"-"`

        // isArray is whether the slice is actually an array.
        isArray bool
}

func (il *InlineList) WidgetValue() any { return &il.Slice }

func (il *InlineList) Init() {
        il.Frame.Init()
        il.Maker(func(p *tree.Plan) {
                sl := reflectx.Underlying(reflect.ValueOf(il.Slice))

                sz := min(sl.Len(), SystemSettings.SliceInlineLength)
                for i := 0; i < sz; i++ {
                        itxt := strconv.Itoa(i)
                        tree.AddNew(p, "value-"+itxt, func() Value {
                                val := reflectx.UnderlyingPointer(sl.Index(i))
                                return NewValue(val.Interface(), "")
                        }, func(w Value) {
                                wb := w.AsWidget()
                                wb.OnChange(func(e events.Event) { il.SendChange() })
                                wb.OnInput(func(e events.Event) {
                                        il.Send(events.Input, e)
                                })
                                if il.IsReadOnly() {
                                        wb.SetReadOnly(true)
                                } else {
                                        wb.AddContextMenu(func(m *Scene) {
                                                il.contextMenu(m, i)
                                        })
                                }
                                wb.Updater(func() {
                                        // We need to get the current value each time:
                                        sl := reflectx.Underlying(reflect.ValueOf(il.Slice))
                                        val := reflectx.UnderlyingPointer(sl.Index(i))
                                        Bind(val.Interface(), w)
                                        wb.SetReadOnly(il.IsReadOnly())
                                })
                        })
                }
                if !il.isArray && !il.IsReadOnly() {
                        tree.AddAt(p, "add-button", func(w *Button) {
                                w.SetIcon(icons.Add).SetType(ButtonTonal)
                                w.Tooltip = "Add an element to the list"
                                w.OnClick(func(e events.Event) {
                                        il.NewAt(-1)
                                })
                        })
                }
        })
}

// SetSlice sets the source slice that we are viewing.
// It rebuilds the children to represent this slice.
func (il *InlineList) SetSlice(sl any) *InlineList {
        if reflectx.IsNil(reflect.ValueOf(sl)) {
                il.Slice = nil
                return il
        }
        newslc := false
        if reflect.TypeOf(sl).Kind() != reflect.Pointer { // prevent crash on non-comparable
                newslc = true
        } else {
                newslc = il.Slice != sl
        }
        if newslc {
                il.Slice = sl
                il.isArray = reflectx.NonPointerType(reflect.TypeOf(sl)).Kind() == reflect.Array
                il.Update()
        }
        return il
}

// NewAt inserts a new blank element at the given index in the slice.
// -1 indicates to insert the element at the end.
func (il *InlineList) NewAt(idx int) {
        if il.isArray {
                return
        }
        reflectx.SliceNewAt(il.Slice, idx)
        il.UpdateChange()
}

// DeleteAt deletes the element at the given index from the slice.
func (il *InlineList) DeleteAt(idx int) {
        if il.isArray {
                return
        }
        reflectx.SliceDeleteAt(il.Slice, idx)
        il.UpdateChange()
}

func (il *InlineList) contextMenu(m *Scene, idx int) {
        if il.IsReadOnly() || il.isArray {
                return
        }
        NewButton(m).SetText("Add").SetIcon(icons.Add).OnClick(func(e events.Event) {
                il.NewAt(idx)
        })
        NewButton(m).SetText("Delete").SetIcon(icons.Delete).OnClick(func(e events.Event) {
                il.DeleteAt(idx)
        })
        NewButton(m).SetText("Open in dialog").SetIcon(icons.OpenInNew).OnClick(func(e events.Event) {
                d := NewBody(il.ValueTitle)
                NewText(d).SetType(TextSupporting).SetText(il.Tooltip)
                NewList(d).SetSlice(il.Slice).SetValueTitle(il.ValueTitle).SetReadOnly(il.IsReadOnly())
                d.OnClose(func(e events.Event) {
                        il.UpdateChange()
                })
                d.RunFullDialog(il)
        })
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "reflect"

        "cogentcore.org/core/base/iox/jsonx"
        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/tree"
)

// Inspector represents a [tree.Node] with a [Tree] and a [Form].
type Inspector struct {
        Frame

        // Root is the root of the tree being edited.
        Root tree.Node

        // currentNode is the currently selected node in the tree.
        currentNode tree.Node

        // filename is the current filename for saving / loading
        filename Filename

        treeWidget *Tree
}

func (is *Inspector) Init() {
        is.Frame.Init()
        is.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 1)
                s.Direction = styles.Column
        })

        var titleWidget *Text
        tree.AddChildAt(is, "title", func(w *Text) {
                titleWidget = w
                is.currentNode = is.Root
                w.SetType(TextHeadlineSmall)
                w.Styler(func(s *styles.Style) {
                        s.Grow.Set(1, 0)
                        s.Align.Self = styles.Center
                })
                w.Updater(func() {
                        w.SetText(fmt.Sprintf("Inspector of %s (%s)", is.currentNode.AsTree().Name, labels.FriendlyTypeName(reflect.TypeOf(is.currentNode))))
                })
        })
        renderRebuild := func() {
                sc, ok := is.Root.(*Scene)
                if !ok {
                        return
                }
                sc.renderContext().rebuild = true // trigger full rebuild
        }
        tree.AddChildAt(is, "splits", func(w *Splits) {
                w.SetSplits(.3, .7)
                var form *Form
                tree.AddChildAt(w, "tree-frame", func(w *Frame) {
                        w.Styler(func(s *styles.Style) {
                                s.Background = colors.Scheme.SurfaceContainerLow
                                s.Direction = styles.Column
                                s.Overflow.Set(styles.OverflowAuto)
                                s.Gap.Zero()
                        })
                        tree.AddChildAt(w, "tree", func(w *Tree) {
                                is.treeWidget = w
                                w.SetTreeInit(func(tr *Tree) {
                                        tr.Styler(func(s *styles.Style) {
                                                s.Max.X.Em(20)
                                        })
                                })
                                w.OnSelect(func(e events.Event) {
                                        if len(w.SelectedNodes) == 0 {
                                                return
                                        }
                                        sn := w.SelectedNodes[0].AsCoreTree().SyncNode
                                        is.currentNode = sn
                                        // Note: doing Update on the entire inspector reverts all tree expansion,
                                        // so we only want to update the title and form
                                        titleWidget.Update()
                                        form.SetStruct(sn).Update()

                                        sc, ok := is.Root.(*Scene)
                                        if !ok {
                                                return
                                        }
                                        if wb := AsWidget(sn); wb != nil {
                                                pselw := sc.selectedWidget
                                                sc.selectedWidget = sn.(Widget)
                                                wb.NeedsRender()
                                                if pselw != nil {
                                                        pselw.AsWidget().NeedsRender()
                                                }
                                        }
                                })
                                w.OnChange(func(e events.Event) {
                                        renderRebuild()
                                })
                                w.SyncTree(is.Root)
                        })
                })
                tree.AddChildAt(w, "struct", func(w *Form) {
                        form = w
                        w.OnChange(func(e events.Event) {
                                renderRebuild()
                        })
                        w.OnClose(func(e events.Event) {
                                sc, ok := is.Root.(*Scene)
                                if !ok {
                                        return
                                }
                                if sc.renderBBoxes {
                                        is.toggleSelectionMode()
                                }
                                pselw := sc.selectedWidget
                                sc.selectedWidget = nil
                                if pselw != nil {
                                        pselw.AsWidget().NeedsRender()
                                }
                        })
                        w.Updater(func() {
                                w.SetStruct(is.currentNode)
                        })
                })
        })
}

// save saves the tree to current filename, in a standard JSON-formatted file.
func (is *Inspector) save() error { //types:add
        if is.Root == nil {
                return nil
        }
        if is.filename == "" {
                return nil
        }

        err := jsonx.Save(is.Root, string(is.filename))
        if err != nil {
                return err
        }
        return nil
}

// saveAs saves tree to given filename, in a standard JSON-formatted file
func (is *Inspector) saveAs(filename Filename) error { //types:add
        if is.Root == nil {
                return nil
        }
        err := jsonx.Save(is.Root, string(filename))
        if err != nil {
                return err
        }
        is.filename = filename
        is.NeedsRender() // notify our editor
        return nil
}

// open opens tree from given filename, in a standard JSON-formatted file
func (is *Inspector) open(filename Filename) error { //types:add
        if is.Root == nil {
                return nil
        }
        err := jsonx.Open(is.Root, string(filename))
        if err != nil {
                return err
        }
        is.filename = filename
        is.NeedsRender() // notify our editor
        return nil
}

// toggleSelectionMode toggles the editor between selection mode or not.
// In selection mode, bounding boxes are rendered around each Widget,
// and clicking on a Widget pulls it up in the inspector.
func (is *Inspector) toggleSelectionMode() { //types:add
        sc, ok := is.Root.(*Scene)
        if !ok {
                return
        }
        sc.renderBBoxes = !sc.renderBBoxes
        if sc.renderBBoxes {
                sc.selectedWidgetChan = make(chan Widget)
                go is.selectionMonitor()
        } else {
                if sc.selectedWidgetChan != nil {
                        close(sc.selectedWidgetChan)
                }
                sc.selectedWidgetChan = nil
        }
        sc.NeedsLayout()
}

// selectionMonitor monitors for the selected widget
func (is *Inspector) selectionMonitor() {
        sc, ok := is.Root.(*Scene)
        if !ok {
                return
        }
        sc.Stage.raise()
        sw, ok := <-sc.selectedWidgetChan
        if !ok || sw == nil {
                return
        }
        tv := is.treeWidget.FindSyncNode(sw)
        if tv == nil {
                // if we can't be found, we are probably a part,
                // so we keep going up until we find somebody in
                // the tree
                sw.AsTree().WalkUpParent(func(k tree.Node) bool {
                        tv = is.treeWidget.FindSyncNode(k)
                        if tv != nil {
                                return tree.Break
                        }
                        return tree.Continue
                })
                if tv == nil {
                        MessageSnackbar(is, fmt.Sprintf("Inspector: tree node missing: %v", sw))
                        return
                }
        }
        is.AsyncLock() // coming from other tree
        tv.OpenParents()
        tv.SelectEvent(events.SelectOne)
        tv.ScrollToThis()
        is.AsyncUnlock()
        is.Scene.Stage.raise()

        sc.AsyncLock()
        sc.renderBBoxes = false
        if sc.selectedWidgetChan != nil {
                close(sc.selectedWidgetChan)
        }
        sc.selectedWidgetChan = nil
        sc.NeedsRender()
        sc.AsyncUnlock()
}

// inspectApp displays [TheApp].
func (is *Inspector) inspectApp() { //types:add
        d := NewBody("Inspect app")
        NewForm(d).SetStruct(TheApp).SetReadOnly(true)
        d.RunFullDialog(is)
}

func (is *Inspector) MakeToolbar(p *tree.Plan) {
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(is.toggleSelectionMode).SetText("Select element").SetIcon(icons.ArrowSelectorTool)
                w.Updater(func() {
                        _, ok := is.Root.(*Scene)
                        w.SetEnabled(ok)
                })
        })
        tree.Add(p, func(w *Separator) {})
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(is.open).SetIcon(icons.Open).SetKey(keymap.Open)
                w.Args[0].SetValue(is.filename).SetTag(`extension:".json"`)
        })
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(is.save).SetIcon(icons.Save).SetKey(keymap.Save)
                w.Updater(func() {
                        w.SetEnabled(is.filename != "")
                })
        })
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(is.saveAs).SetIcon(icons.SaveAs).SetKey(keymap.SaveAs)
                w.Args[0].SetValue(is.filename).SetTag(`extension:".json"`)
        })
        tree.Add(p, func(w *Separator) {})
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(is.inspectApp).SetIcon(icons.Devices)
        })
}

// InspectorWindow opens an interactive editor of the given tree
// in a new window.
func InspectorWindow(n tree.Node) {
        if RecycleMainWindow(n) {
                return
        }
        d := NewBody("Inspector")
        makeInspector(d, n)
        d.RunWindow()
}

// makeInspector configures the given body to have an interactive inspector
// of the given tree.
func makeInspector(b *Body, n tree.Node) {
        b.SetTitle("Inspector").SetData(n)
        if n != nil {
                b.Name += "-" + n.AsTree().Name
                b.Title += ": " + n.AsTree().Name
        }
        is := NewInspector(b)
        is.SetRoot(n)
        b.AddTopBar(func(bar *Frame) {
                NewToolbar(bar).Maker(is.MakeToolbar)
        })
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles/states"
)

// KeyMapButton represents a [keymap.MapName] value with a button.
type KeyMapButton struct {
        Button
        MapName keymap.MapName
}

func (km *KeyMapButton) WidgetValue() any { return &km.MapName }

func (km *KeyMapButton) Init() {
        km.Button.Init()
        km.SetType(ButtonTonal)
        km.Updater(func() {
                km.SetText(string(km.MapName))
        })
        InitValueButton(km, false, func(d *Body) {
                d.SetTitle("Select a key map")
                si := 0
                _, curRow, _ := keymap.AvailableMaps.MapByName(km.MapName)
                tv := NewTable(d).SetSlice(&keymap.AvailableMaps).SetSelectedIndex(curRow).BindSelect(&si)
                tv.OnChange(func(e events.Event) {
                        name := keymap.AvailableMaps[si]
                        km.MapName = keymap.MapName(name.Name)
                })
        })
}

// KeyChordButton represents a [key.Chord] value with a button.
type KeyChordButton struct {
        Button
        Chord key.Chord
}

func (kc *KeyChordButton) WidgetValue() any { return &kc.Chord }

func (kc *KeyChordButton) Init() {
        kc.Button.Init()
        kc.SetType(ButtonTonal)
        kc.OnKeyChord(func(e events.Event) {
                if !kc.StateIs(states.Focused) {
                        return
                }
                kc.Chord = e.KeyChord()
                e.SetHandled()
                kc.UpdateChange()
        })
        kc.Updater(func() {
                kc.SetText(kc.Chord.Label())
        })
        kc.AddContextMenu(func(m *Scene) {
                NewButton(m).SetText("Clear").SetIcon(icons.ClearAll).OnClick(func(e events.Event) {
                        kc.Chord = ""
                        kc.UpdateChange()
                })
        })
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "reflect"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

// KeyedList represents a map value using two columns of editable key and value widgets.
type KeyedList struct {
        Frame

        // Map is the pointer to the map that we are viewing.
        Map any

        // Inline is whether to display the map in one line.
        Inline bool

        // SortByValues is whether to sort by values instead of keys.
        SortByValues bool

        // ncols is the number of columns to display if the keyed list is not inline.
        ncols int
}

func (kl *KeyedList) WidgetValue() any { return &kl.Map }

func (kl *KeyedList) Init() {
        kl.Frame.Init()
        kl.Styler(func(s *styles.Style) {
                if kl.Inline {
                        return
                }
                s.Display = styles.Grid
                s.Columns = kl.ncols
                s.Overflow.Set(styles.OverflowAuto)
                s.Grow.Set(1, 1)
                s.Min.X.Em(20)
                s.Min.Y.Em(10)
        })

        kl.Maker(func(p *tree.Plan) {
                mapv := reflectx.Underlying(reflect.ValueOf(kl.Map))
                if reflectx.IsNil(mapv) {
                        return
                }

                kl.ncols = 2
                typeAny := false
                valueType := mapv.Type().Elem()
                if valueType.String() == "interface {}" {
                        kl.ncols = 3
                        typeAny = true
                }

                builtinTypes := types.BuiltinTypes()

                keys := reflectx.MapSort(kl.Map, !kl.SortByValues, true)
                for _, key := range keys {
                        keytxt := reflectx.ToString(key.Interface())
                        keynm := "key-" + keytxt
                        valnm := "value-" + keytxt

                        tree.AddNew(p, keynm, func() Value {
                                return toValue(key.Interface(), "")
                        }, func(w Value) {
                                bindMapKey(mapv, key, w)
                                wb := w.AsWidget()
                                wb.SetReadOnly(kl.IsReadOnly())
                                wb.Styler(func(s *styles.Style) {
                                        s.SetReadOnly(kl.IsReadOnly())
                                        s.SetTextWrap(false)
                                })
                                wb.OnChange(func(e events.Event) {
                                        kl.UpdateChange(e)
                                })
                                wb.SetReadOnly(kl.IsReadOnly())
                                wb.OnInput(kl.HandleEvent)
                                if !kl.IsReadOnly() {
                                        wb.AddContextMenu(func(m *Scene) {
                                                kl.contextMenu(m, key)
                                        })
                                }
                                wb.Updater(func() {
                                        bindMapKey(mapv, key, w)
                                        wb.SetReadOnly(kl.IsReadOnly())
                                })
                        })
                        tree.AddNew(p, valnm, func() Value {
                                val := mapv.MapIndex(key).Interface()
                                w := toValue(val, "")
                                return bindMapValue(mapv, key, w)
                        }, func(w Value) {
                                wb := w.AsWidget()
                                wb.SetReadOnly(kl.IsReadOnly())
                                wb.OnChange(func(e events.Event) { kl.SendChange(e) })
                                wb.OnInput(kl.HandleEvent)
                                wb.Styler(func(s *styles.Style) {
                                        s.SetReadOnly(kl.IsReadOnly())
                                        s.SetTextWrap(false)
                                })
                                if !kl.IsReadOnly() {
                                        wb.AddContextMenu(func(m *Scene) {
                                                kl.contextMenu(m, key)
                                        })
                                }
                                wb.Updater(func() {
                                        bindMapValue(mapv, key, w)
                                        wb.SetReadOnly(kl.IsReadOnly())
                                })
                        })

                        if typeAny {
                                typnm := "type-" + keytxt
                                tree.AddAt(p, typnm, func(w *Chooser) {
                                        w.SetTypes(builtinTypes...)
                                        w.OnChange(func(e events.Event) {
                                                typ := reflect.TypeOf(w.CurrentItem.Value.(*types.Type).Instance)
                                                newVal := reflect.New(typ)
                                                // try our best to convert the existing value to the new type
                                                reflectx.SetRobust(newVal.Interface(), mapv.MapIndex(key).Interface())
                                                mapv.SetMapIndex(key, newVal.Elem())
                                                kl.DeleteChildByName(valnm) // force it to be updated
                                                kl.Update()
                                        })
                                        w.Updater(func() {
                                                w.SetReadOnly(kl.IsReadOnly())
                                                vtyp := types.TypeByValue(mapv.MapIndex(key).Interface())
                                                if vtyp == nil {
                                                        vtyp = types.TypeByName("string") // default to string
                                                }
                                                w.SetCurrentValue(vtyp)
                                        })
                                })
                        }
                }
                if kl.Inline && !kl.IsReadOnly() {
                        tree.AddAt(p, "add-button", func(w *Button) {
                                w.SetIcon(icons.Add).SetType(ButtonTonal)
                                w.Tooltip = "Add an element"
                                w.OnClick(func(e events.Event) {
                                        kl.AddItem()
                                })
                        })
                }
        })
}

func (kl *KeyedList) contextMenu(m *Scene, keyv reflect.Value) {
        if kl.IsReadOnly() {
                return
        }
        NewButton(m).SetText("Add").SetIcon(icons.Add).OnClick(func(e events.Event) {
                kl.AddItem()
        })
        NewButton(m).SetText("Delete").SetIcon(icons.Delete).OnClick(func(e events.Event) {
                kl.DeleteItem(keyv)
        })
        if kl.Inline {
                NewButton(m).SetText("Open in dialog").SetIcon(icons.OpenInNew).OnClick(func(e events.Event) {
                        d := NewBody(kl.ValueTitle)
                        NewText(d).SetType(TextSupporting).SetText(kl.Tooltip)
                        NewKeyedList(d).SetMap(kl.Map).SetValueTitle(kl.ValueTitle).SetReadOnly(kl.IsReadOnly())
                        d.OnClose(func(e events.Event) {
                                kl.UpdateChange(e)
                        })
                        d.RunFullDialog(kl)
                })
        }
}

// toggleSort toggles sorting by values vs. keys
func (kl *KeyedList) toggleSort() {
        kl.SortByValues = !kl.SortByValues
        kl.Update()
}

// AddItem adds a new key-value item to the map.
func (kl *KeyedList) AddItem() {
        if reflectx.IsNil(reflect.ValueOf(kl.Map)) {
                return
        }
        reflectx.MapAdd(kl.Map)
        kl.UpdateChange()
}

// DeleteItem deletes a key-value item from the map.
func (kl *KeyedList) DeleteItem(key reflect.Value) {
        if reflectx.IsNil(reflect.ValueOf(kl.Map)) {
                return
        }
        reflectx.MapDelete(kl.Map, reflectx.NonPointerValue(key))
        kl.UpdateChange()
}

func (kl *KeyedList) MakeToolbar(p *tree.Plan) {
        if reflectx.IsNil(reflect.ValueOf(kl.Map)) {
                return
        }
        tree.Add(p, func(w *Button) {
                w.SetText("Sort").SetIcon(icons.Sort).SetTooltip("Switch between sorting by the keys and the values").
                        OnClick(func(e events.Event) {
                                kl.toggleSort()
                        })
        })
        if !kl.IsReadOnly() {
                tree.Add(p, func(w *Button) {
                        w.SetText("Add").SetIcon(icons.Add).SetTooltip("Add a new element to the map").
                                OnClick(func(e events.Event) {
                                        kl.AddItem()
                                })
                })
        }
}

// bindMapKey is a version of [Bind] that works for keys in a map.
func bindMapKey[T Value](mapv reflect.Value, key reflect.Value, vw T) T {
        wb := vw.AsWidget()
        alreadyBound := wb.ValueUpdate != nil
        wb.ValueUpdate = func() {
                if vws, ok := any(vw).(ValueSetter); ok {
                        ErrorSnackbar(vw, vws.SetWidgetValue(key.Interface()))
                } else {
                        ErrorSnackbar(vw, reflectx.SetRobust(vw.WidgetValue(), key.Interface()))
                }
        }
        wb.ValueOnChange = func() {
                newKey := reflect.New(key.Type())
                ErrorSnackbar(vw, reflectx.SetRobust(newKey.Interface(), vw.WidgetValue()))
                newKey = newKey.Elem()
                if !mapv.MapIndex(newKey).IsValid() { // not already taken
                        mapv.SetMapIndex(newKey, mapv.MapIndex(key))
                        mapv.SetMapIndex(key, reflect.Value{})
                        return
                }
                d := NewBody("Key already exists")
                NewText(d).SetType(TextSupporting).SetText(fmt.Sprintf("The key %q already exists", reflectx.ToString(newKey.Interface())))
                d.AddBottomBar(func(bar *Frame) {
                        d.AddCancel(bar)
                        d.AddOK(bar).SetText("Overwrite").OnClick(func(e events.Event) {
                                mapv.SetMapIndex(newKey, mapv.MapIndex(key))
                                mapv.SetMapIndex(key, reflect.Value{})
                                wb.SendChange()
                        })
                })
                d.RunDialog(vw)
        }
        if alreadyBound {
                ResetWidgetValue(vw)
        }
        if ob, ok := any(vw).(OnBinder); ok {
                ob.OnBind(key.Interface(), "")
        }
        wb.ValueUpdate() // we update it with the initial value immediately
        return vw
}

// bindMapValue is a version of [Bind] that works for values in a map.
func bindMapValue[T Value](mapv reflect.Value, key reflect.Value, vw T) T {
        wb := vw.AsWidget()
        alreadyBound := wb.ValueUpdate != nil
        wb.ValueUpdate = func() {
                value := mapv.MapIndex(key).Interface()
                if vws, ok := any(vw).(ValueSetter); ok {
                        ErrorSnackbar(vw, vws.SetWidgetValue(value))
                } else {
                        ErrorSnackbar(vw, reflectx.SetRobust(vw.WidgetValue(), value))
                }
        }
        wb.ValueOnChange = func() {
                value := reflectx.NonNilNew(mapv.Type().Elem())
                err := reflectx.SetRobust(value.Interface(), vw.WidgetValue())
                if err != nil {
                        ErrorSnackbar(vw, err)
                        return
                }
                mapv.SetMapIndex(key, value.Elem())
        }
        if alreadyBound {
                ResetWidgetValue(vw)
        }
        if ob, ok := any(vw).(OnBinder); ok {
                value := mapv.MapIndex(key).Interface()
                ob.OnBind(value, "")
        }
        wb.ValueUpdate() // we update it with the initial value immediately
        return vw
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "log/slog"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// Layout uses 3 Size passes, 2 Position passes:
//
// SizeUp: (bottom-up) gathers Actual sizes from our Children & Parts,
// based on Styles.Min / Max sizes and actual content sizing
// (e.g., text size).  Flexible elements (e.g., [Text], Flex Wrap,
// [Toolbar]) should reserve the _minimum_ size possible at this stage,
// and then Grow based on SizeDown allocation.

// SizeDown: (top-down, multiple iterations possible) provides top-down
// size allocations based initially on Scene available size and
// the SizeUp Actual sizes.  If there is extra space available, it is
// allocated according to the Grow factors.
// Flexible elements (e.g., Flex Wrap layouts and Text with word wrap)
// update their Actual size based on available Alloc size (re-wrap),
// to fit the allocated shape vs. the initial bottom-up guess.
// However, do NOT grow the Actual size to match Alloc at this stage,
// as Actual sizes must always represent the minimums (see Position).
// Returns true if any change in Actual size occurred.

// SizeFinal: (bottom-up) similar to SizeUp but done at the end of the
// Sizing phase: first grows widget Actual sizes based on their Grow
// factors, up to their Alloc sizes.  Then gathers this updated final
// actual Size information for layouts to register their actual sizes
// prior to positioning, which requires accurate Actual vs. Alloc
// sizes to perform correct alignment calculations.

// Position: uses the final sizes to set relative positions within layouts
// according to alignment settings, and Grow elements to their actual
// Alloc size per Styles settings and widget-specific behavior.

// ScenePos: computes scene-based absolute positions and final BBox
// bounding boxes for rendering, based on relative positions from
// Position step and parents accumulated position and scroll offset.
// This is the only step needed when scrolling (very fast).

// (Text) Wrapping key principles:
// * Using a heuristic initial box based on expected text area from length
//   of Text and aspect ratio based on styled size to get initial layout size.
//   This avoids extremes of all horizontal or all vertical initial layouts.
// * Use full Alloc for SizeDown to allocate for what has been reserved.
// * Set Actual to what you actually use (key: start with only styled
//   so you don't get hysterisis)
// * Layout always re-gets the actuals for accurate Actual sizing

// Scroll areas are similar: don't request anything more than Min reservation
// and then expand to Alloc in Final.

// Note that it is critical to not actually change any bottom-up Actual
// sizing based on the Alloc, during the SizeDown process, as this will
// introduce false constraints on the process: only work with minimum
// Actual "hard" constraints to make sure those are satisfied.  Text
// and Wrap elements resize only enough to fit within the Alloc space
// to the extent possible, but do not Grow.
//
// The separate SizeFinal step then finally allows elements to grow
// into their final Alloc space, once all the constraints are satisfied.
//
// This overall top-down / bottom-up logic is used in Flutter:
// https://docs.flutter.dev/resources/architectural-overview#rendering-and-layout
// Here's more links to other layout algorithms:
// https://stackoverflow.com/questions/53911631/gui-layout-algorithms-overview

// LayoutPasses is used for the SizeFromChildren method,
// which can potentially compute different sizes for different passes.
type LayoutPasses int32 //enums:enum

const (
        SizeUpPass LayoutPasses = iota
        SizeDownPass
        SizeFinalPass
)

// Layouter is an interface containing layout functions
// implemented by all types embedding [Frame].
type Layouter interface {
        Widget

        // AsFrame returns the Layouter as a [Frame].
        AsFrame() *Frame

        // LayoutSpace sets our Space based on Styles, Scroll, and Gap Spacing.
        // Other layout types can change this if they want to.
        LayoutSpace()

        // SizeFromChildren gathers Actual size from kids into our Actual.Content size.
        // Different Layout types can alter this to present different Content
        // sizes for the layout process, e.g., if Content is sized to fit allocation,
        // as in the [Toolbar] and [List] types.
        SizeFromChildren(iter int, pass LayoutPasses) math32.Vector2

        // SizeDownSetAllocs is the key SizeDown step that sets the allocations
        // in the children, based on our allocation.  In the default implementation
        // this calls SizeDownGrow if there is extra space to grow, or
        // SizeDownAllocActual to set the allocations as they currently are.
        SizeDownSetAllocs(iter int)

        // ManageOverflow uses overflow settings to determine if scrollbars
        // are needed, based on difference between ActualOverflow (full actual size)
        // and Alloc allocation.  Returns true if size changes as a result.
        // If updateSize is false, then the Actual and Alloc sizes are NOT
        // updated as a result of change from adding scrollbars
        // (generally should be true, but some cases not)
        ManageOverflow(iter int, updateSize bool) bool

        // ScrollChanged is called in the OnInput event handler for updating
        // when the scrollbar value has changed, for given dimension
        ScrollChanged(d math32.Dims, sb *Slider)

        // ScrollValues returns the maximum size that could be scrolled,
        // the visible size (which could be less than the max size, in which
        // case no scrollbar is needed), and visSize / maxSize as the VisiblePct.
        // This is used in updating the scrollbar and determining whether one is
        // needed in the first place
        ScrollValues(d math32.Dims) (maxSize, visSize, visPct float32)

        // ScrollGeom returns the target position and size for scrollbars
        ScrollGeom(d math32.Dims) (pos, sz math32.Vector2)

        // SetScrollParams sets scrollbar parameters.  Must set Step and PageStep,
        // but can also set others as needed.
        // Max and VisiblePct are automatically set based on ScrollValues maxSize, visPct.
        SetScrollParams(d math32.Dims, sb *Slider)
}

// AsFrame returns the given value as a [Frame] if it implements [Layouter]
// or nil otherwise.
func AsFrame(n tree.Node) *Frame {
        if t, ok := n.(Layouter); ok {
                return t.AsFrame()
        }
        return nil
}

func (t *Frame) AsFrame() *Frame {
        return t
}

var _ Layouter = &Frame{}

// geomCT has core layout elements: Content and Total
type geomCT struct {
        // Content is for the contents (children, parts) of the widget,
        // excluding the Space (margin, padding, scrollbars).
        // This content includes the InnerSpace factor (Gaps in Layout)
        // which must therefore be subtracted when allocating down to children.
        Content math32.Vector2

        // Total is for the total exterior of the widget: Content + Space
        Total math32.Vector2
}

func (ct geomCT) String() string {
        return fmt.Sprintf("Content: %v, \tTotal: %v", ct.Content, ct.Total)
}

// geomSize has all of the relevant Layout sizes
type geomSize struct {
        // Actual is the actual size for the purposes of rendering, representing
        // the "external" demands of the widget for space from its parent.
        // This is initially the bottom-up constraint computed by SizeUp,
        // and only changes during SizeDown when wrapping elements are reshaped
        // based on allocated size, or when scrollbars are added.
        // For elements with scrollbars (OverflowAuto), the Actual size remains
        // at the initial style minimums, "absorbing" is internal size,
        // while Internal records the true size of the contents.
        // For SizeFinal, Actual size can Grow up to the final Alloc size,
        // while Internal records the actual bottom-up contents size.
        Actual geomCT `display:"inline"`

        // Alloc is the top-down allocated size, based on available visible space,
        // starting from the Scene geometry and working downward, attempting to
        // accommodate the Actual contents, and allocating extra space based on
        // Grow factors.  When Actual < Alloc, alignment factors determine positioning
        // within the allocated space.
        Alloc geomCT `display:"inline"`

        // Internal is the internal size representing the true size of all contents
        // of the widget.  This can be less than Actual.Content if widget has Grow
        // factors but its internal contents did not grow accordingly, or it can
        // be more than Actual.Content if it has scrollbars (OverflowAuto).
        // Note that this includes InnerSpace (Gap).
        Internal math32.Vector2

        // Space is the padding, total effective margin (border, shadow, etc),
        // and scrollbars that subtracts from Total size to get Content size.
        Space math32.Vector2

        // InnerSpace is total extra space that is included within the Content Size region
        // and must be subtracted from Content when passing sizes down to children.
        InnerSpace math32.Vector2

        // Min is the Styles.Min.Dots() (Ceil int) that constrains the Actual.Content size
        Min math32.Vector2

        // Max is the Styles.Max.Dots() (Ceil int) that constrains the Actual.Content size
        Max math32.Vector2
}

func (ls geomSize) String() string {
        return fmt.Sprintf("Actual: %v, \tAlloc: %v", ls.Actual, ls.Alloc)
}

// setInitContentMin sets initial Actual.Content size from given Styles.Min,
// further subject to the current Max constraint.
func (ls *geomSize) setInitContentMin(styMin math32.Vector2) {
        csz := &ls.Actual.Content
        *csz = styMin
        styles.SetClampMaxVector(csz, ls.Max)
}

// FitSizeMax increases given size to fit given fm value, subject to Max constraints
func (ls *geomSize) FitSizeMax(to *math32.Vector2, fm math32.Vector2) {
        styles.SetClampMinVector(to, fm)
        styles.SetClampMaxVector(to, ls.Max)
}

// setTotalFromContent sets the Total size as Content plus Space
func (ls *geomSize) setTotalFromContent(ct *geomCT) {
        ct.Total = ct.Content.Add(ls.Space)
}

// setContentFromTotal sets the Content from Total size,
// subtracting Space
func (ls *geomSize) setContentFromTotal(ct *geomCT) {
        ct.Content = ct.Total.Sub(ls.Space)
}

// geomState contains the the layout geometry state for each widget.
// Set by the parent Layout during the Layout process.
type geomState struct {
        // Size has sizing data for the widget: use Actual for rendering.
        // Alloc shows the potentially larger space top-down allocated.
        Size geomSize `display:"add-fields"`

        // Pos is position within the overall Scene that we render into,
        // including effects of scroll offset, for both Total outer dimension
        // and inner Content dimension.
        Pos geomCT `display:"inline" edit:"-" copier:"-" json:"-" xml:"-" set:"-"`

        // Cell is the logical X, Y index coordinates (col, row) of element
        // within its parent layout
        Cell image.Point

        // RelPos is top, left position relative to parent Content size space
        RelPos math32.Vector2

        // Scroll is additional scrolling offset within our parent layout
        Scroll math32.Vector2

        // 2D bounding box for Actual.Total size occupied within parent Scene
        // that we render onto, starting at Pos.Total and ending at Pos.Total + Size.Total.
        // These are the pixels we can draw into, intersected with parent bounding boxes
        // (empty for invisible). Used for render Bounds clipping.
        // This includes all space (margin, padding etc).
        TotalBBox image.Rectangle `edit:"-" copier:"-" json:"-" xml:"-" set:"-"`

        // 2D bounding box for our Content, which excludes our padding, margin, etc.
        // starting at Pos.Content and ending at Pos.Content + Size.Content.
        // It is intersected with parent bounding boxes.
        ContentBBox image.Rectangle `edit:"-" copier:"-" json:"-" xml:"-" set:"-"`
}

func (ls *geomState) String() string {
        return "Size: " + ls.Size.String() + "\nPos: " + ls.Pos.String() + "\tCell: " + ls.Cell.String() +
                "\tRelPos: " + ls.RelPos.String() + "\tScroll: " + ls.Scroll.String()
}

// contentRangeDim returns the Content bounding box min, max
// along given dimension
func (ls *geomState) contentRangeDim(d math32.Dims) (cmin, cmax float32) {
        cmin = float32(math32.PointDim(ls.ContentBBox.Min, d))
        cmax = float32(math32.PointDim(ls.ContentBBox.Max, d))
        return
}

// totalRect returns Pos.Total -- Size.Actual.Total
// as an image.Rectangle, e.g., for bounding box
func (ls *geomState) totalRect() image.Rectangle {
        return math32.RectFromPosSizeMax(ls.Pos.Total, ls.Size.Actual.Total)
}

// contentRect returns Pos.Content, Size.Actual.Content
// as an image.Rectangle, e.g., for bounding box.
func (ls *geomState) contentRect() image.Rectangle {
        return math32.RectFromPosSizeMax(ls.Pos.Content, ls.Size.Actual.Content)
}

// ScrollOffset computes the net scrolling offset as a function of
// the difference between the allocated position and the actual
// content position according to the clipped bounding box.
func (ls *geomState) ScrollOffset() image.Point {
        return ls.ContentBBox.Min.Sub(ls.Pos.Content.ToPoint())
}

// layoutCell holds the layout implementation data for col, row Cells
type layoutCell struct {

        // Size has the Actual size of elements (not Alloc)
        Size math32.Vector2

        // Grow has the Grow factors
        Grow math32.Vector2
}

func (ls *layoutCell) String() string {
        return fmt.Sprintf("Size: %v, \tGrow: %g", ls.Size, ls.Grow)
}

func (ls *layoutCell) reset() {
        ls.Size.SetZero()
        ls.Grow.SetZero()
}

// layoutCells holds one set of LayoutCell cell elements for rows, cols.
// There can be multiple of these for Wrap case.
type layoutCells struct {

        // Shape is number of cells along each dimension for our ColRow cells,
        Shape image.Point `edit:"-"`

        // ColRow has the data for the columns in [0] and rows in [1]:
        // col Size.X = max(X over rows) (cross axis), .Y = sum(Y over rows) (main axis for col)
        // row Size.X = sum(X over cols) (main axis for row), .Y = max(Y over cols) (cross axis)
        // see: https://docs.google.com/spreadsheets/d/1eimUOIJLyj60so94qUr4Buzruj2ulpG5o6QwG2nyxRw/edit?usp=sharing
        ColRow [2][]layoutCell `edit:"-"`
}

// cell returns the cell for given dimension and index along that
// dimension (X = Cols, idx = col, Y = Rows, idx = row)
func (lc *layoutCells) cell(d math32.Dims, idx int) *layoutCell {
        if len(lc.ColRow[d]) <= idx {
                return nil
        }
        return &(lc.ColRow[d][idx])
}

// init initializes Cells for given shape
func (lc *layoutCells) init(shape image.Point) {
        lc.Shape = shape
        for d := math32.X; d <= math32.Y; d++ {
                n := math32.PointDim(lc.Shape, d)
                if len(lc.ColRow[d]) != n {
                        lc.ColRow[d] = make([]layoutCell, n)
                }
                for i := 0; i < n; i++ {
                        lc.ColRow[d][i].reset()
                }
        }
}

// cellsSize returns the total Size represented by the current Cells,
// which is the Sum of the Max values along each dimension.
func (lc *layoutCells) cellsSize() math32.Vector2 {
        var ksz math32.Vector2
        for ma := math32.X; ma <= math32.Y; ma++ { // main axis = X then Y
                n := math32.PointDim(lc.Shape, ma) // cols, rows
                sum := float32(0)
                for mi := 0; mi < n; mi++ {
                        md := lc.cell(ma, mi) // X, Y
                        mx := md.Size.Dim(ma)
                        sum += mx // sum of maxes
                }
                ksz.SetDim(ma, sum)
        }
        return ksz.Ceil()
}

// gapSizeDim returns the gap size for given dimension, based on Shape and given gap size
func (lc *layoutCells) gapSizeDim(d math32.Dims, gap float32) float32 {
        n := math32.PointDim(lc.Shape, d)
        return float32(n-1) * gap
}

func (lc *layoutCells) String() string {
        s := ""
        n := lc.Shape.X
        for i := 0; i < n; i++ {
                col := lc.cell(math32.X, i)
                s += fmt.Sprintln("col:", i, "\tmax X:", col.Size.X, "\tsum Y:", col.Size.Y, "\tmax grX:", col.Grow.X, "\tsum grY:", col.Grow.Y)
        }
        n = lc.Shape.Y
        for i := 0; i < n; i++ {
                row := lc.cell(math32.Y, i)
                s += fmt.Sprintln("row:", i, "\tsum X:", row.Size.X, "\tmax Y:", row.Size.Y, "\tsum grX:", row.Grow.X, "\tmax grY:", row.Grow.Y)
        }
        return s
}

// layoutState has internal state for implementing layout
type layoutState struct {
        // Shape is number of cells along each dimension,
        // computed for each layout type:
        // For Grid: Max Col, Row.
        // For Flex no Wrap: Cols,1 (X) or 1,Rows (Y).
        // For Flex Wrap: Cols,Max(Rows) or Max(Cols),Rows
        // For Stacked: 1,1
        Shape image.Point `edit:"-"`

        // MainAxis cached here from Styles, to enable Wrap-based access.
        MainAxis math32.Dims

        // Wraps is the number of actual items in each Wrap for Wrap case:
        // MainAxis X: Len = Rows, Val = Cols; MainAxis Y: Len = Cols, Val = Rows.
        // This should be nil for non-Wrap case.
        Wraps []int

        // Cells has the Actual size and Grow factor data for each of the child elements,
        // organized according to the Shape and Display type.
        // For non-Wrap, has one element in slice, with cells based on Shape.
        // For Wrap, slice is number of CrossAxis wraps allocated:
        // MainAxis X = Rows; MainAxis Y = Cols, and Cells are MainAxis layout x 1 CrossAxis.
        Cells []layoutCells `edit:"-"`

        // ScrollSize has the scrollbar sizes (widths) for each dim, which adds to Space.
        // If there is a vertical scrollbar, X has width; if horizontal, Y has "width" = height
        ScrollSize math32.Vector2

        // Gap is the Styles.Gap size
        Gap math32.Vector2

        // GapSize has the total extra gap sizing between elements, which adds to Space.
        // This depends on cell layout so it can vary for Wrap case.
        // For SizeUp / Down Gap contributes to Space like other cases,
        // but for BoundingBox rendering and Alignment, it does NOT, and must be
        // subtracted.  This happens in the Position phase.
        GapSize math32.Vector2
}

// initCells initializes the Cells based on Shape, MainAxis, and Wraps
// which must be set before calling.
func (ls *layoutState) initCells() {
        if ls.Wraps == nil {
                if len(ls.Cells) != 1 {
                        ls.Cells = make([]layoutCells, 1)
                }
                ls.Cells[0].init(ls.Shape)
                return
        }
        ma := ls.MainAxis
        ca := ma.Other()
        nw := len(ls.Wraps)
        if len(ls.Cells) != nw {
                ls.Cells = make([]layoutCells, nw)
        }
        for wi, wn := range ls.Wraps {
                var shp image.Point
                math32.SetPointDim(&shp, ma, wn)
                math32.SetPointDim(&shp, ca, 1)
                ls.Cells[wi].init(shp)
        }
}

func (ls *layoutState) shapeCheck(w Widget, phase string) bool {
        if w.AsTree().HasChildren() && (ls.Shape == (image.Point{}) || len(ls.Cells) == 0) {
                // fmt.Println(w, "Shape is nil in:", phase) // TODO: plan for this?
                return false
        }
        return true
}

// cell returns the cell for given dimension and index along that
// dimension, and given other-dimension axis which is ignored for non-Wrap cases.
// Does no range checking and will crash if out of bounds.
func (ls *layoutState) cell(d math32.Dims, dIndex, odIndex int) *layoutCell {
        if ls.Wraps == nil {
                return ls.Cells[0].cell(d, dIndex)
        }
        if ls.MainAxis == d {
                return ls.Cells[odIndex].cell(d, dIndex)
        }
        return ls.Cells[dIndex].cell(d, 0)
}

// wrapIndexToCoord returns the X,Y coordinates in Wrap case for given sequential idx
func (ls *layoutState) wrapIndexToCoord(idx int) image.Point {
        y := 0
        x := 0
        sum := 0
        if ls.MainAxis == math32.X {
                for _, nx := range ls.Wraps {
                        if idx >= sum && idx < sum+nx {
                                x = idx - sum
                                break
                        }
                        sum += nx
                        y++
                }
        } else {
                for _, ny := range ls.Wraps {
                        if idx >= sum && idx < sum+ny {
                                y = idx - sum
                                break
                        }
                        sum += ny
                        x++
                }
        }
        return image.Point{x, y}
}

// cellsSize returns the total Size represented by the current Cells,
// which is the Sum of the Max values along each dimension within each Cell,
// Maxed over cross-axis dimension for Wrap case, plus GapSize.
func (ls *layoutState) cellsSize() math32.Vector2 {
        if ls.Wraps == nil {
                return ls.Cells[0].cellsSize().Add(ls.GapSize)
        }
        var ksz math32.Vector2
        d := ls.MainAxis
        od := d.Other()
        gap := ls.Gap.Dim(d)
        for wi := range ls.Wraps {
                wsz := ls.Cells[wi].cellsSize()
                wsz.SetDim(d, wsz.Dim(d)+ls.Cells[wi].gapSizeDim(d, gap))
                if wi == 0 {
                        ksz = wsz
                } else {
                        ksz.SetDim(d, max(ksz.Dim(d), wsz.Dim(d)))
                        ksz.SetDim(od, ksz.Dim(od)+wsz.Dim(od))
                }
        }
        ksz.SetDim(od, ksz.Dim(od)+ls.GapSize.Dim(od))
        return ksz.Ceil()
}

// colWidth returns the width of given column for given row index
// (ignored for non-Wrap), with full bounds checking.
// Returns error if out of range.
func (ls *layoutState) colWidth(row, col int) (float32, error) {
        if ls.Wraps == nil {
                n := math32.PointDim(ls.Shape, math32.X)
                if col >= n {
                        return 0, fmt.Errorf("Layout.ColWidth: col: %d > number of columns: %d", col, n)
                }
                return ls.cell(math32.X, col, 0).Size.X, nil
        }
        nw := len(ls.Wraps)
        if ls.MainAxis == math32.X {
                if row >= nw {
                        return 0, fmt.Errorf("Layout.ColWidth: row: %d > number of rows: %d", row, nw)
                }
                wn := ls.Wraps[row]
                if col >= wn {
                        return 0, fmt.Errorf("Layout.ColWidth: col: %d > number of columns: %d", col, wn)
                }
                return ls.cell(math32.X, col, row).Size.X, nil
        }
        if col >= nw {
                return 0, fmt.Errorf("Layout.ColWidth: col: %d > number of columns: %d", col, nw)
        }
        wn := ls.Wraps[col]
        if row >= wn {
                return 0, fmt.Errorf("Layout.ColWidth: row: %d > number of rows: %d", row, wn)
        }
        return ls.cell(math32.X, col, row).Size.X, nil
}

// rowHeight returns the height of given row for given
// column (ignored for non-Wrap), with full bounds checking.
// Returns error if out of range.
func (ls *layoutState) rowHeight(row, col int) (float32, error) {
        if ls.Wraps == nil {
                n := math32.PointDim(ls.Shape, math32.Y)
                if row >= n {
                        return 0, fmt.Errorf("Layout.RowHeight: row: %d > number of rows: %d", row, n)
                }
                return ls.cell(math32.Y, 0, row).Size.Y, nil
        }
        nw := len(ls.Wraps)
        if ls.MainAxis == math32.Y {
                if col >= nw {
                        return 0, fmt.Errorf("Layout.RowHeight: col: %d > number of columns: %d", col, nw)
                }
                wn := ls.Wraps[row]
                if col >= wn {
                        return 0, fmt.Errorf("Layout.RowHeight: row: %d > number of rows: %d", row, wn)
                }
                return ls.cell(math32.Y, col, row).Size.Y, nil
        }
        if row >= nw {
                return 0, fmt.Errorf("Layout.RowHeight: row: %d > number of rows: %d", row, nw)
        }
        wn := ls.Wraps[col]
        if col >= wn {
                return 0, fmt.Errorf("Layout.RowHeight: col: %d > number of columns: %d", col, wn)
        }
        return ls.cell(math32.Y, row, col).Size.Y, nil
}

func (ls *layoutState) String() string {
        if ls.Wraps == nil {
                return ls.Cells[0].String()
        }
        s := ""
        ods := ls.MainAxis.Other().String()
        for wi := range ls.Wraps {
                s += fmt.Sprintf("%s: %d Shape: %v\n", ods, wi, ls.Cells[wi].Shape) + ls.Cells[wi].String()
        }
        return s
}

// StackTopWidget returns the [Frame.StackTop] element as a [WidgetBase].
func (fr *Frame) StackTopWidget() *WidgetBase {
        n := fr.Child(fr.StackTop)
        return AsWidget(n)
}

// laySetContentFitOverflow sets Internal and Actual.Content size to fit given
// new content size, depending on the Styles Overflow: Auto and Scroll types do NOT
// expand Actual and remain at their current styled actual values,
// absorbing the extra content size within their own scrolling zone
// (full size recorded in Internal).
func (fr *Frame) laySetContentFitOverflow(nsz math32.Vector2, pass LayoutPasses) {
        sz := &fr.Geom.Size
        asz := &sz.Actual.Content
        isz := &sz.Internal
        sz.setInitContentMin(sz.Min) // start from style
        *isz = nsz                   // internal is always accurate!
        oflow := &fr.Styles.Overflow
        nosz := pass == SizeUpPass && fr.Styles.IsFlexWrap()
        mx := sz.Max
        for d := math32.X; d <= math32.Y; d++ {
                if nosz {
                        continue
                }
                if !(fr.Scene != nil && fr.Scene.hasFlag(sceneContentSizing)) && oflow.Dim(d) >= styles.OverflowAuto && fr.Parent != nil {
                        if mx.Dim(d) > 0 {
                                asz.SetDim(d, styles.ClampMax(styles.ClampMin(asz.Dim(d), nsz.Dim(d)), mx.Dim(d)))
                        }
                } else {
                        asz.SetDim(d, styles.ClampMin(asz.Dim(d), nsz.Dim(d)))
                }
        }
        styles.SetClampMaxVector(asz, mx)
        sz.setTotalFromContent(&sz.Actual)
}

// SizeUp (bottom-up) gathers Actual sizes from our Children & Parts,
// based on Styles.Min / Max sizes and actual content sizing
// (e.g., text size).  Flexible elements (e.g., [Text], Flex Wrap,
// [Toolbar]) should reserve the _minimum_ size possible at this stage,
// and then Grow based on SizeDown allocation.
func (wb *WidgetBase) SizeUp() {
        wb.SizeUpWidget()
}

// SizeUpWidget is the standard Widget SizeUp pass
func (wb *WidgetBase) SizeUpWidget() {
        wb.sizeFromStyle()
        wb.sizeUpParts()
        sz := &wb.Geom.Size
        sz.setTotalFromContent(&sz.Actual)
}

// spaceFromStyle sets the Space based on Style BoxSpace().Size()
func (wb *WidgetBase) spaceFromStyle() {
        wb.Geom.Size.Space = wb.Styles.BoxSpace().Size().Ceil()
}

// sizeFromStyle sets the initial Actual Sizes from Style.Min, Max.
// Required first call in SizeUp.
func (wb *WidgetBase) sizeFromStyle() {
        sz := &wb.Geom.Size
        s := &wb.Styles
        wb.spaceFromStyle()
        wb.Geom.Size.InnerSpace.SetZero()
        sz.Min = s.Min.Dots().Ceil()
        sz.Max = s.Max.Dots().Ceil()
        if s.Min.X.Unit == units.UnitPw || s.Min.X.Unit == units.UnitPh {
                sz.Min.X = 0
        }
        if s.Min.Y.Unit == units.UnitPw || s.Min.Y.Unit == units.UnitPh {
                sz.Min.Y = 0
        }
        if s.Max.X.Unit == units.UnitPw || s.Max.X.Unit == units.UnitPh {
                sz.Max.X = 0
        }
        if s.Max.Y.Unit == units.UnitPw || s.Max.Y.Unit == units.UnitPh {
                sz.Max.Y = 0
        }
        sz.Internal.SetZero()
        sz.setInitContentMin(sz.Min)
        sz.setTotalFromContent(&sz.Actual)
        if DebugSettings.LayoutTrace && (sz.Actual.Content.X > 0 || sz.Actual.Content.Y > 0) {
                fmt.Println(wb, "SizeUp from Style:", sz.Actual.Content.String())
        }
}

// updateParentRelSizes updates any parent-relative Min, Max size values
// based on current actual parent sizes.
func (wb *WidgetBase) updateParentRelSizes() bool {
        pwb := wb.parentWidget()
        if pwb == nil {
                return false
        }
        sz := &wb.Geom.Size
        s := &wb.Styles
        psz := pwb.Geom.Size.Alloc.Content.Sub(pwb.Geom.Size.InnerSpace)
        got := false
        for d := math32.X; d <= math32.Y; d++ {
                if s.Min.Dim(d).Unit == units.UnitPw {
                        got = true
                        sz.Min.SetDim(d, psz.X*0.01*s.Min.Dim(d).Value)
                }
                if s.Min.Dim(d).Unit == units.UnitPh {
                        got = true
                        sz.Min.SetDim(d, psz.Y*0.01*s.Min.Dim(d).Value)
                }
                if s.Max.Dim(d).Unit == units.UnitPw {
                        got = true
                        sz.Max.SetDim(d, psz.X*0.01*s.Max.Dim(d).Value)
                }
                if s.Max.Dim(d).Unit == units.UnitPh {
                        got = true
                        sz.Max.SetDim(d, psz.Y*0.01*s.Max.Dim(d).Value)
                }
        }
        if got {
                sz.FitSizeMax(&sz.Actual.Total, sz.Min)
                sz.FitSizeMax(&sz.Alloc.Total, sz.Min)
                sz.setContentFromTotal(&sz.Actual)
                sz.setContentFromTotal(&sz.Alloc)
        }
        return got
}

// sizeUpParts adjusts the Content size to hold the Parts layout if present
func (wb *WidgetBase) sizeUpParts() {
        if wb.Parts == nil {
                return
        }
        wb.Parts.SizeUp()
        sz := &wb.Geom.Size
        sz.FitSizeMax(&sz.Actual.Content, wb.Parts.Geom.Size.Actual.Total)
}

func (fr *Frame) SizeUp() {
        if fr.Styles.Display == styles.Custom {
                fr.SizeUpWidget()
                fr.sizeUpChildren()
                return
        }
        if !fr.HasChildren() {
                fr.SizeUpWidget() // behave like a widget
                return
        }
        fr.sizeFromStyle()
        fr.layout.ScrollSize.SetZero() // we don't know yet
        fr.setInitCells()
        fr.This.(Layouter).LayoutSpace()
        fr.sizeUpChildren() // kids do their own thing
        fr.sizeFromChildrenFit(0, SizeUpPass)
        if fr.Parts != nil {
                fr.Parts.SizeUp() // just to get sizes -- no std role in layout
        }
}

// LayoutSpace sets our Space based on Styles and Scroll.
// Other layout types can change this if they want to.
func (fr *Frame) LayoutSpace() {
        fr.spaceFromStyle()
        fr.Geom.Size.Space.SetAdd(fr.layout.ScrollSize)
}

// sizeUpChildren calls SizeUp on all the children of this node
func (fr *Frame) sizeUpChildren() {
        if fr.Styles.Display == styles.Stacked && !fr.LayoutStackTopOnly {
                fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                        cw.SizeUp()
                        return tree.Continue
                })
                return
        }
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cw.SizeUp()
                return tree.Continue
        })
}

// setInitCells sets the initial default assignment of cell indexes
// to each widget, based on layout type.
func (fr *Frame) setInitCells() {
        switch {
        case fr.Styles.Display == styles.Flex:
                if fr.Styles.Wrap {
                        fr.setInitCellsWrap()
                } else {
                        fr.setInitCellsFlex()
                }
        case fr.Styles.Display == styles.Stacked:
                fr.setInitCellsStacked()
        case fr.Styles.Display == styles.Grid:
                fr.setInitCellsGrid()
        default:
                fr.setInitCellsStacked() // whatever
        }
        fr.layout.initCells()
        fr.setGapSizeFromCells()
        fr.layout.shapeCheck(fr, "SizeUp")
        // fmt.Println(ly, "SzUp Init", ly.Layout.Shape)
}

func (fr *Frame) setGapSizeFromCells() {
        li := &fr.layout
        li.Gap = fr.Styles.Gap.Dots().Floor()
        // note: this is not accurate for flex
        li.GapSize.X = max(float32(li.Shape.X-1)*li.Gap.X, 0)
        li.GapSize.Y = max(float32(li.Shape.Y-1)*li.Gap.Y, 0)
        fr.Geom.Size.InnerSpace = li.GapSize
}

func (fr *Frame) setInitCellsFlex() {
        li := &fr.layout
        li.MainAxis = math32.Dims(fr.Styles.Direction)
        ca := li.MainAxis.Other()
        li.Wraps = nil
        idx := 0
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                math32.SetPointDim(&cwb.Geom.Cell, li.MainAxis, idx)
                math32.SetPointDim(&cwb.Geom.Cell, ca, 0)
                idx++
                return tree.Continue
        })
        if idx == 0 {
                if DebugSettings.LayoutTrace {
                        fmt.Println(fr, "no items:", idx)
                }
        }
        math32.SetPointDim(&li.Shape, li.MainAxis, max(idx, 1)) // must be at least 1
        math32.SetPointDim(&li.Shape, ca, 1)
}

func (fr *Frame) setInitCellsWrap() {
        li := &fr.layout
        li.MainAxis = math32.Dims(fr.Styles.Direction)
        ni := 0
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                ni++
                return tree.Continue
        })
        if ni == 0 {
                li.Shape = image.Point{1, 1}
                li.Wraps = nil
                li.GapSize.SetZero()
                fr.Geom.Size.InnerSpace.SetZero()
                if DebugSettings.LayoutTrace {
                        fmt.Println(fr, "no items:", ni)
                }
                return
        }
        nm := max(int(math32.Sqrt(float32(ni))), 1)
        nc := max(ni/nm, 1)
        for nm*nc < ni {
                nm++
        }
        li.Wraps = make([]int, nc)
        sum := 0
        for i := range li.Wraps {
                n := min(ni-sum, nm)
                li.Wraps[i] = n
                sum += n
        }
        fr.setWrapIndexes()
}

// setWrapIndexes sets indexes for Wrap case
func (fr *Frame) setWrapIndexes() {
        li := &fr.layout
        idx := 0
        var maxc image.Point
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                ic := li.wrapIndexToCoord(idx)
                cwb.Geom.Cell = ic
                if ic.X > maxc.X {
                        maxc.X = ic.X
                }
                if ic.Y > maxc.Y {
                        maxc.Y = ic.Y
                }
                idx++
                return tree.Continue
        })
        maxc.X++
        maxc.Y++
        li.Shape = maxc
}

// UpdateStackedVisibility updates the visibility for Stacked layouts
// so the StackTop widget is visible, and others are Invisible.
func (fr *Frame) UpdateStackedVisibility() {
        fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cwb.SetState(i != fr.StackTop, states.Invisible)
                cwb.Geom.Cell = image.Point{0, 0}
                return tree.Continue
        })
}

func (fr *Frame) setInitCellsStacked() {
        fr.UpdateStackedVisibility()
        fr.layout.Shape = image.Point{1, 1}
}

func (fr *Frame) setInitCellsGrid() {
        n := len(fr.Children)
        cols := fr.Styles.Columns
        if cols == 0 {
                cols = int(math32.Sqrt(float32(n)))
        }
        rows := n / cols
        for rows*cols < n {
                rows++
        }
        if rows == 0 || cols == 0 {
                fmt.Println(fr, "no rows or cols:", rows, cols)
        }
        fr.layout.Shape = image.Point{max(cols, 1), max(rows, 1)}
        ci := 0
        ri := 0
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cwb.Geom.Cell = image.Point{ci, ri}
                ci++
                cs := cwb.Styles.ColSpan
                if cs > 1 {
                        ci += cs - 1
                }
                if ci >= cols {
                        ci = 0
                        ri++
                }
                return tree.Continue
        })
}

// sizeFromChildrenFit gathers Actual size from kids, and calls LaySetContentFitOverflow
// to update Actual and Internal size based on this.
func (fr *Frame) sizeFromChildrenFit(iter int, pass LayoutPasses) {
        ksz := fr.This.(Layouter).SizeFromChildren(iter, pass)
        fr.laySetContentFitOverflow(ksz, pass)
        if DebugSettings.LayoutTrace {
                sz := &fr.Geom.Size
                fmt.Println(fr, pass, "FromChildren:", ksz, "Content:", sz.Actual.Content, "Internal:", sz.Internal)
        }
}

// SizeFromChildren gathers Actual size from kids.
// Different Layout types can alter this to present different Content
// sizes for the layout process, e.g., if Content is sized to fit allocation,
// as in the [Toolbar] and [List] types.
func (fr *Frame) SizeFromChildren(iter int, pass LayoutPasses) math32.Vector2 {
        var ksz math32.Vector2
        if fr.Styles.Display == styles.Stacked {
                ksz = fr.sizeFromChildrenStacked()
        } else {
                ksz = fr.sizeFromChildrenCells(iter, pass)
        }
        return ksz
}

// sizeFromChildrenCells for Flex, Grid
func (fr *Frame) sizeFromChildrenCells(iter int, pass LayoutPasses) math32.Vector2 {
        // r   0   1   col X = max(X over rows), Y = sum(Y over rows)
        //   +--+--+
        // 0 |  |  |   row X = sum(X over cols), Y = max(Y over cols)
        //   +--+--+
        // 1 |  |  |
        //   +--+--+
        li := &fr.layout
        li.initCells()
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cidx := cwb.Geom.Cell
                sz := cwb.Geom.Size.Actual.Total
                grw := cwb.Styles.Grow
                if pass == SizeFinalPass {
                        if grw.X == 0 && !cwb.Styles.GrowWrap {
                                sz.X = cwb.Geom.Size.Alloc.Total.X
                        }
                        if grw.Y == 0 {
                                sz.Y = cwb.Geom.Size.Alloc.Total.Y
                        }
                }
                if pass <= SizeDownPass && iter == 0 && cwb.Styles.GrowWrap {
                        grw.Set(1, 0)
                }
                if DebugSettings.LayoutTraceDetail {
                        fmt.Println("SzUp i:", i, cwb, "cidx:", cidx, "sz:", sz, "grw:", grw)
                }
                for ma := math32.X; ma <= math32.Y; ma++ { // main axis = X then Y
                        ca := ma.Other()                // cross axis = Y then X
                        mi := math32.PointDim(cidx, ma) // X, Y
                        ci := math32.PointDim(cidx, ca) // Y, X

                        md := li.cell(ma, mi, ci) // X, Y
                        cd := li.cell(ca, ci, mi) // Y, X
                        if md == nil || cd == nil {
                                break
                        }
                        msz := sz.Dim(ma) // main axis size dim: X, Y
                        mx := md.Size.Dim(ma)
                        mx = max(mx, msz) // Col, max widths of all elements; Row, max heights of all elements
                        md.Size.SetDim(ma, mx)
                        sm := cd.Size.Dim(ma)
                        sm += msz
                        cd.Size.SetDim(ma, sm) // Row, sum widths of all elements; Col, sum heights of all elements
                        gsz := grw.Dim(ma)
                        mx = md.Grow.Dim(ma)
                        mx = max(mx, gsz)
                        md.Grow.SetDim(ma, mx)
                        sm = cd.Grow.Dim(ma)
                        sm += gsz
                        cd.Grow.SetDim(ma, sm)
                }
                return tree.Continue
        })
        if DebugSettings.LayoutTraceDetail {
                fmt.Println(fr, "SizeFromChildren")
                fmt.Println(li.String())
        }
        ksz := li.cellsSize()
        return ksz
}

// sizeFromChildrenStacked for stacked case
func (fr *Frame) sizeFromChildrenStacked() math32.Vector2 {
        fr.layout.initCells()
        kwb := fr.StackTopWidget()
        li := &fr.layout
        var ksz math32.Vector2
        if kwb != nil {
                ksz = kwb.Geom.Size.Actual.Total
                kgrw := kwb.Styles.Grow
                for ma := math32.X; ma <= math32.Y; ma++ { // main axis = X then Y
                        md := li.cell(ma, 0, 0)
                        md.Size = ksz
                        md.Grow = kgrw
                }
        }
        return ksz
}

// SizeDown (top-down, multiple iterations possible) provides top-down
// size allocations based initially on Scene available size and
// the SizeUp Actual sizes.  If there is extra space available, it is
// allocated according to the Grow factors.
// Flexible elements (e.g., Flex Wrap layouts and Text with word wrap)
// update their Actual size based on available Alloc size (re-wrap),
// to fit the allocated shape vs. the initial bottom-up guess.
// However, do NOT grow the Actual size to match Alloc at this stage,
// as Actual sizes must always represent the minimums (see Position).
// Returns true if any change in Actual size occurred.
func (wb *WidgetBase) SizeDown(iter int) bool {
        prel := wb.updateParentRelSizes()
        redo := wb.sizeDownParts(iter)
        return prel || redo
}

func (wb *WidgetBase) sizeDownParts(iter int) bool {
        if wb.Parts == nil {
                return false
        }
        sz := &wb.Geom.Size
        psz := &wb.Parts.Geom.Size
        pgrow, _ := wb.growToAllocSize(sz.Actual.Content, sz.Alloc.Content)
        psz.Alloc.Total = pgrow // parts = content
        psz.setContentFromTotal(&psz.Alloc)
        redo := wb.Parts.SizeDown(iter)
        if redo && DebugSettings.LayoutTrace {
                fmt.Println(wb, "Parts triggered redo")
        }
        return redo
}

// sizeDownChildren calls SizeDown on the Children.
// The kids must have their Size.Alloc set prior to this, which
// is what Layout type does.  Other special widget types can
// do custom layout and call this too.
func (wb *WidgetBase) sizeDownChildren(iter int) bool {
        redo := false
        wb.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                re := cw.SizeDown(iter)
                if re && DebugSettings.LayoutTrace {
                        fmt.Println(wb, "SizeDownChildren child:", cwb.Name, "triggered redo")
                }
                redo = redo || re
                return tree.Continue
        })
        return redo
}

// sizeDownChildren calls SizeDown on the Children.
// The kids must have their Size.Alloc set prior to this, which
// is what Layout type does.  Other special widget types can
// do custom layout and call this too.
func (fr *Frame) sizeDownChildren(iter int) bool {
        if fr.Styles.Display == styles.Stacked && !fr.LayoutStackTopOnly {
                redo := false
                fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                        re := cw.SizeDown(iter)
                        if i == fr.StackTop {
                                redo = redo || re
                        }
                        return tree.Continue
                })
                return redo
        }
        return fr.WidgetBase.sizeDownChildren(iter)
}

// growToAllocSize returns the potential size that widget could grow,
// for any dimension with a non-zero Grow factor.
// If Grow is < 1, then the size is increased in proportion, but
// any factor > 1 produces a full fill along that dimension.
// Returns true if this resulted in a change.
func (wb *WidgetBase) growToAllocSize(act, alloc math32.Vector2) (math32.Vector2, bool) {
        change := false
        for d := math32.X; d <= math32.Y; d++ {
                grw := wb.Styles.Grow.Dim(d)
                allocd := alloc.Dim(d)
                actd := act.Dim(d)
                if grw > 0 && allocd > actd {
                        grw := min(1, grw)
                        nsz := math32.Ceil(actd + grw*(allocd-actd))
                        styles.SetClampMax(&nsz, wb.Geom.Size.Max.Dim(d))
                        if nsz != actd {
                                change = true
                        }
                        act.SetDim(d, nsz)
                }
        }
        return act.Ceil(), change
}

func (fr *Frame) SizeDown(iter int) bool {
        redo := fr.sizeDownFrame(iter)
        if redo && DebugSettings.LayoutTrace {
                fmt.Println(fr, "SizeDown redo")
        }
        return redo
}

// sizeDownFrame is the [Frame] standard SizeDown pass, returning true if another
// iteration is required.  It allocates sizes to fit given parent-allocated
// total size.
func (fr *Frame) sizeDownFrame(iter int) bool {
        if fr.Styles.Display == styles.Custom {
                return fr.sizeDownCustom(iter)
        }
        if !fr.HasChildren() || !fr.layout.shapeCheck(fr, "SizeDown") {
                return fr.WidgetBase.SizeDown(iter) // behave like a widget
        }
        prel := fr.updateParentRelSizes()
        sz := &fr.Geom.Size
        styles.SetClampMaxVector(&sz.Alloc.Content, sz.Max) // can't be more than max..
        sz.setTotalFromContent(&sz.Alloc)
        if DebugSettings.LayoutTrace {
                fmt.Println(fr, "Managing Alloc:", sz.Alloc.Content)
        }
        chg := fr.This.(Layouter).ManageOverflow(iter, true) // this must go first.
        wrapped := false
        if iter <= 1 && fr.Styles.IsFlexWrap() {
                wrapped = fr.sizeDownWrap(iter) // first recompute wrap
                if iter == 0 {
                        wrapped = true // always update
                }
        }
        fr.This.(Layouter).SizeDownSetAllocs(iter)
        redo := fr.sizeDownChildren(iter)
        if prel || redo || wrapped {
                fr.sizeFromChildrenFit(iter, SizeDownPass)
        }
        fr.sizeDownParts(iter) // no std role, just get sizes
        return chg || wrapped || redo || prel
}

// SizeDownSetAllocs is the key SizeDown step that sets the allocations
// in the children, based on our allocation.  In the default implementation
// this calls SizeDownGrow if there is extra space to grow, or
// SizeDownAllocActual to set the allocations as they currrently are.
func (fr *Frame) SizeDownSetAllocs(iter int) {
        sz := &fr.Geom.Size
        extra := sz.Alloc.Content.Sub(sz.Internal) // note: critical to use internal to be accurate
        if extra.X > 0 || extra.Y > 0 {
                if DebugSettings.LayoutTrace {
                        fmt.Println(fr, "SizeDown extra:", extra, "Internal:", sz.Internal, "Alloc:", sz.Alloc.Content)
                }
                fr.sizeDownGrow(iter, extra)
        } else {
                fr.sizeDownAllocActual(iter) // set allocations as is
        }
}

// ManageOverflow uses overflow settings to determine if scrollbars
// are needed (Internal > Alloc).  Returns true if size changes as a result.
// If updateSize is false, then the Actual and Alloc sizes are NOT
// updated as a result of change from adding scrollbars
// (generally should be true, but some cases not)
func (fr *Frame) ManageOverflow(iter int, updateSize bool) bool {
        sz := &fr.Geom.Size
        sbw := math32.Ceil(fr.Styles.ScrollbarWidth.Dots)
        change := false
        if iter == 0 {
                fr.layout.ScrollSize.SetZero()
                fr.setScrollsOff()
                for d := math32.X; d <= math32.Y; d++ {
                        if fr.Styles.Overflow.Dim(d) == styles.OverflowScroll {
                                if !fr.HasScroll[d] {
                                        change = true
                                }
                                fr.HasScroll[d] = true
                                fr.layout.ScrollSize.SetDim(d.Other(), sbw)
                        }
                }
        }
        for d := math32.X; d <= math32.Y; d++ {
                maxSize, visSize, _ := fr.This.(Layouter).ScrollValues(d)
                ofd := maxSize - visSize
                switch fr.Styles.Overflow.Dim(d) {
                // case styles.OverflowVisible:
                // note: this shouldn't happen -- just have this in here for monitoring
                // fmt.Println(ly, "OverflowVisible ERROR -- shouldn't have overflow:", d, ofd)
                case styles.OverflowAuto:
                        if ofd < 0.5 {
                                if fr.HasScroll[d] {
                                        if DebugSettings.LayoutTrace {
                                                fmt.Println(fr, "turned off scroll", d)
                                        }
                                        change = true
                                        fr.HasScroll[d] = false
                                        fr.layout.ScrollSize.SetDim(d.Other(), 0)
                                }
                                continue
                        }
                        if !fr.HasScroll[d] {
                                change = true
                        }
                        fr.HasScroll[d] = true
                        fr.layout.ScrollSize.SetDim(d.Other(), sbw)
                        if change && DebugSettings.LayoutTrace {
                                fmt.Println(fr, "OverflowAuto enabling scrollbars for dim for overflow:", d, ofd, "alloc:", sz.Alloc.Content.Dim(d), "internal:", sz.Internal.Dim(d))
                        }
                }
        }
        fr.This.(Layouter).LayoutSpace() // adds the scroll space
        if updateSize {
                sz.setTotalFromContent(&sz.Actual)
                sz.setContentFromTotal(&sz.Alloc) // alloc is *decreased* from any increase in space
        }
        if change && DebugSettings.LayoutTrace {
                fmt.Println(fr, "ManageOverflow changed")
        }
        return change
}

// sizeDownGrow grows the element sizes based on total extra and Grow
func (fr *Frame) sizeDownGrow(iter int, extra math32.Vector2) bool {
        redo := false
        if fr.Styles.Display == styles.Stacked {
                redo = fr.sizeDownGrowStacked(iter, extra)
        } else {
                redo = fr.sizeDownGrowCells(iter, extra)
        }
        return redo
}

func (fr *Frame) sizeDownGrowCells(iter int, extra math32.Vector2) bool {
        redo := false
        sz := &fr.Geom.Size
        alloc := sz.Alloc.Content.Sub(sz.InnerSpace) // inner is fixed
        // todo: use max growth values instead of individual ones to ensure consistency!
        li := &fr.layout
        if len(li.Cells) == 0 {
                slog.Error("unexpected error: layout has not been initialized", "layout", fr.String())
                return false
        }
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cidx := cwb.Geom.Cell
                ksz := &cwb.Geom.Size
                grw := cwb.Styles.Grow
                if iter == 0 && cwb.Styles.GrowWrap {
                        grw.Set(1, 0)
                }
                // if DebugSettings.LayoutTrace {
                //         fmt.Println("szdn i:", i, kwb, "cidx:", cidx, "sz:", sz, "grw:", grw)
                // }
                for ma := math32.X; ma <= math32.Y; ma++ { // main axis = X then Y
                        gr := grw.Dim(ma)
                        ca := ma.Other()     // cross axis = Y then X
                        exd := extra.Dim(ma) // row.X = extra width for cols; col.Y = extra height for rows in this col
                        if exd < 0 {
                                exd = 0
                        }
                        mi := math32.PointDim(cidx, ma) // X, Y
                        ci := math32.PointDim(cidx, ca) // Y, X
                        md := li.cell(ma, mi, ci)       // X, Y
                        cd := li.cell(ca, ci, mi)       // Y, X
                        if md == nil || cd == nil {
                                break
                        }
                        mx := md.Size.Dim(ma)
                        asz := mx
                        gsum := cd.Grow.Dim(ma)
                        if gsum > 0 && exd > 0 {
                                if gr > gsum {
                                        fmt.Println(fr, "SizeDownGrowCells error: grow > grow sum:", gr, gsum)
                                        gr = gsum
                                }
                                redo = true
                                asz = math32.Round(mx + exd*(gr/gsum))
                                styles.SetClampMax(&asz, ksz.Max.Dim(ma))
                                if asz > math32.Ceil(alloc.Dim(ma))+1 { // bug!
                                        if DebugSettings.LayoutTrace {
                                                fmt.Println(fr, "SizeDownGrowCells error: sub alloc > total to alloc:", asz, alloc.Dim(ma))
                                                fmt.Println("ma:", ma, "mi:", mi, "ci:", ci, "mx:", mx, "gsum:", gsum, "gr:", gr, "ex:", exd, "par act:", sz.Actual.Content.Dim(ma))
                                                fmt.Println(fr.layout.String())
                                                fmt.Println(fr.layout.cellsSize())
                                        }
                                }
                        }
                        if DebugSettings.LayoutTraceDetail {
                                fmt.Println(cwb, ma, "alloc:", asz, "was act:", sz.Actual.Total.Dim(ma), "mx:", mx, "gsum:", gsum, "gr:", gr, "ex:", exd)
                        }
                        ksz.Alloc.Total.SetDim(ma, asz)
                }
                ksz.setContentFromTotal(&ksz.Alloc)
                return tree.Continue
        })
        return redo
}

func (fr *Frame) sizeDownWrap(iter int) bool {
        wrapped := false
        li := &fr.layout
        sz := &fr.Geom.Size
        d := li.MainAxis
        alloc := sz.Alloc.Content
        gap := li.Gap.Dim(d)
        fit := alloc.Dim(d)
        if DebugSettings.LayoutTrace {
                fmt.Println(fr, "SizeDownWrap fitting into:", d, fit)
        }
        first := true
        var sum float32
        var n int
        var wraps []int
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                ksz := cwb.Geom.Size.Actual.Total
                if first {
                        n = 1
                        sum = ksz.Dim(d) + gap
                        first = false
                        return tree.Continue
                }
                if sum+ksz.Dim(d)+gap >= fit {
                        if DebugSettings.LayoutTraceDetail {
                                fmt.Println(fr, "wrapped:", i, sum, ksz.Dim(d), fit)
                        }
                        wraps = append(wraps, n)
                        sum = ksz.Dim(d)
                        n = 1 // this guy is on next line
                } else {
                        sum += ksz.Dim(d) + gap
                        n++
                }
                return tree.Continue
        })
        if n > 0 {
                wraps = append(wraps, n)
        }
        wrapped = false
        if len(wraps) != len(li.Wraps) {
                wrapped = true
        } else {
                for i := range wraps {
                        if wraps[i] != li.Wraps[i] {
                                wrapped = true
                                break
                        }
                }
        }
        if !wrapped {
                return false
        }
        if DebugSettings.LayoutTrace {
                fmt.Println(fr, "wrapped:", wraps)
        }
        li.Wraps = wraps
        fr.setWrapIndexes()
        li.initCells()
        fr.setGapSizeFromCells()
        fr.sizeFromChildrenCells(iter, SizeDownPass)
        return wrapped
}

func (fr *Frame) sizeDownGrowStacked(iter int, extra math32.Vector2) bool {
        // stack just gets everything from us
        chg := false
        asz := fr.Geom.Size.Alloc.Content
        // todo: could actually use the grow factors to decide if growing here?
        if fr.LayoutStackTopOnly {
                kwb := fr.StackTopWidget()
                if kwb != nil {
                        ksz := &kwb.Geom.Size
                        if ksz.Alloc.Total != asz {
                                chg = true
                        }
                        ksz.Alloc.Total = asz
                        ksz.setContentFromTotal(&ksz.Alloc)
                }
                return chg
        }
        // note: allocate everyone in case they are flipped to top
        // need a new layout if size is actually different
        fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                ksz := &cwb.Geom.Size
                if ksz.Alloc.Total != asz {
                        chg = true
                }
                ksz.Alloc.Total = asz
                ksz.setContentFromTotal(&ksz.Alloc)
                return tree.Continue
        })
        return chg
}

// sizeDownAllocActual sets Alloc to Actual for no-extra case.
func (fr *Frame) sizeDownAllocActual(iter int) {
        if fr.Styles.Display == styles.Stacked {
                fr.sizeDownAllocActualStacked(iter)
                return
        }
        // todo: wrap needs special case
        fr.sizeDownAllocActualCells(iter)
}

// sizeDownAllocActualCells sets Alloc to Actual for no-extra case.
// Note however that due to max sizing for row / column,
// this size can actually be different than original actual.
func (fr *Frame) sizeDownAllocActualCells(iter int) {
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                ksz := &cwb.Geom.Size
                cidx := cwb.Geom.Cell
                for ma := math32.X; ma <= math32.Y; ma++ { // main axis = X then Y
                        ca := ma.Other()                 // cross axis = Y then X
                        mi := math32.PointDim(cidx, ma)  // X, Y
                        ci := math32.PointDim(cidx, ca)  // Y, X
                        md := fr.layout.cell(ma, mi, ci) // X, Y
                        asz := md.Size.Dim(ma)
                        ksz.Alloc.Total.SetDim(ma, asz)
                }
                ksz.setContentFromTotal(&ksz.Alloc)
                return tree.Continue
        })
}

func (fr *Frame) sizeDownAllocActualStacked(iter int) {
        // stack just gets everything from us
        asz := fr.Geom.Size.Actual.Content
        // todo: could actually use the grow factors to decide if growing here?
        if fr.LayoutStackTopOnly {
                kwb := fr.StackTopWidget()
                if kwb != nil {
                        ksz := &kwb.Geom.Size
                        ksz.Alloc.Total = asz
                        ksz.setContentFromTotal(&ksz.Alloc)
                }
                return
        }
        // note: allocate everyone in case they are flipped to top
        // need a new layout if size is actually different
        fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                ksz := &cwb.Geom.Size
                ksz.Alloc.Total = asz
                ksz.setContentFromTotal(&ksz.Alloc)
                return tree.Continue
        })
}

func (fr *Frame) sizeDownCustom(iter int) bool {
        prel := fr.updateParentRelSizes()
        fr.growToAlloc()
        sz := &fr.Geom.Size
        if DebugSettings.LayoutTrace {
                fmt.Println(fr, "Custom Managing Alloc:", sz.Alloc.Content)
        }
        styles.SetClampMaxVector(&sz.Alloc.Content, sz.Max) // can't be more than max..
        // this allocates our full size to each child, same as ActualStacked all case
        asz := sz.Actual.Content
        fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                ksz := &cwb.Geom.Size
                ksz.Alloc.Total = asz
                ksz.setContentFromTotal(&ksz.Alloc)
                return tree.Continue
        })
        redo := fr.sizeDownChildren(iter)
        fr.sizeDownParts(iter) // no std role, just get sizes
        return prel || redo
}

// sizeFinalUpdateChildrenSizes can optionally be called for layouts
// that dynamically create child elements based on final layout size.
// It ensures that the children are properly sized.
func (fr *Frame) sizeFinalUpdateChildrenSizes() {
        fr.SizeUp()
        iter := 3 // late stage..
        fr.This.(Layouter).SizeDownSetAllocs(iter)
        fr.sizeDownChildren(iter)
        fr.sizeDownParts(iter) // no std role, just get sizes
}

// SizeFinal: (bottom-up) similar to SizeUp but done at the end of the
// Sizing phase: first grows widget Actual sizes based on their Grow
// factors, up to their Alloc sizes.  Then gathers this updated final
// actual Size information for layouts to register their actual sizes
// prior to positioning, which requires accurate Actual vs. Alloc
// sizes to perform correct alignment calculations.
func (wb *WidgetBase) SizeFinal() {
        wb.Geom.RelPos.SetZero()
        sz := &wb.Geom.Size
        sz.Internal = sz.Actual.Content // keep it before we grow
        wb.growToAlloc()
        wb.styleSizeUpdate() // now that sizes are stable, ensure styling based on size is updated
        wb.sizeFinalParts()
        sz.setTotalFromContent(&sz.Actual)
}

// growToAlloc grows our Actual size up to current Alloc size
// for any dimension with a non-zero Grow factor.
// If Grow is < 1, then the size is increased in proportion, but
// any factor > 1 produces a full fill along that dimension.
// Returns true if this resulted in a change in our Total size.
func (wb *WidgetBase) growToAlloc() bool {
        if (wb.Scene != nil && wb.Scene.hasFlag(sceneContentSizing)) || wb.Styles.GrowWrap {
                return false
        }
        sz := &wb.Geom.Size
        act, change := wb.growToAllocSize(sz.Actual.Total, sz.Alloc.Total)
        if change {
                if DebugSettings.LayoutTrace {
                        fmt.Println(wb, "GrowToAlloc:", sz.Alloc.Total, "from actual:", sz.Actual.Total)
                }
                sz.Actual.Total = act // already has max constraint
                sz.setContentFromTotal(&sz.Actual)
        }
        return change
}

// sizeFinalParts adjusts the Content size to hold the Parts Final sizes
func (wb *WidgetBase) sizeFinalParts() {
        if wb.Parts == nil {
                return
        }
        wb.Parts.SizeFinal()
        sz := &wb.Geom.Size
        sz.FitSizeMax(&sz.Actual.Content, wb.Parts.Geom.Size.Actual.Total)
}

func (fr *Frame) SizeFinal() {
        if fr.Styles.Display == styles.Custom {
                fr.WidgetBase.SizeFinal() // behave like a widget
                fr.WidgetBase.sizeFinalChildren()
                return
        }
        if !fr.HasChildren() || !fr.layout.shapeCheck(fr, "SizeFinal") {
                fr.WidgetBase.SizeFinal() // behave like a widget
                return
        }
        fr.Geom.RelPos.SetZero()
        fr.sizeFinalChildren() // kids do their own thing
        fr.sizeFromChildrenFit(0, SizeFinalPass)
        fr.growToAlloc()
        fr.styleSizeUpdate() // now that sizes are stable, ensure styling based on size is updated
        fr.sizeFinalParts()
}

// sizeFinalChildren calls SizeFinal on all the children of this node
func (wb *WidgetBase) sizeFinalChildren() {
        wb.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cw.SizeFinal()
                return tree.Continue
        })
}

// sizeFinalChildren calls SizeFinal on all the children of this node
func (fr *Frame) sizeFinalChildren() {
        if fr.Styles.Display == styles.Stacked && !fr.LayoutStackTopOnly {
                fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                        cw.SizeFinal()
                        return tree.Continue
                })
                return
        }
        fr.WidgetBase.sizeFinalChildren()
}

// styleSizeUpdate updates styling size values for widget and its parent,
// which should be called after these are updated.  Returns true if any changed.
func (wb *WidgetBase) styleSizeUpdate() bool {
        pwb := wb.parentWidget()
        if pwb == nil {
                return false
        }
        if !wb.updateParentRelSizes() {
                return false
        }
        scsz := wb.Scene.SceneGeom.Size
        sz := wb.Geom.Size.Alloc.Content
        psz := pwb.Geom.Size.Alloc.Content
        chg := wb.Styles.UnitContext.SetSizes(float32(scsz.X), float32(scsz.Y), sz.X, sz.Y, psz.X, psz.Y)
        if chg {
                wb.Styles.ToDots()
        }
        return chg
}

// Position uses the final sizes to set relative positions within layouts
// according to alignment settings.
func (wb *WidgetBase) Position() {
        wb.positionParts()
}

func (wb *WidgetBase) positionWithinAllocMainX(pos math32.Vector2, parJustify, parAlign styles.Aligns) {
        sz := &wb.Geom.Size
        pos.X += styles.AlignPos(styles.ItemAlign(parJustify, wb.Styles.Justify.Self), sz.Actual.Total.X, sz.Alloc.Total.X)
        pos.Y += styles.AlignPos(styles.ItemAlign(parAlign, wb.Styles.Align.Self), sz.Actual.Total.Y, sz.Alloc.Total.Y)
        wb.Geom.RelPos = pos
        if DebugSettings.LayoutTrace {
                fmt.Println(wb, "Position within Main=X:", pos)
        }
}

func (wb *WidgetBase) positionWithinAllocMainY(pos math32.Vector2, parJustify, parAlign styles.Aligns) {
        sz := &wb.Geom.Size
        pos.Y += styles.AlignPos(styles.ItemAlign(parJustify, wb.Styles.Justify.Self), sz.Actual.Total.Y, sz.Alloc.Total.Y)
        pos.X += styles.AlignPos(styles.ItemAlign(parAlign, wb.Styles.Align.Self), sz.Actual.Total.X, sz.Alloc.Total.X)
        wb.Geom.RelPos = pos
        if DebugSettings.LayoutTrace {
                fmt.Println(wb, "Position within Main=Y:", pos)
        }
}

func (wb *WidgetBase) positionParts() {
        if wb.Parts == nil {
                return
        }
        sz := &wb.Geom.Size
        pgm := &wb.Parts.Geom
        pgm.RelPos.X = styles.AlignPos(wb.Parts.Styles.Justify.Content, pgm.Size.Actual.Total.X, sz.Actual.Content.X)
        pgm.RelPos.Y = styles.AlignPos(wb.Parts.Styles.Align.Content, pgm.Size.Actual.Total.Y, sz.Actual.Content.Y)
        if DebugSettings.LayoutTrace {
                fmt.Println(wb.Parts, "parts align pos:", pgm.RelPos)
        }
        wb.Parts.This.(Widget).Position()
}

// positionChildren runs Position on the children
func (wb *WidgetBase) positionChildren() {
        wb.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cw.Position()
                return tree.Continue
        })
}

// Position: uses the final sizes to position everything within layouts
// according to alignment settings.
func (fr *Frame) Position() {
        if fr.Styles.Display == styles.Custom {
                fr.positionFromPos()
                fr.positionChildren()
                return
        }
        if !fr.HasChildren() || !fr.layout.shapeCheck(fr, "Position") {
                fr.WidgetBase.Position() // behave like a widget
                return
        }
        if fr.Parent == nil {
                fr.positionWithinAllocMainY(math32.Vector2{}, fr.Styles.Justify.Items, fr.Styles.Align.Items)
        }
        fr.ConfigScrolls() // and configure the scrolls
        if fr.Styles.Display == styles.Stacked {
                fr.positionStacked()
        } else {
                fr.positionCells()
                fr.positionChildren()
        }
        fr.positionParts()
}

func (fr *Frame) positionCells() {
        if fr.Styles.Display == styles.Flex && fr.Styles.Direction == styles.Column {
                fr.positionCellsMainY()
                return
        }
        fr.positionCellsMainX()
}

// Main axis = X
func (fr *Frame) positionCellsMainX() {
        // todo: can break apart further into Flex rows
        gap := fr.layout.Gap
        sz := &fr.Geom.Size
        if DebugSettings.LayoutTraceDetail {
                fmt.Println(fr, "PositionCells Main X, actual:", sz.Actual.Content, "internal:", sz.Internal)
        }
        var stPos math32.Vector2
        stPos.X = styles.AlignPos(fr.Styles.Justify.Content, sz.Internal.X, sz.Actual.Content.X)
        stPos.Y = styles.AlignPos(fr.Styles.Align.Content, sz.Internal.Y, sz.Actual.Content.Y)
        pos := stPos
        var lastSz math32.Vector2
        idx := 0
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cidx := cwb.Geom.Cell
                if cidx.X == 0 && idx > 0 {
                        pos.X = stPos.X
                        pos.Y += lastSz.Y + gap.Y
                }
                cwb.positionWithinAllocMainX(pos, fr.Styles.Justify.Items, fr.Styles.Align.Items)
                alloc := cwb.Geom.Size.Alloc.Total
                pos.X += alloc.X + gap.X
                lastSz = alloc
                idx++
                return tree.Continue
        })
}

// Main axis = Y
func (fr *Frame) positionCellsMainY() {
        gap := fr.layout.Gap
        sz := &fr.Geom.Size
        if DebugSettings.LayoutTraceDetail {
                fmt.Println(fr, "PositionCells, actual", sz.Actual.Content, "internal:", sz.Internal)
        }
        var lastSz math32.Vector2
        var stPos math32.Vector2
        stPos.Y = styles.AlignPos(fr.Styles.Justify.Content, sz.Internal.Y, sz.Actual.Content.Y)
        stPos.X = styles.AlignPos(fr.Styles.Align.Content, sz.Internal.X, sz.Actual.Content.X)
        pos := stPos
        idx := 0
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cidx := cwb.Geom.Cell
                if cidx.Y == 0 && idx > 0 {
                        pos.Y = stPos.Y
                        pos.X += lastSz.X + gap.X
                }
                cwb.positionWithinAllocMainY(pos, fr.Styles.Justify.Items, fr.Styles.Align.Items)
                alloc := cwb.Geom.Size.Alloc.Total
                pos.Y += alloc.Y + gap.Y
                lastSz = alloc
                idx++
                return tree.Continue
        })
}

func (fr *Frame) positionStacked() {
        fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cwb.Geom.RelPos.SetZero()
                if !fr.LayoutStackTopOnly || i == fr.StackTop {
                        cw.Position()
                }
                return tree.Continue
        })
}

// ApplyScenePos computes scene-based absolute positions and final BBox
// bounding boxes for rendering, based on relative positions from
// Position step and parents accumulated position and scroll offset.
// This is the only step needed when scrolling (very fast).
func (wb *WidgetBase) ApplyScenePos() {
        wb.setPosFromParent()
        wb.setBBoxes()
}

// setContentPosFromPos sets the Pos.Content position based on current Pos
// plus the BoxSpace position offset.
func (wb *WidgetBase) setContentPosFromPos() {
        off := wb.Styles.BoxSpace().Pos().Floor()
        wb.Geom.Pos.Content = wb.Geom.Pos.Total.Add(off)
}

func (wb *WidgetBase) setPosFromParent() {
        pwb := wb.parentWidget()
        var parPos math32.Vector2
        if pwb != nil {
                parPos = pwb.Geom.Pos.Content.Add(pwb.Geom.Scroll) // critical that parent adds here but not to self
        }
        wb.Geom.Pos.Total = wb.Geom.RelPos.Add(parPos)
        wb.setContentPosFromPos()
        if DebugSettings.LayoutTrace {
                fmt.Println(wb, "pos:", wb.Geom.Pos.Total, "parPos:", parPos)
        }
}

// setBBoxesFromAllocs sets BBox and ContentBBox from Geom.Pos and .Size
// This does NOT intersect with parent content BBox, which is done in SetBBoxes.
// Use this for elements that are dynamically positioned outside of parent BBox.
func (wb *WidgetBase) setBBoxesFromAllocs() {
        wb.Geom.TotalBBox = wb.Geom.totalRect()
        wb.Geom.ContentBBox = wb.Geom.contentRect()
}

func (wb *WidgetBase) setBBoxes() {
        pwb := wb.parentWidget()
        var parBB image.Rectangle
        if pwb == nil { // scene
                sz := &wb.Geom.Size
                wb.Geom.TotalBBox = math32.RectFromPosSizeMax(math32.Vector2{}, sz.Alloc.Total)
                off := wb.Styles.BoxSpace().Pos().Floor()
                wb.Geom.ContentBBox = math32.RectFromPosSizeMax(off, sz.Alloc.Content)
                if DebugSettings.LayoutTrace {
                        fmt.Println(wb, "Total BBox:", wb.Geom.TotalBBox)
                        fmt.Println(wb, "Content BBox:", wb.Geom.ContentBBox)
                }
        } else {
                parBB = pwb.Geom.ContentBBox
                bb := wb.Geom.totalRect()
                wb.Geom.TotalBBox = parBB.Intersect(bb)
                if DebugSettings.LayoutTrace {
                        fmt.Println(wb, "Total BBox:", bb, "parBB:", parBB, "BBox:", wb.Geom.TotalBBox)
                }

                cbb := wb.Geom.contentRect()
                wb.Geom.ContentBBox = parBB.Intersect(cbb)
                if DebugSettings.LayoutTrace {
                        fmt.Println(wb, "Content BBox:", cbb, "parBB:", parBB, "BBox:", wb.Geom.ContentBBox)
                }
        }
        wb.applyScenePosParts()
}

func (wb *WidgetBase) applyScenePosParts() {
        if wb.Parts == nil {
                return
        }
        wb.Parts.ApplyScenePos()
}

// applyScenePosChildren runs ApplyScenePos on the children
func (wb *WidgetBase) applyScenePosChildren() {
        wb.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cw.ApplyScenePos()
                return tree.Continue
        })
}

// applyScenePosChildren runs ScenePos on the children
func (fr *Frame) applyScenePosChildren() {
        if fr.Styles.Display == styles.Stacked && !fr.LayoutStackTopOnly {
                fr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                        cw.ApplyScenePos()
                        return tree.Continue
                })
                return
        }
        fr.WidgetBase.applyScenePosChildren()
}

// ApplyScenePos: scene-based position and final BBox is computed based on
// parents accumulated position and scrollbar position.
// This step can be performed when scrolling after updating Scroll.
func (fr *Frame) ApplyScenePos() {
        fr.scrollResetIfNone()
        if fr.Styles.Display == styles.Custom {
                fr.WidgetBase.ApplyScenePos()
                fr.applyScenePosChildren()
                fr.PositionScrolls()
                fr.applyScenePosParts() // in case they fit inside parent
                return
        }
        // note: ly.Geom.Scroll has the X, Y scrolling offsets, set by Layouter.ScrollChanged function
        if !fr.HasChildren() || !fr.layout.shapeCheck(fr, "ScenePos") {
                fr.WidgetBase.ApplyScenePos() // behave like a widget
                return
        }
        fr.WidgetBase.ApplyScenePos()
        fr.applyScenePosChildren()
        fr.PositionScrolls()
        fr.applyScenePosParts() // in case they fit inside parent
        // otherwise handle separately like scrolls on layout
}

// scrollResetIfNone resets the scroll offsets if there are no scrollbars
func (fr *Frame) scrollResetIfNone() {
        for d := math32.X; d <= math32.Y; d++ {
                if !fr.HasScroll[d] {
                        fr.Geom.Scroll.SetDim(d, 0)
                }
        }
}

// positionFromPos does Custom positioning from style positions.
func (fr *Frame) positionFromPos() {
        fr.forVisibleChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cwb.Geom.RelPos.X = cwb.Styles.Pos.X.Dots
                cwb.Geom.RelPos.Y = cwb.Styles.Pos.Y.Dots
                return tree.Continue
        })
}

// DirectRenderDrawBBoxes returns the destination and source bounding boxes
// for RenderDraw call for widgets that do direct rendering.
// The destBBox.Min point can be passed as the dp destination point for Draw
// function, and srcBBox is the source region.  Empty flag indicates if either
// of the srcBBox dimensions are <= 0.
func (wb *WidgetBase) DirectRenderDrawBBoxes(srcFullBBox image.Rectangle) (destBBox, srcBBox image.Rectangle, empty bool) {
        tbb := wb.Geom.TotalBBox
        destBBox = tbb.Add(wb.Scene.SceneGeom.Pos)
        srcBBox = srcFullBBox
        pos := wb.Geom.Pos.Total.ToPoint()
        if pos.X < tbb.Min.X { // scrolled off left
                srcBBox.Min.X = tbb.Min.X - pos.X
        }
        if pos.Y < tbb.Min.Y {
                srcBBox.Min.X = tbb.Min.Y - pos.X
        }
        sz := srcBBox.Size()
        if sz.X <= 0 || sz.Y <= 0 {
                empty = true
        }
        return
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "encoding/json"
        "fmt"
        "image"
        "image/color"
        "log"
        "log/slog"
        "reflect"
        "sort"
        "strconv"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/tree"
)

// List represents a slice value with a list of value widgets and optional index widgets.
// Use [ListBase.BindSelect] to make the list designed for item selection.
type List struct {
        ListBase

        // ListStyler is an optional styler for list items.
        ListStyler ListStyler `copier:"-" json:"-" xml:"-"`
}

// ListStyler is a styling function for custom styling and
// configuration of elements in the list.
type ListStyler func(w Widget, s *styles.Style, row int)

func (ls *List) HasStyler() bool {
        return ls.ListStyler != nil
}

func (ls *List) StyleRow(w Widget, idx, fidx int) {
        if ls.ListStyler != nil {
                ls.ListStyler(w, &w.AsWidget().Styles, idx)
        }
}

// note on implementation:
// * ListGrid handles all the layout logic to start with a minimum number of
//   rows and then computes the total number visible based on allocated size.

const (
        // ListRowProperty is the tree property name for the row of a list element.
        ListRowProperty = "ls-row"

        // ListColProperty is the tree property name for the column of a list element.
        ListColProperty = "ls-col"
)

// Lister is the interface used by [ListBase] to
// support any abstractions needed for different types of lists.
type Lister interface {
        tree.Node

        // AsListBase returns the base for direct access to relevant fields etc
        AsListBase() *ListBase

        // RowWidgetNs returns number of widgets per row and
        // offset for index label
        RowWidgetNs() (nWidgPerRow, idxOff int)

        // UpdateSliceSize updates the current size of the slice
        // and sets SliceSize if changed.
        UpdateSliceSize() int

        // UpdateMaxWidths updates the maximum widths per column based
        // on estimates from length of strings (for string values)
        UpdateMaxWidths()

        // SliceIndex returns the logical slice index: si = i + StartIndex,
        // the actual value index vi into the slice value (typically = si),
        // which can be different if there is an index indirection as in
        // tensorcore.Table), and a bool that is true if the
        // index is beyond the available data and is thus invisible,
        // given the row index provided.
        SliceIndex(i int) (si, vi int, invis bool)

        // MakeRow adds config for one row at given widget row index.
        // Plan must be the StructGrid Plan.
        MakeRow(p *tree.Plan, i int)

        // StyleValue performs additional value widget styling
        StyleValue(w Widget, s *styles.Style, row, col int)

        // HasStyler returns whether there is a custom style function.
        HasStyler() bool

        // StyleRow calls a custom style function on given row (and field)
        StyleRow(w Widget, idx, fidx int)

        // RowGrabFocus grabs the focus for the first focusable
        // widget in given row.
        // returns that element or nil if not successful
        // note: grid must have already rendered for focus to be grabbed!
        RowGrabFocus(row int) *WidgetBase

        // NewAt inserts a new blank element at the given index in the slice.
        // -1 indicates to insert the element at the end.
        NewAt(idx int)

        // DeleteAt deletes the element at the given index from the slice.
        DeleteAt(idx int)

        // MimeDataType returns the data type for mime clipboard
        // (copy / paste) data e.g., fileinfo.DataJson
        MimeDataType() string

        // CopySelectToMime copies selected rows to mime data
        CopySelectToMime() mimedata.Mimes

        // PasteAssign assigns mime data (only the first one!) to this idx
        PasteAssign(md mimedata.Mimes, idx int)

        // PasteAtIndex inserts object(s) from mime data at
        // (before) given slice index
        PasteAtIndex(md mimedata.Mimes, idx int)
}

var _ Lister = &List{}

// ListBase is the base for [List] and [Table] and any other displays
// of array-like data. It automatically computes the number of rows that fit
// within its allocated space, and manages the offset view window into the full
// list of items, and supports row selection, copy / paste, Drag-n-Drop, etc.
// Use [ListBase.BindSelect] to make the list designed for item selection.
type ListBase struct { //core:no-new
        Frame

        // Slice is the pointer to the slice that we are viewing.
        Slice any `set:"-"`

        // ShowIndexes is whether to show the indexes of rows or not (default false).
        ShowIndexes bool

        // MinRows specifies the minimum number of rows to display, to ensure
        // at least this amount is displayed.
        MinRows int `default:"4"`

        // SelectedValue is the current selection value.
        // If it is set, it is used as the initially selected value.
        SelectedValue any `copier:"-" display:"-" json:"-" xml:"-"`

        // SelectedIndex is the index of the currently selected item.
        SelectedIndex int `copier:"-" json:"-" xml:"-"`

        // InitSelectedIndex is the index of the row to select at the start.
        InitSelectedIndex int `copier:"-" json:"-" xml:"-"`

        // SelectedIndexes is a list of currently selected slice indexes.
        SelectedIndexes map[int]struct{} `set:"-" copier:"-"`

        // lastClick is the last row that has been clicked on.
        // This is used to prevent erroneous double click events
        // from being sent when the user clicks on multiple different
        // rows in quick succession.
        lastClick int

        // normalCursor is the cached cursor to display when there
        // is no row being hovered.
        normalCursor cursors.Cursor

        // currentCursor is the cached cursor that should currently be
        // displayed.
        currentCursor cursors.Cursor

        // sliceUnderlying is the underlying slice value.
        sliceUnderlying reflect.Value

        // currently hovered row
        hoverRow int

        // list of currently dragged indexes
        draggedIndexes []int

        // VisibleRows is the total number of rows visible in allocated display size.
        VisibleRows int `set:"-" edit:"-" copier:"-" json:"-" xml:"-"`

        // StartIndex is the starting slice index of visible rows.
        StartIndex int `set:"-" edit:"-" copier:"-" json:"-" xml:"-"`

        // SliceSize is the size of the slice.
        SliceSize int `set:"-" edit:"-" copier:"-" json:"-" xml:"-"`

        // MakeIter is the iteration through the configuration process,
        // which is reset when a new slice type is set.
        MakeIter int `set:"-" edit:"-" copier:"-" json:"-" xml:"-"`

        // temp idx state for e.g., dnd
        tmpIndex int

        // elementValue is a [reflect.Value] representation of the underlying element type
        // which is used whenever there are no slice elements available
        elementValue reflect.Value

        // maximum width of value column in chars, if string
        maxWidth int

        // ReadOnlyKeyNav is whether support key navigation when ReadOnly (default true).
        // It uses a capture of up / down events to manipulate selection, not focus.
        ReadOnlyKeyNav bool `default:"true"`

        // SelectMode is whether to be in select rows mode or editing mode.
        SelectMode bool `set:"-" copier:"-" json:"-" xml:"-"`

        // ReadOnlyMultiSelect: if list is ReadOnly, default selection mode is to
        // choose one row only. If this is true, standard multiple selection logic
        // with modifier keys is instead supported.
        ReadOnlyMultiSelect bool

        // InFocusGrab is a guard for recursive focus grabbing.
        InFocusGrab bool `set:"-" edit:"-" copier:"-" json:"-" xml:"-"`

        // isArray is whether the slice is actually an array.
        isArray bool

        // ListGrid is the [ListGrid] widget.
        ListGrid *ListGrid `set:"-" edit:"-" copier:"-" json:"-" xml:"-"`
}

func (lb *ListBase) WidgetValue() any { return &lb.Slice }

func (lb *ListBase) Init() {
        lb.Frame.Init()
        lb.AddContextMenu(lb.contextMenu)
        lb.InitSelectedIndex = -1
        lb.hoverRow = -1
        lb.MinRows = 4
        lb.ReadOnlyKeyNav = true

        lb.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Clickable, abilities.DoubleClickable, abilities.TripleClickable)
                s.SetAbilities(!lb.IsReadOnly(), abilities.Draggable, abilities.Droppable)
                s.Cursor = lb.currentCursor
                s.Direction = styles.Column
                // absorb horizontal here, vertical in view
                s.Overflow.X = styles.OverflowAuto
                s.Grow.Set(1, 1)
        })
        if !lb.IsReadOnly() {
                lb.On(events.DragStart, func(e events.Event) {
                        lb.dragStart(e)
                })
                lb.On(events.DragEnter, func(e events.Event) {
                        e.SetHandled()
                })
                lb.On(events.DragLeave, func(e events.Event) {
                        e.SetHandled()
                })
                lb.On(events.Drop, func(e events.Event) {
                        lb.dragDrop(e)
                })
                lb.On(events.DropDeleteSource, func(e events.Event) {
                        lb.dropDeleteSource(e)
                })
        }
        lb.FinalStyler(func(s *styles.Style) {
                lb.normalCursor = s.Cursor
        })

        lb.OnFinal(events.KeyChord, func(e events.Event) {
                if lb.IsReadOnly() {
                        if lb.ReadOnlyKeyNav {
                                lb.keyInputReadOnly(e)
                        }
                } else {
                        lb.keyInputEditable(e)
                }
        })
        lb.On(events.MouseMove, func(e events.Event) {
                row, _, isValid := lb.rowFromEventPos(e)
                prevHoverRow := lb.hoverRow
                if !isValid {
                        lb.hoverRow = -1
                        lb.Styles.Cursor = lb.normalCursor
                } else {
                        lb.hoverRow = row
                        lb.Styles.Cursor = cursors.Pointer
                }
                lb.currentCursor = lb.Styles.Cursor
                if lb.hoverRow != prevHoverRow {
                        lb.NeedsRender()
                }
        })
        lb.On(events.MouseDrag, func(e events.Event) {
                row, _, isValid := lb.rowFromEventPos(e)
                if !isValid {
                        return
                }
                pt := lb.PointToRelPos(e.Pos())
                lb.ListGrid.AutoScroll(math32.FromPoint(pt))
                prevHoverRow := lb.hoverRow
                if !isValid {
                        lb.hoverRow = -1
                        lb.Styles.Cursor = lb.normalCursor
                } else {
                        lb.hoverRow = row
                        lb.Styles.Cursor = cursors.Pointer
                }
                lb.currentCursor = lb.Styles.Cursor
                if lb.hoverRow != prevHoverRow {
                        lb.NeedsRender()
                }
        })
        lb.OnFirst(events.DoubleClick, func(e events.Event) {
                row, _, isValid := lb.rowFromEventPos(e)
                if !isValid {
                        return
                }
                if lb.lastClick != row+lb.StartIndex {
                        lb.ListGrid.Send(events.Click, e)
                        e.SetHandled()
                }
        })
        // we must interpret triple click events as double click
        // events for rapid cross-row double clicking to work correctly
        lb.OnFirst(events.TripleClick, func(e events.Event) {
                lb.Send(events.DoubleClick, e)
        })

        lb.Maker(func(p *tree.Plan) {
                ls := lb.This.(Lister)
                ls.UpdateSliceSize()

                scrollTo := -1
                if lb.SelectedValue != nil {
                        idx, ok := sliceIndexByValue(lb.Slice, lb.SelectedValue)
                        if ok {
                                lb.SelectedIndex = idx
                                scrollTo = lb.SelectedIndex
                        }
                        lb.SelectedValue = nil
                        lb.InitSelectedIndex = -1
                } else if lb.InitSelectedIndex >= 0 {
                        lb.SelectedIndex = lb.InitSelectedIndex
                        lb.InitSelectedIndex = -1
                        scrollTo = lb.SelectedIndex
                }
                if scrollTo >= 0 {
                        lb.ScrollToIndex(scrollTo)
                }

                lb.Updater(func() {
                        lb.UpdateStartIndex()
                })

                lb.MakeGrid(p, func(p *tree.Plan) {
                        for i := 0; i < lb.VisibleRows; i++ {
                                ls.MakeRow(p, i)
                        }
                })
        })
}

func (lb *ListBase) SliceIndex(i int) (si, vi int, invis bool) {
        si = lb.StartIndex + i
        vi = si
        invis = si >= lb.SliceSize
        return
}

// StyleValue performs additional value widget styling
func (lb *ListBase) StyleValue(w Widget, s *styles.Style, row, col int) {
        if lb.maxWidth > 0 {
                hv := units.Ch(float32(lb.maxWidth))
                s.Min.X.Value = max(s.Min.X.Value, hv.Convert(s.Min.X.Unit, &s.UnitContext).Value)
        }
        s.SetTextWrap(false)
}

func (lb *ListBase) AsListBase() *ListBase {
        return lb
}

func (lb *ListBase) SetSliceBase() {
        lb.SelectMode = false
        lb.MakeIter = 0
        lb.StartIndex = 0
        lb.VisibleRows = lb.MinRows
        if !lb.IsReadOnly() {
                lb.SelectedIndex = -1
        }
        lb.ResetSelectedIndexes()
        lb.This.(Lister).UpdateMaxWidths()
}

// SetSlice sets the source slice that we are viewing.
// This ReMakes the view for this slice if different.
// Note: it is important to at least set an empty slice of
// the desired type at the start to enable initial configuration.
func (lb *ListBase) SetSlice(sl any) *ListBase {
        if reflectx.IsNil(reflect.ValueOf(sl)) {
                lb.Slice = nil
                return lb
        }
        // TODO: a lot of this garbage needs to be cleaned up.
        // New is not working!
        newslc := false
        if reflect.TypeOf(sl).Kind() != reflect.Pointer { // prevent crash on non-comparable
                newslc = true
        } else {
                newslc = lb.Slice != sl
        }
        if !newslc {
                lb.MakeIter = 0
                return lb
        }

        lb.Slice = sl
        lb.sliceUnderlying = reflectx.Underlying(reflect.ValueOf(lb.Slice))
        lb.isArray = reflectx.NonPointerType(reflect.TypeOf(sl)).Kind() == reflect.Array
        lb.elementValue = reflectx.Underlying(reflectx.SliceElementValue(sl))
        lb.SetSliceBase()
        return lb
}

// rowFromEventPos returns the widget row, slice index, and
// whether the index is in slice range, for given event position.
func (lb *ListBase) rowFromEventPos(e events.Event) (row, idx int, isValid bool) {
        sg := lb.ListGrid
        row, _, isValid = sg.indexFromPixel(e.Pos())
        if !isValid {
                return
        }
        idx = row + lb.StartIndex
        if row < 0 || idx >= lb.SliceSize {
                isValid = false
        }
        return
}

// clickSelectEvent is a helper for processing selection events
// based on a mouse click, which could be a double or triple
// in addition to a regular click.
// Returns false if no further processing should occur,
// because the user clicked outside the range of active rows.
func (lb *ListBase) clickSelectEvent(e events.Event) bool {
        row, _, isValid := lb.rowFromEventPos(e)
        if !isValid {
                e.SetHandled()
        } else {
                lb.updateSelectRow(row, e.SelectMode())
        }
        return isValid
}

// BindSelect makes the list a read-only selection list and then
// binds its events to its scene and its current selection index to the given value.
// It will send an [events.Change] event when the user changes the selection row.
func (lb *ListBase) BindSelect(val *int) *ListBase {
        lb.SetReadOnly(true)
        lb.OnSelect(func(e events.Event) {
                *val = lb.SelectedIndex
                lb.SendChange(e)
        })
        lb.OnDoubleClick(func(e events.Event) {
                if lb.clickSelectEvent(e) {
                        *val = lb.SelectedIndex
                        lb.Scene.sendKey(keymap.Accept, e) // activate OK button
                        if lb.Scene.Stage.Type == DialogStage {
                                lb.Scene.Close() // also directly close dialog for value dialogs without OK button
                        }
                }
        })
        return lb
}

func (lb *ListBase) UpdateMaxWidths() {
        lb.maxWidth = 0
        ev := lb.elementValue
        isString := ev.Type().Kind() == reflect.String && ev.Type() != reflect.TypeFor[icons.Icon]()
        if !isString || lb.SliceSize == 0 {
                return
        }
        mxw := 0
        for rw := 0; rw < lb.SliceSize; rw++ {
                str := reflectx.ToString(lb.sliceElementValue(rw).Interface())
                mxw = max(mxw, len(str))
        }
        lb.maxWidth = mxw
}

// sliceElementValue returns an underlying non-pointer [reflect.Value]
// of slice element at given index or ElementValue if out of range.
func (lb *ListBase) sliceElementValue(si int) reflect.Value {
        var val reflect.Value
        if si < lb.SliceSize {
                val = reflectx.Underlying(lb.sliceUnderlying.Index(si)) // deal with pointer lists
        } else {
                val = lb.elementValue
        }
        if !val.IsValid() {
                val = lb.elementValue
        }
        return val
}

func (lb *ListBase) MakeGrid(p *tree.Plan, maker func(p *tree.Plan)) {
        tree.AddAt(p, "grid", func(w *ListGrid) {
                lb.ListGrid = w
                w.Styler(func(s *styles.Style) {
                        nWidgPerRow, _ := lb.This.(Lister).RowWidgetNs()
                        w.minRows = lb.MinRows
                        s.Display = styles.Grid
                        s.Columns = nWidgPerRow
                        s.Grow.Set(1, 1)
                        s.Overflow.Y = styles.OverflowAuto
                        s.Gap.Set(units.Em(0.5)) // note: match header
                        s.Align.Items = styles.Center
                        // baseline mins:
                        s.Min.X.Ch(20)
                        s.Min.Y.Em(6)
                })
                oc := func(e events.Event) {
                        // lb.SetFocus()
                        row, _, isValid := w.indexFromPixel(e.Pos())
                        if isValid {
                                lb.updateSelectRow(row, e.SelectMode())
                                lb.lastClick = row + lb.StartIndex
                        }
                }
                w.OnClick(oc)
                w.On(events.ContextMenu, func(e events.Event) {
                        // we must select the row on right click so that the context menu
                        // corresponds to the right row
                        oc(e)
                        lb.HandleEvent(e)
                })
                w.Updater(func() {
                        nWidgPerRow, _ := lb.This.(Lister).RowWidgetNs()
                        w.Styles.Columns = nWidgPerRow
                })
                w.Maker(maker)
        })
}

func (lb *ListBase) MakeValue(w Value, i int) {
        ls := lb.This.(Lister)
        wb := w.AsWidget()
        wb.SetProperty(ListRowProperty, i)
        wb.Styler(func(s *styles.Style) {
                if lb.IsReadOnly() {
                        s.SetAbilities(true, abilities.DoubleClickable)
                        s.SetAbilities(false, abilities.Hoverable, abilities.Focusable, abilities.Activatable, abilities.TripleClickable)
                        s.SetReadOnly(true)
                }
                row, col := lb.widgetIndex(w)
                row += lb.StartIndex
                ls.StyleValue(w, s, row, col)
                if row < lb.SliceSize {
                        ls.StyleRow(w, row, col)
                }
        })
        wb.OnSelect(func(e events.Event) {
                e.SetHandled()
                row, _ := lb.widgetIndex(w)
                lb.updateSelectRow(row, e.SelectMode())
                lb.lastClick = row + lb.StartIndex
        })
        wb.OnDoubleClick(lb.HandleEvent)
        wb.On(events.ContextMenu, lb.HandleEvent)
        wb.OnFirst(events.ContextMenu, func(e events.Event) {
                wb.Send(events.Select, e) // we must select the row for context menu actions
        })
        if !lb.IsReadOnly() {
                wb.OnInput(lb.HandleEvent)
        }
}

func (lb *ListBase) MakeRow(p *tree.Plan, i int) {
        ls := lb.This.(Lister)
        si, vi, invis := ls.SliceIndex(i)
        itxt := strconv.Itoa(i)
        val := lb.sliceElementValue(vi)

        if lb.ShowIndexes {
                lb.MakeGridIndex(p, i, si, itxt, invis)
        }

        valnm := fmt.Sprintf("value-%s-%s", itxt, reflectx.ShortTypeName(lb.elementValue.Type()))
        tree.AddNew(p, valnm, func() Value {
                return NewValue(val.Addr().Interface(), "")
        }, func(w Value) {
                wb := w.AsWidget()
                lb.MakeValue(w, i)
                if !lb.IsReadOnly() {
                        wb.OnChange(func(e events.Event) {
                                lb.This.(Lister).UpdateMaxWidths()
                                lb.SendChange(e)
                        })
                }
                wb.Updater(func() {
                        wb := w.AsWidget()
                        _, vi, invis := ls.SliceIndex(i)
                        val := lb.sliceElementValue(vi)
                        Bind(val.Addr().Interface(), w)
                        wb.SetReadOnly(lb.IsReadOnly())
                        wb.SetState(invis, states.Invisible)
                        if lb.This.(Lister).HasStyler() {
                                w.Style()
                        }
                        if invis {
                                wb.SetSelected(false)
                        }
                })
        })

}

func (lb *ListBase) MakeGridIndex(p *tree.Plan, i, si int, itxt string, invis bool) {
        ls := lb.This.(Lister)
        tree.AddAt(p, "index-"+itxt, func(w *Text) {
                w.SetProperty(ListRowProperty, i)
                w.Styler(func(s *styles.Style) {
                        s.SetAbilities(true, abilities.DoubleClickable)
                        s.SetAbilities(!lb.IsReadOnly(), abilities.Draggable, abilities.Droppable)
                        s.Cursor = cursors.None
                        nd := math32.Log10(float32(lb.SliceSize))
                        nd = max(nd, 3)
                        s.Min.X.Ch(nd + 2)
                        s.Padding.Right.Dp(4)
                        s.Text.Align = text.End
                        s.Min.Y.Em(1)
                        s.GrowWrap = false
                })
                w.OnSelect(func(e events.Event) {
                        e.SetHandled()
                        lb.updateSelectRow(i, e.SelectMode())
                        lb.lastClick = si
                })
                w.OnDoubleClick(lb.HandleEvent)
                w.On(events.ContextMenu, lb.HandleEvent)
                if !lb.IsReadOnly() {
                        w.On(events.DragStart, func(e events.Event) {
                                lb.dragStart(e)
                        })
                        w.On(events.DragEnter, func(e events.Event) {
                                e.SetHandled()
                        })
                        w.On(events.DragLeave, func(e events.Event) {
                                e.SetHandled()
                        })
                        w.On(events.Drop, func(e events.Event) {
                                lb.dragDrop(e)
                        })
                        w.On(events.DropDeleteSource, func(e events.Event) {
                                lb.dropDeleteSource(e)
                        })
                }
                w.Updater(func() {
                        si, _, invis := ls.SliceIndex(i)
                        sitxt := strconv.Itoa(si)
                        w.SetText(sitxt)
                        w.SetReadOnly(lb.IsReadOnly())
                        w.SetState(invis, states.Invisible)
                        if invis {
                                w.SetSelected(false)
                        }
                })
        })
}

// RowWidgetNs returns number of widgets per row and offset for index label
func (lb *ListBase) RowWidgetNs() (nWidgPerRow, idxOff int) {
        nWidgPerRow = 2
        idxOff = 1
        if !lb.ShowIndexes {
                nWidgPerRow -= 1
                idxOff = 0
        }
        return
}

// UpdateSliceSize updates and returns the size of the slice
// and sets SliceSize
func (lb *ListBase) UpdateSliceSize() int {
        sz := lb.sliceUnderlying.Len()
        lb.SliceSize = sz
        return sz
}

// widgetIndex returns the row and column indexes for given widget,
// from the properties set during construction.
func (lb *ListBase) widgetIndex(w Widget) (row, col int) {
        if rwi := w.AsTree().Property(ListRowProperty); rwi != nil {
                row = rwi.(int)
        }
        if cli := w.AsTree().Property(ListColProperty); cli != nil {
                col = cli.(int)
        }
        return
}

// UpdateStartIndex updates StartIndex to fit current view
func (lb *ListBase) UpdateStartIndex() {
        sz := lb.This.(Lister).UpdateSliceSize()
        if sz > lb.VisibleRows {
                lastSt := sz - lb.VisibleRows
                lb.StartIndex = min(lastSt, lb.StartIndex)
                lb.StartIndex = max(0, lb.StartIndex)
        } else {
                lb.StartIndex = 0
        }
}

// updateScroll updates the scroll value
func (lb *ListBase) updateScroll() {
        sg := lb.ListGrid
        if sg == nil {
                return
        }
        sg.updateScroll(lb.StartIndex)
}

// newAtRow inserts a new blank element at the given display row.
func (lb *ListBase) newAtRow(row int) {
        lb.This.(Lister).NewAt(lb.StartIndex + row)
}

// NewAt inserts a new blank element at the given index in the slice.
// -1 indicates to insert the element at the end.
func (lb *ListBase) NewAt(idx int) {
        if lb.isArray {
                return
        }

        lb.NewAtSelect(idx)
        reflectx.SliceNewAt(lb.Slice, idx)
        if idx < 0 {
                idx = lb.SliceSize
        }

        lb.This.(Lister).UpdateSliceSize()
        lb.SelectIndexEvent(idx, events.SelectOne)
        lb.UpdateChange()
        lb.IndexGrabFocus(idx)
}

// deleteAtRow deletes the element at the given display row.
func (lb *ListBase) deleteAtRow(row int) {
        lb.This.(Lister).DeleteAt(lb.StartIndex + row)
}

// NewAtSelect updates the selected rows based on
// inserting a new element at the given index.
func (lb *ListBase) NewAtSelect(i int) {
        sl := lb.SelectedIndexesList(false) // ascending
        lb.ResetSelectedIndexes()
        for _, ix := range sl {
                if ix >= i {
                        ix++
                }
                lb.SelectedIndexes[ix] = struct{}{}
        }
}

// DeleteAtSelect updates the selected rows based on
// deleting the element at the given index.
func (lb *ListBase) DeleteAtSelect(i int) {
        sl := lb.SelectedIndexesList(true) // desscending
        lb.ResetSelectedIndexes()
        for _, ix := range sl {
                switch {
                case ix == i:
                        continue
                case ix > i:
                        ix--
                }
                lb.SelectedIndexes[ix] = struct{}{}
        }
}

// DeleteAt deletes the element at the given index from the slice.
func (lb *ListBase) DeleteAt(i int) {
        if lb.isArray {
                return
        }
        if i < 0 || i >= lb.SliceSize {
                return
        }
        lb.DeleteAtSelect(i)
        reflectx.SliceDeleteAt(lb.Slice, i)
        lb.This.(Lister).UpdateSliceSize()
        lb.UpdateChange()
}

func (lb *ListBase) MakeToolbar(p *tree.Plan) {
        if reflectx.IsNil(reflect.ValueOf(lb.Slice)) {
                return
        }
        if lb.isArray || lb.IsReadOnly() {
                return
        }
        tree.Add(p, func(w *Button) {
                w.SetText("Add").SetIcon(icons.Add).SetTooltip("add a new element to the slice").
                        OnClick(func(e events.Event) {
                                lb.This.(Lister).NewAt(-1)
                        })
        })
}

////////
//  Row access methods
//  NOTE: row = physical GUI display row, idx = slice index
//  not the same!

// sliceValue returns value interface at given slice index.
func (lb *ListBase) sliceValue(idx int) any {
        if idx < 0 || idx >= lb.SliceSize {
                fmt.Printf("core.ListBase: slice index out of range: %v\n", idx)
                return nil
        }
        val := reflectx.UnderlyingPointer(lb.sliceUnderlying.Index(idx)) // deal with pointer lists
        vali := val.Interface()
        return vali
}

// IsRowInBounds returns true if disp row is in bounds
func (lb *ListBase) IsRowInBounds(row int) bool {
        return row >= 0 && row < lb.VisibleRows
}

// rowFirstWidget returns the first widget for given row (could be index or
// not) -- false if out of range
func (lb *ListBase) rowFirstWidget(row int) (*WidgetBase, bool) {
        if !lb.ShowIndexes {
                return nil, false
        }
        if !lb.IsRowInBounds(row) {
                return nil, false
        }
        nWidgPerRow, _ := lb.This.(Lister).RowWidgetNs()
        sg := lb.ListGrid
        w := sg.Children[row*nWidgPerRow].(Widget).AsWidget()
        return w, true
}

// RowGrabFocus grabs the focus for the first focusable widget
// in given row.  returns that element or nil if not successful
// note: grid must have already rendered for focus to be grabbed!
func (lb *ListBase) RowGrabFocus(row int) *WidgetBase {
        if !lb.IsRowInBounds(row) || lb.InFocusGrab { // range check
                return nil
        }
        nWidgPerRow, idxOff := lb.This.(Lister).RowWidgetNs()
        ridx := nWidgPerRow * row
        sg := lb.ListGrid
        w := sg.Child(ridx + idxOff).(Widget).AsWidget()
        if w.StateIs(states.Focused) {
                return w
        }
        lb.InFocusGrab = true
        w.SetFocus()
        lb.InFocusGrab = false
        return w
}

// IndexGrabFocus grabs the focus for the first focusable widget
// in given idx.  returns that element or nil if not successful.
func (lb *ListBase) IndexGrabFocus(idx int) *WidgetBase {
        lb.ScrollToIndex(idx)
        return lb.This.(Lister).RowGrabFocus(idx - lb.StartIndex)
}

// indexPos returns center of window position of index label for idx (ContextMenuPos)
func (lb *ListBase) indexPos(idx int) image.Point {
        row := idx - lb.StartIndex
        if row < 0 {
                row = 0
        }
        if row > lb.VisibleRows-1 {
                row = lb.VisibleRows - 1
        }
        var pos image.Point
        w, ok := lb.rowFirstWidget(row)
        if ok {
                pos = w.ContextMenuPos(nil)
        }
        return pos
}

// rowFromPos returns the row that contains given vertical position, false if not found
func (lb *ListBase) rowFromPos(posY int) (int, bool) {
        // todo: could optimize search to approx loc, and search up / down from there
        for rw := 0; rw < lb.VisibleRows; rw++ {
                w, ok := lb.rowFirstWidget(rw)
                if ok {
                        if w.Geom.TotalBBox.Min.Y < posY && posY < w.Geom.TotalBBox.Max.Y {
                                return rw, true
                        }
                }
        }
        return -1, false
}

// indexFromPos returns the idx that contains given vertical position, false if not found
func (lb *ListBase) indexFromPos(posY int) (int, bool) {
        row, ok := lb.rowFromPos(posY)
        if !ok {
                return -1, false
        }
        return row + lb.StartIndex, true
}

// ScrollToIndexNoUpdate ensures that given slice idx is visible
// by scrolling display as needed.
// This version does not update the slicegrid.
// Just computes the StartIndex and updates the scrollbar
func (lb *ListBase) ScrollToIndexNoUpdate(idx int) bool {
        if lb.VisibleRows == 0 {
                return false
        }
        if idx < lb.StartIndex {
                lb.StartIndex = idx
                lb.StartIndex = max(0, lb.StartIndex)
                lb.updateScroll()
                return true
        }
        if idx >= lb.StartIndex+(lb.VisibleRows-1) {
                lb.StartIndex = idx - (lb.VisibleRows - 4)
                lb.StartIndex = max(0, lb.StartIndex)
                lb.updateScroll()
                return true
        }
        return false
}

// ScrollToIndex ensures that given slice idx is visible
// by scrolling display as needed.
func (lb *ListBase) ScrollToIndex(idx int) bool {
        update := lb.ScrollToIndexNoUpdate(idx)
        if update {
                lb.Update()
        }
        return update
}

// sliceIndexByValue searches for first index that contains given value in slice;
// returns false if not found
func sliceIndexByValue(slc any, fldVal any) (int, bool) {
        svnp := reflectx.NonPointerValue(reflect.ValueOf(slc))
        sz := svnp.Len()
        for idx := 0; idx < sz; idx++ {
                rval := reflectx.NonPointerValue(svnp.Index(idx))
                if rval.Interface() == fldVal {
                        return idx, true
                }
        }
        return -1, false
}

// moveDown moves the selection down to next row, using given select mode
// (from keyboard modifiers) -- returns newly selected row or -1 if failed
func (lb *ListBase) moveDown(selMode events.SelectModes) int {
        if lb.SelectedIndex >= lb.SliceSize-1 {
                lb.SelectedIndex = lb.SliceSize - 1
                return -1
        }
        lb.SelectedIndex++
        lb.SelectIndexEvent(lb.SelectedIndex, selMode)
        return lb.SelectedIndex
}

// moveDownEvent moves the selection down to next row, using given select
// mode (from keyboard modifiers) -- and emits select event for newly selected
// row
func (lb *ListBase) moveDownEvent(selMode events.SelectModes) int {
        nidx := lb.moveDown(selMode)
        if nidx >= 0 {
                lb.ScrollToIndex(nidx)
                lb.Send(events.Select) // todo: need to do this for the item?
        }
        return nidx
}

// moveUp moves the selection up to previous idx, using given select mode
// (from keyboard modifiers) -- returns newly selected idx or -1 if failed
func (lb *ListBase) moveUp(selMode events.SelectModes) int {
        if lb.SelectedIndex < 0 {
                lb.SelectedIndex = lb.lastClick
        }
        if lb.SelectedIndex <= 0 {
                lb.SelectedIndex = 0
                return -1
        }
        lb.SelectedIndex--
        lb.SelectIndexEvent(lb.SelectedIndex, selMode)
        return lb.SelectedIndex
}

// moveUpEvent moves the selection up to previous idx, using given select
// mode (from keyboard modifiers) -- and emits select event for newly selected idx
func (lb *ListBase) moveUpEvent(selMode events.SelectModes) int {
        nidx := lb.moveUp(selMode)
        if nidx >= 0 {
                lb.ScrollToIndex(nidx)
                lb.Send(events.Select)
        }
        return nidx
}

// movePageDown moves the selection down to next page, using given select mode
// (from keyboard modifiers) -- returns newly selected idx or -1 if failed
func (lb *ListBase) movePageDown(selMode events.SelectModes) int {
        if lb.SelectedIndex >= lb.SliceSize-1 {
                lb.SelectedIndex = lb.SliceSize - 1
                return -1
        }
        lb.SelectedIndex += lb.VisibleRows
        lb.SelectedIndex = min(lb.SelectedIndex, lb.SliceSize-1)
        lb.SelectIndexEvent(lb.SelectedIndex, selMode)
        return lb.SelectedIndex
}

// movePageDownEvent moves the selection down to next page, using given select
// mode (from keyboard modifiers) -- and emits select event for newly selected idx
func (lb *ListBase) movePageDownEvent(selMode events.SelectModes) int {
        nidx := lb.movePageDown(selMode)
        if nidx >= 0 {
                lb.ScrollToIndex(nidx)
                lb.Send(events.Select)
        }
        return nidx
}

// movePageUp moves the selection up to previous page, using given select mode
// (from keyboard modifiers) -- returns newly selected idx or -1 if failed
func (lb *ListBase) movePageUp(selMode events.SelectModes) int {
        if lb.SelectedIndex <= 0 {
                lb.SelectedIndex = 0
                return -1
        }
        lb.SelectedIndex -= lb.VisibleRows
        lb.SelectedIndex = max(0, lb.SelectedIndex)
        lb.SelectIndexEvent(lb.SelectedIndex, selMode)
        return lb.SelectedIndex
}

// movePageUpEvent moves the selection up to previous page, using given select
// mode (from keyboard modifiers) -- and emits select event for newly selected idx
func (lb *ListBase) movePageUpEvent(selMode events.SelectModes) int {
        nidx := lb.movePageUp(selMode)
        if nidx >= 0 {
                lb.ScrollToIndex(nidx)
                lb.Send(events.Select)
        }
        return nidx
}

////////  Selection: user operates on the index labels

// updateSelectRow updates the selection for the given row
func (lb *ListBase) updateSelectRow(row int, selMode events.SelectModes) {
        idx := row + lb.StartIndex
        if row < 0 || idx >= lb.SliceSize {
                return
        }
        sel := !lb.indexIsSelected(idx)
        lb.updateSelectIndex(idx, sel, selMode)
}

// updateSelectIndex updates the selection for the given index
func (lb *ListBase) updateSelectIndex(idx int, sel bool, selMode events.SelectModes) {
        if lb.IsReadOnly() && !lb.ReadOnlyMultiSelect {
                lb.unselectAllIndexes()
                if sel || lb.SelectedIndex == idx {
                        lb.SelectedIndex = idx
                        lb.SelectIndex(idx)
                }
                lb.Send(events.Select)
                lb.Restyle()
        } else {
                lb.SelectIndexEvent(idx, selMode)
        }
}

// indexIsSelected returns the selected status of given slice index
func (lb *ListBase) indexIsSelected(idx int) bool {
        if lb.IsReadOnly() && !lb.ReadOnlyMultiSelect {
                return idx == lb.SelectedIndex
        }
        _, ok := lb.SelectedIndexes[idx]
        return ok
}

func (lb *ListBase) ResetSelectedIndexes() {
        lb.SelectedIndexes = make(map[int]struct{})
}

// SelectedIndexesList returns list of selected indexes,
// sorted either ascending or descending
func (lb *ListBase) SelectedIndexesList(descendingSort bool) []int {
        rws := make([]int, len(lb.SelectedIndexes))
        i := 0
        for r := range lb.SelectedIndexes {
                if r >= lb.SliceSize { // double safety check at this point
                        delete(lb.SelectedIndexes, r)
                        rws = rws[:len(rws)-1]
                        continue
                }
                rws[i] = r
                i++
        }
        if descendingSort {
                sort.Slice(rws, func(i, j int) bool {
                        return rws[i] > rws[j]
                })
        } else {
                sort.Slice(rws, func(i, j int) bool {
                        return rws[i] < rws[j]
                })
        }
        return rws
}

// SelectIndex selects given idx (if not already selected) -- updates select
// status of index label
func (lb *ListBase) SelectIndex(idx int) {
        lb.SelectedIndexes[idx] = struct{}{}
}

// unselectIndex unselects given idx (if selected)
func (lb *ListBase) unselectIndex(idx int) {
        if lb.indexIsSelected(idx) {
                delete(lb.SelectedIndexes, idx)
        }
}

// unselectAllIndexes unselects all selected idxs
func (lb *ListBase) unselectAllIndexes() {
        lb.ResetSelectedIndexes()
}

// selectAllIndexes selects all idxs
func (lb *ListBase) selectAllIndexes() {
        lb.unselectAllIndexes()
        lb.SelectedIndexes = make(map[int]struct{}, lb.SliceSize)
        for idx := 0; idx < lb.SliceSize; idx++ {
                lb.SelectedIndexes[idx] = struct{}{}
        }
        lb.NeedsRender()
}

// SelectIndexEvent is called when a select event has been received (e.g., a
// mouse click) -- translates into selection updates -- gets selection mode
// from mouse event (ExtendContinuous, ExtendOne)
func (lb *ListBase) SelectIndexEvent(idx int, mode events.SelectModes) {
        if mode == events.NoSelect {
                return
        }
        idx = min(idx, lb.SliceSize-1)
        if idx < 0 {
                lb.ResetSelectedIndexes()
                return
        }
        // row := idx - sv.StartIndex // note: could be out of bounds

        switch mode {
        case events.SelectOne:
                if lb.indexIsSelected(idx) {
                        if len(lb.SelectedIndexes) > 1 {
                                lb.unselectAllIndexes()
                        }
                        lb.SelectedIndex = idx
                        lb.SelectIndex(idx)
                        lb.IndexGrabFocus(idx)
                } else {
                        lb.unselectAllIndexes()
                        lb.SelectedIndex = idx
                        lb.SelectIndex(idx)
                        lb.IndexGrabFocus(idx)
                }
                lb.Send(events.Select) //  sv.SelectedIndex)
        case events.ExtendContinuous:
                if len(lb.SelectedIndexes) == 0 {
                        lb.SelectedIndex = idx
                        lb.SelectIndex(idx)
                        lb.IndexGrabFocus(idx)
                        lb.Send(events.Select) //  sv.SelectedIndex)
                } else {
                        minIndex := -1
                        maxIndex := 0
                        for r := range lb.SelectedIndexes {
                                if minIndex < 0 {
                                        minIndex = r
                                } else {
                                        minIndex = min(minIndex, r)
                                }
                                maxIndex = max(maxIndex, r)
                        }
                        cidx := idx
                        lb.SelectedIndex = idx
                        lb.SelectIndex(idx)
                        if idx < minIndex {
                                for cidx < minIndex {
                                        r := lb.moveDown(events.SelectQuiet) // just select
                                        cidx = r
                                }
                        } else if idx > maxIndex {
                                for cidx > maxIndex {
                                        r := lb.moveUp(events.SelectQuiet) // just select
                                        cidx = r
                                }
                        }
                        lb.IndexGrabFocus(idx)
                        lb.Send(events.Select) //  sv.SelectedIndex)
                }
        case events.ExtendOne:
                if lb.indexIsSelected(idx) {
                        lb.unselectIndexEvent(idx)
                        lb.Send(events.Select) //  sv.SelectedIndex)
                } else {
                        lb.SelectedIndex = idx
                        lb.SelectIndex(idx)
                        lb.IndexGrabFocus(idx)
                        lb.Send(events.Select) //  sv.SelectedIndex)
                }
        case events.Unselect:
                lb.SelectedIndex = idx
                lb.unselectIndexEvent(idx)
        case events.SelectQuiet:
                lb.SelectedIndex = idx
                lb.SelectIndex(idx)
        case events.UnselectQuiet:
                lb.SelectedIndex = idx
                lb.unselectIndex(idx)
        }
        lb.Restyle()
}

// unselectIndexEvent unselects this idx (if selected) -- and emits a signal
func (lb *ListBase) unselectIndexEvent(idx int) {
        if lb.indexIsSelected(idx) {
                lb.unselectIndex(idx)
        }
}

////////  Copy / Cut / Paste

// mimeDataIndex adds mimedata for given idx: an application/json of the struct
func (lb *ListBase) mimeDataIndex(md *mimedata.Mimes, idx int) {
        val := lb.sliceValue(idx)
        b, err := json.MarshalIndent(val, "", "  ")
        if err == nil {
                *md = append(*md, &mimedata.Data{Type: fileinfo.DataJson, Data: b})
        } else {
                log.Printf("ListBase MimeData JSON Marshall error: %v\n", err)
        }
}

// fromMimeData creates a slice of structs from mime data
func (lb *ListBase) fromMimeData(md mimedata.Mimes) []any {
        svtyp := lb.sliceUnderlying.Type()
        sl := make([]any, 0, len(md))
        for _, d := range md {
                if d.Type == fileinfo.DataJson {
                        nval := reflect.New(svtyp.Elem()).Interface()
                        err := json.Unmarshal(d.Data, nval)
                        if err == nil {
                                sl = append(sl, nval)
                        } else {
                                log.Printf("ListBase FromMimeData: JSON load error: %v\n", err)
                        }
                }
        }
        return sl
}

// MimeDataType returns the data type for mime clipboard (copy / paste) data
// e.g., fileinfo.DataJson
func (lb *ListBase) MimeDataType() string {
        return fileinfo.DataJson
}

// CopySelectToMime copies selected rows to mime data
func (lb *ListBase) CopySelectToMime() mimedata.Mimes {
        nitms := len(lb.SelectedIndexes)
        if nitms == 0 {
                return nil
        }
        ixs := lb.SelectedIndexesList(false) // ascending
        md := make(mimedata.Mimes, 0, nitms)
        for _, i := range ixs {
                lb.mimeDataIndex(&md, i)
        }
        return md
}

// copyIndexes copies selected idxs to system.Clipboard, optionally resetting the selection
func (lb *ListBase) copyIndexes(reset bool) { //types:add
        nitms := len(lb.SelectedIndexes)
        if nitms == 0 {
                return
        }
        md := lb.This.(Lister).CopySelectToMime()
        if md != nil {
                lb.Clipboard().Write(md)
        }
        if reset {
                lb.unselectAllIndexes()
        }
}

// cutIndexes copies selected indexes to system.Clipboard and deletes selected indexes
func (lb *ListBase) cutIndexes() { //types:add
        if len(lb.SelectedIndexes) == 0 {
                return
        }

        lb.copyIndexes(false)
        ixs := lb.SelectedIndexesList(true) // descending sort
        idx := ixs[0]
        lb.unselectAllIndexes()
        for _, i := range ixs {
                lb.This.(Lister).DeleteAt(i)
        }
        lb.SendChange()
        lb.SelectIndexEvent(idx, events.SelectOne)
        lb.Update()
}

// pasteIndex pastes clipboard at given idx
func (lb *ListBase) pasteIndex(idx int) { //types:add
        lb.tmpIndex = idx
        dt := lb.This.(Lister).MimeDataType()
        md := lb.Clipboard().Read([]string{dt})
        if md != nil {
                lb.pasteMenu(md, lb.tmpIndex)
        }
}

// makePasteMenu makes the menu of options for paste events
func (lb *ListBase) makePasteMenu(m *Scene, md mimedata.Mimes, idx int, mod events.DropMods, fun func()) {
        ls := lb.This.(Lister)
        if mod == events.DropCopy {
                NewButton(m).SetText("Assign to").OnClick(func(e events.Event) {
                        ls.PasteAssign(md, idx)
                        if fun != nil {
                                fun()
                        }
                })
        }
        NewButton(m).SetText("Insert before").OnClick(func(e events.Event) {
                ls.PasteAtIndex(md, idx)
                if fun != nil {
                        fun()
                }
        })
        NewButton(m).SetText("Insert after").OnClick(func(e events.Event) {
                ls.PasteAtIndex(md, idx+1)
                if fun != nil {
                        fun()
                }
        })
        NewButton(m).SetText("Cancel")
}

// pasteMenu performs a paste from the clipboard using given data -- pops up
// a menu to determine what specifically to do
func (lb *ListBase) pasteMenu(md mimedata.Mimes, idx int) {
        lb.unselectAllIndexes()
        mf := func(m *Scene) {
                lb.makePasteMenu(m, md, idx, events.DropCopy, nil)
        }
        pos := lb.indexPos(idx)
        NewMenu(mf, lb.This.(Widget), pos).Run()
}

// PasteAssign assigns mime data (only the first one!) to this idx
func (lb *ListBase) PasteAssign(md mimedata.Mimes, idx int) {
        sl := lb.fromMimeData(md)
        if len(sl) == 0 {
                return
        }
        ns := sl[0]
        lb.sliceUnderlying.Index(idx).Set(reflect.ValueOf(ns).Elem())
        lb.UpdateChange()
}

// PasteAtIndex inserts object(s) from mime data at (before) given slice index
func (lb *ListBase) PasteAtIndex(md mimedata.Mimes, idx int) {
        sl := lb.fromMimeData(md)
        if len(sl) == 0 {
                return
        }
        svl := reflect.ValueOf(lb.Slice)
        svnp := lb.sliceUnderlying

        for _, ns := range sl {
                sz := svnp.Len()
                svnp = reflect.Append(svnp, reflect.ValueOf(ns).Elem())
                svl.Elem().Set(svnp)
                if idx >= 0 && idx < sz {
                        reflect.Copy(svnp.Slice(idx+1, sz+1), svnp.Slice(idx, sz))
                        svnp.Index(idx).Set(reflect.ValueOf(ns).Elem())
                        svl.Elem().Set(svnp)
                }
                idx++
        }

        lb.sliceUnderlying = reflectx.NonPointerValue(reflect.ValueOf(lb.Slice)) // need to update after changes

        lb.SendChange()
        lb.SelectIndexEvent(idx, events.SelectOne)
        lb.Update()
}

// duplicate copies selected items and inserts them after current selection --
// return idx of start of duplicates if successful, else -1
func (lb *ListBase) duplicate() int { //types:add
        nitms := len(lb.SelectedIndexes)
        if nitms == 0 {
                return -1
        }
        ixs := lb.SelectedIndexesList(true) // descending sort -- last first
        pasteAt := ixs[0]
        lb.copyIndexes(true)
        dt := lb.This.(Lister).MimeDataType()
        md := lb.Clipboard().Read([]string{dt})
        lb.This.(Lister).PasteAtIndex(md, pasteAt)
        return pasteAt
}

//////// Drag-n-Drop

// selectRowIfNone selects the row the mouse is on if there
// are no currently selected items.  Returns false if no valid mouse row.
func (lb *ListBase) selectRowIfNone(e events.Event) bool {
        nitms := len(lb.SelectedIndexes)
        if nitms > 0 {
                return true
        }
        row, _, isValid := lb.ListGrid.indexFromPixel(e.Pos())
        if !isValid {
                return false
        }
        lb.updateSelectRow(row, e.SelectMode())
        return true
}

// mousePosInGrid returns true if the event mouse position is
// located within the slicegrid.
func (lb *ListBase) mousePosInGrid(e events.Event) bool {
        return lb.ListGrid.mousePosInGrid(e.Pos())
}

func (lb *ListBase) dragStart(e events.Event) {
        if !lb.selectRowIfNone(e) || !lb.mousePosInGrid(e) {
                return
        }
        ixs := lb.SelectedIndexesList(false) // ascending
        if len(ixs) == 0 {
                return
        }
        md := lb.This.(Lister).CopySelectToMime()
        w, ok := lb.rowFirstWidget(ixs[0] - lb.StartIndex)
        if ok {
                lb.Scene.Events.DragStart(w, md, e)
                e.SetHandled()
                // } else {
                //         fmt.Println("List DND programmer error")
        }
}

func (lb *ListBase) dragDrop(e events.Event) {
        de := e.(*events.DragDrop)
        if de.Data == nil {
                return
        }
        pos := de.Pos()
        idx, ok := lb.indexFromPos(pos.Y)
        if ok {
                // sv.DraggedIndexes = nil
                lb.tmpIndex = idx
                lb.saveDraggedIndexes(idx)
                md := de.Data.(mimedata.Mimes)
                mf := func(m *Scene) {
                        lb.Scene.Events.DragMenuAddModText(m, de.DropMod)
                        lb.makePasteMenu(m, md, idx, de.DropMod, func() {
                                lb.dropFinalize(de)
                        })
                }
                pos := lb.indexPos(lb.tmpIndex)
                NewMenu(mf, lb.This.(Widget), pos).Run()
        }
}

// dropFinalize is called to finalize Drop actions on the Source node.
// Only relevant for DropMod == DropMove.
func (lb *ListBase) dropFinalize(de *events.DragDrop) {
        lb.NeedsLayout()
        lb.unselectAllIndexes()
        lb.Scene.Events.DropFinalize(de) // sends DropDeleteSource to Source
}

// dropDeleteSource handles delete source event for DropMove case
func (lb *ListBase) dropDeleteSource(e events.Event) {
        sort.Slice(lb.draggedIndexes, func(i, j int) bool {
                return lb.draggedIndexes[i] > lb.draggedIndexes[j]
        })
        idx := lb.draggedIndexes[0]
        for _, i := range lb.draggedIndexes {
                lb.This.(Lister).DeleteAt(i)
        }
        lb.draggedIndexes = nil
        lb.SelectIndexEvent(idx, events.SelectOne)
}

// saveDraggedIndexes saves selectedindexes into dragged indexes
// taking into account insertion at idx
func (lb *ListBase) saveDraggedIndexes(idx int) {
        sz := len(lb.SelectedIndexes)
        if sz == 0 {
                lb.draggedIndexes = nil
                return
        }
        ixs := lb.SelectedIndexesList(false) // ascending
        lb.draggedIndexes = make([]int, len(ixs))
        for i, ix := range ixs {
                if ix > idx {
                        lb.draggedIndexes[i] = ix + sz // make room for insertion
                } else {
                        lb.draggedIndexes[i] = ix
                }
        }
}

func (lb *ListBase) contextMenu(m *Scene) {
        if lb.IsReadOnly() || lb.isArray {
                NewButton(m).SetText("Copy").SetIcon(icons.Copy).OnClick(func(e events.Event) {
                        lb.copyIndexes(true)
                })
                NewSeparator(m)
                NewButton(m).SetText("Toggle indexes").SetIcon(icons.Numbers).OnClick(func(e events.Event) {
                        lb.ShowIndexes = !lb.ShowIndexes
                        lb.Update()
                })
                return
        }
        NewButton(m).SetText("Add row").SetIcon(icons.Add).OnClick(func(e events.Event) {
                lb.newAtRow((lb.SelectedIndex - lb.StartIndex) + 1)
        })
        NewButton(m).SetText("Delete row").SetIcon(icons.Delete).OnClick(func(e events.Event) {
                lb.deleteAtRow(lb.SelectedIndex - lb.StartIndex)
        })
        NewSeparator(m)
        NewButton(m).SetText("Copy").SetIcon(icons.Copy).OnClick(func(e events.Event) {
                lb.copyIndexes(true)
        })
        NewButton(m).SetText("Cut").SetIcon(icons.Cut).OnClick(func(e events.Event) {
                lb.cutIndexes()
        })
        NewButton(m).SetText("Paste").SetIcon(icons.Paste).OnClick(func(e events.Event) {
                lb.pasteIndex(lb.SelectedIndex)
        })
        NewButton(m).SetText("Duplicate").SetIcon(icons.Copy).OnClick(func(e events.Event) {
                lb.duplicate()
        })
        NewSeparator(m)
        NewButton(m).SetText("Toggle indexes").SetIcon(icons.Numbers).OnClick(func(e events.Event) {
                lb.ShowIndexes = !lb.ShowIndexes
                lb.Update()
        })
}

// keyInputNav supports multiple selection navigation keys
func (lb *ListBase) keyInputNav(kt events.Event) {
        kf := keymap.Of(kt.KeyChord())
        selMode := events.SelectModeBits(kt.Modifiers())
        if selMode == events.SelectOne {
                if lb.SelectMode {
                        selMode = events.ExtendContinuous
                }
        }
        switch kf {
        case keymap.CancelSelect:
                lb.unselectAllIndexes()
                lb.SelectMode = false
                kt.SetHandled()
        case keymap.MoveDown:
                lb.moveDownEvent(selMode)
                kt.SetHandled()
        case keymap.MoveUp:
                lb.moveUpEvent(selMode)
                kt.SetHandled()
        case keymap.PageDown:
                lb.movePageDownEvent(selMode)
                kt.SetHandled()
        case keymap.PageUp:
                lb.movePageUpEvent(selMode)
                kt.SetHandled()
        case keymap.SelectMode:
                lb.SelectMode = !lb.SelectMode
                kt.SetHandled()
        case keymap.SelectAll:
                lb.selectAllIndexes()
                lb.SelectMode = false
                kt.SetHandled()
        }
}

func (lb *ListBase) keyInputEditable(kt events.Event) {
        lb.keyInputNav(kt)
        if kt.IsHandled() {
                return
        }
        idx := lb.SelectedIndex
        kf := keymap.Of(kt.KeyChord())
        if DebugSettings.KeyEventTrace {
                slog.Info("ListBase KeyInput", "widget", lb, "keyFunction", kf)
        }
        switch kf {
        // case keymap.Delete: // too dangerous
        //         sv.This.(Lister).SliceDeleteAt(sv.SelectedIndex)
        //         sv.SelectMode = false
        //         sv.SelectIndexEvent(idx, events.SelectOne)
        //         kt.SetHandled()
        case keymap.Duplicate:
                nidx := lb.duplicate()
                lb.SelectMode = false
                if nidx >= 0 {
                        lb.SelectIndexEvent(nidx, events.SelectOne)
                }
                kt.SetHandled()
        case keymap.Insert:
                lb.This.(Lister).NewAt(idx)
                lb.SelectMode = false
                lb.SelectIndexEvent(idx+1, events.SelectOne) // todo: somehow nidx not working
                kt.SetHandled()
        case keymap.InsertAfter:
                lb.This.(Lister).NewAt(idx + 1)
                lb.SelectMode = false
                lb.SelectIndexEvent(idx+1, events.SelectOne)
                kt.SetHandled()
        case keymap.Copy:
                lb.copyIndexes(true)
                lb.SelectMode = false
                lb.SelectIndexEvent(idx, events.SelectOne)
                kt.SetHandled()
        case keymap.Cut:
                lb.cutIndexes()
                lb.SelectMode = false
                kt.SetHandled()
        case keymap.Paste:
                lb.pasteIndex(lb.SelectedIndex)
                lb.SelectMode = false
                kt.SetHandled()
        }
}

func (lb *ListBase) keyInputReadOnly(kt events.Event) {
        if lb.ReadOnlyMultiSelect {
                lb.keyInputNav(kt)
                if kt.IsHandled() {
                        return
                }
        }
        selMode := kt.SelectMode()
        if lb.SelectMode {
                selMode = events.ExtendOne
        }
        kf := keymap.Of(kt.KeyChord())
        if DebugSettings.KeyEventTrace {
                slog.Info("ListBase ReadOnly KeyInput", "widget", lb, "keyFunction", kf)
        }
        idx := lb.SelectedIndex
        switch {
        case kf == keymap.MoveDown:
                ni := idx + 1
                if ni < lb.SliceSize {
                        lb.ScrollToIndex(ni)
                        lb.updateSelectIndex(ni, true, selMode)
                        kt.SetHandled()
                }
        case kf == keymap.MoveUp:
                ni := idx - 1
                if ni >= 0 {
                        lb.ScrollToIndex(ni)
                        lb.updateSelectIndex(ni, true, selMode)
                        kt.SetHandled()
                }
        case kf == keymap.PageDown:
                ni := min(idx+lb.VisibleRows-1, lb.SliceSize-1)
                lb.ScrollToIndex(ni)
                lb.updateSelectIndex(ni, true, selMode)
                kt.SetHandled()
        case kf == keymap.PageUp:
                ni := max(idx-(lb.VisibleRows-1), 0)
                lb.ScrollToIndex(ni)
                lb.updateSelectIndex(ni, true, selMode)
                kt.SetHandled()
        case kf == keymap.Enter || kf == keymap.Accept || kt.KeyRune() == ' ':
                lb.Send(events.DoubleClick, kt)
                kt.SetHandled()
        }
}

func (lb *ListBase) SizeFinal() {
        sg := lb.ListGrid
        if sg == nil {
                lb.Frame.SizeFinal()
                return
        }
        localIter := 0
        for (lb.MakeIter < 2 || lb.VisibleRows != sg.visibleRows) && localIter < 2 {
                if lb.VisibleRows != sg.visibleRows {
                        lb.VisibleRows = sg.visibleRows
                        lb.Update()
                } else {
                        sg.StyleTree()
                }
                sg.sizeFinalUpdateChildrenSizes()
                lb.MakeIter++
                localIter++
        }
        lb.Frame.SizeFinal()
}

// ListGrid handles the resizing logic for all [Lister]s.
type ListGrid struct { //core:no-new
        Frame

        // minRows is set from parent [List]
        minRows int

        // height of a single row, computed during layout
        rowHeight float32

        // total number of rows visible in allocated display size
        visibleRows int

        // Various computed backgrounds
        bgStripe, bgSelect, bgSelectStripe, bgHover, bgHoverStripe, bgHoverSelect, bgHoverSelectStripe image.Image

        // lastBackground is the background for which modified
        // backgrounds were computed -- don't update if same
        lastBackground image.Image
}

func (lg *ListGrid) Init() {
        lg.Frame.Init()
        lg.handleKeyNav = false
        lg.Styler(func(s *styles.Style) {
                s.Display = styles.Grid
        })
}

func (lg *ListGrid) SizeFromChildren(iter int, pass LayoutPasses) math32.Vector2 {
        csz := lg.Frame.SizeFromChildren(iter, pass)
        rht, err := lg.layout.rowHeight(0, 0)
        rht += lg.layout.Gap.Y
        if err != nil {
                // fmt.Println("ListGrid Sizing Error:", err)
                lg.rowHeight = 42
        }
        lg.rowHeight = rht
        if lg.rowHeight == 0 {
                // fmt.Println("ListGrid Sizing Error: RowHeight should not be 0!", sg)
                lg.rowHeight = 42
        }
        allocHt := lg.Geom.Size.Alloc.Content.Y
        if allocHt > lg.rowHeight {
                lg.visibleRows = int(math32.Ceil(allocHt / lg.rowHeight))
        }
        lg.visibleRows = max(lg.visibleRows, lg.minRows)
        minHt := lg.rowHeight * float32(lg.minRows)
        // fmt.Println("VisRows:", sg.VisRows, "rh:", sg.RowHeight, "ht:", minHt)
        // visHt := sg.RowHeight * float32(sg.VisRows)
        csz.Y = minHt
        return csz
}

func (lg *ListGrid) list() *ListBase {
        ls := tree.ParentByType[Lister](lg)
        return ls.AsListBase()
}

func (lg *ListGrid) ScrollChanged(d math32.Dims, sb *Slider) {
        if d == math32.X {
                lg.Frame.ScrollChanged(d, sb)
                return
        }
        ls := lg.list()
        rht := lg.rowHeight
        quo := sb.Value / rht
        floor := math32.Floor(quo)
        ls.StartIndex = int(floor)
        lg.Geom.Scroll.Y = (floor - quo) * rht
        ls.ApplyScenePos()
        ls.UpdateTree()
        ls.NeedsRender()
        // ls.NeedsLayout() // needed to recompute size after resize
}

func (lg *ListGrid) ScrollValues(d math32.Dims) (maxSize, visSize, visPct float32) {
        if d == math32.X {
                return lg.Frame.ScrollValues(d)
        }
        ls := lg.list()
        maxSize = float32(max(ls.SliceSize, 1)) * lg.rowHeight
        visSize = lg.Geom.Size.Alloc.Content.Y
        visPct = visSize / maxSize
        return
}

func (lg *ListGrid) updateScroll(idx int) {
        if !lg.HasScroll[math32.Y] || lg.Scrolls[math32.Y] == nil {
                return
        }
        sb := lg.Scrolls[math32.Y]
        sb.SetValue(float32(idx) * lg.rowHeight)
}

func (lg *ListGrid) updateBackgrounds() {
        bg := lg.Styles.ActualBackground
        if lg.lastBackground == bg {
                return
        }
        lg.lastBackground = bg

        // we take our zebra intensity applied foreground color and then overlay it onto our background color

        zclr := colors.WithAF32(colors.ToUniform(lg.Styles.Color), AppearanceSettings.ZebraStripesWeight())
        lg.bgStripe = gradient.Apply(bg, func(c color.Color) color.Color {
                return colors.AlphaBlend(c, zclr)
        })

        hclr := colors.WithAF32(colors.ToUniform(lg.Styles.Color), 0.08)
        lg.bgHover = gradient.Apply(bg, func(c color.Color) color.Color {
                return colors.AlphaBlend(c, hclr)
        })

        zhclr := colors.WithAF32(colors.ToUniform(lg.Styles.Color), AppearanceSettings.ZebraStripesWeight()+0.08)
        lg.bgHoverStripe = gradient.Apply(bg, func(c color.Color) color.Color {
                return colors.AlphaBlend(c, zhclr)
        })

        lg.bgSelect = colors.Scheme.Select.Container

        lg.bgSelectStripe = colors.Uniform(colors.AlphaBlend(colors.ToUniform(colors.Scheme.Select.Container), zclr))

        lg.bgHoverSelect = colors.Uniform(colors.AlphaBlend(colors.ToUniform(colors.Scheme.Select.Container), hclr))

        lg.bgHoverSelectStripe = colors.Uniform(colors.AlphaBlend(colors.ToUniform(colors.Scheme.Select.Container), zhclr))

}

func (lg *ListGrid) rowBackground(sel, stripe, hover bool) image.Image {
        switch {
        case sel && stripe && hover:
                return lg.bgHoverSelectStripe
        case sel && stripe:
                return lg.bgSelectStripe
        case sel && hover:
                return lg.bgHoverSelect
        case sel:
                return lg.bgSelect
        case stripe && hover:
                return lg.bgHoverStripe
        case stripe:
                return lg.bgStripe
        case hover:
                return lg.bgHover
        default:
                return lg.Styles.ActualBackground
        }
}

func (lg *ListGrid) ChildBackground(child Widget) image.Image {
        ls := lg.list()
        lg.updateBackgrounds()
        row, _ := ls.widgetIndex(child)
        si := row + ls.StartIndex
        return lg.rowBackground(ls.indexIsSelected(si), si%2 == 1, row == ls.hoverRow)
}

func (lg *ListGrid) renderStripes() {
        pos := lg.Geom.Pos.Content
        sz := lg.Geom.Size.Actual.Content
        if lg.visibleRows == 0 || sz.Y == 0 {
                return
        }
        lg.updateBackgrounds()

        pc := &lg.Scene.Painter
        rows := lg.layout.Shape.Y
        cols := lg.layout.Shape.X
        st := pos
        offset := 0
        ls := lg.list()
        startIndex := 0
        if ls != nil {
                startIndex = ls.StartIndex
                offset = startIndex % 2
        }
        for r := 0; r < rows; r++ {
                si := r + startIndex
                ht := lg.rowHeight
                miny := st.Y
                for c := 0; c < cols; c++ {
                        ki := r*cols + c
                        if ki < lg.NumChildren() {
                                kw := lg.Child(ki).(Widget).AsWidget()
                                pyi := math32.Floor(kw.Geom.Pos.Total.Y)
                                if pyi < miny {
                                        miny = pyi
                                }
                        }
                }
                st.Y = miny
                ssz := sz
                ssz.Y = ht
                stripe := (r+offset)%2 == 1
                sbg := lg.rowBackground(ls.indexIsSelected(si), stripe, r == ls.hoverRow)
                pc.BlitBox(st, ssz, sbg)
                st.Y += ht
        }
}

// mousePosInGrid returns true if the event mouse position is
// located within the slicegrid.
func (lg *ListGrid) mousePosInGrid(pt image.Point) bool {
        ptrel := lg.PointToRelPos(pt)
        sz := lg.Geom.ContentBBox.Size()
        if lg.visibleRows == 0 || sz.Y == 0 {
                return false
        }
        if ptrel.Y < 0 || ptrel.Y >= sz.Y || ptrel.X < 0 || ptrel.X >= sz.X-50 { // leave margin on rhs around scroll
                return false
        }
        return true
}

// indexFromPixel returns the row, column indexes of given pixel point within grid.
// Takes a scene-level position.
func (lg *ListGrid) indexFromPixel(pt image.Point) (row, col int, isValid bool) {
        if !lg.mousePosInGrid(pt) {
                return
        }
        ptf := math32.FromPoint(lg.PointToRelPos(pt))
        sz := math32.FromPoint(lg.Geom.ContentBBox.Size())
        isValid = true
        rows := lg.layout.Shape.Y
        cols := lg.layout.Shape.X
        st := math32.Vector2{}
        st.Y = lg.Geom.Scroll.Y
        got := false
        for r := 0; r < rows; r++ {
                ht := lg.rowHeight
                miny := st.Y
                if r > 0 {
                        for c := 0; c < cols; c++ {
                                kwt := lg.Child(r*cols + c)
                                if kwt == nil {
                                        continue
                                }
                                kw := kwt.(Widget).AsWidget()
                                pyi := math32.Floor(kw.Geom.Pos.Total.Y)
                                if pyi < miny {
                                        miny = pyi
                                }
                        }
                }
                st.Y = miny
                ssz := sz
                ssz.Y = ht
                if ptf.Y >= st.Y && ptf.Y < st.Y+ssz.Y {
                        row = r
                        got = true
                        break
                        // todo: col
                }
                st.Y += ht
        }
        if !got {
                row = rows - 1
        }
        return
}

func (lg *ListGrid) Render() {
        lg.WidgetBase.Render()
        lg.renderStripes()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "log/slog"

        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
)

// newMainStage returns a new MainStage with given type and scene contents.
// Make further configuration choices using Set* methods, which
// can be chained directly after the newMainStage call.
// Use an appropriate Run call at the end to start the Stage running.
func newMainStage(typ StageTypes, sc *Scene) *Stage {
        st := &Stage{}
        st.setType(typ)
        st.setScene(sc)
        st.popups = &stages{}
        st.popups.main = st
        st.Main = st
        return st
}

// RunMainWindow creates a new main window from the body,
// runs it, starts the app's main loop, and waits for all windows
// to close. It should typically be called once by every app at
// the end of their main function. It can not be called more than
// once for one app. For secondary windows, see [Body.RunWindow].
// If you need to configure the [Stage] further, use [Body.NewWindow]
// and then [Stage.RunMain] on the resulting [Stage].
func (bd *Body) RunMainWindow() {
        if ExternalParent != nil {
                bd.handleExternalParent()
                return
        }
        bd.RunWindow()
        Wait()
}

// RunMain runs the stage, starts the app's main loop,
// and waits for all windows to close. It can be called instead
// of [Body.RunMainWindow] if extra configuration steps are necessary
// on the [Stage]. It can not be called more than once for one app.
// For secondary stages, see [Stage.Run].
func (st *Stage) RunMain() {
        if ExternalParent != nil {
                st.Scene.Body.handleExternalParent()
                return
        }
        st.Run()
        Wait()
}

// ExternalParent is a parent widget external to this program.
// If it is set, calls to [Body.RunWindow] before [Wait] and
// calls to [Body.RunMainWindow] and [Stage.RunMain] will add the [Body] to this
// parent instead of creating a new window. It should typically not be
// used by end users; it is used in yaegicore and for pre-rendering apps
// as HTML that can be used as a preview and for SEO purposes.
var ExternalParent Widget

// waitCalled is whether [Wait] has been called. It is used for
// [ExternalParent] logic in [Body.RunWindow].
var waitCalled bool

// RunWindow returns and runs a new [WindowStage] that is placed in
// a new system window on multi-window platforms.
// See [Body.NewWindow] to make a window without running it.
// For the first window of your app, you should typically call
// [Body.RunMainWindow] instead.
func (bd *Body) RunWindow() *Stage {
        if ExternalParent != nil && !waitCalled {
                bd.handleExternalParent()
                return nil
        }
        return bd.NewWindow().Run()
}

// handleExternalParent handles [ExternalParent] logic for
// [Body.RunWindow] and [Body.RunMainWindow].
func (bd *Body) handleExternalParent() {
        ExternalParent.AsWidget().AddChild(bd)
        // we must set the correct scene for each node
        bd.WalkDown(func(n tree.Node) bool {
                n.(Widget).AsWidget().Scene = bd.Scene
                return tree.Continue
        })
        // we must not get additional scrollbars here
        bd.Styler(func(s *styles.Style) {
                s.Overflow.Set(styles.OverflowVisible)
        })
}

// NewWindow returns a new [WindowStage] that is placed in
// a new system window on multi-window platforms.
// You must call [Stage.Run] or [Stage.RunMain] to run the window;
// see [Body.RunWindow] and [Body.RunMainWindow] for versions that
// automatically do so.
func (bd *Body) NewWindow() *Stage {
        ms := newMainStage(WindowStage, bd.Scene)
        ms.SetNewWindow(true)
        return ms
}

func (st *Stage) addSceneParts() {
        if st.Type != DialogStage || st.FullWindow || st.NewWindow {
                return
        }
        // TODO: convert to use [Scene.Bars] instead of parts
        sc := st.Scene
        parts := sc.newParts()
        parts.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
                s.Grow.Set(0, 1)
                s.Gap.Zero()
        })
        mv := NewHandle(parts)
        mv.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
        })
        mv.FinalStyler(func(s *styles.Style) {
                s.Cursor = cursors.Move
        })
        mv.SetName("move")
        mv.OnChange(func(e events.Event) {
                e.SetHandled()
                pd := e.PrevDelta()
                np := sc.SceneGeom.Pos.Add(pd)
                np.X = max(np.X, 0)
                np.Y = max(np.Y, 0)
                rw := sc.RenderWindow()
                sz := rw.SystemWindow.Size()
                mx := sz.X - int(sc.SceneGeom.Size.X)
                my := sz.Y - int(sc.SceneGeom.Size.Y)
                np.X = min(np.X, mx)
                np.Y = min(np.Y, my)
                sc.SceneGeom.Pos = np
                sc.NeedsRender()
        })
        if st.Resizable {
                rsz := NewHandle(parts)
                rsz.Styler(func(s *styles.Style) {
                        s.Direction = styles.Column
                        s.FillMargin = false
                })
                rsz.FinalStyler(func(s *styles.Style) {
                        s.Cursor = cursors.ResizeNWSE
                        s.Min.Set(units.Em(1))
                })
                rsz.SetName("resize")
                rsz.OnChange(func(e events.Event) {
                        e.SetHandled()
                        pd := e.PrevDelta()
                        np := sc.SceneGeom.Size.Add(pd)
                        minsz := 100
                        np.X = max(np.X, minsz)
                        np.Y = max(np.Y, minsz)
                        ng := sc.SceneGeom
                        ng.Size = np
                        sc.resize(ng)
                })
        }
}

// firstWindowStages creates a temporary [stages] for the first window
// to be able to get sizing information prior to having a RenderWindow,
// based on the system App Screen Size. Only adds a RenderContext.
func (st *Stage) firstWindowStages() *stages {
        ms := &stages{}
        ms.renderContext = newRenderContext()
        return ms
}

// targetScreen returns the screen to use for opening a new window
// based on Screen field, currentRenderWindow's screen, and a fallback
// default of Screen 0.
func (st *Stage) targetScreen() *system.Screen {
        if st.Screen >= 0 && st.Screen < TheApp.NScreens() {
                return TheApp.Screen(st.Screen)
        }
        if currentRenderWindow != nil {
                return currentRenderWindow.SystemWindow.Screen()
        }
        return TheApp.Screen(0)
}

// configMainStage does main-stage configuration steps
func (st *Stage) configMainStage() {
        sc := st.Scene
        if st.NewWindow {
                st.FullWindow = true
        }
        if TheApp.Platform().IsMobile() {
                // If we are a new window dialog on a large single-window platform,
                // we use a modeless dialog as a substitute.
                if st.NewWindow && st.Type == DialogStage && st.Context != nil && st.Context.AsWidget().SizeClass() != SizeCompact {
                        st.FullWindow = false
                        st.Modal = false
                        st.Scrim = false
                        // Default is to add back button in this situation.
                        if !st.BackButton.Valid {
                                st.SetBackButton(true)
                        }
                }
                // If we are on mobile, we can never have new windows.
                st.NewWindow = false
        }
        if st.FullWindow || st.NewWindow {
                st.Scrim = false
        }
        sc.makeSceneBars()
        sc.updateScene()
}

// runWindow runs a Window with current settings.
func (st *Stage) runWindow() *Stage {
        sc := st.Scene
        if currentRenderWindow == nil {
                // If we have no current render window, we need to be in a new window,
                // and we need a *temporary* Mains to get initial pref size
                st.setMains(st.firstWindowStages())
        } else {
                st.setMains(&currentRenderWindow.mains)
        }
        st.configMainStage()
        st.addSceneParts()

        sz := st.renderContext.geom.Size
        // Mobile windows must take up the whole window
        // and thus don't consider pref size.
        // Desktop new windows and non-full windows can pref size.
        if !TheApp.Platform().IsMobile() &&
                (st.NewWindow || !st.FullWindow || currentRenderWindow == nil) {
                sz = sc.contentSize(sz)
                // On offscreen, we don't want any extra space, as we want the smallest
                // possible representation of the content.
                if TheApp.Platform() != system.Offscreen {
                        sz = sz.Add(image.Pt(20, 20))
                        screen := st.targetScreen()
                        if screen != nil {
                                st.SetScreen(screen.ScreenNumber)
                                if st.NewWindow && st.UseMinSize {
                                        // we require windows to be at least 60% and no more than 80% of the
                                        // screen size by default
                                        scsz := screen.PixelSize
                                        sz = image.Pt(max(sz.X, scsz.X*6/10), max(sz.Y, scsz.Y*6/10))
                                        sz = image.Pt(min(sz.X, scsz.X*8/10), min(sz.Y, scsz.Y*8/10))
                                }
                        }
                }
        }
        st.Mains = nil // reset
        if DebugSettings.WindowRenderTrace {
                fmt.Println("MainStage.RunWindow: Window Size:", sz)
        }

        if st.NewWindow || currentRenderWindow == nil {
                sc.resize(math32.Geom2DInt{st.renderContext.geom.Pos, sz})
                win := st.newRenderWindow()
                mainRenderWindows.add(win)
                setCurrentRenderWindow(win)
                win.goStartEventLoop()
                return st
        }
        if st.Context != nil {
                ms := st.Context.AsWidget().Scene.Stage.Mains
                msc := ms.top().Scene
                sc.SceneGeom.Size = sz
                sc.fitInWindow(msc.SceneGeom) // does resize
                ms.push(st)
                st.setMains(ms)
        } else {
                ms := &currentRenderWindow.mains
                msc := ms.top().Scene
                sc.SceneGeom.Size = sz
                sc.fitInWindow(msc.SceneGeom) // does resize
                ms.push(st)
                st.setMains(ms)
        }
        return st
}

// getValidContext ensures that the Context is non-nil and has a valid
// Scene pointer, using CurrentRenderWindow if the current Context is not valid.
// If CurrentRenderWindow is nil (should not happen), then it returns false and
// the calling function must bail.
func (st *Stage) getValidContext() bool {
        if st.Context == nil || st.Context.AsTree().This == nil || st.Context.AsWidget().Scene == nil {
                if currentRenderWindow == nil {
                        slog.Error("Stage.Run: Context is nil and CurrentRenderWindow is nil, so cannot Run", "Name", st.Name, "Title", st.Title)
                        return false
                }
                st.Context = currentRenderWindow.mains.top().Scene
        }
        return true
}

// runDialog runs a Dialog with current settings.
func (st *Stage) runDialog() *Stage {
        if !st.getValidContext() {
                return st
        }
        ctx := st.Context.AsWidget()

        // if our main stages are nil, we wait until our context is shown and then try again
        if ctx.Scene.Stage == nil || ctx.Scene.Stage.Mains == nil {
                ctx.Defer(func() {
                        st.runDialog()
                })
                return st
        }

        ms := ctx.Scene.Stage.Mains

        sc := st.Scene
        st.configMainStage()
        st.addSceneParts()
        sc.SceneGeom.Pos = st.Pos

        st.setMains(ms) // temporary for prefs

        sz := ms.renderContext.geom.Size
        if !st.FullWindow || st.NewWindow {
                sz = sc.contentSize(sz)
                sz = sz.Add(image.Pt(50, 50))
                if st.UseMinSize {
                        // dialogs must be at least 400dp wide by default
                        minx := int(ctx.Scene.Styles.UnitContext.Dp(400))
                        sz.X = max(sz.X, minx)
                }
                sc.SceneGeom.Pos = sc.SceneGeom.Pos.Sub(sz.Div(2)) // center dialogs by default
                sc.Events.startFocusFirst = true                   // popup dialogs always need focus
                screen := st.targetScreen()
                if screen != nil {
                        st.SetScreen(screen.ScreenNumber)
                }
        }
        if DebugSettings.WindowRenderTrace {
                slog.Info("MainStage.RunDialog", "size", sz)
        }

        if st.NewWindow {
                st.Mains = nil
                sc.resize(math32.Geom2DInt{st.renderContext.geom.Pos, sz})
                st.Type = WindowStage            // critical: now is its own window!
                sc.SceneGeom.Pos = image.Point{} // ignore pos
                win := st.newRenderWindow()
                dialogRenderWindows.add(win)
                setCurrentRenderWindow(win)
                win.goStartEventLoop()
                return st
        }
        sc.SceneGeom.Size = sz
        sc.fitInWindow(st.renderContext.geom) // does resize
        ms.push(st)
        // st.SetMains(ms) // already set
        return st
}

func (st *Stage) newRenderWindow() *renderWindow {
        name := st.Name
        title := st.Title
        opts := &system.NewWindowOptions{
                Title:     title,
                Icon:      appIconImages(),
                Size:      st.Scene.SceneGeom.Size,
                Pos:       st.Pos,
                StdPixels: false,
                Screen:    st.Screen,
        }
        opts.Flags.SetFlag(!st.Resizable, system.FixedSize)
        opts.Flags.SetFlag(st.Maximized, system.Maximized)
        opts.Flags.SetFlag(st.Fullscreen, system.Fullscreen)
        screen := st.targetScreen()
        screenName := ""
        if screen != nil {
                screenName = screen.Name
        }
        var wgp *windowGeometry
        wgp, screen = theWindowGeometrySaver.get(title, screenName)
        if wgp != nil {
                theWindowGeometrySaver.settingStart()
                opts.Screen = screen.ScreenNumber
                opts.Size = wgp.Size
                opts.Pos = wgp.Pos
                opts.StdPixels = false
                if w := AllRenderWindows.FindName(title); w != nil { // offset from existing
                        opts.Pos.X += 20
                        opts.Pos.Y += 20
                }
                opts.Flags.SetFlag(wgp.Max, system.Maximized)
        }
        win := newRenderWindow(name, title, opts)
        theWindowGeometrySaver.settingEnd()
        if win == nil {
                return nil
        }
        AllRenderWindows.add(win)
        // initialize Mains
        win.mains.renderWindow = win
        win.mains.renderContext = newRenderContext() // sets defaults according to Screen
        // note: win is not yet created by the OS and we don't yet know its actual size
        // or dpi.
        win.mains.push(st)
        st.setMains(&win.mains)
        return win
}

// mainHandleEvent handles main stage events
func (st *Stage) mainHandleEvent(e events.Event) {
        if st.Scene == nil {
                return
        }
        st.popups.popupHandleEvent(e)
        if e.IsHandled() || (st.popups != nil && st.popups.topIsModal()) || st.Scene == nil {
                if DebugSettings.EventTrace && e.Type() != events.MouseMove {
                        fmt.Println("Event handled by popup:", e)
                }
                return
        }
        e.SetLocalOff(st.Scene.SceneGeom.Pos)
        st.Scene.Events.handleEvent(e)
}

// mainHandleEvent calls mainHandleEvent on relevant stages in reverse order.
func (sm *stages) mainHandleEvent(e events.Event) {
        n := sm.stack.Len()
        for i := n - 1; i >= 0; i-- {
                st := sm.stack.ValueByIndex(i)
                st.mainHandleEvent(e)
                if e.IsHandled() || st.Modal || st.FullWindow {
                        break
                }
                if st.Type == DialogStage { // modeless dialog, by definition
                        if e.HasPos() && st.Scene != nil {
                                b := st.Scene.SceneGeom.Bounds()
                                if e.WindowPos().In(b) { // don't propagate
                                        break
                                }
                        }
                }
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
)

// StyleMenuScene configures the default styles
// for the given pop-up menu frame with the given parent.
// It should be called on menu frames when they are created.
func StyleMenuScene(msc *Scene) {
        msc.Styler(func(s *styles.Style) {
                s.Grow.Set(0, 0)
                s.Padding.Set(units.Dp(2))
                s.Border.Radius = styles.BorderRadiusExtraSmall
                s.Background = colors.Scheme.SurfaceContainer
                s.BoxShadow = styles.BoxShadow2()
                s.Gap.Zero()
        })
        msc.SetOnChildAdded(func(n tree.Node) {
                if bt := AsButton(n); bt != nil {
                        bt.Type = ButtonMenu
                        bt.OnKeyChord(func(e events.Event) {
                                kf := keymap.Of(e.KeyChord())
                                switch kf {
                                case keymap.MoveRight:
                                        if bt.openMenu(e) {
                                                e.SetHandled()
                                        }
                                case keymap.MoveLeft:
                                        // need to be able to use arrow keys to navigate in completer
                                        if msc.Stage.Type != CompleterStage {
                                                msc.Stage.ClosePopup()
                                                e.SetHandled()
                                        }
                                }
                        })
                        return
                }
                if sp, ok := n.(*Separator); ok {
                        sp.Styler(func(s *styles.Style) {
                                s.Direction = styles.Row
                        })
                }
        })
}

// newMenuScene constructs a [Scene] for displaying a menu, using the
// given menu constructor function. If no name is provided, it defaults
// to "menu".  If no menu items added, returns nil.
func newMenuScene(menu func(m *Scene), name ...string) *Scene {
        nm := "menu"
        if len(name) > 0 {
                nm = name[0] + "-menu"
        }
        msc := NewScene(nm)
        StyleMenuScene(msc)
        menu(msc)
        if !msc.HasChildren() {
                return nil
        }

        hasSelected := false
        msc.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                if cw == msc {
                        return tree.Continue
                }
                if bt := AsButton(cw); bt != nil {
                        if bt.Menu == nil {
                                bt.handleClickDismissMenu()
                        }
                }
                if !hasSelected && cwb.StateIs(states.Selected) {
                        // fmt.Println("start focus sel:", cwb)
                        msc.Events.SetStartFocus(cwb)
                        hasSelected = true
                }
                return tree.Continue
        })
        if !hasSelected && msc.HasChildren() {
                // fmt.Println("start focus first:", msc.Child(0).(Widget))
                msc.Events.SetStartFocus(msc.Child(0).(Widget))
        }
        return msc
}

// NewMenuStage returns a new Menu stage with given scene contents,
// in connection with given widget, which provides key context
// for constructing the menu, at given RenderWindow position
// (e.g., use ContextMenuPos or WinPos method on ctx Widget).
// Make further configuration choices using Set* methods, which
// can be chained directly after the New call.
// Use Run call at the end to start the Stage running.
func NewMenuStage(sc *Scene, ctx Widget, pos image.Point) *Stage {
        if sc == nil || !sc.HasChildren() {
                return nil
        }
        st := NewPopupStage(MenuStage, sc, ctx)
        if pos != (image.Point{}) {
                st.Pos = pos
        }
        return st
}

// NewMenu returns a new menu stage based on the given menu constructor
// function, in connection with given widget, which provides key context
// for constructing the menu at given RenderWindow position
// (e.g., use ContextMenuPos or WinPos method on ctx Widget).
// Make further configuration choices using Set* methods, which
// can be chained directly after the New call.
// Use Run call at the end to start the Stage running.
func NewMenu(menu func(m *Scene), ctx Widget, pos image.Point) *Stage {
        return NewMenuStage(newMenuScene(menu, ctx.AsTree().Name), ctx, pos)
}

// AddContextMenu adds the given context menu to [WidgetBase.ContextMenus].
// It is the main way that code should modify a widget's context menus.
// Context menu functions are run in reverse order, and separators are
// automatically added between each context menu function. [Scene.ContextMenus]
// apply to all widgets in the scene.
func (wb *WidgetBase) AddContextMenu(menu func(m *Scene)) {
        wb.ContextMenus = append(wb.ContextMenus, menu)
}

// applyContextMenus adds the [WidgetBase.ContextMenus] and [Scene.ContextMenus]
// to the given menu scene in reverse order. It also adds separators between each
// context menu function.
func (wb *WidgetBase) applyContextMenus(m *Scene) {
        do := func(cms []func(m *Scene)) {
                for i := len(cms) - 1; i >= 0; i-- {
                        if m.NumChildren() > 0 {
                                NewSeparator(m)
                        }
                        cms[i](m)
                }
        }
        do(wb.ContextMenus)
        if wb.This != wb.Scene {
                do(wb.Scene.ContextMenus)
        }
}

// ContextMenuPos returns the default position for the context menu
// upper left corner.  The event will be from a mouse ContextMenu
// event if non-nil: should handle both cases.
func (wb *WidgetBase) ContextMenuPos(e events.Event) image.Point {
        if e != nil {
                return e.WindowPos()
        }
        return wb.winPos(.5, .5) // center
}

func (wb *WidgetBase) handleWidgetContextMenu() {
        wb.On(events.ContextMenu, func(e events.Event) {
                wi := wb.This.(Widget)
                wi.ShowContextMenu(e)
        })
}

func (wb *WidgetBase) ShowContextMenu(e events.Event) {
        e.SetHandled() // always
        if wb == nil || wb.This == nil {
                return
        }
        wi := wb.This.(Widget)
        nm := NewMenu(wi.AsWidget().applyContextMenus, wi, wi.ContextMenuPos(e))
        if nm == nil { // no items
                return
        }
        nm.Run()
}

// NewMenuFromStrings constructs a new menu from given list of strings,
// calling the given function with the index of the selected string.
// if string == sel, that menu item is selected initially.
func NewMenuFromStrings(strs []string, sel string, fun func(idx int)) *Scene {
        return newMenuScene(func(m *Scene) {
                for i, s := range strs {
                        b := NewButton(m).SetText(s)
                        b.OnClick(func(e events.Event) {
                                fun(i)
                        })
                        if s == sel {
                                b.SetSelected(true)
                        }
                }
        })
}

var (
        // webCanInstall is whether the app can be installed on the web platform
        webCanInstall bool

        // webInstall installs the app on the web platform
        webInstall func()
)

// MenuSearcher is an interface that [Widget]s can implement
// to customize the items of the menu search chooser created
// by the default [Scene] context menu in [Scene.MenuSearchDialog].
type MenuSearcher interface {
        MenuSearch(items *[]ChooserItem)
}

// standardContextMenu adds standard context menu items for the [Scene].
func (sc *Scene) standardContextMenu(m *Scene) { //types:add
        msdesc := "Search for menu buttons and other app actions"
        NewButton(m).SetText("Menu search").SetIcon(icons.Search).SetKey(keymap.Menu).SetTooltip(msdesc).OnClick(func(e events.Event) {
                sc.MenuSearchDialog("Menu search", msdesc)
        })
        NewButton(m).SetText("About").SetIcon(icons.Info).OnClick(func(e events.Event) {
                d := NewBody(TheApp.Name())
                d.Styler(func(s *styles.Style) {
                        s.CenterAll()
                })
                NewText(d).SetType(TextHeadlineLarge).SetText(TheApp.Name())
                if AppIcon != "" {
                        errors.Log(NewSVG(d).ReadString(AppIcon))
                }
                if AppAbout != "" {
                        NewText(d).SetText(AppAbout)
                }
                NewText(d).SetText("App version: " + system.AppVersion)
                NewText(d).SetText("Core version: " + system.CoreVersion)
                d.AddOKOnly().NewDialog(sc).SetDisplayTitle(false).Run()
        })
        NewFuncButton(m).SetFunc(SettingsWindow).SetText("Settings").SetIcon(icons.Settings).SetShortcut("Command+,")
        if webCanInstall {
                icon := icons.InstallDesktop
                if TheApp.SystemPlatform().IsMobile() {
                        icon = icons.InstallMobile
                }
                NewFuncButton(m).SetFunc(webInstall).SetText("Install").SetIcon(icon).SetTooltip("Install this app to your device as a Progressive Web App (PWA)")
        }
        NewButton(m).SetText("Inspect").SetIcon(icons.Edit).SetShortcut("Command+Shift+I").
                SetTooltip("Developer tools for inspecting the content of the app").
                OnClick(func(e events.Event) {
                        InspectorWindow(sc)
                })

        // No window menu on mobile platforms
        if TheApp.Platform().IsMobile() && TheApp.Platform() != system.Web {
                return
        }
        NewButton(m).SetText("Window").SetMenu(func(m *Scene) {
                if sc.IsFullscreen() {
                        NewButton(m).SetText("Exit fullscreen").SetIcon(icons.Fullscreen).OnClick(func(e events.Event) {
                                sc.SetFullscreen(false)
                        })
                } else {
                        NewButton(m).SetText("Fullscreen").SetIcon(icons.Fullscreen).OnClick(func(e events.Event) {
                                sc.SetFullscreen(true)
                        })
                }
                // Only do fullscreen on web
                if TheApp.Platform() == system.Web {
                        return
                }
                NewButton(m).SetText("Focus next").SetIcon(icons.CenterFocusStrong).
                        SetKey(keymap.WinFocusNext).OnClick(func(e events.Event) {
                        AllRenderWindows.focusNext()
                })
                NewButton(m).SetText("Minimize").SetIcon(icons.Minimize).
                        OnClick(func(e events.Event) {
                                win := sc.RenderWindow()
                                if win != nil {
                                        win.minimize()
                                }
                        })
                NewSeparator(m)
                NewButton(m).SetText("Close window").SetIcon(icons.Close).SetKey(keymap.WinClose).
                        OnClick(func(e events.Event) {
                                win := sc.RenderWindow()
                                if win != nil {
                                        win.closeReq()
                                }
                        })
                quit := NewButton(m).SetText("Quit").SetIcon(icons.Close).SetShortcut("Command+Q")
                quit.OnClick(func(e events.Event) {
                        go TheApp.QuitReq()
                })
        })
}

// MenuSearchDialog runs the menu search dialog for the scene with
// the given title and description text. It includes scenes, toolbar buttons,
// and [MenuSearcher]s.
func (sc *Scene) MenuSearchDialog(title, text string) {
        d := NewBody(title)
        NewText(d).SetType(TextSupporting).SetText(text)
        w := NewChooser(d).SetEditable(true).SetIcon(icons.Search)
        w.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 0)
        })
        w.AddItemsFunc(func() {
                for _, rw := range AllRenderWindows {
                        for _, kv := range rw.mains.stack.Order {
                                st := kv.Value
                                // we do not include ourself
                                if st == sc.Stage || st == w.Scene.Stage {
                                        continue
                                }
                                w.Items = append(w.Items, ChooserItem{
                                        Text:    st.Title,
                                        Icon:    icons.Toolbar,
                                        Tooltip: "Show " + st.Title,
                                        Func:    st.raise,
                                })
                        }
                }
        })
        w.AddItemsFunc(func() {
                addButtonItems(&w.Items, sc, "")
                tmps := NewScene()
                sc.applyContextMenus(tmps)
                addButtonItems(&w.Items, tmps, "")
        })
        w.OnFinal(events.Change, func(e events.Event) {
                d.Close()
        })
        d.AddBottomBar(func(bar *Frame) {
                d.AddCancel(bar)
        })
        d.RunDialog(sc)
}

// addButtonItems adds to the given items all of the buttons under
// the given parent. It navigates through button menus to find other
// buttons using a recursive approach that updates path with context
// about the original button menu. Consumers of this function should
// typically set path to "".
func addButtonItems(items *[]ChooserItem, parent tree.Node, path string) {
        parent.AsTree().WalkDown(func(n tree.Node) bool {
                if ms, ok := n.(MenuSearcher); ok {
                        ms.MenuSearch(items)
                }
                bt := AsButton(n)
                if bt == nil || bt.IsDisabled() {
                        return tree.Continue
                }
                _, isTb := bt.Parent.(*Toolbar)
                _, isSc := bt.Parent.(*Scene)
                if !isTb && !isSc {
                        return tree.Continue
                }
                if bt.Text == "Menu search" {
                        return tree.Continue
                }
                label := bt.Text
                if label == "" {
                        label = bt.Tooltip
                }
                if bt.HasMenu() {
                        tmps := NewScene()
                        bt.Menu(tmps)
                        npath := path
                        if npath != "" {
                                npath += " > "
                        }
                        if bt.Name != "overflow-menu" {
                                npath += label
                        }
                        addButtonItems(items, tmps, npath)
                        return tree.Continue
                }
                if path != "" {
                        label = path + " > " + label
                }
                *items = append(*items, ChooserItem{
                        Text:    label,
                        Icon:    bt.Icon,
                        Tooltip: bt.Tooltip,
                        Func: func() {
                                bt.Send(events.Click)
                        },
                })
                return tree.Continue
        })
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/htmltext"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/text"
)

// Meter is a widget that renders a current value on as a filled
// bar/circle/semicircle relative to a minimum and maximum potential
// value.
type Meter struct {
        WidgetBase

        // Type is the styling type of the meter.
        Type MeterTypes

        // Value is the current value of the meter.
        // It defaults to 0.5.
        Value float32

        // Min is the minimum possible value of the meter.
        // It defaults to 0.
        Min float32

        // Max is the maximum possible value of the meter.
        // It defaults to 1.
        Max float32

        // Text, for [MeterCircle] and [MeterSemicircle], is the
        // text to render inside of the circle/semicircle.
        Text string

        // ValueColor is the image color that will be used to
        // render the filled value bar. It should be set in a Styler.
        ValueColor image.Image

        // Width, for [MeterCircle] and [MeterSemicircle], is the
        // width of the circle/semicircle. It should be set in a Styler.
        Width units.Value
}

// MeterTypes are the different styling types of [Meter]s.
type MeterTypes int32 //enums:enum -trim-prefix Meter

const (
        // MeterLinear indicates to render a meter that goes in a straight,
        // linear direction, either horizontal or vertical, as specified by
        // [styles.Style.Direction].
        MeterLinear MeterTypes = iota

        // MeterCircle indicates to render the meter as a circle.
        MeterCircle

        // MeterSemicircle indicates to render the meter as a semicircle.
        MeterSemicircle
)

func (m *Meter) WidgetValue() any { return &m.Value }

func (m *Meter) Init() {
        m.WidgetBase.Init()
        m.Value = 0.5
        m.Max = 1
        m.Styler(func(s *styles.Style) {
                m.ValueColor = colors.Scheme.Primary.Base
                s.Background = colors.Scheme.SurfaceVariant
                s.Border.Radius = styles.BorderRadiusFull
                s.SetTextWrap(false)
        })
        m.FinalStyler(func(s *styles.Style) {
                switch m.Type {
                case MeterLinear:
                        if s.Direction == styles.Row {
                                s.Min.Set(units.Dp(320), units.Dp(8))
                        } else {
                                s.Min.Set(units.Dp(8), units.Dp(320))
                        }
                case MeterCircle:
                        s.Min.Set(units.Dp(128))
                        m.Width.Dp(8)
                        s.Font.Size.Dp(32)
                        s.Text.LineHeight = 40.0 / 32
                        s.Text.Align = text.Center
                        s.Text.AlignV = text.Center
                case MeterSemicircle:
                        s.Min.Set(units.Dp(112), units.Dp(64))
                        m.Width.Dp(16)
                        s.Font.Size.Dp(22)
                        s.Text.LineHeight = 28.0 / 22
                        s.Text.Align = text.Center
                        s.Text.AlignV = text.Center
                }
        })
}

func (m *Meter) Style() {
        m.WidgetBase.Style()
        m.Width.ToDots(&m.Styles.UnitContext)
}

func (m *Meter) WidgetTooltip(pos image.Point) (string, image.Point) {
        res := m.Tooltip
        if res != "" {
                res += " "
        }
        res += fmt.Sprintf("(value: %.4g, minimum: %g, maximum: %g)", m.Value, m.Min, m.Max)
        return res, m.DefaultTooltipPos()
}

func (m *Meter) Render() {
        pc := &m.Scene.Painter
        st := &m.Styles

        prop := (m.Value - m.Min) / (m.Max - m.Min)

        if m.Type == MeterLinear {
                m.RenderStandardBox()
                if m.ValueColor != nil {
                        dim := m.Styles.Direction.Dim()
                        size := m.Geom.Size.Actual.Content.MulDim(dim, prop)
                        pc.Fill.Color = m.ValueColor
                        m.RenderBoxGeom(m.Geom.Pos.Content, size, st.Border)
                }
                return
        }

        pc.Stroke.Width = m.Width
        sw := m.Width.Dots
        pos := m.Geom.Pos.Content.AddScalar(sw / 2)
        size := m.Geom.Size.Actual.Content.SubScalar(sw)
        pc.Fill.Color = colors.Scheme.Surface

        var txt *shaped.Lines
        var toff math32.Vector2
        if m.Text != "" {
                sty, tsty := m.Styles.NewRichText()
                tx, _ := htmltext.HTMLToRich([]byte(m.Text), sty, nil)
                txt = m.Scene.TextShaper().WrapLines(tx, sty, tsty, &AppearanceSettings.Text, size)
                toff = txt.Bounds.Size().DivScalar(2)
        }

        if m.Type == MeterCircle {
                r := size.DivScalar(2)
                c := pos.Add(r)

                pc.EllipticalArc(c.X, c.Y, r.X, r.Y, 0, 0, 2*math32.Pi)
                pc.Stroke.Color = st.Background
                pc.Draw()

                if m.ValueColor != nil {
                        pc.EllipticalArc(c.X, c.Y, r.X, r.Y, 0, -math32.Pi/2, prop*2*math32.Pi-math32.Pi/2)
                        pc.Stroke.Color = m.ValueColor
                        pc.Draw()
                }
                if txt != nil {
                        pc.DrawText(txt, c.Sub(toff))
                }
                return
        }

        r := size.Mul(math32.Vec2(0.5, 1))
        c := pos.Add(r)

        pc.EllipticalArc(c.X, c.Y, r.X, r.Y, 0, math32.Pi, 2*math32.Pi)
        pc.Stroke.Color = st.Background
        pc.Draw()

        if m.ValueColor != nil {
                pc.EllipticalArc(c.X, c.Y, r.X, r.Y, 0, math32.Pi, (1+prop)*math32.Pi)
                pc.Stroke.Color = m.ValueColor
                pc.Draw()
        }
        if txt != nil {
                pc.DrawText(txt, c.Sub(size.Mul(math32.Vec2(0, 0.3))).Sub(toff))
        }
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"

        "cogentcore.org/core/styles"
)

// Pages is a frame that can easily swap its content between that of
// different possible pages.
type Pages struct {
        Frame

        // Page is the currently open page.
        Page string

        // Pages is a map of page names to functions that configure a page.
        Pages map[string]func(pg *Pages) `set:"-"`

        // page is the currently rendered page.
        page string
}

func (pg *Pages) Init() {
        pg.Frame.Init()
        pg.Pages = map[string]func(pg *Pages){}
        pg.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
                s.Grow.Set(1, 1)
        })
        pg.Updater(func() {
                if len(pg.Pages) == 0 {
                        return
                }
                if pg.page == pg.Page {
                        return
                }
                pg.DeleteChildren()
                fun, ok := pg.Pages[pg.Page]
                if !ok {
                        ErrorSnackbar(pg, fmt.Errorf("page %q not found", pg.Page))
                        return
                }
                pg.page = pg.Page
                fun(pg)
                pg.DeferShown()
        })
}

// AddPage adds a page with the given name and configuration function.
// If [Pages.Page] is currently unset, it will be set to the given name.
func (pg *Pages) AddPage(name string, f func(pg *Pages)) {
        pg.Pages[name] = f
        if pg.Page == "" {
                pg.Page = name
        }
}

// Open sets the current page to the given name and updates the display.
// In comparison, [Pages.SetPage] does not update the display and should typically
// only be called at the start.
func (pg *Pages) Open(name string) *Pages {
        pg.SetPage(name)
        pg.Update()
        return pg
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "time"

        "cogentcore.org/core/events"
)

// NewPopupStage returns a new PopupStage with given type and scene contents.
// The given context widget must be non-nil.
// Make further configuration choices using Set* methods, which
// can be chained directly after the NewPopupStage call.
// Use Run call at the end to start the Stage running.
func NewPopupStage(typ StageTypes, sc *Scene, ctx Widget) *Stage {
        ctx = nonNilContext(ctx)
        st := &Stage{}
        st.setType(typ)
        st.setScene(sc)
        st.Context = ctx
        st.Pos = ctx.ContextMenuPos(nil)
        sc.Stage = st
        // note: not setting all the connections until run
        return st
}

// runPopupAsync runs a popup-style Stage in context widget's popups.
// This version is for Asynchronous usage outside the main event loop,
// for example in a delayed callback AfterFunc etc.
func (st *Stage) runPopupAsync() *Stage {
        ctx := st.Context.AsWidget()
        if ctx.Scene.Stage == nil {
                return st.runPopup()
        }
        ms := ctx.Scene.Stage.Main
        rc := ms.renderContext
        rc.Lock()
        defer rc.Unlock()
        return st.runPopup()
}

// runPopup runs a popup-style Stage in context widget's popups.
func (st *Stage) runPopup() *Stage {
        if !st.getValidContext() { // doesn't even have a scene
                return st
        }
        ctx := st.Context.AsWidget()
        // if our context stage is nil, we wait until
        // our context is shown and then try again
        if ctx.Scene.Stage == nil {
                ctx.Defer(func() {
                        st.runPopup()
                })
                return st
        }

        if st.Type == SnackbarStage {
                st.Scene.makeSceneBars()
        }
        st.Scene.updateScene()
        sc := st.Scene

        ms := ctx.Scene.Stage.Main
        msc := ms.Scene

        if st.Type == SnackbarStage {
                // only one snackbar can exist
                ms.popups.popDeleteType(SnackbarStage)
        }

        ms.popups.push(st)
        st.setPopups(ms) // sets all pointers

        maxGeom := msc.SceneGeom
        winst := ms.Mains.windowStage()
        usingWinGeom := false
        if winst != nil && winst.Scene != nil && winst.Scene != msc {
                usingWinGeom = true
                maxGeom = winst.Scene.SceneGeom // use the full window if possible
        }
        // original size and position, which is that of the context widget / location for a tooltip
        osz := sc.SceneGeom.Size
        opos := sc.SceneGeom.Pos

        sc.SceneGeom.Size = maxGeom.Size
        sc.SceneGeom.Pos = st.Pos
        sz := sc.contentSize(maxGeom.Size)
        bigPopup := false
        if usingWinGeom && 4*sz.X*sz.Y > 3*msc.SceneGeom.Size.X*msc.SceneGeom.Size.Y { // reasonable fraction
                bigPopup = true
        }
        scrollWd := int(sc.Styles.ScrollbarWidth.Dots)
        fontHt := sc.Styles.Font.FontHeight()
        if fontHt == 0 {
                fontHt = 16
        }

        switch st.Type {
        case MenuStage:
                sz.X += scrollWd * 2
                maxht := int(float32(SystemSettings.MenuMaxHeight) * fontHt)
                sz.Y = min(maxht, sz.Y)
        case SnackbarStage:
                b := msc.SceneGeom.Bounds()
                // Go in the middle [(max - min) / 2], and then subtract
                // half of the size because we are specifying starting point,
                // not the center. This results in us being centered.
                sc.SceneGeom.Pos.X = (b.Max.X - b.Min.X - sz.X) / 2
                // get enough space to fit plus 10 extra pixels of margin
                sc.SceneGeom.Pos.Y = b.Max.Y - sz.Y - 10
        case TooltipStage:
                sc.SceneGeom.Pos.X = opos.X
                // default to tooltip above element
                ypos := opos.Y - sz.Y - 10
                if ypos < 0 {
                        ypos = 0
                }
                // however, if we are within 10 pixels of the element,
                // we put the tooltip below it instead of above it
                maxy := ypos + sz.Y
                if maxy > opos.Y-10 {
                        ypos = opos.Add(osz).Y + 10
                }
                sc.SceneGeom.Pos.Y = ypos
        }

        sc.SceneGeom.Size = sz
        if bigPopup { // we have a big popup -- make it not cover the original window;
                sc.fitInWindow(maxGeom) // does resize
                // reposition to be as close to top-right of main scene as possible
                tpos := msc.SceneGeom.Pos
                tpos.X += msc.SceneGeom.Size.X
                if tpos.X+sc.SceneGeom.Size.X > maxGeom.Size.X { // favor left side instead
                        tpos.X = max(msc.SceneGeom.Pos.X-sc.SceneGeom.Size.X, 0)
                }
                bpos := tpos.Add(sc.SceneGeom.Size)
                if bpos.X > maxGeom.Size.X {
                        tpos.X -= bpos.X - maxGeom.Size.X
                }
                if bpos.Y > maxGeom.Size.Y {
                        tpos.Y -= bpos.Y - maxGeom.Size.Y
                }
                if tpos.X < 0 {
                        tpos.X = 0
                }
                if tpos.Y < 0 {
                        tpos.Y = 0
                }
                sc.SceneGeom.Pos = tpos
        } else {
                sc.fitInWindow(msc.SceneGeom)
        }
        sc.showIter = 0

        if st.Timeout > 0 {
                time.AfterFunc(st.Timeout, func() {
                        if st.Main == nil {
                                return
                        }
                        st.popups.deleteStage(st)
                })
        }

        return st
}

// closePopupAsync closes this stage as a popup.
// This version is for Asynchronous usage outside the main event loop,
// for example in a delayed callback AfterFunc etc.
func (st *Stage) closePopupAsync() {
        rc := st.Mains.renderContext
        rc.Lock()
        defer rc.Unlock()
        st.ClosePopup()
}

// ClosePopup closes this stage as a popup, returning whether it was closed.
func (st *Stage) ClosePopup() bool {
        // NOTE: this is critical for Completer to not crash due to async closing
        if st.Main == nil || st.popups == nil || st.Mains == nil {
                return false
        }
        return st.popups.deleteStage(st)
}

// closePopupAndBelow closes this stage as a popup,
// and all those immediately below it of the same type.
// It returns whether it successfully closed popups.
func (st *Stage) closePopupAndBelow() bool {
        // NOTE: this is critical for Completer to not crash due to async closing
        if st.Main == nil || st.popups == nil || st.Mains == nil {
                return false
        }
        return st.popups.deleteStageAndBelow(st)
}

func (st *Stage) popupHandleEvent(e events.Event) {
        if st.Scene == nil {
                return
        }
        if e.IsHandled() {
                return
        }
        e.SetLocalOff(st.Scene.SceneGeom.Pos)
        // fmt.Println("pos:", evi.Pos(), "local:", evi.LocalPos())
        st.Scene.Events.handleEvent(e)
}

// topIsModal returns true if there is a Top PopupStage and it is Modal.
func (pm *stages) topIsModal() bool {
        top := pm.top()
        if top == nil {
                return false
        }
        return top.Modal
}

// popupHandleEvent processes Popup events.
// requires outer RenderContext mutex.
func (pm *stages) popupHandleEvent(e events.Event) {
        top := pm.top()
        if top == nil {
                return
        }
        ts := top.Scene

        // we must get the top stage that does not ignore events
        if top.ignoreEvents {
                var ntop *Stage
                for i := pm.stack.Len() - 1; i >= 0; i-- {
                        s := pm.stack.ValueByIndex(i)
                        if !s.ignoreEvents {
                                ntop = s
                                break
                        }
                }
                if ntop == nil {
                        return
                }
                top = ntop
                ts = top.Scene
        }

        if e.HasPos() {
                pos := e.WindowPos()
                // fmt.Println("pos:", pos, "top geom:", ts.SceneGeom)
                if pos.In(ts.SceneGeom.Bounds()) {
                        top.popupHandleEvent(e)
                        e.SetHandled()
                        return
                }
                if top.ClickOff && e.Type() == events.MouseUp {
                        top.closePopupAndBelow()
                }
                if top.Modal { // absorb any other events!
                        e.SetHandled()
                        return
                }
                // otherwise not Handled, so pass on to first lower stage
                // that accepts events and is in bounds
                for i := pm.stack.Len() - 1; i >= 0; i-- {
                        s := pm.stack.ValueByIndex(i)
                        ss := s.Scene
                        if !s.ignoreEvents && pos.In(ss.SceneGeom.Bounds()) {
                                s.popupHandleEvent(e)
                                e.SetHandled()
                                return
                        }
                }
        } else { // typically focus, so handle even if not in bounds
                top.popupHandleEvent(e) // could be set as Handled or not
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "path/filepath"
        "runtime/debug"
        "strings"

        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
)

// timesCrashed is the number of times that the program has
// crashed. It is used to prevent an infinite crash loop
// when rendering the crash window.
var timesCrashed int

// webCrashDialog is the function used to display the crash dialog on web.
// It cannot be displayed normally due to threading and single-window issues.
var webCrashDialog func(title, txt, body string)

// handleRecover is the core value of [system.HandleRecover]. If r is not nil,
// it makes a window displaying information about the panic. [system.HandleRecover]
// is initialized to this in init.
func handleRecover(r any) {
        if r == nil {
                return
        }
        timesCrashed++
        system.HandleRecoverBase(r)
        if timesCrashed > 1 {
                return
        }

        stack := string(debug.Stack())

        // we have to handle the quit button indirectly so that it has the
        // right stack for debugging when panicking
        quit := make(chan struct{})

        title := TheApp.Name() + " stopped unexpectedly"
        txt := "There was an unexpected error and " + TheApp.Name() + " stopped running."

        clpath := filepath.Join(TheApp.AppDataDir(), "crash-logs")
        clpath = strings.ReplaceAll(clpath, " ", `\ `) // escape spaces
        body := fmt.Sprintf("Crash log saved in %s\n\n%s", clpath, system.CrashLogText(r, stack))

        if webCrashDialog != nil {
                webCrashDialog(title, txt, body)
                return
        }

        b := NewBody(title)
        NewText(b).SetText(title).SetType(TextHeadlineSmall)
        NewText(b).SetType(TextSupporting).SetText(txt)
        b.AddBottomBar(func(bar *Frame) {
                NewButton(bar).SetText("Details").SetType(ButtonOutlined).OnClick(func(e events.Event) {
                        d := NewBody("Crash details")
                        NewText(d).SetText(body).Styler(func(s *styles.Style) {
                                s.Font.Family = rich.Monospace
                                s.Text.WhiteSpace = text.WhiteSpacePreWrap
                        })
                        d.AddBottomBar(func(bar *Frame) {
                                NewButton(bar).SetText("Copy").SetIcon(icons.Copy).SetType(ButtonOutlined).
                                        OnClick(func(e events.Event) {
                                                d.Clipboard().Write(mimedata.NewText(body))
                                        })
                                d.AddOK(bar)
                        })
                        d.RunFullDialog(b)
                })
                NewButton(bar).SetText("Quit").OnClick(func(e events.Event) {
                        quit <- struct{}{}
                })
        })
        b.RunWindow()
        <-quit
        panic(r)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "os"
        "path/filepath"
        "runtime"
        "runtime/pprof"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/profile"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/cam/hct"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/render"
        _ "cogentcore.org/core/paint/renderers" // installs default renderer
        "cogentcore.org/core/styles"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
)

// AsyncLock must be called before making any updates in a separate goroutine
// outside of the main configuration, rendering, and event handling structure.
// It must have a matching [WidgetBase.AsyncUnlock] after it.
//
// If the widget has been deleted, or if the [Scene] has been shown but the render
// context is not available, then this will block forever. Enable
// [DebugSettingsData.UpdateTrace] in [DebugSettings] to see when that happens.
// If the scene has not been shown yet and the render context is nil, it will wait
// until the scene is shown before trying again.
func (wb *WidgetBase) AsyncLock() {
        rc := wb.Scene.renderContext()
        if rc == nil {
                if wb.Scene.hasFlag(sceneHasShown) {
                        // If the scene has been shown but there is no render context,
                        // we are probably being deleted, so we just block forever.
                        if DebugSettings.UpdateTrace {
                                fmt.Println("AsyncLock: scene shown but no render context; blocking forever:", wb)
                        }
                        select {}
                }
                // Otherwise, if we haven't been shown yet, we just wait until we are
                // and then try again.
                if DebugSettings.UpdateTrace {
                        fmt.Println("AsyncLock: waiting for scene to be shown:", wb)
                }
                onShow := make(chan struct{})
                wb.OnShow(func(e events.Event) {
                        onShow <- struct{}{}
                })
                <-onShow
                wb.AsyncLock() // try again
                return
        }
        rc.Lock()
        if wb.This == nil {
                rc.Unlock()
                if DebugSettings.UpdateTrace {
                        fmt.Println("AsyncLock: widget deleted; blocking forever:", wb)
                }
                select {}
        }
        wb.Scene.setFlag(true, sceneUpdating)
}

// AsyncUnlock must be called after making any updates in a separate goroutine
// outside of the main configuration, rendering, and event handling structure.
// It must have a matching [WidgetBase.AsyncLock] before it.
func (wb *WidgetBase) AsyncUnlock() {
        rc := wb.Scene.renderContext()
        if rc == nil {
                return
        }
        if wb.Scene != nil {
                wb.Scene.setFlag(false, sceneUpdating)
        }
        rc.Unlock()
}

// NeedsRender specifies that the widget needs to be rendered.
func (wb *WidgetBase) NeedsRender() {
        if DebugSettings.UpdateTrace {
                fmt.Println("\tDebugSettings.UpdateTrace: NeedsRender:", wb)
        }
        wb.setFlag(true, widgetNeedsRender)
        if wb.Scene != nil {
                wb.Scene.setFlag(true, sceneNeedsRender)
        }
}

// NeedsLayout specifies that the widget's scene needs to do a layout.
// This needs to be called after any changes that affect the structure
// and/or size of elements.
func (wb *WidgetBase) NeedsLayout() {
        if DebugSettings.UpdateTrace {
                fmt.Println("\tDebugSettings.UpdateTrace: NeedsLayout:", wb)
        }
        if wb.Scene != nil {
                wb.Scene.setFlag(true, sceneNeedsLayout)
        }
}

// NeedsRebuild returns whether the [renderContext] indicates
// a full rebuild is needed. This is typically used to detect
// when the settings have been changed, such as when the color
// scheme or zoom is changed.
func (wb *WidgetBase) NeedsRebuild() bool {
        if wb.This == nil || wb.Scene == nil || wb.Scene.Stage == nil {
                return false
        }
        rc := wb.Scene.renderContext()
        if rc == nil {
                return false
        }
        return rc.rebuild
}

// layoutScene does a layout of the scene: Size, Position
func (sc *Scene) layoutScene() {
        if DebugSettings.LayoutTrace {
                fmt.Println("\n############################\nLayoutScene SizeUp start:", sc)
        }
        sc.SizeUp()
        sz := &sc.Geom.Size
        sz.Alloc.Total.SetPoint(sc.SceneGeom.Size)
        sz.setContentFromTotal(&sz.Alloc)
        // sz.Actual = sz.Alloc // todo: is this needed??
        if DebugSettings.LayoutTrace {
                fmt.Println("\n############################\nSizeDown start:", sc)
        }
        maxIter := 3
        for iter := 0; iter < maxIter; iter++ { // 3  > 2; 4 same as 3
                redo := sc.SizeDown(iter)
                if redo && iter < maxIter-1 {
                        if DebugSettings.LayoutTrace {
                                fmt.Println("\n############################\nSizeDown redo:", sc, "iter:", iter+1)
                        }
                } else {
                        break
                }
        }
        if DebugSettings.LayoutTrace {
                fmt.Println("\n############################\nSizeFinal start:", sc)
        }
        sc.SizeFinal()
        if DebugSettings.LayoutTrace {
                fmt.Println("\n############################\nPosition start:", sc)
        }
        sc.Position()
        if DebugSettings.LayoutTrace {
                fmt.Println("\n############################\nScenePos start:", sc)
        }
        sc.ApplyScenePos()
}

// layoutRenderScene does a layout and render of the tree:
// GetSize, DoLayout, Render.  Needed after Config.
func (sc *Scene) layoutRenderScene() {
        sc.layoutScene()
        sc.RenderWidget()
}

func (sc *Scene) Render() {
        if TheApp.Platform() == system.Web {
                sc.Painter.Fill.Color = colors.Uniform(colors.Transparent)
                sc.Painter.Clear()
        }
        sc.RenderStandardBox()
}

// doNeedsRender calls Render on tree from me for nodes
// with NeedsRender flags set
func (wb *WidgetBase) doNeedsRender() {
        if wb.This == nil {
                return
        }
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                if cwb.hasFlag(widgetNeedsRender) {
                        cw.RenderWidget()
                        return tree.Break // don't go any deeper
                }
                if ly := AsFrame(cw); ly != nil {
                        for d := math32.X; d <= math32.Y; d++ {
                                if ly.HasScroll[d] && ly.Scrolls[d] != nil {
                                        ly.Scrolls[d].doNeedsRender()
                                }
                        }
                }
                return tree.Continue
        })
}

////////  Scene

var sceneShowIters = 2

// doUpdate checks scene Needs flags to do whatever updating is required.
// returns false if already updating.
// This is the main update call made by the RenderWindow at FPS frequency.
func (sc *Scene) doUpdate() bool {
        if sc.hasFlag(sceneUpdating) {
                return false
        }
        sc.setFlag(true, sceneUpdating) // prevent rendering
        defer func() { sc.setFlag(false, sceneUpdating) }()

        sc.runAnimations()
        rc := sc.renderContext()

        if sc.showIter < sceneShowIters {
                sc.setFlag(true, sceneNeedsLayout)
                sc.showIter++
        }

        switch {
        case rc.rebuild:
                // pr := profile.Start("rebuild")
                sc.doRebuild()
                sc.setFlag(false, sceneNeedsLayout, sceneNeedsRender)
                sc.setFlag(true, sceneImageUpdated)
                // pr.End()
        case sc.lastRender.needsRestyle(rc):
                // pr := profile.Start("restyle")
                sc.applyStyleScene()
                sc.layoutRenderScene()
                sc.setFlag(false, sceneNeedsLayout, sceneNeedsRender)
                sc.setFlag(true, sceneImageUpdated)
                sc.lastRender.saveRender(rc)
                // pr.End()
        case sc.hasFlag(sceneNeedsLayout):
                // pr := profile.Start("layout")
                sc.layoutRenderScene()
                sc.setFlag(false, sceneNeedsLayout, sceneNeedsRender)
                sc.setFlag(true, sceneImageUpdated)
                // pr.End()
        case sc.hasFlag(sceneNeedsRender):
                // pr := profile.Start("render")
                sc.doNeedsRender()
                sc.setFlag(false, sceneNeedsRender)
                sc.setFlag(true, sceneImageUpdated)
                // pr.End()
        default:
                return false
        }

        if sc.showIter == sceneShowIters { // end of first pass
                sc.showIter++ // just go 1 past the iters cutoff
        }
        return true
}

// updateScene calls UpdateTree on the Scene, which calls
// UpdateWidget on all widgets in the Scene.  This will set
// NeedsLayout to drive subsequent layout and render.
// This is a top-level call, typically only done when the window
// is first drawn or resized, or during rebuild,
// once the full sizing information is available.
func (sc *Scene) updateScene() {
        sc.setFlag(true, sceneUpdating) // prevent rendering
        defer func() { sc.setFlag(false, sceneUpdating) }()

        sc.UpdateTree()
}

// applyStyleScene calls ApplyStyle on all widgets in the Scene,
// This is needed whenever the window geometry, DPI,
// etc is updated, which affects styling.
func (sc *Scene) applyStyleScene() {
        sc.setFlag(true, sceneUpdating) // prevent rendering
        defer func() { sc.setFlag(false, sceneUpdating) }()

        sc.StyleTree()
        if sc.Painter.Paint != nil {
                sc.Painter.Paint.UnitContext = sc.Styles.UnitContext
        }
        sc.setFlag(true, sceneNeedsLayout)
}

// doRebuild does the full re-render and RenderContext Rebuild flag
// should be used by Widgets to rebuild things that are otherwise
// cached (e.g., Icon, TextCursor).
func (sc *Scene) doRebuild() {
        sc.Stage.Sprites.Reset()
        sc.updateScene()
        sc.applyStyleScene()
        sc.layoutRenderScene()
}

// contentSize computes the size of the scene based on current content.
// initSz is the initial size, e.g., size of screen.
// Used for auto-sizing windows when created, and in [Scene.ResizeToContent].
func (sc *Scene) contentSize(initSz image.Point) image.Point {
        sc.setFlag(true, sceneUpdating) // prevent rendering
        defer func() { sc.setFlag(false, sceneUpdating) }()

        sc.setFlag(true, sceneContentSizing)
        sc.updateScene()
        sc.applyStyleScene()
        sc.layoutScene()
        sz := &sc.Geom.Size
        psz := sz.Actual.Total
        sc.setFlag(false, sceneContentSizing)
        sc.showIter = 0
        return psz.ToPointFloor()
}

//////// Widget local rendering

// StartRender starts the rendering process in the Painter, if the
// widget is visible, otherwise it returns false.
// It pushes our context and bounds onto the render stack.
// This must be called as the first step in [Widget.RenderWidget] implementations.
func (wb *WidgetBase) StartRender() bool {
        if wb == nil || wb.This == nil {
                return false
        }
        wb.setFlag(false, widgetNeedsRender) // done!
        if !wb.IsVisible() {
                return false
        }
        wb.Styles.ComputeActualBackground(wb.parentActualBackground())
        pc := &wb.Scene.Painter
        if pc.State == nil {
                return false
        }
        pc.PushContext(nil, render.NewBoundsRect(wb.Geom.TotalBBox, wb.Styles.Border.Radius.Dots()))
        pc.Paint.Defaults() // start with default style values
        if DebugSettings.RenderTrace {
                fmt.Printf("Render: %v at %v\n", wb.Path(), wb.Geom.TotalBBox)
        }
        return true
}

// EndRender is the last step in [Widget.RenderWidget] implementations after
// rendering children. It pops our state off of the render stack.
func (wb *WidgetBase) EndRender() {
        if wb == nil || wb.This == nil {
                return
        }
        pc := &wb.Scene.Painter

        isSelw := wb.Scene.selectedWidget == wb.This
        if wb.Scene.renderBBoxes || isSelw {
                pos := math32.FromPoint(wb.Geom.TotalBBox.Min)
                sz := math32.FromPoint(wb.Geom.TotalBBox.Size())
                // node: we won't necc. get a push prior to next update, so saving these.
                pcsw := pc.Stroke.Width
                pcsc := pc.Stroke.Color
                pcfc := pc.Fill.Color
                pcop := pc.Fill.Opacity
                pc.Stroke.Width.Dot(1)
                pc.Stroke.Color = colors.Uniform(hct.New(wb.Scene.renderBBoxHue, 100, 50))
                pc.Fill.Color = nil
                if isSelw {
                        fc := pc.Stroke.Color
                        pc.Fill.Color = fc
                        pc.Fill.Opacity = 0.2
                }
                pc.Rectangle(pos.X, pos.Y, sz.X, sz.Y)
                pc.Draw()
                // restore
                pc.Fill.Opacity = pcop
                pc.Fill.Color = pcfc
                pc.Stroke.Width = pcsw
                pc.Stroke.Color = pcsc

                wb.Scene.renderBBoxHue += 10
                if wb.Scene.renderBBoxHue > 360 {
                        rmdr := (int(wb.Scene.renderBBoxHue-360) + 1) % 9
                        wb.Scene.renderBBoxHue = float32(rmdr)
                }
        }

        pc.PopContext()
}

// Render is the method that widgets should implement to define their
// custom rendering steps. It should not typically be called outside of
// [Widget.RenderWidget], which also does other steps applicable
// for all widgets. The base [WidgetBase.Render] implementation
// renders the standard box model.
func (wb *WidgetBase) Render() {
        wb.RenderStandardBox()
}

// RenderWidget renders the widget and any parts and children that it has.
// It does not render if the widget is invisible. It calls Widget.Render]
// for widget-specific rendering.
func (wb *WidgetBase) RenderWidget() {
        if wb.StartRender() {
                wb.This.(Widget).Render()
                wb.renderChildren()
                wb.renderParts()
                wb.EndRender()
        }
}

func (wb *WidgetBase) renderParts() {
        if wb.Parts != nil {
                wb.Parts.RenderWidget()
        }
}

// renderChildren renders all of the widget's children.
func (wb *WidgetBase) renderChildren() {
        wb.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                cw.RenderWidget()
                return tree.Continue
        })
}

////////  Defer

// Defer adds a function to [WidgetBase.Deferred] that will be called after the next
// [Scene] update/render, including on the initial Scene render. After the function
// is called, it is removed and not called again. In the function, sending events
// etc will work as expected.
func (wb *WidgetBase) Defer(fun func()) {
        wb.Deferred = append(wb.Deferred, fun)
        if wb.Scene != nil {
                wb.Scene.setFlag(true, sceneHasDeferred)
        }
}

// runDeferred runs deferred functions on all widgets in the scene.
func (sc *Scene) runDeferred() {
        sc.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                for _, f := range cwb.Deferred {
                        f()
                }
                cwb.Deferred = nil
                return tree.Continue
        })
}

// DeferShown adds a [WidgetBase.Defer] function to call [WidgetBase.Shown]
// and activate [WidgetBase.StartFocus]. For example, this is called in [Tabs]
// and [Pages] when a tab/page is newly shown, so that elements can perform
// [WidgetBase.OnShow] updating as needed.
func (wb *WidgetBase) DeferShown() {
        wb.Defer(func() {
                wb.Shown()
        })
}

// Shown sends [events.Show] to all widgets from this one down. Also see
// [WidgetBase.DeferShown].
func (wb *WidgetBase) Shown() {
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                cwb.Send(events.Show)
                return tree.Continue
        })
        wb.Events().activateStartFocus()
}

////////  Standard Box Model rendering

// RenderBoxGeom renders a box with the given geometry.
func (wb *WidgetBase) RenderBoxGeom(pos math32.Vector2, sz math32.Vector2, bs styles.Border) {
        wb.Scene.Painter.Border(pos.X, pos.Y, sz.X, sz.Y, bs)
}

// RenderStandardBox renders the standard box model, using Actual size.
func (wb *WidgetBase) RenderStandardBox() {
        pos := wb.Geom.Pos.Total
        sz := wb.Geom.Size.Actual.Total
        wb.Scene.Painter.StandardBox(&wb.Styles, pos, sz, wb.parentActualBackground())
}

// RenderAllocBox renders the standard box model using Alloc size, instead of Actual.
func (wb *WidgetBase) RenderAllocBox() {
        pos := wb.Geom.Pos.Total
        sz := wb.Geom.Size.Alloc.Total
        wb.Scene.Painter.StandardBox(&wb.Styles, pos, sz, wb.parentActualBackground())
}

////////        Widget position functions

// PointToRelPos translates a point in Scene pixel coords
// into relative position within node, based on the Content BBox
func (wb *WidgetBase) PointToRelPos(pt image.Point) image.Point {
        return pt.Sub(wb.Geom.ContentBBox.Min)
}

// winBBox returns the RenderWindow based bounding box for the widget
// by adding the Scene position to the ScBBox
func (wb *WidgetBase) winBBox() image.Rectangle {
        bb := wb.Geom.TotalBBox
        if wb.Scene != nil {
                return bb.Add(wb.Scene.SceneGeom.Pos)
        }
        return bb
}

// winPos returns the RenderWindow based position within the
// bounding box of the widget, where the x, y coordinates
// are the proportion across the bounding box to use:
// 0 = left / top, 1 = right / bottom
func (wb *WidgetBase) winPos(x, y float32) image.Point {
        bb := wb.winBBox()
        sz := bb.Size()
        var pt image.Point
        pt.X = bb.Min.X + int(math32.Round(float32(sz.X)*x))
        pt.Y = bb.Min.Y + int(math32.Round(float32(sz.Y)*y))
        return pt
}

//////// Profiling and Benchmarking, controlled by settings app bar

// ProfileToggle turns profiling on or off, which does both
// targeted profiling and global CPU and memory profiling.
func ProfileToggle() { //types:add
        if profile.Profiling {
                endTargetedProfile()
                endCPUMemoryProfile()
        } else {
                startTargetedProfile()
                startCPUMemoryProfile()
        }
}

var (
        // cpuProfileDir is the directory where the profile started
        cpuProfileDir string

        // cpuProfileFile is the file created by [startCPUMemoryProfile],
        // which needs to be stored so that it can be closed in [endCPUMemoryProfile].
        cpuProfileFile *os.File
)

// startCPUMemoryProfile starts the standard Go cpu and memory profiling.
func startCPUMemoryProfile() {
        cpuProfileDir, _ = os.Getwd()
        cpufnm := filepath.Join(cpuProfileDir, "cpu.prof")
        fmt.Println("Starting standard cpu and memory profiling to:", cpufnm)
        f, err := os.Create(cpufnm)
        if errors.Log(err) == nil {
                cpuProfileFile = f
                errors.Log(pprof.StartCPUProfile(f))
        }
}

// endCPUMemoryProfile ends the standard Go cpu and memory profiling.
func endCPUMemoryProfile() {
        memfnm := filepath.Join(cpuProfileDir, "mem.prof")
        fmt.Println("Ending standard cpu and memory profiling to:", memfnm)
        pprof.StopCPUProfile()
        errors.Log(cpuProfileFile.Close())
        f, err := os.Create(memfnm)
        if errors.Log(err) == nil {
                runtime.GC() // get up-to-date statistics
                errors.Log(pprof.WriteHeapProfile(f))
                errors.Log(f.Close())
        }
}

// startTargetedProfile starts targeted profiling using the [profile] package.
func startTargetedProfile() {
        fmt.Println("Starting targeted profiling")
        profile.Reset()
        profile.Profiling = true
}

// endTargetedProfile ends targeted profiling and prints the report.
func endTargetedProfile() {
        profile.Report(time.Millisecond)
        profile.Profiling = false
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !js

package core

import (
        "image"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/renderers/rasterx"
        "cogentcore.org/core/system/composer"
        "golang.org/x/image/draw"
)

func (ps *paintSource) Draw(c composer.Composer) {
        cd := c.(*composer.ComposerDrawer)
        rd := ps.renderer.(*rasterx.Renderer)

        unchanged := len(ps.render) == 0
        if !unchanged {
                rd.Render(ps.render)
        }
        img := rd.Image()
        cd.Drawer.Copy(ps.drawPos, img, img.Bounds(), ps.drawOp, unchanged)
}

func (ss *scrimSource) Draw(c composer.Composer) {
        cd := c.(*composer.ComposerDrawer)
        clr := colors.Uniform(colors.ApplyOpacity(colors.ToUniform(colors.Scheme.Scrim), 0.5))
        cd.Drawer.Copy(image.Point{}, clr, ss.bbox, draw.Over, composer.Unchanged)
}

func (ss *spritesSource) Draw(c composer.Composer) {
        cd := c.(*composer.ComposerDrawer)
        for _, sr := range ss.sprites {
                if !sr.active {
                        continue
                }
                cd.Drawer.Copy(sr.drawPos, sr.pixels, sr.pixels.Bounds(), draw.Over, composer.Unchanged)
        }
}

////////         fillInsets

// fillInsetsSource is a [composer.Source] implementation for fillInsets.
type fillInsetsSource struct {
        rbb, wbb image.Rectangle
}

func (ss *fillInsetsSource) Draw(c composer.Composer) {
        cd := c.(*composer.ComposerDrawer)
        clr := colors.Scheme.Background

        fill := func(x0, y0, x1, y1 int) {
                r := image.Rect(x0, y0, x1, y1)
                if r.Dx() == 0 || r.Dy() == 0 {
                        return
                }
                cd.Drawer.Copy(image.Point{}, clr, r, draw.Src, composer.Unchanged)
        }
        rb := ss.rbb
        wb := ss.wbb
        fill(0, 0, wb.Max.X, rb.Min.Y)        // top
        fill(0, rb.Max.Y, wb.Max.X, wb.Max.Y) // bottom
        fill(rb.Max.X, 0, wb.Max.X, wb.Max.Y) // right
        fill(0, 0, rb.Min.X, wb.Max.Y)        // left
}

// fillInsets fills the window insets, if any, with [colors.Scheme.Background].
func (w *renderWindow) fillInsets(cp composer.Composer) {
        // render geom and window geom
        rg := w.SystemWindow.RenderGeom()
        wg := math32.Geom2DInt{Size: w.SystemWindow.Size()}

        // if our window geom is the same as our render geom, we have no
        // window insets to fill
        if wg == rg {
                return
        }
        cp.Add(&fillInsetsSource{rbb: rg.Bounds(), wbb: wg.Bounds()}, w)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"

        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/system/composer"
        "golang.org/x/image/draw"
)

//////// Scene

// SceneSource returns a [composer.Source] for the given scene
// using the given suggested draw operation.
func SceneSource(sc *Scene, op draw.Op) composer.Source {
        if sc.Painter.State == nil || sc.renderer == nil {
                return nil
        }
        render := sc.Painter.RenderDone()
        return &paintSource{render: render, renderer: sc.renderer, drawOp: op, drawPos: sc.SceneGeom.Pos}
}

// paintSource is the [composer.Source] for [paint.Painter] content, such as for a [Scene].
type paintSource struct {

        // render is the render content.
        render render.Render

        // renderer is the renderer for drawing the painter content.
        renderer render.Renderer

        // drawOp is the [draw.Op] operation: [draw.Src] to copy source,
        // [draw.Over] to alpha blend.
        drawOp draw.Op

        // drawPos is the position offset for the [Image] renderer to
        // use in its Draw to a [composer.Drawer] (i.e., the [Scene] position).
        drawPos image.Point
}

//////// Scrim

// ScrimSource returns a [composer.Source] for a scrim with the given bounding box.
func ScrimSource(bbox image.Rectangle) composer.Source {
        return &scrimSource{bbox: bbox}
}

// scrimSource is a [composer.Source] implementation for a scrim.
type scrimSource struct {
        bbox image.Rectangle
}

//////// Sprites

// SpritesSource returns a [composer.Source] for rendering [Sprites].
func SpritesSource(sprites *Sprites, scpos image.Point) composer.Source {
        sprites.Lock()
        defer sprites.Unlock()
        ss := &spritesSource{}
        ss.sprites = make([]spriteRender, len(sprites.Order))
        for i, kv := range sprites.Order {
                sp := kv.Value
                // note: may need to copy pixels but hoping not..
                sr := spriteRender{drawPos: sp.Geom.Pos.Add(scpos), pixels: sp.Pixels, active: sp.Active}
                ss.sprites[i] = sr
        }
        sprites.modified = false
        return ss
}

// spritesSource is a [composer.Source] implementation for [Sprites].
type spritesSource struct {
        sprites []spriteRender
}

// spriteRender holds info sufficient for rendering a sprite.
type spriteRender struct {
        drawPos image.Point
        pixels  *image.RGBA
        active  bool
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "log"
        "sync"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/colors/matcolor"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/system"
        "cogentcore.org/core/system/composer"
        "cogentcore.org/core/text/shaped"
        "golang.org/x/image/draw"
)

// windowWait is a wait group for waiting for all the open window event
// loops to finish. It is incremented by [renderWindow.GoStartEventLoop]
// and decremented when the event loop terminates.
var windowWait sync.WaitGroup

// Wait waits for all windows to close and runs the main app loop.
// This should be put at the end of the main function if
// [Body.RunMainWindow] is not used.
//
// For offscreen testing, Wait is typically never called, as it is
// not necessary (the app will already terminate once all tests are done,
// and nothing needs to run on the main thread).
func Wait() {
        waitCalled = true
        defer func() { system.HandleRecover(recover()) }()
        go func() {
                defer func() { system.HandleRecover(recover()) }()
                windowWait.Wait()
                system.TheApp.Quit()
        }()
        system.TheApp.MainLoop()
}

var (
        // currentRenderWindow is the current [renderWindow].
        // On single window platforms (mobile, web, and offscreen),
        // this is the only render window.
        currentRenderWindow *renderWindow

        // renderWindowGlobalMu is a mutex for any global state associated with windows
        renderWindowGlobalMu sync.Mutex
)

func setCurrentRenderWindow(w *renderWindow) {
        renderWindowGlobalMu.Lock()
        currentRenderWindow = w
        renderWindowGlobalMu.Unlock()
}

// renderWindow provides an outer "actual" window where everything is rendered,
// and is the point of entry for all events coming in from user actions.
//
// renderWindow contents are all managed by the [stages] stack that
// handles main [Stage] elements such as [WindowStage] and [DialogStage], which in
// turn manage their own stack of popup stage elements such as menus and tooltips.
// The contents of each Stage is provided by a Scene, containing Widgets,
// and the Stage Pixels image is drawn to the renderWindow in the renderWindow method.
//
// Rendering is handled by the [system.Drawer]. It is akin to a window manager overlaying Go image bitmaps
// on top of each other in the proper order, based on the [stages] stacking order.
// Sprites are managed by the main stage, as layered textures of the same size,
// to enable unlimited number packed into a few descriptors for standard sizes.
type renderWindow struct {

        // name is the name of the window.
        name string

        // title is the displayed name of window, for window manager etc.
        // Window object name is the internal handle and is used for tracking property info etc
        title string

        // SystemWindow is the OS-specific window interface, which handles
        // all the os-specific functions, including delivering events etc
        SystemWindow system.Window `json:"-" xml:"-"`

        // mains is the stack of main stages in this render window.
        // The [RenderContext] in this manager is the original source for all Stages.
        mains stages

        // noEventsChan is a channel on which a signal is sent when there are
        // no events left in the window [events.Deque]. It is used internally
        // for event handling in tests.
        noEventsChan chan struct{}

        // flags are atomic renderWindow flags.
        flags renderWindowFlags

        // lastResize is the time stamp of last resize event -- used for efficient updating.
        lastResize time.Time
}

// newRenderWindow creates a new window with given internal name handle,
// display name, and options.  This is called by Stage.newRenderWindow
// which handles setting the opts and other infrastructure.
func newRenderWindow(name, title string, opts *system.NewWindowOptions) *renderWindow {
        w := &renderWindow{}
        w.name = name
        w.title = title
        var err error
        w.SystemWindow, err = system.TheApp.NewWindow(opts)
        if err != nil {
                fmt.Printf("Cogent Core NewRenderWindow error: %v \n", err)
                return nil
        }
        w.SystemWindow.SetName(title)
        w.SystemWindow.SetTitleBarIsDark(matcolor.SchemeIsDark)
        w.SystemWindow.SetCloseReqFunc(func(win system.Window) {
                rc := w.renderContext()
                rc.Lock()
                w.flags.SetFlag(true, winClosing)
                // ensure that everyone is closed first
                for _, kv := range w.mains.stack.Order {
                        if kv.Value == nil || kv.Value.Scene == nil || kv.Value.Scene.This == nil {
                                continue
                        }
                        if !kv.Value.Scene.Close() {
                                w.flags.SetFlag(false, winClosing)
                                return
                        }
                }
                rc.Unlock()
                win.Close()
        })
        return w
}

// MainScene returns the current [renderWindow.mains] top Scene,
// which is the current window or full window dialog occupying the RenderWindow.
func (w *renderWindow) MainScene() *Scene {
        top := w.mains.top()
        if top == nil {
                return nil
        }
        return top.Scene
}

// RecycleMainWindow looks for an existing non-dialog window with the given Data.
// If it finds it, it shows it and returns true. Otherwise, it returns false.
// See [RecycleDialog] for a dialog version.
func RecycleMainWindow(data any) bool {
        if data == nil {
                return false
        }
        ew, got := mainRenderWindows.findData(data)
        if !got {
                return false
        }
        if DebugSettings.WindowEventTrace {
                fmt.Printf("Win: %v getting recycled based on data match\n", ew.name)
        }
        ew.Raise()
        return true
}

// setName sets name of this window and also the RenderWindow, and applies any window
// geometry settings associated with the new name if it is different from before
func (w *renderWindow) setName(name string) {
        curnm := w.name
        isdif := curnm != name
        w.name = name
        if w.SystemWindow != nil {
                w.SystemWindow.SetName(name)
        }
        if isdif && w.SystemWindow != nil && !w.SystemWindow.Is(system.Fullscreen) {
                wgp, sc := theWindowGeometrySaver.get(w.title, "")
                if wgp != nil {
                        theWindowGeometrySaver.settingStart()
                        if w.SystemWindow.Size() != wgp.Size || w.SystemWindow.Position(sc) != wgp.Pos {
                                if DebugSettings.WindowGeometryTrace {
                                        log.Printf("WindowGeometry: SetName setting geom for window: %v pos: %v size: %v\n", w.name, wgp.Pos, wgp.Size)
                                }
                                w.SystemWindow.SetGeometry(false, wgp.Pos, wgp.Size, sc)
                                system.TheApp.SendEmptyEvent()
                        }
                        theWindowGeometrySaver.settingEnd()
                }
        }
}

// setTitle sets title of this window and its underlying SystemWin.
func (w *renderWindow) setTitle(title string) {
        w.title = title
        if w.SystemWindow != nil {
                w.SystemWindow.SetTitle(title)
        }
}

// SetStageTitle sets the title of the underlying [system.Window] to the given stage title
// combined with the [renderWindow] title.
func (w *renderWindow) SetStageTitle(title string) {
        if title == "" {
                title = w.title
        } else if title != w.title {
                title = title + " • " + w.title
        }
        w.SystemWindow.SetTitle(title)
}

// logicalDPI returns the current logical dots-per-inch resolution of the
// window, which should be used for most conversion of standard units --
// physical DPI can be found in the Screen
func (w *renderWindow) logicalDPI() float32 {
        if w.SystemWindow == nil {
                sc := system.TheApp.Screen(0)
                if sc == nil {
                        return 160 // null default
                }
                return sc.LogicalDPI
        }
        return w.SystemWindow.LogicalDPI()
}

// stepZoom calls [SetZoom] with the current zoom plus 10 times the given number of steps.
func (w *renderWindow) stepZoom(steps float32) {
        sc := w.SystemWindow.Screen()
        curZoom := AppearanceSettings.Zoom
        screenName := ""
        sset, ok := AppearanceSettings.Screens[sc.Name]
        if ok {
                screenName = sc.Name
                curZoom = sset.Zoom
        }
        w.setZoom(curZoom+10*steps, screenName)
}

// setZoom sets [AppearanceSettingsData.Zoom] to the given value and then triggers
// necessary updating and makes a snackbar. If screenName is non-empty, then the
// zoom is set on the screen-specific settings, instead of the global.
func (w *renderWindow) setZoom(zoom float32, screenName string) {
        zoom = math32.Clamp(zoom, 10, 500)
        if screenName != "" {
                sset := AppearanceSettings.Screens[screenName]
                sset.Zoom = zoom
                AppearanceSettings.Screens[screenName] = sset
        } else {
                AppearanceSettings.Zoom = zoom
        }
        AppearanceSettings.Apply()
        UpdateAll()
        errors.Log(SaveSettings(AppearanceSettings))

        if ms := w.MainScene(); ms != nil {
                b := NewBody().AddSnackbarText(fmt.Sprintf("%.f%%", zoom))
                NewStretch(b)
                b.AddSnackbarIcon(icons.Remove, func(e events.Event) {
                        w.stepZoom(-1)
                })
                b.AddSnackbarIcon(icons.Add, func(e events.Event) {
                        w.stepZoom(1)
                })
                b.AddSnackbarButton("Reset", func(e events.Event) {
                        w.setZoom(100, screenName)
                })
                b.DeleteChildByName("stretch")
                b.RunSnackbar(ms)
        }
}

// resized updates Scene sizes after a window has been resized.
// It is called on any geometry update, including move and
// DPI changes, so it detects what actually needs to be updated.
func (w *renderWindow) resized() {
        rc := w.renderContext()
        if !w.isVisible() {
                rc.visible = false
                return
        }

        w.SystemWindow.Lock()
        rg := w.SystemWindow.RenderGeom()
        w.SystemWindow.Unlock()

        curRg := rc.geom
        curDPI := w.logicalDPI()
        if curRg == rg {
                newDPI := false
                if rc.logicalDPI != curDPI {
                        rc.logicalDPI = curDPI
                        newDPI = true
                }
                if DebugSettings.WindowEventTrace {
                        fmt.Printf("Win: %v same-size resized: %v newDPI: %v\n", w.name, curRg, newDPI)
                }
                if w.mains.resize(rg) || newDPI {
                        for _, kv := range w.mains.stack.Order {
                                st := kv.Value
                                sc := st.Scene
                                sc.applyStyleScene()
                        }
                }
                return
        }
        rc.logicalDPI = curDPI
        if !w.isVisible() {
                rc.visible = false
                if DebugSettings.WindowEventTrace {
                        fmt.Printf("Win: %v Resized already closed\n", w.name)
                }
                return
        }
        if DebugSettings.WindowEventTrace {
                fmt.Printf("Win: %v Resized from: %v to: %v\n", w.name, curRg, rg)
        }
        rc.geom = rg
        rc.visible = true
        w.flags.SetFlag(true, winResize)
        w.mains.resize(rg)
        if DebugSettings.WindowGeometryTrace {
                log.Printf("WindowGeometry: recording from Resize\n")
        }
        theWindowGeometrySaver.record(w)
}

// Raise requests that the window be at the top of the stack of windows,
// and receive focus. If it is minimized, it will be un-minimized. This
// is the only supported mechanism for un-minimizing. This also sets
// [currentRenderWindow] to the window.
func (w *renderWindow) Raise() {
        w.SystemWindow.Raise()
        setCurrentRenderWindow(w)
}

// minimize requests that the window be minimized, making it no longer
// visible or active; rendering should not occur for minimized windows.
func (w *renderWindow) minimize() {
        w.SystemWindow.Minimize()
}

// closeReq requests that the window be closed, which could be rejected.
// It firsts unlocks and then locks the [renderContext] to prevent deadlocks.
// If this is called asynchronously outside of the main event loop,
// [renderWindow.SystemWin.closeReq] should be called directly instead.
func (w *renderWindow) closeReq() {
        rc := w.renderContext()
        rc.Unlock()
        w.SystemWindow.CloseReq()
        rc.Lock()
}

// closed frees any resources after the window has been closed.
func (w *renderWindow) closed() {
        AllRenderWindows.delete(w)
        mainRenderWindows.delete(w)
        dialogRenderWindows.delete(w)
        if DebugSettings.WindowEventTrace {
                fmt.Printf("Win: %v Closed\n", w.name)
        }
        if len(AllRenderWindows) > 0 {
                pfw := AllRenderWindows[len(AllRenderWindows)-1]
                if DebugSettings.WindowEventTrace {
                        fmt.Printf("Win: %v getting restored focus after: %v closed\n", pfw.name, w.name)
                }
                pfw.Raise()
        }
}

// isClosed reports if the window has been closed
func (w *renderWindow) isClosed() bool {
        return w.SystemWindow.IsClosed() || w.mains.stack.Len() == 0
}

// isVisible is the main visibility check; don't do any window updates if not visible!
func (w *renderWindow) isVisible() bool {
        if w == nil || w.SystemWindow == nil || w.isClosed() || w.flags.HasFlag(winClosing) || !w.SystemWindow.IsVisible() {
                return false
        }
        return true
}

// goStartEventLoop starts the event processing loop for this window in a new
// goroutine, and returns immediately.  Adds to WindowWait wait group so a main
// thread can wait on that for all windows to close.
func (w *renderWindow) goStartEventLoop() {
        windowWait.Add(1)
        go w.eventLoop()
}

// todo: fix or remove
// sendWinFocusEvent sends the RenderWinFocusEvent to widgets
func (w *renderWindow) sendWinFocusEvent(act events.WinActions) {
        // se := window.NewEvent(act)
        // se.Init()
        // w.Mains.HandleEvent(se)
}

// eventLoop runs the event processing loop for the RenderWindow -- grabs system
// events for the window and dispatches them to receiving nodes, and manages
// other state etc (popups, etc).
func (w *renderWindow) eventLoop() {
        defer func() { system.HandleRecover(recover()) }()

        d := &w.SystemWindow.Events().Deque

        for {
                if w.flags.HasFlag(winStopEventLoop) {
                        w.flags.SetFlag(false, winStopEventLoop)
                        break
                }
                e := d.NextEvent()
                if w.flags.HasFlag(winStopEventLoop) {
                        w.flags.SetFlag(false, winStopEventLoop)
                        break
                }
                w.handleEvent(e)
                if w.noEventsChan != nil && len(d.Back) == 0 && len(d.Front) == 0 {
                        w.noEventsChan <- struct{}{}
                }
        }
        if DebugSettings.WindowEventTrace {
                fmt.Printf("Win: %v out of event loop\n", w.name)
        }
        windowWait.Done()
        // our last act must be self destruction!
        w.mains.deleteAll()
}

// handleEvent processes given events.Event.
// All event processing operates under a RenderContext.Lock
// so that no rendering update can occur during event-driven updates.
// Because rendering itself is event driven, this extra level of safety
// is redundant in this case, but other non-event-driven updates require
// the lock protection.
func (w *renderWindow) handleEvent(e events.Event) {
        rc := w.renderContext()
        rc.Lock()
        // we manually handle Unlock's in this function instead of deferring
        // it to avoid a cryptic "sync: can't unlock an already unlocked Mutex"
        // error when panicking in the rendering goroutine. This is critical for
        // debugging on Android. TODO: maybe figure out a more sustainable approach to this.

        et := e.Type()
        if DebugSettings.EventTrace && et != events.WindowPaint && et != events.MouseMove {
                log.Println("Window got event", e)
        }
        if et >= events.Window && et <= events.WindowPaint {
                w.handleWindowEvents(e)
                rc.Unlock()
                return
        }
        if DebugSettings.EventTrace && (!w.isVisible() || w.SystemWindow.Is(system.Minimized)) {
                log.Println("got event while invisible:", e)
                log.Println("w.isClosed:", w.isClosed(), "winClosing flag:", w.flags.HasFlag(winClosing), "syswin !isvis:", !w.SystemWindow.IsVisible(), "minimized:", w.SystemWindow.Is(system.Minimized))
        }
        // fmt.Printf("got event type: %v: %v\n", et.BitIndexString(), evi)
        w.mains.mainHandleEvent(e)
        rc.Unlock()
}

func (w *renderWindow) handleWindowEvents(e events.Event) {
        et := e.Type()
        switch et {
        case events.WindowPaint:
                e.SetHandled()
                rc := w.renderContext()
                rc.Unlock() // one case where we need to break lock
                w.renderWindow()
                rc.Lock()
                w.mains.runDeferred() // note: must be outside of locks in renderWindow

        case events.WindowResize:
                e.SetHandled()
                w.resized()

        case events.Window:
                ev := e.(*events.WindowEvent)
                switch ev.Action {
                case events.WinClose:
                        if w.SystemWindow.Lock() {
                                // fmt.Printf("got close event for window %v \n", w.name)
                                e.SetHandled()
                                w.flags.SetFlag(true, winStopEventLoop)
                                w.closed()
                                w.SystemWindow.Unlock()
                        }
                case events.WinMinimize:
                        e.SetHandled()
                        // on mobile platforms, we need to set the size to 0 so that it detects a size difference
                        // and lets the size event go through when we come back later
                        // if Platform().IsMobile() {
                        //         w.Scene.Geom.Size = image.Point{}
                        // }
                case events.WinShow:
                        e.SetHandled()
                        // note that this is sent delayed by driver
                        if DebugSettings.WindowEventTrace {
                                fmt.Printf("Win: %v got show event\n", w.name)
                        }
                case events.WinMove:
                        e.SetHandled()
                        // fmt.Printf("win move: %v\n", w.SystemWin.Position())
                        if DebugSettings.WindowGeometryTrace {
                                log.Printf("WindowGeometry: recording from Move\n")
                        }
                        w.SystemWindow.ConstrainFrame(true) // top only
                        theWindowGeometrySaver.record(w)
                case events.WinFocus:
                        // if we are not already the last in AllRenderWins, we go there,
                        // as this allows focus to be restored to us in the future
                        if len(AllRenderWindows) > 0 && AllRenderWindows[len(AllRenderWindows)-1] != w {
                                AllRenderWindows.delete(w)
                                AllRenderWindows.add(w)
                        }
                        if !w.flags.HasFlag(winGotFocus) {
                                w.flags.SetFlag(true, winGotFocus)
                                w.sendWinFocusEvent(events.WinFocus)
                                if DebugSettings.WindowEventTrace {
                                        fmt.Printf("Win: %v got focus\n", w.name)
                                }
                        } else {
                                if DebugSettings.WindowEventTrace {
                                        fmt.Printf("Win: %v got extra focus\n", w.name)
                                }
                        }
                        setCurrentRenderWindow(w)
                case events.WinFocusLost:
                        if DebugSettings.WindowEventTrace {
                                fmt.Printf("Win: %v lost focus\n", w.name)
                        }
                        w.flags.SetFlag(false, winGotFocus)
                        w.sendWinFocusEvent(events.WinFocusLost)
                case events.ScreenUpdate:
                        if DebugSettings.WindowEventTrace {
                                log.Println("Win: ScreenUpdate", w.name, screenConfig())
                        }
                        if !TheApp.Platform().IsMobile() { // native desktop
                                if TheApp.NScreens() > 0 {
                                        AppearanceSettings.Apply()
                                        UpdateAll()
                                        theWindowGeometrySaver.restoreAll()
                                }
                        } else {
                                w.resized()
                        }
                }
        }
}

////////  Rendering

// renderParams are the key [renderWindow] params that determine if
// a scene needs to be restyled since last render, if these params change.
type renderParams struct {
        // logicalDPI is the current logical dots-per-inch resolution of the
        // window, which should be used for most conversion of standard units.
        logicalDPI float32

        // Geometry of the rendering window, in actual "dot" pixels used for rendering.
        geom math32.Geom2DInt
}

// needsRestyle returns true if the current render context
// params differ from those used in last render.
func (rp *renderParams) needsRestyle(rc *renderContext) bool {
        return rp.logicalDPI != rc.logicalDPI || rp.geom != rc.geom
}

// saveRender grabs current render context params
func (rp *renderParams) saveRender(rc *renderContext) {
        rp.logicalDPI = rc.logicalDPI
        rp.geom = rc.geom
}

// renderContext provides rendering context from outer RenderWindow
// window to Stage and Scene elements to inform styling, layout
// and rendering. It also has the main Mutex for any updates
// to the window contents: use Lock for anything updating.
type renderContext struct {

        // logicalDPI is the current logical dots-per-inch resolution of the
        // window, which should be used for most conversion of standard units.
        logicalDPI float32

        // Geometry of the rendering window, in actual "dot" pixels used for rendering.
        geom math32.Geom2DInt

        // visible is whether the window is visible and should be rendered to.
        visible bool

        // rebuild is whether to force a rebuild of all Scene elements.
        rebuild bool

        // TextShaper is the text shaping system for the render context,
        // for doing text layout.
        textShaper shaped.Shaper

        // render mutex for locking out rendering and any destructive updates.
        // It is locked at the [renderWindow] level during rendering and
        // event processing to provide exclusive blocking of external updates.
        // Use [WidgetBase.AsyncLock] from any outside routine to grab the lock before
        // doing modifications.
        sync.Mutex
}

// newRenderContext returns a new [renderContext] initialized according to
// the main Screen size and LogicalDPI as initial defaults.
// The actual window size is set during Resized method, which is typically
// called after the window is created by the OS.
func newRenderContext() *renderContext {
        rc := &renderContext{}
        scr := system.TheApp.Screen(0)
        if scr != nil {
                rc.geom.SetRect(image.Rectangle{Max: scr.PixelSize})
                rc.logicalDPI = scr.LogicalDPI
        } else {
                rc.geom = math32.Geom2DInt{Size: image.Pt(1080, 720)}
                rc.logicalDPI = 160
        }
        rc.visible = true
        rc.textShaper = shaped.NewShaper()
        return rc
}

func (rc *renderContext) String() string {
        str := fmt.Sprintf("Geom: %s  Visible: %v", rc.geom, rc.visible)
        return str
}

func (w *renderWindow) renderContext() *renderContext {
        return w.mains.renderContext
}

////////  renderWindow

// renderWindow performs all rendering based on current Stages config.
// It locks and unlocks the renderContext itself, which is necessary so that
// there is a moment for other goroutines to acquire the lock and get necessary
// updates through (such as in offscreen testing).
func (w *renderWindow) renderWindow() {
        if w.flags.HasFlag(winIsRendering) { // still doing the last one
                w.flags.SetFlag(true, winRenderSkipped)
                if DebugSettings.WindowRenderTrace {
                        log.Printf("RenderWindow: still rendering, skipped: %v\n", w.name)
                }
                return
        }

        offscreen := TheApp.Platform() == system.Offscreen

        sinceResize := time.Since(w.lastResize)
        if !offscreen && sinceResize < 100*time.Millisecond {
                // get many rapid updates during resizing, so just rerender last one if so.
                // this works best in practice after a lot of experimentation.
                w.flags.SetFlag(true, winRenderSkipped)
                w.SystemWindow.Composer().Redraw()
                return
        }

        rc := w.renderContext()
        rc.Lock()
        defer func() {
                rc.rebuild = false
                rc.Unlock()
        }()
        rebuild := rc.rebuild

        stageMods, sceneMods := w.mains.updateAll() // handles all Scene / Widget updates!
        top := w.mains.top()
        if top == nil || w.mains.stack.Len() == 0 {
                return
        }
        spriteMods := top.Sprites.IsModified()

        if !spriteMods && !rebuild && !stageMods && !sceneMods { // nothing to do!
                if w.flags.HasFlag(winRenderSkipped) {
                        w.flags.SetFlag(false, winRenderSkipped)
                } else {
                        return
                }
        }
        if !w.isVisible() || w.SystemWindow.Is(system.Minimized) {
                if DebugSettings.WindowRenderTrace {
                        log.Printf("RenderWindow: skipping update on inactive / minimized window: %v\n", w.name)
                }
                return
        }

        if DebugSettings.WindowRenderTrace {
                log.Println("RenderWindow: doing render:", w.name)
                log.Println("rebuild:", rebuild, "stageMods:", stageMods, "sceneMods:", sceneMods)
        }

        if !w.SystemWindow.Lock() {
                if DebugSettings.WindowRenderTrace {
                        log.Printf("RenderWindow: window was closed: %v\n", w.name)
                }
                return
        }

        // now we go in the proper bottom-up order to generate the [render.Scene]
        cp := w.SystemWindow.Composer()
        cp.Start()
        sm := &w.mains
        n := sm.stack.Len()

        w.fillInsets(cp) // only does something on non-js

        // first, find the top-level window:
        winIndex := 0
        var winScene *Scene
        for i := n - 1; i >= 0; i-- {
                st := sm.stack.ValueByIndex(i)
                if st.Type == WindowStage {
                        if DebugSettings.WindowRenderTrace {
                                log.Println("GatherScenes: main Window:", st.String())
                        }
                        winScene = st.Scene
                        winIndex = i
                        cp.Add(winScene.RenderSource(draw.Src), winScene)
                        for _, dr := range winScene.directRenders {
                                cp.Add(dr.RenderSource(draw.Over), dr)
                        }
                        break
                }
        }

        // then add everyone above that
        for i := winIndex + 1; i < n; i++ {
                st := sm.stack.ValueByIndex(i)
                if st.Scrim && i == n-1 {
                        cp.Add(ScrimSource(winScene.Geom.TotalBBox), &st.Scrim)
                }
                cp.Add(st.Scene.RenderSource(draw.Over), st.Scene)
                if DebugSettings.WindowRenderTrace {
                        log.Println("GatherScenes: overlay Stage:", st.String())
                }
        }

        // then add the popups for the top main stage
        for _, kv := range top.popups.stack.Order {
                st := kv.Value
                cp.Add(st.Scene.RenderSource(draw.Over), st.Scene)
                if DebugSettings.WindowRenderTrace {
                        log.Println("GatherScenes: popup:", st.String())
                }
        }
        scpos := winScene.SceneGeom.Pos
        if TheApp.Platform().IsMobile() {
                scpos = image.Point{}
        }
        cp.Add(SpritesSource(&top.Sprites, scpos), &top.Sprites)

        w.SystemWindow.Unlock()
        if offscreen || w.flags.HasFlag(winResize) || sinceResize < 500*time.Millisecond {
                w.flags.SetFlag(true, winIsRendering)
                w.renderAsync(cp)
                if w.flags.HasFlag(winResize) {
                        w.lastResize = time.Now()
                }
                w.flags.SetFlag(false, winResize)
        } else {
                // note: it is critical to set *before* going into loop
                // because otherwise we can lose an entire pass before the goroutine starts!
                // function will turn flag off when it finishes.
                w.flags.SetFlag(true, winIsRendering)
                go w.renderAsync(cp)
        }
}

// renderAsync is the implementation of the main render pass,
// which must be called in a goroutine. It relies on the platform-specific
// [renderWindow.doRender].
func (w *renderWindow) renderAsync(cp composer.Composer) {
        if !w.SystemWindow.Lock() {
                w.flags.SetFlag(false, winIsRendering) // note: comes in with flag set
                // fmt.Println("renderAsync SystemWindow lock fail")
                return
        }
        // pr := profile.Start("Compose")
        // fmt.Println("start compose")
        cp.Compose()
        // pr.End()
        w.flags.SetFlag(false, winIsRendering) // note: comes in with flag set
        w.SystemWindow.Unlock()
}

// RenderSource returns the [render.Render] state from the [Scene.Painter].
func (sc *Scene) RenderSource(op draw.Op) composer.Source {
        sc.setFlag(false, sceneImageUpdated)
        return SceneSource(sc, op)
}

// renderWindowFlags are atomic bit flags for [renderWindow] state.
// They must be atomic to prevent race conditions.
type renderWindowFlags int64 //enums:bitflag -trim-prefix win

const (
        // winIsRendering indicates that the renderAsync function is running.
        winIsRendering renderWindowFlags = iota

        // winRenderSkipped indicates that a render update was skipped, so
        // another update will be run to ensure full updating.
        winRenderSkipped

        // winResize indicates that the window was just resized.
        winResize

        // winStopEventLoop indicates that the event loop should be stopped.
        winStopEventLoop

        // winClosing is whether the window is closing.
        winClosing

        // winGotFocus indicates that have we received focus.
        winGotFocus
)

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "slices"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/sides"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/tree"
)

// Scene contains a [Widget] tree, rooted in an embedded [Frame] layout,
// which renders into its own [paint.Painter]. The [Scene] is set in a
// [Stage], which the [Scene] has a pointer to.
//
// Each [Scene] contains state specific to its particular usage
// within a given [Stage] and overall rendering context, representing the unit
// of rendering in the Cogent Core framework.
type Scene struct { //core:no-new
        Frame

        // Body provides the main contents of scenes that use control Bars
        // to allow the main window contents to be specified separately
        // from that dynamic control content.  When constructing scenes using
        // a [Body], you can operate directly on the [Body], which has wrappers
        // for most major Scene functions.
        Body *Body `json:"-" xml:"-" set:"-"`

        // WidgetInit is a function called on every newly created [Widget].
        // This can be used to set global configuration and styling for all
        // widgets in conjunction with [App.SceneInit].
        WidgetInit func(w Widget) `json:"-" xml:"-" edit:"-"`

        // Bars are functions for creating control bars,
        // attached to different sides of a [Scene]. Functions
        // are called in forward order so first added are called first.
        Bars sides.Sides[BarFuncs] `json:"-" xml:"-" set:"-"`

        // Data is the optional data value being represented by this scene.
        // Used e.g., for recycling views of a given item instead of creating new one.
        Data any

        // Size and position relative to overall rendering context.
        SceneGeom math32.Geom2DInt `edit:"-" set:"-"`

        // painter for rendering
        Painter paint.Painter `copier:"-" json:"-" xml:"-" display:"-" set:"-"`

        // event manager for this scene
        Events Events `copier:"-" json:"-" xml:"-" set:"-"`

        // current stage in which this Scene is set
        Stage *Stage `copier:"-" json:"-" xml:"-" set:"-"`

        // Animations are the currently active [Animation]s in this scene.
        Animations []*Animation `json:"-" xml:"-" set:"-"`

        // renderBBoxes indicates to render colored bounding boxes for all of the widgets
        // in the scene. This is enabled by the [Inspector] in select element mode.
        renderBBoxes bool

        // renderBBoxHue is current hue for rendering bounding box in [Scene.RenderBBoxes] mode.
        renderBBoxHue float32

        // selectedWidget is the currently selected/hovered widget through the [Inspector] selection mode
        // that should be highlighted with a background color.
        selectedWidget Widget

        // selectedWidgetChan is the channel on which the selected widget through the inspect editor
        // selection mode is transmitted to the inspect editor after the user is done selecting.
        selectedWidgetChan chan Widget `json:"-" xml:"-"`

        // source renderer for rendering the scene
        renderer render.Renderer `copier:"-" json:"-" xml:"-" display:"-" set:"-"`

        // lastRender captures key params from last render.
        // If different then a new ApplyStyleScene is needed.
        lastRender renderParams

        // showIter counts up at start of showing a Scene
        // to trigger Show event and other steps at start of first show
        showIter int

        // directRenders are widgets that render directly to the [RenderWindow]
        // instead of rendering into the Scene Painter.
        directRenders []Widget

        // flags are atomic bit flags for [Scene] state.
        flags sceneFlags
}

// sceneFlags are atomic bit flags for [Scene] state.
// They must be atomic to prevent race conditions.
type sceneFlags int64 //enums:bitflag -trim-prefix scene

const (
        // sceneHasShown is whether this scene has been shown.
        // This is used to ensure that [events.Show] is only sent once.
        sceneHasShown sceneFlags = iota

        // sceneUpdating means the Scene is in the process of sceneUpdating.
        // It is set for any kind of tree-level update.
        // Skip any further update passes until it goes off.
        sceneUpdating

        // sceneNeedsRender is whether anything in the Scene needs to be re-rendered
        // (but not necessarily the whole scene itself).
        sceneNeedsRender

        // sceneNeedsLayout is whether the Scene needs a new layout pass.
        sceneNeedsLayout

        // sceneHasDeferred is whether the Scene has elements with Deferred functions.
        sceneHasDeferred

        // sceneImageUpdated indicates that the Scene's image has been updated
        // e.g., due to a render or a resize. This is reset by the
        // global [RenderWindow] rendering pass, so it knows whether it needs to
        // copy the image up to the GPU or not.
        sceneImageUpdated

        // sceneContentSizing means that this scene is currently doing a
        // contentSize computation to compute the size of the scene
        // (for sizing window for example). Affects layout size computation.
        sceneContentSizing
)

// hasFlag returns whether the given flag is set.
func (sc *Scene) hasFlag(f sceneFlags) bool {
        return sc.flags.HasFlag(f)
}

// setFlag sets the given flags to the given value.
func (sc *Scene) setFlag(on bool, f ...enums.BitFlag) {
        sc.flags.SetFlag(on, f...)
}

// newBodyScene creates a new Scene for use with an associated Body that
// contains the main content of the Scene (e.g., a Window, Dialog, etc).
// It will be constructed from the Bars-configured control bars on each
// side, with the given Body as the central content.
func newBodyScene(body *Body) *Scene {
        sc := NewScene(body.Name + " scene")
        sc.Body = body
        // need to set parent immediately so that SceneInit works,
        // but can not add it yet because it may go elsewhere due
        // to app bars
        tree.SetParent(body, sc)
        return sc
}

// NewScene creates a new [Scene] object without a [Body], e.g., for use
// in a Menu, Tooltip or other such simple popups or non-control-bar Scenes.
func NewScene(name ...string) *Scene {
        sc := tree.New[Scene]()
        if len(name) > 0 {
                sc.SetName(name[0])
        }
        sc.Events.scene = sc
        return sc
}

func (sc *Scene) Init() {
        sc.Scene = sc
        sc.Frame.Init()
        sc.AddContextMenu(sc.standardContextMenu)
        sc.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Clickable) // this is critical to enable click-off to turn off focus.
                s.Cursor = cursors.Arrow
                s.Background = colors.Scheme.Background
                s.Color = colors.Scheme.OnBackground
                // we never want borders on scenes
                s.MaxBorder = styles.Border{}
                s.Direction = styles.Column
                s.Overflow.Set(styles.OverflowAuto) // screen is always scroller of last resort

                // insets and minimum window padding
                if sc.Stage == nil {
                        return
                }
                if sc.Stage.Type.isPopup() || (sc.Stage.Type == DialogStage && !sc.Stage.FullWindow) {
                        return
                }

                s.Padding.Set(units.Dp(8))
        })
        sc.OnShow(func(e events.Event) {
                currentRenderWindow.SetStageTitle(sc.Stage.Title)
        })
        sc.OnClose(func(e events.Event) {
                sm := sc.Stage.Mains
                if sm == nil {
                        return
                }
                sm.Lock()
                defer sm.Unlock()

                if sm.stack.Len() < 2 {
                        return
                }
                // the stage that will be visible next
                st := sm.stack.ValueByIndex(sm.stack.Len() - 2)
                currentRenderWindow.SetStageTitle(st.Title)
        })
        sc.Updater(func() {
                if TheApp.Platform() == system.Offscreen {
                        return
                }
                // At the scene level, we reset the shortcuts and add our context menu
                // shortcuts every time. This clears the way for buttons to add their
                // shortcuts in their own Updaters. We must get the shortcuts every time
                // since buttons may be added or removed dynamically.
                sc.Events.shortcuts = nil
                tmps := NewScene()
                sc.applyContextMenus(tmps)
                sc.Events.getShortcutsIn(tmps)
        })
        if TheApp.SceneInit != nil {
                TheApp.SceneInit(sc)
        }
}

// renderContext returns the current render context.
// This will be nil prior to actual rendering.
func (sc *Scene) renderContext() *renderContext {
        if sc.Stage == nil {
                return nil
        }
        sm := sc.Stage.Mains
        if sm == nil {
                return nil
        }
        return sm.renderContext
}

// TextShaper returns the current [shaped.TextShaper], for text shaping.
// may be nil if not yet initialized.
func (sc *Scene) TextShaper() shaped.Shaper {
        rc := sc.renderContext()
        if rc != nil {
                return rc.textShaper
        }
        return nil
}

// RenderWindow returns the current render window for this scene.
// In general it is best to go through [renderContext] instead of the window.
// This will be nil prior to actual rendering.
func (sc *Scene) RenderWindow() *renderWindow {
        if sc.Stage == nil {
                return nil
        }
        sm := sc.Stage.Mains
        if sm == nil {
                return nil
        }
        return sm.renderWindow
}

// fitInWindow fits Scene geometry (pos, size) into given window geom.
// Calls resize for the new size and returns whether it actually needed to
// be resized.
func (sc *Scene) fitInWindow(winGeom math32.Geom2DInt) bool {
        geom := sc.SceneGeom
        geom = geom.FitInWindow(winGeom)
        return sc.resize(geom)
}

// resize resizes the scene if needed, creating a new image; updates Geom.
// returns false if the scene is already the correct size.
func (sc *Scene) resize(geom math32.Geom2DInt) bool {
        if geom.Size.X <= 0 || geom.Size.Y <= 0 {
                return false
        }
        sz := math32.FromPoint(geom.Size)
        if sc.Painter.State == nil {
                sc.Painter = *paint.NewPainter(sz)
                sc.Painter.Paint.UnitContext = sc.Styles.UnitContext
        }
        sc.SceneGeom.Pos = geom.Pos
        if sc.renderer != nil {
                img := sc.renderer.Image()
                if img != nil {
                        isz := img.Bounds().Size()
                        if isz == geom.Size {
                                return false
                        }
                }
        } else {
                sc.renderer = paint.NewSourceRenderer(sz)
        }
        sc.Painter.Paint.UnitContext = sc.Styles.UnitContext
        sc.Painter.State.Init(sc.Painter.Paint, sz)
        sc.renderer.SetSize(units.UnitDot, sz)
        sc.SceneGeom.Size = geom.Size // make sure

        sc.updateScene()
        sc.applyStyleScene()
        // restart the multi-render updating after resize, to get windows to update correctly while
        // resizing on Windows (OS) and Linux (see https://github.com/cogentcore/core/issues/584),
        // to get windows on Windows (OS) to update after a window snap (see
        // https://github.com/cogentcore/core/issues/497),
        // and to get FillInsets to overwrite mysterious black bars that otherwise are rendered
        // on both iOS and Android in different contexts.
        // TODO(kai): is there a more efficient way to do this, and do we need to do this on all platforms?
        sc.showIter = 0
        sc.NeedsLayout()
        return true
}

// ResizeToContent resizes the scene so it fits the current content.
// Only applicable to desktop systems where windows can be resized.
// Optional extra size is added to the amount computed to hold the contents,
// which is needed in cases with wrapped text elements, which don't
// always size accurately. See [Scene.SetGeometry] for a more general way
// to set all window geometry properties.
func (sc *Scene) ResizeToContent(extra ...image.Point) {
        if TheApp.Platform().IsMobile() { // not resizable
                return
        }
        win := sc.RenderWindow()
        if win == nil {
                return
        }
        go func() {
                scsz := system.TheApp.Screen(0).PixelSize
                sz := sc.contentSize(scsz)
                if len(extra) == 1 {
                        sz = sz.Add(extra[0])
                }
                win.SystemWindow.SetSize(sz)
        }()
}

// SetGeometry uses [system.Window.SetGeometry] to set all window geometry properties,
// with pos in operating system window manager units and size in raw pixels.
// If pos and/or size is not specified, it defaults to the current value.
// If fullscreen is true, pos and size are ignored, and screen indicates the number
// of the screen on which to fullscreen the window. If fullscreen is false, the
// window is moved to the given pos and size on the given screen. If screen is -1,
// the current screen the window is on is used, and fullscreen/pos/size are all
// relative to that screen. It is only applicable on desktop and web platforms,
// with only fullscreen supported on web. See [Scene.SetFullscreen] for a simpler way
// to set only the fullscreen state. See [Scene.ResizeToContent] to resize the window
// to fit the current content.
func (sc *Scene) SetGeometry(fullscreen bool, pos image.Point, size image.Point, screen int) {
        rw := sc.RenderWindow()
        if rw == nil {
                return
        }
        scr := TheApp.Screen(screen)
        if screen < 0 {
                scr = rw.SystemWindow.Screen()
        }
        rw.SystemWindow.SetGeometry(fullscreen, pos, size, scr)
}

// IsFullscreen returns whether the window associated with this [Scene]
// is in fullscreen mode (true) or window mode (false). This is implemented
// on desktop and web platforms. See [Scene.SetFullscreen] to update the
// current fullscreen state and [Stage.SetFullscreen] to set the initial state.
func (sc *Scene) IsFullscreen() bool {
        rw := sc.RenderWindow()
        if rw == nil {
                return false
        }
        return rw.SystemWindow.Is(system.Fullscreen)
}

// SetFullscreen requests that the window associated with this [Scene]
// be updated to either fullscreen mode (true) or window mode (false).
// This is implemented on desktop and web platforms. See [Scene.IsFullscreen]
// to get the current fullscreen state and [Stage.SetFullscreen] to set the
// initial state. ([Stage.SetFullscreen] sets the initial state, whereas
// this function sets the current state after the [Stage] is already running).
// See [Scene.SetGeometry] for a more general way to set all window
// geometry properties.
func (sc *Scene) SetFullscreen(fullscreen bool) {
        rw := sc.RenderWindow()
        if rw == nil {
                return
        }
        wgp, screen := theWindowGeometrySaver.get(rw.title, "")
        if wgp != nil {
                rw.SystemWindow.SetGeometry(fullscreen, wgp.Pos, wgp.Size, screen)
        } else {
                rw.SystemWindow.SetGeometry(fullscreen, image.Point{}, image.Point{}, rw.SystemWindow.Screen())
        }
}

// Close closes the [Stage] associated with this [Scene].
// This only works for main stages (windows and dialogs).
// It returns whether the [Stage] was successfully closed.
func (sc *Scene) Close() bool {
        if sc == nil {
                return true
        }
        e := &events.Base{Typ: events.Close}
        e.Init()
        sc.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                cw.AsWidget().HandleEvent(e)
                return tree.Continue
        })
        // if they set the event as handled, we do not close the scene
        if e.IsHandled() {
                return false
        }
        mm := sc.Stage.Mains
        if mm == nil {
                return false // todo: needed, but not sure why
        }
        mm.deleteStage(sc.Stage)
        if sc.Stage.NewWindow && !TheApp.Platform().IsMobile() && !mm.renderWindow.flags.HasFlag(winClosing) && !mm.renderWindow.flags.HasFlag(winStopEventLoop) && !TheApp.IsQuitting() {
                mm.renderWindow.closeReq()
        }
        return true
}

func (sc *Scene) ApplyScenePos() {
        sc.Frame.ApplyScenePos()
        if sc.Parts == nil {
                return
        }

        mvi := sc.Parts.ChildByName("move", 1)
        if mvi == nil {
                return
        }
        mv := mvi.(Widget).AsWidget()

        sc.Parts.Geom.Pos.Total.Y = math32.Ceil(0.5 * mv.Geom.Size.Actual.Total.Y)
        sc.Parts.Geom.Size.Actual = sc.Geom.Size.Actual
        sc.Parts.Geom.Size.Alloc = sc.Geom.Size.Alloc
        sc.Parts.setContentPosFromPos()
        sc.Parts.setBBoxesFromAllocs()
        sc.Parts.applyScenePosChildren()

        psz := sc.Parts.Geom.Size.Actual.Content

        mv.Geom.RelPos.X = 0.5*psz.X - 0.5*mv.Geom.Size.Actual.Total.X
        mv.Geom.RelPos.Y = 0
        mv.setPosFromParent()
        mv.setBBoxesFromAllocs()

        rszi := sc.Parts.ChildByName("resize", 1)
        if rszi == nil {
                return
        }
        rsz := rszi.(Widget).AsWidget()
        rsz.Geom.RelPos.X = psz.X // - 0.5*rsz.Geom.Size.Actual.Total.X
        rsz.Geom.RelPos.Y = psz.Y // - 0.5*rsz.Geom.Size.Actual.Total.Y
        rsz.setPosFromParent()
        rsz.setBBoxesFromAllocs()
}

func (sc *Scene) AddDirectRender(w Widget) {
        sc.directRenders = append(sc.directRenders, w)
}

func (sc *Scene) DeleteDirectRender(w Widget) {
        idx := slices.Index(sc.directRenders, w)
        if idx >= 0 {
                sc.directRenders = slices.Delete(sc.directRenders, idx, idx+1)
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "time"

        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// autoScrollRate determines the rate of auto-scrolling of layouts
var autoScrollRate = float32(10)

// hasAnyScroll returns true if the frame has any scrollbars.
func (fr *Frame) hasAnyScroll() bool {
        return fr.HasScroll[math32.X] || fr.HasScroll[math32.Y]
}

// ScrollGeom returns the target position and size for scrollbars
func (fr *Frame) ScrollGeom(d math32.Dims) (pos, sz math32.Vector2) {
        sbw := math32.Ceil(fr.Styles.ScrollbarWidth.Dots)
        sbwb := sbw + fr.Styles.Border.Width.Right.Dots + fr.Styles.Margin.Right.Dots
        od := d.Other()
        bbmin := math32.FromPoint(fr.Geom.ContentBBox.Min)
        bbmax := math32.FromPoint(fr.Geom.ContentBBox.Max)
        bbtmax := math32.FromPoint(fr.Geom.TotalBBox.Max)
        if fr.This != fr.Scene.This { // if not the scene, keep inside the scene
                bbmin.SetMax(math32.FromPoint(fr.Scene.Geom.ContentBBox.Min))
                bbmax.SetMin(math32.FromPoint(fr.Scene.Geom.ContentBBox.Max))
                bbtmax.SetMin(math32.FromPoint(fr.Scene.Geom.TotalBBox.Max))
        }
        pos.SetDim(d, bbmin.Dim(d))
        pos.SetDim(od, bbtmax.Dim(od)-sbwb) // base from total
        bbsz := bbmax.Sub(bbmin)
        sz.SetDim(d, bbsz.Dim(d)-4)
        sz.SetDim(od, sbw)
        sz = sz.Ceil()
        return
}

// ConfigScrolls configures any scrollbars that have been enabled
// during the Layout process. This is called during Position, once
// the sizing and need for scrollbars has been established.
// The final position of the scrollbars is set during ScenePos in
// PositionScrolls.  Scrolls are kept around in general.
func (fr *Frame) ConfigScrolls() {
        for d := math32.X; d <= math32.Y; d++ {
                if fr.HasScroll[d] {
                        fr.configScroll(d)
                }
        }
}

// configScroll configures scroll for given dimension
func (fr *Frame) configScroll(d math32.Dims) {
        if fr.Scrolls[d] != nil {
                return
        }
        fr.Scrolls[d] = NewSlider()
        sb := fr.Scrolls[d]
        tree.SetParent(sb, fr)
        // sr.SetFlag(true, tree.Field) // note: do not turn on -- breaks pos
        sb.SetType(SliderScrollbar)
        sb.InputThreshold = 1
        sb.Min = 0.0
        sb.Styler(func(s *styles.Style) {
                s.Direction = styles.Directions(d)
                s.Padding.Zero()
                s.Margin.Zero()
                s.MaxBorder.Width.Zero()
                s.Border.Width.Zero()
                s.FillMargin = false
        })
        sb.FinalStyler(func(s *styles.Style) {
                od := d.Other()
                _, sz := fr.This.(Layouter).ScrollGeom(d)
                if sz.X > 0 && sz.Y > 0 {
                        s.SetState(false, states.Invisible)
                        s.Min.SetDim(d, units.Dot(sz.Dim(d)))
                        s.Min.SetDim(od, units.Dot(sz.Dim(od)))
                } else {
                        s.SetState(true, states.Invisible)
                }
                s.Max = s.Min
        })
        sb.OnInput(func(e events.Event) {
                e.SetHandled()
                fr.This.(Layouter).ScrollChanged(d, sb)
        })
        sb.Update()
}

// ScrollChanged is called in the OnInput event handler for updating,
// when the scrollbar value has changed, for given dimension.
// This is part of the Layouter interface.
func (fr *Frame) ScrollChanged(d math32.Dims, sb *Slider) {
        fr.Geom.Scroll.SetDim(d, -sb.Value)
        fr.This.(Layouter).ApplyScenePos() // computes updated positions
        fr.NeedsRender()
}

// ScrollUpdateFromGeom updates the scrollbar for given dimension
// based on the current Geom.Scroll value for that dimension.
// This can be used to programatically update the scroll value.
func (fr *Frame) ScrollUpdateFromGeom(d math32.Dims) {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return
        }
        sb := fr.Scrolls[d]
        cv := fr.Geom.Scroll.Dim(d)
        sb.setValueEvent(-cv)
        fr.This.(Layouter).ApplyScenePos() // computes updated positions
        fr.NeedsRender()
}

// ScrollValues returns the maximum size that could be scrolled,
// the visible size (which could be less than the max size, in which
// case no scrollbar is needed), and visSize / maxSize as the VisiblePct.
// This is used in updating the scrollbar and determining whether one is
// needed in the first place
func (fr *Frame) ScrollValues(d math32.Dims) (maxSize, visSize, visPct float32) {
        sz := &fr.Geom.Size
        maxSize = sz.Internal.Dim(d)
        visSize = sz.Alloc.Content.Dim(d)
        visPct = visSize / maxSize
        return
}

// SetScrollParams sets scrollbar parameters.  Must set Step and PageStep,
// but can also set others as needed.
// Max and VisiblePct are automatically set based on ScrollValues maxSize, visPct.
func (fr *Frame) SetScrollParams(d math32.Dims, sb *Slider) {
        sb.Min = 0
        sb.Step = 1
        sb.PageStep = float32(fr.Geom.ContentBBox.Dy())
}

// PositionScrolls arranges scrollbars
func (fr *Frame) PositionScrolls() {
        for d := math32.X; d <= math32.Y; d++ {
                if fr.HasScroll[d] && fr.Scrolls[d] != nil {
                        fr.positionScroll(d)
                } else {
                        fr.Geom.Scroll.SetDim(d, 0)
                }
        }
}

func (fr *Frame) positionScroll(d math32.Dims) {
        sb := fr.Scrolls[d]
        pos, ssz := fr.This.(Layouter).ScrollGeom(d)
        maxSize, _, visPct := fr.This.(Layouter).ScrollValues(d)
        if sb.Geom.Pos.Total == pos && sb.Geom.Size.Actual.Content == ssz && sb.visiblePercent == visPct {
                return
        }
        if ssz.X <= 0 || ssz.Y <= 0 {
                sb.SetState(true, states.Invisible)
                return
        }
        sb.SetState(false, states.Invisible)
        sb.Max = maxSize
        sb.setVisiblePercent(visPct)
        // fmt.Println(ly, d, "vis pct:", asz/csz)
        sb.SetValue(sb.Value) // keep in range
        fr.This.(Layouter).SetScrollParams(d, sb)

        sb.Restyle() // applies style
        sb.SizeUp()
        sb.Geom.Size.Alloc = fr.Geom.Size.Actual
        sb.SizeDown(0)

        sb.Geom.Pos.Total = pos
        sb.setContentPosFromPos()
        // note: usually these are intersected with parent *content* bbox,
        // but scrolls are specifically outside of that.
        sb.setBBoxesFromAllocs()
}

// RenderScrolls renders the scrollbars.
func (fr *Frame) RenderScrolls() {
        for d := math32.X; d <= math32.Y; d++ {
                if fr.HasScroll[d] && fr.Scrolls[d] != nil {
                        fr.Scrolls[d].RenderWidget()
                }
        }
}

// setScrollsOff turns off the scrollbars.
func (fr *Frame) setScrollsOff() {
        for d := math32.X; d <= math32.Y; d++ {
                fr.HasScroll[d] = false
        }
}

// scrollActionDelta moves the scrollbar in given dimension by given delta.
// returns whether actually scrolled.
func (fr *Frame) scrollActionDelta(d math32.Dims, delta float32) bool {
        if fr.HasScroll[d] && fr.Scrolls[d] != nil {
                sb := fr.Scrolls[d]
                nval := sb.Value + sb.scrollScale(delta)
                chg := sb.setValueEvent(nval)
                if chg {
                        fr.NeedsRender() // only render needed -- scroll updates pos
                }
                return chg
        }
        return false
}

// scrollDelta processes a scroll event.  If only one dimension is processed,
// and there is a non-zero in other, then the consumed dimension is reset to 0
// and the event is left unprocessed, so a higher level can consume the
// remainder.
func (fr *Frame) scrollDelta(e events.Event) {
        se := e.(*events.MouseScroll)
        fdel := se.Delta

        hasShift := e.HasAnyModifier(key.Shift, key.Alt) // shift or alt indicates to scroll horizontally
        if hasShift {
                if !fr.HasScroll[math32.X] { // if we have shift, we can only horizontal scroll
                        return
                }
                if fr.scrollActionDelta(math32.X, fdel.Y) {
                        e.SetHandled()
                }
                return
        }

        if fr.HasScroll[math32.Y] && fr.HasScroll[math32.X] {
                ch1 := fr.scrollActionDelta(math32.Y, fdel.Y)
                ch2 := fr.scrollActionDelta(math32.X, fdel.X)
                if ch1 || ch2 {
                        e.SetHandled()
                }
        } else if fr.HasScroll[math32.Y] {
                if fr.scrollActionDelta(math32.Y, fdel.Y) {
                        e.SetHandled()
                }
        } else if fr.HasScroll[math32.X] {
                if se.Delta.X != 0 {
                        if fr.scrollActionDelta(math32.X, fdel.X) {
                                e.SetHandled()
                        }
                } else if se.Delta.Y != 0 {
                        if fr.scrollActionDelta(math32.X, fdel.Y) {
                                e.SetHandled()
                        }
                }
        }
}

// parentScrollFrame returns the first parent frame that has active scrollbars.
func (wb *WidgetBase) parentScrollFrame() *Frame {
        ly := tree.ParentByType[Layouter](wb)
        if ly == nil {
                return nil
        }
        fr := ly.AsFrame()
        if fr.hasAnyScroll() {
                return fr
        }
        return fr.parentScrollFrame()
}

// ScrollToThis tells this widget's parent frame to scroll to keep
// this widget in view. It returns whether any scrolling was done.
func (wb *WidgetBase) ScrollToThis() bool {
        if wb.This == nil {
                return false
        }
        fr := wb.parentScrollFrame()
        if fr == nil {
                return false
        }
        return fr.scrollToWidget(wb.This.(Widget))
}

// ScrollThisToTop tells this widget's parent frame to scroll so the top
// of this widget is at the top of the visible range.
// It returns whether any scrolling was done.
func (wb *WidgetBase) ScrollThisToTop() bool {
        if wb.This == nil {
                return false
        }
        fr := wb.parentScrollFrame()
        if fr == nil {
                return false
        }
        box := wb.AsWidget().Geom.totalRect()
        return fr.ScrollDimToStart(math32.Y, box.Min.Y)
}

// scrollToWidget scrolls the layout to ensure that the given widget is in view.
// It returns whether scrolling was needed.
func (fr *Frame) scrollToWidget(w Widget) bool {
        // note: critical to NOT use BBox b/c it is zero for invisible items!
        box := w.AsWidget().Geom.totalRect()
        if box.Size() == (image.Point{}) {
                return false
        }
        return fr.ScrollToBox(box)
}

// autoScrollDim auto-scrolls along one dimension, based on a position value
// relative to the visible dimensions of the frame
// (i.e., subtracting ed.Geom.Pos.Content).
func (fr *Frame) autoScrollDim(d math32.Dims, pos float32) bool {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return false
        }
        sb := fr.Scrolls[d]
        smax := sb.effectiveMax()
        ssz := sb.scrollThumbValue()
        dst := sb.Step * autoScrollRate

        fromMax := ssz - pos                      // distance from max in visible window
        if pos < 0 || pos < math32.Abs(fromMax) { // pushing toward min
                pct := pos / ssz
                if pct < .1 && sb.Value > 0 {
                        dst = min(dst, sb.Value)
                        sb.setValueEvent(sb.Value - dst)
                        return true
                }
        } else {
                pct := fromMax / ssz
                if pct < .1 && sb.Value < smax {
                        dst = min(dst, (smax - sb.Value))
                        sb.setValueEvent(sb.Value + dst)
                        return true
                }
        }
        return false
}

var lastAutoScroll time.Time

// AutoScroll scrolls the layout based on given position in scroll
// coordinates (i.e., already subtracing the BBox Min for a mouse event).
func (fr *Frame) AutoScroll(pos math32.Vector2) bool {
        now := time.Now()
        lag := now.Sub(lastAutoScroll)
        if lag < SystemSettings.LayoutAutoScrollDelay {
                return false
        }
        did := false
        if fr.HasScroll[math32.Y] && fr.HasScroll[math32.X] {
                did = fr.autoScrollDim(math32.Y, pos.Y)
                did = did || fr.autoScrollDim(math32.X, pos.X)
        } else if fr.HasScroll[math32.Y] {
                did = fr.autoScrollDim(math32.Y, pos.Y)
        } else if fr.HasScroll[math32.X] {
                did = fr.autoScrollDim(math32.X, pos.X)
        }
        if did {
                lastAutoScroll = time.Now()
        }
        return did
}

// scrollToBoxDim scrolls to ensure that given target [min..max] range
// along one dimension is in view. Returns true if scrolling was needed
func (fr *Frame) scrollToBoxDim(d math32.Dims, tmini, tmaxi int) bool {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return false
        }
        sb := fr.Scrolls[d]
        if sb == nil || sb.This == nil {
                return false
        }
        tmin, tmax := float32(tmini), float32(tmaxi)
        cmin, cmax := fr.Geom.contentRangeDim(d)
        if tmin >= cmin && tmax <= cmax {
                return false
        }
        h := fr.Styles.Font.Size.Dots
        if tmin < cmin { // favors scrolling to start
                trg := sb.Value + tmin - cmin - h
                if trg < 0 {
                        trg = 0
                }
                sb.setValueEvent(trg)
                return true
        }
        if (tmax - tmin) < sb.scrollThumbValue() { // only if whole thing fits
                trg := sb.Value + float32(tmax-cmax) + h
                sb.setValueEvent(trg)
                return true
        }
        return false
}

// ScrollToBox scrolls the layout to ensure that given rect box is in view.
// Returns true if scrolling was needed
func (fr *Frame) ScrollToBox(box image.Rectangle) bool {
        did := false
        if fr.HasScroll[math32.Y] && fr.HasScroll[math32.X] {
                did = fr.scrollToBoxDim(math32.Y, box.Min.Y, box.Max.Y)
                did = did || fr.scrollToBoxDim(math32.X, box.Min.X, box.Max.X)
        } else if fr.HasScroll[math32.Y] {
                did = fr.scrollToBoxDim(math32.Y, box.Min.Y, box.Max.Y)
        } else if fr.HasScroll[math32.X] {
                did = fr.scrollToBoxDim(math32.X, box.Min.X, box.Max.X)
        }
        if did {
                fr.NeedsRender()
        }
        return did
}

// ScrollDimToStart scrolls to put the given child coordinate position (eg.,
// top / left of a view box) at the start (top / left) of our scroll area, to
// the extent possible. Returns true if scrolling was needed.
func (fr *Frame) ScrollDimToStart(d math32.Dims, posi int) bool {
        if !fr.HasScroll[d] {
                return false
        }
        pos := float32(posi)
        cmin, _ := fr.Geom.contentRangeDim(d)
        if pos == cmin {
                return false
        }
        sb := fr.Scrolls[d]
        trg := math32.Clamp(sb.Value+(pos-cmin), 0, sb.effectiveMax())
        sb.setValueEvent(trg)
        return true
}

// ScrollDimToContentStart is a helper function that scrolls the layout to the
// start of its content (ie: moves the scrollbar to the very start).
// See also [Frame.IsDimAtContentStart].
func (fr *Frame) ScrollDimToContentStart(d math32.Dims) bool {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return false
        }
        sb := fr.Scrolls[d]
        sb.setValueEvent(0)
        return true
}

// IsDimAtContentStart returns whether the given dimension is scrolled to the
// start of its content. See also [Frame.ScrollDimToContentStart].
func (fr *Frame) IsDimAtContentStart(d math32.Dims) bool {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return false
        }
        sb := fr.Scrolls[d]
        return sb.Value == 0
}

// ScrollDimToEnd scrolls to put the given child coordinate position (eg.,
// bottom / right of a view box) at the end (bottom / right) of our scroll
// area, to the extent possible. Returns true if scrolling was needed.
func (fr *Frame) ScrollDimToEnd(d math32.Dims, posi int) bool {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return false
        }
        pos := float32(posi)
        _, cmax := fr.Geom.contentRangeDim(d)
        if pos == cmax {
                return false
        }
        sb := fr.Scrolls[d]
        trg := math32.Clamp(sb.Value+(pos-cmax), 0, sb.effectiveMax())
        sb.setValueEvent(trg)
        return true
}

// ScrollDimToContentEnd is a helper function that scrolls the layout to the
// end of its content (ie: moves the scrollbar to the very end).
// See also [Frame.IsDimAtContentEnd].
func (fr *Frame) ScrollDimToContentEnd(d math32.Dims) bool {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return false
        }
        sb := fr.Scrolls[d]
        sb.setValueEvent(sb.effectiveMax())
        return true
}

// IsDimAtContentEnd returns whether the given dimension is scrolled to the
// end of its content. See also [Frame.ScrollDimToContentEnd].
func (fr *Frame) IsDimAtContentEnd(d math32.Dims) bool {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return false
        }
        sb := fr.Scrolls[d]
        return sb.Value == sb.effectiveMax()
}

// ScrollDimToCenter scrolls to put the given child coordinate position (eg.,
// middle of a view box) at the center of our scroll area, to the extent
// possible. Returns true if scrolling was needed.
func (fr *Frame) ScrollDimToCenter(d math32.Dims, posi int) bool {
        if !fr.HasScroll[d] || fr.Scrolls[d] == nil {
                return false
        }
        pos := float32(posi)
        cmin, cmax := fr.Geom.contentRangeDim(d)
        mid := 0.5 * (cmin + cmax)
        if pos == mid {
                return false
        }
        sb := fr.Scrolls[d]
        trg := math32.Clamp(sb.Value+(pos-mid), 0, sb.effectiveMax())
        sb.setValueEvent(trg)
        return true
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/colors"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
)

// Separator draws a separator line. It goes in the direction
// specified by [styles.Style.Direction].
type Separator struct {
        WidgetBase
}

func (sp *Separator) Init() {
        sp.WidgetBase.Init()
        sp.Styler(func(s *styles.Style) {
                s.Align.Self = styles.Center
                s.Justify.Self = styles.Center
                s.Background = colors.Scheme.OutlineVariant
        })
        sp.FinalStyler(func(s *styles.Style) {
                if s.Direction == styles.Row {
                        s.Grow.Set(1, 0)
                        s.Min.Y.Dp(1)
                        s.Margin.SetHorizontal(units.Dp(6))
                } else {
                        s.Grow.Set(0, 1)
                        s.Min.X.Dp(1)
                        s.Margin.SetVertical(units.Dp(6))
                }
        })
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image/color"
        "io/fs"
        "os"
        "os/user"
        "path/filepath"
        "reflect"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/iox/jsonx"
        "cogentcore.org/core/base/iox/tomlx"
        "cogentcore.org/core/base/option"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/stringsx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/colors/matcolor"
        "cogentcore.org/core/cursors/cursorimg"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/tree"
)

// AllSettings is a global slice containing all of the user [Settings]
// that the user will see in the settings window. It contains the base Cogent Core
// settings by default and should be modified by other apps to add their
// app settings.
var AllSettings = []Settings{AppearanceSettings, SystemSettings, DeviceSettings, DebugSettings}

// Settings is the interface that describes the functionality common
// to all settings data types.
type Settings interface {

        // Label returns the label text for the settings.
        Label() string

        // Filename returns the full filename/filepath at which the settings are stored.
        Filename() string

        // Defaults sets the default values for all of the settings.
        Defaults()

        // Apply does anything necessary to apply the settings to the app.
        Apply()

        // MakeToolbar is an optional method that settings objects can implement in order to
        // configure the settings view toolbar with settings-related actions that the user can
        // perform.
        MakeToolbar(p *tree.Plan)
}

// SettingsOpener is an optional additional interface that
// [Settings] can satisfy to customize the behavior of [openSettings].
type SettingsOpener interface {
        Settings

        // Open opens the settings
        Open() error
}

// SettingsSaver is an optional additional interface that
// [Settings] can satisfy to customize the behavior of [SaveSettings].
type SettingsSaver interface {
        Settings

        // Save saves the settings
        Save() error
}

// SettingsBase contains base settings logic that other settings data types can extend.
type SettingsBase struct {

        // Name is the name of the settings.
        Name string `display:"-" save:"-"`

        // File is the full filename/filepath at which the settings are stored.
        File string `display:"-" save:"-"`
}

// Label returns the label text for the settings.
func (sb *SettingsBase) Label() string {
        return sb.Name
}

// Filename returns the full filename/filepath at which the settings are stored.
func (sb *SettingsBase) Filename() string {
        return sb.File
}

// Defaults does nothing by default and can be extended by other settings data types.
func (sb *SettingsBase) Defaults() {}

// Apply does nothing by default and can be extended by other settings data types.
func (sb *SettingsBase) Apply() {}

// MakeToolbar does nothing by default and can be extended by other settings data types.
func (sb *SettingsBase) MakeToolbar(p *tree.Plan) {}

// openSettings opens the given settings from their [Settings.Filename].
// The settings are assumed to be in TOML unless they have a .json file
// extension. If they satisfy the [SettingsOpener] interface,
// [SettingsOpener.Open] will be used instead.
func openSettings(se Settings) error {
        if so, ok := se.(SettingsOpener); ok {
                return so.Open()
        }
        fnm := se.Filename()
        if filepath.Ext(fnm) == ".json" {
                return jsonx.Open(se, fnm)
        }
        return tomlx.Open(se, fnm)
}

// SaveSettings saves the given settings to their [Settings.Filename].
// The settings will be encoded in TOML unless they have a .json file
// extension. If they satisfy the [SettingsSaver] interface,
// [SettingsSaver.Save] will be used instead. Any non default
// fields are not saved, following [reflectx.NonDefaultFields].
func SaveSettings(se Settings) error {
        if ss, ok := se.(SettingsSaver); ok {
                return ss.Save()
        }
        fnm := se.Filename()
        ndf := reflectx.NonDefaultFields(se)
        if filepath.Ext(fnm) == ".json" {
                return jsonx.Save(ndf, fnm)
        }
        return tomlx.Save(ndf, fnm)
}

// resetSettings resets the given settings to their default values.
func resetSettings(se Settings) error {
        err := os.RemoveAll(se.Filename())
        if err != nil {
                return err
        }
        npv := reflectx.NonPointerValue(reflect.ValueOf(se))
        // we only reset the non-default fields to avoid removing the base
        // information (name, filename, etc)
        ndf := reflectx.NonDefaultFields(se)
        for f := range ndf {
                rf := npv.FieldByName(f)
                rf.Set(reflect.Zero(rf.Type()))
        }
        return loadSettings(se)
}

// resetAllSettings resets all of the settings to their default values.
func resetAllSettings() error { //types:add
        for _, se := range AllSettings {
                err := resetSettings(se)
                if err != nil {
                        return err
                }
        }
        UpdateAll()
        return nil
}

// loadSettings sets the defaults of, opens, and applies the given settings.
// If they are not already saved, it saves them. It process their `default:` struct
// tags in addition to calling their [Settings.Default] method.
func loadSettings(se Settings) error {
        errors.Log(reflectx.SetFromDefaultTags(se))
        se.Defaults()
        err := openSettings(se)
        // we always apply the settings even if we can't open them
        // to apply at least the default values
        se.Apply()
        if errors.Is(err, fs.ErrNotExist) {
                return nil // it is okay for settings to not be saved
        }
        return err
}

// LoadAllSettings sets the defaults of, opens, and applies [AllSettings].
func LoadAllSettings() error {
        errs := []error{}
        for _, se := range AllSettings {
                err := loadSettings(se)
                if err != nil {
                        errs = append(errs, err)
                }
        }
        return errors.Join(errs...)
}

// UpdateSettings applies and saves the given settings in the context of the given
// widget and then updates all windows and triggers a full render rebuild.
func UpdateSettings(ctx Widget, se Settings) {
        se.Apply()
        ErrorSnackbar(ctx, SaveSettings(se), "Error saving "+se.Label()+" settings")
        UpdateAll()
}

// UpdateAll updates all windows and triggers a full render rebuild.
// It is typically called when user settings are changed.
func UpdateAll() { //types:add
        // Some caches are invalid now:
        clear(gradient.Cache)
        clear(cursorimg.Cursors)

        for _, w := range AllRenderWindows {
                rc := w.mains.renderContext
                rc.logicalDPI = w.logicalDPI()
                rc.rebuild = true // trigger full rebuild
        }
}

// AppearanceSettings are the currently active global Cogent Core appearance settings.
var AppearanceSettings = &AppearanceSettingsData{
        SettingsBase: SettingsBase{
                Name: "Appearance",
                File: filepath.Join(TheApp.CogentCoreDataDir(), "appearance-settings.toml"),
        },
}

// AppearanceSettingsData is the data type for the global Cogent Core appearance settings.
type AppearanceSettingsData struct { //types:add
        SettingsBase

        // the color theme.
        Theme Themes `default:"Auto"`

        // the primary color used to generate the color scheme.
        Color color.RGBA `default:"#4285f4"`

        // overall zoom factor as a percentage of the default zoom.
        // Use Control +/- keyboard shortcut to change zoom level anytime.
        // Screen-specific zoom factor will be used if present, see 'Screens' field.
        Zoom float32 `default:"100" min:"10" max:"500" step:"10" format:"%g%%"`

        // the overall spacing factor as a percentage of the default amount of spacing
        // (higher numbers lead to more space and lower numbers lead to higher density).
        Spacing float32 `default:"100" min:"10" max:"500" step:"10" format:"%g%%"`

        // the overall font size factor applied to all text as a percentage
        // of the default font size (higher numbers lead to larger text).
        FontSize float32 `default:"100" min:"10" max:"500" step:"10" format:"%g%%"`

        // Font size factor applied only to documentation and other
        // dense text contexts, not normal interactive elements.
        // It is a percentage of the base Font size setting (higher numbers
        // lead to larger text).
        DocsFontSize float32 `default:"100" min:"10" max:"500" step:"10" format:"%g%%"`

        // the amount that alternating rows are highlighted when showing
        // tabular data (set to 0 to disable zebra striping).
        ZebraStripes float32 `default:"0" min:"0" max:"100" step:"10" format:"%g%%"`

        // screen-specific settings, which will override overall defaults if set,
        // so different screens can use different zoom levels.
        // Use 'Save screen zoom' in the toolbar to save the current zoom for the current
        // screen, and Control +/- keyboard shortcut to change this zoom level anytime.
        Screens map[string]ScreenSettings `edit:"-"`

        // text highlighting style / theme.
        Highlighting HighlightingName `default:"emacs"`

        // Text specifies text settings including the language, and the
        // font families for different styles of fonts.
        Text rich.Settings
}

func (as *AppearanceSettingsData) Defaults() {
        as.Text.Defaults()
}

// ConstantSpacing returns a spacing value (padding, margin, gap)
// that will remain constant regardless of changes in the
// [AppearanceSettings.Spacing] setting.
func ConstantSpacing(value float32) float32 {
        return value * 100 / AppearanceSettings.Spacing
}

// Themes are the different possible themes that a user can select in their settings.
type Themes int32 //enums:enum -trim-prefix Theme

const (
        // ThemeAuto indicates to use the theme specified by the operating system
        ThemeAuto Themes = iota

        // ThemeLight indicates to use a light theme
        ThemeLight

        // ThemeDark indicates to use a dark theme
        ThemeDark
)

func (as *AppearanceSettingsData) ShouldDisplay(field string) bool {
        switch field {
        case "Color":
                return !ForceAppColor
        }
        return true
}

// AppColor is the default primary color used to generate the color
// scheme. The user can still change the primary color used to generate
// the color scheme through [AppearanceSettingsData.Color] unless
// [ForceAppColor] is set to true, but this value will always take
// effect if the settings color is the default value. It defaults to
// Google Blue (#4285f4).
var AppColor = color.RGBA{66, 133, 244, 255}

// ForceAppColor is whether to prevent the user from changing the color
// scheme and make it always based on [AppColor].
var ForceAppColor bool

func (as *AppearanceSettingsData) Apply() { //types:add
        if ForceAppColor || (as.Color == color.RGBA{66, 133, 244, 255}) {
                colors.SetSchemes(AppColor)
        } else {
                colors.SetSchemes(as.Color)
        }
        switch as.Theme {
        case ThemeLight:
                colors.SetScheme(false)
        case ThemeDark:
                colors.SetScheme(true)
        case ThemeAuto:
                colors.SetScheme(system.TheApp.IsDark())
        }
        if as.Highlighting == "" {
                as.Highlighting = "emacs"
        }
        rich.DefaultSettings = as.Text

        // TODO(kai): move HiStyle to a separate text editor settings
        // if TheViewInterface != nil {
        //         TheViewInterface.SetHiStyleDefault(as.HiStyle)
        // }

        as.applyDPI()
}

// applyDPI updates the screen LogicalDPI values according to current
// settings and zoom factor, and then updates all open windows as well.
func (as *AppearanceSettingsData) applyDPI() {
        // zoom is percentage, but LogicalDPIScale is multiplier
        system.LogicalDPIScale = as.Zoom / 100
        // fmt.Println("system ldpi:", system.LogicalDPIScale)
        n := system.TheApp.NScreens()
        for i := 0; i < n; i++ {
                sc := system.TheApp.Screen(i)
                if sc == nil {
                        continue
                }
                if scp, ok := as.Screens[sc.Name]; ok {
                        // zoom is percentage, but LogicalDPIScale is multiplier
                        system.SetLogicalDPIScale(sc.Name, scp.Zoom/100)
                }
                sc.UpdateLogicalDPI()
        }
        for _, w := range AllRenderWindows {
                w.SystemWindow.SetLogicalDPI(w.SystemWindow.Screen().LogicalDPI)
                // this isn't DPI-related, but this is the most efficient place to do it
                w.SystemWindow.SetTitleBarIsDark(matcolor.SchemeIsDark)
        }
}

// deleteSavedWindowGeometries deletes the file that saves the position and size of
// each window, by screen, and clear current in-memory cache. You shouldn't generally
// need to do this, but sometimes it is useful for testing or windows that are
// showing up in bad places that you can't recover from.
func (as *AppearanceSettingsData) deleteSavedWindowGeometries() { //types:add
        theWindowGeometrySaver.deleteAll()
}

// ZebraStripesWeight returns a 0 to 0.2 alpha opacity factor to use in computing
// a zebra stripe color.
func (as *AppearanceSettingsData) ZebraStripesWeight() float32 {
        return as.ZebraStripes * 0.002
}

// DeviceSettings are the global device settings.
var DeviceSettings = &DeviceSettingsData{
        SettingsBase: SettingsBase{
                Name: "Device",
                File: filepath.Join(TheApp.CogentCoreDataDir(), "device-settings.toml"),
        },
}

// SaveScreenZoom saves the current zoom factor for the current screen,
// which will then be used for this screen instead of overall default.
// Use the Control +/- keyboard shortcut to modify the screen zoom level.
func (as *AppearanceSettingsData) SaveScreenZoom() { //types:add
        sc := system.TheApp.Screen(0)
        sp, ok := as.Screens[sc.Name]
        if !ok {
                sp = ScreenSettings{}
        }
        sp.Zoom = as.Zoom
        if as.Screens == nil {
                as.Screens = make(map[string]ScreenSettings)
        }
        as.Screens[sc.Name] = sp
        errors.Log(SaveSettings(as))
}

// DeviceSettingsData is the data type for the device settings.
type DeviceSettingsData struct { //types:add
        SettingsBase

        // The keyboard shortcut map to use
        KeyMap keymap.MapName

        // The keyboard shortcut maps available as options for Key map.
        // If you do not want to have custom key maps, you should leave
        // this unset so that you always have the latest standard key maps.
        KeyMaps option.Option[keymap.Maps]

        // The maximum time interval between button press events to count as a double-click
        DoubleClickInterval time.Duration `default:"500ms" min:"100ms" step:"50ms"`

        // How fast the scroll wheel moves, which is typically pixels per wheel step
        // but units can be arbitrary. It is generally impossible to standardize speed
        // and variable across devices, and we don't have access to the system settings,
        // so unfortunately you have to set it here.
        ScrollWheelSpeed float32 `default:"1" min:"0.01" step:"1"`

        // The duration over which the current scroll widget retains scroll focus,
        // such that subsequent scroll events are sent to it.
        ScrollFocusTime time.Duration `default:"1s" min:"100ms" step:"50ms"`

        // The amount of time to wait before initiating a slide event
        // (as opposed to a basic press event)
        SlideStartTime time.Duration `default:"50ms" min:"5ms" max:"1s" step:"5ms"`

        // The amount of time to wait before initiating a drag (drag and drop) event
        // (as opposed to a basic press or slide event)
        DragStartTime time.Duration `default:"150ms" min:"5ms" max:"1s" step:"5ms"`

        // The amount of time to wait between each repeat click event,
        // when the mouse is pressed down.  The first click is 8x this.
        RepeatClickTime time.Duration `default:"100ms" min:"5ms" max:"1s" step:"5ms"`

        // The number of pixels that must be moved before initiating a slide/drag
        // event (as opposed to a basic press event)
        DragStartDistance int `default:"4" min:"0" max:"100" step:"1"`

        // The amount of time to wait before initiating a long hover event (e.g., for opening a tooltip)
        LongHoverTime time.Duration `default:"250ms" min:"10ms" max:"10s" step:"10ms"`

        // The maximum number of pixels that mouse can move and still register a long hover event
        LongHoverStopDistance int `default:"5" min:"0" max:"1000" step:"1"`

        // The amount of time to wait before initiating a long press event (e.g., for opening a tooltip)
        LongPressTime time.Duration `default:"500ms" min:"10ms" max:"10s" step:"10ms"`

        // The maximum number of pixels that mouse/finger can move and still register a long press event
        LongPressStopDistance int `default:"50" min:"0" max:"1000" step:"1"`
}

func (ds *DeviceSettingsData) Defaults() {
        ds.KeyMap = keymap.DefaultMap
        ds.KeyMaps.Value = keymap.AvailableMaps
}

func (ds *DeviceSettingsData) Apply() {
        if ds.KeyMaps.Valid {
                keymap.AvailableMaps = ds.KeyMaps.Value
        }
        if ds.KeyMap != "" {
                keymap.SetActiveMapName(ds.KeyMap)
        }

        events.ScrollWheelSpeed = ds.ScrollWheelSpeed
}

// ScreenSettings are per-screen settings that override the global settings.
type ScreenSettings struct { //types:add

        // overall zoom factor as a percentage of the default zoom
        Zoom float32 `default:"100" min:"10" max:"1000" step:"10" format:"%g%%"`
}

// SystemSettings are the currently active Cogent Core system settings.
var SystemSettings = &SystemSettingsData{
        SettingsBase: SettingsBase{
                Name: "System",
                File: filepath.Join(TheApp.CogentCoreDataDir(), "system-settings.toml"),
        },
}

// SystemSettingsData is the data type of the global Cogent Core settings.
type SystemSettingsData struct { //types:add
        SettingsBase

        // text editor settings
        Editor text.EditorSettings

        // whether to use a 24-hour clock (instead of AM and PM)
        Clock24 bool `label:"24-hour clock"`

        // SnackbarTimeout is the default amount of time until snackbars
        // disappear (snackbars show short updates about app processes
        // at the bottom of the screen)
        SnackbarTimeout time.Duration `default:"5s"`

        // only support closing the currently selected active tab;
        // if this is set to true, pressing the close button on other tabs
        // will take you to that tab, from which you can close it.
        OnlyCloseActiveTab bool `default:"false"`

        // the limit of file size, above which user will be prompted before
        // opening / copying, etc.
        BigFileSize int `default:"10000000"`

        // maximum number of saved paths to save in FilePicker
        SavedPathsMax int `default:"50"`

        // user info, which is partially filled-out automatically if empty
        // when settings are first created.
        User User

        // favorite paths, shown in FilePickerer and also editable there
        FavPaths favoritePaths

        // column to sort by in FilePicker, and :up or :down for direction.
        // Updated automatically via FilePicker
        FilePickerSort string `display:"-"`

        // the maximum height of any menu popup panel in units of font height;
        // scroll bars are enforced beyond that size.
        MenuMaxHeight int `default:"30" min:"5" step:"1"`

        // the amount of time to wait before offering completions
        CompleteWaitDuration time.Duration `default:"0ms" min:"0ms" max:"10s" step:"10ms"`

        // the maximum number of completions offered in popup
        CompleteMaxItems int `default:"25" min:"5" step:"1"`

        // time interval for cursor blinking on and off -- set to 0 to disable blinking
        CursorBlinkTime time.Duration `default:"500ms" min:"0ms" max:"1s" step:"5ms"`

        // The amount of time to wait before trying to autoscroll again
        LayoutAutoScrollDelay time.Duration `default:"25ms" min:"1ms" step:"5ms"`

        // number of steps to take in PageUp / Down events in terms of number of items
        LayoutPageSteps int `default:"10" min:"1" step:"1"`

        // the amount of time between keypresses to combine characters into name
        // to search for within layout -- starts over after this delay.
        LayoutFocusNameTimeout time.Duration `default:"500ms" min:"0ms" max:"5s" step:"20ms"`

        // the amount of time since last focus name event to allow tab to focus
        // on next element with same name.
        LayoutFocusNameTabTime time.Duration `default:"2s" min:"10ms" max:"10s" step:"100ms"`

        // the number of map elements at or below which an inline representation
        // of the map will be presented, which is more convenient for small #'s of properties
        MapInlineLength int `default:"2" min:"1" step:"1"`

        // the number of elemental struct fields at or below which an inline representation
        // of the struct will be presented, which is more convenient for small structs
        StructInlineLength int `default:"4" min:"2" step:"1"`

        // the number of slice elements below which inline will be used
        SliceInlineLength int `default:"4" min:"2" step:"1"`
}

func (ss *SystemSettingsData) Defaults() {
        ss.FavPaths.setToDefaults()
        ss.updateUser()
}

// Apply detailed settings to all the relevant settings.
func (ss *SystemSettingsData) Apply() { //types:add
        np := len(ss.FavPaths)
        for i := 0; i < np; i++ {
                if ss.FavPaths[i].Icon == "" || ss.FavPaths[i].Icon == "folder" {
                        ss.FavPaths[i].Icon = icons.Folder
                }
        }
}

func (ss *SystemSettingsData) Open() error {
        fnm := ss.Filename()
        err := tomlx.Open(ss, fnm)
        if len(ss.FavPaths) == 0 {
                ss.FavPaths.setToDefaults()
        }
        return err
}

// TimeFormat returns the Go time format layout string that should
// be used for displaying times to the user, based on the value of
// [SystemSettingsData.Clock24].
func (ss *SystemSettingsData) TimeFormat() string {
        if ss.Clock24 {
                return "15:04"
        }
        return "3:04 PM"
}

// updateUser gets the user info from the OS
func (ss *SystemSettingsData) updateUser() {
        usr, err := user.Current()
        if err == nil {
                ss.User.User = *usr
        }
}

// User basic user information that might be needed for different apps
type User struct { //types:add
        user.User

        // default email address -- e.g., for recording changes in a version control system
        Email string
}

////////  FavoritePaths

// favoritePathItem represents one item in a favorite path list, for display of
// favorites. Is an ordered list instead of a map because user can organize
// in order
type favoritePathItem struct { //types:add

        // icon for item
        Icon icons.Icon

        // name of the favorite item
        Name string `width:"20"`

        // the path of the favorite item
        Path string `table:"-select"`
}

// Label satisfies the Labeler interface
func (fi favoritePathItem) Label() string {
        return fi.Name
}

// favoritePaths is a list (slice) of favorite path items
type favoritePaths []favoritePathItem

// setToDefaults sets the paths to default values
func (pf *favoritePaths) setToDefaults() {
        *pf = make(favoritePaths, len(defaultPaths))
        copy(*pf, defaultPaths)
}

// findPath returns index of path on list, or -1, false if not found
func (pf *favoritePaths) findPath(path string) (int, bool) {
        for i, fi := range *pf {
                if fi.Path == path {
                        return i, true
                }
        }
        return -1, false
}

// defaultPaths are default favorite paths
var defaultPaths = favoritePaths{
        {icons.Home, "home", "~"},
        {icons.DesktopMac, "Desktop", "~/Desktop"},
        {icons.Document, "Documents", "~/Documents"},
        {icons.Download, "Downloads", "~/Downloads"},
        {icons.Computer, "root", "/"},
}

////////  FilePaths

// FilePaths represents a set of file paths.
type FilePaths []string

// recentPaths are the recently opened paths in the file picker.
var recentPaths FilePaths

// Open file paths from a json-formatted file.
func (fp *FilePaths) Open(filename string) error { //types:add
        err := jsonx.Open(fp, filename)
        if err != nil && !errors.Is(err, fs.ErrNotExist) {
                errors.Log(err)
        }
        return err
}

// Save file paths to a json-formatted file.
func (fp *FilePaths) Save(filename string) error { //types:add
        return errors.Log(jsonx.Save(fp, filename))
}

// AddPath inserts a path to the file paths (at the start), subject to max
// length -- if path is already on the list then it is moved to the start.
func (fp *FilePaths) AddPath(path string, max int) {
        stringsx.InsertFirstUnique((*[]string)(fp), path, max)
}

// savedPathsFilename is the name of the saved file paths file in
// the Cogent Core data directory.
const savedPathsFilename = "saved-paths.json"

// saveRecentPaths saves the active RecentPaths to data dir
func saveRecentPaths() {
        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, savedPathsFilename)
        errors.Log(recentPaths.Save(pnm))
}

// openRecentPaths loads the active RecentPaths from data dir
func openRecentPaths() {
        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, savedPathsFilename)
        err := recentPaths.Open(pnm)
        if err != nil && !errors.Is(err, fs.ErrNotExist) {
                errors.Log(err)
        }
}

////////  DebugSettings

// DebugSettings are the currently active debugging settings
var DebugSettings = &DebugSettingsData{
        SettingsBase: SettingsBase{
                Name: "Debug",
                File: filepath.Join(TheApp.CogentCoreDataDir(), "debug-settings.toml"),
        },
}

// DebugSettingsData is the data type for debugging settings.
type DebugSettingsData struct { //types:add
        SettingsBase

        // Print a trace of updates that trigger re-rendering
        UpdateTrace bool

        // Print a trace of the nodes rendering
        RenderTrace bool

        // Print a trace of all layouts
        LayoutTrace bool

        // Print more detailed info about the underlying layout computations
        LayoutTraceDetail bool

        // Print a trace of window events
        WindowEventTrace bool

        // Print the stack trace leading up to win publish events
        // which are expensive
        WindowRenderTrace bool

        // Print a trace of window geometry saving / loading functions
        WindowGeometryTrace bool

        // Print a trace of keyboard events
        KeyEventTrace bool

        // Print a trace of event handling
        EventTrace bool

        // Print a trace of focus changes
        FocusTrace bool

        // Print a trace of DND event handling
        DNDTrace bool

        // DisableWindowGeometrySaver disables the saving and loading of window geometry
        // data to allow for easier testing of window manipulation code.
        DisableWindowGeometrySaver bool

        // Print a trace of Go language completion and lookup process
        GoCompleteTrace bool

        // Print a trace of Go language type parsing and inference process
        GoTypeTrace bool
}

func (db *DebugSettingsData) Defaults() {
        // TODO(kai/binsize): figure out how to do this without dragging in parse langs dependency
        // db.GoCompleteTrace = golang.CompleteTrace
        // db.GoTypeTrace = golang.TraceTypes
}

func (db *DebugSettingsData) Apply() {
        // golang.CompleteTrace = db.GoCompleteTrace
        // golang.TraceTypes = db.GoTypeTrace
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/tree"
)

// settingsEditorToolbarBase is the base toolbar configuration
// function used in [SettingsEditor].
func settingsEditorToolbarBase(p *tree.Plan) {
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(AppearanceSettings.SaveScreenZoom).SetIcon(icons.ZoomIn)
                w.SetAfterFunc(func() {
                        AppearanceSettings.Apply()
                        UpdateAll()
                })
        })
}

// SettingsWindow opens a window for editing user settings.
func SettingsWindow() { //types:add
        if RecycleMainWindow(&AllSettings) {
                return
        }
        d := NewBody("Settings").SetData(&AllSettings)
        SettingsEditor(d)
        d.RunWindow()
}

// SettingsEditor adds to the given body an editor of user settings.
func SettingsEditor(b *Body) {
        b.AddTopBar(func(bar *Frame) {
                tb := NewToolbar(bar)
                tb.Maker(settingsEditorToolbarBase)
                for _, se := range AllSettings {
                        tb.Maker(se.MakeToolbar)
                }
                tb.AddOverflowMenu(func(m *Scene) {
                        NewFuncButton(m).SetFunc(resetAllSettings).SetConfirm(true).SetText("Reset settings").SetIcon(icons.Delete)
                        NewFuncButton(m).SetFunc(AppearanceSettings.deleteSavedWindowGeometries).SetConfirm(true).SetIcon(icons.Delete)
                        NewFuncButton(m).SetFunc(ProfileToggle).SetShortcut("Control+Alt+R").SetText("Profile performance").SetIcon(icons.Analytics)
                })
        })

        tabs := NewTabs(b)

        for _, se := range AllSettings {
                fr, _ := tabs.NewTab(se.Label())

                NewForm(fr).SetStruct(se).OnChange(func(e events.Event) {
                        UpdateSettings(fr, se)
                })
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import "cogentcore.org/core/math32"

// SizeClasses are the different size classes that a window can have.
type SizeClasses int32 //enums:enum -trim-prefix Size

const (
        // SizeCompact is the size class for windows with a width less than
        // 600dp, which typically happens on phones.
        SizeCompact SizeClasses = iota

        // SizeMedium is the size class for windows with a width between 600dp
        // and 840dp inclusive, which typically happens on tablets.
        SizeMedium

        // SizeExpanded is the size class for windows with a width greater than
        // 840dp, which typically happens on desktop and laptop computers.
        SizeExpanded
)

// SceneSize returns the effective size of the scene in which the widget is contained
// in terms of dp (density-independent pixels).
func (wb *WidgetBase) SceneSize() math32.Vector2 {
        dots := math32.FromPoint(wb.Scene.SceneGeom.Size)
        if wb.Scene.hasFlag(sceneContentSizing) {
                if currentRenderWindow != nil {
                        rg := currentRenderWindow.SystemWindow.RenderGeom()
                        dots = math32.FromPoint(rg.Size)
                }
        }
        dpd := wb.Scene.Styles.UnitContext.Dp(1) // dots per dp
        dp := dots.DivScalar(dpd)                // dots / (dots / dp) = dots * (dp / dots) = dp
        return dp
}

// SizeClass returns the size class of the scene in which the widget is contained
// based on [WidgetBase.SceneSize].
func (wb *WidgetBase) SizeClass() SizeClasses {
        dp := wb.SceneSize().X
        switch {
        case dp < 600:
                return SizeCompact
        case dp > 840:
                return SizeExpanded
        default:
                return SizeMedium
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "log/slog"
        "reflect"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// Slider is a slideable widget that provides slider functionality with a draggable
// thumb and a clickable track. The [styles.Style.Direction] determines the direction
// in which the slider slides.
type Slider struct {
        Frame

        // Type is the type of the slider, which determines its visual
        // and functional properties. The default type, [SliderSlider],
        // should work for most end-user use cases.
        Type SliderTypes

        // Value is the current value, represented by the position of the thumb.
        // It defaults to 0.5.
        Value float32 `set:"-"`

        // Min is the minimum possible value.
        // It defaults to 0.
        Min float32

        // Max is the maximum value supported.
        // It defaults to 1.
        Max float32

        // Step is the amount that the arrow keys increment/decrement the value by.
        // It defaults to 0.1.
        Step float32

        // EnforceStep is whether to ensure that the value is always
        // a multiple of [Slider.Step].
        EnforceStep bool

        // PageStep is the amount that the PageUp and PageDown keys
        // increment/decrement the value by.
        // It defaults to 0.2, and will be at least as big as [Slider.Step].
        PageStep float32

        // Icon is an optional icon to use for the dragging thumb.
        Icon icons.Icon

        // For Scrollbar type only: proportion (1 max) of the full range of scrolled data
        // that is currently visible.  This determines the thumb size and range of motion:
        // if 1, full slider is the thumb and no motion is possible.
        visiblePercent float32 `set:"-"`

        // ThumbSize is the size of the thumb as a proportion of the slider thickness,
        // which is the content size (inside the padding).
        ThumbSize math32.Vector2

        // TrackSize is the proportion of slider thickness for the visible track
        // for the [SliderSlider] type. It is often thinner than the thumb, achieved
        // by values less than 1 (0.5 default).
        TrackSize float32 `default:"0.5"`

        // InputThreshold is the threshold for the amount of change in scroll
        // value before emitting an input event.
        InputThreshold float32

        // Precision specifies the precision of decimal places (total, not after the decimal
        // point) to use in representing the number. This helps to truncate small weird
        // floating point values.
        Precision int

        // ValueColor is the background color that is used for styling the selected value
        // section of the slider. It should be set in a Styler, just like the main style
        // object is. If it is set to transparent, no value is rendered, so the value
        // section of the slider just looks like the rest of the slider.
        ValueColor image.Image

        // ThumbColor is the background color that is used for styling the thumb (handle)
        // of the slider. It should be set in a Styler, just like the main style object is.
        // If it is set to transparent, no thumb is rendered, so the thumb section of the
        // slider just looks like the rest of the slider.
        ThumbColor image.Image

        // StayInView is whether to keep the slider (typically a [SliderScrollbar]) within
        // the parent [Scene] bounding box, if the parent is in view. This is the default
        // behavior for [Frame] scrollbars, and setting this flag replicates that behavior
        // in other scrollbars.
        StayInView bool

        // Computed values below:

        // logical position of the slider relative to Size
        pos float32

        // previous Change event emitted value; don't re-emit Change if it is the same
        lastValue float32

        // previous sliding value (for computing the Input change)
        prevSlide float32

        // underlying drag position of slider; not subject to snapping
        slideStartPos float32
}

// SliderTypes are the different types of sliders.
type SliderTypes int32 //enums:enum -trim-prefix Slider

const (
        // SliderSlider indicates a standard, user-controllable slider
        // for setting a numeric value.
        SliderSlider SliderTypes = iota

        // SliderScrollbar indicates a slider acting as a scrollbar for content.
        // It has a [Slider.visiblePercent] factor that specifies the percent of the content
        // currently visible, which determines the size of the thumb, and thus the range
        // of motion remaining for the thumb Value ([Slider.visiblePercent] = 1 means thumb
        // is full size, and no remaining range of motion). The content size (inside the
        // margin and padding) determines the outer bounds of the rendered area.
        SliderScrollbar
)

func (sr *Slider) WidgetValue() any { return &sr.Value }

func (sr *Slider) OnBind(value any, tags reflect.StructTag) {
        kind := reflectx.NonPointerType(reflect.TypeOf(value)).Kind()
        if kind >= reflect.Int && kind <= reflect.Uintptr {
                sr.SetStep(1).SetEnforceStep(true).SetMax(100)
        }
        setFromTag(tags, "min", func(v float32) { sr.SetMin(v) })
        setFromTag(tags, "max", func(v float32) { sr.SetMax(v) })
        setFromTag(tags, "step", func(v float32) { sr.SetStep(v) })
}

func (sr *Slider) Init() {
        sr.Frame.Init()
        sr.Value = 0.5
        sr.Max = 1
        sr.visiblePercent = 1
        sr.Step = 0.1
        sr.PageStep = 0.2
        sr.Precision = 9
        sr.ThumbSize.Set(1, 1)
        sr.TrackSize = 0.5
        sr.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Activatable, abilities.Focusable, abilities.Hoverable, abilities.Slideable)

                // we use a different color for the thumb and value color
                // (compared to the background color) so that they get the
                // correct state layer
                s.Color = colors.Scheme.Primary.On

                if sr.Type == SliderSlider {
                        sr.ValueColor = colors.Scheme.Primary.Base
                        sr.ThumbColor = colors.Scheme.Primary.Base
                        s.Padding.Set(units.Dp(8))
                        s.Background = colors.Scheme.SurfaceVariant
                } else {
                        sr.ValueColor = colors.Scheme.OutlineVariant
                        sr.ThumbColor = colors.Scheme.OutlineVariant
                        s.Background = colors.Scheme.SurfaceContainerLow
                }

                // sr.ValueColor = s.StateBackgroundColor(sr.ValueColor)
                // sr.ThumbColor = s.StateBackgroundColor(sr.ThumbColor)
                s.Color = colors.Scheme.OnSurface

                s.Border.Radius = styles.BorderRadiusFull
                if !sr.IsReadOnly() {
                        s.Cursor = cursors.Grab
                        switch {
                        case s.Is(states.Sliding):
                                s.Cursor = cursors.Grabbing
                        case s.Is(states.Active):
                                s.Cursor = cursors.Grabbing
                        }
                }
        })
        sr.FinalStyler(func(s *styles.Style) {
                if s.Direction == styles.Row {
                        s.Min.X.Em(20)
                        s.Min.Y.Em(1)
                } else {
                        s.Min.Y.Em(20)
                        s.Min.X.Em(1)
                }
                if sr.Type == SliderScrollbar {
                        if s.Direction == styles.Row {
                                s.Min.Y = s.ScrollbarWidth
                        } else {
                                s.Min.X = s.ScrollbarWidth
                        }
                }
        })
        sr.On(events.SlideStart, func(e events.Event) {
                pos := sr.pointToRelPos(e.Pos())
                sr.setSliderPosEvent(pos)
                sr.slideStartPos = sr.pos
        })
        sr.On(events.SlideMove, func(e events.Event) {
                del := e.StartDelta()
                if sr.Styles.Direction == styles.Row {
                        sr.setSliderPosEvent(sr.slideStartPos + float32(del.X))
                } else {
                        sr.setSliderPosEvent(sr.slideStartPos + float32(del.Y))
                }
        })
        sr.On(events.SlideStop, func(e events.Event) {
                del := e.StartDelta()
                if sr.Styles.Direction == styles.Row {
                        sr.setSliderPosEvent(sr.slideStartPos + float32(del.X))
                } else {
                        sr.setSliderPosEvent(sr.slideStartPos + float32(del.Y))
                }
                sr.sendChange()
        })
        sr.On(events.Click, func(e events.Event) {
                pos := sr.pointToRelPos(e.Pos())
                sr.setSliderPosEvent(pos)
                sr.sendChange()
        })
        sr.On(events.Scroll, func(e events.Event) {
                se := e.(*events.MouseScroll)
                se.SetHandled()
                var del float32
                // if we are scrolling in the y direction on an x slider,
                // we still count it
                if sr.Styles.Direction == styles.Row && se.Delta.X != 0 {
                        del = se.Delta.X
                } else {
                        del = se.Delta.Y
                }
                if sr.Type == SliderScrollbar {
                        del = -del // invert for "natural" scroll
                }
                edel := sr.scrollScale(del)
                sr.setValueEvent(sr.Value + edel)
                sr.sendChange()
        })
        sr.OnKeyChord(func(e events.Event) {
                kf := keymap.Of(e.KeyChord())
                if DebugSettings.KeyEventTrace {
                        slog.Info("SliderBase KeyInput", "widget", sr, "keyFunction", kf)
                }
                switch kf {
                case keymap.MoveUp:
                        sr.setValueEvent(sr.Value - sr.Step)
                        e.SetHandled()
                case keymap.MoveLeft:
                        sr.setValueEvent(sr.Value - sr.Step)
                        e.SetHandled()
                case keymap.MoveDown:
                        sr.setValueEvent(sr.Value + sr.Step)
                        e.SetHandled()
                case keymap.MoveRight:
                        sr.setValueEvent(sr.Value + sr.Step)
                        e.SetHandled()
                case keymap.PageUp:
                        if sr.PageStep < sr.Step {
                                sr.PageStep = 2 * sr.Step
                        }
                        sr.setValueEvent(sr.Value - sr.PageStep)
                        e.SetHandled()
                case keymap.PageDown:
                        if sr.PageStep < sr.Step {
                                sr.PageStep = 2 * sr.Step
                        }
                        sr.setValueEvent(sr.Value + sr.PageStep)
                        e.SetHandled()
                case keymap.Home:
                        sr.setValueEvent(sr.Min)
                        e.SetHandled()
                case keymap.End:
                        sr.setValueEvent(sr.Max)
                        e.SetHandled()
                }
        })

        sr.Maker(func(p *tree.Plan) {
                if !sr.Icon.IsSet() {
                        return
                }
                tree.AddAt(p, "icon", func(w *Icon) {
                        w.Styler(func(s *styles.Style) {
                                s.Font.Size.Dp(24)
                                s.Color = sr.ThumbColor
                        })
                        w.Updater(func() {
                                w.SetIcon(sr.Icon)
                        })
                })
        })
}

// snapValue snaps the value to [Slider.Step] if [Slider.EnforceStep] is on.
func (sr *Slider) snapValue() {
        if !sr.EnforceStep {
                return
        }
        // round to the nearest step
        sr.Value = sr.Step * math32.Round(sr.Value/sr.Step)
}

// sendChange calls [WidgetBase.SendChange] if the current value
// is different from the last value.
func (sr *Slider) sendChange(e ...events.Event) bool {
        if sr.Value == sr.lastValue {
                return false
        }
        sr.lastValue = sr.Value
        sr.SendChange(e...)
        return true
}

// sliderSize returns the size available for sliding, based on allocation
func (sr *Slider) sliderSize() float32 {
        sz := sr.Geom.Size.Actual.Content.Dim(sr.Styles.Direction.Dim())
        if sr.Type != SliderScrollbar {
                thsz := sr.thumbSizeDots()
                sz -= thsz.Dim(sr.Styles.Direction.Dim()) // half on each size
        }
        return sz
}

// sliderThickness returns the thickness of the slider: Content size in other dim.
func (sr *Slider) sliderThickness() float32 {
        return sr.Geom.Size.Actual.Content.Dim(sr.Styles.Direction.Dim().Other())
}

// thumbSizeDots returns the thumb size in dots, based on ThumbSize
// and the content thickness
func (sr *Slider) thumbSizeDots() math32.Vector2 {
        return sr.ThumbSize.MulScalar(sr.sliderThickness())
}

// slideThumbSize returns thumb size, based on type
func (sr *Slider) slideThumbSize() float32 {
        if sr.Type == SliderScrollbar {
                minsz := sr.sliderThickness()
                return max(math32.Clamp(sr.visiblePercent, 0, 1)*sr.sliderSize(), minsz)
        }
        return sr.thumbSizeDots().Dim(sr.Styles.Direction.Dim())
}

// effectiveMax returns the effective maximum value represented.
// For the Slider type, it it is just Max.
// for the Scrollbar type, it is Max - Value of thumb size
func (sr *Slider) effectiveMax() float32 {
        if sr.Type == SliderScrollbar {
                return sr.Max - math32.Clamp(sr.visiblePercent, 0, 1)*(sr.Max-sr.Min)
        }
        return sr.Max
}

// scrollThumbValue returns the current scroll VisiblePct
// in terms of the Min - Max range of values.
func (sr *Slider) scrollThumbValue() float32 {
        return math32.Clamp(sr.visiblePercent, 0, 1) * (sr.Max - sr.Min)
}

// setSliderPos sets the position of the slider at the given
// relative position within the usable Content sliding range,
// in pixels, and updates the corresponding Value based on that position.
func (sr *Slider) setSliderPos(pos float32) {
        sz := sr.Geom.Size.Actual.Content.Dim(sr.Styles.Direction.Dim())
        if sz <= 0 {
                return
        }

        thsz := sr.slideThumbSize()
        thszh := .5 * thsz
        sr.pos = math32.Clamp(pos, thszh, sz-thszh)
        prel := (sr.pos - thszh) / (sz - thsz)
        effmax := sr.effectiveMax()
        val := math32.Truncate(sr.Min+prel*(effmax-sr.Min), sr.Precision)
        val = math32.Clamp(val, sr.Min, effmax)
        // fmt.Println(pos, thsz, prel, val)
        sr.Value = val
        sr.snapValue()
        sr.setPosFromValue(sr.Value) // go back the other way to be fully consistent
        sr.NeedsRender()
}

// setSliderPosEvent sets the position of the slider at the given position in pixels,
// and updates the corresponding Value based on that position.
// This version sends input events.
func (sr *Slider) setSliderPosEvent(pos float32) {
        sr.setSliderPos(pos)
        if math32.Abs(sr.prevSlide-sr.Value) > sr.InputThreshold {
                sr.prevSlide = sr.Value
                sr.Send(events.Input)
        }
}

// setPosFromValue sets the slider position based on the given value
// (typically rs.Value)
func (sr *Slider) setPosFromValue(val float32) {
        sz := sr.Geom.Size.Actual.Content.Dim(sr.Styles.Direction.Dim())
        if sz <= 0 {
                return
        }

        effmax := sr.effectiveMax()
        val = math32.Clamp(val, sr.Min, effmax)
        prel := (val - sr.Min) / (effmax - sr.Min) // relative position 0-1
        thsz := sr.slideThumbSize()
        thszh := .5 * thsz
        sr.pos = 0.5*thsz + prel*(sz-thsz)
        sr.pos = math32.Clamp(sr.pos, thszh, sz-thszh)
        sr.NeedsRender()
}

// setVisiblePercent sets the [Slider.visiblePercent] value for a [SliderScrollbar].
func (sr *Slider) setVisiblePercent(val float32) *Slider {
        sr.visiblePercent = math32.Clamp(val, 0, 1)
        return sr
}

// SetValue sets the value and updates the slider position,
// but does not send an [events.Change] event.
func (sr *Slider) SetValue(value float32) *Slider {
        effmax := sr.effectiveMax()
        value = math32.Clamp(value, sr.Min, effmax)
        if sr.Value != value {
                sr.Value = value
                sr.snapValue()
                sr.setPosFromValue(value)
        }
        sr.NeedsRender()
        return sr
}

// setValueEvent sets the value and updates the slider representation, and
// emits an input and change event.  Returns true if value actually changed.
func (sr *Slider) setValueEvent(val float32) bool {
        if sr.Value == val {
                return false
        }
        curVal := sr.Value
        sr.SetValue(val)
        sr.Send(events.Input)
        sr.SendChange()
        return curVal != sr.Value
}

func (sr *Slider) WidgetTooltip(pos image.Point) (string, image.Point) {
        res := sr.Tooltip
        if sr.Type == SliderScrollbar {
                return res, sr.DefaultTooltipPos()
        }
        if res != "" {
                res += " "
        }
        res += fmt.Sprintf("(value: %.4g, minimum: %.4g, maximum: %.4g)", sr.Value, sr.Min, sr.Max)
        return res, sr.DefaultTooltipPos()
}

// pointToRelPos translates a point in scene local pixel coords into relative
// position within the slider content range
func (sr *Slider) pointToRelPos(pt image.Point) float32 {
        ptf := math32.FromPoint(pt).Dim(sr.Styles.Direction.Dim())
        return ptf - sr.Geom.Pos.Content.Dim(sr.Styles.Direction.Dim())
}

// scrollScale returns scaled value of scroll delta
// as a function of the step size.
func (sr *Slider) scrollScale(del float32) float32 {
        return del * sr.Step
}

func (sr *Slider) Render() {
        sr.setPosFromValue(sr.Value)

        pc := &sr.Scene.Painter
        st := &sr.Styles

        dim := sr.Styles.Direction.Dim()
        od := dim.Other()
        sz := sr.Geom.Size.Actual.Content
        pos := sr.Geom.Pos.Content

        pabg := sr.parentActualBackground()

        if sr.Type == SliderScrollbar {
                pc.StandardBox(st, pos, sz, pabg) // track
                if sr.ValueColor != nil {
                        thsz := sr.slideThumbSize()
                        osz := sr.thumbSizeDots().Dim(od)
                        tpos := pos
                        tpos = tpos.AddDim(dim, sr.pos)
                        tpos = tpos.SubDim(dim, thsz*.5)
                        tsz := sz
                        tsz.SetDim(dim, thsz)
                        origsz := sz.Dim(od)
                        tsz.SetDim(od, osz)
                        tpos = tpos.AddDim(od, 0.5*(osz-origsz))
                        vabg := sr.Styles.ComputeActualBackgroundFor(sr.ValueColor, pabg)
                        pc.Fill.Color = vabg
                        sr.RenderBoxGeom(tpos, tsz, styles.Border{Radius: st.Border.Radius}) // thumb
                }
        } else {
                prevbg := st.Background
                prevsl := st.StateLayer
                // use surrounding background with no state layer for surrounding box
                st.Background = pabg
                st.StateLayer = 0
                st.ComputeActualBackground(pabg)
                // surrounding box (needed to prevent it from rendering over itself)
                sr.RenderStandardBox()
                st.Background = prevbg
                st.StateLayer = prevsl
                st.ComputeActualBackground(pabg)

                trsz := sz.Dim(od) * sr.TrackSize
                bsz := sz
                bsz.SetDim(od, trsz)
                bpos := pos
                bpos = bpos.AddDim(od, .5*(sz.Dim(od)-trsz))
                pc.Fill.Color = st.ActualBackground
                sr.RenderBoxGeom(bpos, bsz, styles.Border{Radius: st.Border.Radius}) // track

                if sr.ValueColor != nil {
                        bsz.SetDim(dim, sr.pos)
                        vabg := sr.Styles.ComputeActualBackgroundFor(sr.ValueColor, pabg)
                        pc.Fill.Color = vabg
                        sr.RenderBoxGeom(bpos, bsz, styles.Border{Radius: st.Border.Radius})
                }

                thsz := sr.thumbSizeDots()
                tpos := pos
                tpos.SetDim(dim, pos.Dim(dim)+sr.pos)
                tpos = tpos.AddDim(od, 0.5*sz.Dim(od)) // ctr

                // render thumb as icon or box
                if sr.Icon.IsSet() && sr.HasChildren() {
                        ic := sr.Child(0).(*Icon)
                        tpos.SetSub(thsz.MulScalar(.5))
                        ic.Geom.Pos.Total = tpos
                        ic.setContentPosFromPos()
                        ic.setBBoxes()
                } else {
                        tabg := sr.Styles.ComputeActualBackgroundFor(sr.ThumbColor, pabg)
                        pc.Fill.Color = tabg
                        tpos.SetSub(thsz.MulScalar(0.5))
                        sr.RenderBoxGeom(tpos, thsz, styles.Border{Radius: st.Border.Radius})
                }
        }
}

func (sr *Slider) ApplyScenePos() {
        sr.WidgetBase.ApplyScenePos()
        if !sr.StayInView {
                return
        }
        pwb := sr.parentWidget()
        if !pwb.IsVisible() {
                return
        }
        sbw := math32.Ceil(sr.Styles.ScrollbarWidth.Dots)
        scmax := math32.FromPoint(sr.Scene.Geom.ContentBBox.Max).SubScalar(sbw)
        sr.Geom.Pos.Total.SetMin(scmax)
        sr.setContentPosFromPos()
        sr.setBBoxesFromAllocs()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "log/slog"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
)

// RunSnackbar returns and runs a new [SnackbarStage] in the context
// of the given widget. See [Body.NewSnackbar] to make a snackbar without running it.
func (bd *Body) RunSnackbar(ctx Widget) *Stage {
        return bd.NewSnackbar(ctx).Run()
}

// NewSnackbar returns a new [SnackbarStage] in the context
// of the given widget. You must call [Stage.Run] to run the
// snackbar; see [Body.RunSnackbar] for a version that
// automatically runs it.
func (bd *Body) NewSnackbar(ctx Widget) *Stage {
        ctx = nonNilContext(ctx)
        bd.snackbarStyles()
        bd.Scene.Stage = NewPopupStage(SnackbarStage, bd.Scene, ctx).
                SetTimeout(SystemSettings.SnackbarTimeout)
        return bd.Scene.Stage
}

// MessageSnackbar opens a [SnackbarStage] displaying the given message
// in the context of the given widget.
func MessageSnackbar(ctx Widget, message string) {
        NewBody().AddSnackbarText(message).RunSnackbar(ctx)
}

// ErrorSnackbar opens a [SnackbarStage] displaying the given error
// in the context of the given widget. Optional label text can be
// provided; if it is not, the label text will default to "Error".
// If the given error is nil, no snackbar is created.
func ErrorSnackbar(ctx Widget, err error, label ...string) {
        if err == nil {
                return
        }
        lbl := "Error"
        if len(label) > 0 {
                lbl = label[0]
        }
        text := lbl + ": " + err.Error()
        // we need to get [errors.CallerInfo] at this level
        slog.Error(text + " | " + errors.CallerInfo())
        MessageSnackbar(ctx, text)
}

// snackbarStyles sets default stylers for snackbar bodies.
// It is automatically called in [Body.NewSnackbar].
func (bd *Body) snackbarStyles() {
        bd.Styler(func(s *styles.Style) {
                s.Direction = styles.Row
                s.Overflow.Set(styles.OverflowVisible) // key for avoiding sizing errors when re-rendering with small pref size
                s.Border.Radius = styles.BorderRadiusExtraSmall
                s.Padding.SetHorizontal(units.Dp(16))
                s.Background = colors.Scheme.InverseSurface
                s.Color = colors.Scheme.InverseOnSurface
                // we go on top of things so we want no margin background
                s.FillMargin = false
                s.Align.Content = styles.Center
                s.Align.Items = styles.Center
                s.Gap.X.Dp(12)
                s.Grow.Set(1, 0)
                s.Min.Y.Dp(48)
                s.Min.X.SetCustom(func(uc *units.Context) float32 {
                        return min(uc.Em(20), uc.Vw(70))
                })
        })
        bd.Scene.Styler(func(s *styles.Style) {
                s.Background = nil
                s.Border.Radius = styles.BorderRadiusExtraSmall
                s.BoxShadow = styles.BoxShadow3()
        })
}

// AddSnackbarText adds a snackbar [Text] with the given text.
func (bd *Body) AddSnackbarText(text string) *Body {
        tx := NewText(bd).SetText(text).SetType(TextBodyMedium)
        tx.Styler(func(s *styles.Style) {
                s.SetTextWrap(false)
                if s.Is(states.Selected) {
                        s.Color = colors.Scheme.Select.OnContainer
                }
        })
        return bd
}

// AddSnackbarButton adds a snackbar button with the given text and optional OnClick
// event handler. Only the first of the given event handlers is used, and the
// snackbar is automatically closed when the button is clicked regardless of
// whether there is an event handler passed.
func (bd *Body) AddSnackbarButton(text string, onClick ...func(e events.Event)) *Body {
        NewStretch(bd)
        bt := NewButton(bd).SetType(ButtonText).SetText(text)
        bt.Styler(func(s *styles.Style) {
                s.Color = colors.Scheme.InversePrimary
        })
        bt.OnClick(func(e events.Event) {
                if len(onClick) > 0 {
                        onClick[0](e)
                }
                bd.Scene.Stage.ClosePopup()
        })
        return bd
}

// AddSnackbarIcon adds a snackbar icon button with the given icon and optional
// OnClick event handler. Only the first of the given event handlers is used, and the
// snackbar is automatically closed when the button is clicked regardless of whether
// there is an event handler passed.
func (bd *Body) AddSnackbarIcon(icon icons.Icon, onClick ...func(e events.Event)) *Body {
        ic := NewButton(bd).SetType(ButtonAction).SetIcon(icon)
        ic.Styler(func(s *styles.Style) {
                s.Color = colors.Scheme.InverseOnSurface
        })
        ic.OnClick(func(e events.Event) {
                if len(onClick) > 0 {
                        onClick[0](e)
                }
                bd.Scene.Stage.ClosePopup()
        })
        return bd
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "log/slog"
        "reflect"
        "strconv"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/tree"
)

// Spinner is a [TextField] for editing numerical values. It comes with
// fields, methods, buttons, and shortcuts to enhance numerical value editing.
type Spinner struct {
        TextField

        // Value is the current value.
        Value float32 `set:"-"`

        // HasMin is whether there is a minimum value to enforce.
        // It should be set using [Spinner.SetMin].
        HasMin bool `set:"-"`

        // Min, if [Spinner.HasMin] is true, is the the minimum value in range.
        // It should be set using [Spinner.SetMin].
        Min float32 `set:"-"`

        // HaxMax is whether there is a maximum value to enforce.
        // It should be set using [Spinner.SetMax].
        HasMax bool `set:"-"`

        // Max, if [Spinner.HasMax] is true, is the maximum value in range.
        // It should be set using [Spinner.SetMax].
        Max float32 `set:"-"`

        // Step is the amount that the up and down buttons and arrow keys
        // increment/decrement the value by. It defaults to 0.1.
        Step float32

        // EnforceStep is whether to ensure that the value of the spinner
        // is always a multiple of [Spinner.Step].
        EnforceStep bool

        // PageStep is the amount that the PageUp and PageDown keys
        // increment/decrement the value by.
        // It defaults to 0.2, and will be at least as big as [Spinner.Step].
        PageStep float32

        // Precision specifies the precision of decimal places
        // (total, not after the decimal point) to use in
        // representing the number. This helps to truncate
        // small weird floating point values.
        Precision int

        // Format is the format string to use for printing the value.
        // If it unset, %g is used. If it is decimal based
        // (ends in d, b, c, o, O, q, x, X, or U) then the value is
        // converted to decimal prior to printing.
        Format string
}

func (sp *Spinner) WidgetValue() any { return &sp.Value }

func (sp *Spinner) SetWidgetValue(value any) error {
        f, err := reflectx.ToFloat32(value)
        if err != nil {
                return err
        }
        sp.SetValue(f)
        return nil
}

func (sp *Spinner) OnBind(value any, tags reflect.StructTag) {
        kind := reflectx.NonPointerType(reflect.TypeOf(value)).Kind()
        if kind >= reflect.Int && kind <= reflect.Uintptr {
                sp.SetStep(1).SetEnforceStep(true)
                if kind >= reflect.Uint {
                        sp.SetMin(0)
                }
        }
        if f, ok := tags.Lookup("format"); ok {
                sp.SetFormat(f)
        }
        setFromTag(tags, "min", func(v float32) { sp.SetMin(v) })
        setFromTag(tags, "max", func(v float32) { sp.SetMax(v) })
        setFromTag(tags, "step", func(v float32) { sp.SetStep(v) })
}

func (sp *Spinner) Init() {
        sp.TextField.Init()
        sp.SetStep(0.1).SetPageStep(0.2).SetPrecision(6).SetFormat("%g")
        sp.SetLeadingIcon(icons.Remove, func(e events.Event) {
                sp.incrementValue(-1)
        }).SetTrailingIcon(icons.Add, func(e events.Event) {
                sp.incrementValue(1)
        })
        sp.Updater(sp.setTextToValue)
        sp.Styler(func(s *styles.Style) {
                s.SetTextWrap(false)
                s.VirtualKeyboard = styles.KeyboardNumber
                if sp.IsReadOnly() {
                        s.Min.X.Ch(6)
                        s.Max.X.Ch(14)
                } else {
                        s.Min.X.Ch(14)
                        s.Max.X.Ch(22)
                }
                // s.Text.Align = styles.End // this doesn't work
        })

        sp.On(events.Scroll, func(e events.Event) {
                if sp.IsReadOnly() || !sp.StateIs(states.Focused) {
                        return
                }
                se := e.(*events.MouseScroll)
                se.SetHandled()
                sp.incrementValue(float32(se.Delta.Y))
        })
        sp.SetValidator(func() error {
                text := sp.Text()
                val, err := sp.stringToValue(text)
                if err != nil {
                        return err
                }
                sp.SetValue(val)
                return nil
        })
        sp.OnKeyChord(func(e events.Event) {
                if sp.IsReadOnly() {
                        return
                }
                kf := keymap.Of(e.KeyChord())
                if DebugSettings.KeyEventTrace {
                        slog.Info("Spinner KeyChordEvent", "widget", sp, "keyFunction", kf)
                }
                switch {
                case kf == keymap.MoveUp:
                        e.SetHandled()
                        sp.incrementValue(1)
                case kf == keymap.MoveDown:
                        e.SetHandled()
                        sp.incrementValue(-1)
                case kf == keymap.PageUp:
                        e.SetHandled()
                        sp.pageIncrementValue(1)
                case kf == keymap.PageDown:
                        e.SetHandled()
                        sp.pageIncrementValue(-1)
                }
        })

        i := func(w *Button) {
                w.Styler(func(s *styles.Style) {
                        // icons do not get separate focus, as people can
                        // use the arrow keys to get the same effect
                        s.SetAbilities(false, abilities.Focusable)
                        s.SetAbilities(true, abilities.RepeatClickable)
                })
        }
        sp.Maker(func(p *tree.Plan) {
                if sp.IsReadOnly() {
                        return
                }
                tree.AddInit(p, "lead-icon", i)
                tree.AddInit(p, "trail-icon", i)
        })
}

func (sp *Spinner) setTextToValue() {
        sp.SetText(sp.valueToString(sp.Value))
}

// SetMin sets the minimum bound on the value.
func (sp *Spinner) SetMin(min float32) *Spinner {
        sp.HasMin = true
        sp.Min = min
        return sp
}

// SetMax sets the maximum bound on the value.
func (sp *Spinner) SetMax(max float32) *Spinner {
        sp.HasMax = true
        sp.Max = max
        return sp
}

// SetValue sets the value, enforcing any limits, and updates the display.
func (sp *Spinner) SetValue(val float32) *Spinner {
        sp.Value = val
        if sp.HasMax && sp.Value > sp.Max {
                sp.Value = sp.Max
        } else if sp.HasMin && sp.Value < sp.Min {
                sp.Value = sp.Min
        }
        sp.Value = math32.Truncate(sp.Value, sp.Precision)
        if sp.EnforceStep {
                // round to the nearest step
                sp.Value = sp.Step * math32.Round(sp.Value/sp.Step)
        }
        sp.setTextToValue()
        sp.NeedsRender()
        return sp
}

// setValueEvent calls SetValue and also sends a change event.
func (sp *Spinner) setValueEvent(val float32) *Spinner {
        sp.SetValue(val)
        sp.SendChange()
        return sp
}

// incrementValue increments the value by given number of steps (+ or -),
// and enforces it to be an even multiple of the step size (snap-to-value),
// and sends a change event.
func (sp *Spinner) incrementValue(steps float32) *Spinner {
        if sp.IsReadOnly() {
                return sp
        }
        val := sp.Value + steps*sp.Step
        val = sp.wrapAround(val)
        return sp.setValueEvent(val)
}

// pageIncrementValue increments the value by given number of page steps (+ or -),
// and enforces it to be an even multiple of the step size (snap-to-value),
// and sends a change event.
func (sp *Spinner) pageIncrementValue(steps float32) *Spinner {
        if sp.IsReadOnly() {
                return sp
        }
        if sp.PageStep < sp.Step {
                sp.PageStep = 2 * sp.Step
        }
        val := sp.Value + steps*sp.PageStep
        val = sp.wrapAround(val)
        return sp.setValueEvent(val)
}

// wrapAround, if the spinner has a min and a max, converts values less
// than min to max and values greater than max to min.
func (sp *Spinner) wrapAround(val float32) float32 {
        if !sp.HasMin || !sp.HasMax {
                return val
        }
        if val < sp.Min {
                return sp.Max
        }
        if val > sp.Max {
                return sp.Min
        }
        return val
}

// formatIsInt returns true if the format string requires an integer value
func (sp *Spinner) formatIsInt() bool {
        if sp.Format == "" {
                return false
        }
        fc := sp.Format[len(sp.Format)-1]
        switch fc {
        case 'd', 'b', 'c', 'o', 'O', 'q', 'x', 'X', 'U':
                return true
        }
        return false
}

// valueToString converts the value to the string representation thereof
func (sp *Spinner) valueToString(val float32) string {
        if sp.formatIsInt() {
                return fmt.Sprintf(sp.Format, int64(val))
        }
        return fmt.Sprintf(sp.Format, val)
}

// stringToValue converts the string field back to float value
func (sp *Spinner) stringToValue(str string) (float32, error) {
        if sp.Format == "" {
                f64, err := strconv.ParseFloat(str, 32)
                return float32(f64), err
        }

        var err error
        if sp.formatIsInt() {
                var ival int
                _, err = fmt.Sscanf(str, sp.Format, &ival)
                if err == nil {
                        return float32(ival), nil
                }
        } else {
                var fval float32
                _, err = fmt.Sscanf(str, sp.Format, &fval)
                if err == nil {
                        return fval, nil
                }
        }
        // if we have an error using the formatted version,
        // we try using a pure parse
        f64, ferr := strconv.ParseFloat(str, 32)
        if ferr == nil {
                return float32(f64), nil
        }
        // if everything fails, we return the error for the
        // formatted version
        return 0, err
}

func (sp *Spinner) WidgetTooltip(pos image.Point) (string, image.Point) {
        res, rpos := sp.TextField.WidgetTooltip(pos)
        if sp.error != nil {
                return res, rpos
        }
        if sp.HasMin {
                if res != "" {
                        res += " "
                }
                res += "(minimum: " + sp.valueToString(sp.Min)
                if !sp.HasMax {
                        res += ")"
                }
        }
        if sp.HasMax {
                if sp.HasMin {
                        res += ", "
                } else if res != "" {
                        res += " ("
                } else {
                        res += "("
                }
                res += "maximum: " + sp.valueToString(sp.Max) + ")"
        }
        return res, rpos
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "log/slog"
        "strconv"
        "strings"

        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
)

// SplitsTiles specifies 2D tiles for organizing elements within the [Splits] Widget.
// The [styles.Style.Direction] defines the main axis, and the cross axis is orthogonal
// to that, which is organized into chunks of 2 cross-axis "rows".  In the case of a
// 1D pattern, only Span is relevant, indicating a single element per split.
type SplitsTiles int32 //enums:enum -trim-prefix Tile

const (
        // Span has a single element spanning the cross dimension, i.e.,
        // a vertical span for a horizontal main axis, or a horizontal
        // span for a vertical main axis.  It is the only valid value
        // for 1D Splits, where it specifies a single element per split.
        // If all tiles are Span, then a 1D line is generated.
        TileSpan SplitsTiles = iota

        // Split has a split between elements along the cross dimension,
        // with the first of 2 elements in the first main axis line and
        // the second in the second line.
        TileSplit

        // FirstLong has a long span of first element along the first
        // main axis line and a split between the next two elements
        // along the second line, with a split between the two lines.
        // Visually, the splits form a T shape for a horizontal main axis.
        TileFirstLong

        // SecondLong has the first two elements split along the first line,
        // and the third with a long span along the second main axis line,
        // with a split between the two lines.  Visually, the splits form
        // an inverted T shape for a horizontal main axis.
        TileSecondLong

        // Plus is arranged like a plus sign + with the main split along
        // the main axis line, and then individual cross-axis splits
        // between the first two and next two elements.
        TilePlus
)

var (
        // tileNumElements is the number of elements per tile.
        // the number of splitter handles is n-1.
        tileNumElements = map[SplitsTiles]int{TileSpan: 1, TileSplit: 2, TileFirstLong: 3, TileSecondLong: 3, TilePlus: 4}

        // tileNumSubSplits is the number of SubSplits proportions per tile.
        // The Long cases require 2 pairs, first for the split along the cross axis
        // and second for the split along the main axis; Plus requires 3 pairs.
        tileNumSubSplits = map[SplitsTiles]int{TileSpan: 1, TileSplit: 2, TileFirstLong: 4, TileSecondLong: 4, TilePlus: 6}
)

// Splits allocates a certain proportion of its space to each of its children,
// organized along [styles.Style.Direction] as the main axis, and supporting
// [SplitsTiles] of 2D splits configurations along the cross axis.
// There is always a split between each Tile segment along the main axis,
// with the proportion of the total main axis space per Tile allocated
// according to normalized Splits factors.
// If all Tiles are Span then a 1D line is generated.  Children are allocated
// in order along the main axis, according to each of the Tiles,
// which consume 1 to 4 elements, and have 0 to 3 splits internally.
// The internal split proportion are stored separately in SubSplits.
// A [Handle] widget is added to the Parts for each split, allowing the user
// to drag the relative size of each splits region.
// If more complex geometries are required, use nested Splits.
type Splits struct {
        Frame

        // Tiles specifies the 2D layout of elements along the [styles.Style.Direction]
        // main axis and the orthogonal cross axis.  If all Tiles are TileSpan, then
        // a 1D line is generated.  There is always a split between each Tile segment,
        // and different tiles consume different numbers of elements in order, and
        // have different numbers of SubSplits.  Because each Tile can represent a
        // different number of elements, care must be taken to ensure that the full
        // set of tiles corresponds to the actual number of children.  A default
        // 1D configuration will be imposed if there is a mismatch.
        Tiles []SplitsTiles

        // TileSplits is the proportion (0-1 normalized, enforced) of space
        // allocated to each Tile element along the main axis.
        // 0 indicates that an element should  be completely collapsed.
        // By default, each element gets the same amount of space.
        TileSplits []float32

        // SubSplits contains splits proportions for each Tile element, with
        // a variable number depending on the Tile.  For the First and Second Long
        // elements, there are 2 subsets of sub-splits, with 4 total subsplits.
        SubSplits [][]float32

        // savedSplits is a saved version of the Splits that can be restored
        // for dynamic collapse/expand operations.
        savedSplits []float32

        // savedSubSplits is a saved version of the SubSplits that can be restored
        // for dynamic collapse/expand operations.
        savedSubSplits [][]float32

        // handleDirs contains the target directions for each of the handles.
        // this is set by parent split in its style function, and consumed
        // by each handle in its own style function.
        handleDirs []styles.Directions
}

func (sl *Splits) Init() {
        sl.Frame.Init()
        sl.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 1)
                s.Margin.Zero()
                s.Padding.Zero()
                s.Min.Y.Em(10)

                if sl.SizeClass() == SizeCompact {
                        s.Direction = styles.Column
                } else {
                        s.Direction = styles.Row
                }
        })
        sl.FinalStyler(func(s *styles.Style) {
                sl.styleSplits()
        })
        sl.SetOnChildAdded(func(n tree.Node) {
                if n != sl.Parts {
                        AsWidget(n).Styler(func(s *styles.Style) {
                                // splits elements must scroll independently and grow
                                s.Overflow.Set(styles.OverflowAuto)
                                s.Grow.Set(1, 1)
                                s.Direction = styles.Column
                        })
                }
        })

        sl.OnKeyChord(func(e events.Event) {
                kc := string(e.KeyChord())
                mod := "Control+"
                if TheApp.Platform() == system.MacOS {
                        mod = "Meta+"
                }
                if !strings.HasPrefix(kc, mod) {
                        return
                }
                kns := kc[len(mod):]

                knc, err := strconv.Atoi(kns)
                if err != nil {
                        return
                }
                kn := int(knc)
                if kn == 0 {
                        e.SetHandled()
                        sl.evenSplits(sl.TileSplits)
                        sl.NeedsLayout()

                } else if kn <= len(sl.Children) {
                        e.SetHandled()
                        if sl.TileSplits[kn-1] <= 0.01 {
                                sl.restoreChild(kn - 1)
                        } else {
                                sl.collapseSplit(true, kn-1)
                        }
                }
        })

        sl.Updater(func() {
                sl.updateSplits()
        })
        parts := sl.newParts()
        parts.Maker(func(p *tree.Plan) {
                // handles are organized first between tiles, then within tiles.
                sl.styleSplits()
                addHand := func(hidx int) {
                        tree.AddAt(p, "handle-"+strconv.Itoa(hidx), func(w *Handle) {
                                w.OnChange(func(e events.Event) {
                                        sl.setHandlePos(w.IndexInParent(), w.Value())
                                })
                                w.Styler(func(s *styles.Style) {
                                        ix := w.IndexInParent()
                                        if len(sl.handleDirs) > ix {
                                                s.Direction = sl.handleDirs[ix]
                                        }
                                })
                        })
                }

                nt := len(sl.Tiles)
                for i := range nt - 1 {
                        addHand(i)
                }
                hi := nt - 1
                for _, t := range sl.Tiles {
                        switch t {
                        case TileSpan:
                        case TileSplit:
                                addHand(hi)
                                hi++
                        case TileFirstLong, TileSecondLong:
                                addHand(hi)     // long
                                addHand(hi + 1) // sub
                                hi += 2
                        case TilePlus:
                                addHand(hi)     // long
                                addHand(hi + 1) // sub1
                                addHand(hi + 2) // sub2
                                hi += 3
                        }
                }
        })
}

// SetSplits sets the split proportions for the children.
// In general you should pass the same number of args
// as there are children, though fewer could be passed.
func (sl *Splits) SetSplits(splits ...float32) *Splits {
        sl.updateSplits()
        _, hasNonSpans := sl.tilesTotal()
        if !hasNonSpans {
                nc := len(splits)
                sl.TileSplits = slicesx.SetLength(sl.TileSplits, nc)
                copy(sl.TileSplits, splits)
                sl.Tiles = slicesx.SetLength(sl.Tiles, nc)
                for i := range nc {
                        sl.Tiles[i] = TileSpan
                }
                sl.updateSplits()
                return sl
        }
        for i, sp := range splits {
                sl.SetSplit(i, sp)
        }
        return sl
}

// SetSplit sets the split proportion of relevant display width
// specific to given child index.  Also updates other split values
// in proportion.
func (sl *Splits) SetSplit(idx int, val float32) {
        ci := 0
        for i, t := range sl.Tiles {
                tn := tileNumElements[t]
                if idx < ci || idx >= ci+tn {
                        ci += tn
                        continue
                }
                ri := idx - ci
                switch t {
                case TileSpan:
                        sl.TileSplits[i] = val
                        sl.normOtherSplits(i, sl.TileSplits)
                case TileSplit:
                        sl.SubSplits[i][ri] = val
                        sl.normOtherSplits(ri, sl.SubSplits[i])
                case TileFirstLong:
                        if ri == 0 {
                                sl.SubSplits[i][0] = val
                                sl.normOtherSplits(0, sl.SubSplits[i][:2])
                        } else {
                                sl.SubSplits[i][1+ri] = val
                                sl.normOtherSplits(ri-1, sl.SubSplits[i][2:])
                        }
                case TileSecondLong:
                        if ri == 2 {
                                sl.SubSplits[i][1] = val
                                sl.normOtherSplits(1, sl.SubSplits[i][:2])
                        } else {
                                sl.SubSplits[i][2+ri] = val
                                sl.normOtherSplits(ri, sl.SubSplits[i][2:])
                        }
                case TilePlus:
                        si := 2 + ri
                        gi := (si / 2) * 2
                        oi := 1 - (si % 2)
                        sl.SubSplits[i][si] = val
                        sl.normOtherSplits(oi, sl.SubSplits[i][gi:gi+2])
                }
                ci += tn
        }
}

// Splits returns the split proportion for each child element.
func (sl *Splits) Splits() []float32 {
        nc := len(sl.Children)
        sv := make([]float32, nc)
        for i := range nc {
                sv[i] = sl.Split(i)
        }
        return sv
}

// Split returns the split proportion for given child index
func (sl *Splits) Split(idx int) float32 {
        ci := 0
        for i, t := range sl.Tiles {
                tn := tileNumElements[t]
                if idx < ci || idx >= ci+tn {
                        ci += tn
                        continue
                }
                ri := idx - ci
                switch t {
                case TileSpan:
                        return sl.TileSplits[i]
                case TileSplit:
                        return sl.SubSplits[i][ri]
                case TileFirstLong:
                        if ri == 0 {
                                return sl.SubSplits[i][0]
                        }
                        return sl.SubSplits[i][1+ri]
                case TileSecondLong:
                        if ri == 2 {
                                return sl.SubSplits[i][1]
                        }
                        return sl.SubSplits[i][2+ri]
                case TilePlus:
                        si := 2 + ri
                        return sl.SubSplits[i][si]
                }
                ci += tn
        }
        return 0
}

// ChildIsCollapsed returns true if the split proportion
// for given child index is 0.  Also checks the overall tile
// splits for the child.
func (sl *Splits) ChildIsCollapsed(idx int) bool {
        if sl.Split(idx) < 0.01 {
                return true
        }
        ci := 0
        for i, t := range sl.Tiles {
                tn := tileNumElements[t]
                if idx < ci || idx >= ci+tn {
                        ci += tn
                        continue
                }
                ri := idx - ci
                if sl.TileSplits[i] < 0.01 {
                        return true
                }
                // extra consideration for long split onto subs:
                switch t {
                case TileFirstLong:
                        if ri > 0 && sl.SubSplits[i][1] < 0.01 {
                                return true
                        }
                case TileSecondLong:
                        if ri < 2 && sl.SubSplits[i][0] < 0.01 {
                                return true
                        }
                case TilePlus:
                        if ri < 2 {
                                return sl.SubSplits[i][0] < 0.01
                        }
                        return sl.SubSplits[i][1] < 0.01
                }
                return false
        }
        return false
}

// tilesTotal returns the total number of child elements associated
// with the current set of Tiles elements, and whether there are any
// non-TileSpan elements, which has implications for error handling
// if the total does not match the actual number of children in the Splits.
func (sl *Splits) tilesTotal() (total int, hasNonSpans bool) {
        for _, t := range sl.Tiles {
                total += tileNumElements[t]
                if t != TileSpan {
                        hasNonSpans = true
                }
        }
        return
}

// updateSplits ensures the Tiles, TileSplits and SubSplits
// are all configured properly, given the number of children.
func (sl *Splits) updateSplits() *Splits {
        nc := len(sl.Children)
        ntc, hasNonSpans := sl.tilesTotal()
        if nc == 0 && ntc == 0 {
                return sl
        }
        if nc > 0 && ntc != nc {
                if ntc != 0 && hasNonSpans {
                        slog.Error("core.Splits: number of children for current Tiles != number of actual children, reverting to 1D", "children", nc, "tiles", ntc)
                }
                sl.Tiles = slicesx.SetLength(sl.Tiles, nc)
                for i := range nc {
                        sl.Tiles[i] = TileSpan
                }
        }
        nt := len(sl.Tiles)
        sl.TileSplits = slicesx.SetLength(sl.TileSplits, nt)
        sl.normSplits(sl.TileSplits)
        sl.SubSplits = slicesx.SetLength(sl.SubSplits, nt)
        for i, t := range sl.Tiles {
                ssn := tileNumSubSplits[t]
                ss := sl.SubSplits[i]
                ss = slicesx.SetLength(ss, ssn)
                switch t {
                case TileSpan:
                        ss[0] = 1
                case TileSplit:
                        sl.normSplits(ss)
                case TileFirstLong, TileSecondLong:
                        sl.normSplits(ss[:2]) // first is cross-axis
                        sl.normSplits(ss[2:])
                case TilePlus:
                        for j := range 3 {
                                sl.normSplits(ss[2*j : 2*j+2])
                        }
                }
                sl.SubSplits[i] = ss
        }
        return sl
}

// normSplits normalizes the given splits proportions,
// using evenSplits if all zero
func (sl *Splits) normSplits(s []float32) {
        sum := float32(0)
        for _, sp := range s {
                sum += sp
        }
        if sum == 0 { // set default even splits
                sl.evenSplits(s)
                return
        }
        norm := 1 / sum
        for i := range s {
                s[i] *= norm
        }
}

// normOtherSplits normalizes the given splits proportions,
// while keeping the one at the given index at its current value.
func (sl *Splits) normOtherSplits(idx int, s []float32) {
        n := len(s)
        if n == 1 {
                return
        }
        val := s[idx]
        sum := float32(0)
        even := (1 - val) / float32(n-1)
        for i, sp := range s {
                if i != idx {
                        if sp == 0 {
                                s[i], sp = even, even
                        }
                        sum += sp
                }
        }
        norm := (1 - val) / sum
        nsum := float32(0)
        for i := range s {
                if i != idx {
                        s[i] *= norm
                }
                nsum += s[i]
        }
}

// evenSplits splits space evenly across all elements
func (sl *Splits) evenSplits(s []float32) {
        n := len(s)
        if n == 0 {
                return
        }
        even := 1.0 / float32(n)
        for i := range s {
                s[i] = even
        }
}

// saveSplits saves the current set of splits in SavedSplits, for a later RestoreSplits
func (sl *Splits) saveSplits() {
        n := len(sl.TileSplits)
        if n == 0 {
                return
        }
        sl.savedSplits = slicesx.SetLength(sl.savedSplits, n)
        copy(sl.savedSplits, sl.TileSplits)
        sl.savedSubSplits = slicesx.SetLength(sl.savedSubSplits, n)
        for i, ss := range sl.SubSplits {
                sv := sl.savedSubSplits[i]
                sv = slicesx.SetLength(sv, len(ss))
                copy(sv, ss)
                sl.savedSubSplits[i] = sv
        }
}

// restoreSplits restores a previously saved set of splits (if it exists), does an update
func (sl *Splits) restoreSplits() {
        if len(sl.savedSplits) != len(sl.TileSplits) {
                return
        }
        sl.SetSplits(sl.savedSplits...)
        for i, ss := range sl.SubSplits {
                sv := sl.savedSubSplits[i]
                if len(sv) == len(ss) {
                        copy(ss, sv)
                }
        }
        sl.NeedsLayout()
}

// setSplitIndex sets given proportional "Splits" space to given value.
// Splits are indexed first by Tiles (major splits) and then
// within tiles, where TileSplit has 2 and the Long cases,
// have the long element first followed by the two smaller ones.
// Calls updateSplits after to ensure renormalization and
// NeedsLayout to ensure layout is updated.
func (sl *Splits) setSplitIndex(idx int, val float32) {
        nt := len(sl.Tiles)
        if nt == 0 {
                return
        }
        if idx < nt {
                sl.TileSplits[idx] = val
                return
        }
        ci := nt
        for i, t := range sl.Tiles {
                tn := tileNumElements[t]
                ri := idx - ci
                if ri < 0 {
                        break
                }
                switch t {
                case TileSpan:
                case TileSplit:
                        if ri < 2 {
                                sl.SubSplits[i][ri] = val
                        }
                case TileFirstLong, TileSecondLong:
                        if ri == 0 {
                                sl.SubSplits[i][ri] = val
                        } else {
                                sl.SubSplits[i][2+ri-1] = val
                        }
                case TilePlus:
                        sl.SubSplits[i][2+ri] = val
                }
                ci += tn
        }
        sl.updateSplits()
        sl.NeedsLayout()
}

// collapseSplit collapses the splitter region(s) at given index(es),
// by setting splits value to 0.
// optionally saving the prior splits for later Restore function.
func (sl *Splits) collapseSplit(save bool, idxs ...int) {
        if save {
                sl.saveSplits()
        }
        for _, idx := range idxs {
                sl.setSplitIndex(idx, 0)
        }
}

// setHandlePos sets given splits handle position to given 0-1 normalized value.
// Handles are indexed 0..Tiles-1 for main tiles handles, then sequentially
// for any additional child sub-splits depending on tile config.
// Calls updateSplits after to ensure renormalization and
// NeedsLayout to ensure layout is updated.
func (sl *Splits) setHandlePos(idx int, val float32) {
        val = math32.Clamp(val, 0, 1)

        update := func(idx int, nw float32, s []float32) {
                n := len(s)
                old := s[idx]
                sumTo := float32(0)
                for i := range idx + 1 {
                        sumTo += s[i]
                }
                delta := nw - sumTo
                uval := old + delta
                if uval < 0 {
                        uval = 0
                        delta = -old
                        nw = sumTo + delta
                }
                rmdr := 1 - nw
                oldrmdr := 1 - sumTo
                if oldrmdr <= 0 {
                        if rmdr > 0 {
                                dper := rmdr / float32((n-1)-idx)
                                for i := idx + 1; i < n; i++ {
                                        s[i] = dper
                                }
                        }
                } else {
                        for i := idx + 1; i < n; i++ {
                                cur := s[i]
                                s[i] = rmdr * (cur / oldrmdr) // proportional
                        }
                }
                s[idx] = uval
        }

        nt := len(sl.Tiles)
        if idx < nt-1 {
                update(idx, val, sl.TileSplits)
                sl.updateSplits()
                sl.NeedsLayout()
                return
        }
        ci := nt - 1
        for i, t := range sl.Tiles {
                tn := tileNumElements[t] - 1
                if tn == 0 {
                        continue
                }
                if idx < ci || idx >= ci+tn {
                        ci += tn
                        continue
                }
                ri := idx - ci
                switch t {
                case TileSplit:
                        update(0, val, sl.SubSplits[i])
                case TileFirstLong, TileSecondLong:
                        if ri == 0 {
                                update(0, val, sl.SubSplits[i][:2])
                        } else {
                                update(0, val, sl.SubSplits[i][2:])
                        }
                case TilePlus:
                        if ri == 0 {
                                update(0, val, sl.SubSplits[i][:2])
                        } else {
                                gi := ri * 2
                                update(0, val, sl.SubSplits[i][gi:gi+2])
                        }
                }
                ci += tn
        }
        sl.updateSplits()
        sl.NeedsLayout()
}

// restoreChild restores given child(ren)
// todo: not clear if this makes sense anymore
func (sl *Splits) restoreChild(idxs ...int) {
        n := len(sl.Children)
        for _, idx := range idxs {
                if idx >= 0 && idx < n {
                        sl.TileSplits[idx] = 1.0 / float32(n)
                }
        }
        sl.updateSplits()
        sl.NeedsLayout()
}

func (sl *Splits) styleSplits() {
        nt := len(sl.Tiles)
        if nt == 0 {
                return
        }
        nh := nt - 1
        for _, t := range sl.Tiles {
                nh += tileNumElements[t] - 1
        }
        sl.handleDirs = slicesx.SetLength(sl.handleDirs, nh)
        dir := sl.Styles.Direction
        odir := dir.Other()
        hi := nt - 1 // extra handles

        for i, t := range sl.Tiles {
                if i > 0 {
                        sl.handleDirs[i-1] = dir
                }
                switch t {
                case TileSpan:
                case TileSplit:
                        sl.handleDirs[hi] = odir
                        hi++
                case TileFirstLong, TileSecondLong:
                        sl.handleDirs[hi] = odir
                        sl.handleDirs[hi+1] = dir
                        hi += 2
                case TilePlus:
                        sl.handleDirs[hi] = odir
                        sl.handleDirs[hi+1] = dir
                        sl.handleDirs[hi+2] = dir
                        hi += 3
                }
        }
}

func (sl *Splits) SizeDownSetAllocs(iter int) {
        if sl.NumChildren() <= 1 {
                return
        }
        sl.updateSplits()
        sz := &sl.Geom.Size
        // note: InnerSpace is computed based on n children -- not accurate!
        csz := sz.Alloc.Content
        dim := sl.Styles.Direction.Dim()
        odim := dim.Other()
        cszd := csz.Dim(dim)
        cszo := csz.Dim(odim)
        gap := sl.Styles.Gap.Dots().Floor()
        gapd := gap.Dim(dim)
        gapo := gap.Dim(odim)
        hand := sl.Parts.Child(0).(*Handle)
        hwd := hand.Geom.Size.Actual.Total.Dim(dim)
        cszd -= float32(len(sl.TileSplits)-1) * (hwd + gapd)

        setCsz := func(idx int, szm, szc float32) {
                cwb := AsWidget(sl.Child(idx))
                ksz := &cwb.Geom.Size
                ksz.Alloc.Total.SetDim(dim, szm)
                ksz.Alloc.Total.SetDim(odim, szc)
                ksz.setContentFromTotal(&ksz.Alloc)
        }

        ci := 0
        for i, t := range sl.Tiles {
                szt := math32.Round(sl.TileSplits[i] * cszd) // tile size, main axis
                szcs := cszo - hwd - gapo                    // cross axis spilt
                szs := szt - hwd - gapd
                tn := tileNumElements[t]
                switch t {
                case TileSpan:
                        setCsz(ci, szt, cszo)
                case TileSplit:
                        setCsz(ci, szt, math32.Round(szcs*sl.SubSplits[i][0]))
                        setCsz(ci+1, szt, math32.Round(szcs*sl.SubSplits[i][1]))
                case TileFirstLong:
                        fcht := math32.Round(szcs * sl.SubSplits[i][0])
                        scht := math32.Round(szcs * sl.SubSplits[i][1])
                        setCsz(ci, szt, fcht)
                        setCsz(ci+1, math32.Round(szs*sl.SubSplits[i][2]), scht)
                        setCsz(ci+2, math32.Round(szs*sl.SubSplits[i][3]), scht)
                case TileSecondLong:
                        fcht := math32.Round(szcs * sl.SubSplits[i][1])
                        scht := math32.Round(szcs * sl.SubSplits[i][0])
                        setCsz(ci, math32.Round(szs*sl.SubSplits[i][2]), scht)
                        setCsz(ci+1, math32.Round(szs*sl.SubSplits[i][3]), scht)
                        setCsz(ci+2, szt, fcht)
                case TilePlus:
                        fcht := math32.Round(szcs * sl.SubSplits[i][0])
                        scht := math32.Round(szcs * sl.SubSplits[i][1])
                        setCsz(ci, math32.Round(szs*sl.SubSplits[i][2]), fcht)
                        setCsz(ci+1, math32.Round(szs*sl.SubSplits[i][3]), fcht)
                        setCsz(ci+2, math32.Round(szs*sl.SubSplits[i][4]), scht)
                        setCsz(ci+3, math32.Round(szs*sl.SubSplits[i][5]), scht)
                }
                ci += tn
        }
}

func (sl *Splits) positionSplits() {
        if sl.NumChildren() <= 1 {
                return
        }
        if sl.Parts != nil {
                sl.Parts.Geom.Size = sl.Geom.Size // inherit: allows bbox to include handle
        }
        sz := &sl.Geom.Size
        dim := sl.Styles.Direction.Dim()
        odim := dim.Other()
        csz := sz.Alloc.Content
        cszd := csz.Dim(dim)
        cszo := csz.Dim(odim)
        gap := sl.Styles.Gap.Dots().Floor()
        gapd := gap.Dim(dim)
        gapo := gap.Dim(odim)

        hand := sl.Parts.Child(0).(*Handle)
        hwd := hand.Geom.Size.Actual.Total.Dim(dim)
        hht := hand.Geom.Size.Actual.Total.Dim(odim)
        cszd -= float32(len(sl.TileSplits)-1) * (hwd + gapd)
        hwdg := hwd + 0.5*gapd

        setChildPos := func(idx int, dpos, opos float32) {
                cwb := AsWidget(sl.Child(idx))
                cwb.Geom.RelPos.SetDim(dim, dpos)
                cwb.Geom.RelPos.SetDim(odim, opos)
        }
        setHandlePos := func(idx int, dpos, opos, lpos, mn, mx float32) {
                hl := sl.Parts.Child(idx).(*Handle)
                hl.Geom.RelPos.SetDim(dim, dpos)
                hl.Geom.RelPos.SetDim(odim, opos)
                hl.Pos = lpos
                hl.Min = mn
                hl.Max = mx
        }

        tpos := float32(0) // tile position
        ci := 0
        nt := len(sl.Tiles)
        hi := nt - 1 // extra handles

        for i, t := range sl.Tiles {
                szt := math32.Round(sl.TileSplits[i] * cszd) // tile size, main axis
                szcs := cszo - hwd - gapo                    // cross axis spilt
                szs := szt - hwd - gapd
                tn := tileNumElements[t]
                if i > 0 {
                        setHandlePos(i-1, tpos-hwdg, .5*(cszo-hht), tpos, 0, cszd)
                }
                switch t {
                case TileSpan:
                        setChildPos(ci, tpos, 0)
                case TileSplit:
                        fcht := math32.Round(szcs * sl.SubSplits[i][0])
                        setHandlePos(hi, tpos+.5*(szt-hht), fcht+0.5*gapo, fcht, 0, szcs)
                        hi++
                        setChildPos(ci, tpos, 0)
                        setChildPos(ci+1, tpos, fcht+hwd+gapo)
                case TileFirstLong, TileSecondLong:
                        fcht := math32.Round(szcs * sl.SubSplits[i][0])
                        scht := math32.Round(szcs * sl.SubSplits[i][1])
                        swd := math32.Round(szs * sl.SubSplits[i][2])
                        bot := fcht + hwd + gapo
                        setHandlePos(hi, tpos+.5*(szt-hht), fcht+0.5*gapo, fcht, 0, szcs) // long
                        if t == TileFirstLong {
                                setHandlePos(hi+1, tpos+swd+0.5*gapd, bot+0.5*(scht-hht), tpos+swd, tpos, tpos+szs)
                                setChildPos(ci, tpos, 0)
                                setChildPos(ci+1, tpos, bot)
                                setChildPos(ci+2, tpos+swd+hwd+gapd, bot)
                        } else {
                                setHandlePos(hi+1, tpos+swd+0.5*gapd, 0.5*(fcht-hht), tpos+swd, tpos, tpos+szs)
                                setChildPos(ci, tpos, 0)
                                setChildPos(ci+1, tpos+swd+hwd+gapd, 0)
                                setChildPos(ci+2, tpos, bot)
                        }
                        hi += 2
                case TilePlus:
                        fcht := math32.Round(szcs * sl.SubSplits[i][0])
                        scht := math32.Round(szcs * sl.SubSplits[i][1])
                        bot := fcht + hwd + gapo
                        setHandlePos(hi, tpos+.5*(szt-hht), fcht+0.5*gapo, fcht, 0, szcs) // long
                        swd1 := math32.Round(szs * sl.SubSplits[i][2])
                        swd2 := math32.Round(szs * sl.SubSplits[i][4])
                        setHandlePos(hi+1, tpos+swd1+0.5*gapd, 0.5*(fcht-hht), tpos+swd1, tpos, tpos+szs)
                        setHandlePos(hi+2, tpos+swd2+0.5*gapd, bot+0.5*(scht-hht), tpos+swd2, tpos, tpos+szs)
                        setChildPos(ci, tpos, 0)
                        setChildPos(ci+1, tpos+swd1+hwd+gapd, 0)
                        setChildPos(ci+2, tpos, bot)
                        setChildPos(ci+3, tpos+swd2+hwd+gapd, bot)
                        hi += 3
                }
                ci += tn
                tpos += szt + hwd + gapd
        }
}

func (sl *Splits) Position() {
        if !sl.HasChildren() {
                sl.Frame.Position()
                return
        }
        sl.updateSplits()
        sl.ConfigScrolls()
        sl.positionSplits()
        sl.positionChildren()
}

func (sl *Splits) RenderWidget() {
        if sl.StartRender() {
                sl.ForWidgetChildren(func(i int, kwi Widget, cwb *WidgetBase) bool {
                        cwb.SetState(sl.ChildIsCollapsed(i), states.Invisible)
                        kwi.RenderWidget()
                        return tree.Continue
                })
                sl.renderParts()
                sl.EndRender()
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "sync"

        "cogentcore.org/core/base/ordmap"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "golang.org/x/image/draw"
)

// A Sprite is just an image (with optional background) that can be drawn onto
// the OverTex overlay texture of a window.  Sprites are used for text cursors/carets
// and for dynamic editing / interactive GUI elements (e.g., drag-n-drop elements)
type Sprite struct {

        // Active is whether this sprite is Active now or not.
        Active bool

        // Name is the unique name of the sprite.
        Name string

        // properties for sprite, which allow for user-extensible data
        Properties map[string]any

        // position and size of the image within the RenderWindow
        Geom math32.Geom2DInt

        // pixels to render, which should be the same size as [Sprite.Geom.Size]
        Pixels *image.RGBA

        // listeners are event listener functions for processing events on this widget.
        // They are called in sequential descending order (so the last added listener
        // is called first). They should be added using the On function. FirstListeners
        // and FinalListeners are called before and after these listeners, respectively.
        listeners events.Listeners `copier:"-" json:"-" xml:"-" set:"-"`
}

// NewSprite returns a new [Sprite] with the given name, which must remain
// invariant and unique among all sprites in use, and is used for all access;
// prefix with package and type name to ensure uniqueness. Starts out in
// inactive state; must call ActivateSprite. If size is 0, no image is made.
func NewSprite(name string, sz image.Point, pos image.Point) *Sprite {
        sp := &Sprite{Name: name}
        sp.SetSize(sz)
        sp.Geom.Pos = pos
        return sp
}

// SetSize sets sprite image to given size; makes a new image (does not resize)
// returns true if a new image was set
func (sp *Sprite) SetSize(nwsz image.Point) bool {
        if nwsz.X == 0 || nwsz.Y == 0 {
                return false
        }
        sp.Geom.Size = nwsz // always make sure
        if sp.Pixels != nil && sp.Pixels.Bounds().Size() == nwsz {
                return false
        }
        sp.Pixels = image.NewRGBA(image.Rectangle{Max: nwsz})
        return true
}

// grabRenderFrom grabs the rendered image from the given widget.
func (sp *Sprite) grabRenderFrom(w Widget) {
        img := grabRenderFrom(w)
        if img != nil {
                sp.Pixels = img
                sp.Geom.Size = sp.Pixels.Bounds().Size()
        } else {
                sp.SetSize(image.Pt(10, 10)) // just a blank placeholder
        }
}

// grabRenderFrom grabs the rendered image from the given widget.
// If it returns nil, then the image could not be fetched.
func grabRenderFrom(w Widget) *image.RGBA {
        wb := w.AsWidget()
        scimg := wb.Scene.renderer.Image() // todo: need to make this real on JS
        if scimg == nil {
                return nil
        }
        if wb.Geom.TotalBBox.Empty() { // the widget is offscreen
                return nil
        }
        sz := wb.Geom.TotalBBox.Size()
        img := image.NewRGBA(image.Rectangle{Max: sz})
        draw.Draw(img, img.Bounds(), scimg, wb.Geom.TotalBBox.Min, draw.Src)
        return img
}

// On adds the given event handler to the sprite's Listeners for the given event type.
// Listeners are called in sequential descending order, so this listener will be called
// before all of the ones added before it.
func (sp *Sprite) On(etype events.Types, fun func(e events.Event)) *Sprite {
        sp.listeners.Add(etype, fun)
        return sp
}

// OnClick adds an event listener function for [events.Click] events
func (sp *Sprite) OnClick(fun func(e events.Event)) *Sprite {
        return sp.On(events.Click, fun)
}

// OnSlideStart adds an event listener function for [events.SlideStart] events
func (sp *Sprite) OnSlideStart(fun func(e events.Event)) *Sprite {
        return sp.On(events.SlideStart, fun)
}

// OnSlideMove adds an event listener function for [events.SlideMove] events
func (sp *Sprite) OnSlideMove(fun func(e events.Event)) *Sprite {
        return sp.On(events.SlideMove, fun)
}

// OnSlideStop adds an event listener function for [events.SlideStop] events
func (sp *Sprite) OnSlideStop(fun func(e events.Event)) *Sprite {
        return sp.On(events.SlideStop, fun)
}

// HandleEvent sends the given event to all listeners for that event type.
func (sp *Sprite) handleEvent(e events.Event) {
        sp.listeners.Call(e)
}

// send sends an new event of the given type to this sprite,
// optionally starting from values in the given original event
// (recommended to include where possible).
// Do not send an existing event using this method if you
// want the Handled state to persist throughout the call chain;
// call [Sprite.handleEvent] directly for any existing events.
func (sp *Sprite) send(typ events.Types, original ...events.Event) {
        var e events.Event
        if len(original) > 0 && original[0] != nil {
                e = original[0].NewFromClone(typ)
        } else {
                e = &events.Base{Typ: typ}
                e.Init()
        }
        sp.handleEvent(e)
}

// Sprites manages a collection of Sprites, with unique name ids.
type Sprites struct {
        ordmap.Map[string, *Sprite]

        // set to true if sprites have been modified since last config
        modified bool

        sync.Mutex
}

// Add adds sprite to list, and returns the image index and
// layer index within that for given sprite.  If name already
// exists on list, then it is returned, with size allocation
// updated as needed.
func (ss *Sprites) Add(sp *Sprite) {
        ss.Lock()
        ss.Init()
        ss.Map.Add(sp.Name, sp)
        ss.modified = true
        ss.Unlock()
}

// Delete deletes sprite by name, returning indexes where it was located.
// All sprite images must be updated when this occurs, as indexes may have shifted.
func (ss *Sprites) Delete(sp *Sprite) {
        ss.Lock()
        ss.DeleteKey(sp.Name)
        ss.modified = true
        ss.Unlock()
}

// SpriteByName returns the sprite by name
func (ss *Sprites) SpriteByName(name string) (*Sprite, bool) {
        ss.Lock()
        defer ss.Unlock()
        return ss.ValueByKeyTry(name)
}

// reset removes all sprites
func (ss *Sprites) reset() {
        ss.Lock()
        ss.Reset()
        ss.modified = true
        ss.Unlock()
}

// ActivateSprite flags the sprite as active, setting Modified if wasn't before.
func (ss *Sprites) ActivateSprite(name string) {
        sp, ok := ss.SpriteByName(name)
        if !ok {
                return // not worth bothering about errs -- use a consistent string var!
        }
        ss.Lock()
        if !sp.Active {
                sp.Active = true
                ss.modified = true
        }
        ss.Unlock()
}

// InactivateSprite flags the sprite as inactive, setting Modified if wasn't before.
func (ss *Sprites) InactivateSprite(name string) {
        sp, ok := ss.SpriteByName(name)
        if !ok {
                return // not worth bothering about errs -- use a consistent string var!
        }
        ss.Lock()
        if sp.Active {
                sp.Active = false
                ss.modified = true
        }
        ss.Unlock()
}

// IsModified returns whether the sprites have been modified.
func (ss *Sprites) IsModified() bool {
        ss.Lock()
        defer ss.Unlock()
        return ss.modified
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "strings"
        "time"

        "cogentcore.org/core/base/option"
        "cogentcore.org/core/system"
)

// StageTypes are the types of [Stage] containers.
// There are two main categories: MainStage and PopupStage.
// MainStages are [WindowStage] and [DialogStage], which are
// large and potentially complex [Scene]s that persist until
// dismissed. PopupStages are [MenuStage], [TooltipStage],
// [SnackbarStage], and [CompleterStage], which are transitory
// and simple, without additional decorations. MainStages live
// in a [stages] associated with a [renderWindow] and manage
// their own set of PopupStages via another [stages].
type StageTypes int32 //enums:enum

const (
        // WindowStage is a MainStage that displays a [Scene] in a full window.
        // One of these must be created first, as the primary app content,
        // and it typically persists throughout. It fills the [renderWindow].
        // Additional windows can be created either within the same [renderWindow]
        // on all platforms or in separate [renderWindow]s on desktop platforms.
        WindowStage StageTypes = iota

        // DialogStage is a MainStage that displays a [Scene] in a smaller dialog
        // window on top of a [WindowStage], or in a full or separate window.
        // It can be [Stage.Modal] or not.
        DialogStage

        // MenuStage is a PopupStage that displays a [Scene] typically containing
        // [Button]s overlaid on a MainStage. It is typically [Stage.Modal] and
        // [Stage.ClickOff], and closes when an button is clicked.
        MenuStage

        // TooltipStage is a PopupStage that displays a [Scene] with extra text
        // info for a widget overlaid on a MainStage. It is typically [Stage.ClickOff]
        // and not [Stage.Modal].
        TooltipStage

        // SnackbarStage is a PopupStage that displays a [Scene] with text info
        // and an optional additional button. It is displayed at the bottom of the
        // screen. It is typically not [Stage.ClickOff] or [Stage.Modal], but has a
        // [Stage.Timeout].
        SnackbarStage

        // CompleterStage is a PopupStage that displays a [Scene] with text completion
        // options, spelling corrections, or other such dynamic info. It is typically
        // [Stage.ClickOff], not [Stage.Modal], dynamically updating, and closes when
        // something is selected or typing renders it no longer relevant.
        CompleterStage
)

// isMain returns true if this type of Stage is a Main stage that manages
// its own set of popups
func (st StageTypes) isMain() bool {
        return st <= DialogStage
}

// isPopup returns true if this type of Stage is a Popup, managed by another
// Main stage.
func (st StageTypes) isPopup() bool {
        return !st.isMain()
}

// Stage is a container and manager for displaying a [Scene]
// in different functional ways, defined by [StageTypes].
type Stage struct { //types:add -setters

        // Type is the type of [Stage], which determines behavior and styling.
        Type StageTypes `set:"-"`

        // Scene contents of this [Stage] (what it displays).
        Scene *Scene `set:"-"`

        // Context is a widget in another scene that requested this stage to be created
        // and provides context.
        Context Widget

        // Name is the name of the Stage, which is generally auto-set
        // based on the [Scene.Name].
        Name string

        // Title is the title of the Stage, which is generally auto-set
        // based on the [Body.Title]. It used for the title of [WindowStage]
        // and [DialogStage] types, and for a [Text] title widget if
        // [Stage.DisplayTitle] is true.
        Title string

        // Screen specifies the screen number on which a new window is opened
        // by default on desktop platforms. It defaults to -1, which indicates
        // that the first window should open on screen 0 (the default primary
        // screen) and any subsequent windows should open on the same screen as
        // the currently active window. Regardless, the automatically saved last
        // screen of a window with the same [Stage.Title] takes precedence if it exists;
        // see the website documentation on window geometry saving for more information.
        // Use [TheApp].ScreenByName("name").ScreenNumber to get the screen by name.
        Screen int

        // Modal, if true, blocks input to all other stages.
        Modal bool `set:"-"`

        // Scrim, if true, places a darkening scrim over other stages.
        Scrim bool

        // ClickOff, if true, dismisses the [Stage] if the user clicks anywhere
        // off of the [Stage].
        ClickOff bool

        // ignoreEvents is whether to send no events to the stage and
        // just pass them down to lower stages.
        ignoreEvents bool

        // NewWindow, if true, opens a [WindowStage] or [DialogStage] in its own
        // separate operating system window ([renderWindow]). This is true by
        // default for [WindowStage] on non-mobile platforms, otherwise false.
        NewWindow bool

        // FullWindow, if [Stage.NewWindow] is false, makes [DialogStage]s and
        // [WindowStage]s take up the entire window they are created in.
        FullWindow bool

        // Maximized is whether to make a window take up the entire screen on desktop
        // platforms by default. It is different from [Stage.Fullscreen] in that
        // fullscreen makes the window truly fullscreen without decorations
        // (such as for a video player), whereas maximized keeps decorations and just
        // makes it fill the available space. The automatically saved user previous
        // maximized state takes precedence.
        Maximized bool

        // Fullscreen is whether to make a window fullscreen on desktop platforms.
        // It is different from [Stage.Maximized] in that fullscreen makes
        // the window truly fullscreen without decorations (such as for a video player),
        // whereas maximized keeps decorations and just makes it fill the available space.
        // Not to be confused with [Stage.FullWindow], which is for stages contained within
        // another system window. See [Scene.IsFullscreen] and [Scene.SetFullscreen] to
        // check and update fullscreen state dynamically on desktop and web platforms
        // ([Stage.SetFullscreen] sets the initial state, whereas [Scene.SetFullscreen]
        // sets the current state after the [Stage] is already running).
        Fullscreen bool

        // UseMinSize uses a minimum size as a function of the total available size
        // for sizing new windows and dialogs. Otherwise, only the content size is used.
        // The saved window position and size takes precedence on multi-window platforms.
        UseMinSize bool

        // Resizable specifies whether a window on desktop platforms can
        // be resized by the user, and whether a non-full same-window dialog can
        // be resized by the user on any platform. It defaults to true.
        Resizable bool

        // Timeout, if greater than 0, results in a popup stages disappearing
        // after this timeout duration.
        Timeout time.Duration

        // BackButton is whether to add a back button to the top bar that calls
        // [Scene.Close] when clicked. If it is unset, is will be treated as true
        // on non-[system.Offscreen] platforms for [Stage.FullWindow] but not
        // [Stage.NewWindow] [Stage]s that are not the first in the stack.
        BackButton option.Option[bool] `set:"-"`

        // DisplayTitle is whether to display the [Stage.Title] using a
        // [Text] widget in the top bar. It is on by default for [DialogStage]s
        // and off for all other stages.
        DisplayTitle bool

        // Pos is the default target position for the [Stage] to be placed within
        // the surrounding window or screen in raw pixels. For a new window on desktop
        // platforms, the automatically saved user previous window position takes precedence.
        // For dialogs, this position is the target center position, not the upper-left corner.
        Pos image.Point

        // If a popup stage, this is the main stage that owns it (via its [Stage.popups]).
        // If a main stage, it points to itself.
        Main *Stage `set:"-"`

        // For main stages, this is the stack of the popups within it
        // (created specifically for the main stage).
        // For popups, this is the pointer to the popups within the
        // main stage managing it.
        popups *stages

        // For all stages, this is the main [Stages] that lives in a [renderWindow]
        // and manages the main stages.
        Mains *stages `set:"-"`

        // rendering context which has info about the RenderWindow onto which we render.
        // This should be used instead of the RenderWindow itself for all relevant
        // rendering information. This is only available once a Stage is Run,
        // and must always be checked for nil.
        renderContext *renderContext

        // Sprites are named images that are rendered last overlaying everything else.
        Sprites Sprites `json:"-" xml:"-" set:"-"`
}

func (st *Stage) String() string {
        str := fmt.Sprintf("%s Type: %s", st.Name, st.Type)
        if st.Scene != nil {
                str += "  Scene: " + st.Scene.Name
        }
        rc := st.renderContext
        if rc != nil {
                str += "  Rc: " + rc.String()
        }
        return str
}

// SetBackButton sets [Stage.BackButton] using [option.Option.Set].
func (st *Stage) SetBackButton(b bool) *Stage {
        st.BackButton.Set(b)
        return st
}

// setNameFromScene sets the name of this Stage based on existing
// Scene and Type settings.
func (st *Stage) setNameFromScene() *Stage {
        if st.Scene == nil {
                return nil
        }
        sc := st.Scene
        st.Name = sc.Name + "-" + strings.ToLower(st.Type.String())
        if sc.Body != nil {
                st.Title = sc.Body.Title
        }
        return st
}

func (st *Stage) setScene(sc *Scene) *Stage {
        st.Scene = sc
        if sc != nil {
                sc.Stage = st
                st.setNameFromScene()
        }
        return st
}

// setMains sets the [Stage.Mains] to the given stack of main stages,
// and also sets the RenderContext from that.
func (st *Stage) setMains(sm *stages) *Stage {
        st.Mains = sm
        st.renderContext = sm.renderContext
        return st
}

// setPopups sets the [Stage.Popups] and [Stage.Mains] from the given main
// stage to which this popup stage belongs.
func (st *Stage) setPopups(mainSt *Stage) *Stage {
        st.Main = mainSt
        st.Mains = mainSt.Mains
        st.popups = mainSt.popups
        st.renderContext = st.Mains.renderContext
        return st
}

// setType sets the type and also sets default parameters based on that type
func (st *Stage) setType(typ StageTypes) *Stage {
        st.Type = typ
        st.UseMinSize = true
        st.Resizable = true
        st.Screen = -1
        switch st.Type {
        case WindowStage:
                if !TheApp.Platform().IsMobile() {
                        st.NewWindow = true
                }
                st.FullWindow = true
                st.Modal = true // note: there is no global modal option between RenderWindow windows
        case DialogStage:
                st.Modal = true
                st.Scrim = true
                st.ClickOff = true
                st.DisplayTitle = true
        case MenuStage:
                st.Modal = true
                st.Scrim = false
                st.ClickOff = true
        case TooltipStage:
                st.Modal = false
                st.ClickOff = true
                st.Scrim = false
                st.ignoreEvents = true
        case SnackbarStage:
                st.Modal = false
        case CompleterStage:
                st.Modal = false
                st.Scrim = false
                st.ClickOff = true
        }
        return st
}

// SetModal sets modal flag for blocking other input (for dialogs).
// Also updates [Stage.Scrim] accordingly if not modal.
func (st *Stage) SetModal(modal bool) *Stage {
        st.Modal = modal
        if !st.Modal {
                st.Scrim = false
        }
        return st
}

// Run runs the stage using the default run behavior based on the type of stage.
func (st *Stage) Run() *Stage {
        if system.OnSystemWindowCreated == nil {
                return st.run()
        }
        // need to prevent premature quitting by ensuring
        // that WinWait is not done until we run the Stage
        windowWait.Add(1)
        go func() {
                <-system.OnSystemWindowCreated
                system.OnSystemWindowCreated = nil // no longer applicable
                st.run()
                // now that we have run the Stage, WinWait is accurate and
                // we no longer need to prevent it from being done
                windowWait.Done()
        }()
        return st
}

// run is the implementation of [Stage.Run].
func (st *Stage) run() *Stage {
        defer func() { system.HandleRecover(recover()) }()
        switch st.Type {
        case WindowStage:
                return st.runWindow()
        case DialogStage:
                return st.runDialog()
        default:
                return st.runPopup()
        }
}

// doUpdate calls doUpdate on our Scene and UpdateAll on our Popups for Main types.
// returns stageMods = true if any Popup Stages have been modified
// and sceneMods = true if any Scenes have been modified.
func (st *Stage) doUpdate() (stageMods, sceneMods bool) {
        if st.Scene == nil {
                return
        }
        if st.Type.isMain() && st.popups != nil {
                stageMods, sceneMods = st.popups.updateAll()
        }
        scMods := st.Scene.doUpdate()
        sceneMods = sceneMods || scMods
        // if stageMods || sceneMods {
        //         fmt.Println("scene mod", st.Scene.Name, stageMods, scMods)
        // }
        return
}

// raise moves the Stage to the top of its main [stages]
// and raises the [renderWindow] it is in if necessary.
func (st *Stage) raise() {
        if st.Mains.renderWindow != currentRenderWindow {
                st.Mains.renderWindow.Raise()
        }
        st.Mains.moveToTop(st)
        currentRenderWindow.SetStageTitle(st.Title)
}

func (st *Stage) delete() {
        if st.Type.isMain() && st.popups != nil {
                st.popups.deleteAll()
                st.Sprites.reset()
        }
        if st.Scene != nil {
                st.Scene.DeleteChildren()
        }
        st.Scene = nil
        st.Main = nil
        st.popups = nil
        st.Mains = nil
        st.renderContext = nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "sync"

        "cogentcore.org/core/base/ordmap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/system"
)

// stages manages a stack of [Stage]s.
type stages struct {

        // stack is the stack of stages managed by this stage manager.
        stack ordmap.Map[string, *Stage]

        // modified is set to true whenever the stack has been modified.
        // This is cleared by the RenderWindow each render cycle.
        modified bool

        // rendering context provides key rendering information and locking
        // for the RenderWindow in which the stages are running.
        renderContext *renderContext

        // render window to which we are rendering.
        // rely on the RenderContext wherever possible.
        renderWindow *renderWindow

        // main is the main stage that owns this [Stages].
        // This is only set for popup stages.
        main *Stage

        // mutex protecting reading / updating of the Stack.
        // Destructive stack updating gets a Write lock, else Read.
        sync.Mutex
}

// top returns the top-most Stage in the Stack, under Read Lock
func (sm *stages) top() *Stage {
        sm.Lock()
        defer sm.Unlock()

        sz := sm.stack.Len()
        if sz == 0 {
                return nil
        }
        return sm.stack.ValueByIndex(sz - 1)
}

// uniqueName returns unique name for given item
func (sm *stages) uniqueName(nm string) string {
        ctr := 0
        for _, kv := range sm.stack.Order {
                if kv.Key == nm {
                        ctr++
                }
        }
        if ctr > 0 {
                return fmt.Sprintf("%s-%d", nm, len(sm.stack.Order))
        }
        return nm
}

// push pushes a new Stage to top, under Write lock
func (sm *stages) push(st *Stage) {
        sm.Lock()
        defer sm.Unlock()

        sm.modified = true
        sm.stack.Add(sm.uniqueName(st.Name), st)
}

// deleteStage deletes given stage (removing from stack, calling Delete
// on Stage), returning true if found.
// It runs under Write lock.
func (sm *stages) deleteStage(st *Stage) bool {
        sm.Lock()
        defer sm.Unlock()

        l := sm.stack.Len()
        fullWindow := st.FullWindow
        got := false
        for i := l - 1; i >= 0; i-- {
                s := sm.stack.ValueByIndex(i)
                if st == s {
                        sm.modified = true
                        sm.stack.DeleteIndex(i, i+1)
                        st.delete()
                        got = true
                        break
                }
        }
        if !got {
                return false
        }
        // After closing a full window stage on web, the top stage behind
        // needs to be rerendered, or else nothing will show up.
        if fullWindow && TheApp.Platform() == system.Web {
                sz := sm.renderWindow.mains.stack.Len()
                if sz > 0 {
                        ts := sm.renderWindow.mains.stack.ValueByIndex(sz - 1)
                        if ts.Scene != nil {
                                ts.Scene.NeedsRender()
                        }
                }
        }
        return true
}

// deleteStageAndBelow deletes given stage (removing from stack,
// calling Delete on Stage), returning true if found.
// And also deletes all stages of the same type immediately below it.
// It runs under Write lock.
func (sm *stages) deleteStageAndBelow(st *Stage) bool {
        sm.Lock()
        defer sm.Unlock()

        styp := st.Type

        l := sm.stack.Len()
        got := false
        for i := l - 1; i >= 0; i-- {
                s := sm.stack.ValueByIndex(i)
                if !got {
                        if st == s {
                                sm.modified = true
                                sm.stack.DeleteIndex(i, i+1)
                                st.delete()
                                got = true
                        }
                } else {
                        if s.Type == styp {
                                sm.stack.DeleteIndex(i, i+1)
                                st.delete()
                        }
                }
        }
        return got
}

// moveToTop moves the given stage to the top of the stack,
// returning true if found. It runs under Write lock.
func (sm *stages) moveToTop(st *Stage) bool {
        sm.Lock()
        defer sm.Unlock()

        l := sm.stack.Len()
        for i := l - 1; i >= 0; i-- {
                s := sm.stack.ValueByIndex(i)
                if st == s {
                        k := sm.stack.KeyByIndex(i)
                        sm.modified = true
                        sm.stack.DeleteIndex(i, i+1)
                        sm.stack.InsertAtIndex(sm.stack.Len(), k, s)
                        return true
                }
        }
        return false
}

// popType pops the top-most Stage of the given type of the stack,
// returning it or nil if none. It runs under Write lock.
func (sm *stages) popType(typ StageTypes) *Stage {
        sm.Lock()
        defer sm.Unlock()

        l := sm.stack.Len()
        for i := l - 1; i >= 0; i-- {
                st := sm.stack.ValueByIndex(i)
                if st.Type == typ {
                        sm.modified = true
                        sm.stack.DeleteIndex(i, i+1)
                        return st
                }
        }
        return nil
}

// popDeleteType pops the top-most Stage of the given type off the stack
// and calls Delete on it.
func (sm *stages) popDeleteType(typ StageTypes) {
        st := sm.popType(typ)
        if st != nil {
                st.delete()
        }
}

// deleteAll deletes all of the stages.
// For when Stage with Popups is Deleted, or when a RenderWindow is closed.
// requires outer RenderContext mutex!
func (sm *stages) deleteAll() {
        sm.Lock()
        defer sm.Unlock()

        sz := sm.stack.Len()
        if sz == 0 {
                return
        }
        sm.modified = true
        for i := sz - 1; i >= 0; i-- {
                st := sm.stack.ValueByIndex(i)
                st.delete()
                sm.stack.DeleteIndex(i, i+1)
        }
}

// resize calls resize on all stages within based on the given window render geom.
// if nothing actually needed to be resized, it returns false.
func (sm *stages) resize(rg math32.Geom2DInt) bool {
        resized := false
        for _, kv := range sm.stack.Order {
                st := kv.Value
                if st.FullWindow {
                        did := st.Scene.resize(rg)
                        if did {
                                st.Sprites.reset()
                                resized = true
                        }
                } else {
                        did := st.Scene.fitInWindow(rg)
                        if did {
                                resized = true
                        }
                }
        }
        return resized
}

// updateAll is the primary updating function to update all scenes
// and determine if any updates were actually made.
// This [stages] is the mains of the [renderWindow] or the popups
// of a list of popups within a main stage.
// It iterates through all Stages and calls doUpdate on them.
// returns stageMods = true if any Stages have been modified (Main or Popup),
// and sceneMods = true if any Scenes have been modified.
// Stage calls doUpdate on its [Scene], ensuring everything is updated at the
// Widget level. If nothing is needed, nothing is done.
// This is called only during [renderWindow.renderWindow],
// under the global RenderContext.Mu lock so nothing else can happen.
func (sm *stages) updateAll() (stageMods, sceneMods bool) {
        sm.Lock()
        defer sm.Unlock()

        stageMods = sm.modified
        sm.modified = false

        sz := sm.stack.Len()
        if sz == 0 {
                return
        }
        for _, kv := range sm.stack.Order {
                st := kv.Value
                stMod, scMod := st.doUpdate()
                stageMods = stageMods || stMod
                sceneMods = sceneMods || scMod
        }
        return
}

// windowStage returns the highest level WindowStage (i.e., full window)
func (sm *stages) windowStage() *Stage {
        n := sm.stack.Len()
        for i := n - 1; i >= 0; i-- {
                st := sm.stack.ValueByIndex(i)
                if st.Type == WindowStage {
                        return st
                }
        }
        return nil
}

func (sm *stages) runDeferred() {
        for _, kv := range sm.stack.Order {
                st := kv.Value
                if st.Scene == nil {
                        continue
                }
                sc := st.Scene
                if sc.hasFlag(sceneContentSizing) {
                        continue
                }
                if sc.hasFlag(sceneHasDeferred) {
                        sc.setFlag(false, sceneHasDeferred)
                        sc.runDeferred()
                }

                if sc.showIter == sceneShowIters+1 {
                        sc.showIter++
                        if !sc.hasFlag(sceneHasShown) {
                                sc.setFlag(true, sceneHasShown)
                                sc.Shown()
                        }
                }

                // If we own popups, we also need to runDeferred on them.
                if st.Main == st && st.popups.stack.Len() > 0 {
                        st.popups.runDeferred()
                }
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "reflect"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/tree"
)

// Styler adds the given function for setting the style properties of the widget
// to [WidgetBase.Stylers.Normal]. It is one of the main ways to specify the styles of
// a widget, in addition to FirstStyler and FinalStyler, which add stylers that
// are called before and after the stylers added by this function, respectively.
func (wb *WidgetBase) Styler(s func(s *styles.Style)) {
        wb.Stylers.Normal = append(wb.Stylers.Normal, s)
}

// FirstStyler adds the given function for setting the style properties of the widget
// to [WidgetBase.Stylers.First]. It is one of the main ways to specify the styles of
// a widget, in addition to Styler and FinalStyler, which add stylers that
// are called after the stylers added by this function.
func (wb *WidgetBase) FirstStyler(s func(s *styles.Style)) {
        wb.Stylers.First = append(wb.Stylers.First, s)
}

// FinalStyler adds the given function for setting the style properties of the widget
// to [WidgetBase.Stylers.Final]. It is one of the main ways to specify the styles of
// a widget, in addition to FirstStyler and Styler, which add stylers that are called
// before the stylers added by this function.
func (wb *WidgetBase) FinalStyler(s func(s *styles.Style)) {
        wb.Stylers.Final = append(wb.Stylers.Final, s)
}

// Style updates the style properties of the widget based on [WidgetBase.Stylers].
// To specify the style properties of a widget, use [WidgetBase.Styler].
func (wb *WidgetBase) Style() {
        if wb.This == nil {
                return
        }

        pw := wb.parentWidget()

        // we do these things even if we are overriding the style
        defer func() {
                // note: this does not un-set the Invisible if not None, because all kinds of things
                // can turn invisible to off.
                if wb.Styles.Display == styles.DisplayNone {
                        wb.SetState(true, states.Invisible)
                }
                psz := math32.Vector2{}
                if pw != nil {
                        psz = pw.Geom.Size.Alloc.Content
                }
                setUnitContext(&wb.Styles, wb.Scene, wb.Geom.Size.Alloc.Content, psz)
        }()

        if wb.OverrideStyle {
                return
        }
        wb.resetStyleWidget()

        if pw != nil {
                wb.Styles.InheritFields(&pw.Styles)
        }

        wb.resetStyleSettings()
        wb.runStylers()
        wb.styleSettings()
}

// resetStyleWidget resets the widget styles and applies the basic
// default styles specified in [styles.Style.Defaults].
func (wb *WidgetBase) resetStyleWidget() {
        s := &wb.Styles

        // need to persist state
        state := s.State
        *s = styles.Style{}
        s.Defaults()
        s.State = state

        // default to state layer associated with the state,
        // which the developer can override in their stylers
        // wb.Transition(&s.StateLayer, s.State.StateLayer(), 200*time.Millisecond, LinearTransition)
        s.StateLayer = s.State.StateLayer()
        s.Font.Family = rich.SansSerif
}

// runStylers runs the [WidgetBase.Stylers].
func (wb *WidgetBase) runStylers() {
        wb.Stylers.Do(func(s []func(s *styles.Style)) {
                for _, f := range s {
                        f(&wb.Styles)
                }
        })
}

// resetStyleSettings reverses the effects of [WidgetBase.styleSettings]
// for the widget's font size so that it does not create cascading
// inhereted font size values. It only does this for non-root elements,
// as the root element must receive the larger font size so that
// all other widgets inherit it. It must be called before
// [WidgetBase.runStylers] and [WidgetBase.styleSettings].
func (wb *WidgetBase) resetStyleSettings() {
        if tree.IsRoot(wb) {
                return
        }
        fsz := AppearanceSettings.FontSize / 100
        wb.Styles.Font.Size.Value /= fsz
}

// styleSettings applies [AppearanceSettingsData.Spacing]
// and [AppearanceSettingsData.FontSize] to the style values for the widget.
func (wb *WidgetBase) styleSettings() {
        s := &wb.Styles
        spc := AppearanceSettings.Spacing / 100
        s.Margin.Top.Value *= spc
        s.Margin.Right.Value *= spc
        s.Margin.Bottom.Value *= spc
        s.Margin.Left.Value *= spc
        s.Padding.Top.Value *= spc
        s.Padding.Right.Value *= spc
        s.Padding.Bottom.Value *= spc
        s.Padding.Left.Value *= spc
        s.Gap.X.Value *= spc
        s.Gap.Y.Value *= spc

        fsz := AppearanceSettings.FontSize / 100
        s.Font.Size.Value *= fsz
}

// StyleTree calls [WidgetBase.Style] on every widget in tree
// underneath and including this widget.
func (wb *WidgetBase) StyleTree() {
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                cw.Style()
                return tree.Continue
        })
}

// Restyle ensures that the styling of the widget and all of its children
// is updated and rendered by calling [WidgetBase.StyleTree] and
// [WidgetBase.NeedsRender]. It does not trigger a new update or layout
// pass, so it should only be used for non-structural styling changes.
func (wb *WidgetBase) Restyle() {
        wb.StyleTree()
        wb.NeedsRender()
}

// setUnitContext sets the unit context based on size of scene, element, and parent
// element (from bbox) and then caches everything out in terms of raw pixel
// dots for rendering.
// Zero values for element and parent size are ignored.
func setUnitContext(st *styles.Style, sc *Scene, el, parent math32.Vector2) {
        var rc *renderContext
        sz := image.Point{1920, 1080}
        if sc != nil {
                rc = sc.renderContext()
                sz = sc.SceneGeom.Size
        }
        if rc != nil {
                st.UnitContext.DPI = rc.logicalDPI
        } else {
                st.UnitContext.DPI = 160
        }
        st.UnitContext.SetSizes(float32(sz.X), float32(sz.Y), el.X, el.Y, parent.X, parent.Y)
        st.Font.ToDots(&st.UnitContext) // key to set first
        st.Font.SetUnitContext(&st.UnitContext)
        st.ToDots()
}

// ChildBackground returns the background color (Image) for the given child Widget.
// By default, this is just our [styles.Style.ActualBackground] but it can be computed
// specifically for the child (e.g., for zebra stripes in [ListGrid])
func (wb *WidgetBase) ChildBackground(child Widget) image.Image {
        return wb.Styles.ActualBackground
}

// parentActualBackground returns the actual background of
// the parent of the widget. If it has no parent, it returns nil.
func (wb *WidgetBase) parentActualBackground() image.Image {
        pwb := wb.parentWidget()
        if pwb == nil {
                return nil
        }
        return pwb.This.(Widget).ChildBackground(wb.This.(Widget))
}

// setFromTag uses the given tags to call the given set function for the given tag.
func setFromTag(tags reflect.StructTag, tag string, set func(v float32)) {
        if v, ok := tags.Lookup(tag); ok {
                f, err := reflectx.ToFloat32(v)
                if errors.Log(err) == nil {
                        set(f)
                }
        }
}

// styleFromTags adds a [WidgetBase.Styler] to the given widget
// to set its style properties based on the given [reflect.StructTag].
// Width, height, and grow properties are supported.
func styleFromTags(w Widget, tags reflect.StructTag) {
        w.AsWidget().Styler(func(s *styles.Style) {
                setFromTag(tags, "width", s.Min.X.Ch)
                setFromTag(tags, "max-width", s.Max.X.Ch)
                setFromTag(tags, "height", s.Min.Y.Em)
                setFromTag(tags, "max-height", s.Max.Y.Em)
                setFromTag(tags, "grow", func(v float32) { s.Grow.X = v })
                setFromTag(tags, "grow-y", func(v float32) { s.Grow.Y = v })
        })
        if tags.Get("new-window") == "+" {
                w.AsWidget().setFlag(true, widgetValueNewWindow)
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "io"
        "io/fs"
        "strings"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/svg"
        "cogentcore.org/core/tree"
        "golang.org/x/image/draw"
)

// todo: rewrite svg.SVG to accept an external painter to render to,
// and use that for this, so it renders directly instead of via image.

// SVG is a Widget that renders an [svg.SVG] object.
// If it is not [states.ReadOnly], the user can pan and zoom the display.
// By default, it is [states.ReadOnly].
type SVG struct {
        WidgetBase

        // SVG is the SVG drawing to display.
        SVG *svg.SVG `set:"-"`

        // image renderer
        renderer render.Renderer

        // cached rendered image
        image image.Image

        // prevSize is the cached allocated size for the last rendered image.
        prevSize image.Point `xml:"-" json:"-" set:"-"`
}

func (sv *SVG) Init() {
        sv.WidgetBase.Init()
        sz := math32.Vec2(10, 10)
        sv.SVG = svg.NewSVG(sz)
        sv.renderer = paint.NewImageRenderer(sz)
        sv.SetReadOnly(true)
        sv.Styler(func(s *styles.Style) {
                s.Min.Set(units.Dp(256))

                ro := sv.IsReadOnly()
                s.SetAbilities(!ro, abilities.Slideable, abilities.Activatable, abilities.Scrollable)
                if !ro {
                        if s.Is(states.Active) {
                                s.Cursor = cursors.Grabbing
                                s.StateLayer = 0
                        } else {
                                s.Cursor = cursors.Grab
                        }
                }
        })
        sv.FinalStyler(func(s *styles.Style) {
                sv.SVG.Root.ViewBox.PreserveAspectRatio.SetFromStyle(s)
        })

        sv.On(events.SlideMove, func(e events.Event) {
                if sv.IsReadOnly() {
                        return
                }
                e.SetHandled()
                del := e.PrevDelta()
                sv.SVG.Translate.X += float32(del.X)
                sv.SVG.Translate.Y += float32(del.Y)
                sv.NeedsRender()
        })
        sv.On(events.Scroll, func(e events.Event) {
                if sv.IsReadOnly() {
                        return
                }
                e.SetHandled()
                se := e.(*events.MouseScroll)
                sv.SVG.Scale += float32(se.Delta.Y) / 100
                if sv.SVG.Scale <= 0.0000001 {
                        sv.SVG.Scale = 0.01
                }
                sv.NeedsRender()
        })
}

// Open opens an XML-formatted SVG file
func (sv *SVG) Open(filename Filename) error { //types:add
        return sv.SVG.OpenXML(string(filename))
}

// OpenSVG opens an XML-formatted SVG file from the given fs.
func (sv *SVG) OpenFS(fsys fs.FS, filename string) error {
        return sv.SVG.OpenFS(fsys, filename)
}

// Read reads an XML-formatted SVG file from the given reader.
func (sv *SVG) Read(r io.Reader) error {
        return sv.SVG.ReadXML(r)
}

// ReadString reads an XML-formatted SVG file from the given string.
func (sv *SVG) ReadString(s string) error {
        return sv.SVG.ReadXML(strings.NewReader(s))
}

// SaveSVG saves the current SVG to an XML-encoded standard SVG file.
func (sv *SVG) SaveSVG(filename Filename) error { //types:add
        return sv.SVG.SaveXML(string(filename))
}

// SaveImage saves the current rendered SVG image to an image file,
// using the filename extension to determine the file type.
func (sv *SVG) SaveImage(filename Filename) error { //types:add
        return sv.SVG.SaveImage(string(filename))
}

func (sv *SVG) SizeFinal() {
        sv.WidgetBase.SizeFinal()
        sz := sv.Geom.Size.Actual.Content
        sv.SVG.SetSize(sz)
        sv.renderer.SetSize(units.UnitDot, sz)
}

// renderSVG renders the SVG
func (sv *SVG) renderSVG() {
        if sv.SVG == nil {
                return
        }
        sv.SVG.TextShaper = sv.Scene.TextShaper()
        sv.renderer.Render(sv.SVG.Render(nil).RenderDone())
        sv.image = imagex.WrapJS(sv.renderer.Image())
        sv.prevSize = sv.image.Bounds().Size()
}

func (sv *SVG) Render() {
        sv.WidgetBase.Render()
        if sv.SVG == nil {
                return
        }
        needsRender := !sv.IsReadOnly()
        if !needsRender {
                if sv.image == nil {
                        needsRender = true
                } else {
                        sz := sv.image.Bounds().Size()
                        if sz != sv.prevSize || sz == (image.Point{}) {
                                needsRender = true
                        }
                }
        }
        if needsRender {
                sv.renderSVG()
        }
        r := sv.Geom.ContentBBox
        sp := sv.Geom.ScrollOffset()
        sv.Scene.Painter.DrawImage(sv.image, r, sp, draw.Over)
}

func (sv *SVG) MakeToolbar(p *tree.Plan) {
        tree.Add(p, func(w *Button) {
                w.SetText("Pan").SetIcon(icons.PanTool)
                w.SetTooltip("Toggle the ability to zoom and pan")
                w.OnClick(func(e events.Event) {
                        sv.SetReadOnly(!sv.IsReadOnly())
                        sv.Restyle()
                })
        })
        tree.Add(p, func(w *Separator) {})
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(sv.Open).SetIcon(icons.Open)
        })
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(sv.SaveSVG).SetIcon(icons.Save)
        })
        tree.Add(p, func(w *FuncButton) {
                w.SetFunc(sv.SaveImage).SetIcon(icons.Save)
        })
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "reflect"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/tree"
)

// Switch is a widget that can toggle between an on and off state.
// It can be displayed as a switch, chip, checkbox, radio button,
// or segmented button.
type Switch struct {
        Frame

        // Type is the styling type of switch.
        // It must be set using [Switch.SetType].
        Type SwitchTypes `set:"-"`

        // Text is the optional text of the switch.
        Text string

        // IconOn is the icon to use for the on, checked state of the switch.
        IconOn icons.Icon

        // Iconoff is the icon to use for the off, unchecked state of the switch.
        IconOff icons.Icon

        // IconIndeterminate is the icon to use for the indeterminate (unknown) state.
        IconIndeterminate icons.Icon
}

// SwitchTypes contains the different types of [Switch]es.
type SwitchTypes int32 //enums:enum -trim-prefix Switch -transform kebab

const (
        // SwitchSwitch indicates to display a switch as a switch (toggle slider).
        SwitchSwitch SwitchTypes = iota

        // SwitchChip indicates to display a switch as chip (like Material Design's
        // filter chip), which is typically only used in the context of [Switches].
        SwitchChip

        // SwitchCheckbox indicates to display a switch as a checkbox.
        SwitchCheckbox

        // SwitchRadioButton indicates to display a switch as a radio button.
        SwitchRadioButton

        // SwitchSegmentedButton indicates to display a segmented button, which is
        // typically only used in the context of [Switches].
        SwitchSegmentedButton
)

func (sw *Switch) WidgetValue() any { return sw.IsChecked() }

func (sw *Switch) SetWidgetValue(value any) error {
        b, err := reflectx.ToBool(value)
        if err != nil {
                return err
        }
        sw.SetChecked(b)
        return nil
}

func (sw *Switch) OnBind(value any, tags reflect.StructTag) {
        if d, ok := tags.Lookup("display"); ok {
                errors.Log(sw.Type.SetString(d))
                sw.SetType(sw.Type)
        }
}

func (sw *Switch) Init() {
        sw.Frame.Init()
        sw.Styler(func(s *styles.Style) {
                if !sw.IsReadOnly() {
                        s.SetAbilities(true, abilities.Activatable, abilities.Focusable, abilities.Hoverable, abilities.Checkable)
                        s.Cursor = cursors.Pointer
                }
                s.Text.Align = text.Start
                s.Text.AlignV = text.Center
                s.Padding.SetVertical(units.Dp(4))
                s.Padding.SetHorizontal(units.Dp(ConstantSpacing(4))) // needed for layout issues
                s.Border.Radius = styles.BorderRadiusSmall
                s.Gap.Zero()
                s.CenterAll()

                if sw.Type == SwitchChip {
                        if s.Is(states.Checked) {
                                s.Background = colors.Scheme.SurfaceVariant
                                s.Color = colors.Scheme.OnSurfaceVariant
                        } else if !s.Is(states.Focused) {
                                s.Border.Width.Set(units.Dp(1))
                        }
                }
                if sw.Type == SwitchSegmentedButton {
                        if !s.Is(states.Focused) {
                                s.Border.Width.Set(units.Dp(1))
                        }
                        if s.Is(states.Checked) {
                                s.Background = colors.Scheme.SurfaceVariant
                                s.Color = colors.Scheme.OnSurfaceVariant
                        }
                }

                if s.Is(states.Selected) {
                        s.Background = colors.Scheme.Select.Container
                }
        })

        sw.SendClickOnEnter()
        sw.OnFinal(events.Click, func(e events.Event) {
                if sw.IsReadOnly() {
                        return
                }
                sw.SetChecked(sw.IsChecked())
                if sw.Type == SwitchChip || sw.Type == SwitchSegmentedButton {
                        sw.updateStackTop() // must update here
                        sw.NeedsLayout()
                } else {
                        sw.NeedsRender()
                }
                sw.SendChange(e)
        })

        sw.Maker(func(p *tree.Plan) {
                if sw.IconOn == "" {
                        sw.IconOn = icons.ToggleOnFill // fallback
                }
                if sw.IconOff == "" {
                        sw.IconOff = icons.ToggleOff // fallback
                }

                tree.AddAt(p, "stack", func(w *Frame) {
                        w.Styler(func(s *styles.Style) {
                                s.Display = styles.Stacked
                                s.Gap.Zero()
                        })
                        w.Updater(func() {
                                sw.updateStackTop() // need to update here
                        })
                        w.Maker(func(p *tree.Plan) {
                                tree.AddAt(p, "icon-on", func(w *Icon) {
                                        w.Styler(func(s *styles.Style) {
                                                if sw.Type == SwitchChip {
                                                        s.Color = colors.Scheme.OnSurfaceVariant
                                                } else {
                                                        s.Color = colors.Scheme.Primary.Base
                                                }
                                                // switches need to be bigger
                                                if sw.Type == SwitchSwitch {
                                                        s.Min.Set(units.Em(2), units.Em(1.5))
                                                } else {
                                                        s.Min.Set(units.Em(1.5))
                                                }
                                        })
                                        w.Updater(func() {
                                                w.SetIcon(sw.IconOn)
                                        })
                                })
                                // same styles for off and indeterminate
                                iconStyle := func(s *styles.Style) {
                                        switch {
                                        case sw.Type == SwitchSwitch:
                                                // switches need to be bigger
                                                s.Min.Set(units.Em(2), units.Em(1.5))
                                        case sw.IconOff == icons.None && sw.IconIndeterminate == icons.None:
                                                s.Min.Zero() // nothing to render
                                        default:
                                                s.Min.Set(units.Em(1.5))
                                        }
                                }
                                tree.AddAt(p, "icon-off", func(w *Icon) {
                                        w.Styler(iconStyle)
                                        w.Updater(func() {
                                                w.SetIcon(sw.IconOff)
                                        })
                                })
                                tree.AddAt(p, "icon-indeterminate", func(w *Icon) {
                                        w.Styler(iconStyle)
                                        w.Updater(func() {
                                                w.SetIcon(sw.IconIndeterminate)
                                        })
                                })
                        })
                })

                if sw.Text != "" {
                        tree.AddAt(p, "space", func(w *Space) {
                                w.Styler(func(s *styles.Style) {
                                        s.Min.X.Ch(0.1)
                                })
                        })
                        tree.AddAt(p, "text", func(w *Text) {
                                w.Styler(func(s *styles.Style) {
                                        s.SetNonSelectable()
                                        s.SetTextWrap(false)
                                        s.FillMargin = false
                                })
                                w.Updater(func() {
                                        w.SetText(sw.Text)
                                })
                        })
                }
        })
}

// IsChecked returns whether the switch is checked.
func (sw *Switch) IsChecked() bool {
        return sw.StateIs(states.Checked)
}

// SetChecked sets whether the switch it checked.
func (sw *Switch) SetChecked(on bool) *Switch {
        sw.SetState(on, states.Checked)
        sw.SetState(false, states.Indeterminate)
        return sw
}

// updateStackTop updates the [Frame.StackTop] of the stack in the switch
// according to the current icon. It is called automatically to keep the
// switch up-to-date.
func (sw *Switch) updateStackTop() {
        st, ok := sw.ChildByName("stack", 0).(*Frame)
        if !ok {
                return
        }
        switch {
        case sw.StateIs(states.Indeterminate):
                st.StackTop = 2
        case sw.IsChecked():
                st.StackTop = 0
        default:
                if sw.Type == SwitchChip {
                        // chips render no icon when off
                        st.StackTop = -1
                        return
                }
                st.StackTop = 1
        }
}

// SetType sets the styling type of the switch.
func (sw *Switch) SetType(typ SwitchTypes) *Switch {
        sw.Type = typ
        sw.IconIndeterminate = icons.Blank
        switch sw.Type {
        case SwitchSwitch:
                // TODO: material has more advanced switches with a checkmark
                // if they are turned on; we could implement that at some point
                sw.IconOn = icons.ToggleOnFill
                sw.IconOff = icons.ToggleOff
                sw.IconIndeterminate = icons.ToggleMid
        case SwitchChip, SwitchSegmentedButton:
                sw.IconOn = icons.Check
                sw.IconOff = icons.None
                sw.IconIndeterminate = icons.None
        case SwitchCheckbox:
                sw.IconOn = icons.CheckBoxFill
                sw.IconOff = icons.CheckBoxOutlineBlank
                sw.IconIndeterminate = icons.IndeterminateCheckBox
        case SwitchRadioButton:
                sw.IconOn = icons.RadioButtonChecked
                sw.IconOff = icons.RadioButtonUnchecked
                sw.IconIndeterminate = icons.RadioButtonPartial
        }
        return sw
}

func (sw *Switch) Render() {
        sw.updateStackTop() // important: make sure we're always up-to-date on render
        st, ok := sw.ChildByName("stack", 0).(*Frame)
        if ok {
                st.UpdateStackedVisibility()
        }
        sw.WidgetBase.Render()
}

// Copyright (c) 2019, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "reflect"
        "slices"
        "strconv"
        "strings"
        "unicode"

        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

// Switches is a widget for containing a set of [Switch]es.
// It can optionally enforce mutual exclusivity (ie: radio buttons)
// through the [Switches.Mutex] field. It supports binding to
// [enums.Enum] and [enums.BitFlag] values with appropriate properties
// automatically set.
type Switches struct {
        Frame

        // Type is the type of switches that will be made.
        Type SwitchTypes

        // Items are the items displayed to the user.
        Items []SwitchItem

        // Mutex is whether to make the items mutually exclusive
        // (checking one turns off all the others).
        Mutex bool

        // AllowNone is whether to allow the user to deselect all items.
        // It is on by default.
        AllowNone bool `default:"true"`

        // selectedIndexes are the indexes in [Switches.Items] of the currently
        // selected switch items.
        selectedIndexes []int

        // bitFlagValue is the associated bit flag value if non-nil (for [Value]).
        bitFlagValue enums.BitFlagSetter
}

// SwitchItem contains the properties of one item in a [Switches].
type SwitchItem struct {

        // Value is the underlying value the switch item represents.
        Value any

        // Text is the text displayed to the user for this item.
        // If it is empty, then [labels.ToLabel] of [SwitchItem.Value]
        // is used instead.
        Text string

        // Tooltip is the tooltip displayed to the user for this item.
        Tooltip string
}

// getText returns the effective text for this switch item.
// If [SwitchItem.Text] is set, it returns that. Otherwise,
// it returns [labels.ToLabel] of [SwitchItem.Value].
func (si *SwitchItem) getText() string {
        if si.Text != "" {
                return si.Text
        }
        if si.Value == nil {
                return ""
        }
        return labels.ToLabel(si.Value)
}

func (sw *Switches) WidgetValue() any {
        if sw.bitFlagValue != nil {
                sw.bitFlagFromSelected(sw.bitFlagValue)
                // We must return a non-pointer value to prevent [ResetWidgetValue]
                // from clearing the bit flag value (since we only ever have one
                // total pointer to it, so it is uniquely vulnerable to being destroyed).
                return reflectx.Underlying(reflect.ValueOf(sw.bitFlagValue)).Interface()
        }
        item := sw.SelectedItem()
        if item == nil {
                return nil
        }
        return item.Value
}

func (sw *Switches) SetWidgetValue(value any) error {
        up := reflectx.UnderlyingPointer(reflect.ValueOf(value))
        if bf, ok := up.Interface().(enums.BitFlagSetter); ok {
                sw.selectFromBitFlag(bf)
                return nil
        }
        return sw.SelectValue(up.Elem().Interface())
}

func (sw *Switches) OnBind(value any, tags reflect.StructTag) {
        if e, ok := value.(enums.Enum); ok {
                sw.SetEnum(e).SetType(SwitchSegmentedButton).SetMutex(true)
        }
        if bf, ok := value.(enums.BitFlagSetter); ok {
                sw.bitFlagValue = bf
                sw.SetType(SwitchChip).SetMutex(false)
        } else {
                sw.bitFlagValue = nil
                sw.AllowNone = false
        }
}

func (sw *Switches) Init() {
        sw.Frame.Init()
        sw.AllowNone = true
        sw.Styler(func(s *styles.Style) {
                s.Padding.Set(units.Dp(ConstantSpacing(2)))
                s.Margin.Set(units.Dp(ConstantSpacing(2)))
                if sw.Type == SwitchSegmentedButton {
                        s.Gap.Zero()
                } else {
                        s.Wrap = true
                }
        })
        sw.FinalStyler(func(s *styles.Style) {
                if s.Direction != styles.Row {
                        // if we wrap, it just goes in the x direction
                        s.Wrap = false
                }
        })

        sw.Maker(func(p *tree.Plan) {
                for i, item := range sw.Items {
                        tree.AddAt(p, strconv.Itoa(i), func(w *Switch) {
                                w.OnChange(func(e events.Event) {
                                        if w.IsChecked() {
                                                if sw.Mutex {
                                                        sw.selectedIndexes = []int{i}
                                                } else {
                                                        sw.selectedIndexes = append(sw.selectedIndexes, i)
                                                }
                                        } else if sw.AllowNone || len(sw.selectedIndexes) > 1 {
                                                sw.selectedIndexes = slices.DeleteFunc(sw.selectedIndexes, func(v int) bool { return v == i })
                                        }
                                        sw.SendChange(e)
                                        sw.UpdateRender()
                                })
                                w.Styler(func(s *styles.Style) {
                                        if sw.Type != SwitchSegmentedButton {
                                                return
                                        }
                                        ip := w.IndexInParent()
                                        brf := styles.BorderRadiusFull.Top
                                        ps := &sw.Styles
                                        if ip == 0 {
                                                if ps.Direction == styles.Row {
                                                        s.Border.Radius.Set(brf, units.Zero(), units.Zero(), brf)
                                                } else {
                                                        s.Border.Radius.Set(brf, brf, units.Zero(), units.Zero())
                                                }
                                        } else if ip == sw.NumChildren()-1 {
                                                if ps.Direction == styles.Row {
                                                        if !s.Is(states.Focused) {
                                                                s.Border.Width.SetLeft(units.Zero())
                                                                s.MaxBorder.Width = s.Border.Width
                                                        }
                                                        s.Border.Radius.Set(units.Zero(), brf, brf, units.Zero())
                                                } else {
                                                        if !s.Is(states.Focused) {
                                                                s.Border.Width.SetTop(units.Zero())
                                                                s.MaxBorder.Width = s.Border.Width
                                                        }
                                                        s.Border.Radius.Set(units.Zero(), units.Zero(), brf, brf)
                                                }
                                        } else {
                                                if !s.Is(states.Focused) {
                                                        if ps.Direction == styles.Row {
                                                                s.Border.Width.SetLeft(units.Zero())
                                                        } else {
                                                                s.Border.Width.SetTop(units.Zero())
                                                        }
                                                        s.MaxBorder.Width = s.Border.Width
                                                }
                                                s.Border.Radius.Zero()
                                        }
                                })
                                w.Updater(func() {
                                        w.SetType(sw.Type).SetText(item.getText()).SetTooltip(item.Tooltip)
                                        if sw.Type == SwitchSegmentedButton && sw.Styles.Direction == styles.Column {
                                                // need a blank icon to create a cohesive segmented button
                                                w.SetIconOff(icons.Blank).SetIconIndeterminate(icons.Blank)
                                        }
                                        if !w.StateIs(states.Indeterminate) {
                                                w.SetChecked(slices.Contains(sw.selectedIndexes, i))
                                        }
                                })
                        })
                }
        })
}

// SelectedItem returns the first selected (checked) switch item. It is only
// useful when [Switches.Mutex] is true; if it is not, use [Switches.SelectedItems].
// If no switches are selected, it returns nil.
func (sw *Switches) SelectedItem() *SwitchItem {
        if len(sw.selectedIndexes) == 0 {
                return nil
        }
        return &sw.Items[sw.selectedIndexes[0]]
}

// SelectedItems returns all of the currently selected (checked) switch items.
// If [Switches.Mutex] is true, you should use [Switches.SelectedItem] instead.
func (sw *Switches) SelectedItems() []SwitchItem {
        res := []SwitchItem{}
        for _, i := range sw.selectedIndexes {
                res = append(res, sw.Items[i])
        }
        return res
}

// SelectValue sets the item with the given [SwitchItem.Value]
// to be the only selected item.
func (sw *Switches) SelectValue(value any) error {
        for i, item := range sw.Items {
                if item.Value == value {
                        sw.selectedIndexes = []int{i}
                        return nil
                }
        }
        return fmt.Errorf("Switches.SelectValue: item not found: (value: %v, items: %v)", value, sw.Items)
}

// SetStrings sets the [Switches.Items] from the given strings.
func (sw *Switches) SetStrings(ss ...string) *Switches {
        sw.Items = make([]SwitchItem, len(ss))
        for i, s := range ss {
                sw.Items[i] = SwitchItem{Value: s}
        }
        return sw
}

// SetEnums sets the [Switches.Items] from the given enums.
func (sw *Switches) SetEnums(es ...enums.Enum) *Switches {
        sw.Items = make([]SwitchItem, len(es))
        for i, enum := range es {
                str := ""
                if bf, ok := enum.(enums.BitFlag); ok {
                        str = bf.BitIndexString()
                } else {
                        str = enum.String()
                }
                lbl := strcase.ToSentence(str)
                desc := enum.Desc()
                // If the documentation does not start with the transformed name, but it does
                // start with an uppercase letter, then we assume that the first word of the
                // documentation is the correct untransformed name. This fixes
                // https://github.com/cogentcore/core/issues/774 (also for Chooser).
                if !strings.HasPrefix(desc, str) && len(desc) > 0 && unicode.IsUpper(rune(desc[0])) {
                        str, _, _ = strings.Cut(desc, " ")
                }
                tip := types.FormatDoc(desc, str, lbl)
                sw.Items[i] = SwitchItem{Value: enum, Text: lbl, Tooltip: tip}
        }
        return sw
}

// SetEnum sets the [Switches.Items] from the [enums.Enum.Values] of the given enum.
func (sw *Switches) SetEnum(enum enums.Enum) *Switches {
        return sw.SetEnums(enum.Values()...)
}

// selectFromBitFlag sets which switches are selected based on the given bit flag value.
func (sw *Switches) selectFromBitFlag(bitflag enums.BitFlagSetter) {
        values := bitflag.Values()
        sw.selectedIndexes = []int{}
        for i, value := range values {
                if bitflag.HasFlag(value.(enums.BitFlag)) {
                        sw.selectedIndexes = append(sw.selectedIndexes, i)
                }
        }
}

// bitFlagFromSelected sets the given bit flag value based on which switches are selected.
func (sw *Switches) bitFlagFromSelected(bitflag enums.BitFlagSetter) {
        bitflag.SetInt64(0)
        values := bitflag.Values()
        for _, i := range sw.selectedIndexes {
                bitflag.SetFlag(true, values[i].(enums.BitFlag))
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "log/slog"
        "reflect"
        "strconv"
        "strings"

        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

// todo:
// * search option, both as a search field and as simple type-to-search

// Table represents a slice of structs as a table, where the fields are
// the columns and the elements are the rows. It is a full-featured editor with
// multiple-selection, cut-and-paste, and drag-and-drop.
// Use [ListBase.BindSelect] to make the table designed for item selection.
type Table struct {
        ListBase

        // TableStyler is an optional styling function for table items.
        TableStyler TableStyler `copier:"-" json:"-" xml:"-"`

        // SelectedField is the current selection field; initially select value in this field.
        SelectedField string `copier:"-" display:"-" json:"-" xml:"-"`

        // sortIndex is the current sort index.
        sortIndex int

        // sortDescending is whether the current sort order is descending.
        sortDescending bool

        // visibleFields are the visible fields.
        visibleFields []reflect.StructField

        // numVisibleFields is the number of visible fields.
        numVisibleFields int

        // headerWidths has the number of characters in each header, per visibleFields.
        headerWidths []int

        // colMaxWidths records maximum width in chars of string type fields.
        colMaxWidths []int

        header *Frame
}

// TableStyler is a styling function for custom styling and
// configuration of elements in the table.
type TableStyler func(w Widget, s *styles.Style, row, col int)

func (tb *Table) Init() {
        tb.ListBase.Init()
        tb.AddContextMenu(tb.contextMenu)
        tb.sortIndex = -1

        tb.Makers.Normal[0] = func(p *tree.Plan) { // TODO: reduce redundancy with ListBase Maker
                svi := tb.This.(Lister)
                svi.UpdateSliceSize()

                tb.SortSlice()

                scrollTo := -1
                if tb.SelectedField != "" && tb.SelectedValue != nil {
                        tb.SelectedIndex, _ = structSliceIndexByValue(tb.Slice, tb.SelectedField, tb.SelectedValue)
                        tb.SelectedField = ""
                        tb.SelectedValue = nil
                        tb.InitSelectedIndex = -1
                        scrollTo = tb.SelectedIndex
                } else if tb.InitSelectedIndex >= 0 {
                        tb.SelectedIndex = tb.InitSelectedIndex
                        tb.InitSelectedIndex = -1
                        scrollTo = tb.SelectedIndex
                }
                if scrollTo >= 0 {
                        tb.ScrollToIndex(scrollTo)
                }
                tb.UpdateStartIndex()

                tb.Updater(func() {
                        tb.UpdateStartIndex()
                })

                tb.makeHeader(p)
                tb.MakeGrid(p, func(p *tree.Plan) {
                        for i := 0; i < tb.VisibleRows; i++ {
                                svi.MakeRow(p, i)
                        }
                })
        }
}

// StyleValue performs additional value widget styling
func (tb *Table) StyleValue(w Widget, s *styles.Style, row, col int) {
        hw := float32(tb.headerWidths[col])
        if col == tb.sortIndex {
                hw += 6
        }
        if len(tb.colMaxWidths) > col {
                hw = max(float32(tb.colMaxWidths[col]), hw)
        }
        hv := units.Ch(hw)
        s.Min.X.Value = max(s.Min.X.Value, hv.Convert(s.Min.X.Unit, &s.UnitContext).Value)
        s.SetTextWrap(false)
}

// SetSlice sets the source slice that we are viewing.
func (tb *Table) SetSlice(sl any) *Table {
        if reflectx.IsNil(reflect.ValueOf(sl)) {
                tb.Slice = nil
                return tb
        }
        if tb.Slice == sl {
                tb.MakeIter = 0
                return tb
        }

        slpTyp := reflect.TypeOf(sl)
        if slpTyp.Kind() != reflect.Pointer {
                slog.Error("Table requires that you pass a pointer to a slice of struct elements, but type is not a Ptr", "type", slpTyp)
                return tb
        }
        if slpTyp.Elem().Kind() != reflect.Slice {
                slog.Error("Table requires that you pass a pointer to a slice of struct elements, but ptr doesn't point to a slice", "type", slpTyp.Elem())
                return tb
        }
        eltyp := reflectx.NonPointerType(reflectx.SliceElementType(sl))
        if eltyp.Kind() != reflect.Struct {
                slog.Error("Table requires that you pass a slice of struct elements, but type is not a Struct", "type", eltyp.String())
                return tb
        }

        tb.Slice = sl
        tb.sliceUnderlying = reflectx.Underlying(reflect.ValueOf(tb.Slice))
        tb.elementValue = reflectx.Underlying(reflectx.SliceElementValue(sl))
        tb.SetSliceBase()
        tb.cacheVisibleFields()
        return tb
}

// cacheVisibleFields caches the visible struct fields.
func (tb *Table) cacheVisibleFields() {
        tb.visibleFields = make([]reflect.StructField, 0)
        shouldShow := func(field reflect.StructField) bool {
                tvtag := field.Tag.Get("table")
                switch {
                case tvtag == "+":
                        return true
                case tvtag == "-":
                        return false
                case tvtag == "-select" && tb.IsReadOnly():
                        return false
                case tvtag == "-edit" && !tb.IsReadOnly():
                        return false
                default:
                        return field.Tag.Get("display") != "-"
                }
        }

        reflectx.WalkFields(tb.elementValue,
                func(parent reflect.Value, field reflect.StructField, value reflect.Value) bool {
                        return shouldShow(field)
                },
                func(parent reflect.Value, parentField *reflect.StructField, field reflect.StructField, value reflect.Value) {
                        if parentField != nil {
                                field.Index = append(parentField.Index, field.Index...)
                        }
                        tb.visibleFields = append(tb.visibleFields, field)
                })
        tb.numVisibleFields = len(tb.visibleFields)
        tb.headerWidths = make([]int, tb.numVisibleFields)
        tb.colMaxWidths = make([]int, tb.numVisibleFields)
}

func (tb *Table) UpdateMaxWidths() {
        if tb.SliceSize == 0 {
                return
        }
        updated := false
        for fli := 0; fli < tb.numVisibleFields; fli++ {
                field := tb.visibleFields[fli]
                val := tb.sliceElementValue(0)
                fval := val.FieldByIndex(field.Index)
                isString := fval.Type().Kind() == reflect.String && fval.Type() != reflect.TypeFor[icons.Icon]()
                if !isString {
                        tb.colMaxWidths[fli] = 0
                        continue
                }
                mxw := 0
                for rw := 0; rw < tb.SliceSize; rw++ {
                        val := tb.sliceElementValue(rw)
                        str := reflectx.ToString(val.FieldByIndex(field.Index).Interface())
                        mxw = max(mxw, len(str))
                }
                if mxw != tb.colMaxWidths[fli] {
                        tb.colMaxWidths[fli] = mxw
                        updated = true
                }
        }
        if updated {
                tb.Update()
        }
}

func (tb *Table) makeHeader(p *tree.Plan) {
        tree.AddAt(p, "header", func(w *Frame) {
                tb.header = w
                ToolbarStyles(w)
                w.FinalStyler(func(s *styles.Style) {
                        s.Padding.Zero()
                        s.Grow.Set(0, 0)
                        s.Gap.Set(units.Em(0.5)) // matches grid default
                })
                w.Maker(func(p *tree.Plan) {
                        if tb.ShowIndexes {
                                tree.AddAt(p, "_head-index", func(w *Text) {
                                        w.SetType(TextBodyMedium)
                                        w.Styler(func(s *styles.Style) {
                                                s.Align.Self = styles.Center
                                        })
                                        w.SetText("Index")
                                })
                        }
                        for fli := 0; fli < tb.numVisibleFields; fli++ {
                                field := tb.visibleFields[fli]
                                tree.AddAt(p, "head-"+field.Name, func(w *Button) {
                                        w.SetType(ButtonAction)
                                        w.Styler(func(s *styles.Style) {
                                                s.Justify.Content = styles.Start
                                        })
                                        w.OnClick(func(e events.Event) {
                                                tb.SortColumn(fli)
                                        })
                                        w.Updater(func() {
                                                htxt := ""
                                                if lbl, ok := field.Tag.Lookup("label"); ok {
                                                        htxt = lbl
                                                } else {
                                                        htxt = strcase.ToSentence(field.Name)
                                                }
                                                w.SetText(htxt)
                                                w.Tooltip = htxt + " (click to sort by)"
                                                doc, ok := types.GetDoc(reflect.Value{}, tb.elementValue, field, htxt)
                                                if ok && doc != "" {
                                                        w.Tooltip += ": " + doc
                                                }
                                                tb.headerWidths[fli] = len(htxt)
                                                if fli == tb.sortIndex {
                                                        if tb.sortDescending {
                                                                w.SetIndicator(icons.KeyboardArrowDown)
                                                        } else {
                                                                w.SetIndicator(icons.KeyboardArrowUp)
                                                        }
                                                } else {
                                                        w.SetIndicator(icons.Blank)
                                                }
                                        })
                                })
                        }
                })
        })
}

// RowWidgetNs returns number of widgets per row and offset for index label
func (tb *Table) RowWidgetNs() (nWidgPerRow, idxOff int) {
        nWidgPerRow = 1 + tb.numVisibleFields
        idxOff = 1
        if !tb.ShowIndexes {
                nWidgPerRow -= 1
                idxOff = 0
        }
        return
}

func (tb *Table) MakeRow(p *tree.Plan, i int) {
        svi := tb.This.(Lister)
        si, _, invis := svi.SliceIndex(i)
        itxt := strconv.Itoa(i)
        val := tb.sliceElementValue(si)
        // stru := val.Interface()

        if tb.ShowIndexes {
                tb.MakeGridIndex(p, i, si, itxt, invis)
        }

        for fli := 0; fli < tb.numVisibleFields; fli++ {
                field := tb.visibleFields[fli]
                uvp := reflectx.UnderlyingPointer(val.FieldByIndex(field.Index))
                uv := uvp.Elem()
                valnm := fmt.Sprintf("value-%d-%s-%s", fli, itxt, reflectx.ShortTypeName(field.Type))
                tags := field.Tag
                if uv.Kind() == reflect.Slice || uv.Kind() == reflect.Map {
                        ni := reflect.StructTag(`display:"no-inline"`)
                        if tags == "" {
                                tags += " " + ni
                        } else {
                                tags = ni
                        }
                }
                readOnlyTag := tags.Get("edit") == "-"

                tree.AddNew(p, valnm, func() Value {
                        return NewValue(uvp.Interface(), tags)
                }, func(w Value) {
                        wb := w.AsWidget()
                        tb.MakeValue(w, i)
                        w.AsTree().SetProperty(ListColProperty, fli)
                        if !tb.IsReadOnly() && !readOnlyTag {
                                wb.OnChange(func(e events.Event) {
                                        tb.This.(Lister).UpdateMaxWidths()
                                        tb.SendChange()
                                })
                        }
                        wb.Updater(func() {
                                si, vi, invis := svi.SliceIndex(i)
                                val := tb.sliceElementValue(vi)
                                upv := reflectx.UnderlyingPointer(val.FieldByIndex(field.Index))
                                Bind(upv.Interface(), w)

                                vc := tb.ValueTitle + "[" + strconv.Itoa(si) + "]"
                                if !invis {
                                        if lblr, ok := tb.Slice.(labels.SliceLabeler); ok {
                                                slbl := lblr.ElemLabel(si)
                                                if slbl != "" {
                                                        vc = joinValueTitle(tb.ValueTitle, slbl)
                                                }
                                        }
                                }
                                wb.ValueTitle = vc + " (" + wb.ValueTitle + ")"
                                wb.SetReadOnly(tb.IsReadOnly() || readOnlyTag)
                                wb.SetState(invis, states.Invisible)
                                if svi.HasStyler() {
                                        w.Style()
                                }
                                if invis {
                                        wb.SetSelected(false)
                                }
                        })
                })
        }
}

func (tb *Table) HasStyler() bool {
        return tb.TableStyler != nil
}

func (tb *Table) StyleRow(w Widget, idx, fidx int) {
        if tb.TableStyler != nil {
                tb.TableStyler(w, &w.AsWidget().Styles, idx, fidx)
        }
}

// NewAt inserts a new blank element at the given index in the slice.
// -1 indicates to insert the element at the end.
func (tb *Table) NewAt(idx int) {
        tb.NewAtSelect(idx)
        reflectx.SliceNewAt(tb.Slice, idx)
        if idx < 0 {
                idx = tb.SliceSize
        }

        tb.This.(Lister).UpdateSliceSize()
        tb.SelectIndexEvent(idx, events.SelectOne)
        tb.UpdateChange()
        tb.IndexGrabFocus(idx)
}

// DeleteAt deletes the element at the given index from the slice.
func (tb *Table) DeleteAt(idx int) {
        if idx < 0 || idx >= tb.SliceSize {
                return
        }

        tb.DeleteAtSelect(idx)

        reflectx.SliceDeleteAt(tb.Slice, idx)

        tb.This.(Lister).UpdateSliceSize()
        tb.UpdateChange()
}

// SortSlice sorts the slice according to current settings.
func (tb *Table) SortSlice() {
        if tb.sortIndex < 0 || tb.sortIndex >= len(tb.visibleFields) {
                return
        }
        rawIndex := tb.visibleFields[tb.sortIndex].Index
        reflectx.StructSliceSort(tb.Slice, rawIndex, !tb.sortDescending)
}

// SortColumn sorts the slice for the given field index.
// It toggles between ascending and descending if already
// sorting on this field.
func (tb *Table) SortColumn(fieldIndex int) {
        sgh := tb.header
        _, idxOff := tb.RowWidgetNs()

        for fli := 0; fli < tb.numVisibleFields; fli++ {
                hdr := sgh.Child(idxOff + fli).(*Button)
                hdr.SetType(ButtonAction)
                if fli == fieldIndex {
                        if tb.sortIndex == fli {
                                tb.sortDescending = !tb.sortDescending
                        } else {
                                tb.sortDescending = false
                        }
                }
        }

        tb.sortIndex = fieldIndex
        tb.SortSlice()
        tb.Update()
}

// sortFieldName returns the name of the field being sorted, along with :up or
// :down depending on ascending or descending sorting.
func (tb *Table) sortFieldName() string {
        if tb.sortIndex >= 0 && tb.sortIndex < tb.numVisibleFields {
                nm := tb.visibleFields[tb.sortIndex].Name
                if tb.sortDescending {
                        nm += ":down"
                } else {
                        nm += ":up"
                }
                return nm
        }
        return ""
}

// setSortFieldName sets sorting to happen on given field and direction
// see [Table.sortFieldName] for details.
func (tb *Table) setSortFieldName(nm string) {
        if nm == "" {
                return
        }
        spnm := strings.Split(nm, ":")
        got := false
        for fli := 0; fli < tb.numVisibleFields; fli++ {
                fld := tb.visibleFields[fli]
                if fld.Name == spnm[0] {
                        got = true
                        // fmt.Println("sorting on:", fld.Name, fli, "from:", nm)
                        tb.sortIndex = fli
                }
        }
        if len(spnm) == 2 {
                if spnm[1] == "down" {
                        tb.sortDescending = true
                } else {
                        tb.sortDescending = false
                }
        }
        if got {
                tb.SortSlice()
        }
}

// RowGrabFocus grabs the focus for the first focusable widget in given row;
// returns that element or nil if not successful. Note: grid must have
// already rendered for focus to be grabbed!
func (tb *Table) RowGrabFocus(row int) *WidgetBase {
        if !tb.IsRowInBounds(row) || tb.InFocusGrab { // range check
                return nil
        }
        nWidgPerRow, idxOff := tb.RowWidgetNs()
        ridx := nWidgPerRow * row
        lg := tb.ListGrid
        // first check if we already have focus
        for fli := 0; fli < tb.numVisibleFields; fli++ {
                w := lg.Child(ridx + idxOff + fli).(Widget).AsWidget()
                if w.StateIs(states.Focused) || w.ContainsFocus() {
                        return w
                }
        }
        tb.InFocusGrab = true
        defer func() { tb.InFocusGrab = false }()
        for fli := 0; fli < tb.numVisibleFields; fli++ {
                w := lg.Child(ridx + idxOff + fli).(Widget).AsWidget()
                if w.CanFocus() {
                        w.SetFocus()
                        return w
                }
        }
        return nil
}

// selectFieldValue sets SelectedField and SelectedValue and attempts to find
// corresponding row, setting SelectedIndex and selecting row if found; returns
// true if found, false otherwise.
func (tb *Table) selectFieldValue(fld, val string) bool {
        tb.SelectedField = fld
        tb.SelectedValue = val
        if tb.SelectedField != "" && tb.SelectedValue != nil {
                idx, _ := structSliceIndexByValue(tb.Slice, tb.SelectedField, tb.SelectedValue)
                if idx >= 0 {
                        tb.ScrollToIndex(idx)
                        tb.updateSelectIndex(idx, true, events.SelectOne)
                        return true
                }
        }
        return false
}

// structSliceIndexByValue searches for first index that contains given value in field of
// given name.
func structSliceIndexByValue(structSlice any, fieldName string, fieldValue any) (int, error) {
        svnp := reflectx.NonPointerValue(reflect.ValueOf(structSlice))
        sz := svnp.Len()
        struTyp := reflectx.NonPointerType(reflect.TypeOf(structSlice).Elem().Elem())
        fld, ok := struTyp.FieldByName(fieldName)
        if !ok {
                err := fmt.Errorf("StructSliceRowByValue: field name: %v not found", fieldName)
                slog.Error(err.Error())
                return -1, err
        }
        fldIndex := fld.Index
        for idx := 0; idx < sz; idx++ {
                rval := reflectx.UnderlyingPointer(svnp.Index(idx))
                fval := rval.Elem().FieldByIndex(fldIndex)
                if !fval.IsValid() {
                        continue
                }
                if fval.Interface() == fieldValue {
                        return idx, nil
                }
        }
        return -1, nil
}

func (tb *Table) editIndex(idx int) {
        if idx < 0 || idx >= tb.sliceUnderlying.Len() {
                return
        }
        val := reflectx.UnderlyingPointer(tb.sliceUnderlying.Index(idx))
        stru := val.Interface()
        tynm := reflectx.NonPointerType(val.Type()).Name()
        lbl := labels.ToLabel(stru)
        if lbl != "" {
                tynm += ": " + lbl
        }
        d := NewBody(tynm)
        NewForm(d).SetStruct(stru).SetReadOnly(tb.IsReadOnly())
        d.AddBottomBar(func(bar *Frame) {
                d.AddCancel(bar)
                d.AddOK(bar)
        })
        d.RunWindowDialog(tb)
}

func (tb *Table) contextMenu(m *Scene) {
        e := NewButton(m)
        if tb.IsReadOnly() {
                e.SetText("View").SetIcon(icons.Visibility)
        } else {
                e.SetText("Edit").SetIcon(icons.Edit)
        }
        e.OnClick(func(e events.Event) {
                tb.editIndex(tb.SelectedIndex)
        })
}

// Header layout:

func (tb *Table) SizeFinal() {
        tb.ListBase.SizeFinal()
        sg := tb.ListGrid
        if sg == nil {
                return
        }
        sh := tb.header
        sh.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                sgb := AsWidget(sg.Child(i))
                gsz := &sgb.Geom.Size
                ksz := &cwb.Geom.Size
                ksz.Actual.Total.X = gsz.Actual.Total.X
                ksz.Actual.Content.X = gsz.Actual.Content.X
                ksz.Alloc.Total.X = gsz.Alloc.Total.X
                ksz.Alloc.Content.X = gsz.Alloc.Content.X
                return tree.Continue
        })
        gsz := &sg.Geom.Size
        ksz := &sh.Geom.Size
        ksz.Actual.Total.X = gsz.Actual.Total.X
        ksz.Actual.Content.X = gsz.Actual.Content.X
        ksz.Alloc.Total.X = gsz.Alloc.Total.X
        ksz.Alloc.Content.X = gsz.Alloc.Content.X
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "log/slog"
        "sync"

        "cogentcore.org/core/base/elide"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// Tabber is an interface for getting the parent Tabs of tab buttons.
type Tabber interface {
        // AsCoreTabs returns the underlying Tabs implementation.
        AsCoreTabs() *Tabs
}

// Tabs divide widgets into logical groups and give users the ability
// to freely navigate between them using tab buttons.
type Tabs struct {
        Frame

        // Type is the styling type of the tabs. If it is changed after
        // the tabs are first configured, Update needs to be called on
        // the tabs.
        Type TabTypes

        // NewTabButton is whether to show a new tab button at the end of the list of tabs.
        NewTabButton bool

        // maxChars is the maximum number of characters to include in the tab text.
        // It elides text that are longer than that.
        maxChars int

        // CloseIcon is the icon used for tab close buttons.
        // If it is "" or [icons.None], the tab is not closeable.
        // The default value is [icons.Close].
        // Only [FunctionalTabs] can be closed; all other types of
        // tabs will not render a close button and can not be closed.
        CloseIcon icons.Icon

        // mu is a mutex protecting updates to tabs. Tabs can be driven
        // programmatically and via user input so need extra protection.
        mu sync.Mutex

        tabs, frame *Frame
}

// TabTypes are the different styling types of tabs.
type TabTypes int32 //enums:enum

const (
        // StandardTabs indicates to render the standard type
        // of Material Design style tabs.
        StandardTabs TabTypes = iota

        // FunctionalTabs indicates to render functional tabs
        // like those in Google Chrome. These tabs take up less
        // space and are the only kind that can be closed.
        // They will also support being moved at some point.
        FunctionalTabs

        // NavigationAuto indicates to render the tabs as either
        // [NavigationBar] or [NavigationDrawer] if
        // [WidgetBase.SizeClass] is [SizeCompact] or not, respectively.
        // NavigationAuto should typically be used instead of one of the
        // specific navigation types for better cross-platform compatability.
        NavigationAuto

        // NavigationBar indicates to render the tabs as a
        // bottom navigation bar with text and icons.
        NavigationBar

        // NavigationDrawer indicates to render the tabs as a
        // side navigation drawer with text and icons.
        NavigationDrawer
)

// effective returns the effective tab type in the context
// of the given widget, handling [NavigationAuto] based on
// [WidgetBase.SizeClass].
func (tt TabTypes) effective(w Widget) TabTypes {
        if tt != NavigationAuto {
                return tt
        }
        switch w.AsWidget().SizeClass() {
        case SizeCompact:
                return NavigationBar
        default:
                return NavigationDrawer
        }
}

// isColumn returns whether the tabs should be arranged in a column.
func (tt TabTypes) isColumn() bool {
        return tt == NavigationDrawer
}

func (ts *Tabs) AsCoreTabs() *Tabs { return ts }

func (ts *Tabs) Init() {
        ts.Frame.Init()
        ts.maxChars = 16
        ts.CloseIcon = icons.Close
        ts.Styler(func(s *styles.Style) {
                s.Color = colors.Scheme.OnBackground
                s.Grow.Set(1, 1)
                if ts.Type.effective(ts).isColumn() {
                        s.Direction = styles.Row
                } else {
                        s.Direction = styles.Column
                }
        })

        ts.Maker(func(p *tree.Plan) {
                tree.AddAt(p, "tabs", func(w *Frame) {
                        ts.tabs = w
                        w.Styler(func(s *styles.Style) {
                                s.Overflow.Set(styles.OverflowHidden) // no scrollbars!
                                s.Gap.Set(units.Dp(4))

                                if ts.Type.effective(ts).isColumn() {
                                        s.Direction = styles.Column
                                        s.Grow.Set(0, 1)
                                } else {
                                        s.Direction = styles.Row
                                        s.Grow.Set(1, 0)
                                        s.Wrap = true
                                }
                        })
                        w.Updater(func() {
                                if !ts.NewTabButton {
                                        w.DeleteChildByName("new-tab-button")
                                        return
                                }
                                if w.ChildByName("new-tab-button") != nil {
                                        return
                                }
                                ntb := NewButton(w).SetType(ButtonAction).SetIcon(icons.Add)
                                ntb.SetTooltip("Add a new tab").SetName("new-tab-button")
                                ntb.OnClick(func(e events.Event) {
                                        ts.NewTab("New tab")
                                        ts.SelectTabIndex(ts.NumTabs() - 1)
                                })
                        })
                })
                tree.AddAt(p, "frame", func(w *Frame) {
                        ts.frame = w
                        w.LayoutStackTopOnly = true // key for allowing each tab to have its own size
                        w.Styler(func(s *styles.Style) {
                                s.Display = styles.Stacked
                                s.Min.Set(units.Dp(160), units.Dp(96))
                                s.Grow.Set(1, 1)
                        })
                })
                // frame comes before tabs in bottom navigation bar
                if ts.Type.effective(ts) == NavigationBar {
                        p.Children[0], p.Children[1] = p.Children[1], p.Children[0]
                }
        })
}

// NumTabs returns the number of tabs.
func (ts *Tabs) NumTabs() int {
        fr := ts.getFrame()
        if fr == nil {
                return 0
        }
        return len(fr.Children)
}

// CurrentTab returns currently selected tab and its index; returns nil if none.
func (ts *Tabs) CurrentTab() (Widget, int) {
        if ts.NumTabs() == 0 {
                return nil, -1
        }
        ts.mu.Lock()
        defer ts.mu.Unlock()
        fr := ts.getFrame()
        if fr.StackTop < 0 {
                return nil, -1
        }
        w := fr.Child(fr.StackTop).(Widget)
        return w, fr.StackTop
}

// NewTab adds a new tab with the given label and returns the resulting tab frame
// and associated tab button, which can be further customized as needed.
// It is the main end-user API for creating new tabs.
func (ts *Tabs) NewTab(label string) (*Frame, *Tab) {
        fr := ts.getFrame()
        idx := len(fr.Children)
        return ts.insertNewTab(label, idx)
}

// insertNewTab inserts a new tab with the given label at the given index position
// within the list of tabs and returns the resulting tab frame and button.
func (ts *Tabs) insertNewTab(label string, idx int) (*Frame, *Tab) {
        tfr := ts.getFrame()
        alreadyExists := tfr.ChildByName(label) != nil
        frame := NewFrame()
        tfr.InsertChild(frame, idx)
        frame.SetName(label)
        frame.Styler(func(s *styles.Style) {
                // tab frames must scroll independently and grow
                s.Overflow.Set(styles.OverflowAuto)
                s.Grow.Set(1, 1)
                s.Direction = styles.Column
        })
        button := ts.insertTabButtonAt(label, idx)
        if alreadyExists {
                tree.SetUniqueName(frame)  // prevent duplicate names
                button.SetName(frame.Name) // must be the same name
        }
        ts.Update()
        return frame, button
}

// insertTabButtonAt inserts just the tab button at given index, after the panel has
// already been added to the frame; assumed to be wrapped in update. Generally
// for internal use only.
func (ts *Tabs) insertTabButtonAt(label string, idx int) *Tab {
        tb := ts.getTabs()
        tab := tree.New[Tab]()
        tb.InsertChild(tab, idx)
        tab.SetName(label)
        tab.SetText(label).SetType(ts.Type).SetCloseIcon(ts.CloseIcon).SetTooltip(label)
        tab.maxChars = ts.maxChars
        tab.OnClick(func(e events.Event) {
                ts.SelectTabByName(tab.Name)
        })
        fr := ts.getFrame()
        if len(fr.Children) == 1 {
                fr.StackTop = 0
                tab.SetSelected(true)
                // } else {
                //         frame.SetState(true, states.Invisible) // new tab is invisible until selected
        }
        return tab
}

// tabAtIndex returns content frame and tab button at given index, nil if
// index out of range (emits log message).
func (ts *Tabs) tabAtIndex(idx int) (*Frame, *Tab) {
        ts.mu.Lock()
        defer ts.mu.Unlock()

        fr := ts.getFrame()
        tb := ts.getTabs()
        sz := len(fr.Children)
        if idx < 0 || idx >= sz {
                slog.Error("Tabs: index out of range for number of tabs", "index", idx, "numTabs", sz)
                return nil, nil
        }
        tab := tb.Child(idx).(*Tab)
        frame := fr.Child(idx).(*Frame)
        return frame, tab
}

// SelectTabIndex selects the tab at the given index, returning it or nil.
// This is the final tab selection path.
func (ts *Tabs) SelectTabIndex(idx int) *Frame {
        frame, tab := ts.tabAtIndex(idx)
        if frame == nil {
                return nil
        }
        fr := ts.getFrame()
        if fr.StackTop == idx {
                return frame
        }
        ts.mu.Lock()
        ts.unselectOtherTabs(idx)
        tab.SetSelected(true)
        fr.StackTop = idx
        fr.Update()
        frame.DeferShown()
        ts.mu.Unlock()
        return frame
}

// TabByName returns the tab [Frame] with the given widget name
// (nil if not found). The widget name is the original full tab label,
// prior to any eliding.
func (ts *Tabs) TabByName(name string) *Frame {
        ts.mu.Lock()
        defer ts.mu.Unlock()
        fr := ts.getFrame()
        frame, _ := fr.ChildByName(name).(*Frame)
        return frame
}

// tabIndexByName returns the tab index for the given tab widget name
// and -1 if it can not be found.
// The widget name is the original full tab label, prior to any eliding.
func (ts *Tabs) tabIndexByName(name string) int {
        ts.mu.Lock()
        defer ts.mu.Unlock()

        tb := ts.getTabs()
        tab := tb.ChildByName(name)
        if tab == nil {
                return -1
        }
        return tab.AsTree().IndexInParent()
}

// SelectTabByName selects the tab by widget name, returning it.
// The widget name is the original full tab label, prior to any eliding.
func (ts *Tabs) SelectTabByName(name string) *Frame {
        idx := ts.tabIndexByName(name)
        if idx < 0 {
                return nil
        }
        ts.SelectTabIndex(idx)
        fr := ts.getFrame()
        return fr.Child(idx).(*Frame)
}

// RecycleTab returns a tab with the given name, first by looking for an existing one,
// and if not found, making a new one. It returns the frame for the tab.
func (ts *Tabs) RecycleTab(name string) *Frame {
        frame := ts.TabByName(name)
        if frame == nil {
                frame, _ = ts.NewTab(name)
        }
        ts.SelectTabByName(name)
        return frame
}

// RecycleTabWidget returns a tab with the given widget type in the tab frame,
// first by looking for an existing one with the given name, and if not found,
// making and configuring a new one. It returns the resulting widget.
func RecycleTabWidget[T tree.NodeValue](ts *Tabs, name string) *T {
        fr := ts.RecycleTab(name)
        if fr.HasChildren() {
                return any(fr.Child(0)).(*T)
        }
        w := tree.New[T](fr)
        any(w).(Widget).AsWidget().UpdateWidget()
        return w
}

// deleteTabIndex deletes the tab at the given index, returning whether it was successful.
func (ts *Tabs) deleteTabIndex(idx int) bool {
        frame, _ := ts.tabAtIndex(idx)
        if frame == nil {
                return false
        }

        ts.mu.Lock()
        fr := ts.getFrame()
        sz := len(fr.Children)
        tb := ts.getTabs()
        nidx := -1
        if fr.StackTop == idx {
                if idx > 0 {
                        nidx = idx - 1
                } else if idx < sz-1 {
                        nidx = idx
                }
        }
        // if we didn't delete the current tab and have at least one
        // other tab, we go to the next tab over
        if nidx < 0 && ts.NumTabs() > 1 {
                nidx = max(idx-1, 0)
        }
        fr.DeleteChildAt(idx)
        tb.DeleteChildAt(idx)
        ts.mu.Unlock()

        if nidx >= 0 {
                ts.SelectTabIndex(nidx)
        }
        ts.NeedsLayout()
        return true
}

// getTabs returns the [Frame] containing the tabs (the first element within us).
// It configures the [Tabs] if necessary.
func (ts *Tabs) getTabs() *Frame {
        if ts.tabs == nil {
                ts.UpdateWidget()
        }
        return ts.tabs
}

// Frame returns the stacked [Frame] (the second element within us).
// It configures the Tabs if necessary.
func (ts *Tabs) getFrame() *Frame {
        if ts.frame == nil {
                ts.UpdateWidget()
        }
        return ts.frame
}

// unselectOtherTabs turns off all the tabs except given one
func (ts *Tabs) unselectOtherTabs(idx int) {
        sz := ts.NumTabs()
        tbs := ts.getTabs()
        for i := 0; i < sz; i++ {
                if i == idx {
                        continue
                }
                tb := tbs.Child(i).(*Tab)
                if tb.StateIs(states.Selected) {
                        tb.SetSelected(false)
                }
        }
}

// Tab is a tab button that contains one or more of a label, an icon,
// and a close icon. Tabs should be made using the [Tabs.NewTab] function.
type Tab struct { //core:no-new
        Frame

        // Type is the styling type of the tab. This property
        // must be set on the parent [Tabs] for it to work correctly.
        Type TabTypes

        // Text is the text for the tab. If it is blank, no text is shown.
        // Text is never shown for [NavigationRail] tabs.
        Text string

        // Icon is the icon for the tab.
        // If it is "" or [icons.None], no icon is shown.
        Icon icons.Icon

        // CloseIcon is the icon used as a close button for the tab.
        // If it is "" or [icons.None], the tab is not closeable.
        // The default value is [icons.Close].
        // Only [FunctionalTabs] can be closed; all other types of
        // tabs will not render a close button and can not be closed.
        CloseIcon icons.Icon

        // TODO(kai): replace this with general text overflow property (#778)

        // maxChars is the maximum number of characters to include in tab text.
        // It elides text that is longer than that.
        maxChars int
}

func (tb *Tab) Init() {
        tb.Frame.Init()
        tb.maxChars = 16
        tb.CloseIcon = icons.Close
        tb.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Activatable, abilities.Focusable, abilities.Hoverable)

                if !tb.IsReadOnly() {
                        s.Cursor = cursors.Pointer
                }

                if tb.Type.effective(tb).isColumn() {
                        s.Grow.X = 1
                        s.Border.Radius = styles.BorderRadiusFull
                        s.Padding.Set(units.Dp(16))
                } else {
                        s.Border.Radius = styles.BorderRadiusSmall
                        s.Padding.Set(units.Dp(10))
                }

                s.Gap.Zero()
                s.Align.Content = styles.Center
                s.Align.Items = styles.Center

                if tb.StateIs(states.Selected) {
                        s.Color = colors.Scheme.Select.OnContainer
                } else {
                        s.Color = colors.Scheme.OnSurfaceVariant
                        if tb.Type.effective(tb) == FunctionalTabs {
                                s.Background = colors.Scheme.SurfaceContainer
                        }
                }
        })

        tb.SendClickOnEnter()

        tb.Maker(func(p *tree.Plan) {
                if tb.maxChars > 0 { // TODO: find a better time to do this?
                        tb.Text = elide.Middle(tb.Text, tb.maxChars)
                }

                if tb.Icon.IsSet() {
                        tree.AddAt(p, "icon", func(w *Icon) {
                                w.Styler(func(s *styles.Style) {
                                        s.Font.Size.Dp(18)
                                })
                                w.Updater(func() {
                                        w.SetIcon(tb.Icon)
                                })
                        })
                        if tb.Text != "" {
                                tree.AddAt(p, "space", func(w *Space) {})
                        }
                }
                if tb.Text != "" {
                        tree.AddAt(p, "text", func(w *Text) {
                                w.Styler(func(s *styles.Style) {
                                        s.SetNonSelectable()
                                        s.SetTextWrap(false)
                                })
                                w.Updater(func() {
                                        if tb.Type.effective(tb) == FunctionalTabs {
                                                w.SetType(TextBodyMedium)
                                        } else {
                                                w.SetType(TextLabelLarge)
                                        }
                                        w.SetText(tb.Text)
                                })
                        })
                }
                if tb.Type.effective(tb) == FunctionalTabs && tb.CloseIcon.IsSet() {
                        tree.AddAt(p, "close-space", func(w *Space) {})
                        tree.AddAt(p, "close", func(w *Button) {
                                w.SetType(ButtonAction)
                                w.Styler(func(s *styles.Style) {
                                        s.Padding.Zero()
                                        s.Border.Radius = styles.BorderRadiusFull
                                })
                                w.OnClick(func(e events.Event) {
                                        ts := tb.tabs()
                                        idx := ts.tabIndexByName(tb.Name)
                                        // if OnlyCloseActiveTab is on, only process delete when already selected
                                        if SystemSettings.OnlyCloseActiveTab && !tb.StateIs(states.Selected) {
                                                ts.SelectTabIndex(idx)
                                        } else {
                                                ts.deleteTabIndex(idx)
                                        }
                                })
                                w.Updater(func() {
                                        w.SetIcon(tb.CloseIcon)
                                })
                        })
                }
        })
}

// tabs returns the parent [Tabs] of this [Tab].
func (tb *Tab) tabs() *Tabs {
        if tbr, ok := tb.Parent.AsTree().Parent.(Tabber); ok {
                return tbr.AsCoreTabs()
        }
        return nil
}

func (tb *Tab) Label() string {
        if tb.Text != "" {
                return tb.Text
        }
        return tb.Name
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/events"
        "cogentcore.org/core/system/composer"
)

// getImager is implemented by offscreen.Drawer for [Body.AssertRender].
type getImager interface {
        GetImage() *image.RGBA
}

// AssertRender makes a new window from the body, waits until it is shown
// and all events have been handled, does any necessary re-rendering,
// asserts that its rendered image is the same as that stored at the given
// filename, saving the image to that filename if it does not already exist,
// and then closes the window. It does not return until all of those steps
// are completed. Each (optional) function passed is called after the
// window is shown, and all system events are handled before proessing continues.
// A testdata directory and png file extension are automatically added to
// the the filename, and forward slashes are automatically replaced with
// backslashes on Windows.
func (b *Body) AssertRender(t imagex.TestingT, filename string, fun ...func()) {
        b.runAndShowNewWindow()

        rw := b.Scene.RenderWindow()
        for i := 0; i < len(fun); i++ {
                fun[i]()
                b.waitNoEvents(rw)
        }
        if len(fun) == 0 {
                // we didn't get it above
                b.waitNoEvents(rw)
        }

        // Ensure that everything is updated and rendered. If there are no changes,
        // the performance impact is minimal.
        for range 10 { // note: 10 is essential for textcore tests
                rw.renderWindow()
                b.AsyncLock()
                rw.mains.runDeferred()
                b.AsyncUnlock()
        }

        dw := b.Scene.RenderWindow().SystemWindow.Composer().(*composer.ComposerDrawer).Drawer
        img := dw.(getImager).GetImage()
        imagex.Assert(t, img, filename)

        // When closing the scene, our access to the render context stops working,
        // so using normal AsyncLock and AsyncUnlock will lead to AsyncLock failing.
        // That leaves the lock on, which prevents the WinClose event from being
        // received. Therefore, we get the rc ahead of time.
        rc := b.Scene.renderContext()
        rc.Lock()
        b.Close()
        rc.Unlock()
}

// runAndShowNewWindow runs a new window and waits for it to be shown.
func (b *Body) runAndShowNewWindow() {
        showed := make(chan struct{})
        b.OnFinal(events.Show, func(e events.Event) {
                showed <- struct{}{}
        })
        b.RunWindow()
        <-showed
}

// waitNoEvents waits for all events to be handled and does any rendering
// of the body necessary.
func (b *Body) waitNoEvents(rw *renderWindow) {
        rw.noEventsChan = make(chan struct{})
        <-rw.noEventsChan
        rw.noEventsChan = nil
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"

        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/htmltext"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/text/textpos"
)

// Text is a widget for rendering text. It supports full HTML styling,
// including links. By default, text wraps and collapses whitespace, although
// you can change this by changing [styles.Text.WhiteSpace].
type Text struct {
        WidgetBase

        // Text is the text to display.
        Text string

        // Type is the styling type of text to use.
        // It defaults to [TextBodyLarge].
        Type TextTypes

        // Links is the list of links in the text.
        Links []rich.Hyperlink `copier:"-" json:"-" xml:"-" set:"-"`

        // richText is the conversion of the HTML text source.
        richText rich.Text

        // paintText is the [shaped.Lines] for the text.
        paintText *shaped.Lines

        // normalCursor is the cached cursor to display when there
        // is no link being hovered.
        normalCursor cursors.Cursor

        // selectRange is the selected range, in _runes_, which must be applied
        selectRange textpos.Range
}

// TextTypes is an enum containing the different
// possible styling types of [Text] widgets.
type TextTypes int32 //enums:enum -trim-prefix Text

const (
        // TextDisplayLarge is large, short, and important
        // display text with a default font size of 57dp.
        TextDisplayLarge TextTypes = iota
        // TextDisplayMedium is medium-sized, short, and important
        // display text with a default font size of 45dp.
        TextDisplayMedium
        // TextDisplaySmall is small, short, and important
        // display text with a default font size of 36dp.
        TextDisplaySmall

        // TextHeadlineLarge is large, high-emphasis
        // headline text with a default font size of 32dp.
        TextHeadlineLarge
        // TextHeadlineMedium is medium-sized, high-emphasis
        // headline text with a default font size of 28dp.
        TextHeadlineMedium
        // TextHeadlineSmall is small, high-emphasis
        // headline text with a default font size of 24dp.
        TextHeadlineSmall

        // TextTitleLarge is large, medium-emphasis
        // title text with a default font size of 22dp.
        TextTitleLarge
        // TextTitleMedium is medium-sized, medium-emphasis
        // title text with a default font size of 16dp.
        TextTitleMedium
        // TextTitleSmall is small, medium-emphasis
        // title text with a default font size of 14dp.
        TextTitleSmall

        // TextBodyLarge is large body text used for longer
        // passages of text with a default font size of 16dp.
        TextBodyLarge
        // TextBodyMedium is medium-sized body text used for longer
        // passages of text with a default font size of 14dp.
        TextBodyMedium
        // TextBodySmall is small body text used for longer
        // passages of text with a default font size of 12dp.
        TextBodySmall

        // TextLabelLarge is large text used for label text (like a caption
        // or the text inside a button) with a default font size of 14dp.
        TextLabelLarge
        // TextLabelMedium is medium-sized text used for label text (like a caption
        // or the text inside a button) with a default font size of 12dp.
        TextLabelMedium
        // TextLabelSmall is small text used for label text (like a caption
        // or the text inside a button) with a default font size of 11dp.
        TextLabelSmall

        // TextSupporting is medium-sized supporting text typically used for
        // secondary dialog information below the title. It has a default font
        // size of 14dp and color of [colors.Scheme.OnSurfaceVariant].
        TextSupporting
)

func (tx *Text) WidgetValue() any { return &tx.Text }

func (tx *Text) Init() {
        tx.WidgetBase.Init()
        tx.AddContextMenu(tx.contextMenu)
        tx.SetType(TextBodyLarge)
        tx.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Selectable, abilities.DoubleClickable, abilities.TripleClickable, abilities.LongPressable, abilities.Slideable)
                if len(tx.Links) > 0 {
                        s.SetAbilities(true, abilities.Clickable, abilities.LongHoverable, abilities.LongPressable)
                }
                if !tx.IsReadOnly() {
                        s.Cursor = cursors.Text
                }
                s.GrowWrap = true

                // Text styles based on https://m3.material.io/styles/typography/type-scale-tokens
                // We use Em for line height so that it scales properly with font size changes.
                switch tx.Type {
                case TextLabelLarge:
                        s.Text.LineHeight = 20.0 / 14
                        s.Font.Size.Dp(14)
                        s.Font.Weight = rich.Medium
                case TextLabelMedium:
                        s.Text.LineHeight = 16.0 / 12
                        s.Font.Size.Dp(12)
                        s.Font.Weight = rich.Medium
                case TextLabelSmall:
                        s.Text.LineHeight = 16.0 / 11
                        s.Font.Size.Dp(11)
                        s.Font.Weight = rich.Medium
                case TextBodyLarge:
                        s.Text.LineHeight = 24.0 / 16
                        s.Font.Size.Dp(16)
                        s.Font.Weight = rich.Normal
                case TextSupporting:
                        s.Color = colors.Scheme.OnSurfaceVariant
                        fallthrough
                case TextBodyMedium:
                        s.Text.LineHeight = 20.0 / 14
                        s.Font.Size.Dp(14)
                        s.Font.Weight = rich.Normal
                case TextBodySmall:
                        s.Text.LineHeight = 16.0 / 12
                        s.Font.Size.Dp(12)
                        s.Font.Weight = rich.Normal
                case TextTitleLarge:
                        s.Text.LineHeight = 28.0 / 22
                        s.Font.Size.Dp(22)
                        s.Font.Weight = rich.Normal
                case TextTitleMedium:
                        s.Text.LineHeight = 24.0 / 16
                        s.Font.Size.Dp(16)
                        s.Font.Weight = rich.Bold
                case TextTitleSmall:
                        s.Text.LineHeight = 20.0 / 14
                        s.Font.Size.Dp(14)
                        s.Font.Weight = rich.Medium
                case TextHeadlineLarge:
                        s.Text.LineHeight = 40.0 / 32
                        s.Font.Size.Dp(32)
                        s.Font.Weight = rich.Normal
                case TextHeadlineMedium:
                        s.Text.LineHeight = 36.0 / 28
                        s.Font.Size.Dp(28)
                        s.Font.Weight = rich.Normal
                case TextHeadlineSmall:
                        s.Text.LineHeight = 32.0 / 24
                        s.Font.Size.Dp(24)
                        s.Font.Weight = rich.Normal
                case TextDisplayLarge:
                        s.Text.LineHeight = 70.0 / 57
                        s.Font.Size.Dp(57)
                        s.Font.Weight = rich.Normal
                case TextDisplayMedium:
                        s.Text.LineHeight = 52.0 / 45
                        s.Font.Size.Dp(45)
                        s.Font.Weight = rich.Normal
                case TextDisplaySmall:
                        s.Text.LineHeight = 44.0 / 36
                        s.Font.Size.Dp(36)
                        s.Font.Weight = rich.Normal
                }
        })
        tx.FinalStyler(func(s *styles.Style) {
                tx.normalCursor = s.Cursor
                tx.updateRichText() // note: critical to update with final styles
                if tx.paintText != nil && tx.Text != "" {
                        _, tsty := s.NewRichText()
                        tx.paintText.UpdateStyle(tx.richText, tsty)
                }
        })

        tx.HandleTextClick(func(tl *rich.Hyperlink) {
                system.TheApp.OpenURL(tl.URL)
        })
        tx.OnFocusLost(func(e events.Event) {
                tx.selectReset()
        })
        tx.OnKeyChord(func(e events.Event) {
                if tx.selectRange.Len() == 0 {
                        return
                }
                kf := keymap.Of(e.KeyChord())
                if kf == keymap.Copy {
                        e.SetHandled()
                        tx.copy()
                }
        })
        tx.On(events.MouseMove, func(e events.Event) {
                tl, _ := tx.findLink(e.Pos())
                if tl != nil {
                        tx.Styles.Cursor = cursors.Pointer
                } else {
                        tx.Styles.Cursor = tx.normalCursor
                }
        })
        tx.On(events.DoubleClick, func(e events.Event) {
                e.SetHandled()
                tx.selectWord(tx.pixelToRune(e.Pos()))
                tx.SetFocusQuiet()
        })
        tx.On(events.TripleClick, func(e events.Event) {
                e.SetHandled()
                tx.selectAll()
                tx.SetFocusQuiet()
                if TheApp.SystemPlatform().IsMobile() {
                        tx.Send(events.ContextMenu, e)
                }
        })
        tx.On(events.SlideStart, func(e events.Event) {
                e.SetHandled()
                tx.SetState(true, states.Sliding)
                tx.SetFocusQuiet()
                tx.selectRange.Start = tx.pixelToRune(e.Pos())
                tx.selectRange.End = tx.selectRange.Start
                tx.paintText.SelectReset()
                tx.NeedsRender()
        })
        tx.On(events.SlideMove, func(e events.Event) {
                e.SetHandled()
                tx.selectUpdate(tx.pixelToRune(e.Pos()))
                tx.NeedsRender()
        })
        tx.On(events.SlideStop, func(e events.Event) {
                if TheApp.SystemPlatform().IsMobile() {
                        tx.Send(events.ContextMenu, e)
                }
        })

        tx.FinalUpdater(func() {
                tx.updateRichText()
                tx.configTextAlloc(tx.Geom.Size.Alloc.Content)
        })
}

// updateRichText gets the richtext from Text, using HTML parsing.
func (tx *Text) updateRichText() {
        sty, tsty := tx.Styles.NewRichText()
        if tsty.WhiteSpace.KeepWhiteSpace() {
                tx.richText, _ = htmltext.HTMLPreToRich([]byte(tx.Text), sty, nil)
        } else {
                tx.richText, _ = htmltext.HTMLToRich([]byte(tx.Text), sty, nil)
        }
        tx.Links = tx.richText.GetLinks()
}

// findLink finds the text link at the given scene-local position. If it
// finds it, it returns it and its bounds; otherwise, it returns nil.
func (tx *Text) findLink(pos image.Point) (*rich.Hyperlink, image.Rectangle) {
        if tx.paintText == nil || len(tx.Links) == 0 {
                return nil, image.Rectangle{}
        }
        tpos := tx.Geom.Pos.Content
        ri := tx.pixelToRune(pos)
        for li := range tx.Links {
                lr := &tx.Links[li]
                if !lr.Range.Contains(ri) {
                        continue
                }
                gb := tx.paintText.RuneBounds(ri).Translate(tpos).ToRect()
                return lr, gb
        }
        return nil, image.Rectangle{}
}

// HandleTextClick handles click events such that the given function will be called
// on any links that are clicked on.
func (tx *Text) HandleTextClick(openLink func(tl *rich.Hyperlink)) {
        tx.OnClick(func(e events.Event) {
                tl, _ := tx.findLink(e.Pos())
                if tl == nil {
                        return
                }
                openLink(tl)
                e.SetHandled()
        })
}

func (tx *Text) WidgetTooltip(pos image.Point) (string, image.Point) {
        if pos == image.Pt(-1, -1) {
                return tx.Tooltip, image.Point{}
        }
        tl, bounds := tx.findLink(pos)
        if tl == nil {
                return tx.Tooltip, tx.DefaultTooltipPos()
        }
        return tl.URL, bounds.Min
}

func (tx *Text) contextMenu(m *Scene) {
        NewFuncButton(m).SetFunc(tx.copy).SetIcon(icons.Copy).SetKey(keymap.Copy).SetEnabled(tx.hasSelection())
}

func (tx *Text) copy() { //types:add
        if !tx.hasSelection() {
                return
        }
        // note: selectRange is in runes, not string indexes.
        md := mimedata.NewText(string([]rune(tx.Text)[tx.selectRange.Start:tx.selectRange.End]))
        em := tx.Events()
        if em != nil {
                em.Clipboard().Write(md)
        }
        tx.selectReset()
}

func (tx *Text) Label() string {
        if tx.Text != "" {
                return tx.Text
        }
        return tx.Name
}

func (tx *Text) pixelToRune(pt image.Point) int {
        return tx.paintText.RuneAtPoint(math32.FromPoint(pt), tx.Geom.Pos.Content)
}

// selectUpdate updates selection based on rune index
func (tx *Text) selectUpdate(ri int) {
        if ri >= tx.selectRange.Start {
                tx.selectRange.End = ri
        } else {
                tx.selectRange.Start, tx.selectRange.End = ri, tx.selectRange.Start
        }
        tx.paintText.SelectReset()
        tx.paintText.SelectRegion(tx.selectRange)
}

// hasSelection returns true if there is an active selection.
func (tx *Text) hasSelection() bool {
        return tx.selectRange.Len() > 0
}

// selectReset resets any current selection
func (tx *Text) selectReset() {
        tx.selectRange.Start = 0
        tx.selectRange.End = 0
        tx.paintText.SelectReset()
        tx.NeedsRender()
}

// selectAll selects entire set of text
func (tx *Text) selectAll() {
        tx.selectRange.Start = 0
        txt := tx.richText.Join()
        tx.selectUpdate(len(txt))
        tx.NeedsRender()
}

// selectWord selects word at given rune location
func (tx *Text) selectWord(ri int) {
        tx.paintText.SelectReset()
        txt := tx.richText.Join()
        wr := textpos.WordAt(txt, ri)
        if wr.Start >= 0 {
                tx.selectRange = wr
                tx.paintText.SelectRegion(tx.selectRange)
        }
        tx.NeedsRender()
}

// configTextSize does the text shaping layout for text,
// using given size to constrain layout.
func (tx *Text) configTextSize(sz math32.Vector2) {
        if tx.Styles.Font.Size.Dots == 0 { // not init
                return
        }
        sty, tsty := tx.Styles.NewRichText()
        tsty.Align, tsty.AlignV = text.Start, text.Start
        tx.paintText = tx.Scene.TextShaper().WrapLines(tx.richText, sty, tsty, &AppearanceSettings.Text, sz)
}

// configTextAlloc is used for determining how much space the text
// takes, using given size (typically Alloc).
// In this case, alignment factors are turned off,
// because they otherwise can absorb much more space, which should
// instead be controlled by the base Align X,Y factors.
func (tx *Text) configTextAlloc(sz math32.Vector2) math32.Vector2 {
        if tx.Scene == nil || tx.Scene.TextShaper() == nil {
                return sz
        }
        if tx.Styles.Font.Size.Dots == 0 {
                return sz // not init
        }
        tsh := tx.Scene.TextShaper()
        sty, tsty := tx.Styles.NewRichText()
        rsz := sz
        if tsty.Align != text.Start && tsty.AlignV != text.Start {
                etxs := *tsty
                etxs.Align, etxs.AlignV = text.Start, text.Start
                tx.paintText = tsh.WrapLines(tx.richText, sty, &etxs, &AppearanceSettings.Text, rsz)
                rsz = tx.paintText.Bounds.Size().Ceil()
        }
        tx.paintText = tsh.WrapLines(tx.richText, sty, tsty, &AppearanceSettings.Text, rsz)
        return tx.paintText.Bounds.Size().Ceil()
}

func (tx *Text) SizeUp() {
        tx.WidgetBase.SizeUp() // sets Actual size based on styles
        sz := &tx.Geom.Size
        if tx.Styles.Text.WhiteSpace.HasWordWrap() {
                sty, tsty := tx.Styles.NewRichText()
                est := shaped.WrapSizeEstimate(sz.Actual.Content, len(tx.Text), .5, sty, tsty)
                tx.configTextSize(est)
        } else {
                tx.configTextSize(sz.Actual.Content)
        }
        if tx.paintText == nil {
                return
        }
        rsz := tx.paintText.Bounds.Size().Ceil()
        sz.FitSizeMax(&sz.Actual.Content, rsz)
        sz.setTotalFromContent(&sz.Actual)
        if DebugSettings.LayoutTrace {
                fmt.Println(tx, "Text SizeUp:", rsz, "Actual:", sz.Actual.Content)
        }
}

func (tx *Text) SizeDown(iter int) bool {
        if !tx.Styles.Text.WhiteSpace.HasWordWrap() || iter > 1 {
                return false
        }
        sz := &tx.Geom.Size
        asz := sz.Alloc.Content
        rsz := tx.configTextAlloc(asz) // use allocation
        prevContent := sz.Actual.Content
        // start over so we don't reflect hysteresis of prior guess
        sz.setInitContentMin(tx.Styles.Min.Dots().Ceil())
        sz.FitSizeMax(&sz.Actual.Content, rsz)
        sz.setTotalFromContent(&sz.Actual)
        chg := prevContent != sz.Actual.Content
        if chg {
                if DebugSettings.LayoutTrace {
                        fmt.Println(tx, "Label Size Changed:", sz.Actual.Content, "was:", prevContent)
                }
        }
        return chg
}

func (tx *Text) Render() {
        tx.WidgetBase.Render()
        tx.Scene.Painter.DrawText(tx.paintText, tx.Geom.Pos.Content)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "log/slog"
        "reflect"
        "slices"
        "sync"
        "time"
        "unicode"

        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/tree"
        "golang.org/x/image/draw"
)

// TextField is a widget for editing a line of text.
//
// With the default [styles.WhiteSpaceNormal] setting,
// text will wrap onto multiple lines as needed. You can
// call [styles.Style.SetTextWrap](false) to force everything
// to be rendered on a single line. With multi-line wrapped text,
// the text is still treated as a single contiguous line of wrapped text.
type TextField struct { //core:embedder
        Frame

        // Type is the styling type of the text field.
        Type TextFieldTypes

        // Placeholder is the text that is displayed
        // when the text field is empty.
        Placeholder string

        // Validator is a function used to validate the input
        // of the text field. If it returns a non-nil error,
        // then an error color, icon, and tooltip will be displayed.
        Validator func() error `json:"-" xml:"-"`

        // LeadingIcon, if specified, indicates to add a button
        // at the start of the text field with this icon.
        // See [TextField.SetLeadingIcon].
        LeadingIcon icons.Icon `set:"-"`

        // LeadingIconOnClick, if specified, is the function to call when
        // the LeadingIcon is clicked. If this is nil, the leading icon
        // will not be interactive. See [TextField.SetLeadingIcon].
        LeadingIconOnClick func(e events.Event) `json:"-" xml:"-"`

        // TrailingIcon, if specified, indicates to add a button
        // at the end of the text field with this icon.
        // See [TextField.SetTrailingIcon].
        TrailingIcon icons.Icon `set:"-"`

        // TrailingIconOnClick, if specified, is the function to call when
        // the TrailingIcon is clicked. If this is nil, the trailing icon
        // will not be interactive. See [TextField.SetTrailingIcon].
        TrailingIconOnClick func(e events.Event) `json:"-" xml:"-"`

        // NoEcho is whether replace displayed characters with bullets
        // to conceal text (for example, for a password input). Also
        // see [TextField.SetTypePassword].
        NoEcho bool

        // CursorWidth is the width of the text field cursor.
        // It should be set in a Styler like all other style properties.
        // By default, it is 1dp.
        CursorWidth units.Value

        // CursorColor is the color used for the text field cursor (caret).
        // It should be set in a Styler like all other style properties.
        // By default, it is [colors.Scheme.Primary.Base].
        CursorColor image.Image

        // PlaceholderColor is the color used for the [TextField.Placeholder] text.
        // It should be set in a Styler like all other style properties.
        // By default, it is [colors.Scheme.OnSurfaceVariant].
        PlaceholderColor image.Image

        // complete contains functions and data for text field completion.
        // It must be set using [TextField.SetCompleter].
        complete *Complete

        // text is the last saved value of the text string being edited.
        text string

        // edited is whether the text has been edited relative to the original.
        edited bool

        // editText is the live text string being edited, with the latest modifications.
        editText []rune

        // error is the current validation error of the text field.
        error error

        // effPos is the effective position with any leading icon space added.
        effPos math32.Vector2

        // effSize is the effective size, subtracting any leading and trailing icon space.
        effSize math32.Vector2

        // dispRange is the range of visible text, for scrolling text case (non-wordwrap).
        dispRange textpos.Range

        // cursorPos is the current cursor position as rune index into string.
        cursorPos int

        // cursorLine is the current cursor line position, for word wrap case.
        cursorLine int

        // charWidth is the approximate number of chars that can be
        // displayed at any time, which is computed from the font size.
        charWidth int

        // selectRange is the selected range.
        selectRange textpos.Range

        // selectInit is the initial selection position (where it started).
        selectInit int

        // selectMode is whether to select text as the cursor moves.
        selectMode bool

        // selectModeShift is whether selectmode was turned on because of the shift key.
        selectModeShift bool

        // renderAll is the render version of entire text, for sizing.
        renderAll *shaped.Lines

        // renderVisible is the render version of just the visible text in dispRange.
        renderVisible *shaped.Lines

        // renderedRange is the dispRange last rendered.
        renderedRange textpos.Range

        // number of lines from last render update, for word-wrap version
        numLines int

        // lineHeight is the line height cached during styling.
        lineHeight float32

        // blinkOn oscillates between on and off for blinking.
        blinkOn bool

        // cursorMu is the mutex for updating the cursor between blinker and field.
        cursorMu sync.Mutex

        // undos is the undo manager for the text field.
        undos textFieldUndos

        leadingIconButton, trailingIconButton *Button
}

// TextFieldTypes is an enum containing the
// different possible types of text fields.
type TextFieldTypes int32 //enums:enum -trim-prefix TextField

const (
        // TextFieldFilled represents a filled
        // [TextField] with a background color
        // and a bottom border.
        TextFieldFilled TextFieldTypes = iota

        // TextFieldOutlined represents an outlined
        // [TextField] with a border on all sides
        // and no background color.
        TextFieldOutlined
)

// Validator is an interface for types to provide a Validate method
// that is used to validate string [Value]s using [TextField.Validator].
type Validator interface {

        // Validate returns an error if the value is invalid.
        Validate() error
}

func (tf *TextField) WidgetValue() any { return &tf.text }

func (tf *TextField) OnBind(value any, tags reflect.StructTag) {
        if vd, ok := value.(Validator); ok {
                tf.Validator = vd.Validate
        }
}

func (tf *TextField) Init() {
        tf.Frame.Init()
        tf.AddContextMenu(tf.contextMenu)

        tf.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Activatable, abilities.Focusable, abilities.Hoverable, abilities.Slideable, abilities.DoubleClickable, abilities.TripleClickable)
                s.SetAbilities(false, abilities.ScrollableUnattended)
                tf.CursorWidth.Dp(1)
                tf.PlaceholderColor = colors.Scheme.OnSurfaceVariant
                tf.CursorColor = colors.Scheme.Primary.Base
                s.Cursor = cursors.Text
                s.VirtualKeyboard = styles.KeyboardSingleLine
                s.GrowWrap = false // note: doesn't work with Grow
                s.Grow.Set(1, 0)
                s.Min.Y.Em(1.1)
                s.Min.X.Ch(20)
                s.Max.X.Ch(40)
                s.Gap.Zero()
                s.Padding.Set(units.Dp(8), units.Dp(8))
                if tf.LeadingIcon.IsSet() {
                        s.Padding.Left.Dp(12)
                }
                if tf.TrailingIcon.IsSet() {
                        s.Padding.Right.Dp(12)
                }
                s.Text.LineHeight = 1.4
                s.Text.Align = text.Start
                s.Align.Items = styles.Center
                s.Color = colors.Scheme.OnSurface
                switch tf.Type {
                case TextFieldFilled:
                        s.Border.Style.Set(styles.BorderNone)
                        s.Border.Style.Bottom = styles.BorderSolid
                        s.Border.Width.Zero()
                        s.Border.Color.Zero()
                        s.Border.Radius = styles.BorderRadiusExtraSmallTop
                        s.Background = colors.Scheme.SurfaceContainer

                        s.MaxBorder = s.Border
                        s.MaxBorder.Width.Bottom = units.Dp(2)
                        s.MaxBorder.Color.Bottom = colors.Scheme.Primary.Base

                        s.Border.Width.Bottom = units.Dp(1)
                        s.Border.Color.Bottom = colors.Scheme.OnSurfaceVariant
                        if tf.error != nil {
                                s.Border.Color.Bottom = colors.Scheme.Error.Base
                        }
                case TextFieldOutlined:
                        s.Border.Style.Set(styles.BorderSolid)
                        s.Border.Radius = styles.BorderRadiusExtraSmall

                        s.MaxBorder = s.Border
                        s.MaxBorder.Width.Set(units.Dp(2))
                        s.MaxBorder.Color.Set(colors.Scheme.Primary.Base)
                        s.Border.Width.Set(units.Dp(1))
                        if tf.error != nil {
                                s.Border.Color.Set(colors.Scheme.Error.Base)
                        }
                }
                if tf.IsReadOnly() {
                        s.Border.Color.Zero()
                        s.Border.Width.Zero()
                        s.Border.Radius.Zero()
                        s.MaxBorder = s.Border
                        s.Background = nil
                }
                if s.Is(states.Selected) {
                        s.Background = colors.Scheme.Select.Container
                }
        })
        tf.FinalStyler(func(s *styles.Style) {
                s.SetAbilities(!tf.IsReadOnly(), abilities.Focusable)
        })

        tf.handleKeyEvents()
        tf.OnFirst(events.Change, func(e events.Event) {
                tf.validate()
                if tf.error != nil {
                        e.SetHandled()
                }
        })
        tf.OnClick(func(e events.Event) {
                if !tf.IsReadOnly() {
                        tf.SetFocus()
                }
                switch e.MouseButton() {
                case events.Left:
                        tf.setCursorFromPixel(e.Pos(), e.SelectMode())
                case events.Middle:
                        if !tf.IsReadOnly() {
                                tf.paste()
                        }
                }
        })
        tf.On(events.DoubleClick, func(e events.Event) {
                if tf.IsReadOnly() {
                        return
                }
                if !tf.IsReadOnly() && !tf.StateIs(states.Focused) {
                        tf.SetFocus()
                }
                e.SetHandled()
                tf.selectWord()
        })
        tf.On(events.TripleClick, func(e events.Event) {
                if tf.IsReadOnly() {
                        return
                }
                if !tf.IsReadOnly() && !tf.StateIs(states.Focused) {
                        tf.SetFocus()
                }
                e.SetHandled()
                tf.selectAll()
        })
        tf.On(events.SlideStart, func(e events.Event) {
                e.SetHandled()
                tf.SetState(true, states.Sliding)
                if tf.selectMode || e.SelectMode() != events.SelectOne { // extend existing select
                        tf.setCursorFromPixel(e.Pos(), e.SelectMode())
                } else {
                        tf.cursorPos = tf.pixelToCursor(e.Pos())
                        if !tf.selectMode {
                                tf.selectModeToggle()
                        }
                }
        })
        tf.On(events.SlideMove, func(e events.Event) {
                e.SetHandled()
                tf.selectMode = true // always
                tf.setCursorFromPixel(e.Pos(), events.SelectOne)
        })
        tf.OnClose(func(e events.Event) {
                tf.editDone() // todo: this must be protected against something else, for race detector
        })

        tf.Maker(func(p *tree.Plan) {
                tf.editText = []rune(tf.text)
                tf.edited = false

                if tf.IsReadOnly() {
                        return
                }
                if tf.LeadingIcon.IsSet() {
                        tree.AddAt(p, "lead-icon", func(w *Button) {
                                tf.leadingIconButton = w
                                w.SetType(ButtonAction)
                                w.Styler(func(s *styles.Style) {
                                        s.Padding.Zero()
                                        s.Color = colors.Scheme.OnSurfaceVariant
                                        s.Margin.SetRight(units.Dp(8))
                                        if tf.LeadingIconOnClick == nil {
                                                s.SetAbilities(false, abilities.Activatable, abilities.Focusable, abilities.Hoverable)
                                                s.Cursor = cursors.None
                                        }
                                        // If we are responsible for a positive (non-disabled) state layer
                                        // (instead of our parent), then we amplify it so that it is clear
                                        // that we ourself are receiving a state layer amplifying event.
                                        // Otherwise, we set our state color to that of our parent
                                        // so that it does not appear as if we are getting interaction ourself;
                                        // instead, we are a part of our parent and render a background color no
                                        // different than them.
                                        if s.Is(states.Hovered) || s.Is(states.Focused) || s.Is(states.Active) {
                                                s.StateLayer *= 3
                                        } else {
                                                s.StateColor = tf.Styles.Color
                                        }
                                })
                                w.OnClick(func(e events.Event) {
                                        if tf.LeadingIconOnClick != nil {
                                                tf.LeadingIconOnClick(e)
                                        }
                                })
                                w.Updater(func() {
                                        w.SetIcon(tf.LeadingIcon)
                                })
                        })
                } else {
                        tf.leadingIconButton = nil
                }
                if tf.TrailingIcon.IsSet() || tf.error != nil {
                        tree.AddAt(p, "trail-icon-stretch", func(w *Stretch) {
                                w.Styler(func(s *styles.Style) {
                                        s.Grow.Set(1, 0)
                                })
                        })
                        tree.AddAt(p, "trail-icon", func(w *Button) {
                                tf.trailingIconButton = w
                                w.SetType(ButtonAction)
                                w.Styler(func(s *styles.Style) {
                                        s.Padding.Zero()
                                        s.Color = colors.Scheme.OnSurfaceVariant
                                        if tf.error != nil {
                                                s.Color = colors.Scheme.Error.Base
                                        }
                                        s.Margin.SetLeft(units.Dp(8))
                                        if tf.TrailingIconOnClick == nil || tf.error != nil {
                                                s.SetAbilities(false, abilities.Activatable, abilities.Focusable, abilities.Hoverable)
                                                s.Cursor = cursors.None
                                                // need to clear state in case it was set when there
                                                // was no error
                                                s.State = 0
                                        }
                                        // same reasoning as for leading icon
                                        if s.Is(states.Hovered) || s.Is(states.Focused) || s.Is(states.Active) {
                                                s.StateLayer *= 3
                                        } else {
                                                s.StateColor = tf.Styles.Color
                                        }
                                })
                                w.OnClick(func(e events.Event) {
                                        if tf.TrailingIconOnClick != nil {
                                                tf.TrailingIconOnClick(e)
                                        }
                                })
                                w.Updater(func() {
                                        w.SetIcon(tf.TrailingIcon)
                                        if tf.error != nil {
                                                w.SetIcon(icons.Error)
                                        }
                                })
                        })
                } else {
                        tf.trailingIconButton = nil
                }
        })
        tf.Updater(func() {
                tf.renderVisible = nil // ensures re-render
        })
}

func (tf *TextField) Destroy() {
        tf.stopCursor()
        tf.Frame.Destroy()
}

// Text returns the current text of the text field. It applies any unapplied changes
// first, and sends an [events.Change] event if applicable. This is the main end-user
// method to get the current value of the text field.
func (tf *TextField) Text() string {
        tf.editDone()
        return tf.text
}

// SetText sets the text of the text field and reverts any current edits
// to reflect this new text.
func (tf *TextField) SetText(text string) *TextField {
        if tf.text == text && !tf.edited {
                return tf
        }
        tf.text = text
        tf.revert()
        return tf
}

// SetLeadingIcon sets the [TextField.LeadingIcon] to the given icon. If an
// on click function is specified, it also sets the [TextField.LeadingIconOnClick]
// to that function. If no function is specified, it does not override any already
// set function.
func (tf *TextField) SetLeadingIcon(icon icons.Icon, onClick ...func(e events.Event)) *TextField {
        tf.LeadingIcon = icon
        if len(onClick) > 0 {
                tf.LeadingIconOnClick = onClick[0]
        }
        return tf
}

// SetTrailingIcon sets the [TextField.TrailingIcon] to the given icon. If an
// on click function is specified, it also sets the [TextField.TrailingIconOnClick]
// to that function. If no function is specified, it does not override any already
// set function.
func (tf *TextField) SetTrailingIcon(icon icons.Icon, onClick ...func(e events.Event)) *TextField {
        tf.TrailingIcon = icon
        if len(onClick) > 0 {
                tf.TrailingIconOnClick = onClick[0]
        }
        return tf
}

// AddClearButton adds a trailing icon button at the end
// of the text field that clears the text in the text field
// when it is clicked.
func (tf *TextField) AddClearButton() *TextField {
        return tf.SetTrailingIcon(icons.Close, func(e events.Event) {
                tf.clear()
        })
}

// SetTypePassword enables [TextField.NoEcho] and adds a trailing
// icon button at the end of the textfield that toggles [TextField.NoEcho].
// It also sets [styles.Style.VirtualKeyboard] to [styles.KeyboardPassword].
func (tf *TextField) SetTypePassword() *TextField {
        tf.SetNoEcho(true).SetTrailingIcon(icons.Visibility, func(e events.Event) {
                tf.NoEcho = !tf.NoEcho
                if tf.NoEcho {
                        tf.TrailingIcon = icons.Visibility
                } else {
                        tf.TrailingIcon = icons.VisibilityOff
                }
                if icon := tf.trailingIconButton; icon != nil {
                        icon.SetIcon(tf.TrailingIcon).Update()
                }
        }).Styler(func(s *styles.Style) {
                s.VirtualKeyboard = styles.KeyboardPassword
        })
        return tf
}

// textEdited must be called whenever the text is edited.
// it sets the edited flag and ensures a new render of current text.
func (tf *TextField) textEdited() {
        tf.edited = true
        tf.renderVisible = nil
        tf.NeedsRender()
}

// editDone completes editing and copies the active edited text to the [TextField.text].
// It is called when the return key is pressed or the text field goes out of focus.
func (tf *TextField) editDone() {
        if tf.edited {
                tf.edited = false
                tf.text = string(tf.editText)
                tf.SendChange()
                // widget can be killed after SendChange
                if tf.This == nil {
                        return
                }
        }
        tf.clearSelected()
        tf.clearCursor()
}

// revert aborts editing and reverts to the last saved text.
func (tf *TextField) revert() {
        tf.renderVisible = nil
        tf.editText = []rune(tf.text)
        tf.edited = false
        tf.dispRange.Start = 0
        tf.dispRange.End = tf.charWidth
        tf.selectReset()
        tf.NeedsRender()
}

// clear clears any existing text.
func (tf *TextField) clear() {
        tf.renderVisible = nil
        tf.edited = true
        tf.editText = tf.editText[:0]
        tf.dispRange.Start = 0
        tf.dispRange.End = 0
        tf.selectReset()
        tf.SetFocus() // this is essential for ensuring that the clear applies after focus is lost..
        tf.NeedsRender()
}

// clearError clears any existing validation error.
func (tf *TextField) clearError() {
        if tf.error == nil {
                return
        }
        tf.error = nil
        tf.Update()
        tf.Send(events.LongHoverEnd) // get rid of any validation tooltip
}

// validate runs [TextField.Validator] and takes any necessary actions
// as a result of that.
func (tf *TextField) validate() {
        if tf.Validator == nil {
                return
        }
        err := tf.Validator()
        if err == nil {
                tf.clearError()
                return
        }
        tf.error = err
        tf.Update()
        // show the error tooltip immediately
        tf.Send(events.LongHoverStart)
}

func (tf *TextField) WidgetTooltip(pos image.Point) (string, image.Point) {
        if tf.error == nil {
                return tf.Tooltip, tf.DefaultTooltipPos()
        }
        return tf.error.Error(), tf.DefaultTooltipPos()
}

////////  Cursor Navigation

func (tf *TextField) updateLinePos() {
        tf.cursorLine = tf.renderAll.RuneToLinePos(tf.cursorPos).Line
}

// cursorForward moves the cursor forward
func (tf *TextField) cursorForward(steps int) {
        tf.cursorPos += steps
        if tf.cursorPos > len(tf.editText) {
                tf.cursorPos = len(tf.editText)
        }
        if tf.cursorPos > tf.dispRange.End {
                inc := tf.cursorPos - tf.dispRange.End
                tf.dispRange.End += inc
        }
        tf.updateLinePos()
        if tf.selectMode {
                tf.selectRegionUpdate(tf.cursorPos)
        }
        tf.NeedsRender()
}

// cursorForwardWord moves the cursor forward by words
func (tf *TextField) cursorForwardWord(steps int) {
        tf.cursorPos, _ = textpos.ForwardWord(tf.editText, tf.cursorPos, steps)
        if tf.cursorPos > tf.dispRange.End {
                inc := tf.cursorPos - tf.dispRange.End
                tf.dispRange.End += inc
        }
        tf.updateLinePos()
        if tf.selectMode {
                tf.selectRegionUpdate(tf.cursorPos)
        }
        tf.NeedsRender()
}

// cursorBackward moves the cursor backward
func (tf *TextField) cursorBackward(steps int) {
        tf.cursorPos -= steps
        if tf.cursorPos < 0 {
                tf.cursorPos = 0
        }
        if tf.cursorPos <= tf.dispRange.Start {
                dec := min(tf.dispRange.Start, 8)
                tf.dispRange.Start -= dec
        }
        tf.updateLinePos()
        if tf.selectMode {
                tf.selectRegionUpdate(tf.cursorPos)
        }
        tf.NeedsRender()
}

// cursorBackwardWord moves the cursor backward by words
func (tf *TextField) cursorBackwardWord(steps int) {
        tf.cursorPos, _ = textpos.BackwardWord(tf.editText, tf.cursorPos, steps)
        if tf.cursorPos <= tf.dispRange.Start {
                dec := min(tf.dispRange.Start, 8)
                tf.dispRange.Start -= dec
        }
        tf.updateLinePos()
        if tf.selectMode {
                tf.selectRegionUpdate(tf.cursorPos)
        }
        tf.NeedsRender()
}

// cursorDown moves the cursor down
func (tf *TextField) cursorDown(steps int) {
        if tf.numLines <= 1 {
                return
        }
        if tf.cursorLine >= tf.numLines-1 {
                return
        }
        tf.cursorPos = tf.renderVisible.RuneAtLineDelta(tf.cursorPos, steps)
        tf.updateLinePos()
        if tf.selectMode {
                tf.selectRegionUpdate(tf.cursorPos)
        }
        tf.NeedsRender()
}

// cursorUp moves the cursor up
func (tf *TextField) cursorUp(steps int) {
        if tf.numLines <= 1 {
                return
        }
        if tf.cursorLine <= 0 {
                return
        }
        tf.cursorPos = tf.renderVisible.RuneAtLineDelta(tf.cursorPos, -steps)
        tf.updateLinePos()
        if tf.selectMode {
                tf.selectRegionUpdate(tf.cursorPos)
        }
        tf.NeedsRender()
}

// cursorStart moves the cursor to the start of the text, updating selection
// if select mode is active.
func (tf *TextField) cursorStart() {
        tf.cursorPos = 0
        tf.dispRange.Start = 0
        tf.dispRange.End = min(len(tf.editText), tf.dispRange.Start+tf.charWidth)
        if tf.selectMode {
                tf.selectRegionUpdate(tf.cursorPos)
        }
        tf.NeedsRender()
}

// cursorEnd moves the cursor to the end of the text, updating selection
// if select mode is active.
func (tf *TextField) cursorEnd() {
        ed := len(tf.editText)
        tf.cursorPos = ed
        tf.dispRange.End = len(tf.editText) // try -- display will adjust
        tf.dispRange.Start = max(0, tf.dispRange.End-tf.charWidth)
        if tf.selectMode {
                tf.selectRegionUpdate(tf.cursorPos)
        }
        tf.NeedsRender()
}

// cursorBackspace deletes character(s) immediately before cursor
func (tf *TextField) cursorBackspace(steps int) {
        if tf.hasSelection() {
                tf.deleteSelection()
                return
        }
        if tf.cursorPos < steps {
                steps = tf.cursorPos
        }
        if steps <= 0 {
                return
        }
        tf.editText = append(tf.editText[:tf.cursorPos-steps], tf.editText[tf.cursorPos:]...)
        tf.textEdited()
        tf.cursorBackward(steps)
}

// cursorDelete deletes character(s) immediately after the cursor
func (tf *TextField) cursorDelete(steps int) {
        if tf.hasSelection() {
                tf.deleteSelection()
                return
        }
        if tf.cursorPos+steps > len(tf.editText) {
                steps = len(tf.editText) - tf.cursorPos
        }
        if steps <= 0 {
                return
        }
        tf.editText = append(tf.editText[:tf.cursorPos], tf.editText[tf.cursorPos+steps:]...)
        tf.textEdited()
}

// cursorBackspaceWord deletes words(s) immediately before cursor
func (tf *TextField) cursorBackspaceWord(steps int) {
        if tf.hasSelection() {
                tf.deleteSelection()
                return
        }
        org := tf.cursorPos
        tf.cursorBackwardWord(steps)
        tf.editText = append(tf.editText[:tf.cursorPos], tf.editText[org:]...)
        tf.textEdited()
}

// cursorDeleteWord deletes word(s) immediately after the cursor
func (tf *TextField) cursorDeleteWord(steps int) {
        if tf.hasSelection() {
                tf.deleteSelection()
                return
        }
        // note: no update b/c signal from buf will drive update
        org := tf.cursorPos
        tf.cursorForwardWord(steps)
        tf.editText = append(tf.editText[:tf.cursorPos], tf.editText[org:]...)
        tf.textEdited()
}

// cursorKill deletes text from cursor to end of text
func (tf *TextField) cursorKill() {
        steps := len(tf.editText) - tf.cursorPos
        tf.cursorDelete(steps)
}

////////  Selection

// clearSelected resets both the global selected flag and any current selection
func (tf *TextField) clearSelected() {
        tf.SetState(false, states.Selected)
        tf.selectReset()
}

// hasSelection returns whether there is a selected region of text
func (tf *TextField) hasSelection() bool {
        tf.selectUpdate()
        return tf.selectRange.Start < tf.selectRange.End
}

// selection returns the currently selected text
func (tf *TextField) selection() string {
        if tf.hasSelection() {
                return string(tf.editText[tf.selectRange.Start:tf.selectRange.End])
        }
        return ""
}

// selectModeToggle toggles the SelectMode, updating selection with cursor movement
func (tf *TextField) selectModeToggle() {
        if tf.selectMode {
                tf.selectMode = false
        } else {
                tf.selectMode = true
                tf.selectInit = tf.cursorPos
                tf.selectRange.Start = tf.cursorPos
                tf.selectRange.End = tf.selectRange.Start
        }
}

// shiftSelect sets the selection start if the shift key is down but wasn't previously.
// If the shift key has been released, the selection info is cleared.
func (tf *TextField) shiftSelect(e events.Event) {
        hasShift := e.HasAnyModifier(key.Shift)
        if hasShift && !tf.selectMode {
                tf.selectModeToggle()
                tf.selectModeShift = true
        }
        if !hasShift && tf.selectMode && tf.selectModeShift {
                tf.selectReset()
                tf.selectModeShift = false
        }
}

// selectRegionUpdate updates current select region based on given cursor position
// relative to SelectStart position
func (tf *TextField) selectRegionUpdate(pos int) {
        if pos < tf.selectInit {
                tf.selectRange.Start = pos
                tf.selectRange.End = tf.selectInit
        } else {
                tf.selectRange.Start = tf.selectInit
                tf.selectRange.End = pos
        }
        tf.selectUpdate()
}

// selectAll selects all the text
func (tf *TextField) selectAll() {
        tf.selectRange.Start = 0
        tf.selectInit = 0
        tf.selectRange.End = len(tf.editText)
        if TheApp.SystemPlatform().IsMobile() {
                tf.Send(events.ContextMenu)
        }
        tf.NeedsRender()
}

// selectWord selects the word (whitespace delimited) that the cursor is on
func (tf *TextField) selectWord() {
        sz := len(tf.editText)
        if sz <= 3 {
                tf.selectAll()
                return
        }
        tf.selectRange = textpos.WordAt(tf.editText, tf.cursorPos)
        tf.selectInit = tf.selectRange.Start
        if TheApp.SystemPlatform().IsMobile() {
                tf.Send(events.ContextMenu)
        }
        tf.NeedsRender()
}

// selectReset resets the selection
func (tf *TextField) selectReset() {
        tf.selectMode = false
        if tf.selectRange.Start == 0 && tf.selectRange.End == 0 {
                return
        }
        tf.selectRange.Start = 0
        tf.selectRange.End = 0
        tf.NeedsRender()
}

// selectUpdate updates the select region after any change to the text, to keep it in range
func (tf *TextField) selectUpdate() {
        if tf.selectRange.Start < tf.selectRange.End {
                ed := len(tf.editText)
                if tf.selectRange.Start < 0 {
                        tf.selectRange.Start = 0
                }
                if tf.selectRange.End > ed {
                        tf.selectRange.End = ed
                }
        } else {
                tf.selectReset()
        }
}

// cut cuts any selected text and adds it to the clipboard.
func (tf *TextField) cut() { //types:add
        if tf.NoEcho {
                return
        }
        cut := tf.deleteSelection()
        if cut != "" {
                em := tf.Events()
                if em != nil {
                        em.Clipboard().Write(mimedata.NewText(cut))
                }
        }
}

// deleteSelection deletes any selected text, without adding to clipboard --
// returns text deleted
func (tf *TextField) deleteSelection() string {
        tf.selectUpdate()
        if !tf.hasSelection() {
                return ""
        }
        cut := tf.selection()
        tf.editText = append(tf.editText[:tf.selectRange.Start], tf.editText[tf.selectRange.End:]...)
        if tf.cursorPos > tf.selectRange.Start {
                if tf.cursorPos < tf.selectRange.End {
                        tf.cursorPos = tf.selectRange.Start
                } else {
                        tf.cursorPos -= tf.selectRange.End - tf.selectRange.Start
                }
        }
        tf.textEdited()
        tf.selectReset()
        return cut
}

// copy copies any selected text to the clipboard.
func (tf *TextField) copy() { //types:add
        if tf.NoEcho {
                return
        }
        tf.selectUpdate()
        if !tf.hasSelection() {
                return
        }

        md := mimedata.NewText(tf.selection())
        tf.Clipboard().Write(md)
}

// paste inserts text from the clipboard at current cursor position; if
// cursor is within a current selection, that selection is replaced.
func (tf *TextField) paste() { //types:add
        data := tf.Clipboard().Read([]string{mimedata.TextPlain})
        if data != nil {
                if tf.cursorPos >= tf.selectRange.Start && tf.cursorPos < tf.selectRange.End {
                        tf.deleteSelection()
                }
                tf.insertAtCursor(data.Text(mimedata.TextPlain))
        }
}

// insertAtCursor inserts the given text at current cursor position.
func (tf *TextField) insertAtCursor(str string) {
        if tf.hasSelection() {
                tf.cut()
        }
        rs := []rune(str)
        rsl := len(rs)
        nt := append(tf.editText, rs...)               // first append to end
        copy(nt[tf.cursorPos+rsl:], nt[tf.cursorPos:]) // move stuff to end
        copy(nt[tf.cursorPos:], rs)                    // copy into position
        tf.editText = nt
        tf.dispRange.End += rsl
        tf.textEdited()
        tf.cursorForward(rsl)
}

func (tf *TextField) contextMenu(m *Scene) {
        NewFuncButton(m).SetFunc(tf.copy).SetIcon(icons.Copy).SetKey(keymap.Copy).SetState(tf.NoEcho || !tf.hasSelection(), states.Disabled)
        if !tf.IsReadOnly() {
                NewFuncButton(m).SetFunc(tf.cut).SetIcon(icons.Cut).SetKey(keymap.Cut).SetState(tf.NoEcho || !tf.hasSelection(), states.Disabled)
                paste := NewFuncButton(m).SetFunc(tf.paste).SetIcon(icons.Paste).SetKey(keymap.Paste)
                cb := tf.Scene.Events.Clipboard()
                if cb != nil {
                        paste.SetState(cb.IsEmpty(), states.Disabled)
                }
        }
}

////////  Undo

// textFieldUndoRecord holds one undo record
type textFieldUndoRecord struct {
        text      []rune
        cursorPos int
}

func (ur *textFieldUndoRecord) set(txt []rune, curpos int) {
        ur.text = slices.Clone(txt)
        ur.cursorPos = curpos
}

// textFieldUndos manages everything about the undo process for a [TextField].
type textFieldUndos struct {

        // stack of undo records
        stack []textFieldUndoRecord

        // position within the undo stack
        pos int

        // last time undo was saved, for grouping
        lastSave time.Time
}

func (us *textFieldUndos) saveUndo(txt []rune, curpos int) {
        n := len(us.stack)
        now := time.Now()
        ts := now.Sub(us.lastSave)
        if n > 0 && ts < 250*time.Millisecond {
                r := us.stack[n-1]
                r.set(txt, curpos)
                us.stack[n-1] = r
                return
        }
        r := textFieldUndoRecord{}
        r.set(txt, curpos)
        us.stack = append(us.stack, r)
        us.pos = len(us.stack)
        us.lastSave = now
}

func (tf *TextField) saveUndo() {
        tf.undos.saveUndo(tf.editText, tf.cursorPos)
}

func (us *textFieldUndos) undo(txt []rune, curpos int) *textFieldUndoRecord {
        n := len(us.stack)
        if us.pos <= 0 || n == 0 {
                return &textFieldUndoRecord{}
        }
        if us.pos == n {
                us.lastSave = time.Time{}
                us.saveUndo(txt, curpos)
                us.pos--
        }
        us.pos--
        us.lastSave = time.Time{} // prevent any merging
        r := &us.stack[us.pos]
        return r
}

func (tf *TextField) undo() {
        r := tf.undos.undo(tf.editText, tf.cursorPos)
        if r != nil {
                tf.editText = r.text
                tf.cursorPos = r.cursorPos
                tf.renderVisible = nil
                tf.NeedsRender()
        }
}

func (us *textFieldUndos) redo() *textFieldUndoRecord {
        n := len(us.stack)
        if us.pos >= n-1 {
                return nil
        }
        us.lastSave = time.Time{} // prevent any merging
        us.pos++
        return &us.stack[us.pos]
}

func (tf *TextField) redo() {
        r := tf.undos.redo()
        if r != nil {
                tf.editText = r.text
                tf.cursorPos = r.cursorPos
                tf.renderVisible = nil
                tf.NeedsRender()
        }
}

////////  Complete

// SetCompleter sets completion functions so that completions will
// automatically be offered as the user types.
func (tf *TextField) SetCompleter(data any, matchFun complete.MatchFunc, editFun complete.EditFunc) {
        if matchFun == nil || editFun == nil {
                tf.complete = nil
                return
        }
        tf.complete = NewComplete().SetContext(data).SetMatchFunc(matchFun).SetEditFunc(editFun)
        tf.complete.OnSelect(func(e events.Event) {
                tf.completeText(tf.complete.Completion)
        })
}

// offerComplete pops up a menu of possible completions
func (tf *TextField) offerComplete() {
        if tf.complete == nil {
                return
        }
        s := string(tf.editText[0:tf.cursorPos])
        cpos := tf.charRenderPos(tf.cursorPos, true).ToPoint()
        cpos.X += 5
        cpos.Y = tf.Geom.TotalBBox.Max.Y
        tf.complete.SrcLn = 0
        tf.complete.SrcCh = tf.cursorPos
        tf.complete.Show(tf, cpos, s)
}

// cancelComplete cancels any pending completion -- call this when new events
// have moved beyond any prior completion scenario
func (tf *TextField) cancelComplete() {
        if tf.complete == nil {
                return
        }
        tf.complete.Cancel()
}

// completeText edits the text field using the string chosen from the completion menu
func (tf *TextField) completeText(s string) {
        txt := string(tf.editText) // Reminder: do NOT call tf.Text() in an active editing context!
        c := tf.complete.GetCompletion(s)
        ed := tf.complete.EditFunc(tf.complete.Context, txt, tf.cursorPos, c, tf.complete.Seed)
        st := tf.cursorPos - len(tf.complete.Seed)
        tf.cursorPos = st
        tf.cursorDelete(ed.ForwardDelete)
        tf.insertAtCursor(ed.NewText)
        tf.editDone()
}

////////  Rendering

// hasWordWrap returns true if the layout is multi-line word wrapping
func (tf *TextField) hasWordWrap() bool {
        return tf.Styles.Text.WhiteSpace.HasWordWrap()
}

// charPos returns the relative starting position of the given rune,
// in the overall RenderAll of all the text.
// These positions can be out of visible range: see CharRenderPos
func (tf *TextField) charPos(idx int) math32.Vector2 {
        if idx <= 0 || len(tf.renderAll.Lines) == 0 {
                return math32.Vector2{}
        }
        bb := tf.renderAll.RuneBounds(idx)
        if idx >= len(tf.editText) {
                if tf.numLines > 1 && tf.editText[len(tf.editText)-1] == ' ' {
                        bb.Max.X += tf.lineHeight * 0.2
                        return bb.Max
                }
                return bb.Max
        }
        return bb.Min
}

// relCharPos returns the text width in dots between the two text string
// positions (ed is exclusive -- +1 beyond actual char).
func (tf *TextField) relCharPos(st, ed int) math32.Vector2 {
        return tf.charPos(ed).Sub(tf.charPos(st))
}

// charRenderPos returns the starting render coords for the given character
// position in string -- makes no attempt to rationalize that pos (i.e., if
// not in visible range, position will be out of range too).
// if wincoords is true, then adds window box offset -- for cursor, popups
func (tf *TextField) charRenderPos(charidx int, wincoords bool) math32.Vector2 {
        pos := tf.effPos
        if wincoords {
                sc := tf.Scene
                pos = pos.Add(math32.FromPoint(sc.SceneGeom.Pos))
        }
        cpos := tf.relCharPos(tf.dispRange.Start, charidx)
        return pos.Add(cpos)
}

var (
        // textFieldBlinker manages cursor blinking
        textFieldBlinker = Blinker{}

        // textFieldSpriteName is the name of the window sprite used for the cursor
        textFieldSpriteName = "TextField.Cursor"
)

func init() {
        TheApp.AddQuitCleanFunc(textFieldBlinker.QuitClean)
        textFieldBlinker.Func = func() {
                w := textFieldBlinker.Widget
                textFieldBlinker.Unlock() // comes in locked
                if w == nil {
                        return
                }
                tf := AsTextField(w)
                if !tf.StateIs(states.Focused) || !tf.IsVisible() {
                        tf.blinkOn = false
                        tf.renderCursor(false)
                } else {
                        // Need consistent test results on offscreen.
                        if TheApp.Platform() != system.Offscreen {
                                tf.blinkOn = !tf.blinkOn
                        }
                        tf.renderCursor(tf.blinkOn)
                }
        }
}

// startCursor starts the cursor blinking and renders it
func (tf *TextField) startCursor() {
        if tf == nil || tf.This == nil {
                return
        }
        if !tf.IsVisible() {
                return
        }
        tf.blinkOn = true
        tf.renderCursor(true)
        if SystemSettings.CursorBlinkTime == 0 {
                return
        }
        textFieldBlinker.SetWidget(tf.This.(Widget))
        textFieldBlinker.Blink(SystemSettings.CursorBlinkTime)
}

// clearCursor turns off cursor and stops it from blinking
func (tf *TextField) clearCursor() {
        if tf.IsReadOnly() {
                return
        }
        tf.stopCursor()
        tf.renderCursor(false)
}

// stopCursor stops the cursor from blinking
func (tf *TextField) stopCursor() {
        if tf == nil || tf.This == nil {
                return
        }
        textFieldBlinker.ResetWidget(tf.This.(Widget))
}

// renderCursor renders the cursor on or off, as a sprite that is either on or off
func (tf *TextField) renderCursor(on bool) {
        if tf == nil || tf.This == nil {
                return
        }
        if !on {
                if tf.Scene == nil || tf.Scene.Stage == nil {
                        return
                }
                ms := tf.Scene.Stage.Main
                if ms == nil {
                        return
                }
                spnm := fmt.Sprintf("%v-%v", textFieldSpriteName, tf.lineHeight)
                ms.Sprites.InactivateSprite(spnm)
                return
        }
        if !tf.IsVisible() {
                return
        }

        tf.cursorMu.Lock()
        defer tf.cursorMu.Unlock()

        sp := tf.cursorSprite(on)
        if sp == nil {
                return
        }
        sp.Geom.Pos = tf.charRenderPos(tf.cursorPos, true).ToPointFloor()
}

// cursorSprite returns the Sprite for the cursor (which is
// only rendered once with a vertical bar, and just activated and inactivated
// depending on render status).  On sets the On status of the cursor.
func (tf *TextField) cursorSprite(on bool) *Sprite {
        sc := tf.Scene
        if sc == nil {
                return nil
        }
        ms := sc.Stage.Main
        if ms == nil {
                return nil // only MainStage has sprites
        }
        spnm := fmt.Sprintf("%v-%v", textFieldSpriteName, tf.lineHeight)
        sp, ok := ms.Sprites.SpriteByName(spnm)
        // TODO: figure out how to update caret color on color scheme change
        if !ok {
                bbsz := image.Point{int(math32.Ceil(tf.CursorWidth.Dots)), int(math32.Ceil(tf.lineHeight))}
                if bbsz.X < 2 { // at least 2
                        bbsz.X = 2
                }
                sp = NewSprite(spnm, bbsz, image.Point{})
                sp.Active = on
                ibox := sp.Pixels.Bounds()
                draw.Draw(sp.Pixels, ibox, tf.CursorColor, image.Point{}, draw.Src)
                ms.Sprites.Add(sp)
        }
        if on {
                ms.Sprites.ActivateSprite(sp.Name)
        } else {
                ms.Sprites.InactivateSprite(sp.Name)
        }
        return sp
}

// renderSelect renders the selected region, if any, underneath the text
func (tf *TextField) renderSelect() {
        tf.renderVisible.SelectReset()
        if !tf.hasSelection() {
                return
        }
        dn := tf.dispRange.Len()
        effst := max(0, tf.selectRange.Start-tf.dispRange.Start)
        effed := min(dn, tf.selectRange.End-tf.dispRange.Start)
        if effst == effed {
                return
        }
        // fmt.Println("sel range:", effst, effed)
        tf.renderVisible.SelectRegion(textpos.Range{effst, effed})
}

// autoScroll scrolls the starting position to keep the cursor visible,
// and does various other state-updating steps to ensure everything is updated.
// This is called during Render().
func (tf *TextField) autoScroll() {
        sz := &tf.Geom.Size
        icsz := tf.iconsSize()
        availSz := sz.Actual.Content.Sub(icsz)
        if tf.renderAll != nil {
                availSz.Y += tf.renderAll.LineHeight * 2 // allow it to add a line
        }
        tf.configTextSize(availSz)
        n := len(tf.editText)
        tf.cursorPos = math32.Clamp(tf.cursorPos, 0, n)

        if tf.hasWordWrap() { // does not scroll
                tf.dispRange.Start = 0
                tf.dispRange.End = n
                if len(tf.renderAll.Lines) != tf.numLines {
                        tf.renderVisible = nil
                        tf.NeedsLayout()
                }
                return
        }
        st := &tf.Styles

        if n == 0 || tf.Geom.Size.Actual.Content.X <= 0 {
                tf.cursorPos = 0
                tf.dispRange.End = 0
                tf.dispRange.Start = 0
                return
        }
        maxw := tf.effSize.X
        if maxw < 0 {
                return
        }
        tf.charWidth = int(maxw / st.UnitContext.Dots(units.UnitCh)) // rough guess in chars
        if tf.charWidth < 1 {
                tf.charWidth = 1
        }

        // first rationalize all the values
        if tf.dispRange.End == 0 || tf.dispRange.End > n { // not init
                tf.dispRange.End = n
        }
        if tf.dispRange.Start >= tf.dispRange.End {
                tf.dispRange.Start = max(0, tf.dispRange.End-tf.charWidth)
        }

        inc := int(math32.Ceil(.1 * float32(tf.charWidth)))
        inc = max(4, inc)

        // keep cursor in view with buffer
        startIsAnchor := true
        if tf.cursorPos < (tf.dispRange.Start + inc) {
                tf.dispRange.Start -= inc
                tf.dispRange.Start = max(tf.dispRange.Start, 0)
                tf.dispRange.End = tf.dispRange.Start + tf.charWidth
                tf.dispRange.End = min(n, tf.dispRange.End)
        } else if tf.cursorPos > (tf.dispRange.End - inc) {
                tf.dispRange.End += inc
                tf.dispRange.End = min(tf.dispRange.End, n)
                tf.dispRange.Start = tf.dispRange.End - tf.charWidth
                tf.dispRange.Start = max(0, tf.dispRange.Start)
                startIsAnchor = false
        }
        if tf.dispRange.End < tf.dispRange.Start {
                return
        }

        if startIsAnchor {
                gotWidth := false
                spos := tf.charPos(tf.dispRange.Start).X
                for {
                        w := tf.charPos(tf.dispRange.End).X - spos
                        if w < maxw {
                                if tf.dispRange.End == n {
                                        break
                                }
                                nw := tf.charPos(tf.dispRange.End+1).X - spos
                                if nw >= maxw {
                                        gotWidth = true
                                        break
                                }
                                tf.dispRange.End++
                        } else {
                                tf.dispRange.End--
                        }
                }
                if gotWidth || tf.dispRange.Start == 0 {
                        return
                }
                // otherwise, try getting some more chars by moving up start..
        }

        // end is now anchor
        epos := tf.charPos(tf.dispRange.End).X
        for {
                w := epos - tf.charPos(tf.dispRange.Start).X
                if w < maxw {
                        if tf.dispRange.Start == 0 {
                                break
                        }
                        nw := epos - tf.charPos(tf.dispRange.Start-1).X
                        if nw >= maxw {
                                break
                        }
                        tf.dispRange.Start--
                } else {
                        tf.dispRange.Start++
                }
        }
}

// pixelToCursor finds the cursor position that corresponds to the given pixel location
func (tf *TextField) pixelToCursor(pt image.Point) int {
        ptf := math32.FromPoint(pt)
        rpt := ptf.Sub(tf.effPos)
        if rpt.X <= 0 || rpt.Y < 0 {
                return tf.dispRange.Start
        }
        n := len(tf.editText)
        if tf.hasWordWrap() {
                ix := tf.renderAll.RuneAtPoint(ptf, tf.effPos)
                if ix >= 0 {
                        return ix
                }
                return tf.dispRange.Start
        }
        pr := tf.PointToRelPos(pt)

        px := float32(pr.X)
        st := &tf.Styles
        c := tf.dispRange.Start + int(float64(px/st.UnitContext.Dots(units.UnitCh)))
        c = min(c, n)

        w := tf.relCharPos(tf.dispRange.Start, c).X
        if w > px {
                for w > px {
                        c--
                        if c <= tf.dispRange.Start {
                                c = tf.dispRange.Start
                                break
                        }
                        w = tf.relCharPos(tf.dispRange.Start, c).X
                }
        } else if w < px {
                for c < tf.dispRange.End {
                        wn := tf.relCharPos(tf.dispRange.Start, c+1).X
                        if wn > px {
                                break
                        } else if wn == px {
                                c++
                                break
                        }
                        c++
                }
        }
        return c
}

// setCursorFromPixel finds cursor location from given scene-relative
// pixel location, and sets current cursor to it, updating selection too.
func (tf *TextField) setCursorFromPixel(pt image.Point, selMode events.SelectModes) {
        oldPos := tf.cursorPos
        tf.cursorPos = tf.pixelToCursor(pt)
        if tf.selectMode || selMode != events.SelectOne {
                if !tf.selectMode && selMode != events.SelectOne {
                        tf.selectRange.Start = oldPos
                        tf.selectMode = true
                }
                if !tf.StateIs(states.Sliding) && selMode == events.SelectOne {
                        tf.selectReset()
                } else {
                        tf.selectRegionUpdate(tf.cursorPos)
                }
                tf.selectUpdate()
        } else if tf.hasSelection() {
                tf.selectReset()
        }
        tf.NeedsRender()
}

func (tf *TextField) handleKeyEvents() {
        tf.OnKeyChord(func(e events.Event) {
                kf := keymap.Of(e.KeyChord())
                if DebugSettings.KeyEventTrace {
                        slog.Info("TextField KeyInput", "widget", tf, "keyFunction", kf)
                }
                if !tf.StateIs(states.Focused) && kf == keymap.Abort {
                        return
                }

                // first all the keys that work for both inactive and active
                switch kf {
                case keymap.MoveRight:
                        e.SetHandled()
                        tf.shiftSelect(e)
                        tf.cursorForward(1)
                        tf.offerComplete()
                case keymap.WordRight:
                        e.SetHandled()
                        tf.shiftSelect(e)
                        tf.cursorForwardWord(1)
                        tf.offerComplete()
                case keymap.MoveLeft:
                        e.SetHandled()
                        tf.shiftSelect(e)
                        tf.cursorBackward(1)
                        tf.offerComplete()
                case keymap.WordLeft:
                        e.SetHandled()
                        tf.shiftSelect(e)
                        tf.cursorBackwardWord(1)
                        tf.offerComplete()
                case keymap.MoveDown:
                        if tf.numLines > 1 {
                                e.SetHandled()
                                tf.shiftSelect(e)
                                tf.cursorDown(1)
                        }
                case keymap.MoveUp:
                        if tf.numLines > 1 {
                                e.SetHandled()
                                tf.shiftSelect(e)
                                tf.cursorUp(1)
                        }
                case keymap.Home:
                        e.SetHandled()
                        tf.shiftSelect(e)
                        tf.cancelComplete()
                        tf.cursorStart()
                case keymap.End:
                        e.SetHandled()
                        tf.shiftSelect(e)
                        tf.cancelComplete()
                        tf.cursorEnd()
                case keymap.SelectMode:
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.selectModeToggle()
                case keymap.CancelSelect:
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.selectReset()
                case keymap.SelectAll:
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.selectAll()
                case keymap.Copy:
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.copy()
                }
                if tf.IsReadOnly() || e.IsHandled() {
                        return
                }
                switch kf {
                case keymap.Enter:
                        fallthrough
                case keymap.FocusNext: // we process tab to make it EditDone as opposed to other ways of losing focus
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.editDone()
                        tf.focusNext()
                case keymap.Accept: // ctrl+enter
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.editDone()
                case keymap.FocusPrev:
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.editDone()
                        tf.focusPrev()
                case keymap.Abort: // esc
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.revert()
                        // tf.FocusChanged(FocusInactive)
                case keymap.Backspace:
                        e.SetHandled()
                        tf.saveUndo()
                        tf.cursorBackspace(1)
                        tf.offerComplete()
                        tf.Send(events.Input, e)
                case keymap.Kill:
                        e.SetHandled()
                        tf.cancelComplete()
                        tf.cursorKill()
                        tf.Send(events.Input, e)
                case keymap.Delete:
                        e.SetHandled()
                        tf.saveUndo()
                        tf.cursorDelete(1)
                        tf.offerComplete()
                        tf.Send(events.Input, e)
                case keymap.BackspaceWord:
                        e.SetHandled()
                        tf.saveUndo()
                        tf.cursorBackspaceWord(1)
                        tf.offerComplete()
                        tf.Send(events.Input, e)
                case keymap.DeleteWord:
                        e.SetHandled()
                        tf.saveUndo()
                        tf.cursorDeleteWord(1)
                        tf.offerComplete()
                        tf.Send(events.Input, e)
                case keymap.Cut:
                        e.SetHandled()
                        tf.saveUndo()
                        tf.cancelComplete()
                        tf.cut()
                        tf.Send(events.Input, e)
                case keymap.Paste:
                        e.SetHandled()
                        tf.saveUndo()
                        tf.cancelComplete()
                        tf.paste()
                        tf.Send(events.Input, e)
                case keymap.Undo:
                        e.SetHandled()
                        tf.undo()
                case keymap.Redo:
                        e.SetHandled()
                        tf.redo()
                case keymap.Complete:
                        e.SetHandled()
                        tf.offerComplete()
                case keymap.None:
                        if unicode.IsPrint(e.KeyRune()) {
                                if !e.HasAnyModifier(key.Control, key.Meta) {
                                        e.SetHandled()
                                        tf.saveUndo()
                                        tf.insertAtCursor(string(e.KeyRune()))
                                        if e.KeyRune() == ' ' {
                                                tf.cancelComplete()
                                        } else {
                                                tf.offerComplete()
                                        }
                                        tf.Send(events.Input, e)
                                }
                        }
                }
        })
        tf.OnFocus(func(e events.Event) {
                if tf.IsReadOnly() {
                        e.SetHandled()
                }
        })
        tf.OnFocusLost(func(e events.Event) {
                if tf.IsReadOnly() {
                        e.SetHandled()
                        return
                }
                tf.editDone()
        })
}

func (tf *TextField) Style() {
        tf.WidgetBase.Style()
        tf.CursorWidth.ToDots(&tf.Styles.UnitContext)
}

func (tf *TextField) configTextSize(sz math32.Vector2) math32.Vector2 {
        txt := tf.editText
        if len(txt) == 0 && len(tf.Placeholder) > 0 {
                txt = []rune(tf.Placeholder)
        }
        if tf.NoEcho {
                txt = concealDots(len(tf.editText))
        }
        sty, tsty := tf.Styles.NewRichText()
        etxs := *tsty
        etxs.Align, etxs.AlignV = text.Start, text.Start // only works with this
        tx := rich.NewText(sty, txt)
        tf.renderAll = tf.Scene.TextShaper().WrapLines(tx, sty, &etxs, &AppearanceSettings.Text, sz)
        rsz := tf.renderAll.Bounds.Size().Ceil()
        return rsz
}

func (tf *TextField) iconsSize() math32.Vector2 {
        var sz math32.Vector2
        if lead := tf.leadingIconButton; lead != nil {
                sz.X += lead.Geom.Size.Actual.Total.X
        }
        if trail := tf.trailingIconButton; trail != nil {
                sz.X += trail.Geom.Size.Actual.Total.X
        }
        return sz
}

func (tf *TextField) SizeUp() {
        tf.renderVisible = nil
        tf.Frame.SizeUp()
        txt := tf.editText
        if len(txt) == 0 && len(tf.Placeholder) > 0 {
                txt = []rune(tf.Placeholder)
        }
        tf.dispRange.Start = 0
        tf.dispRange.End = len(txt)

        sz := &tf.Geom.Size
        icsz := tf.iconsSize()
        availSz := sz.Actual.Content.Sub(icsz)

        rsz := tf.configTextSize(availSz)
        rsz.SetAdd(icsz)
        sz.FitSizeMax(&sz.Actual.Content, rsz)
        sz.setTotalFromContent(&sz.Actual)
        tf.lineHeight = tf.Styles.LineHeightDots()
        if DebugSettings.LayoutTrace {
                fmt.Println(tf, "TextField SizeUp:", rsz, "Actual:", sz.Actual.Content)
        }
}

func (tf *TextField) SizeDown(iter int) bool {
        sz := &tf.Geom.Size
        prevContent := sz.Actual.Content
        sz.setInitContentMin(tf.Styles.Min.Dots().Ceil())
        pgrow, _ := tf.growToAllocSize(sz.Actual.Content, sz.Alloc.Content) // get before update
        icsz := tf.iconsSize()
        availSz := pgrow.Sub(icsz)
        rsz := tf.configTextSize(availSz)
        rsz.SetAdd(icsz)
        // start over so we don't reflect hysteresis of prior guess
        chg := prevContent != sz.Actual.Content
        if chg {
                if DebugSettings.LayoutTrace {
                        fmt.Println(tf, "TextField Size Changed:", sz.Actual.Content, "was:", prevContent)
                }
        }
        if tf.Styles.Grow.X > 0 {
                rsz.X = max(pgrow.X, rsz.X)
        }
        if tf.Styles.Grow.Y > 0 {
                rsz.Y = max(pgrow.Y, rsz.Y)
        }
        sz.FitSizeMax(&sz.Actual.Content, rsz)
        sz.setTotalFromContent(&sz.Actual)
        sz.Alloc = sz.Actual // this is important for constraining our children layout:
        redo := tf.Frame.SizeDown(iter)
        return chg || redo
}

func (tf *TextField) SizeFinal() {
        tf.Geom.RelPos.SetZero()
        // tf.sizeFromChildrenFit(0, SizeFinalPass) // key to omit
        tf.growToAlloc()
        tf.sizeFinalChildren()
        tf.styleSizeUpdate() // now that sizes are stable, ensure styling based on size is updated
        tf.sizeFinalParts()
}

func (tf *TextField) ApplyScenePos() {
        tf.Frame.ApplyScenePos()
        tf.setEffPosAndSize()
}

// setEffPosAndSize sets the effective position and size of
// the textfield based on its base position and size
// and its icons or lack thereof
func (tf *TextField) setEffPosAndSize() {
        sz := tf.Geom.Size.Actual.Content
        pos := tf.Geom.Pos.Content
        if lead := tf.leadingIconButton; lead != nil {
                pos.X += lead.Geom.Size.Actual.Total.X
                sz.X -= lead.Geom.Size.Actual.Total.X
        }
        if trail := tf.trailingIconButton; trail != nil {
                sz.X -= trail.Geom.Size.Actual.Total.X
        }
        if tf.renderAll == nil {
                tf.numLines = 0
        } else {
                tf.numLines = len(tf.renderAll.Lines)
        }
        if tf.numLines <= 1 {
                pos.Y += 0.5 * (sz.Y - tf.lineHeight) // center
        }
        tf.effSize = sz.Ceil()
        tf.effPos = pos.Ceil()
}

func (tf *TextField) layoutCurrent() {
        cur := tf.editText[tf.dispRange.Start:tf.dispRange.End]
        clr := tf.Styles.Color
        if len(tf.editText) == 0 && len(tf.Placeholder) > 0 {
                clr = tf.PlaceholderColor
                cur = []rune(tf.Placeholder)
        } else if tf.NoEcho {
                cur = concealDots(len(cur))
        }
        sz := &tf.Geom.Size
        icsz := tf.iconsSize()
        availSz := sz.Actual.Content.Sub(icsz)
        sty, tsty := tf.Styles.NewRichText()
        tsty.Color = colors.ToUniform(clr)
        tx := rich.NewText(sty, cur)
        tf.renderVisible = tf.Scene.TextShaper().WrapLines(tx, sty, tsty, &AppearanceSettings.Text, availSz)
        tf.renderedRange = tf.dispRange
}

func (tf *TextField) Render() {
        defer func() {
                if tf.IsReadOnly() {
                        return
                }
                if tf.StateIs(states.Focused) {
                        tf.startCursor()
                } else {
                        tf.stopCursor()
                }
        }()

        tf.autoScroll() // does all update checking, inits paint with our style
        tf.RenderAllocBox()
        if tf.dispRange.Start < 0 || tf.dispRange.End > len(tf.editText) {
                return
        }
        if tf.renderVisible == nil || tf.dispRange != tf.renderedRange {
                tf.layoutCurrent()
        }
        tf.renderSelect()
        tf.Scene.Painter.DrawText(tf.renderVisible, tf.effPos)
}

// concealDots creates an n-length []rune of bullet characters.
func concealDots(n int) []rune {
        dots := make([]rune, n)
        for i := range dots {
                dots[i] = '•'
        }
        return dots
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "reflect"
        "strconv"
        "time"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// TimePicker is a widget for picking a time.
type TimePicker struct {
        Frame

        // Time is the time that we are viewing.
        Time time.Time

        // the raw input hour
        hour int

        // whether we are in pm mode (so we have to add 12h to everything)
        pm bool
}

func (tp *TimePicker) WidgetValue() any { return &tp.Time }

func (tp *TimePicker) Init() {
        tp.Frame.Init()
        spinnerInit := func(w *Spinner) {
                w.Styler(func(s *styles.Style) {
                        s.Font.Size.Dp(57)
                        s.Min.X.Ch(7)
                })
                buttonInit := func(w *Button) {
                        tree.AddChildInit(w, "icon", func(w *Icon) {
                                w.Styler(func(s *styles.Style) {
                                        s.Font.Size.Dp(32)
                                })
                        })
                }
                tree.AddChildInit(w, "lead-icon", buttonInit)
                tree.AddChildInit(w, "trail-icon", buttonInit)
        }
        tree.AddChild(tp, func(w *Spinner) {
                spinnerInit(w)
                w.SetStep(1).SetEnforceStep(true)
                w.Updater(func() {
                        if SystemSettings.Clock24 {
                                tp.hour = tp.Time.Hour()
                                w.SetMax(24).SetMin(0)
                        } else {
                                tp.hour = tp.Time.Hour() % 12
                                if tp.hour == 0 {
                                        tp.hour = 12
                                }
                                w.SetMax(12).SetMin(1)
                        }
                        w.SetValue(float32(tp.hour))
                })
                w.OnChange(func(e events.Event) {
                        hr := int(w.Value)
                        if hr == 12 && !SystemSettings.Clock24 {
                                hr = 0
                        }
                        tp.hour = hr
                        if tp.pm {
                                // only add to local variable
                                hr += 12
                        }
                        // we set our hour and keep everything else
                        tt := tp.Time
                        tp.Time = time.Date(tt.Year(), tt.Month(), tt.Day(), hr, tt.Minute(), tt.Second(), tt.Nanosecond(), tt.Location())
                        tp.SendChange()
                })
        })
        tree.AddChild(tp, func(w *Text) {
                w.SetType(TextDisplayLarge).SetText(":")
                w.Styler(func(s *styles.Style) {
                        s.SetTextWrap(false)
                        s.Min.X.Ch(1)
                })
        })
        tree.AddChild(tp, func(w *Spinner) {
                spinnerInit(w)
                w.SetStep(1).SetEnforceStep(true).
                        SetMin(0).SetMax(59).SetFormat("%02d")
                w.Updater(func() {
                        w.SetValue(float32(tp.Time.Minute()))
                })
                w.OnChange(func(e events.Event) {
                        // we set our minute and keep everything else
                        tt := tp.Time
                        tp.Time = time.Date(tt.Year(), tt.Month(), tt.Day(), tt.Hour(), int(w.Value), tt.Second(), tt.Nanosecond(), tt.Location())
                        tp.SendChange()
                })
        })
        tp.Maker(func(p *tree.Plan) {
                if !SystemSettings.Clock24 {
                        tree.Add(p, func(w *Switches) {
                                w.SetMutex(true).SetAllowNone(false).SetType(SwitchSegmentedButton).SetItems(SwitchItem{Value: "AM"}, SwitchItem{Value: "PM"})
                                tp.pm = tp.Time.Hour() >= 12
                                w.Styler(func(s *styles.Style) {
                                        s.Direction = styles.Column
                                })
                                w.Updater(func() {
                                        if tp.pm {
                                                w.SelectValue("PM")
                                        } else {
                                                w.SelectValue("AM")
                                        }
                                })
                                w.OnChange(func(e events.Event) {
                                        si := w.SelectedItem()
                                        tt := tp.Time
                                        if tp.hour == 12 {
                                                tp.hour = 0
                                        }
                                        switch si.Value {
                                        case "AM":
                                                tp.pm = false
                                                tp.Time = time.Date(tt.Year(), tt.Month(), tt.Day(), tp.hour, tt.Minute(), tt.Second(), tt.Nanosecond(), tt.Location())
                                        case "PM":
                                                tp.pm = true
                                                tp.Time = time.Date(tt.Year(), tt.Month(), tt.Day(), tp.hour+12, tt.Minute(), tt.Second(), tt.Nanosecond(), tt.Location())
                                        }
                                        tp.SendChange()
                                })
                        })
                }
        })
}

var shortMonths = []string{"Jan", "Feb", "Apr", "Mar", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}

// DatePicker is a widget for picking a date.
type DatePicker struct {
        Frame

        // Time is the time that we are viewing.
        Time time.Time

        // getTime converts the given calendar grid index to its corresponding time.
        // We must store this logic in a closure so that it can always be recomputed
        // correctly in the inner closures of the grid maker; otherwise, the local
        // variables needed would be stale.
        getTime func(i int) time.Time

        // som is the start of the month (must be set here to avoid stale variables).
        som time.Time
}

// setTime sets the source time and updates the picker.
func (dp *DatePicker) setTime(tim time.Time) {
        dp.SetTime(tim).UpdateChange()
}

func (dp *DatePicker) Init() {
        dp.Frame.Init()
        dp.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
        })

        tree.AddChild(dp, func(w *Frame) {
                w.Styler(func(s *styles.Style) {
                        s.Gap.Zero()
                })
                arrowStyle := func(s *styles.Style) {
                        s.Padding.SetHorizontal(units.Dp(12))
                        s.Color = colors.Scheme.OnSurfaceVariant
                }
                tree.AddChild(w, func(w *Button) {
                        w.SetType(ButtonAction).SetIcon(icons.NavigateBefore)
                        w.OnClick(func(e events.Event) {
                                dp.setTime(dp.Time.AddDate(0, -1, 0))
                        })
                        w.Styler(arrowStyle)
                })
                tree.AddChild(w, func(w *Chooser) {
                        sms := make([]ChooserItem, len(shortMonths))
                        for i, sm := range shortMonths {
                                sms[i] = ChooserItem{Value: sm}
                        }
                        w.SetItems(sms...)
                        w.Updater(func() {
                                w.SetCurrentIndex(int(dp.Time.Month() - 1))
                        })
                        w.OnChange(func(e events.Event) {
                                // set our month
                                dp.setTime(dp.Time.AddDate(0, w.CurrentIndex+1-int(dp.Time.Month()), 0))
                        })
                })
                tree.AddChild(w, func(w *Button) {
                        w.SetType(ButtonAction).SetIcon(icons.NavigateNext)
                        w.OnClick(func(e events.Event) {
                                dp.setTime(dp.Time.AddDate(0, 1, 0))
                        })
                        w.Styler(arrowStyle)
                })
                tree.AddChild(w, func(w *Button) {
                        w.SetType(ButtonAction).SetIcon(icons.NavigateBefore)
                        w.OnClick(func(e events.Event) {
                                dp.setTime(dp.Time.AddDate(-1, 0, 0))
                        })
                        w.Styler(arrowStyle)
                })
                tree.AddChild(w, func(w *Chooser) {
                        w.Updater(func() {
                                yr := dp.Time.Year()
                                var yrs []ChooserItem
                                // we go 100 in each direction from the current year
                                for i := yr - 100; i <= yr+100; i++ {
                                        yrs = append(yrs, ChooserItem{Value: i})
                                }
                                w.SetItems(yrs...)
                                w.SetCurrentValue(yr)
                        })
                        w.OnChange(func(e events.Event) {
                                // we are centered at current year with 100 in each direction
                                nyr := w.CurrentIndex + dp.Time.Year() - 100
                                // set our year
                                dp.setTime(dp.Time.AddDate(nyr-dp.Time.Year(), 0, 0))
                        })
                })
                tree.AddChild(w, func(w *Button) {
                        w.SetType(ButtonAction).SetIcon(icons.NavigateNext)
                        w.OnClick(func(e events.Event) {
                                dp.setTime(dp.Time.AddDate(1, 0, 0))
                        })
                        w.Styler(arrowStyle)
                })
        })
        tree.AddChild(dp, func(w *Frame) {
                w.Styler(func(s *styles.Style) {
                        s.Display = styles.Grid
                        s.Columns = 7
                })
                w.Maker(func(p *tree.Plan) {
                        // start of the month
                        som := dp.Time.AddDate(0, 0, -dp.Time.Day()+1)
                        // end of the month
                        eom := dp.Time.AddDate(0, 1, -dp.Time.Day())
                        // start of the week containing the start of the month
                        somw := som.AddDate(0, 0, -int(som.Weekday()))
                        // year day of the start of the week containing the start of the month
                        somwyd := somw.YearDay()
                        // end of the week containing the end of the month
                        eomw := eom.AddDate(0, 0, int(6-eom.Weekday()))
                        // year day of the end of the week containing the end of the month
                        eomwyd := eomw.YearDay()
                        // if we have moved up a year (happens in December),
                        // we add the number of days in this year
                        if eomw.Year() > somw.Year() {
                                eomwyd += time.Date(somw.Year(), 13, -1, 0, 0, 0, 0, somw.Location()).YearDay()
                        }
                        dp.getTime = func(i int) time.Time {
                                return somw.AddDate(0, 0, i)
                        }
                        dp.som = som
                        for i := range 1 + eomwyd - somwyd {
                                tree.AddAt(p, strconv.Itoa(i), func(w *Button) {
                                        w.SetType(ButtonAction)
                                        w.Updater(func() {
                                                w.SetText(strconv.Itoa(dp.getTime(i).Day()))
                                        })
                                        w.OnClick(func(e events.Event) {
                                                dp.setTime(dp.getTime(i))
                                        })
                                        w.Styler(func(s *styles.Style) {
                                                s.CenterAll()
                                                s.Min.Set(units.Dp(32))
                                                s.Padding.Set(units.Dp(6))
                                                dt := dp.getTime(i)
                                                if dt.Month() != dp.som.Month() {
                                                        s.Color = colors.Scheme.OnSurfaceVariant
                                                }
                                                if dt.Year() == time.Now().Year() && dt.YearDay() == time.Now().YearDay() {
                                                        s.Border.Width.Set(units.Dp(1))
                                                        s.Border.Color.Set(colors.Scheme.Primary.Base)
                                                        s.Color = colors.Scheme.Primary.Base
                                                }
                                                if dt.Year() == dp.Time.Year() && dt.YearDay() == dp.Time.YearDay() {
                                                        s.Background = colors.Scheme.Primary.Base
                                                        s.Color = colors.Scheme.Primary.On
                                                }
                                        })
                                        tree.AddChildInit(w, "text", func(w *Text) {
                                                w.FinalUpdater(func() {
                                                        w.SetType(TextBodyLarge)
                                                })
                                        })
                                })
                        }
                })
        })
}

// TimeInput presents two text fields for editing a date and time,
// both of which can pull up corresponding picker dialogs.
type TimeInput struct {
        Frame
        Time time.Time

        // DisplayDate is whether the date input is displayed (default true).
        DisplayDate bool

        // DisplayTime is whether the time input is displayed (default true).
        DisplayTime bool
}

func (ti *TimeInput) WidgetValue() any { return &ti.Time }

func (ti *TimeInput) OnBind(value any, tags reflect.StructTag) {
        switch tags.Get("display") {
        case "date":
                ti.DisplayTime = false
        case "time":
                ti.DisplayDate = false
        }
}

func (ti *TimeInput) Init() {
        ti.Frame.Init()

        ti.DisplayDate = true
        ti.DisplayTime = true

        style := func(s *styles.Style) {
                s.Min.X.Em(8)
                s.Max.X.Em(10)
                if ti.IsReadOnly() { // must inherit abilities when read only for table
                        s.Abilities = ti.Styles.Abilities
                }
        }

        ti.Maker(func(p *tree.Plan) {
                if ti.DisplayDate {
                        tree.Add(p, func(w *TextField) {
                                w.SetTooltip("The date")
                                w.SetLeadingIcon(icons.CalendarToday, func(e events.Event) {
                                        d := NewBody("Select date")
                                        dp := NewDatePicker(d).SetTime(ti.Time)
                                        d.AddBottomBar(func(bar *Frame) {
                                                d.AddCancel(bar)
                                                d.AddOK(bar).OnClick(func(e events.Event) {
                                                        ti.Time = dp.Time
                                                        ti.UpdateChange()
                                                })
                                        })
                                        d.RunDialog(w)
                                })
                                w.Styler(style)
                                w.Updater(func() {
                                        w.SetReadOnly(ti.IsReadOnly())
                                        w.SetText(ti.Time.Format("1/2/2006"))
                                })
                                w.SetValidator(func() error {
                                        d, err := time.Parse("1/2/2006", w.Text())
                                        if err != nil {
                                                return err
                                        }
                                        // new date and old time
                                        ti.Time = time.Date(d.Year(), d.Month(), d.Day(), ti.Time.Hour(), ti.Time.Minute(), ti.Time.Second(), ti.Time.Nanosecond(), ti.Time.Location())
                                        ti.SendChange()
                                        return nil
                                })
                        })
                }

                if ti.DisplayTime {
                        tree.Add(p, func(w *TextField) {
                                w.SetTooltip("The time")
                                w.SetLeadingIcon(icons.Schedule, func(e events.Event) {
                                        d := NewBody("Edit time")
                                        tp := NewTimePicker(d).SetTime(ti.Time)
                                        d.AddBottomBar(func(bar *Frame) {
                                                d.AddCancel(bar)
                                                d.AddOK(bar).OnClick(func(e events.Event) {
                                                        ti.Time = tp.Time
                                                        ti.UpdateChange()
                                                })
                                        })
                                        d.RunDialog(w)
                                })
                                w.Styler(style)
                                w.Updater(func() {
                                        w.SetReadOnly(ti.IsReadOnly())
                                        w.SetText(ti.Time.Format(SystemSettings.TimeFormat()))
                                })
                                w.SetValidator(func() error {
                                        t, err := time.Parse(SystemSettings.TimeFormat(), w.Text())
                                        if err != nil {
                                                return err
                                        }
                                        // old date and new time
                                        ti.Time = time.Date(ti.Time.Year(), ti.Time.Month(), ti.Time.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), ti.Time.Location())
                                        ti.SendChange()
                                        return nil
                                })
                        })
                }
        })
}

// DurationInput represents a [time.Duration] value with a spinner and unit chooser.
type DurationInput struct {
        Frame

        Duration time.Duration

        // Unit is the unit of time.
        Unit string
}

func (di *DurationInput) WidgetValue() any { return &di.Duration }

func (di *DurationInput) Init() {
        di.Frame.Init()
        tree.AddChild(di, func(w *Spinner) {
                w.SetStep(1).SetPageStep(10)
                w.SetTooltip("The value of time")
                w.Updater(func() {
                        if di.Unit == "" {
                                di.setAutoUnit()
                        }
                        w.SetValue(float32(di.Duration) / float32(durationUnitsMap[di.Unit]))
                        w.SetReadOnly(di.IsReadOnly())
                })
                w.OnChange(func(e events.Event) {
                        di.Duration = time.Duration(w.Value * float32(durationUnitsMap[di.Unit]))
                        di.SendChange()
                })
        })
        tree.AddChild(di, func(w *Chooser) {
                Bind(&di.Unit, w)

                units := make([]ChooserItem, len(durationUnits))
                for i, u := range durationUnits {
                        units[i] = ChooserItem{Value: u}
                }

                w.SetItems(units...)
                w.SetTooltip("The unit of time")
                w.Updater(func() {
                        w.SetReadOnly(di.IsReadOnly())
                })
                w.OnChange(func(e events.Event) {
                        di.Update()
                })
        })
}

// setAutoUnit sets the [DurationInput.Unit] automatically based on the current duration.
func (di *DurationInput) setAutoUnit() {
        di.Unit = durationUnits[0]
        for _, u := range durationUnits {
                if durationUnitsMap[u] > di.Duration {
                        break
                }
                di.Unit = u
        }
}

var durationUnits = []string{
        "nanoseconds",
        "microseconds",
        "milliseconds",
        "seconds",
        "minutes",
        "hours",
        "days",
        "weeks",
        "months",
        "years",
}

var durationUnitsMap = map[string]time.Duration{
        "nanoseconds":  time.Nanosecond,
        "microseconds": time.Microsecond,
        "milliseconds": time.Millisecond,
        "seconds":      time.Second,
        "minutes":      time.Minute,
        "hours":        time.Hour,
        "days":         24 * time.Hour,
        "weeks":        7 * 24 * time.Hour,
        "months":       30 * 24 * time.Hour,
        "years":        365 * 24 * time.Hour,
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "cogentcore.org/core/colors"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// Toolbar is a [Frame] that is useful for holding [Button]s that do things.
// It automatically moves items that do not fit into an overflow menu, and
// manages additional items that are always placed onto this overflow menu.
// Toolbars are frequently added in [Body.AddTopBar]. All toolbars use the
// [WidgetBase.Maker] system, so you cannot directly add widgets; see
// https://cogentcore.org/core/toolbar.
type Toolbar struct {
        Frame

        // OverflowMenus are functions for configuring the overflow menu of the
        // toolbar. You can use [Toolbar.AddOverflowMenu] to add them.
        // These are processed in reverse order (last in, first called)
        // so that the default items are added last.
        OverflowMenus []func(m *Scene) `set:"-" json:"-" xml:"-"`

        // allItemsPlan has all the items, during layout sizing
        allItemsPlan *tree.Plan

        // overflowItems are items moved from the main toolbar that will be
        // shown in the overflow menu.
        overflowItems []*tree.PlanItem

        // overflowButton is the widget to pull up the overflow menu.
        overflowButton *Button
}

// ToolbarMaker is an interface that types can implement to make a toolbar plan.
// It is automatically used when making [Value] dialogs.
type ToolbarMaker interface {
        MakeToolbar(p *tree.Plan)
}

func (tb *Toolbar) Init() {
        tb.Frame.Init()
        ToolbarStyles(tb)
        tb.FinalMaker(func(p *tree.Plan) { // must go at end
                tree.AddAt(p, "overflow-menu", func(w *Button) {
                        ic := icons.MoreVert
                        if tb.Styles.Direction != styles.Row {
                                ic = icons.MoreHoriz
                        }
                        w.SetIcon(ic).SetTooltip("Additional menu items")
                        w.Updater(func() {
                                tb, ok := w.Parent.(*Toolbar)
                                if ok {
                                        w.Menu = tb.overflowMenu
                                }
                        })
                })
        })
}

func (tb *Toolbar) SizeUp() {
        if tb.Styles.Wrap {
                tb.getOverflowButton()
                tb.setOverflowMenuVisibility()
                tb.Frame.SizeUp()
                return
        }
        tb.allItemsToChildren()
        tb.Frame.SizeUp()
}

func (tb *Toolbar) SizeDown(iter int) bool {
        if tb.Styles.Wrap {
                return tb.Frame.SizeDown(iter)
        }
        redo := tb.Frame.SizeDown(iter)
        if iter == 0 {
                return true // ensure a second pass
        }
        if tb.Scene.showIter > 0 {
                tb.moveToOverflow()
        }
        return redo
}

func (tb *Toolbar) SizeFromChildren(iter int, pass LayoutPasses) math32.Vector2 {
        csz := tb.Frame.SizeFromChildren(iter, pass)
        if pass == SizeUpPass || (pass == SizeDownPass && iter == 0) {
                dim := tb.Styles.Direction.Dim()
                ovsz := tb.Styles.UnitContext.FontEm * 2
                if tb.overflowButton != nil {
                        ovsz = tb.overflowButton.Geom.Size.Actual.Total.Dim(dim)
                }
                csz.SetDim(dim, ovsz) // present the minimum size initially
                return csz
        }
        return csz
}

// allItemsToChildren moves the overflow items back to the children,
// so the full set is considered for the next layout round,
// and ensures the overflow button is made and moves it
// to the end of the list.
func (tb *Toolbar) allItemsToChildren() {
        tb.overflowItems = nil
        tb.allItemsPlan = &tree.Plan{}
        tb.Make(tb.allItemsPlan)
        np := len(tb.allItemsPlan.Children)
        if tb.NumChildren() != np {
                tb.Scene.RenderWidget()
                tb.Update() // todo: needs one more redraw here
        }
}

func (tb *Toolbar) parentSize() float32 {
        ma := tb.Styles.Direction.Dim()
        psz := tb.parentWidget().Geom.Size.Alloc.Content.Sub(tb.Geom.Size.Space)
        avail := psz.Dim(ma)
        return avail
}

func (tb *Toolbar) getOverflowButton() {
        tb.overflowButton = nil
        li := tb.Children[tb.NumChildren()-1]
        if li == nil {
                return
        }
        if ob, ok := li.(*Button); ok {
                tb.overflowButton = ob
        }
}

// moveToOverflow moves overflow out of children to the OverflowItems list
func (tb *Toolbar) moveToOverflow() {
        if !tb.HasChildren() {
                return
        }
        ma := tb.Styles.Direction.Dim()
        avail := tb.parentSize()
        tb.getOverflowButton()
        if tb.overflowButton == nil {
                return
        }
        ovsz := tb.overflowButton.Geom.Size.Actual.Total.Dim(ma)
        avsz := avail - ovsz
        sz := &tb.Geom.Size
        sz.Alloc.Total.SetDim(ma, avail)
        sz.setContentFromTotal(&sz.Alloc)
        n := len(tb.Children)
        pn := len(tb.allItemsPlan.Children)
        ovidx := n - 1
        hasOv := false
        szsum := float32(0)
        tb.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                if i >= n-1 {
                        return tree.Break
                }
                ksz := cwb.Geom.Size.Alloc.Total.Dim(ma)
                szsum += ksz
                if szsum > avsz {
                        if !hasOv {
                                ovidx = i
                                hasOv = true
                        }
                        pi := tb.allItemsPlan.Children[i]
                        tb.overflowItems = append(tb.overflowItems, pi)
                }
                return tree.Continue
        })
        if hasOv {
                p := &tree.Plan{}
                p.Children = tb.allItemsPlan.Children[:ovidx]
                p.Children = append(p.Children, tb.allItemsPlan.Children[pn-1]) // ovm
                p.Update(tb)
        }
        if len(tb.overflowItems) == 0 && len(tb.OverflowMenus) == 0 {
                tb.overflowButton.SetState(true, states.Invisible)
        } else {
                tb.overflowButton.SetState(false, states.Invisible)
                tb.overflowButton.Update()
        }
        tb.setOverflowMenuVisibility()
}

func (tb *Toolbar) setOverflowMenuVisibility() {
        if tb.overflowButton == nil {
                return
        }
        if len(tb.overflowItems) == 0 && len(tb.OverflowMenus) == 0 {
                tb.overflowButton.SetState(true, states.Invisible)
        } else {
                tb.overflowButton.SetState(false, states.Invisible)
                tb.overflowButton.Update()
        }
}

// overflowMenu adds the overflow menu to the given Scene.
func (tb *Toolbar) overflowMenu(m *Scene) {
        nm := len(tb.OverflowMenus)
        ni := len(tb.overflowItems)
        if ni > 0 {
                p := &tree.Plan{}
                p.Children = tb.overflowItems
                p.Update(m)
                if nm > 1 { // default includes sep
                        NewSeparator(m)
                }
        }
        // reverse order so defaults are last
        for i := nm - 1; i >= 0; i-- {
                fn := tb.OverflowMenus[i]
                fn(m)
        }
}

// AddOverflowMenu adds the given menu function to the overflow menu list.
// These functions are called in reverse order such that the last added function
// is called first when constructing the menu.
func (tb *Toolbar) AddOverflowMenu(fun func(m *Scene)) {
        tb.OverflowMenus = append(tb.OverflowMenus, fun)
}

// ToolbarStyles styles the given widget to have standard toolbar styling.
func ToolbarStyles(w Widget) {
        wb := w.AsWidget()
        wb.Styler(func(s *styles.Style) {
                s.Border.Radius = styles.BorderRadiusFull
                s.Background = colors.Scheme.SurfaceContainer
                s.Gap.Zero()
                s.Align.Items = styles.Center
                if len(wb.Children) == 0 {
                        // we must not render toolbars with no children
                        s.Display = styles.DisplayNone
                } else {
                        s.Display = styles.Flex
                }
        })
        wb.FinalStyler(func(s *styles.Style) {
                if s.Direction == styles.Row {
                        s.Grow.Set(1, 0)
                        s.Padding.SetHorizontal(units.Dp(16))
                } else {
                        s.Grow.Set(0, 1)
                        s.Padding.SetVertical(units.Dp(16))
                }
        })
        wb.SetOnChildAdded(func(n tree.Node) {
                if bt := AsButton(n); bt != nil {
                        bt.Type = ButtonAction
                        return
                }
                if sp, ok := n.(*Separator); ok {
                        sp.Styler(func(s *styles.Style) {
                                s.Direction = wb.Styles.Direction.Other()
                        })
                }
        })
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
)

// DefaultTooltipPos returns the default position for the tooltip
// for this widget in window coordinates using the window bounding box.
func (wb *WidgetBase) DefaultTooltipPos() image.Point {
        bb := wb.winBBox()
        pos := bb.Min
        pos.X += (bb.Max.X - bb.Min.X) / 2 // center on X
        // top of Y
        return pos
}

// newTooltipFromScene returns a new Tooltip stage with given scene contents,
// in connection with given widget (which provides key context).
// Make further configuration choices using Set* methods, which
// can be chained directly after the New call.
// Use an appropriate Run call at the end to start the Stage running.
func newTooltipFromScene(sc *Scene, ctx Widget) *Stage {
        return NewPopupStage(TooltipStage, sc, ctx)
}

// newTooltip returns a new tooltip stage displaying the given tooltip text
// for the given widget based at the given window-level position, with the size
// defaulting to the size of the widget.
func newTooltip(w Widget, tooltip string, pos image.Point) *Stage {
        return newTooltipTextSize(w, tooltip, pos, w.AsWidget().winBBox().Size())
}

// newTooltipTextSize returns a new tooltip stage displaying the given tooltip text
// for the given widget at the given window-level position with the given size.
func newTooltipTextSize(w Widget, tooltip string, pos, sz image.Point) *Stage {
        return newTooltipFromScene(newTooltipScene(w, tooltip, pos, sz), w)
}

// newTooltipScene returns a new tooltip scene for the given widget with the
// given tooltip based on the given context position and context size.
func newTooltipScene(w Widget, tooltip string, pos, sz image.Point) *Scene {
        sc := NewScene(w.AsTree().Name + "-tooltip")
        // tooltip positioning uses the original scene geom as the context values
        sc.SceneGeom.Pos = pos
        sc.SceneGeom.Size = sz // used for positioning if needed
        sc.Styler(func(s *styles.Style) {
                s.Border.Radius = styles.BorderRadiusExtraSmall
                s.Grow.Set(1, 1)
                s.Overflow.Set(styles.OverflowVisible) // key for avoiding sizing errors when re-rendering with small pref size
                s.Padding.Set(units.Dp(8))
                s.Background = colors.Scheme.InverseSurface
                s.Color = colors.Scheme.InverseOnSurface
                s.BoxShadow = styles.BoxShadow1()
        })
        NewText(sc).SetType(TextBodyMedium).SetText(tooltip).
                Styler(func(s *styles.Style) {
                        s.SetTextWrap(true)
                        s.Max.X.Em(20)
                })
        return sc
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "bytes"
        "fmt"
        "image"
        "log/slog"
        "strings"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/base/iox/jsonx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/tree"
)

// Treer is an interface for [Tree] types
// providing access to the base [Tree] and
// overridable method hooks for actions taken on the [Tree],
// including OnOpen, OnClose, etc.
type Treer interface { //types:add
        Widget

        // AsTree returns the base [Tree] for this node.
        AsCoreTree() *Tree

        // CanOpen returns true if the node is able to open.
        // By default it checks HasChildren(), but could check other properties
        // to perform lazy building of the tree.
        CanOpen() bool

        // OnOpen is called when a node is toggled open.
        // The base version does nothing.
        OnOpen()

        // OnClose is called when a node is toggled closed.
        // The base version does nothing.
        OnClose()

        // The following are all tree editing functions:

        MimeData(md *mimedata.Mimes)
        Cut()
        Copy()
        Paste()
        DragDrop(e events.Event)
        DropDeleteSource(e events.Event)
}

// AsTree returns the given value as a [Tree] if it has
// an AsCoreTree() method, or nil otherwise.
func AsTree(n tree.Node) *Tree {
        if t, ok := n.(Treer); ok {
                return t.AsCoreTree()
        }
        return nil
}

// note: see treesync.go for all the SyncNode mode specific
// functions.

// Tree provides a graphical representation of a tree structure,
// providing full navigation and manipulation abilities.
//
// It does not handle layout by itself, so if you want it to scroll
// separately from the rest of the surrounding context, you must
// place it in a [Frame].
//
// If the [Tree.SyncNode] field is non-nil, typically via the
// [Tree.SyncTree] method, then the Tree mirrors another
// tree structure, and tree editing functions apply to
// the source tree first, and then to the Tree by sync.
//
// Otherwise, data can be directly encoded in a Tree
// derived type, to represent any kind of tree structure
// and associated data.
//
// Standard [events.Event]s are sent to any listeners, including
// [events.Select], [events.Change], and [events.DoubleClick].
// The selected nodes are in the root [Tree.SelectedNodes] list;
// select events are sent to both selected nodes and the root node.
// See [Tree.IsRootSelected] to check whether a select event on the root
// node corresponds to the root node or another node.
type Tree struct {
        WidgetBase

        // SyncNode, if non-nil, is the [tree.Node] that this widget is
        // viewing in the tree (the source). It should be set using
        // [Tree.SyncTree].
        SyncNode tree.Node `set:"-" copier:"-" json:"-" xml:"-"`

        // Text is the text to display for the tree item label, which automatically
        // defaults to the [tree.Node.Name] of the tree node. It has no effect
        // if [Tree.SyncNode] is non-nil.
        Text string

        // Icon is an optional icon displayed to the the left of the text label.
        Icon icons.Icon

        // IconOpen is the icon to use for an open (expanded) branch;
        // it defaults to [icons.KeyboardArrowDown].
        IconOpen icons.Icon

        // IconClosed is the icon to use for a closed (collapsed) branch;
        // it defaults to [icons.KeyboardArrowRight].
        IconClosed icons.Icon

        // IconLeaf is the icon to use for a terminal node branch that has no children;
        // it defaults to [icons.Blank].
        IconLeaf icons.Icon

        // TreeInit is a function that can be set on the root node that is called
        // with each child tree node when it is initialized. It is only
        // called with the root node itself in [Tree.SetTreeInit], so you
        // should typically call that instead of setting this directly.
        TreeInit func(tr *Tree) `set:"-" json:"-" xml:"-"`

        // Indent is the amount to indent children relative to this node.
        // It should be set in a Styler like all other style properties.
        Indent units.Value `copier:"-" json:"-" xml:"-"`

        // OpenDepth is the depth for nodes be initialized as open (default 4).
        // Nodes beyond this depth will be initialized as closed.
        OpenDepth int `copier:"-" json:"-" xml:"-"`

        // Closed is whether this tree node is currently toggled closed
        // (children not visible).
        Closed bool

        // SelectMode, when set on the root node, determines whether keyboard movements should update selection.
        SelectMode bool

        // Computed fields:

        // linear index of this node within the entire tree.
        // updated on full rebuilds and may sometimes be off,
        // but close enough for expected uses
        viewIndex int

        // size of just this node widget.
        // our alloc includes all of our children, but we only draw us.
        widgetSize math32.Vector2

        // Root is the cached root of the tree. It is automatically set.
        Root Treer `copier:"-" json:"-" xml:"-" edit:"-" set:"-"`

        // SelectedNodes holds the currently selected nodes.
        // It is only set on the root node. See [Tree.GetSelectedNodes]
        // for a version that also works on non-root nodes.
        SelectedNodes []Treer `copier:"-" json:"-" xml:"-" edit:"-" set:"-"`

        // actStateLayer is the actual state layer of the tree, which
        // should be used when rendering it and its parts (but not its children).
        // the reason that it exists is so that the children of the tree
        // (other trees) do not inherit its stateful background color, as
        // that does not look good.
        actStateLayer float32

        // inOpen is set in the Open method to prevent recursive opening for lazy-open nodes.
        inOpen bool

        // Branch is the branch widget that is used to open and close the tree node.
        Branch *Switch `json:"-" xml:"-" copier:"-" set:"-" display:"-"`
}

// AsCoreTree satisfies the [Treer] interface.
func (tr *Tree) AsCoreTree() *Tree {
        return tr
}

// rootSetViewIndex sets the [Tree.root] and [Tree.viewIndex] for all nodes.
// It returns the total number of leaves in the tree.
func (tr *Tree) rootSetViewIndex() int {
        idx := 0
        tr.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                tvn := AsTree(cw)
                if tvn != nil {
                        tvn.viewIndex = idx
                        if tvn.Root == nil {
                                tvn.Root = tr
                        }
                        idx++
                }
                return tree.Continue
        })
        return idx
}

func (tr *Tree) Init() {
        tr.WidgetBase.Init()
        tr.AddContextMenu(tr.contextMenu)
        tr.IconOpen = icons.KeyboardArrowDown
        tr.IconClosed = icons.KeyboardArrowRight
        tr.IconLeaf = icons.Blank
        tr.OpenDepth = 4
        tr.Styler(func(s *styles.Style) {
                // our parts are draggable and droppable, not us ourself
                s.SetAbilities(true, abilities.Activatable, abilities.Focusable, abilities.Selectable, abilities.Hoverable)
                tr.Indent.Em(1)
                s.Border.Style.Set(styles.BorderNone)
                s.Border.Radius = styles.BorderRadiusFull
                s.MaxBorder = s.Border
                // s.Border.Width.Left.SetDp(1)
                // s.Border.Color.Left = colors.Scheme.OutlineVariant
                s.Margin.Zero()
                s.Padding.Left.Dp(ConstantSpacing(4))
                s.Padding.SetVertical(units.Dp(4))
                s.Padding.Right.Zero()
                s.Text.Align = text.Start

                // need to copy over to actual and then clear styles one
                if s.Is(states.Selected) {
                        // render handles manually, similar to with actStateLayer
                        s.Background = nil
                } else {
                        s.Color = colors.Scheme.OnSurface
                }
        })
        tr.FinalStyler(func(s *styles.Style) {
                tr.actStateLayer = s.StateLayer
                s.StateLayer = 0
        })

        // We let the parts handle our state
        // so that we only get it when we are doing
        // something with this tree specifically,
        // not with any of our children (see OnChildAdded).
        // we only need to handle the starting ones here,
        // as the other ones will just set the state to
        // false, which it already is.
        tr.On(events.MouseEnter, func(e events.Event) { e.SetHandled() })
        tr.On(events.MouseLeave, func(e events.Event) { e.SetHandled() })
        tr.On(events.MouseDown, func(e events.Event) { e.SetHandled() })
        tr.OnClick(func(e events.Event) { e.SetHandled() })
        tr.On(events.DragStart, func(e events.Event) { e.SetHandled() })
        tr.On(events.DragEnter, func(e events.Event) { e.SetHandled() })
        tr.On(events.DragLeave, func(e events.Event) { e.SetHandled() })
        tr.On(events.Drop, func(e events.Event) { e.SetHandled() })
        tr.On(events.DropDeleteSource, func(e events.Event) { tr.This.(Treer).DropDeleteSource(e) })
        tr.On(events.KeyChord, func(e events.Event) {
                kf := keymap.Of(e.KeyChord())
                selMode := events.SelectModeBits(e.Modifiers())
                if DebugSettings.KeyEventTrace {
                        slog.Info("Tree KeyInput", "widget", tr, "keyFunction", kf, "selMode", selMode)
                }

                if selMode == events.SelectOne {
                        if tr.SelectMode {
                                selMode = events.ExtendContinuous
                        }
                }

                tri := tr.This.(Treer)

                // first all the keys that work for ReadOnly and active
                switch kf {
                case keymap.CancelSelect:
                        tr.UnselectAll()
                        tr.SetSelectMode(false)
                        e.SetHandled()
                case keymap.MoveRight:
                        tr.Open()
                        e.SetHandled()
                case keymap.MoveLeft:
                        tr.Close()
                        e.SetHandled()
                case keymap.MoveDown:
                        tr.moveDownEvent(selMode)
                        e.SetHandled()
                case keymap.MoveUp:
                        tr.moveUpEvent(selMode)
                        e.SetHandled()
                case keymap.PageUp:
                        tr.movePageUpEvent(selMode)
                        e.SetHandled()
                case keymap.PageDown:
                        tr.movePageDownEvent(selMode)
                        e.SetHandled()
                case keymap.Home:
                        tr.moveHomeEvent(selMode)
                        e.SetHandled()
                case keymap.End:
                        tr.moveEndEvent(selMode)
                        e.SetHandled()
                case keymap.SelectMode:
                        tr.SelectMode = !tr.SelectMode
                        e.SetHandled()
                case keymap.SelectAll:
                        tr.SelectAll()
                        e.SetHandled()
                case keymap.Enter:
                        tr.ToggleClose()
                        e.SetHandled()
                case keymap.Copy:
                        tri.Copy()
                        e.SetHandled()
                }
                if !tr.rootIsReadOnly() && !e.IsHandled() {
                        switch kf {
                        case keymap.Delete:
                                tr.DeleteNode()
                                e.SetHandled()
                        case keymap.Duplicate:
                                tr.Duplicate()
                                e.SetHandled()
                        case keymap.Insert:
                                tr.InsertBefore()
                                e.SetHandled()
                        case keymap.InsertAfter:
                                tr.InsertAfter()
                                e.SetHandled()
                        case keymap.Cut:
                                tri.Cut()
                                e.SetHandled()
                        case keymap.Paste:
                                tri.Paste()
                                e.SetHandled()
                        }
                }
        })

        parts := tr.newParts()
        tri := tr.This.(Treer)
        parts.Styler(func(s *styles.Style) {
                s.Cursor = cursors.Pointer
                s.SetAbilities(true, abilities.Activatable, abilities.Focusable, abilities.Selectable, abilities.Hoverable, abilities.DoubleClickable)
                s.SetAbilities(!tr.IsReadOnly() && !tr.rootIsReadOnly(), abilities.Draggable, abilities.Droppable)
                s.Gap.X.Em(0.1)
                s.Padding.Zero()

                // we manually inherit our state layer from the tree state
                // layer so that the parts get it but not the other trees
                s.StateLayer = tr.actStateLayer
        })
        parts.AsWidget().FinalStyler(func(s *styles.Style) {
                s.Grow.Set(1, 0)
        })
        // we let the parts handle our state
        // so that we only get it when we are doing
        // something with this tree specifically,
        // not with any of our children (see HandleTreeMouse)
        parts.On(events.MouseEnter, func(e events.Event) {
                tr.SetState(true, states.Hovered)
                tr.Style()
                tr.NeedsRender()
                e.SetHandled()
        })
        parts.On(events.MouseLeave, func(e events.Event) {
                tr.SetState(false, states.Hovered)
                tr.Style()
                tr.NeedsRender()
                e.SetHandled()
        })
        parts.On(events.MouseDown, func(e events.Event) {
                tr.SetState(true, states.Active)
                tr.Style()
                tr.NeedsRender()
                e.SetHandled()
        })
        parts.On(events.MouseUp, func(e events.Event) {
                tr.SetState(false, states.Active)
                tr.Style()
                tr.NeedsRender()
                e.SetHandled()
        })
        parts.OnClick(func(e events.Event) {
                tr.SelectEvent(e.SelectMode())
                e.SetHandled()
        })
        parts.AsWidget().OnDoubleClick(func(e events.Event) {
                if tr.HasChildren() {
                        tr.ToggleClose()
                }
        })
        parts.On(events.DragStart, func(e events.Event) {
                tr.dragStart(e)
        })
        parts.On(events.DragEnter, func(e events.Event) {
                tr.SetState(true, states.DragHovered)
                tr.Style()
                tr.NeedsRender()
                e.SetHandled()
        })
        parts.On(events.DragLeave, func(e events.Event) {
                tr.SetState(false, states.DragHovered)
                tr.Style()
                tr.NeedsRender()
                e.SetHandled()
        })
        parts.On(events.Drop, func(e events.Event) {
                tri.DragDrop(e)
        })
        parts.On(events.DropDeleteSource, func(e events.Event) {
                tri.DropDeleteSource(e)
        })
        // the context menu events will get sent to the parts, so it
        // needs to intercept them and send them up
        parts.On(events.ContextMenu, func(e events.Event) {
                sels := tr.GetSelectedNodes()
                if len(sels) == 0 {
                        tr.SelectEvent(e.SelectMode())
                }
                tr.ShowContextMenu(e)
        })
        tree.AddChildAt(parts, "branch", func(w *Switch) {
                tr.Branch = w
                w.SetType(SwitchCheckbox)
                w.SetIconOn(tr.IconOpen).SetIconOff(tr.IconClosed).SetIconIndeterminate(tr.IconLeaf)
                w.Styler(func(s *styles.Style) {
                        s.SetAbilities(false, abilities.Focusable)
                        // parent will handle our cursor
                        s.Cursor = cursors.None
                        s.Color = colors.Scheme.Primary.Base
                        s.Padding.Zero()
                        s.Align.Self = styles.Center
                        if !w.StateIs(states.Indeterminate) {
                                // we amplify any state layer we receiver so that it is clear
                                // we are receiving it, not just our parent
                                s.StateLayer *= 3
                        } else {
                                // no abilities and state layer for indeterminate because
                                // they are not interactive
                                s.Abilities = 0
                                s.StateLayer = 0
                        }
                })
                w.OnClick(func(e events.Event) {
                        if w.IsChecked() && !w.StateIs(states.Indeterminate) {
                                if !tr.Closed {
                                        tr.Close()
                                }
                        } else {
                                if tr.Closed {
                                        tr.Open()
                                }
                        }
                })
                w.Updater(func() {
                        if tr.This.(Treer).CanOpen() {
                                tr.setBranchState()
                        }
                })
        })
        parts.Maker(func(p *tree.Plan) {
                if tr.Icon.IsSet() {
                        tree.AddAt(p, "icon", func(w *Icon) {
                                w.Styler(func(s *styles.Style) {
                                        s.Font.Size.Dp(24)
                                        s.Color = colors.Scheme.Primary.Base
                                        s.Align.Self = styles.Center
                                })
                                w.Updater(func() {
                                        w.SetIcon(tr.Icon)
                                })
                        })
                }
        })
        tree.AddChildAt(parts, "text", func(w *Text) {
                w.Styler(func(s *styles.Style) {
                        s.SetNonSelectable()
                        s.SetTextWrap(false)
                        s.Min.X.Ch(16)
                        s.Min.Y.Em(1.2)
                })
                w.Updater(func() {
                        w.SetText(tr.Label())
                })
        })
}

func (tr *Tree) OnAdd() {
        tr.WidgetBase.OnAdd()
        tr.Text = tr.Name
        if ptv := AsTree(tr.Parent); ptv != nil {
                tr.Root = ptv.Root
                tr.IconOpen = ptv.IconOpen
                tr.IconClosed = ptv.IconClosed
                tr.IconLeaf = ptv.IconLeaf
        } else {
                if tr.Root == nil {
                        tr.Root = tr
                }
        }
        troot := tr.Root.AsCoreTree()
        if troot.TreeInit != nil {
                troot.TreeInit(tr)
        }
}

// SetTreeInit sets the [Tree.TreeInit]:
// TreeInit is a function that can be set on the root node that is called
// with each child tree node when it is initialized. It is only
// called with the root node itself in this function, SetTreeInit, so you
// should typically call this instead of setting it directly.
func (tr *Tree) SetTreeInit(v func(tr *Tree)) *Tree {
        tr.TreeInit = v
        v(tr)
        return tr
}

// rootIsReadOnly returns the ReadOnly status of the root node,
// which is what controls the functional inactivity of the tree
// if individual nodes are ReadOnly that only affects display typically.
func (tr *Tree) rootIsReadOnly() bool {
        if tr.Root == nil {
                return true
        }
        return tr.Root.AsCoreTree().IsReadOnly()
}

func (tr *Tree) Style() {
        if !tr.HasChildren() {
                tr.SetClosed(true)
        }
        tr.WidgetBase.Style()
        tr.Indent.ToDots(&tr.Styles.UnitContext)
        tr.Indent.Dots = math32.Ceil(tr.Indent.Dots)
}

func (tr *Tree) setBranchState() {
        br := tr.Branch
        if br == nil {
                return
        }
        switch {
        case !tr.This.(Treer).CanOpen():
                br.SetState(true, states.Indeterminate)
        case tr.Closed:
                br.SetState(false, states.Indeterminate)
                br.SetState(false, states.Checked)
                br.NeedsRender()
        default:
                br.SetState(false, states.Indeterminate)
                br.SetState(true, states.Checked)
                br.NeedsRender()
        }
}

// Tree is tricky for alloc because it is both a layout
// of its children but has to maintain its own bbox for its own widget.

func (tr *Tree) SizeUp() {
        tr.WidgetBase.SizeUp()
        tr.widgetSize = tr.Geom.Size.Actual.Total
        h := tr.widgetSize.Y
        w := tr.widgetSize.X
        if tr.IsRoot() { // do it every time on root
                tr.rootSetViewIndex()
        }

        if !tr.Closed {
                // we layout children under us
                tr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                        cw.SizeUp()
                        h += cwb.Geom.Size.Actual.Total.Y
                        kw := cwb.Geom.Size.Actual.Total.X
                        if math32.IsNaN(kw) { // somehow getting a nan
                                slog.Error("Tree, node width is NaN", "node:", cwb)
                        } else {
                                w = max(w, tr.Indent.Dots+kw)
                        }
                        // fmt.Println(kwb, w, h)
                        return tree.Continue
                })
        }
        sz := &tr.Geom.Size
        sz.Actual.Content = math32.Vec2(w, h)
        sz.setTotalFromContent(&sz.Actual)
        sz.Alloc = sz.Actual // need allocation to match!
        tr.widgetSize.X = w  // stretch
}

func (tr *Tree) SizeDown(iter int) bool {
        // note: key to not grab the whole allocation, as widget default does
        redo := tr.sizeDownParts(iter) // give our content to parts
        re := tr.sizeDownChildren(iter)
        return redo || re
}

func (tr *Tree) Position() {
        if tr.Root == nil {
                slog.Error("core.Tree: RootView is nil", "in node:", tr)
                return
        }
        rn := tr.Root.AsCoreTree()
        tr.setBranchState()
        sz := &tr.Geom.Size
        sz.Actual.Total.X = rn.Geom.Size.Actual.Total.X - (tr.Geom.Pos.Total.X - rn.Geom.Pos.Total.X)
        sz.Actual.Content.X = sz.Actual.Total.X - sz.Space.X
        tr.widgetSize.X = sz.Actual.Total.X
        sz.Alloc = sz.Actual
        psz := &tr.Parts.Geom.Size
        psz.Alloc.Total = tr.widgetSize
        psz.setContentFromTotal(&psz.Alloc)

        tr.WidgetBase.Position() // just does our parts

        if !tr.Closed {
                h := tr.widgetSize.Y
                tr.ForWidgetChildren(func(i int, cw Widget, cwb *WidgetBase) bool {
                        cwb.Geom.RelPos.Y = h
                        cwb.Geom.RelPos.X = tr.Indent.Dots
                        h += cwb.Geom.Size.Actual.Total.Y
                        cw.Position()
                        return tree.Continue
                })
        }
}

func (tr *Tree) ApplyScenePos() {
        sz := &tr.Geom.Size
        if sz.Actual.Total == tr.widgetSize {
                sz.setTotalFromContent(&sz.Actual) // restore after scrolling
        }
        tr.WidgetBase.ApplyScenePos()
        tr.applyScenePosChildren()
        sz.Actual.Total = tr.widgetSize // key: we revert to just ourselves
}

func (tr *Tree) Render() {
        pc := &tr.Scene.Painter
        st := &tr.Styles

        pabg := tr.parentActualBackground()

        // must use workaround act values
        st.StateLayer = tr.actStateLayer
        if st.Is(states.Selected) {
                st.Background = colors.Scheme.Select.Container
        }
        tr.Styles.ComputeActualBackground(pabg)

        pc.StandardBox(st, tr.Geom.Pos.Total, tr.Geom.Size.Actual.Total, pabg)

        // after we are done rendering, we clear the values so they aren't inherited
        st.StateLayer = 0
        st.Background = nil
        tr.Styles.ComputeActualBackground(pabg)
}

func (tr *Tree) RenderWidget() {
        if tr.StartRender() {
                tr.Render()
                if tr.Parts != nil {
                        // we must copy from actual values in parent
                        tr.Parts.Styles.StateLayer = tr.actStateLayer
                        if tr.StateIs(states.Selected) {
                                tr.Parts.Styles.Background = colors.Scheme.Select.Container
                        }
                        tr.renderParts()
                }
                tr.EndRender()
        }
        // We have to render our children outside of `if StartRender`
        // since we could be out of scope but they could still be in!
        if !tr.Closed {
                tr.renderChildren()
        }
}

////////  Selection

// IsRootSelected returns whether the root node is the only node selected.
// This can be used in [events.Select] event handlers to check whether a
// select event on the root node truly corresponds to the root node or whether
// it is for another node, as select events are sent to the root when any node
// is selected.
func (tr *Tree) IsRootSelected() bool {
        return len(tr.SelectedNodes) == 1 && tr.SelectedNodes[0] == tr.Root
}

// GetSelectedNodes returns a slice of the currently selected
// Trees within the entire tree, using a list maintained
// by the root node.
func (tr *Tree) GetSelectedNodes() []Treer {
        if tr.Root == nil {
                return nil
        }
        rn := tr.Root.AsCoreTree()
        if len(rn.SelectedNodes) == 0 {
                return rn.SelectedNodes
        }
        return rn.SelectedNodes
}

// SetSelectedNodes updates the selected nodes on the root node to the given list.
func (tr *Tree) SetSelectedNodes(sl []Treer) {
        if tr.Root != nil {
                tr.Root.AsCoreTree().SelectedNodes = sl
        }
}

// HasSelection returns whether there are currently selected items.
func (tr *Tree) HasSelection() bool {
        return len(tr.GetSelectedNodes()) > 0
}

// Select selects this node (if not already selected).
// You must use this method to update global selection list.
func (tr *Tree) Select() {
        if !tr.StateIs(states.Selected) {
                tr.SetSelected(true)
                tr.Style()
                sl := tr.GetSelectedNodes()
                sl = append(sl, tr.This.(Treer))
                tr.SetSelectedNodes(sl)
                tr.NeedsRender()
        }
}

// Unselect unselects this node (if selected).
// You must use this method to update global selection list.
func (tr *Tree) Unselect() {
        if tr.StateIs(states.Selected) {
                tr.SetSelected(false)
                tr.Style()
                sl := tr.GetSelectedNodes()
                sz := len(sl)
                for i := 0; i < sz; i++ {
                        if sl[i] == tr {
                                sl = append(sl[:i], sl[i+1:]...)
                                break
                        }
                }
                tr.SetSelectedNodes(sl)
                tr.NeedsRender()
        }
}

// UnselectAll unselects all selected items in the tree.
func (tr *Tree) UnselectAll() {
        if tr.Scene == nil {
                return
        }
        sl := tr.GetSelectedNodes()
        tr.SetSelectedNodes(nil) // clear in advance
        for _, v := range sl {
                vt := v.AsCoreTree()
                if vt == nil || vt.This == nil {
                        continue
                }
                vt.SetSelected(false)
                v.Style()
                vt.NeedsRender()
        }
        tr.NeedsRender()
}

// SelectAll selects all items in the tree.
func (tr *Tree) SelectAll() {
        if tr.Scene == nil {
                return
        }
        tr.UnselectAll()
        nn := tr.Root.AsCoreTree()
        nn.Select()
        for nn != nil {
                nn = nn.moveDown(events.SelectQuiet)
        }
        tr.NeedsRender()
}

// selectUpdate updates selection to include this node,
// using selectmode from mouse event (ExtendContinuous, ExtendOne).
// Returns true if this node selected.
func (tr *Tree) selectUpdate(mode events.SelectModes) bool {
        if mode == events.NoSelect {
                return false
        }
        sel := false
        switch mode {
        case events.SelectOne:
                if tr.StateIs(states.Selected) {
                        sl := tr.GetSelectedNodes()
                        if len(sl) > 1 {
                                tr.UnselectAll()
                                tr.Select()
                                tr.SetFocusQuiet()
                                sel = true
                        }
                } else {
                        tr.UnselectAll()
                        tr.Select()
                        tr.SetFocusQuiet()
                        sel = true
                }
        case events.ExtendContinuous:
                sl := tr.GetSelectedNodes()
                if len(sl) == 0 {
                        tr.Select()
                        tr.SetFocusQuiet()
                        sel = true
                } else {
                        minIndex := -1
                        maxIndex := 0
                        sel = true
                        for _, v := range sl {
                                vn := v.AsCoreTree()
                                if minIndex < 0 {
                                        minIndex = vn.viewIndex
                                } else {
                                        minIndex = min(minIndex, vn.viewIndex)
                                }
                                maxIndex = max(maxIndex, vn.viewIndex)
                        }
                        cidx := tr.viewIndex
                        nn := tr
                        tr.Select()
                        if tr.viewIndex < minIndex {
                                for cidx < minIndex {
                                        nn = nn.moveDown(events.SelectQuiet) // just select
                                        cidx = nn.viewIndex
                                }
                        } else if tr.viewIndex > maxIndex {
                                for cidx > maxIndex {
                                        nn = nn.moveUp(events.SelectQuiet) // just select
                                        cidx = nn.viewIndex
                                }
                        }
                }
        case events.ExtendOne:
                if tr.StateIs(states.Selected) {
                        tr.UnselectEvent()
                } else {
                        tr.Select()
                        tr.SetFocusQuiet()
                        sel = true
                }
        case events.SelectQuiet:
                tr.Select()
                // not sel -- no signal..
        case events.UnselectQuiet:
                tr.Unselect()
                // not sel -- no signal..
        }
        tr.NeedsRender()
        return sel
}

// sendSelectEvent sends an [events.Select] event on both this node and the root node.
func (tr *Tree) sendSelectEvent(original ...events.Event) {
        if !tr.IsRoot() {
                tr.Send(events.Select, original...)
        }
        tr.Root.AsCoreTree().Send(events.Select, original...)
}

// sendChangeEvent sends an [events.Change] event on both this node and the root node.
func (tr *Tree) sendChangeEvent(original ...events.Event) {
        if !tr.IsRoot() {
                tr.SendChange(original...)
        }
        tr.Root.AsCoreTree().SendChange(original...)
}

// sendChangeEventReSync sends an [events.Change] event on the RootView node.
// If SyncNode != nil, it also does a re-sync from root.
func (tr *Tree) sendChangeEventReSync(original ...events.Event) {
        tr.sendChangeEvent(original...)
        rn := tr.Root.AsCoreTree()
        if rn.SyncNode != nil {
                rn.Resync()
        }
}

// SelectEvent updates selection to include this node,
// using selectmode from mouse event (ExtendContinuous, ExtendOne),
// and root sends selection event. Returns true if event sent.
func (tr *Tree) SelectEvent(mode events.SelectModes) bool {
        sel := tr.selectUpdate(mode)
        if sel {
                tr.sendSelectEvent()
        }
        return sel
}

// UnselectEvent unselects this node (if selected),
// and root sends a selection event.
func (tr *Tree) UnselectEvent() {
        if tr.StateIs(states.Selected) {
                tr.Unselect()
                tr.sendSelectEvent()
        }
}

////////  Moving

// moveDown moves the selection down to next element in the tree,
// using given select mode (from keyboard modifiers).
// Returns newly selected node.
func (tr *Tree) moveDown(selMode events.SelectModes) *Tree {
        if tr.Parent == nil {
                return nil
        }
        if tr.Closed || !tr.HasChildren() { // next sibling
                return tr.moveDownSibling(selMode)
        }
        if tr.HasChildren() {
                nn := AsTree(tr.Child(0))
                if nn != nil {
                        nn.selectUpdate(selMode)
                        return nn
                }
        }
        return nil
}

// moveDownEvent moves the selection down to next element in the tree,
// using given select mode (from keyboard modifiers).
// Sends select event for newly selected item.
func (tr *Tree) moveDownEvent(selMode events.SelectModes) *Tree {
        nn := tr.moveDown(selMode)
        if nn != nil && nn != tr {
                nn.SetFocusQuiet()
                nn.ScrollToThis()
                tr.sendSelectEvent()
        }
        return nn
}

// moveDownSibling moves down only to siblings, not down into children,
// using given select mode (from keyboard modifiers)
func (tr *Tree) moveDownSibling(selMode events.SelectModes) *Tree {
        if tr.Parent == nil {
                return nil
        }
        if tr == tr.Root {
                return nil
        }
        myidx := tr.IndexInParent()
        if myidx < len(tr.Parent.AsTree().Children)-1 {
                nn := AsTree(tr.Parent.AsTree().Child(myidx + 1))
                if nn != nil {
                        nn.selectUpdate(selMode)
                        return nn
                }
        } else {
                return AsTree(tr.Parent).moveDownSibling(selMode) // try up
        }
        return nil
}

// moveUp moves selection up to previous element in the tree,
// using given select mode (from keyboard modifiers).
// Returns newly selected node
func (tr *Tree) moveUp(selMode events.SelectModes) *Tree {
        if tr.Parent == nil || tr == tr.Root {
                return nil
        }
        myidx := tr.IndexInParent()
        if myidx > 0 {
                nn := AsTree(tr.Parent.AsTree().Child(myidx - 1))
                if nn != nil {
                        return nn.moveToLastChild(selMode)
                }
        } else {
                if tr.Parent != nil {
                        nn := AsTree(tr.Parent)
                        if nn != nil {
                                nn.selectUpdate(selMode)
                                return nn
                        }
                }
        }
        return nil
}

// moveUpEvent moves the selection up to previous element in the tree,
// using given select mode (from keyboard modifiers).
// Sends select event for newly selected item.
func (tr *Tree) moveUpEvent(selMode events.SelectModes) *Tree {
        nn := tr.moveUp(selMode)
        if nn != nil && nn != tr {
                nn.SetFocusQuiet()
                nn.ScrollToThis()
                tr.sendSelectEvent()
        }
        return nn
}

// treePageSteps is the number of steps to take in PageUp / Down events
const treePageSteps = 10

// movePageUpEvent moves the selection up to previous
// TreePageSteps elements in the tree,
// using given select mode (from keyboard modifiers).
// Sends select event for newly selected item.
func (tr *Tree) movePageUpEvent(selMode events.SelectModes) *Tree {
        mvMode := selMode
        if selMode == events.SelectOne {
                mvMode = events.NoSelect
        } else if selMode == events.ExtendContinuous || selMode == events.ExtendOne {
                mvMode = events.SelectQuiet
        }
        fnn := tr.moveUp(mvMode)
        if fnn != nil && fnn != tr {
                for i := 1; i < treePageSteps; i++ {
                        nn := fnn.moveUp(mvMode)
                        if nn == nil || nn == fnn {
                                break
                        }
                        fnn = nn
                }
                if selMode == events.SelectOne {
                        fnn.selectUpdate(selMode)
                }
                fnn.SetFocusQuiet()
                fnn.ScrollToThis()
                tr.sendSelectEvent()
        }
        tr.NeedsRender()
        return fnn
}

// movePageDownEvent moves the selection up to
// previous TreePageSteps elements in the tree,
// using given select mode (from keyboard modifiers).
// Sends select event for newly selected item.
func (tr *Tree) movePageDownEvent(selMode events.SelectModes) *Tree {
        mvMode := selMode
        if selMode == events.SelectOne {
                mvMode = events.NoSelect
        } else if selMode == events.ExtendContinuous || selMode == events.ExtendOne {
                mvMode = events.SelectQuiet
        }
        fnn := tr.moveDown(mvMode)
        if fnn != nil && fnn != tr {
                for i := 1; i < treePageSteps; i++ {
                        nn := fnn.moveDown(mvMode)
                        if nn == nil || nn == fnn {
                                break
                        }
                        fnn = nn
                }
                if selMode == events.SelectOne {
                        fnn.selectUpdate(selMode)
                }
                fnn.SetFocusQuiet()
                fnn.ScrollToThis()
                tr.sendSelectEvent()
        }
        tr.NeedsRender()
        return fnn
}

// moveToLastChild moves to the last child under me, using given select mode
// (from keyboard modifiers)
func (tr *Tree) moveToLastChild(selMode events.SelectModes) *Tree {
        if tr.Parent == nil || tr == tr.Root {
                return nil
        }
        if !tr.Closed && tr.HasChildren() {
                nn := AsTree(tr.Child(tr.NumChildren() - 1))
                return nn.moveToLastChild(selMode)
        }
        tr.selectUpdate(selMode)
        return tr
}

// moveHomeEvent moves the selection up to top of the tree,
// using given select mode (from keyboard modifiers)
// and emits select event for newly selected item
func (tr *Tree) moveHomeEvent(selMode events.SelectModes) *Tree {
        rn := tr.Root.AsCoreTree()
        rn.selectUpdate(selMode)
        rn.SetFocusQuiet()
        rn.ScrollToThis()
        rn.sendSelectEvent()
        return rn
}

// moveEndEvent moves the selection to the very last node in the tree,
// using given select mode (from keyboard modifiers)
// Sends select event for newly selected item.
func (tr *Tree) moveEndEvent(selMode events.SelectModes) *Tree {
        mvMode := selMode
        if selMode == events.SelectOne {
                mvMode = events.NoSelect
        } else if selMode == events.ExtendContinuous || selMode == events.ExtendOne {
                mvMode = events.SelectQuiet
        }
        fnn := tr.moveDown(mvMode)
        if fnn != nil && fnn != tr {
                for {
                        nn := fnn.moveDown(mvMode)
                        if nn == nil || nn == fnn {
                                break
                        }
                        fnn = nn
                }
                if selMode == events.SelectOne {
                        fnn.selectUpdate(selMode)
                }
                fnn.SetFocusQuiet()
                fnn.ScrollToThis()
                tr.sendSelectEvent()
        }
        return fnn
}

func (tr *Tree) setChildrenVisibility(parentClosed bool) {
        for _, c := range tr.Children {
                tvn := AsTree(c)
                if tvn != nil {
                        tvn.SetState(parentClosed, states.Invisible)
                }
        }
}

// OnClose is called when a node is closed.
// The base version does nothing.
func (tr *Tree) OnClose() {}

// Close closes the given node and updates the tree accordingly
// (if it is not already closed). It calls OnClose in the [Treer]
// interface for extensible actions.
func (tr *Tree) Close() {
        if tr.Closed {
                return
        }
        tr.SetClosed(true)
        tr.setBranchState()
        tr.This.(Treer).OnClose()
        tr.setChildrenVisibility(true) // parent closed
        tr.NeedsLayout()
}

// OnOpen is called when a node is opened.
// The base version does nothing.
func (tr *Tree) OnOpen() {}

// CanOpen returns true if the node is able to open.
// By default it checks HasChildren(), but could check other properties
// to perform lazy building of the tree.
func (tr *Tree) CanOpen() bool {
        return tr.HasChildren()
}

// Open opens the given node and updates the tree accordingly
// (if it is not already opened). It calls OnOpen in the [Treer]
// interface for extensible actions.
func (tr *Tree) Open() {
        if !tr.Closed || tr.inOpen || tr.This == nil {
                return
        }
        tr.inOpen = true
        if tr.This.(Treer).CanOpen() {
                tr.SetClosed(false)
                tr.setBranchState()
                tr.setChildrenVisibility(false)
                tr.This.(Treer).OnOpen()
        }
        tr.inOpen = false
        tr.NeedsLayout()
}

// ToggleClose toggles the close / open status: if closed, opens, and vice-versa.
func (tr *Tree) ToggleClose() {
        if tr.Closed {
                tr.Open()
        } else {
                tr.Close()
        }
}

// OpenAll opens the node and all of its sub-nodes.
func (tr *Tree) OpenAll() { //types:add
        tr.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                tvn := AsTree(cw)
                if tvn != nil {
                        tvn.Open()
                        return tree.Continue
                }
                return tree.Break
        })
        tr.NeedsLayout()
}

// CloseAll closes the node and all of its sub-nodes.
func (tr *Tree) CloseAll() { //types:add
        tr.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                tvn := AsTree(cw)
                if tvn != nil {
                        tvn.Close()
                        return tree.Continue
                }
                return tree.Break
        })
        tr.NeedsLayout()
}

// OpenParents opens all the parents of this node
// so that it will be visible.
func (tr *Tree) OpenParents() {
        tr.WalkUpParent(func(k tree.Node) bool {
                tvn := AsTree(k)
                if tvn != nil {
                        tvn.Open()
                        return tree.Continue
                }
                return tree.Break
        })
        tr.NeedsLayout()
}

////////  Modifying Source Tree

func (tr *Tree) ContextMenuPos(e events.Event) (pos image.Point) {
        if e != nil {
                pos = e.WindowPos()
                return
        }
        pos.X = tr.Geom.TotalBBox.Min.X + int(tr.Indent.Dots)
        pos.Y = (tr.Geom.TotalBBox.Min.Y + tr.Geom.TotalBBox.Max.Y) / 2
        return
}

func (tr *Tree) contextMenuReadOnly(m *Scene) {
        tri := tr.This.(Treer)
        NewFuncButton(m).SetFunc(tri.Copy).SetKey(keymap.Copy).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tr.editNode).SetText("View").SetIcon(icons.Visibility).SetEnabled(tr.HasSelection())
        NewSeparator(m)

        NewFuncButton(m).SetFunc(tr.OpenAll).SetIcon(icons.KeyboardArrowDown).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tr.CloseAll).SetIcon(icons.KeyboardArrowRight).SetEnabled(tr.HasSelection())
}

func (tr *Tree) contextMenu(m *Scene) {
        if tr.IsReadOnly() || tr.rootIsReadOnly() {
                tr.contextMenuReadOnly(m)
                return
        }
        tri := tr.This.(Treer)
        NewFuncButton(m).SetFunc(tr.AddChildNode).SetText("Add child").SetIcon(icons.Add).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tr.InsertBefore).SetIcon(icons.Add).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tr.InsertAfter).SetIcon(icons.Add).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tr.Duplicate).SetIcon(icons.ContentCopy).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tr.DeleteNode).SetText("Delete").SetIcon(icons.Delete).
                SetEnabled(tr.HasSelection())
        NewSeparator(m)
        NewFuncButton(m).SetFunc(tri.Copy).SetIcon(icons.Copy).SetKey(keymap.Copy).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tri.Cut).SetIcon(icons.Cut).SetKey(keymap.Cut).SetEnabled(tr.HasSelection())
        paste := NewFuncButton(m).SetFunc(tri.Paste).SetIcon(icons.Paste).SetKey(keymap.Paste)
        cb := tr.Scene.Events.Clipboard()
        if cb != nil {
                paste.SetState(cb.IsEmpty(), states.Disabled)
        }
        NewSeparator(m)
        NewFuncButton(m).SetFunc(tr.editNode).SetText("Edit").SetIcon(icons.Edit).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tr.inspectNode).SetText("Inspect").SetIcon(icons.EditDocument).SetEnabled(tr.HasSelection())
        NewSeparator(m)

        NewFuncButton(m).SetFunc(tr.OpenAll).SetIcon(icons.KeyboardArrowDown).SetEnabled(tr.HasSelection())
        NewFuncButton(m).SetFunc(tr.CloseAll).SetIcon(icons.KeyboardArrowRight).SetEnabled(tr.HasSelection())
}

// IsRoot returns true if given node is the root of the tree,
// creating an error snackbar if it is and action is non-empty.
func (tr *Tree) IsRoot(action ...string) bool {
        if tr.This == tr.Root.AsCoreTree().This {
                if len(action) > 0 {
                        MessageSnackbar(tr, fmt.Sprintf("Cannot %v the root of the tree", action[0]))
                }
                return true
        }
        return false
}

////////  Copy / Cut / Paste

// MimeData adds mimedata for this node: a text/plain of the Path.
func (tr *Tree) MimeData(md *mimedata.Mimes) {
        if tr.SyncNode != nil {
                tr.mimeDataSync(md)
                return
        }
        *md = append(*md, mimedata.NewTextData(tr.PathFrom(tr.Root.AsCoreTree())))
        var buf bytes.Buffer
        err := jsonx.Write(tr.This, &buf)
        if err == nil {
                *md = append(*md, &mimedata.Data{Type: fileinfo.DataJson, Data: buf.Bytes()})
        } else {
                ErrorSnackbar(tr, err, "Error encoding node")
        }
}

// nodesFromMimeData returns a slice of tree nodes for
// the Tree nodes and paths from mime data.
func (tr *Tree) nodesFromMimeData(md mimedata.Mimes) ([]tree.Node, []string) {
        ni := len(md) / 2
        sl := make([]tree.Node, 0, ni)
        pl := make([]string, 0, ni)
        for _, d := range md {
                if d.Type == fileinfo.DataJson {
                        nn, err := tree.UnmarshalRootJSON(d.Data)
                        if err == nil {
                                sl = append(sl, nn)
                        } else {
                                ErrorSnackbar(tr, err, "Error loading node")
                        }
                } else if d.Type == fileinfo.TextPlain { // paths
                        pl = append(pl, string(d.Data))
                }
        }
        return sl, pl
}

// Copy copies the tree to the clipboard.
func (tr *Tree) Copy() { //types:add
        sels := tr.GetSelectedNodes()
        nitms := max(1, len(sels))
        md := make(mimedata.Mimes, 0, 2*nitms)
        tr.This.(Treer).MimeData(&md) // source is always first..
        if nitms > 1 {
                for _, sn := range sels {
                        if sn != tr.This {
                                sn.MimeData(&md)
                        }
                }
        }
        tr.Clipboard().Write(md)
}

// Cut copies to [system.Clipboard] and deletes selected items.
func (tr *Tree) Cut() { //types:add
        if tr.IsRoot("Cut") {
                return
        }
        if tr.SyncNode != nil {
                tr.cutSync()
                return
        }
        tr.Copy()
        sels := tr.GetSelectedNodes()
        rn := tr.Root.AsCoreTree()
        tr.UnselectAll()
        for _, sn := range sels {
                sn.AsTree().Delete()
        }
        rn.Update()
        rn.sendChangeEvent()
}

// Paste pastes clipboard at given node.
func (tr *Tree) Paste() { //types:add
        md := tr.Clipboard().Read([]string{fileinfo.DataJson})
        if md != nil {
                tr.pasteMenu(md)
        }
}

// pasteMenu performs a paste from the clipboard using given data,
// by popping up a menu to determine what specifically to do.
func (tr *Tree) pasteMenu(md mimedata.Mimes) {
        tr.UnselectAll()
        mf := func(m *Scene) {
                tr.makePasteMenu(m, md, nil)
        }
        pos := tr.ContextMenuPos(nil)
        NewMenu(mf, tr.This.(Widget), pos).Run()
}

// makePasteMenu makes the menu of options for paste events
// Optional function is typically the DropFinalize but could also be other actions
// to take after each optional action.
func (tr *Tree) makePasteMenu(m *Scene, md mimedata.Mimes, fun func()) {
        NewButton(m).SetText("Assign To").OnClick(func(e events.Event) {
                tr.pasteAssign(md)
                if fun != nil {
                        fun()
                }
        })
        NewButton(m).SetText("Add to Children").OnClick(func(e events.Event) {
                tr.pasteChildren(md, events.DropCopy)
                if fun != nil {
                        fun()
                }
        })
        if !tr.IsRoot() {
                NewButton(m).SetText("Insert Before").OnClick(func(e events.Event) {
                        tr.pasteBefore(md, events.DropCopy)
                        if fun != nil {
                                fun()
                        }
                })
                NewButton(m).SetText("Insert After").OnClick(func(e events.Event) {
                        tr.pasteAfter(md, events.DropCopy)
                        if fun != nil {
                                fun()
                        }
                })
        }
        NewButton(m).SetText("Cancel")
}

// pasteAssign assigns mime data (only the first one!) to this node
func (tr *Tree) pasteAssign(md mimedata.Mimes) {
        if tr.SyncNode != nil {
                tr.pasteAssignSync(md)
                return
        }
        sl, _ := tr.nodesFromMimeData(md)
        if len(sl) == 0 {
                return
        }
        tr.CopyFrom(sl[0])    // nodes with data copy here
        tr.setScene(tr.Scene) // ensure children have scene
        tr.Update()           // could have children
        tr.Open()
        tr.sendChangeEvent()
}

// pasteBefore inserts object(s) from mime data before this node.
// If another item with the same name already exists, it will
// append _Copy on the name of the inserted objects
func (tr *Tree) pasteBefore(md mimedata.Mimes, mod events.DropMods) {
        tr.pasteAt(md, mod, 0, "Paste before")
}

// pasteAfter inserts object(s) from mime data after this node.
// If another item with the same name already exists, it will
// append _Copy on the name of the inserted objects
func (tr *Tree) pasteAfter(md mimedata.Mimes, mod events.DropMods) {
        tr.pasteAt(md, mod, 1, "Paste after")
}

// treeTempMovedTag is a kind of hack to prevent moved items from being deleted, using DND
const treeTempMovedTag = `_\&MOVED\&`

// todo: these methods require an interface to work for descended
// nodes, based on base code

// pasteAt inserts object(s) from mime data at rel position to this node.
// If another item with the same name already exists, it will
// append _Copy on the name of the inserted objects
func (tr *Tree) pasteAt(md mimedata.Mimes, mod events.DropMods, rel int, actNm string) {
        if tr.Parent == nil {
                return
        }
        parent := AsTree(tr.Parent)
        if parent == nil {
                MessageSnackbar(tr, "Error: cannot insert after the root of the tree")
                return
        }
        if tr.SyncNode != nil {
                tr.pasteAtSync(md, mod, rel, actNm)
                return
        }
        sl, pl := tr.nodesFromMimeData(md)

        myidx := tr.IndexInParent()
        if myidx < 0 {
                return
        }
        myidx += rel
        sz := len(sl)
        var selTv *Tree
        for i, ns := range sl {
                orgpath := pl[i]
                if mod != events.DropMove {
                        if cn := parent.ChildByName(ns.AsTree().Name, 0); cn != nil {
                                ns.AsTree().SetName(ns.AsTree().Name + "_Copy")
                        }
                }
                parent.InsertChild(ns, myidx+i)
                nwb := AsWidget(ns)
                ntv := AsTree(ns)
                ntv.Root = tr.Root
                nwb.setScene(tr.Scene)
                nwb.Update() // incl children
                npath := ns.AsTree().PathFrom(tr.Root)
                if mod == events.DropMove && npath == orgpath { // we will be nuked immediately after drag
                        ns.AsTree().SetName(ns.AsTree().Name + treeTempMovedTag) // special keyword :)
                }
                if i == sz-1 {
                        selTv = ntv
                }
        }
        tr.sendChangeEvent()
        parent.NeedsLayout()
        if selTv != nil {
                selTv.SelectEvent(events.SelectOne)
        }
}

// pasteChildren inserts object(s) from mime data
// at end of children of this node
func (tr *Tree) pasteChildren(md mimedata.Mimes, mod events.DropMods) {
        if tr.SyncNode != nil {
                tr.pasteChildrenSync(md, mod)
                return
        }
        sl, _ := tr.nodesFromMimeData(md)

        for _, ns := range sl {
                tr.AddChild(ns)
                nwb := AsWidget(ns)
                ntv := AsTree(ns)
                ntv.Root = tr.Root
                nwb.setScene(tr.Scene)
        }
        tr.Update()
        tr.Open()
        tr.sendChangeEvent()
}

////////  Drag-n-Drop

// dragStart starts a drag-n-drop on this node -- it includes any other
// selected nodes as well, each as additional records in mimedata.
func (tr *Tree) dragStart(e events.Event) {
        sels := tr.GetSelectedNodes()
        nitms := max(1, len(sels))
        md := make(mimedata.Mimes, 0, 2*nitms)
        tr.This.(Treer).MimeData(&md) // source is always first..
        if nitms > 1 {
                for _, sn := range sels {
                        if sn != tr.This {
                                sn.MimeData(&md)
                        }
                }
        }
        tr.Scene.Events.DragStart(tr.This.(Widget), md, e)
}

// dropExternal is not handled by base case but could be in derived
func (tr *Tree) dropExternal(md mimedata.Mimes, mod events.DropMods) {
        // todo: not yet implemented
}

// dragClearStates clears the drag-drop related states for this widget
func (tr *Tree) dragClearStates() {
        tr.dragStateReset()
        tr.Parts.dragStateReset()
        tr.Style()
        tr.NeedsRender()
}

// DragDrop handles drag drop event
func (tr *Tree) DragDrop(e events.Event) {
        // todo: some kind of validation for source
        tr.UnselectAll()
        de := e.(*events.DragDrop)
        stv := AsTree(de.Source.(Widget))
        if stv != nil {
                stv.dragClearStates()
        }
        md := de.Data.(mimedata.Mimes)
        mf := func(m *Scene) {
                tr.Scene.Events.DragMenuAddModText(m, de.DropMod)
                tr.makePasteMenu(m, md, func() {
                        tr.DropFinalize(de)
                })
        }
        pos := tr.ContextMenuPos(nil)
        NewMenu(mf, tr.This.(Widget), pos).Run()
}

// DropFinalize is called to finalize Drop actions on the Source node.
// Only relevant for DropMod == DropMove.
func (tr *Tree) DropFinalize(de *events.DragDrop) {
        tr.UnselectAll()
        tr.dragClearStates()
        tr.Scene.Events.DropFinalize(de) // sends DropDeleteSource to Source
}

// DropDeleteSource handles delete source event for DropMove case
func (tr *Tree) DropDeleteSource(e events.Event) {
        de := e.(*events.DragDrop)
        tr.UnselectAll()
        if tr.SyncNode != nil {
                tr.dropDeleteSourceSync(de)
                return
        }
        md := de.Data.(mimedata.Mimes)
        rn := tr.Root.AsCoreTree()
        for _, d := range md {
                if d.Type != fileinfo.TextPlain { // link
                        continue
                }
                path := string(d.Data)
                sn := rn.FindPath(path)
                if sn != nil {
                        sn.AsTree().Delete()
                }
                sn = rn.FindPath(path + treeTempMovedTag)
                if sn != nil {
                        psplt := strings.Split(path, "/")
                        orgnm := psplt[len(psplt)-1]
                        sn.AsTree().SetName(orgnm)
                        AsWidget(sn).NeedsRender()
                }
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "bytes"
        "fmt"
        "log"
        "strings"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/base/iox/jsonx"
        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/events"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

// note: see this file has all the SyncNode specific
// functions for Tree.

// SyncTree sets the root [Tree.SyncNode] to the root of the given [tree.Node]
// and synchronizes the rest of the tree to match. The source tree must have
// unique names for each child within a given parent.
func (tr *Tree) SyncTree(n tree.Node) *Tree {
        if tr.SyncNode != n {
                tr.SyncNode = n
        }
        tvIndex := 0
        tr.syncToSrc(&tvIndex, true, 0)
        tr.Update()
        return tr
}

// setSyncNode sets the sync source node that we are viewing,
// and syncs the view of its tree.  It is called routinely
// via SyncToSrc during tree updating.
// It uses tree Config mechanism to perform minimal updates to
// remain in sync.
func (tr *Tree) setSyncNode(sn tree.Node, tvIndex *int, init bool, depth int) {
        if tr.SyncNode != sn {
                tr.SyncNode = sn
        }
        tr.syncToSrc(tvIndex, init, depth)
}

// Resync resynchronizes the [Tree] relative to the [Tree.SyncNode]
// underlying nodes and triggers an update.
func (tr *Tree) Resync() {
        tvIndex := tr.viewIndex
        tr.syncToSrc(&tvIndex, false, 0)
        tr.Update()
}

// syncToSrc updates the view tree to match the sync tree, using
// ConfigChildren to maximally preserve existing tree elements.
// init means we are doing initial build, and depth tracks depth
// (only during init).
func (tr *Tree) syncToSrc(tvIndex *int, init bool, depth int) {
        sn := tr.SyncNode
        // root must keep the same name for continuity with surrounding context
        if tr != tr.Root {
                nm := "tv_" + sn.AsTree().Name
                tr.SetName(nm)
        }
        tr.viewIndex = *tvIndex
        *tvIndex++
        if init && depth >= tr.Root.AsCoreTree().OpenDepth {
                tr.SetClosed(true)
        }
        skids := sn.AsTree().Children
        p := make(tree.TypePlan, 0, len(skids))
        typ := tr.NodeType()
        for _, skid := range skids {
                p.Add(typ, "tv_"+skid.AsTree().Name)
        }
        tree.Update(tr, p)
        idx := 0
        for _, skid := range sn.AsTree().Children {
                if len(tr.Children) <= idx {
                        break
                }
                vk := AsTree(tr.Children[idx])
                vk.setSyncNode(skid, tvIndex, init, depth+1)
                idx++
        }
        if !sn.AsTree().HasChildren() {
                tr.SetClosed(true)
        }
}

// Label returns the display label for this node,
// satisfying the [labels.Labeler] interface.
func (tr *Tree) Label() string {
        if tr.SyncNode != nil {
                // TODO: make this an option?
                if lbl, has := labels.ToLabeler(tr.SyncNode); has {
                        return lbl
                }
                return tr.SyncNode.AsTree().Name
        }
        if tr.Text != "" {
                return tr.Text
        }
        return tr.Name
}

// selectedSyncNodes returns a slice of the currently selected
// sync source nodes in the entire tree
func (tr *Tree) selectedSyncNodes() []tree.Node {
        var res []tree.Node
        sl := tr.GetSelectedNodes()
        for _, v := range sl {
                res = append(res, v.AsCoreTree().SyncNode)
        }
        return res
}

// FindSyncNode returns the [Tree] node for the corresponding given
// source [tree.Node] in [Tree.SyncNode] or nil if not found.
func (tr *Tree) FindSyncNode(n tree.Node) *Tree {
        var res *Tree
        tr.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                tvn := AsTree(cw)
                if tvn != nil {
                        if tvn.SyncNode == n {
                                res = tvn
                                return tree.Break
                        }
                }
                return tree.Continue
        })
        return res
}

// InsertAfter inserts a new node in the tree
// after this node, at the same (sibling) level,
// prompting for the type of node to insert.
// If SyncNode is set, operates on Sync Tree.
func (tr *Tree) InsertAfter() { //types:add
        tr.insertAt(1, "Insert after")
}

// InsertBefore inserts a new node in the tree
// before this node, at the same (sibling) level,
// prompting for the type of node to insert
// If SyncNode is set, operates on Sync Tree.
func (tr *Tree) InsertBefore() { //types:add
        tr.insertAt(0, "Insert before")
}

func (tr *Tree) addTreeNodes(rel, myidx int, typ *types.Type, n int) {
        var stv *Tree
        for i := 0; i < n; i++ {
                nn := tree.NewOfType(typ)
                tr.InsertChild(nn, myidx+i)
                nn.AsTree().SetName(fmt.Sprintf("new-%v-%v", typ.IDName, myidx+rel+i))
                ntv := AsTree(nn)
                ntv.Update()
                if i == n-1 {
                        stv = ntv
                }
        }
        tr.Update()
        tr.Open()
        tr.sendChangeEvent()
        if stv != nil {
                stv.SelectEvent(events.SelectOne)
        }
}

func (tr *Tree) addSyncNodes(rel, myidx int, typ *types.Type, n int) {
        parent := tr.SyncNode
        var sn tree.Node
        for i := 0; i < n; i++ {
                nn := tree.NewOfType(typ)
                parent.AsTree().InsertChild(nn, myidx+i)
                nn.AsTree().SetName(fmt.Sprintf("new-%v-%v", typ.IDName, myidx+rel+i))
                if i == n-1 {
                        sn = nn
                }
        }
        tr.sendChangeEventReSync(nil)
        if sn != nil {
                if tvk := tr.ChildByName("tv_"+sn.AsTree().Name, 0); tvk != nil {
                        stv := AsTree(tvk)
                        stv.SelectEvent(events.SelectOne)
                }
        }
}

// newItemsData contains the data necessary to make a certain
// number of items of a certain type, which can be used with a
// [Form] in new item dialogs.
type newItemsData struct {

        // Number is the number of elements to create
        Number int

        // Type is the type of elements to create
        Type *types.Type
}

// insertAt inserts a new node in the tree
// at given relative offset from this node,
// at the same (sibling) level,
// prompting for the type of node to insert
// If SyncNode is set, operates on Sync Tree.
func (tr *Tree) insertAt(rel int, actNm string) {
        if tr.IsRoot(actNm) {
                return
        }
        myidx := tr.IndexInParent()
        if myidx < 0 {
                return
        }
        myidx += rel
        var typ *types.Type
        if tr.SyncNode == nil {
                typ = types.TypeByValue(tr.This)
        } else {
                typ = types.TypeByValue(tr.SyncNode)
        }
        d := NewBody(actNm)
        NewText(d).SetType(TextSupporting).SetText("Number and type of items to insert:")
        nd := &newItemsData{Number: 1, Type: typ}
        NewForm(d).SetStruct(nd)
        d.AddBottomBar(func(bar *Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).OnClick(func(e events.Event) {
                        parent := AsTree(tr.Parent)
                        if tr.SyncNode != nil {
                                parent.addSyncNodes(rel, myidx, nd.Type, nd.Number)
                        } else {
                                parent.addTreeNodes(rel, myidx, nd.Type, nd.Number)
                        }
                })
        })
        d.RunDialog(tr)
}

// AddChildNode adds a new child node to this one in the tree,
// prompting the user for the type of node to add
// If SyncNode is set, operates on Sync Tree.
func (tr *Tree) AddChildNode() { //types:add
        ttl := "Add child"
        var typ *types.Type
        if tr.SyncNode == nil {
                typ = types.TypeByValue(tr.This)
        } else {
                typ = types.TypeByValue(tr.SyncNode)
        }
        d := NewBody(ttl)
        NewText(d).SetType(TextSupporting).SetText("Number and type of items to insert:")
        nd := &newItemsData{Number: 1, Type: typ}
        NewForm(d).SetStruct(nd)
        d.AddBottomBar(func(bar *Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).OnClick(func(e events.Event) {
                        if tr.SyncNode != nil {
                                tr.addSyncNodes(0, 0, nd.Type, nd.Number)
                        } else {
                                tr.addTreeNodes(0, 0, nd.Type, nd.Number)
                        }
                })
        })
        d.RunDialog(tr)
}

// DeleteNode deletes the tree node or sync node corresponding
// to this view node in the sync tree.
// If SyncNode is set, operates on Sync Tree.
func (tr *Tree) DeleteNode() { //types:add
        ttl := "Delete"
        if tr.IsRoot(ttl) {
                return
        }
        tr.Close()
        if tr.moveDown(events.SelectOne) == nil {
                tr.moveUp(events.SelectOne)
        }
        if tr.SyncNode != nil {
                tr.SyncNode.AsTree().Delete()
                tr.sendChangeEventReSync(nil)
        } else {
                parent := AsTree(tr.Parent)
                tr.Delete()
                parent.Update()
                parent.sendChangeEvent()
        }
}

// Duplicate duplicates the sync node corresponding to this view node in
// the tree, and inserts the duplicate after this node (as a new sibling).
// If SyncNode is set, operates on Sync Tree.
func (tr *Tree) Duplicate() { //types:add
        ttl := "Duplicate"
        if tr.IsRoot(ttl) {
                return
        }
        if tr.Parent == nil {
                return
        }
        if tr.SyncNode != nil {
                tr.duplicateSync()
                return
        }
        parent := AsTree(tr.Parent)
        myidx := tr.IndexInParent()
        if myidx < 0 {
                return
        }
        nm := fmt.Sprintf("%v_Copy", tr.Name)
        tr.Unselect()
        nwkid := tr.Clone()
        nwkid.AsTree().SetName(nm)
        ntv := AsTree(nwkid)
        parent.InsertChild(nwkid, myidx+1)
        ntv.Update()
        parent.Update()
        parent.sendChangeEvent()
        // ntv.SelectEvent(events.SelectOne)
}

func (tr *Tree) duplicateSync() {
        sn := tr.SyncNode
        tvparent := AsTree(tr.Parent)
        parent := tvparent.SyncNode
        if parent == nil {
                log.Printf("Tree %v nil SyncNode in: %v\n", tr, tvparent.Path())
                return
        }
        myidx := sn.AsTree().IndexInParent()
        if myidx < 0 {
                return
        }
        nm := fmt.Sprintf("%v_Copy", sn.AsTree().Name)
        nwkid := sn.AsTree().Clone()
        nwkid.AsTree().SetName(nm)
        parent.AsTree().InsertChild(nwkid, myidx+1)
        tvparent.sendChangeEventReSync(nil)
        if tvk := tvparent.ChildByName("tv_"+nm, 0); tvk != nil {
                stv := AsTree(tvk)
                stv.SelectEvent(events.SelectOne)
        }
}

// editNode pulls up a [Form] dialog for the node.
// If SyncNode is set, operates on Sync Tree.
func (tr *Tree) editNode() { //types:add
        if tr.SyncNode != nil {
                tynm := tr.SyncNode.AsTree().NodeType().Name
                d := NewBody(tynm)
                NewForm(d).SetStruct(tr.SyncNode).SetReadOnly(tr.IsReadOnly())
                d.RunWindowDialog(tr)
        } else {
                tynm := tr.NodeType().Name
                d := NewBody(tynm)
                NewForm(d).SetStruct(tr.This).SetReadOnly(tr.IsReadOnly())
                d.RunWindowDialog(tr)
        }
}

// inspectNode pulls up a new Inspector window on the node.
// If SyncNode is set, operates on Sync Tree.
func (tr *Tree) inspectNode() { //types:add
        if tr.SyncNode != nil {
                InspectorWindow(tr.SyncNode)
        } else {
                InspectorWindow(tr)
        }
}

// mimeDataSync adds mimedata for this node: a text/plain of the Path,
// and an application/json of the sync node.
func (tr *Tree) mimeDataSync(md *mimedata.Mimes) {
        sroot := tr.Root.AsCoreTree().SyncNode
        src := tr.SyncNode
        *md = append(*md, mimedata.NewTextData(src.AsTree().PathFrom(sroot)))
        var buf bytes.Buffer
        err := jsonx.Write(src, &buf)
        if err == nil {
                *md = append(*md, &mimedata.Data{Type: fileinfo.DataJson, Data: buf.Bytes()})
        } else {
                ErrorSnackbar(tr, err, "Error encoding node")
        }
}

// syncNodesFromMimeData creates a slice of tree node(s)
// from given mime data and also a corresponding slice
// of original paths.
func (tr *Tree) syncNodesFromMimeData(md mimedata.Mimes) ([]tree.Node, []string) {
        ni := len(md) / 2
        sl := make([]tree.Node, 0, ni)
        pl := make([]string, 0, ni)
        for _, d := range md {
                if d.Type == fileinfo.DataJson {
                        nn, err := tree.UnmarshalRootJSON(d.Data)
                        if err == nil {
                                sl = append(sl, nn)
                        } else {
                                ErrorSnackbar(tr, err, "Error loading node")
                        }
                } else if d.Type == fileinfo.TextPlain { // paths
                        pl = append(pl, string(d.Data))
                }
        }
        return sl, pl
}

// pasteAssignSync assigns mime data (only the first one!) to this node
func (tr *Tree) pasteAssignSync(md mimedata.Mimes) {
        sl, _ := tr.syncNodesFromMimeData(md)
        if len(sl) == 0 {
                return
        }
        tr.SyncNode.AsTree().CopyFrom(sl[0])
        tr.NeedsLayout()
        tr.sendChangeEvent()
}

// pasteAtSync inserts object(s) from mime data at rel position to this node.
// If another item with the same name already exists, it will
// append _Copy on the name of the inserted objects
func (tr *Tree) pasteAtSync(md mimedata.Mimes, mod events.DropMods, rel int, actNm string) {
        sn := tr.SyncNode
        sl, pl := tr.nodesFromMimeData(md)
        tvparent := AsTree(tr.Parent)
        parent := sn.AsTree().Parent
        myidx := sn.AsTree().IndexInParent()
        if myidx < 0 {
                return
        }
        myidx += rel
        sroot := tr.Root.AsCoreTree().SyncNode
        sz := len(sl)
        var seln tree.Node
        for i, ns := range sl {
                orgpath := pl[i]
                if mod != events.DropMove {
                        if cn := parent.AsTree().ChildByName(ns.AsTree().Name, 0); cn != nil {
                                ns.AsTree().SetName(ns.AsTree().Name + "_Copy")
                        }
                }
                parent.AsTree().InsertChild(ns, myidx+i)
                npath := ns.AsTree().PathFrom(sroot)
                if mod == events.DropMove && npath == orgpath { // we will be nuked immediately after drag
                        ns.AsTree().SetName(ns.AsTree().Name + treeTempMovedTag) // special keyword :)
                }
                if i == sz-1 {
                        seln = ns
                }
        }
        tvparent.sendChangeEventReSync(nil)
        if seln != nil {
                if tvk := tvparent.ChildByName("tv_"+seln.AsTree().Name, myidx); tvk != nil {
                        stv := AsTree(tvk)
                        stv.SelectEvent(events.SelectOne)
                }
        }
}

// pasteChildrenSync inserts object(s) from mime data at
// end of children of this node
func (tr *Tree) pasteChildrenSync(md mimedata.Mimes, mod events.DropMods) {
        sl, _ := tr.nodesFromMimeData(md)
        sk := tr.SyncNode
        for _, ns := range sl {
                sk.AsTree().AddChild(ns)
        }
        tr.sendChangeEventReSync(nil)
}

// cutSync copies to system.Clipboard and deletes selected items.
func (tr *Tree) cutSync() {
        tr.Copy()
        sels := tr.selectedSyncNodes()
        tr.UnselectAll()
        for _, sn := range sels {
                sn.AsTree().Delete()
        }
        tr.sendChangeEventReSync(nil)
}

// dropDeleteSourceSync handles delete source event for DropMove case, for Sync
func (tr *Tree) dropDeleteSourceSync(de *events.DragDrop) {
        md := de.Data.(mimedata.Mimes)
        sroot := tr.Root.AsCoreTree().SyncNode
        for _, d := range md {
                if d.Type != fileinfo.TextPlain { // link
                        continue
                }
                path := string(d.Data)
                sn := sroot.AsTree().FindPath(path)
                if sn != nil {
                        sn.AsTree().Delete()
                }
                sn = sroot.AsTree().FindPath(path + treeTempMovedTag)
                if sn != nil {
                        psplt := strings.Split(path, "/")
                        orgnm := psplt[len(psplt)-1]
                        sn.AsTree().SetName(orgnm)
                        AsWidget(sn).NeedsRender()
                }
        }
        tr.sendChangeEventReSync(nil)
}

// Code generated by "core generate"; DO NOT EDIT.

package core

import (
        "image"
        "image/color"
        "reflect"
        "time"

        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.App", IDName: "app", Doc: "App represents a Cogent Core app. It extends [system.App] to provide both system-level\nand high-level data and functions to do with the currently running application. The\nsingle instance of it is [TheApp], which embeds [system.TheApp].", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Embeds: []types.Field{{Name: "App"}}, Fields: []types.Field{{Name: "SceneInit", Doc: "SceneInit is a function called on every newly created [Scene].\nThis can be used to set global configuration and styling for all\nwidgets in conjunction with [Scene.WidgetInit]."}}})

// SetSceneInit sets the [App.SceneInit]:
// SceneInit is a function called on every newly created [Scene].
// This can be used to set global configuration and styling for all
// widgets in conjunction with [Scene.WidgetInit].
func (t *App) SetSceneInit(v func(sc *Scene)) *App { t.SceneInit = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Body", IDName: "body", Doc: "Body holds the primary content of a [Scene].\nIt is the main container for app content.", Directives: []types.Directive{{Tool: "core", Directive: "no-new"}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Title", Doc: "Title is the title of the body, which is also\nused for the window title where relevant."}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Button", IDName: "button", Doc: "Button is an interactive button with text, an icon, an indicator, a shortcut,\nand/or a menu. The standard behavior is to register a click event handler with\n[WidgetBase.OnClick].", Directives: []types.Directive{{Tool: "core", Directive: "embedder"}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the type of button."}, {Name: "Text", Doc: "Text is the text for the button.\nIf it is blank, no text is shown."}, {Name: "Icon", Doc: "Icon is the icon for the button.\nIf it is \"\" or [icons.None], no icon is shown."}, {Name: "Indicator", Doc: "Indicator is the menu indicator icon to present.\nIf it is \"\" or [icons.None],, no indicator is shown.\nIt is automatically set to [icons.KeyboardArrowDown]\nwhen there is a Menu elements present unless it is\nset to [icons.None]."}, {Name: "Shortcut", Doc: "Shortcut is an optional shortcut keyboard chord to trigger this button,\nactive in window-wide scope. Avoid conflicts with other shortcuts\n(a log message will be emitted if so). Shortcuts are processed after\nall other processing of keyboard input. Command is automatically translated\ninto Meta on macOS and Control on all other platforms. Also see [Button.SetKey]."}, {Name: "Menu", Doc: "Menu is a menu constructor function used to build and display\na menu whenever the button is clicked. There will be no menu\nif it is nil. The constructor function should add buttons\nto the Scene that it is passed."}}})

// NewButton returns a new [Button] with the given optional parent:
// Button is an interactive button with text, an icon, an indicator, a shortcut,
// and/or a menu. The standard behavior is to register a click event handler with
// [WidgetBase.OnClick].
func NewButton(parent ...tree.Node) *Button { return tree.New[Button](parent...) }

// ButtonEmbedder is an interface that all types that embed Button satisfy
type ButtonEmbedder interface {
        AsButton() *Button
}

// AsButton returns the given value as a value of type Button if the type
// of the given value embeds Button, or nil otherwise
func AsButton(n tree.Node) *Button {
        if t, ok := n.(ButtonEmbedder); ok {
                return t.AsButton()
        }
        return nil
}

// AsButton satisfies the [ButtonEmbedder] interface
func (t *Button) AsButton() *Button { return t }

// SetType sets the [Button.Type]:
// Type is the type of button.
func (t *Button) SetType(v ButtonTypes) *Button { t.Type = v; return t }

// SetText sets the [Button.Text]:
// Text is the text for the button.
// If it is blank, no text is shown.
func (t *Button) SetText(v string) *Button { t.Text = v; return t }

// SetIcon sets the [Button.Icon]:
// Icon is the icon for the button.
// If it is "" or [icons.None], no icon is shown.
func (t *Button) SetIcon(v icons.Icon) *Button { t.Icon = v; return t }

// SetIndicator sets the [Button.Indicator]:
// Indicator is the menu indicator icon to present.
// If it is "" or [icons.None],, no indicator is shown.
// It is automatically set to [icons.KeyboardArrowDown]
// when there is a Menu elements present unless it is
// set to [icons.None].
func (t *Button) SetIndicator(v icons.Icon) *Button { t.Indicator = v; return t }

// SetShortcut sets the [Button.Shortcut]:
// Shortcut is an optional shortcut keyboard chord to trigger this button,
// active in window-wide scope. Avoid conflicts with other shortcuts
// (a log message will be emitted if so). Shortcuts are processed after
// all other processing of keyboard input. Command is automatically translated
// into Meta on macOS and Control on all other platforms. Also see [Button.SetKey].
func (t *Button) SetShortcut(v key.Chord) *Button { t.Shortcut = v; return t }

// SetMenu sets the [Button.Menu]:
// Menu is a menu constructor function used to build and display
// a menu whenever the button is clicked. There will be no menu
// if it is nil. The constructor function should add buttons
// to the Scene that it is passed.
func (t *Button) SetMenu(v func(m *Scene)) *Button { t.Menu = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Canvas", IDName: "canvas", Doc: "Canvas is a widget that can be arbitrarily drawn to by setting\nits Draw function using [Canvas.SetDraw].", Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "Draw", Doc: "Draw is the function used to draw the content of the\ncanvas every time that it is rendered. The paint context\nis automatically normalized to the size of the canvas,\nso you should specify points on a 0-1 scale."}, {Name: "painter", Doc: "painter is the paint painter used for drawing."}}})

// NewCanvas returns a new [Canvas] with the given optional parent:
// Canvas is a widget that can be arbitrarily drawn to by setting
// its Draw function using [Canvas.SetDraw].
func NewCanvas(parent ...tree.Node) *Canvas { return tree.New[Canvas](parent...) }

// SetDraw sets the [Canvas.Draw]:
// Draw is the function used to draw the content of the
// canvas every time that it is rendered. The paint context
// is automatically normalized to the size of the canvas,
// so you should specify points on a 0-1 scale.
func (t *Canvas) SetDraw(v func(pc *paint.Painter)) *Canvas { t.Draw = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Chooser", IDName: "chooser", Doc: "Chooser is a dropdown selection widget that allows users to choose\none option among a list of items.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the styling type of the chooser."}, {Name: "Items", Doc: "Items are the chooser items available for selection."}, {Name: "Icon", Doc: "Icon is an optional icon displayed on the left side of the chooser."}, {Name: "Indicator", Doc: "Indicator is the icon to use for the indicator displayed on the\nright side of the chooser."}, {Name: "Editable", Doc: "Editable is whether provide a text field for editing the value,\nor just a button for selecting items."}, {Name: "AllowNew", Doc: "AllowNew is whether to allow the user to add new items to the\nchooser through the editable textfield (if Editable is set to\ntrue) and a button at the end of the chooser menu. See also [DefaultNew]."}, {Name: "DefaultNew", Doc: "DefaultNew configures the chooser to accept new items, as in\n[AllowNew], and also turns off completion popups and always\nadds new items to the list of items, without prompting.\nUse this for cases where the typical use-case is to enter new values,\nbut the history of prior values can also be useful."}, {Name: "placeholder", Doc: "placeholder, if Editable is set to true, is the text that is\ndisplayed in the text field when it is empty. It must be set\nusing [Chooser.SetPlaceholder]."}, {Name: "ItemsFuncs", Doc: "ItemsFuncs is a slice of functions to call before showing the items\nof the chooser, which is typically used to configure them\n(eg: if they are based on dynamic data). The functions are called\nin ascending order such that the items added in the first function\nwill appear before those added in the last function. Use\n[Chooser.AddItemsFunc] to add a new items function. If at least\none ItemsFunc is specified, the items of the chooser will be\ncleared before calling the functions."}, {Name: "CurrentItem", Doc: "CurrentItem is the currently selected item."}, {Name: "CurrentIndex", Doc: "CurrentIndex is the index of the currently selected item\nin [Chooser.Items]."}, {Name: "text"}, {Name: "textField"}}})

// NewChooser returns a new [Chooser] with the given optional parent:
// Chooser is a dropdown selection widget that allows users to choose
// one option among a list of items.
func NewChooser(parent ...tree.Node) *Chooser { return tree.New[Chooser](parent...) }

// SetType sets the [Chooser.Type]:
// Type is the styling type of the chooser.
func (t *Chooser) SetType(v ChooserTypes) *Chooser { t.Type = v; return t }

// SetItems sets the [Chooser.Items]:
// Items are the chooser items available for selection.
func (t *Chooser) SetItems(v ...ChooserItem) *Chooser { t.Items = v; return t }

// SetIcon sets the [Chooser.Icon]:
// Icon is an optional icon displayed on the left side of the chooser.
func (t *Chooser) SetIcon(v icons.Icon) *Chooser { t.Icon = v; return t }

// SetIndicator sets the [Chooser.Indicator]:
// Indicator is the icon to use for the indicator displayed on the
// right side of the chooser.
func (t *Chooser) SetIndicator(v icons.Icon) *Chooser { t.Indicator = v; return t }

// SetEditable sets the [Chooser.Editable]:
// Editable is whether provide a text field for editing the value,
// or just a button for selecting items.
func (t *Chooser) SetEditable(v bool) *Chooser { t.Editable = v; return t }

// SetAllowNew sets the [Chooser.AllowNew]:
// AllowNew is whether to allow the user to add new items to the
// chooser through the editable textfield (if Editable is set to
// true) and a button at the end of the chooser menu. See also [DefaultNew].
func (t *Chooser) SetAllowNew(v bool) *Chooser { t.AllowNew = v; return t }

// SetDefaultNew sets the [Chooser.DefaultNew]:
// DefaultNew configures the chooser to accept new items, as in
// [AllowNew], and also turns off completion popups and always
// adds new items to the list of items, without prompting.
// Use this for cases where the typical use-case is to enter new values,
// but the history of prior values can also be useful.
func (t *Chooser) SetDefaultNew(v bool) *Chooser { t.DefaultNew = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Collapser", IDName: "collapser", Doc: "Collapser is a widget that can be collapsed or expanded by a user.\nThe [Collapser.Summary] is always visible, and the [Collapser.Details]\nare only visible when the [Collapser] is expanded with [Collapser.Open]\nequal to true.\n\nYou can directly add any widgets to the [Collapser.Summary] and [Collapser.Details]\nby specifying one of them as the parent in calls to New{WidgetName}.\nCollapser is similar to HTML's <details> and <summary> tags.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Open", Doc: "Open is whether the collapser is currently expanded. It defaults to false."}, {Name: "Summary", Doc: "Summary is the part of the collapser that is always visible."}, {Name: "Details", Doc: "Details is the part of the collapser that is only visible when\nthe collapser is expanded."}}})

// NewCollapser returns a new [Collapser] with the given optional parent:
// Collapser is a widget that can be collapsed or expanded by a user.
// The [Collapser.Summary] is always visible, and the [Collapser.Details]
// are only visible when the [Collapser] is expanded with [Collapser.Open]
// equal to true.
//
// You can directly add any widgets to the [Collapser.Summary] and [Collapser.Details]
// by specifying one of them as the parent in calls to New{WidgetName}.
// Collapser is similar to HTML's <details> and <summary> tags.
func NewCollapser(parent ...tree.Node) *Collapser { return tree.New[Collapser](parent...) }

// SetOpen sets the [Collapser.Open]:
// Open is whether the collapser is currently expanded. It defaults to false.
func (t *Collapser) SetOpen(v bool) *Collapser { t.Open = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.ColorMapButton", IDName: "color-map-button", Doc: "ColorMapButton displays a [colormap.Map] and can be clicked on\nto display a dialog for selecting different color map options.\nIt represents a [ColorMapName] value.", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "MapName"}}})

// NewColorMapButton returns a new [ColorMapButton] with the given optional parent:
// ColorMapButton displays a [colormap.Map] and can be clicked on
// to display a dialog for selecting different color map options.
// It represents a [ColorMapName] value.
func NewColorMapButton(parent ...tree.Node) *ColorMapButton {
        return tree.New[ColorMapButton](parent...)
}

// SetMapName sets the [ColorMapButton.MapName]
func (t *ColorMapButton) SetMapName(v string) *ColorMapButton { t.MapName = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.ColorPicker", IDName: "color-picker", Doc: "ColorPicker represents a color value with an interactive color picker\ncomposed of history buttons, a hex input, three HCT sliders, and standard\nnamed color buttons.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Color", Doc: "Color is the current color."}}})

// NewColorPicker returns a new [ColorPicker] with the given optional parent:
// ColorPicker represents a color value with an interactive color picker
// composed of history buttons, a hex input, three HCT sliders, and standard
// named color buttons.
func NewColorPicker(parent ...tree.Node) *ColorPicker { return tree.New[ColorPicker](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.ColorButton", IDName: "color-button", Doc: "ColorButton represents a color value with a button that opens a [ColorPicker].", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "Color"}}})

// NewColorButton returns a new [ColorButton] with the given optional parent:
// ColorButton represents a color value with a button that opens a [ColorPicker].
func NewColorButton(parent ...tree.Node) *ColorButton { return tree.New[ColorButton](parent...) }

// SetColor sets the [ColorButton.Color]
func (t *ColorButton) SetColor(v color.RGBA) *ColorButton { t.Color = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Complete", IDName: "complete", Doc: "Complete holds the current completion data and functions to call for building\nthe list of possible completions and for editing text after a completion is selected.\nIt also holds the popup [Stage] associated with it.", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Fields: []types.Field{{Name: "MatchFunc", Doc: "function to get the list of possible completions"}, {Name: "LookupFunc", Doc: "function to get the text to show for lookup"}, {Name: "EditFunc", Doc: "function to edit text using the selected completion"}, {Name: "Context", Doc: "the context object that implements the completion functions"}, {Name: "SrcLn", Doc: "line number in source that completion is operating on, if relevant"}, {Name: "SrcCh", Doc: "character position in source that completion is operating on"}, {Name: "completions", Doc: "the list of potential completions"}, {Name: "Seed", Doc: "current completion seed"}, {Name: "Completion", Doc: "the user's completion selection"}, {Name: "listeners", Doc: "the event listeners for the completer (it sends [events.Select] events)"}, {Name: "stage", Doc: "stage is the popup [Stage] associated with the [Complete]."}, {Name: "delayTimer"}, {Name: "delayMu"}, {Name: "showMu"}}})

// SetMatchFunc sets the [Complete.MatchFunc]:
// function to get the list of possible completions
func (t *Complete) SetMatchFunc(v complete.MatchFunc) *Complete { t.MatchFunc = v; return t }

// SetLookupFunc sets the [Complete.LookupFunc]:
// function to get the text to show for lookup
func (t *Complete) SetLookupFunc(v complete.LookupFunc) *Complete { t.LookupFunc = v; return t }

// SetEditFunc sets the [Complete.EditFunc]:
// function to edit text using the selected completion
func (t *Complete) SetEditFunc(v complete.EditFunc) *Complete { t.EditFunc = v; return t }

// SetContext sets the [Complete.Context]:
// the context object that implements the completion functions
func (t *Complete) SetContext(v any) *Complete { t.Context = v; return t }

// SetSrcLn sets the [Complete.SrcLn]:
// line number in source that completion is operating on, if relevant
func (t *Complete) SetSrcLn(v int) *Complete { t.SrcLn = v; return t }

// SetSrcCh sets the [Complete.SrcCh]:
// character position in source that completion is operating on
func (t *Complete) SetSrcCh(v int) *Complete { t.SrcCh = v; return t }

// SetSeed sets the [Complete.Seed]:
// current completion seed
func (t *Complete) SetSeed(v string) *Complete { t.Seed = v; return t }

// SetCompletion sets the [Complete.Completion]:
// the user's completion selection
func (t *Complete) SetCompletion(v string) *Complete { t.Completion = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.FilePicker", IDName: "file-picker", Doc: "FilePicker is a widget for selecting files.", Methods: []types.Method{{Name: "updateFilesEvent", Doc: "updateFilesEvent updates the list of files and other views for the current path.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "addPathToFavorites", Doc: "addPathToFavorites adds the current path to favorites", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "directoryUp", Doc: "directoryUp moves up one directory in the path", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "newFolder", Doc: "newFolder creates a new folder with the given name in the current directory.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"name"}, Returns: []string{"error"}}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Filterer", Doc: "Filterer is an optional filtering function for which files to display."}, {Name: "directory", Doc: "directory is the absolute path to the directory of files to display."}, {Name: "selectedFilename", Doc: "selectedFilename is the name of the currently selected file,\nnot including the directory. See [FilePicker.SelectedFile]\nfor the full path."}, {Name: "extensions", Doc: "extensions is a list of the target file extensions.\nIf there are multiple, they must be comma separated.\nThe extensions must include the dot (\".\") at the start.\nThey must be set using [FilePicker.SetExtensions]."}, {Name: "extensionMap", Doc: "extensionMap is a map of lower-cased extensions from Extensions.\nIt used for highlighting files with one of these extensions;\nmaps onto original Extensions value."}, {Name: "files", Doc: "files for current directory"}, {Name: "selectedIndex", Doc: "index of currently selected file in Files list (-1 if none)"}, {Name: "watcher", Doc: "change notify for current dir"}, {Name: "doneWatcher", Doc: "channel to close watcher watcher"}, {Name: "prevPath", Doc: "Previous path that was processed via UpdateFiles"}, {Name: "favoritesTable"}, {Name: "filesTable"}, {Name: "selectField"}, {Name: "extensionField"}}})

// NewFilePicker returns a new [FilePicker] with the given optional parent:
// FilePicker is a widget for selecting files.
func NewFilePicker(parent ...tree.Node) *FilePicker { return tree.New[FilePicker](parent...) }

// SetFilterer sets the [FilePicker.Filterer]:
// Filterer is an optional filtering function for which files to display.
func (t *FilePicker) SetFilterer(v FilePickerFilterer) *FilePicker { t.Filterer = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.FileButton", IDName: "file-button", Doc: "FileButton represents a [Filename] value with a button\nthat opens a [FilePicker].", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "Filename"}, {Name: "Extensions", Doc: "Extensions are the target file extensions for the file picker."}}})

// NewFileButton returns a new [FileButton] with the given optional parent:
// FileButton represents a [Filename] value with a button
// that opens a [FilePicker].
func NewFileButton(parent ...tree.Node) *FileButton { return tree.New[FileButton](parent...) }

// SetFilename sets the [FileButton.Filename]
func (t *FileButton) SetFilename(v string) *FileButton { t.Filename = v; return t }

// SetExtensions sets the [FileButton.Extensions]:
// Extensions are the target file extensions for the file picker.
func (t *FileButton) SetExtensions(v string) *FileButton { t.Extensions = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Form", IDName: "form", Doc: "Form represents a struct with rows of field names and editable values.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Struct", Doc: "Struct is the pointer to the struct that we are viewing."}, {Name: "Inline", Doc: "Inline is whether to display the form in one line."}, {Name: "Modified", Doc: "Modified optionally highlights and tracks fields that have been modified\nthrough an OnChange event. If present, it replaces the default value highlighting\nand resetting logic. Ignored if nil."}, {Name: "structFields", Doc: "structFields are the fields of the current struct, keys are field paths."}, {Name: "isShouldDisplayer", Doc: "isShouldDisplayer is whether the struct implements [ShouldDisplayer], which results\nin additional updating being done at certain points."}}})

// NewForm returns a new [Form] with the given optional parent:
// Form represents a struct with rows of field names and editable values.
func NewForm(parent ...tree.Node) *Form { return tree.New[Form](parent...) }

// SetStruct sets the [Form.Struct]:
// Struct is the pointer to the struct that we are viewing.
func (t *Form) SetStruct(v any) *Form { t.Struct = v; return t }

// SetInline sets the [Form.Inline]:
// Inline is whether to display the form in one line.
func (t *Form) SetInline(v bool) *Form { t.Inline = v; return t }

// SetModified sets the [Form.Modified]:
// Modified optionally highlights and tracks fields that have been modified
// through an OnChange event. If present, it replaces the default value highlighting
// and resetting logic. Ignored if nil.
func (t *Form) SetModified(v map[string]bool) *Form { t.Modified = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Frame", IDName: "frame", Doc: "Frame is the primary node type responsible for organizing the sizes\nand positions of child widgets. It also renders the standard box model.\nAll collections of widgets should generally be contained within a [Frame];\notherwise, the parent widget must take over responsibility for positioning.\nFrames automatically can add scrollbars depending on the [styles.Style.Overflow].\n\nFor a [styles.Grid] frame, the [styles.Style.Columns] property should\ngenerally be set to the desired number of columns, from which the number of rows\nis computed; otherwise, it uses the square root of number of\nelements.", Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "StackTop", Doc: "StackTop, for a [styles.Stacked] frame, is the index of the node to use\nas the top of the stack. Only the node at this index is rendered; if it is\nnot a valid index, nothing is rendered."}, {Name: "LayoutStackTopOnly", Doc: "LayoutStackTopOnly is whether to only layout the top widget\n(specified by [Frame.StackTop]) for a [styles.Stacked] frame.\nThis is appropriate for widgets such as [Tabs], which do a full\nredraw on stack changes, but not for widgets such as [Switch]es\nwhich don't."}, {Name: "layout", Doc: "layout contains implementation state info for doing layout"}, {Name: "HasScroll", Doc: "HasScroll is whether scrollbars exist for each dimension."}, {Name: "Scrolls", Doc: "Scrolls are the scroll bars, which are fully managed as needed."}, {Name: "handleKeyNav", Doc: "handleKeyNav indicates whether this frame should handle keyboard\nnavigation events using the default handlers. Set to false to allow\ncustom event handling."}, {Name: "focusName", Doc: "accumulated name to search for when keys are typed"}, {Name: "focusNameTime", Doc: "time of last focus name event; for timeout"}, {Name: "focusNameLast", Doc: "last element focused on; used as a starting point if name is the same"}}})

// NewFrame returns a new [Frame] with the given optional parent:
// Frame is the primary node type responsible for organizing the sizes
// and positions of child widgets. It also renders the standard box model.
// All collections of widgets should generally be contained within a [Frame];
// otherwise, the parent widget must take over responsibility for positioning.
// Frames automatically can add scrollbars depending on the [styles.Style.Overflow].
//
// For a [styles.Grid] frame, the [styles.Style.Columns] property should
// generally be set to the desired number of columns, from which the number of rows
// is computed; otherwise, it uses the square root of number of
// elements.
func NewFrame(parent ...tree.Node) *Frame { return tree.New[Frame](parent...) }

// SetStackTop sets the [Frame.StackTop]:
// StackTop, for a [styles.Stacked] frame, is the index of the node to use
// as the top of the stack. Only the node at this index is rendered; if it is
// not a valid index, nothing is rendered.
func (t *Frame) SetStackTop(v int) *Frame { t.StackTop = v; return t }

// SetLayoutStackTopOnly sets the [Frame.LayoutStackTopOnly]:
// LayoutStackTopOnly is whether to only layout the top widget
// (specified by [Frame.StackTop]) for a [styles.Stacked] frame.
// This is appropriate for widgets such as [Tabs], which do a full
// redraw on stack changes, but not for widgets such as [Switch]es
// which don't.
func (t *Frame) SetLayoutStackTopOnly(v bool) *Frame { t.LayoutStackTopOnly = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Stretch", IDName: "stretch", Doc: "Stretch adds a stretchy element that grows to fill all\navailable space. You can set [styles.Style.Grow] to change\nhow much it grows relative to other growing elements.\nIt does not render anything.", Embeds: []types.Field{{Name: "WidgetBase"}}})

// NewStretch returns a new [Stretch] with the given optional parent:
// Stretch adds a stretchy element that grows to fill all
// available space. You can set [styles.Style.Grow] to change
// how much it grows relative to other growing elements.
// It does not render anything.
func NewStretch(parent ...tree.Node) *Stretch { return tree.New[Stretch](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Space", IDName: "space", Doc: "Space is a fixed size blank space, with\na default width of 1ch and a height of 1em.\nYou can set [styles.Style.Min] to change its size.\nIt does not render anything.", Embeds: []types.Field{{Name: "WidgetBase"}}})

// NewSpace returns a new [Space] with the given optional parent:
// Space is a fixed size blank space, with
// a default width of 1ch and a height of 1em.
// You can set [styles.Style.Min] to change its size.
// It does not render anything.
func NewSpace(parent ...tree.Node) *Space { return tree.New[Space](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.FuncButton", IDName: "func-button", Doc: "FuncButton is a button that is set up to call a function when it\nis pressed, using a dialog to prompt the user for any arguments.\nAlso, it automatically sets various properties of the button like\nthe text and tooltip based on the properties of the function,\nusing [reflect] and [types]. The function must be registered\nwith [types] to get documentation information, but that is not\nrequired; add a `//types:add` comment directive and run `core generate`\nif you want tooltips. If the function is a method, both the method and\nits receiver type must be added to [types] to get documentation.\nThe main function to call first is [FuncButton.SetFunc].", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "typesFunc", Doc: "typesFunc is the [types.Func] associated with this button.\nThis function can also be a method, but it must be\nconverted to a [types.Func] first. It should typically\nbe set using [FuncButton.SetFunc]."}, {Name: "reflectFunc", Doc: "reflectFunc is the [reflect.Value] of the function or\nmethod associated with this button. It should typically\nbet set using [FuncButton.SetFunc]."}, {Name: "Args", Doc: "Args are the [FuncArg] objects associated with the\narguments of the function. They are automatically set in\n[FuncButton.SetFunc], but they can be customized to configure\ndefault values and other options."}, {Name: "Returns", Doc: "Returns are the [FuncArg] objects associated with the\nreturn values of the function. They are automatically\nset in [FuncButton.SetFunc], but they can be customized\nto configure options. The [FuncArg.Value]s are not set until\nthe function is called, and are thus not typically applicable\nto access."}, {Name: "Confirm", Doc: "Confirm is whether to prompt the user for confirmation\nbefore calling the function."}, {Name: "ShowReturn", Doc: "ShowReturn is whether to display the return values of\nthe function (and a success message if there are none).\nThe way that the return values are shown is determined\nby ShowReturnAsDialog. Non-nil error return values will\nalways be shown, even if ShowReturn is set to false."}, {Name: "ShowReturnAsDialog", Doc: "ShowReturnAsDialog, if and only if ShowReturn is true,\nindicates to show the return values of the function in\na dialog, instead of in a snackbar, as they are by default.\nIf there are multiple return values from the function, or if\none of them is a complex type (pointer, struct, slice,\narray, map), then ShowReturnAsDialog will\nautomatically be set to true."}, {Name: "NewWindow", Doc: "NewWindow makes the return value dialog a NewWindow dialog."}, {Name: "WarnUnadded", Doc: "WarnUnadded is whether to log warnings when a function that\nhas not been added to [types] is used. It is on by default and\nmust be set before [FuncButton.SetFunc] is called for it to\nhave any effect. Warnings are never logged for anonymous functions."}, {Name: "Context", Doc: "Context is used for opening dialogs if non-nil."}, {Name: "AfterFunc", Doc: "AfterFunc is an optional function called after the func button\nfunction is executed."}}})

// NewFuncButton returns a new [FuncButton] with the given optional parent:
// FuncButton is a button that is set up to call a function when it
// is pressed, using a dialog to prompt the user for any arguments.
// Also, it automatically sets various properties of the button like
// the text and tooltip based on the properties of the function,
// using [reflect] and [types]. The function must be registered
// with [types] to get documentation information, but that is not
// required; add a `//types:add` comment directive and run `core generate`
// if you want tooltips. If the function is a method, both the method and
// its receiver type must be added to [types] to get documentation.
// The main function to call first is [FuncButton.SetFunc].
func NewFuncButton(parent ...tree.Node) *FuncButton { return tree.New[FuncButton](parent...) }

// SetConfirm sets the [FuncButton.Confirm]:
// Confirm is whether to prompt the user for confirmation
// before calling the function.
func (t *FuncButton) SetConfirm(v bool) *FuncButton { t.Confirm = v; return t }

// SetShowReturn sets the [FuncButton.ShowReturn]:
// ShowReturn is whether to display the return values of
// the function (and a success message if there are none).
// The way that the return values are shown is determined
// by ShowReturnAsDialog. Non-nil error return values will
// always be shown, even if ShowReturn is set to false.
func (t *FuncButton) SetShowReturn(v bool) *FuncButton { t.ShowReturn = v; return t }

// SetShowReturnAsDialog sets the [FuncButton.ShowReturnAsDialog]:
// ShowReturnAsDialog, if and only if ShowReturn is true,
// indicates to show the return values of the function in
// a dialog, instead of in a snackbar, as they are by default.
// If there are multiple return values from the function, or if
// one of them is a complex type (pointer, struct, slice,
// array, map), then ShowReturnAsDialog will
// automatically be set to true.
func (t *FuncButton) SetShowReturnAsDialog(v bool) *FuncButton { t.ShowReturnAsDialog = v; return t }

// SetNewWindow sets the [FuncButton.NewWindow]:
// NewWindow makes the return value dialog a NewWindow dialog.
func (t *FuncButton) SetNewWindow(v bool) *FuncButton { t.NewWindow = v; return t }

// SetWarnUnadded sets the [FuncButton.WarnUnadded]:
// WarnUnadded is whether to log warnings when a function that
// has not been added to [types] is used. It is on by default and
// must be set before [FuncButton.SetFunc] is called for it to
// have any effect. Warnings are never logged for anonymous functions.
func (t *FuncButton) SetWarnUnadded(v bool) *FuncButton { t.WarnUnadded = v; return t }

// SetContext sets the [FuncButton.Context]:
// Context is used for opening dialogs if non-nil.
func (t *FuncButton) SetContext(v Widget) *FuncButton { t.Context = v; return t }

// SetAfterFunc sets the [FuncButton.AfterFunc]:
// AfterFunc is an optional function called after the func button
// function is executed.
func (t *FuncButton) SetAfterFunc(v func()) *FuncButton { t.AfterFunc = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.FuncArg", IDName: "func-arg", Doc: "FuncArg represents one argument or return value of a function\nin the context of a [FuncButton].", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Fields: []types.Field{{Name: "Name", Doc: "Name is the name of the argument or return value."}, {Name: "Tag", Doc: "Tag contains any tags associated with the argument or return value,\nwhich can be added programmatically to customize [Value] behavior."}, {Name: "Value", Doc: "Value is the actual value of the function argument or return value.\nIt can be modified when creating a [FuncButton] to set a default value."}}})

// SetName sets the [FuncArg.Name]:
// Name is the name of the argument or return value.
func (t *FuncArg) SetName(v string) *FuncArg { t.Name = v; return t }

// SetTag sets the [FuncArg.Tag]:
// Tag contains any tags associated with the argument or return value,
// which can be added programmatically to customize [Value] behavior.
func (t *FuncArg) SetTag(v reflect.StructTag) *FuncArg { t.Tag = v; return t }

// SetValue sets the [FuncArg.Value]:
// Value is the actual value of the function argument or return value.
// It can be modified when creating a [FuncButton] to set a default value.
func (t *FuncArg) SetValue(v any) *FuncArg { t.Value = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Handle", IDName: "handle", Doc: "Handle represents a draggable handle that can be used to\ncontrol the size of an element. The [styles.Style.Direction]\ncontrols the direction in which the handle moves.", Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "Min", Doc: "Min is the minimum value that the handle can go to\n(typically the lower bound of the dialog/splits)"}, {Name: "Max", Doc: "Max is the maximum value that the handle can go to\n(typically the upper bound of the dialog/splits)"}, {Name: "Pos", Doc: "Pos is the current position of the handle on the\nscale of [Handle.Min] to [Handle.Max]."}}})

// NewHandle returns a new [Handle] with the given optional parent:
// Handle represents a draggable handle that can be used to
// control the size of an element. The [styles.Style.Direction]
// controls the direction in which the handle moves.
func NewHandle(parent ...tree.Node) *Handle { return tree.New[Handle](parent...) }

// SetMin sets the [Handle.Min]:
// Min is the minimum value that the handle can go to
// (typically the lower bound of the dialog/splits)
func (t *Handle) SetMin(v float32) *Handle { t.Min = v; return t }

// SetMax sets the [Handle.Max]:
// Max is the maximum value that the handle can go to
// (typically the upper bound of the dialog/splits)
func (t *Handle) SetMax(v float32) *Handle { t.Max = v; return t }

// SetPos sets the [Handle.Pos]:
// Pos is the current position of the handle on the
// scale of [Handle.Min] to [Handle.Max].
func (t *Handle) SetPos(v float32) *Handle { t.Pos = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Icon", IDName: "icon", Doc: "Icon renders an [icons.Icon].\nThe rendered version is cached for the current size.\nIcons do not render a background or border independent of their SVG object.\nThe size of an Icon is determined by the [styles.Font.Size] property.", Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "Icon", Doc: "Icon is the [icons.Icon] used to render the [Icon]."}, {Name: "prevIcon", Doc: "prevIcon is the previously rendered icon."}, {Name: "prevColor", Doc: "prevColor is the previously rendered color, as uniform."}, {Name: "prevOpacity", Doc: "prevOpacity is the previously rendered opacity."}, {Name: "pixels", Doc: "image representation of the icon, cached for faster drawing."}}})

// NewIcon returns a new [Icon] with the given optional parent:
// Icon renders an [icons.Icon].
// The rendered version is cached for the current size.
// Icons do not render a background or border independent of their SVG object.
// The size of an Icon is determined by the [styles.Font.Size] property.
func NewIcon(parent ...tree.Node) *Icon { return tree.New[Icon](parent...) }

// SetIcon sets the [Icon.Icon]:
// Icon is the [icons.Icon] used to render the [Icon].
func (t *Icon) SetIcon(v icons.Icon) *Icon { t.Icon = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Image", IDName: "image", Doc: "Image is a widget that renders an [image.Image].\nSee [styles.Style.ObjectFit] to control the image rendering within\nthe allocated size. The default minimum requested size is the pixel\nsize in [units.Dp] units (1/160th of an inch).", Methods: []types.Method{{Name: "Open", Doc: "Open sets the image to the image located at the given filename.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename"}, Returns: []string{"error"}}}, Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "Image", Doc: "Image is the [image.Image]."}, {Name: "prevImage", Doc: "prevImage is the cached last [Image.Image]."}, {Name: "prevRenderImage", Doc: "prevRenderImage is the cached last rendered image with any transformations applied."}, {Name: "prevObjectFit", Doc: "prevObjectFit is the cached [styles.Style.ObjectFit] of the last rendered image."}, {Name: "prevSize", Doc: "prevSize is the cached allocated size for the last rendered image."}}})

// NewImage returns a new [Image] with the given optional parent:
// Image is a widget that renders an [image.Image].
// See [styles.Style.ObjectFit] to control the image rendering within
// the allocated size. The default minimum requested size is the pixel
// size in [units.Dp] units (1/160th of an inch).
func NewImage(parent ...tree.Node) *Image { return tree.New[Image](parent...) }

// SetImage sets the [Image.Image]:
// Image is the [image.Image].
func (t *Image) SetImage(v image.Image) *Image { t.Image = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.InlineList", IDName: "inline-list", Doc: "InlineList represents a slice within a single line of value widgets.\nThis is typically used for smaller slices.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Slice", Doc: "Slice is the slice that we are viewing."}, {Name: "isArray", Doc: "isArray is whether the slice is actually an array."}}})

// NewInlineList returns a new [InlineList] with the given optional parent:
// InlineList represents a slice within a single line of value widgets.
// This is typically used for smaller slices.
func NewInlineList(parent ...tree.Node) *InlineList { return tree.New[InlineList](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Inspector", IDName: "inspector", Doc: "Inspector represents a [tree.Node] with a [Tree] and a [Form].", Methods: []types.Method{{Name: "save", Doc: "save saves the tree to current filename, in a standard JSON-formatted file.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Returns: []string{"error"}}, {Name: "saveAs", Doc: "saveAs saves tree to given filename, in a standard JSON-formatted file", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename"}, Returns: []string{"error"}}, {Name: "open", Doc: "open opens tree from given filename, in a standard JSON-formatted file", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename"}, Returns: []string{"error"}}, {Name: "toggleSelectionMode", Doc: "toggleSelectionMode toggles the editor between selection mode or not.\nIn selection mode, bounding boxes are rendered around each Widget,\nand clicking on a Widget pulls it up in the inspector.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "inspectApp", Doc: "inspectApp displays [TheApp].", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Root", Doc: "Root is the root of the tree being edited."}, {Name: "currentNode", Doc: "currentNode is the currently selected node in the tree."}, {Name: "filename", Doc: "filename is the current filename for saving / loading"}, {Name: "treeWidget"}}})

// NewInspector returns a new [Inspector] with the given optional parent:
// Inspector represents a [tree.Node] with a [Tree] and a [Form].
func NewInspector(parent ...tree.Node) *Inspector { return tree.New[Inspector](parent...) }

// SetRoot sets the [Inspector.Root]:
// Root is the root of the tree being edited.
func (t *Inspector) SetRoot(v tree.Node) *Inspector { t.Root = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.KeyMapButton", IDName: "key-map-button", Doc: "KeyMapButton represents a [keymap.MapName] value with a button.", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "MapName"}}})

// NewKeyMapButton returns a new [KeyMapButton] with the given optional parent:
// KeyMapButton represents a [keymap.MapName] value with a button.
func NewKeyMapButton(parent ...tree.Node) *KeyMapButton { return tree.New[KeyMapButton](parent...) }

// SetMapName sets the [KeyMapButton.MapName]
func (t *KeyMapButton) SetMapName(v keymap.MapName) *KeyMapButton { t.MapName = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.KeyChordButton", IDName: "key-chord-button", Doc: "KeyChordButton represents a [key.Chord] value with a button.", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "Chord"}}})

// NewKeyChordButton returns a new [KeyChordButton] with the given optional parent:
// KeyChordButton represents a [key.Chord] value with a button.
func NewKeyChordButton(parent ...tree.Node) *KeyChordButton {
        return tree.New[KeyChordButton](parent...)
}

// SetChord sets the [KeyChordButton.Chord]
func (t *KeyChordButton) SetChord(v key.Chord) *KeyChordButton { t.Chord = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.KeyedList", IDName: "keyed-list", Doc: "KeyedList represents a map value using two columns of editable key and value widgets.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Map", Doc: "Map is the pointer to the map that we are viewing."}, {Name: "Inline", Doc: "Inline is whether to display the map in one line."}, {Name: "SortByValues", Doc: "SortByValues is whether to sort by values instead of keys."}, {Name: "ncols", Doc: "ncols is the number of columns to display if the keyed list is not inline."}}})

// NewKeyedList returns a new [KeyedList] with the given optional parent:
// KeyedList represents a map value using two columns of editable key and value widgets.
func NewKeyedList(parent ...tree.Node) *KeyedList { return tree.New[KeyedList](parent...) }

// SetMap sets the [KeyedList.Map]:
// Map is the pointer to the map that we are viewing.
func (t *KeyedList) SetMap(v any) *KeyedList { t.Map = v; return t }

// SetInline sets the [KeyedList.Inline]:
// Inline is whether to display the map in one line.
func (t *KeyedList) SetInline(v bool) *KeyedList { t.Inline = v; return t }

// SetSortByValues sets the [KeyedList.SortByValues]:
// SortByValues is whether to sort by values instead of keys.
func (t *KeyedList) SetSortByValues(v bool) *KeyedList { t.SortByValues = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.List", IDName: "list", Doc: "List represents a slice value with a list of value widgets and optional index widgets.\nUse [ListBase.BindSelect] to make the list designed for item selection.", Embeds: []types.Field{{Name: "ListBase"}}, Fields: []types.Field{{Name: "ListStyler", Doc: "ListStyler is an optional styler for list items."}}})

// NewList returns a new [List] with the given optional parent:
// List represents a slice value with a list of value widgets and optional index widgets.
// Use [ListBase.BindSelect] to make the list designed for item selection.
func NewList(parent ...tree.Node) *List { return tree.New[List](parent...) }

// SetListStyler sets the [List.ListStyler]:
// ListStyler is an optional styler for list items.
func (t *List) SetListStyler(v ListStyler) *List { t.ListStyler = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.ListBase", IDName: "list-base", Doc: "ListBase is the base for [List] and [Table] and any other displays\nof array-like data. It automatically computes the number of rows that fit\nwithin its allocated space, and manages the offset view window into the full\nlist of items, and supports row selection, copy / paste, Drag-n-Drop, etc.\nUse [ListBase.BindSelect] to make the list designed for item selection.", Directives: []types.Directive{{Tool: "core", Directive: "no-new"}}, Methods: []types.Method{{Name: "copyIndexes", Doc: "copyIndexes copies selected idxs to system.Clipboard, optionally resetting the selection", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"reset"}}, {Name: "cutIndexes", Doc: "cutIndexes copies selected indexes to system.Clipboard and deletes selected indexes", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "pasteIndex", Doc: "pasteIndex pastes clipboard at given idx", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"idx"}}, {Name: "duplicate", Doc: "duplicate copies selected items and inserts them after current selection --\nreturn idx of start of duplicates if successful, else -1", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Returns: []string{"int"}}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Slice", Doc: "Slice is the pointer to the slice that we are viewing."}, {Name: "ShowIndexes", Doc: "ShowIndexes is whether to show the indexes of rows or not (default false)."}, {Name: "MinRows", Doc: "MinRows specifies the minimum number of rows to display, to ensure\nat least this amount is displayed."}, {Name: "SelectedValue", Doc: "SelectedValue is the current selection value.\nIf it is set, it is used as the initially selected value."}, {Name: "SelectedIndex", Doc: "SelectedIndex is the index of the currently selected item."}, {Name: "InitSelectedIndex", Doc: "InitSelectedIndex is the index of the row to select at the start."}, {Name: "SelectedIndexes", Doc: "SelectedIndexes is a list of currently selected slice indexes."}, {Name: "lastClick", Doc: "lastClick is the last row that has been clicked on.\nThis is used to prevent erroneous double click events\nfrom being sent when the user clicks on multiple different\nrows in quick succession."}, {Name: "normalCursor", Doc: "normalCursor is the cached cursor to display when there\nis no row being hovered."}, {Name: "currentCursor", Doc: "currentCursor is the cached cursor that should currently be\ndisplayed."}, {Name: "sliceUnderlying", Doc: "sliceUnderlying is the underlying slice value."}, {Name: "hoverRow", Doc: "currently hovered row"}, {Name: "draggedIndexes", Doc: "list of currently dragged indexes"}, {Name: "VisibleRows", Doc: "VisibleRows is the total number of rows visible in allocated display size."}, {Name: "StartIndex", Doc: "StartIndex is the starting slice index of visible rows."}, {Name: "SliceSize", Doc: "SliceSize is the size of the slice."}, {Name: "MakeIter", Doc: "MakeIter is the iteration through the configuration process,\nwhich is reset when a new slice type is set."}, {Name: "tmpIndex", Doc: "temp idx state for e.g., dnd"}, {Name: "elementValue", Doc: "elementValue is a [reflect.Value] representation of the underlying element type\nwhich is used whenever there are no slice elements available"}, {Name: "maxWidth", Doc: "maximum width of value column in chars, if string"}, {Name: "ReadOnlyKeyNav", Doc: "ReadOnlyKeyNav is whether support key navigation when ReadOnly (default true).\nIt uses a capture of up / down events to manipulate selection, not focus."}, {Name: "SelectMode", Doc: "SelectMode is whether to be in select rows mode or editing mode."}, {Name: "ReadOnlyMultiSelect", Doc: "ReadOnlyMultiSelect: if list is ReadOnly, default selection mode is to\nchoose one row only. If this is true, standard multiple selection logic\nwith modifier keys is instead supported."}, {Name: "InFocusGrab", Doc: "InFocusGrab is a guard for recursive focus grabbing."}, {Name: "isArray", Doc: "isArray is whether the slice is actually an array."}, {Name: "ListGrid", Doc: "ListGrid is the [ListGrid] widget."}}})

// SetShowIndexes sets the [ListBase.ShowIndexes]:
// ShowIndexes is whether to show the indexes of rows or not (default false).
func (t *ListBase) SetShowIndexes(v bool) *ListBase { t.ShowIndexes = v; return t }

// SetMinRows sets the [ListBase.MinRows]:
// MinRows specifies the minimum number of rows to display, to ensure
// at least this amount is displayed.
func (t *ListBase) SetMinRows(v int) *ListBase { t.MinRows = v; return t }

// SetSelectedValue sets the [ListBase.SelectedValue]:
// SelectedValue is the current selection value.
// If it is set, it is used as the initially selected value.
func (t *ListBase) SetSelectedValue(v any) *ListBase { t.SelectedValue = v; return t }

// SetSelectedIndex sets the [ListBase.SelectedIndex]:
// SelectedIndex is the index of the currently selected item.
func (t *ListBase) SetSelectedIndex(v int) *ListBase { t.SelectedIndex = v; return t }

// SetInitSelectedIndex sets the [ListBase.InitSelectedIndex]:
// InitSelectedIndex is the index of the row to select at the start.
func (t *ListBase) SetInitSelectedIndex(v int) *ListBase { t.InitSelectedIndex = v; return t }

// SetReadOnlyKeyNav sets the [ListBase.ReadOnlyKeyNav]:
// ReadOnlyKeyNav is whether support key navigation when ReadOnly (default true).
// It uses a capture of up / down events to manipulate selection, not focus.
func (t *ListBase) SetReadOnlyKeyNav(v bool) *ListBase { t.ReadOnlyKeyNav = v; return t }

// SetReadOnlyMultiSelect sets the [ListBase.ReadOnlyMultiSelect]:
// ReadOnlyMultiSelect: if list is ReadOnly, default selection mode is to
// choose one row only. If this is true, standard multiple selection logic
// with modifier keys is instead supported.
func (t *ListBase) SetReadOnlyMultiSelect(v bool) *ListBase { t.ReadOnlyMultiSelect = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.ListGrid", IDName: "list-grid", Doc: "ListGrid handles the resizing logic for all [Lister]s.", Directives: []types.Directive{{Tool: "core", Directive: "no-new"}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "minRows", Doc: "minRows is set from parent [List]"}, {Name: "rowHeight", Doc: "height of a single row, computed during layout"}, {Name: "visibleRows", Doc: "total number of rows visible in allocated display size"}, {Name: "bgStripe", Doc: "Various computed backgrounds"}, {Name: "bgSelect", Doc: "Various computed backgrounds"}, {Name: "bgSelectStripe", Doc: "Various computed backgrounds"}, {Name: "bgHover", Doc: "Various computed backgrounds"}, {Name: "bgHoverStripe", Doc: "Various computed backgrounds"}, {Name: "bgHoverSelect", Doc: "Various computed backgrounds"}, {Name: "bgHoverSelectStripe", Doc: "Various computed backgrounds"}, {Name: "lastBackground", Doc: "lastBackground is the background for which modified\nbackgrounds were computed -- don't update if same"}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Meter", IDName: "meter", Doc: "Meter is a widget that renders a current value on as a filled\nbar/circle/semicircle relative to a minimum and maximum potential\nvalue.", Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the styling type of the meter."}, {Name: "Value", Doc: "Value is the current value of the meter.\nIt defaults to 0.5."}, {Name: "Min", Doc: "Min is the minimum possible value of the meter.\nIt defaults to 0."}, {Name: "Max", Doc: "Max is the maximum possible value of the meter.\nIt defaults to 1."}, {Name: "Text", Doc: "Text, for [MeterCircle] and [MeterSemicircle], is the\ntext to render inside of the circle/semicircle."}, {Name: "ValueColor", Doc: "ValueColor is the image color that will be used to\nrender the filled value bar. It should be set in a Styler."}, {Name: "Width", Doc: "Width, for [MeterCircle] and [MeterSemicircle], is the\nwidth of the circle/semicircle. It should be set in a Styler."}}})

// NewMeter returns a new [Meter] with the given optional parent:
// Meter is a widget that renders a current value on as a filled
// bar/circle/semicircle relative to a minimum and maximum potential
// value.
func NewMeter(parent ...tree.Node) *Meter { return tree.New[Meter](parent...) }

// SetType sets the [Meter.Type]:
// Type is the styling type of the meter.
func (t *Meter) SetType(v MeterTypes) *Meter { t.Type = v; return t }

// SetValue sets the [Meter.Value]:
// Value is the current value of the meter.
// It defaults to 0.5.
func (t *Meter) SetValue(v float32) *Meter { t.Value = v; return t }

// SetMin sets the [Meter.Min]:
// Min is the minimum possible value of the meter.
// It defaults to 0.
func (t *Meter) SetMin(v float32) *Meter { t.Min = v; return t }

// SetMax sets the [Meter.Max]:
// Max is the maximum possible value of the meter.
// It defaults to 1.
func (t *Meter) SetMax(v float32) *Meter { t.Max = v; return t }

// SetText sets the [Meter.Text]:
// Text, for [MeterCircle] and [MeterSemicircle], is the
// text to render inside of the circle/semicircle.
func (t *Meter) SetText(v string) *Meter { t.Text = v; return t }

// SetValueColor sets the [Meter.ValueColor]:
// ValueColor is the image color that will be used to
// render the filled value bar. It should be set in a Styler.
func (t *Meter) SetValueColor(v image.Image) *Meter { t.ValueColor = v; return t }

// SetWidth sets the [Meter.Width]:
// Width, for [MeterCircle] and [MeterSemicircle], is the
// width of the circle/semicircle. It should be set in a Styler.
func (t *Meter) SetWidth(v units.Value) *Meter { t.Width = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Pages", IDName: "pages", Doc: "Pages is a frame that can easily swap its content between that of\ndifferent possible pages.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Page", Doc: "Page is the currently open page."}, {Name: "Pages", Doc: "Pages is a map of page names to functions that configure a page."}, {Name: "page", Doc: "page is the currently rendered page."}}})

// NewPages returns a new [Pages] with the given optional parent:
// Pages is a frame that can easily swap its content between that of
// different possible pages.
func NewPages(parent ...tree.Node) *Pages { return tree.New[Pages](parent...) }

// SetPage sets the [Pages.Page]:
// Page is the currently open page.
func (t *Pages) SetPage(v string) *Pages { t.Page = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Scene", IDName: "scene", Doc: "Scene contains a [Widget] tree, rooted in an embedded [Frame] layout,\nwhich renders into its own [paint.Painter]. The [Scene] is set in a\n[Stage], which the [Scene] has a pointer to.\n\nEach [Scene] contains state specific to its particular usage\nwithin a given [Stage] and overall rendering context, representing the unit\nof rendering in the Cogent Core framework.", Directives: []types.Directive{{Tool: "core", Directive: "no-new"}}, Methods: []types.Method{{Name: "standardContextMenu", Doc: "standardContextMenu adds standard context menu items for the [Scene].", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"m"}}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Body", Doc: "Body provides the main contents of scenes that use control Bars\nto allow the main window contents to be specified separately\nfrom that dynamic control content.  When constructing scenes using\na [Body], you can operate directly on the [Body], which has wrappers\nfor most major Scene functions."}, {Name: "WidgetInit", Doc: "WidgetInit is a function called on every newly created [Widget].\nThis can be used to set global configuration and styling for all\nwidgets in conjunction with [App.SceneInit]."}, {Name: "Bars", Doc: "Bars are functions for creating control bars,\nattached to different sides of a [Scene]. Functions\nare called in forward order so first added are called first."}, {Name: "Data", Doc: "Data is the optional data value being represented by this scene.\nUsed e.g., for recycling views of a given item instead of creating new one."}, {Name: "SceneGeom", Doc: "Size and position relative to overall rendering context."}, {Name: "Painter", Doc: "painter for rendering"}, {Name: "Events", Doc: "event manager for this scene"}, {Name: "Stage", Doc: "current stage in which this Scene is set"}, {Name: "Animations", Doc: "Animations are the currently active [Animation]s in this scene."}, {Name: "renderBBoxes", Doc: "renderBBoxes indicates to render colored bounding boxes for all of the widgets\nin the scene. This is enabled by the [Inspector] in select element mode."}, {Name: "renderBBoxHue", Doc: "renderBBoxHue is current hue for rendering bounding box in [Scene.RenderBBoxes] mode."}, {Name: "selectedWidget", Doc: "selectedWidget is the currently selected/hovered widget through the [Inspector] selection mode\nthat should be highlighted with a background color."}, {Name: "selectedWidgetChan", Doc: "selectedWidgetChan is the channel on which the selected widget through the inspect editor\nselection mode is transmitted to the inspect editor after the user is done selecting."}, {Name: "renderer", Doc: "source renderer for rendering the scene"}, {Name: "lastRender", Doc: "lastRender captures key params from last render.\nIf different then a new ApplyStyleScene is needed."}, {Name: "showIter", Doc: "showIter counts up at start of showing a Scene\nto trigger Show event and other steps at start of first show"}, {Name: "directRenders", Doc: "directRenders are widgets that render directly to the [RenderWindow]\ninstead of rendering into the Scene Painter."}, {Name: "flags", Doc: "flags are atomic bit flags for [Scene] state."}}})

// SetWidgetInit sets the [Scene.WidgetInit]:
// WidgetInit is a function called on every newly created [Widget].
// This can be used to set global configuration and styling for all
// widgets in conjunction with [App.SceneInit].
func (t *Scene) SetWidgetInit(v func(w Widget)) *Scene { t.WidgetInit = v; return t }

// SetData sets the [Scene.Data]:
// Data is the optional data value being represented by this scene.
// Used e.g., for recycling views of a given item instead of creating new one.
func (t *Scene) SetData(v any) *Scene { t.Data = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Separator", IDName: "separator", Doc: "Separator draws a separator line. It goes in the direction\nspecified by [styles.Style.Direction].", Embeds: []types.Field{{Name: "WidgetBase"}}})

// NewSeparator returns a new [Separator] with the given optional parent:
// Separator draws a separator line. It goes in the direction
// specified by [styles.Style.Direction].
func NewSeparator(parent ...tree.Node) *Separator { return tree.New[Separator](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.AppearanceSettingsData", IDName: "appearance-settings-data", Doc: "AppearanceSettingsData is the data type for the global Cogent Core appearance settings.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Methods: []types.Method{{Name: "Apply", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "deleteSavedWindowGeometries", Doc: "deleteSavedWindowGeometries deletes the file that saves the position and size of\neach window, by screen, and clear current in-memory cache. You shouldn't generally\nneed to do this, but sometimes it is useful for testing or windows that are\nshowing up in bad places that you can't recover from.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "SaveScreenZoom", Doc: "SaveScreenZoom saves the current zoom factor for the current screen,\nwhich will then be used for this screen instead of overall default.\nUse the Control +/- keyboard shortcut to modify the screen zoom level.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "SettingsBase"}}, Fields: []types.Field{{Name: "Theme", Doc: "the color theme."}, {Name: "Color", Doc: "the primary color used to generate the color scheme."}, {Name: "Zoom", Doc: "overall zoom factor as a percentage of the default zoom.\nUse Control +/- keyboard shortcut to change zoom level anytime.\nScreen-specific zoom factor will be used if present, see 'Screens' field."}, {Name: "Spacing", Doc: "the overall spacing factor as a percentage of the default amount of spacing\n(higher numbers lead to more space and lower numbers lead to higher density)."}, {Name: "FontSize", Doc: "the overall font size factor applied to all text as a percentage\nof the default font size (higher numbers lead to larger text)."}, {Name: "DocsFontSize", Doc: "Font size factor applied only to documentation and other\ndense text contexts, not normal interactive elements.\nIt is a percentage of the base Font size setting (higher numbers\nlead to larger text)."}, {Name: "ZebraStripes", Doc: "the amount that alternating rows are highlighted when showing\ntabular data (set to 0 to disable zebra striping)."}, {Name: "Screens", Doc: "screen-specific settings, which will override overall defaults if set,\nso different screens can use different zoom levels.\nUse 'Save screen zoom' in the toolbar to save the current zoom for the current\nscreen, and Control +/- keyboard shortcut to change this zoom level anytime."}, {Name: "Highlighting", Doc: "text highlighting style / theme."}, {Name: "Text", Doc: "Text specifies text settings including the language, and the\nfont families for different styles of fonts."}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.DeviceSettingsData", IDName: "device-settings-data", Doc: "DeviceSettingsData is the data type for the device settings.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Embeds: []types.Field{{Name: "SettingsBase"}}, Fields: []types.Field{{Name: "KeyMap", Doc: "The keyboard shortcut map to use"}, {Name: "KeyMaps", Doc: "The keyboard shortcut maps available as options for Key map.\nIf you do not want to have custom key maps, you should leave\nthis unset so that you always have the latest standard key maps."}, {Name: "DoubleClickInterval", Doc: "The maximum time interval between button press events to count as a double-click"}, {Name: "ScrollWheelSpeed", Doc: "How fast the scroll wheel moves, which is typically pixels per wheel step\nbut units can be arbitrary. It is generally impossible to standardize speed\nand variable across devices, and we don't have access to the system settings,\nso unfortunately you have to set it here."}, {Name: "ScrollFocusTime", Doc: "The duration over which the current scroll widget retains scroll focus,\nsuch that subsequent scroll events are sent to it."}, {Name: "SlideStartTime", Doc: "The amount of time to wait before initiating a slide event\n(as opposed to a basic press event)"}, {Name: "DragStartTime", Doc: "The amount of time to wait before initiating a drag (drag and drop) event\n(as opposed to a basic press or slide event)"}, {Name: "RepeatClickTime", Doc: "The amount of time to wait between each repeat click event,\nwhen the mouse is pressed down.  The first click is 8x this."}, {Name: "DragStartDistance", Doc: "The number of pixels that must be moved before initiating a slide/drag\nevent (as opposed to a basic press event)"}, {Name: "LongHoverTime", Doc: "The amount of time to wait before initiating a long hover event (e.g., for opening a tooltip)"}, {Name: "LongHoverStopDistance", Doc: "The maximum number of pixels that mouse can move and still register a long hover event"}, {Name: "LongPressTime", Doc: "The amount of time to wait before initiating a long press event (e.g., for opening a tooltip)"}, {Name: "LongPressStopDistance", Doc: "The maximum number of pixels that mouse/finger can move and still register a long press event"}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.ScreenSettings", IDName: "screen-settings", Doc: "ScreenSettings are per-screen settings that override the global settings.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Fields: []types.Field{{Name: "Zoom", Doc: "overall zoom factor as a percentage of the default zoom"}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.SystemSettingsData", IDName: "system-settings-data", Doc: "SystemSettingsData is the data type of the global Cogent Core settings.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Methods: []types.Method{{Name: "Apply", Doc: "Apply detailed settings to all the relevant settings.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "SettingsBase"}}, Fields: []types.Field{{Name: "Editor", Doc: "text editor settings"}, {Name: "Clock24", Doc: "whether to use a 24-hour clock (instead of AM and PM)"}, {Name: "SnackbarTimeout", Doc: "SnackbarTimeout is the default amount of time until snackbars\ndisappear (snackbars show short updates about app processes\nat the bottom of the screen)"}, {Name: "OnlyCloseActiveTab", Doc: "only support closing the currently selected active tab;\nif this is set to true, pressing the close button on other tabs\nwill take you to that tab, from which you can close it."}, {Name: "BigFileSize", Doc: "the limit of file size, above which user will be prompted before\nopening / copying, etc."}, {Name: "SavedPathsMax", Doc: "maximum number of saved paths to save in FilePicker"}, {Name: "User", Doc: "user info, which is partially filled-out automatically if empty\nwhen settings are first created."}, {Name: "FavPaths", Doc: "favorite paths, shown in FilePickerer and also editable there"}, {Name: "FilePickerSort", Doc: "column to sort by in FilePicker, and :up or :down for direction.\nUpdated automatically via FilePicker"}, {Name: "MenuMaxHeight", Doc: "the maximum height of any menu popup panel in units of font height;\nscroll bars are enforced beyond that size."}, {Name: "CompleteWaitDuration", Doc: "the amount of time to wait before offering completions"}, {Name: "CompleteMaxItems", Doc: "the maximum number of completions offered in popup"}, {Name: "CursorBlinkTime", Doc: "time interval for cursor blinking on and off -- set to 0 to disable blinking"}, {Name: "LayoutAutoScrollDelay", Doc: "The amount of time to wait before trying to autoscroll again"}, {Name: "LayoutPageSteps", Doc: "number of steps to take in PageUp / Down events in terms of number of items"}, {Name: "LayoutFocusNameTimeout", Doc: "the amount of time between keypresses to combine characters into name\nto search for within layout -- starts over after this delay."}, {Name: "LayoutFocusNameTabTime", Doc: "the amount of time since last focus name event to allow tab to focus\non next element with same name."}, {Name: "MapInlineLength", Doc: "the number of map elements at or below which an inline representation\nof the map will be presented, which is more convenient for small #'s of properties"}, {Name: "StructInlineLength", Doc: "the number of elemental struct fields at or below which an inline representation\nof the struct will be presented, which is more convenient for small structs"}, {Name: "SliceInlineLength", Doc: "the number of slice elements below which inline will be used"}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.User", IDName: "user", Doc: "User basic user information that might be needed for different apps", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Embeds: []types.Field{{Name: "User"}}, Fields: []types.Field{{Name: "Email", Doc: "default email address -- e.g., for recording changes in a version control system"}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.favoritePathItem", IDName: "favorite-path-item", Doc: "favoritePathItem represents one item in a favorite path list, for display of\nfavorites. Is an ordered list instead of a map because user can organize\nin order", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Fields: []types.Field{{Name: "Icon", Doc: "icon for item"}, {Name: "Name", Doc: "name of the favorite item"}, {Name: "Path", Doc: "the path of the favorite item"}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.DebugSettingsData", IDName: "debug-settings-data", Doc: "DebugSettingsData is the data type for debugging settings.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Embeds: []types.Field{{Name: "SettingsBase"}}, Fields: []types.Field{{Name: "UpdateTrace", Doc: "Print a trace of updates that trigger re-rendering"}, {Name: "RenderTrace", Doc: "Print a trace of the nodes rendering"}, {Name: "LayoutTrace", Doc: "Print a trace of all layouts"}, {Name: "LayoutTraceDetail", Doc: "Print more detailed info about the underlying layout computations"}, {Name: "WindowEventTrace", Doc: "Print a trace of window events"}, {Name: "WindowRenderTrace", Doc: "Print the stack trace leading up to win publish events\nwhich are expensive"}, {Name: "WindowGeometryTrace", Doc: "Print a trace of window geometry saving / loading functions"}, {Name: "KeyEventTrace", Doc: "Print a trace of keyboard events"}, {Name: "EventTrace", Doc: "Print a trace of event handling"}, {Name: "FocusTrace", Doc: "Print a trace of focus changes"}, {Name: "DNDTrace", Doc: "Print a trace of DND event handling"}, {Name: "DisableWindowGeometrySaver", Doc: "DisableWindowGeometrySaver disables the saving and loading of window geometry\ndata to allow for easier testing of window manipulation code."}, {Name: "GoCompleteTrace", Doc: "Print a trace of Go language completion and lookup process"}, {Name: "GoTypeTrace", Doc: "Print a trace of Go language type parsing and inference process"}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Slider", IDName: "slider", Doc: "Slider is a slideable widget that provides slider functionality with a draggable\nthumb and a clickable track. The [styles.Style.Direction] determines the direction\nin which the slider slides.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the type of the slider, which determines its visual\nand functional properties. The default type, [SliderSlider],\nshould work for most end-user use cases."}, {Name: "Value", Doc: "Value is the current value, represented by the position of the thumb.\nIt defaults to 0.5."}, {Name: "Min", Doc: "Min is the minimum possible value.\nIt defaults to 0."}, {Name: "Max", Doc: "Max is the maximum value supported.\nIt defaults to 1."}, {Name: "Step", Doc: "Step is the amount that the arrow keys increment/decrement the value by.\nIt defaults to 0.1."}, {Name: "EnforceStep", Doc: "EnforceStep is whether to ensure that the value is always\na multiple of [Slider.Step]."}, {Name: "PageStep", Doc: "PageStep is the amount that the PageUp and PageDown keys\nincrement/decrement the value by.\nIt defaults to 0.2, and will be at least as big as [Slider.Step]."}, {Name: "Icon", Doc: "Icon is an optional icon to use for the dragging thumb."}, {Name: "visiblePercent", Doc: "For Scrollbar type only: proportion (1 max) of the full range of scrolled data\nthat is currently visible.  This determines the thumb size and range of motion:\nif 1, full slider is the thumb and no motion is possible."}, {Name: "ThumbSize", Doc: "ThumbSize is the size of the thumb as a proportion of the slider thickness,\nwhich is the content size (inside the padding)."}, {Name: "TrackSize", Doc: "TrackSize is the proportion of slider thickness for the visible track\nfor the [SliderSlider] type. It is often thinner than the thumb, achieved\nby values less than 1 (0.5 default)."}, {Name: "InputThreshold", Doc: "InputThreshold is the threshold for the amount of change in scroll\nvalue before emitting an input event."}, {Name: "Precision", Doc: "Precision specifies the precision of decimal places (total, not after the decimal\npoint) to use in representing the number. This helps to truncate small weird\nfloating point values."}, {Name: "ValueColor", Doc: "ValueColor is the background color that is used for styling the selected value\nsection of the slider. It should be set in a Styler, just like the main style\nobject is. If it is set to transparent, no value is rendered, so the value\nsection of the slider just looks like the rest of the slider."}, {Name: "ThumbColor", Doc: "ThumbColor is the background color that is used for styling the thumb (handle)\nof the slider. It should be set in a Styler, just like the main style object is.\nIf it is set to transparent, no thumb is rendered, so the thumb section of the\nslider just looks like the rest of the slider."}, {Name: "StayInView", Doc: "StayInView is whether to keep the slider (typically a [SliderScrollbar]) within\nthe parent [Scene] bounding box, if the parent is in view. This is the default\nbehavior for [Frame] scrollbars, and setting this flag replicates that behavior\nin other scrollbars."}, {Name: "pos", Doc: "logical position of the slider relative to Size"}, {Name: "lastValue", Doc: "previous Change event emitted value; don't re-emit Change if it is the same"}, {Name: "prevSlide", Doc: "previous sliding value (for computing the Input change)"}, {Name: "slideStartPos", Doc: "underlying drag position of slider; not subject to snapping"}}})

// NewSlider returns a new [Slider] with the given optional parent:
// Slider is a slideable widget that provides slider functionality with a draggable
// thumb and a clickable track. The [styles.Style.Direction] determines the direction
// in which the slider slides.
func NewSlider(parent ...tree.Node) *Slider { return tree.New[Slider](parent...) }

// SetType sets the [Slider.Type]:
// Type is the type of the slider, which determines its visual
// and functional properties. The default type, [SliderSlider],
// should work for most end-user use cases.
func (t *Slider) SetType(v SliderTypes) *Slider { t.Type = v; return t }

// SetMin sets the [Slider.Min]:
// Min is the minimum possible value.
// It defaults to 0.
func (t *Slider) SetMin(v float32) *Slider { t.Min = v; return t }

// SetMax sets the [Slider.Max]:
// Max is the maximum value supported.
// It defaults to 1.
func (t *Slider) SetMax(v float32) *Slider { t.Max = v; return t }

// SetStep sets the [Slider.Step]:
// Step is the amount that the arrow keys increment/decrement the value by.
// It defaults to 0.1.
func (t *Slider) SetStep(v float32) *Slider { t.Step = v; return t }

// SetEnforceStep sets the [Slider.EnforceStep]:
// EnforceStep is whether to ensure that the value is always
// a multiple of [Slider.Step].
func (t *Slider) SetEnforceStep(v bool) *Slider { t.EnforceStep = v; return t }

// SetPageStep sets the [Slider.PageStep]:
// PageStep is the amount that the PageUp and PageDown keys
// increment/decrement the value by.
// It defaults to 0.2, and will be at least as big as [Slider.Step].
func (t *Slider) SetPageStep(v float32) *Slider { t.PageStep = v; return t }

// SetIcon sets the [Slider.Icon]:
// Icon is an optional icon to use for the dragging thumb.
func (t *Slider) SetIcon(v icons.Icon) *Slider { t.Icon = v; return t }

// SetThumbSize sets the [Slider.ThumbSize]:
// ThumbSize is the size of the thumb as a proportion of the slider thickness,
// which is the content size (inside the padding).
func (t *Slider) SetThumbSize(v math32.Vector2) *Slider { t.ThumbSize = v; return t }

// SetTrackSize sets the [Slider.TrackSize]:
// TrackSize is the proportion of slider thickness for the visible track
// for the [SliderSlider] type. It is often thinner than the thumb, achieved
// by values less than 1 (0.5 default).
func (t *Slider) SetTrackSize(v float32) *Slider { t.TrackSize = v; return t }

// SetInputThreshold sets the [Slider.InputThreshold]:
// InputThreshold is the threshold for the amount of change in scroll
// value before emitting an input event.
func (t *Slider) SetInputThreshold(v float32) *Slider { t.InputThreshold = v; return t }

// SetPrecision sets the [Slider.Precision]:
// Precision specifies the precision of decimal places (total, not after the decimal
// point) to use in representing the number. This helps to truncate small weird
// floating point values.
func (t *Slider) SetPrecision(v int) *Slider { t.Precision = v; return t }

// SetValueColor sets the [Slider.ValueColor]:
// ValueColor is the background color that is used for styling the selected value
// section of the slider. It should be set in a Styler, just like the main style
// object is. If it is set to transparent, no value is rendered, so the value
// section of the slider just looks like the rest of the slider.
func (t *Slider) SetValueColor(v image.Image) *Slider { t.ValueColor = v; return t }

// SetThumbColor sets the [Slider.ThumbColor]:
// ThumbColor is the background color that is used for styling the thumb (handle)
// of the slider. It should be set in a Styler, just like the main style object is.
// If it is set to transparent, no thumb is rendered, so the thumb section of the
// slider just looks like the rest of the slider.
func (t *Slider) SetThumbColor(v image.Image) *Slider { t.ThumbColor = v; return t }

// SetStayInView sets the [Slider.StayInView]:
// StayInView is whether to keep the slider (typically a [SliderScrollbar]) within
// the parent [Scene] bounding box, if the parent is in view. This is the default
// behavior for [Frame] scrollbars, and setting this flag replicates that behavior
// in other scrollbars.
func (t *Slider) SetStayInView(v bool) *Slider { t.StayInView = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Spinner", IDName: "spinner", Doc: "Spinner is a [TextField] for editing numerical values. It comes with\nfields, methods, buttons, and shortcuts to enhance numerical value editing.", Embeds: []types.Field{{Name: "TextField"}}, Fields: []types.Field{{Name: "Value", Doc: "Value is the current value."}, {Name: "HasMin", Doc: "HasMin is whether there is a minimum value to enforce.\nIt should be set using [Spinner.SetMin]."}, {Name: "Min", Doc: "Min, if [Spinner.HasMin] is true, is the the minimum value in range.\nIt should be set using [Spinner.SetMin]."}, {Name: "HasMax", Doc: "HaxMax is whether there is a maximum value to enforce.\nIt should be set using [Spinner.SetMax]."}, {Name: "Max", Doc: "Max, if [Spinner.HasMax] is true, is the maximum value in range.\nIt should be set using [Spinner.SetMax]."}, {Name: "Step", Doc: "Step is the amount that the up and down buttons and arrow keys\nincrement/decrement the value by. It defaults to 0.1."}, {Name: "EnforceStep", Doc: "EnforceStep is whether to ensure that the value of the spinner\nis always a multiple of [Spinner.Step]."}, {Name: "PageStep", Doc: "PageStep is the amount that the PageUp and PageDown keys\nincrement/decrement the value by.\nIt defaults to 0.2, and will be at least as big as [Spinner.Step]."}, {Name: "Precision", Doc: "Precision specifies the precision of decimal places\n(total, not after the decimal point) to use in\nrepresenting the number. This helps to truncate\nsmall weird floating point values."}, {Name: "Format", Doc: "Format is the format string to use for printing the value.\nIf it unset, %g is used. If it is decimal based\n(ends in d, b, c, o, O, q, x, X, or U) then the value is\nconverted to decimal prior to printing."}}})

// NewSpinner returns a new [Spinner] with the given optional parent:
// Spinner is a [TextField] for editing numerical values. It comes with
// fields, methods, buttons, and shortcuts to enhance numerical value editing.
func NewSpinner(parent ...tree.Node) *Spinner { return tree.New[Spinner](parent...) }

// SetStep sets the [Spinner.Step]:
// Step is the amount that the up and down buttons and arrow keys
// increment/decrement the value by. It defaults to 0.1.
func (t *Spinner) SetStep(v float32) *Spinner { t.Step = v; return t }

// SetEnforceStep sets the [Spinner.EnforceStep]:
// EnforceStep is whether to ensure that the value of the spinner
// is always a multiple of [Spinner.Step].
func (t *Spinner) SetEnforceStep(v bool) *Spinner { t.EnforceStep = v; return t }

// SetPageStep sets the [Spinner.PageStep]:
// PageStep is the amount that the PageUp and PageDown keys
// increment/decrement the value by.
// It defaults to 0.2, and will be at least as big as [Spinner.Step].
func (t *Spinner) SetPageStep(v float32) *Spinner { t.PageStep = v; return t }

// SetPrecision sets the [Spinner.Precision]:
// Precision specifies the precision of decimal places
// (total, not after the decimal point) to use in
// representing the number. This helps to truncate
// small weird floating point values.
func (t *Spinner) SetPrecision(v int) *Spinner { t.Precision = v; return t }

// SetFormat sets the [Spinner.Format]:
// Format is the format string to use for printing the value.
// If it unset, %g is used. If it is decimal based
// (ends in d, b, c, o, O, q, x, X, or U) then the value is
// converted to decimal prior to printing.
func (t *Spinner) SetFormat(v string) *Spinner { t.Format = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Splits", IDName: "splits", Doc: "Splits allocates a certain proportion of its space to each of its children,\norganized along [styles.Style.Direction] as the main axis, and supporting\n[SplitsTiles] of 2D splits configurations along the cross axis.\nThere is always a split between each Tile segment along the main axis,\nwith the proportion of the total main axis space per Tile allocated\naccording to normalized Splits factors.\nIf all Tiles are Span then a 1D line is generated.  Children are allocated\nin order along the main axis, according to each of the Tiles,\nwhich consume 1 to 4 elements, and have 0 to 3 splits internally.\nThe internal split proportion are stored separately in SubSplits.\nA [Handle] widget is added to the Parts for each split, allowing the user\nto drag the relative size of each splits region.\nIf more complex geometries are required, use nested Splits.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Tiles", Doc: "Tiles specifies the 2D layout of elements along the [styles.Style.Direction]\nmain axis and the orthogonal cross axis.  If all Tiles are TileSpan, then\na 1D line is generated.  There is always a split between each Tile segment,\nand different tiles consume different numbers of elements in order, and\nhave different numbers of SubSplits.  Because each Tile can represent a\ndifferent number of elements, care must be taken to ensure that the full\nset of tiles corresponds to the actual number of children.  A default\n1D configuration will be imposed if there is a mismatch."}, {Name: "TileSplits", Doc: "TileSplits is the proportion (0-1 normalized, enforced) of space\nallocated to each Tile element along the main axis.\n0 indicates that an element should  be completely collapsed.\nBy default, each element gets the same amount of space."}, {Name: "SubSplits", Doc: "SubSplits contains splits proportions for each Tile element, with\na variable number depending on the Tile.  For the First and Second Long\nelements, there are 2 subsets of sub-splits, with 4 total subsplits."}, {Name: "savedSplits", Doc: "savedSplits is a saved version of the Splits that can be restored\nfor dynamic collapse/expand operations."}, {Name: "savedSubSplits", Doc: "savedSubSplits is a saved version of the SubSplits that can be restored\nfor dynamic collapse/expand operations."}, {Name: "handleDirs", Doc: "handleDirs contains the target directions for each of the handles.\nthis is set by parent split in its style function, and consumed\nby each handle in its own style function."}}})

// NewSplits returns a new [Splits] with the given optional parent:
// Splits allocates a certain proportion of its space to each of its children,
// organized along [styles.Style.Direction] as the main axis, and supporting
// [SplitsTiles] of 2D splits configurations along the cross axis.
// There is always a split between each Tile segment along the main axis,
// with the proportion of the total main axis space per Tile allocated
// according to normalized Splits factors.
// If all Tiles are Span then a 1D line is generated.  Children are allocated
// in order along the main axis, according to each of the Tiles,
// which consume 1 to 4 elements, and have 0 to 3 splits internally.
// The internal split proportion are stored separately in SubSplits.
// A [Handle] widget is added to the Parts for each split, allowing the user
// to drag the relative size of each splits region.
// If more complex geometries are required, use nested Splits.
func NewSplits(parent ...tree.Node) *Splits { return tree.New[Splits](parent...) }

// SetTiles sets the [Splits.Tiles]:
// Tiles specifies the 2D layout of elements along the [styles.Style.Direction]
// main axis and the orthogonal cross axis.  If all Tiles are TileSpan, then
// a 1D line is generated.  There is always a split between each Tile segment,
// and different tiles consume different numbers of elements in order, and
// have different numbers of SubSplits.  Because each Tile can represent a
// different number of elements, care must be taken to ensure that the full
// set of tiles corresponds to the actual number of children.  A default
// 1D configuration will be imposed if there is a mismatch.
func (t *Splits) SetTiles(v ...SplitsTiles) *Splits { t.Tiles = v; return t }

// SetTileSplits sets the [Splits.TileSplits]:
// TileSplits is the proportion (0-1 normalized, enforced) of space
// allocated to each Tile element along the main axis.
// 0 indicates that an element should  be completely collapsed.
// By default, each element gets the same amount of space.
func (t *Splits) SetTileSplits(v ...float32) *Splits { t.TileSplits = v; return t }

// SetSubSplits sets the [Splits.SubSplits]:
// SubSplits contains splits proportions for each Tile element, with
// a variable number depending on the Tile.  For the First and Second Long
// elements, there are 2 subsets of sub-splits, with 4 total subsplits.
func (t *Splits) SetSubSplits(v ...[]float32) *Splits { t.SubSplits = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Stage", IDName: "stage", Doc: "Stage is a container and manager for displaying a [Scene]\nin different functional ways, defined by [StageTypes].", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the type of [Stage], which determines behavior and styling."}, {Name: "Scene", Doc: "Scene contents of this [Stage] (what it displays)."}, {Name: "Context", Doc: "Context is a widget in another scene that requested this stage to be created\nand provides context."}, {Name: "Name", Doc: "Name is the name of the Stage, which is generally auto-set\nbased on the [Scene.Name]."}, {Name: "Title", Doc: "Title is the title of the Stage, which is generally auto-set\nbased on the [Body.Title]. It used for the title of [WindowStage]\nand [DialogStage] types, and for a [Text] title widget if\n[Stage.DisplayTitle] is true."}, {Name: "Screen", Doc: "Screen specifies the screen number on which a new window is opened\nby default on desktop platforms. It defaults to -1, which indicates\nthat the first window should open on screen 0 (the default primary\nscreen) and any subsequent windows should open on the same screen as\nthe currently active window. Regardless, the automatically saved last\nscreen of a window with the same [Stage.Title] takes precedence if it exists;\nsee the website documentation on window geometry saving for more information.\nUse [TheApp].ScreenByName(\"name\").ScreenNumber to get the screen by name."}, {Name: "Modal", Doc: "Modal, if true, blocks input to all other stages."}, {Name: "Scrim", Doc: "Scrim, if true, places a darkening scrim over other stages."}, {Name: "ClickOff", Doc: "ClickOff, if true, dismisses the [Stage] if the user clicks anywhere\noff of the [Stage]."}, {Name: "ignoreEvents", Doc: "ignoreEvents is whether to send no events to the stage and\njust pass them down to lower stages."}, {Name: "NewWindow", Doc: "NewWindow, if true, opens a [WindowStage] or [DialogStage] in its own\nseparate operating system window ([renderWindow]). This is true by\ndefault for [WindowStage] on non-mobile platforms, otherwise false."}, {Name: "FullWindow", Doc: "FullWindow, if [Stage.NewWindow] is false, makes [DialogStage]s and\n[WindowStage]s take up the entire window they are created in."}, {Name: "Maximized", Doc: "Maximized is whether to make a window take up the entire screen on desktop\nplatforms by default. It is different from [Stage.Fullscreen] in that\nfullscreen makes the window truly fullscreen without decorations\n(such as for a video player), whereas maximized keeps decorations and just\nmakes it fill the available space. The automatically saved user previous\nmaximized state takes precedence."}, {Name: "Fullscreen", Doc: "Fullscreen is whether to make a window fullscreen on desktop platforms.\nIt is different from [Stage.Maximized] in that fullscreen makes\nthe window truly fullscreen without decorations (such as for a video player),\nwhereas maximized keeps decorations and just makes it fill the available space.\nNot to be confused with [Stage.FullWindow], which is for stages contained within\nanother system window. See [Scene.IsFullscreen] and [Scene.SetFullscreen] to\ncheck and update fullscreen state dynamically on desktop and web platforms\n([Stage.SetFullscreen] sets the initial state, whereas [Scene.SetFullscreen]\nsets the current state after the [Stage] is already running)."}, {Name: "UseMinSize", Doc: "UseMinSize uses a minimum size as a function of the total available size\nfor sizing new windows and dialogs. Otherwise, only the content size is used.\nThe saved window position and size takes precedence on multi-window platforms."}, {Name: "Resizable", Doc: "Resizable specifies whether a window on desktop platforms can\nbe resized by the user, and whether a non-full same-window dialog can\nbe resized by the user on any platform. It defaults to true."}, {Name: "Timeout", Doc: "Timeout, if greater than 0, results in a popup stages disappearing\nafter this timeout duration."}, {Name: "BackButton", Doc: "BackButton is whether to add a back button to the top bar that calls\n[Scene.Close] when clicked. If it is unset, is will be treated as true\non non-[system.Offscreen] platforms for [Stage.FullWindow] but not\n[Stage.NewWindow] [Stage]s that are not the first in the stack."}, {Name: "DisplayTitle", Doc: "DisplayTitle is whether to display the [Stage.Title] using a\n[Text] widget in the top bar. It is on by default for [DialogStage]s\nand off for all other stages."}, {Name: "Pos", Doc: "Pos is the default target position for the [Stage] to be placed within\nthe surrounding window or screen in raw pixels. For a new window on desktop\nplatforms, the automatically saved user previous window position takes precedence.\nFor dialogs, this position is the target center position, not the upper-left corner."}, {Name: "Main", Doc: "If a popup stage, this is the main stage that owns it (via its [Stage.popups]).\nIf a main stage, it points to itself."}, {Name: "popups", Doc: "For main stages, this is the stack of the popups within it\n(created specifically for the main stage).\nFor popups, this is the pointer to the popups within the\nmain stage managing it."}, {Name: "Mains", Doc: "For all stages, this is the main [Stages] that lives in a [renderWindow]\nand manages the main stages."}, {Name: "renderContext", Doc: "rendering context which has info about the RenderWindow onto which we render.\nThis should be used instead of the RenderWindow itself for all relevant\nrendering information. This is only available once a Stage is Run,\nand must always be checked for nil."}, {Name: "Sprites", Doc: "Sprites are named images that are rendered last overlaying everything else."}}})

// SetContext sets the [Stage.Context]:
// Context is a widget in another scene that requested this stage to be created
// and provides context.
func (t *Stage) SetContext(v Widget) *Stage { t.Context = v; return t }

// SetName sets the [Stage.Name]:
// Name is the name of the Stage, which is generally auto-set
// based on the [Scene.Name].
func (t *Stage) SetName(v string) *Stage { t.Name = v; return t }

// SetTitle sets the [Stage.Title]:
// Title is the title of the Stage, which is generally auto-set
// based on the [Body.Title]. It used for the title of [WindowStage]
// and [DialogStage] types, and for a [Text] title widget if
// [Stage.DisplayTitle] is true.
func (t *Stage) SetTitle(v string) *Stage { t.Title = v; return t }

// SetScreen sets the [Stage.Screen]:
// Screen specifies the screen number on which a new window is opened
// by default on desktop platforms. It defaults to -1, which indicates
// that the first window should open on screen 0 (the default primary
// screen) and any subsequent windows should open on the same screen as
// the currently active window. Regardless, the automatically saved last
// screen of a window with the same [Stage.Title] takes precedence if it exists;
// see the website documentation on window geometry saving for more information.
// Use [TheApp].ScreenByName("name").ScreenNumber to get the screen by name.
func (t *Stage) SetScreen(v int) *Stage { t.Screen = v; return t }

// SetScrim sets the [Stage.Scrim]:
// Scrim, if true, places a darkening scrim over other stages.
func (t *Stage) SetScrim(v bool) *Stage { t.Scrim = v; return t }

// SetClickOff sets the [Stage.ClickOff]:
// ClickOff, if true, dismisses the [Stage] if the user clicks anywhere
// off of the [Stage].
func (t *Stage) SetClickOff(v bool) *Stage { t.ClickOff = v; return t }

// SetNewWindow sets the [Stage.NewWindow]:
// NewWindow, if true, opens a [WindowStage] or [DialogStage] in its own
// separate operating system window ([renderWindow]). This is true by
// default for [WindowStage] on non-mobile platforms, otherwise false.
func (t *Stage) SetNewWindow(v bool) *Stage { t.NewWindow = v; return t }

// SetFullWindow sets the [Stage.FullWindow]:
// FullWindow, if [Stage.NewWindow] is false, makes [DialogStage]s and
// [WindowStage]s take up the entire window they are created in.
func (t *Stage) SetFullWindow(v bool) *Stage { t.FullWindow = v; return t }

// SetMaximized sets the [Stage.Maximized]:
// Maximized is whether to make a window take up the entire screen on desktop
// platforms by default. It is different from [Stage.Fullscreen] in that
// fullscreen makes the window truly fullscreen without decorations
// (such as for a video player), whereas maximized keeps decorations and just
// makes it fill the available space. The automatically saved user previous
// maximized state takes precedence.
func (t *Stage) SetMaximized(v bool) *Stage { t.Maximized = v; return t }

// SetFullscreen sets the [Stage.Fullscreen]:
// Fullscreen is whether to make a window fullscreen on desktop platforms.
// It is different from [Stage.Maximized] in that fullscreen makes
// the window truly fullscreen without decorations (such as for a video player),
// whereas maximized keeps decorations and just makes it fill the available space.
// Not to be confused with [Stage.FullWindow], which is for stages contained within
// another system window. See [Scene.IsFullscreen] and [Scene.SetFullscreen] to
// check and update fullscreen state dynamically on desktop and web platforms
// ([Stage.SetFullscreen] sets the initial state, whereas [Scene.SetFullscreen]
// sets the current state after the [Stage] is already running).
func (t *Stage) SetFullscreen(v bool) *Stage { t.Fullscreen = v; return t }

// SetUseMinSize sets the [Stage.UseMinSize]:
// UseMinSize uses a minimum size as a function of the total available size
// for sizing new windows and dialogs. Otherwise, only the content size is used.
// The saved window position and size takes precedence on multi-window platforms.
func (t *Stage) SetUseMinSize(v bool) *Stage { t.UseMinSize = v; return t }

// SetResizable sets the [Stage.Resizable]:
// Resizable specifies whether a window on desktop platforms can
// be resized by the user, and whether a non-full same-window dialog can
// be resized by the user on any platform. It defaults to true.
func (t *Stage) SetResizable(v bool) *Stage { t.Resizable = v; return t }

// SetTimeout sets the [Stage.Timeout]:
// Timeout, if greater than 0, results in a popup stages disappearing
// after this timeout duration.
func (t *Stage) SetTimeout(v time.Duration) *Stage { t.Timeout = v; return t }

// SetDisplayTitle sets the [Stage.DisplayTitle]:
// DisplayTitle is whether to display the [Stage.Title] using a
// [Text] widget in the top bar. It is on by default for [DialogStage]s
// and off for all other stages.
func (t *Stage) SetDisplayTitle(v bool) *Stage { t.DisplayTitle = v; return t }

// SetPos sets the [Stage.Pos]:
// Pos is the default target position for the [Stage] to be placed within
// the surrounding window or screen in raw pixels. For a new window on desktop
// platforms, the automatically saved user previous window position takes precedence.
// For dialogs, this position is the target center position, not the upper-left corner.
func (t *Stage) SetPos(v image.Point) *Stage { t.Pos = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.SVG", IDName: "svg", Doc: "SVG is a Widget that renders an [svg.SVG] object.\nIf it is not [states.ReadOnly], the user can pan and zoom the display.\nBy default, it is [states.ReadOnly].", Methods: []types.Method{{Name: "Open", Doc: "Open opens an XML-formatted SVG file", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename"}, Returns: []string{"error"}}, {Name: "SaveSVG", Doc: "SaveSVG saves the current SVG to an XML-encoded standard SVG file.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename"}, Returns: []string{"error"}}, {Name: "SaveImage", Doc: "SaveImage saves the current rendered SVG image to an image file,\nusing the filename extension to determine the file type.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename"}, Returns: []string{"error"}}}, Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "SVG", Doc: "SVG is the SVG drawing to display."}, {Name: "renderer", Doc: "image renderer"}, {Name: "image", Doc: "cached rendered image"}, {Name: "prevSize", Doc: "prevSize is the cached allocated size for the last rendered image."}}})

// NewSVG returns a new [SVG] with the given optional parent:
// SVG is a Widget that renders an [svg.SVG] object.
// If it is not [states.ReadOnly], the user can pan and zoom the display.
// By default, it is [states.ReadOnly].
func NewSVG(parent ...tree.Node) *SVG { return tree.New[SVG](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Switch", IDName: "switch", Doc: "Switch is a widget that can toggle between an on and off state.\nIt can be displayed as a switch, chip, checkbox, radio button,\nor segmented button.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the styling type of switch.\nIt must be set using [Switch.SetType]."}, {Name: "Text", Doc: "Text is the optional text of the switch."}, {Name: "IconOn", Doc: "IconOn is the icon to use for the on, checked state of the switch."}, {Name: "IconOff", Doc: "Iconoff is the icon to use for the off, unchecked state of the switch."}, {Name: "IconIndeterminate", Doc: "IconIndeterminate is the icon to use for the indeterminate (unknown) state."}}})

// NewSwitch returns a new [Switch] with the given optional parent:
// Switch is a widget that can toggle between an on and off state.
// It can be displayed as a switch, chip, checkbox, radio button,
// or segmented button.
func NewSwitch(parent ...tree.Node) *Switch { return tree.New[Switch](parent...) }

// SetText sets the [Switch.Text]:
// Text is the optional text of the switch.
func (t *Switch) SetText(v string) *Switch { t.Text = v; return t }

// SetIconOn sets the [Switch.IconOn]:
// IconOn is the icon to use for the on, checked state of the switch.
func (t *Switch) SetIconOn(v icons.Icon) *Switch { t.IconOn = v; return t }

// SetIconOff sets the [Switch.IconOff]:
// Iconoff is the icon to use for the off, unchecked state of the switch.
func (t *Switch) SetIconOff(v icons.Icon) *Switch { t.IconOff = v; return t }

// SetIconIndeterminate sets the [Switch.IconIndeterminate]:
// IconIndeterminate is the icon to use for the indeterminate (unknown) state.
func (t *Switch) SetIconIndeterminate(v icons.Icon) *Switch { t.IconIndeterminate = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Switches", IDName: "switches", Doc: "Switches is a widget for containing a set of [Switch]es.\nIt can optionally enforce mutual exclusivity (ie: radio buttons)\nthrough the [Switches.Mutex] field. It supports binding to\n[enums.Enum] and [enums.BitFlag] values with appropriate properties\nautomatically set.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the type of switches that will be made."}, {Name: "Items", Doc: "Items are the items displayed to the user."}, {Name: "Mutex", Doc: "Mutex is whether to make the items mutually exclusive\n(checking one turns off all the others)."}, {Name: "AllowNone", Doc: "AllowNone is whether to allow the user to deselect all items.\nIt is on by default."}, {Name: "selectedIndexes", Doc: "selectedIndexes are the indexes in [Switches.Items] of the currently\nselected switch items."}, {Name: "bitFlagValue", Doc: "bitFlagValue is the associated bit flag value if non-nil (for [Value])."}}})

// NewSwitches returns a new [Switches] with the given optional parent:
// Switches is a widget for containing a set of [Switch]es.
// It can optionally enforce mutual exclusivity (ie: radio buttons)
// through the [Switches.Mutex] field. It supports binding to
// [enums.Enum] and [enums.BitFlag] values with appropriate properties
// automatically set.
func NewSwitches(parent ...tree.Node) *Switches { return tree.New[Switches](parent...) }

// SetType sets the [Switches.Type]:
// Type is the type of switches that will be made.
func (t *Switches) SetType(v SwitchTypes) *Switches { t.Type = v; return t }

// SetItems sets the [Switches.Items]:
// Items are the items displayed to the user.
func (t *Switches) SetItems(v ...SwitchItem) *Switches { t.Items = v; return t }

// SetMutex sets the [Switches.Mutex]:
// Mutex is whether to make the items mutually exclusive
// (checking one turns off all the others).
func (t *Switches) SetMutex(v bool) *Switches { t.Mutex = v; return t }

// SetAllowNone sets the [Switches.AllowNone]:
// AllowNone is whether to allow the user to deselect all items.
// It is on by default.
func (t *Switches) SetAllowNone(v bool) *Switches { t.AllowNone = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Table", IDName: "table", Doc: "Table represents a slice of structs as a table, where the fields are\nthe columns and the elements are the rows. It is a full-featured editor with\nmultiple-selection, cut-and-paste, and drag-and-drop.\nUse [ListBase.BindSelect] to make the table designed for item selection.", Embeds: []types.Field{{Name: "ListBase"}}, Fields: []types.Field{{Name: "TableStyler", Doc: "TableStyler is an optional styling function for table items."}, {Name: "SelectedField", Doc: "SelectedField is the current selection field; initially select value in this field."}, {Name: "sortIndex", Doc: "sortIndex is the current sort index."}, {Name: "sortDescending", Doc: "sortDescending is whether the current sort order is descending."}, {Name: "visibleFields", Doc: "visibleFields are the visible fields."}, {Name: "numVisibleFields", Doc: "numVisibleFields is the number of visible fields."}, {Name: "headerWidths", Doc: "headerWidths has the number of characters in each header, per visibleFields."}, {Name: "colMaxWidths", Doc: "colMaxWidths records maximum width in chars of string type fields."}, {Name: "header"}}})

// NewTable returns a new [Table] with the given optional parent:
// Table represents a slice of structs as a table, where the fields are
// the columns and the elements are the rows. It is a full-featured editor with
// multiple-selection, cut-and-paste, and drag-and-drop.
// Use [ListBase.BindSelect] to make the table designed for item selection.
func NewTable(parent ...tree.Node) *Table { return tree.New[Table](parent...) }

// SetTableStyler sets the [Table.TableStyler]:
// TableStyler is an optional styling function for table items.
func (t *Table) SetTableStyler(v TableStyler) *Table { t.TableStyler = v; return t }

// SetSelectedField sets the [Table.SelectedField]:
// SelectedField is the current selection field; initially select value in this field.
func (t *Table) SetSelectedField(v string) *Table { t.SelectedField = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Tabs", IDName: "tabs", Doc: "Tabs divide widgets into logical groups and give users the ability\nto freely navigate between them using tab buttons.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the styling type of the tabs. If it is changed after\nthe tabs are first configured, Update needs to be called on\nthe tabs."}, {Name: "NewTabButton", Doc: "NewTabButton is whether to show a new tab button at the end of the list of tabs."}, {Name: "maxChars", Doc: "maxChars is the maximum number of characters to include in the tab text.\nIt elides text that are longer than that."}, {Name: "CloseIcon", Doc: "CloseIcon is the icon used for tab close buttons.\nIf it is \"\" or [icons.None], the tab is not closeable.\nThe default value is [icons.Close].\nOnly [FunctionalTabs] can be closed; all other types of\ntabs will not render a close button and can not be closed."}, {Name: "mu", Doc: "mu is a mutex protecting updates to tabs. Tabs can be driven\nprogrammatically and via user input so need extra protection."}, {Name: "tabs"}, {Name: "frame"}}})

// NewTabs returns a new [Tabs] with the given optional parent:
// Tabs divide widgets into logical groups and give users the ability
// to freely navigate between them using tab buttons.
func NewTabs(parent ...tree.Node) *Tabs { return tree.New[Tabs](parent...) }

// SetType sets the [Tabs.Type]:
// Type is the styling type of the tabs. If it is changed after
// the tabs are first configured, Update needs to be called on
// the tabs.
func (t *Tabs) SetType(v TabTypes) *Tabs { t.Type = v; return t }

// SetNewTabButton sets the [Tabs.NewTabButton]:
// NewTabButton is whether to show a new tab button at the end of the list of tabs.
func (t *Tabs) SetNewTabButton(v bool) *Tabs { t.NewTabButton = v; return t }

// SetCloseIcon sets the [Tabs.CloseIcon]:
// CloseIcon is the icon used for tab close buttons.
// If it is "" or [icons.None], the tab is not closeable.
// The default value is [icons.Close].
// Only [FunctionalTabs] can be closed; all other types of
// tabs will not render a close button and can not be closed.
func (t *Tabs) SetCloseIcon(v icons.Icon) *Tabs { t.CloseIcon = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Tab", IDName: "tab", Doc: "Tab is a tab button that contains one or more of a label, an icon,\nand a close icon. Tabs should be made using the [Tabs.NewTab] function.", Directives: []types.Directive{{Tool: "core", Directive: "no-new"}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the styling type of the tab. This property\nmust be set on the parent [Tabs] for it to work correctly."}, {Name: "Text", Doc: "Text is the text for the tab. If it is blank, no text is shown.\nText is never shown for [NavigationRail] tabs."}, {Name: "Icon", Doc: "Icon is the icon for the tab.\nIf it is \"\" or [icons.None], no icon is shown."}, {Name: "CloseIcon", Doc: "CloseIcon is the icon used as a close button for the tab.\nIf it is \"\" or [icons.None], the tab is not closeable.\nThe default value is [icons.Close].\nOnly [FunctionalTabs] can be closed; all other types of\ntabs will not render a close button and can not be closed."}, {Name: "maxChars", Doc: "maxChars is the maximum number of characters to include in tab text.\nIt elides text that is longer than that."}}})

// SetType sets the [Tab.Type]:
// Type is the styling type of the tab. This property
// must be set on the parent [Tabs] for it to work correctly.
func (t *Tab) SetType(v TabTypes) *Tab { t.Type = v; return t }

// SetText sets the [Tab.Text]:
// Text is the text for the tab. If it is blank, no text is shown.
// Text is never shown for [NavigationRail] tabs.
func (t *Tab) SetText(v string) *Tab { t.Text = v; return t }

// SetIcon sets the [Tab.Icon]:
// Icon is the icon for the tab.
// If it is "" or [icons.None], no icon is shown.
func (t *Tab) SetIcon(v icons.Icon) *Tab { t.Icon = v; return t }

// SetCloseIcon sets the [Tab.CloseIcon]:
// CloseIcon is the icon used as a close button for the tab.
// If it is "" or [icons.None], the tab is not closeable.
// The default value is [icons.Close].
// Only [FunctionalTabs] can be closed; all other types of
// tabs will not render a close button and can not be closed.
func (t *Tab) SetCloseIcon(v icons.Icon) *Tab { t.CloseIcon = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Text", IDName: "text", Doc: "Text is a widget for rendering text. It supports full HTML styling,\nincluding links. By default, text wraps and collapses whitespace, although\nyou can change this by changing [styles.Text.WhiteSpace].", Methods: []types.Method{{Name: "copy", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "Text", Doc: "Text is the text to display."}, {Name: "Type", Doc: "Type is the styling type of text to use.\nIt defaults to [TextBodyLarge]."}, {Name: "Links", Doc: "Links is the list of links in the text."}, {Name: "richText", Doc: "richText is the conversion of the HTML text source."}, {Name: "paintText", Doc: "paintText is the [shaped.Lines] for the text."}, {Name: "normalCursor", Doc: "normalCursor is the cached cursor to display when there\nis no link being hovered."}, {Name: "selectRange", Doc: "selectRange is the selected range, in _runes_, which must be applied"}}})

// NewText returns a new [Text] with the given optional parent:
// Text is a widget for rendering text. It supports full HTML styling,
// including links. By default, text wraps and collapses whitespace, although
// you can change this by changing [styles.Text.WhiteSpace].
func NewText(parent ...tree.Node) *Text { return tree.New[Text](parent...) }

// SetText sets the [Text.Text]:
// Text is the text to display.
func (t *Text) SetText(v string) *Text { t.Text = v; return t }

// SetType sets the [Text.Type]:
// Type is the styling type of text to use.
// It defaults to [TextBodyLarge].
func (t *Text) SetType(v TextTypes) *Text { t.Type = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.TextField", IDName: "text-field", Doc: "TextField is a widget for editing a line of text.\n\nWith the default [styles.WhiteSpaceNormal] setting,\ntext will wrap onto multiple lines as needed. You can\ncall [styles.Style.SetTextWrap](false) to force everything\nto be rendered on a single line. With multi-line wrapped text,\nthe text is still treated as a single contiguous line of wrapped text.", Directives: []types.Directive{{Tool: "core", Directive: "embedder"}}, Methods: []types.Method{{Name: "cut", Doc: "cut cuts any selected text and adds it to the clipboard.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "copy", Doc: "copy copies any selected text to the clipboard.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "paste", Doc: "paste inserts text from the clipboard at current cursor position; if\ncursor is within a current selection, that selection is replaced.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Type", Doc: "Type is the styling type of the text field."}, {Name: "Placeholder", Doc: "Placeholder is the text that is displayed\nwhen the text field is empty."}, {Name: "Validator", Doc: "Validator is a function used to validate the input\nof the text field. If it returns a non-nil error,\nthen an error color, icon, and tooltip will be displayed."}, {Name: "LeadingIcon", Doc: "LeadingIcon, if specified, indicates to add a button\nat the start of the text field with this icon.\nSee [TextField.SetLeadingIcon]."}, {Name: "LeadingIconOnClick", Doc: "LeadingIconOnClick, if specified, is the function to call when\nthe LeadingIcon is clicked. If this is nil, the leading icon\nwill not be interactive. See [TextField.SetLeadingIcon]."}, {Name: "TrailingIcon", Doc: "TrailingIcon, if specified, indicates to add a button\nat the end of the text field with this icon.\nSee [TextField.SetTrailingIcon]."}, {Name: "TrailingIconOnClick", Doc: "TrailingIconOnClick, if specified, is the function to call when\nthe TrailingIcon is clicked. If this is nil, the trailing icon\nwill not be interactive. See [TextField.SetTrailingIcon]."}, {Name: "NoEcho", Doc: "NoEcho is whether replace displayed characters with bullets\nto conceal text (for example, for a password input). Also\nsee [TextField.SetTypePassword]."}, {Name: "CursorWidth", Doc: "CursorWidth is the width of the text field cursor.\nIt should be set in a Styler like all other style properties.\nBy default, it is 1dp."}, {Name: "CursorColor", Doc: "CursorColor is the color used for the text field cursor (caret).\nIt should be set in a Styler like all other style properties.\nBy default, it is [colors.Scheme.Primary.Base]."}, {Name: "PlaceholderColor", Doc: "PlaceholderColor is the color used for the [TextField.Placeholder] text.\nIt should be set in a Styler like all other style properties.\nBy default, it is [colors.Scheme.OnSurfaceVariant]."}, {Name: "complete", Doc: "complete contains functions and data for text field completion.\nIt must be set using [TextField.SetCompleter]."}, {Name: "text", Doc: "text is the last saved value of the text string being edited."}, {Name: "edited", Doc: "edited is whether the text has been edited relative to the original."}, {Name: "editText", Doc: "editText is the live text string being edited, with the latest modifications."}, {Name: "error", Doc: "error is the current validation error of the text field."}, {Name: "effPos", Doc: "effPos is the effective position with any leading icon space added."}, {Name: "effSize", Doc: "effSize is the effective size, subtracting any leading and trailing icon space."}, {Name: "dispRange", Doc: "dispRange is the range of visible text, for scrolling text case (non-wordwrap)."}, {Name: "cursorPos", Doc: "cursorPos is the current cursor position as rune index into string."}, {Name: "cursorLine", Doc: "cursorLine is the current cursor line position, for word wrap case."}, {Name: "charWidth", Doc: "charWidth is the approximate number of chars that can be\ndisplayed at any time, which is computed from the font size."}, {Name: "selectRange", Doc: "selectRange is the selected range."}, {Name: "selectInit", Doc: "selectInit is the initial selection position (where it started)."}, {Name: "selectMode", Doc: "selectMode is whether to select text as the cursor moves."}, {Name: "selectModeShift", Doc: "selectModeShift is whether selectmode was turned on because of the shift key."}, {Name: "renderAll", Doc: "renderAll is the render version of entire text, for sizing."}, {Name: "renderVisible", Doc: "renderVisible is the render version of just the visible text in dispRange."}, {Name: "renderedRange", Doc: "renderedRange is the dispRange last rendered."}, {Name: "numLines", Doc: "number of lines from last render update, for word-wrap version"}, {Name: "lineHeight", Doc: "lineHeight is the line height cached during styling."}, {Name: "blinkOn", Doc: "blinkOn oscillates between on and off for blinking."}, {Name: "cursorMu", Doc: "cursorMu is the mutex for updating the cursor between blinker and field."}, {Name: "undos", Doc: "undos is the undo manager for the text field."}, {Name: "leadingIconButton"}, {Name: "trailingIconButton"}}})

// NewTextField returns a new [TextField] with the given optional parent:
// TextField is a widget for editing a line of text.
//
// With the default [styles.WhiteSpaceNormal] setting,
// text will wrap onto multiple lines as needed. You can
// call [styles.Style.SetTextWrap](false) to force everything
// to be rendered on a single line. With multi-line wrapped text,
// the text is still treated as a single contiguous line of wrapped text.
func NewTextField(parent ...tree.Node) *TextField { return tree.New[TextField](parent...) }

// TextFieldEmbedder is an interface that all types that embed TextField satisfy
type TextFieldEmbedder interface {
        AsTextField() *TextField
}

// AsTextField returns the given value as a value of type TextField if the type
// of the given value embeds TextField, or nil otherwise
func AsTextField(n tree.Node) *TextField {
        if t, ok := n.(TextFieldEmbedder); ok {
                return t.AsTextField()
        }
        return nil
}

// AsTextField satisfies the [TextFieldEmbedder] interface
func (t *TextField) AsTextField() *TextField { return t }

// SetType sets the [TextField.Type]:
// Type is the styling type of the text field.
func (t *TextField) SetType(v TextFieldTypes) *TextField { t.Type = v; return t }

// SetPlaceholder sets the [TextField.Placeholder]:
// Placeholder is the text that is displayed
// when the text field is empty.
func (t *TextField) SetPlaceholder(v string) *TextField { t.Placeholder = v; return t }

// SetValidator sets the [TextField.Validator]:
// Validator is a function used to validate the input
// of the text field. If it returns a non-nil error,
// then an error color, icon, and tooltip will be displayed.
func (t *TextField) SetValidator(v func() error) *TextField { t.Validator = v; return t }

// SetLeadingIconOnClick sets the [TextField.LeadingIconOnClick]:
// LeadingIconOnClick, if specified, is the function to call when
// the LeadingIcon is clicked. If this is nil, the leading icon
// will not be interactive. See [TextField.SetLeadingIcon].
func (t *TextField) SetLeadingIconOnClick(v func(e events.Event)) *TextField {
        t.LeadingIconOnClick = v
        return t
}

// SetTrailingIconOnClick sets the [TextField.TrailingIconOnClick]:
// TrailingIconOnClick, if specified, is the function to call when
// the TrailingIcon is clicked. If this is nil, the trailing icon
// will not be interactive. See [TextField.SetTrailingIcon].
func (t *TextField) SetTrailingIconOnClick(v func(e events.Event)) *TextField {
        t.TrailingIconOnClick = v
        return t
}

// SetNoEcho sets the [TextField.NoEcho]:
// NoEcho is whether replace displayed characters with bullets
// to conceal text (for example, for a password input). Also
// see [TextField.SetTypePassword].
func (t *TextField) SetNoEcho(v bool) *TextField { t.NoEcho = v; return t }

// SetCursorWidth sets the [TextField.CursorWidth]:
// CursorWidth is the width of the text field cursor.
// It should be set in a Styler like all other style properties.
// By default, it is 1dp.
func (t *TextField) SetCursorWidth(v units.Value) *TextField { t.CursorWidth = v; return t }

// SetCursorColor sets the [TextField.CursorColor]:
// CursorColor is the color used for the text field cursor (caret).
// It should be set in a Styler like all other style properties.
// By default, it is [colors.Scheme.Primary.Base].
func (t *TextField) SetCursorColor(v image.Image) *TextField { t.CursorColor = v; return t }

// SetPlaceholderColor sets the [TextField.PlaceholderColor]:
// PlaceholderColor is the color used for the [TextField.Placeholder] text.
// It should be set in a Styler like all other style properties.
// By default, it is [colors.Scheme.OnSurfaceVariant].
func (t *TextField) SetPlaceholderColor(v image.Image) *TextField { t.PlaceholderColor = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.TimePicker", IDName: "time-picker", Doc: "TimePicker is a widget for picking a time.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Time", Doc: "Time is the time that we are viewing."}, {Name: "hour", Doc: "the raw input hour"}, {Name: "pm", Doc: "whether we are in pm mode (so we have to add 12h to everything)"}}})

// NewTimePicker returns a new [TimePicker] with the given optional parent:
// TimePicker is a widget for picking a time.
func NewTimePicker(parent ...tree.Node) *TimePicker { return tree.New[TimePicker](parent...) }

// SetTime sets the [TimePicker.Time]:
// Time is the time that we are viewing.
func (t *TimePicker) SetTime(v time.Time) *TimePicker { t.Time = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.DatePicker", IDName: "date-picker", Doc: "DatePicker is a widget for picking a date.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Time", Doc: "Time is the time that we are viewing."}, {Name: "getTime", Doc: "getTime converts the given calendar grid index to its corresponding time.\nWe must store this logic in a closure so that it can always be recomputed\ncorrectly in the inner closures of the grid maker; otherwise, the local\nvariables needed would be stale."}, {Name: "som", Doc: "som is the start of the month (must be set here to avoid stale variables)."}}})

// NewDatePicker returns a new [DatePicker] with the given optional parent:
// DatePicker is a widget for picking a date.
func NewDatePicker(parent ...tree.Node) *DatePicker { return tree.New[DatePicker](parent...) }

// SetTime sets the [DatePicker.Time]:
// Time is the time that we are viewing.
func (t *DatePicker) SetTime(v time.Time) *DatePicker { t.Time = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.TimeInput", IDName: "time-input", Doc: "TimeInput presents two text fields for editing a date and time,\nboth of which can pull up corresponding picker dialogs.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Time"}, {Name: "DisplayDate", Doc: "DisplayDate is whether the date input is displayed (default true)."}, {Name: "DisplayTime", Doc: "DisplayTime is whether the time input is displayed (default true)."}}})

// NewTimeInput returns a new [TimeInput] with the given optional parent:
// TimeInput presents two text fields for editing a date and time,
// both of which can pull up corresponding picker dialogs.
func NewTimeInput(parent ...tree.Node) *TimeInput { return tree.New[TimeInput](parent...) }

// SetTime sets the [TimeInput.Time]
func (t *TimeInput) SetTime(v time.Time) *TimeInput { t.Time = v; return t }

// SetDisplayDate sets the [TimeInput.DisplayDate]:
// DisplayDate is whether the date input is displayed (default true).
func (t *TimeInput) SetDisplayDate(v bool) *TimeInput { t.DisplayDate = v; return t }

// SetDisplayTime sets the [TimeInput.DisplayTime]:
// DisplayTime is whether the time input is displayed (default true).
func (t *TimeInput) SetDisplayTime(v bool) *TimeInput { t.DisplayTime = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.DurationInput", IDName: "duration-input", Doc: "DurationInput represents a [time.Duration] value with a spinner and unit chooser.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Duration"}, {Name: "Unit", Doc: "Unit is the unit of time."}}})

// NewDurationInput returns a new [DurationInput] with the given optional parent:
// DurationInput represents a [time.Duration] value with a spinner and unit chooser.
func NewDurationInput(parent ...tree.Node) *DurationInput { return tree.New[DurationInput](parent...) }

// SetDuration sets the [DurationInput.Duration]
func (t *DurationInput) SetDuration(v time.Duration) *DurationInput { t.Duration = v; return t }

// SetUnit sets the [DurationInput.Unit]:
// Unit is the unit of time.
func (t *DurationInput) SetUnit(v string) *DurationInput { t.Unit = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Toolbar", IDName: "toolbar", Doc: "Toolbar is a [Frame] that is useful for holding [Button]s that do things.\nIt automatically moves items that do not fit into an overflow menu, and\nmanages additional items that are always placed onto this overflow menu.\nToolbars are frequently added in [Body.AddTopBar]. All toolbars use the\n[WidgetBase.Maker] system, so you cannot directly add widgets; see\nhttps://cogentcore.org/core/toolbar.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "OverflowMenus", Doc: "OverflowMenus are functions for configuring the overflow menu of the\ntoolbar. You can use [Toolbar.AddOverflowMenu] to add them.\nThese are processed in reverse order (last in, first called)\nso that the default items are added last."}, {Name: "allItemsPlan", Doc: "allItemsPlan has all the items, during layout sizing"}, {Name: "overflowItems", Doc: "overflowItems are items moved from the main toolbar that will be\nshown in the overflow menu."}, {Name: "overflowButton", Doc: "overflowButton is the widget to pull up the overflow menu."}}})

// NewToolbar returns a new [Toolbar] with the given optional parent:
// Toolbar is a [Frame] that is useful for holding [Button]s that do things.
// It automatically moves items that do not fit into an overflow menu, and
// manages additional items that are always placed onto this overflow menu.
// Toolbars are frequently added in [Body.AddTopBar]. All toolbars use the
// [WidgetBase.Maker] system, so you cannot directly add widgets; see
// https://cogentcore.org/core/toolbar.
func NewToolbar(parent ...tree.Node) *Toolbar { return tree.New[Toolbar](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Treer", IDName: "treer", Doc: "Treer is an interface for [Tree] types\nproviding access to the base [Tree] and\noverridable method hooks for actions taken on the [Tree],\nincluding OnOpen, OnClose, etc.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Methods: []types.Method{{Name: "AsCoreTree", Doc: "AsTree returns the base [Tree] for this node.", Returns: []string{"Tree"}}, {Name: "CanOpen", Doc: "CanOpen returns true if the node is able to open.\nBy default it checks HasChildren(), but could check other properties\nto perform lazy building of the tree.", Returns: []string{"bool"}}, {Name: "OnOpen", Doc: "OnOpen is called when a node is toggled open.\nThe base version does nothing."}, {Name: "OnClose", Doc: "OnClose is called when a node is toggled closed.\nThe base version does nothing."}, {Name: "MimeData", Args: []string{"md"}}, {Name: "Cut"}, {Name: "Copy"}, {Name: "Paste"}, {Name: "DragDrop", Args: []string{"e"}}, {Name: "DropDeleteSource", Args: []string{"e"}}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.Tree", IDName: "tree", Doc: "Tree provides a graphical representation of a tree structure,\nproviding full navigation and manipulation abilities.\n\nIt does not handle layout by itself, so if you want it to scroll\nseparately from the rest of the surrounding context, you must\nplace it in a [Frame].\n\nIf the [Tree.SyncNode] field is non-nil, typically via the\n[Tree.SyncTree] method, then the Tree mirrors another\ntree structure, and tree editing functions apply to\nthe source tree first, and then to the Tree by sync.\n\nOtherwise, data can be directly encoded in a Tree\nderived type, to represent any kind of tree structure\nand associated data.\n\nStandard [events.Event]s are sent to any listeners, including\n[events.Select], [events.Change], and [events.DoubleClick].\nThe selected nodes are in the root [Tree.SelectedNodes] list;\nselect events are sent to both selected nodes and the root node.\nSee [Tree.IsRootSelected] to check whether a select event on the root\nnode corresponds to the root node or another node.", Methods: []types.Method{{Name: "OpenAll", Doc: "OpenAll opens the node and all of its sub-nodes.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "CloseAll", Doc: "CloseAll closes the node and all of its sub-nodes.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "Copy", Doc: "Copy copies the tree to the clipboard.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "Cut", Doc: "Cut copies to [system.Clipboard] and deletes selected items.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "Paste", Doc: "Paste pastes clipboard at given node.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "InsertAfter", Doc: "InsertAfter inserts a new node in the tree\nafter this node, at the same (sibling) level,\nprompting for the type of node to insert.\nIf SyncNode is set, operates on Sync Tree.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "InsertBefore", Doc: "InsertBefore inserts a new node in the tree\nbefore this node, at the same (sibling) level,\nprompting for the type of node to insert\nIf SyncNode is set, operates on Sync Tree.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "AddChildNode", Doc: "AddChildNode adds a new child node to this one in the tree,\nprompting the user for the type of node to add\nIf SyncNode is set, operates on Sync Tree.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "DeleteNode", Doc: "DeleteNode deletes the tree node or sync node corresponding\nto this view node in the sync tree.\nIf SyncNode is set, operates on Sync Tree.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "Duplicate", Doc: "Duplicate duplicates the sync node corresponding to this view node in\nthe tree, and inserts the duplicate after this node (as a new sibling).\nIf SyncNode is set, operates on Sync Tree.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "editNode", Doc: "editNode pulls up a [Form] dialog for the node.\nIf SyncNode is set, operates on Sync Tree.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "inspectNode", Doc: "inspectNode pulls up a new Inspector window on the node.\nIf SyncNode is set, operates on Sync Tree.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "WidgetBase"}}, Fields: []types.Field{{Name: "SyncNode", Doc: "SyncNode, if non-nil, is the [tree.Node] that this widget is\nviewing in the tree (the source). It should be set using\n[Tree.SyncTree]."}, {Name: "Text", Doc: "Text is the text to display for the tree item label, which automatically\ndefaults to the [tree.Node.Name] of the tree node. It has no effect\nif [Tree.SyncNode] is non-nil."}, {Name: "Icon", Doc: "Icon is an optional icon displayed to the the left of the text label."}, {Name: "IconOpen", Doc: "IconOpen is the icon to use for an open (expanded) branch;\nit defaults to [icons.KeyboardArrowDown]."}, {Name: "IconClosed", Doc: "IconClosed is the icon to use for a closed (collapsed) branch;\nit defaults to [icons.KeyboardArrowRight]."}, {Name: "IconLeaf", Doc: "IconLeaf is the icon to use for a terminal node branch that has no children;\nit defaults to [icons.Blank]."}, {Name: "TreeInit", Doc: "TreeInit is a function that can be set on the root node that is called\nwith each child tree node when it is initialized. It is only\ncalled with the root node itself in [Tree.SetTreeInit], so you\nshould typically call that instead of setting this directly."}, {Name: "Indent", Doc: "Indent is the amount to indent children relative to this node.\nIt should be set in a Styler like all other style properties."}, {Name: "OpenDepth", Doc: "OpenDepth is the depth for nodes be initialized as open (default 4).\nNodes beyond this depth will be initialized as closed."}, {Name: "Closed", Doc: "Closed is whether this tree node is currently toggled closed\n(children not visible)."}, {Name: "SelectMode", Doc: "SelectMode, when set on the root node, determines whether keyboard movements should update selection."}, {Name: "viewIndex", Doc: "linear index of this node within the entire tree.\nupdated on full rebuilds and may sometimes be off,\nbut close enough for expected uses"}, {Name: "widgetSize", Doc: "size of just this node widget.\nour alloc includes all of our children, but we only draw us."}, {Name: "Root", Doc: "Root is the cached root of the tree. It is automatically set."}, {Name: "SelectedNodes", Doc: "SelectedNodes holds the currently selected nodes.\nIt is only set on the root node. See [Tree.GetSelectedNodes]\nfor a version that also works on non-root nodes."}, {Name: "actStateLayer", Doc: "actStateLayer is the actual state layer of the tree, which\nshould be used when rendering it and its parts (but not its children).\nthe reason that it exists is so that the children of the tree\n(other trees) do not inherit its stateful background color, as\nthat does not look good."}, {Name: "inOpen", Doc: "inOpen is set in the Open method to prevent recursive opening for lazy-open nodes."}, {Name: "Branch", Doc: "Branch is the branch widget that is used to open and close the tree node."}}})

// NewTree returns a new [Tree] with the given optional parent:
// Tree provides a graphical representation of a tree structure,
// providing full navigation and manipulation abilities.
//
// It does not handle layout by itself, so if you want it to scroll
// separately from the rest of the surrounding context, you must
// place it in a [Frame].
//
// If the [Tree.SyncNode] field is non-nil, typically via the
// [Tree.SyncTree] method, then the Tree mirrors another
// tree structure, and tree editing functions apply to
// the source tree first, and then to the Tree by sync.
//
// Otherwise, data can be directly encoded in a Tree
// derived type, to represent any kind of tree structure
// and associated data.
//
// Standard [events.Event]s are sent to any listeners, including
// [events.Select], [events.Change], and [events.DoubleClick].
// The selected nodes are in the root [Tree.SelectedNodes] list;
// select events are sent to both selected nodes and the root node.
// See [Tree.IsRootSelected] to check whether a select event on the root
// node corresponds to the root node or another node.
func NewTree(parent ...tree.Node) *Tree { return tree.New[Tree](parent...) }

// SetText sets the [Tree.Text]:
// Text is the text to display for the tree item label, which automatically
// defaults to the [tree.Node.Name] of the tree node. It has no effect
// if [Tree.SyncNode] is non-nil.
func (t *Tree) SetText(v string) *Tree { t.Text = v; return t }

// SetIcon sets the [Tree.Icon]:
// Icon is an optional icon displayed to the the left of the text label.
func (t *Tree) SetIcon(v icons.Icon) *Tree { t.Icon = v; return t }

// SetIconOpen sets the [Tree.IconOpen]:
// IconOpen is the icon to use for an open (expanded) branch;
// it defaults to [icons.KeyboardArrowDown].
func (t *Tree) SetIconOpen(v icons.Icon) *Tree { t.IconOpen = v; return t }

// SetIconClosed sets the [Tree.IconClosed]:
// IconClosed is the icon to use for a closed (collapsed) branch;
// it defaults to [icons.KeyboardArrowRight].
func (t *Tree) SetIconClosed(v icons.Icon) *Tree { t.IconClosed = v; return t }

// SetIconLeaf sets the [Tree.IconLeaf]:
// IconLeaf is the icon to use for a terminal node branch that has no children;
// it defaults to [icons.Blank].
func (t *Tree) SetIconLeaf(v icons.Icon) *Tree { t.IconLeaf = v; return t }

// SetIndent sets the [Tree.Indent]:
// Indent is the amount to indent children relative to this node.
// It should be set in a Styler like all other style properties.
func (t *Tree) SetIndent(v units.Value) *Tree { t.Indent = v; return t }

// SetOpenDepth sets the [Tree.OpenDepth]:
// OpenDepth is the depth for nodes be initialized as open (default 4).
// Nodes beyond this depth will be initialized as closed.
func (t *Tree) SetOpenDepth(v int) *Tree { t.OpenDepth = v; return t }

// SetClosed sets the [Tree.Closed]:
// Closed is whether this tree node is currently toggled closed
// (children not visible).
func (t *Tree) SetClosed(v bool) *Tree { t.Closed = v; return t }

// SetSelectMode sets the [Tree.SelectMode]:
// SelectMode, when set on the root node, determines whether keyboard movements should update selection.
func (t *Tree) SetSelectMode(v bool) *Tree { t.SelectMode = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.ListButton", IDName: "list-button", Doc: "ListButton represents a slice or array value with a button that opens a [List].", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "Slice"}}})

// NewListButton returns a new [ListButton] with the given optional parent:
// ListButton represents a slice or array value with a button that opens a [List].
func NewListButton(parent ...tree.Node) *ListButton { return tree.New[ListButton](parent...) }

// SetSlice sets the [ListButton.Slice]
func (t *ListButton) SetSlice(v any) *ListButton { t.Slice = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.FormButton", IDName: "form-button", Doc: "FormButton represents a struct value with a button that opens a [Form].", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "Struct"}}})

// NewFormButton returns a new [FormButton] with the given optional parent:
// FormButton represents a struct value with a button that opens a [Form].
func NewFormButton(parent ...tree.Node) *FormButton { return tree.New[FormButton](parent...) }

// SetStruct sets the [FormButton.Struct]
func (t *FormButton) SetStruct(v any) *FormButton { t.Struct = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.KeyedListButton", IDName: "keyed-list-button", Doc: "KeyedListButton represents a map value with a button that opens a [KeyedList].", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "Map"}}})

// NewKeyedListButton returns a new [KeyedListButton] with the given optional parent:
// KeyedListButton represents a map value with a button that opens a [KeyedList].
func NewKeyedListButton(parent ...tree.Node) *KeyedListButton {
        return tree.New[KeyedListButton](parent...)
}

// SetMap sets the [KeyedListButton.Map]
func (t *KeyedListButton) SetMap(v any) *KeyedListButton { t.Map = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.TreeButton", IDName: "tree-button", Doc: "TreeButton represents a [tree.Node] value with a button.", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "Tree"}}})

// NewTreeButton returns a new [TreeButton] with the given optional parent:
// TreeButton represents a [tree.Node] value with a button.
func NewTreeButton(parent ...tree.Node) *TreeButton { return tree.New[TreeButton](parent...) }

// SetTree sets the [TreeButton.Tree]
func (t *TreeButton) SetTree(v tree.Node) *TreeButton { t.Tree = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.TypeChooser", IDName: "type-chooser", Doc: "TypeChooser represents a [types.Type] value with a chooser.", Embeds: []types.Field{{Name: "Chooser"}}})

// NewTypeChooser returns a new [TypeChooser] with the given optional parent:
// TypeChooser represents a [types.Type] value with a chooser.
func NewTypeChooser(parent ...tree.Node) *TypeChooser { return tree.New[TypeChooser](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.IconButton", IDName: "icon-button", Doc: "IconButton represents an [icons.Icon] with a [Button] that opens\na dialog for selecting the icon.", Embeds: []types.Field{{Name: "Button"}}})

// NewIconButton returns a new [IconButton] with the given optional parent:
// IconButton represents an [icons.Icon] with a [Button] that opens
// a dialog for selecting the icon.
func NewIconButton(parent ...tree.Node) *IconButton { return tree.New[IconButton](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.FontButton", IDName: "font-button", Doc: "FontButton represents a [FontName] with a [Button] that opens\na dialog for selecting the font family.", Embeds: []types.Field{{Name: "Button"}}})

// NewFontButton returns a new [FontButton] with the given optional parent:
// FontButton represents a [FontName] with a [Button] that opens
// a dialog for selecting the font family.
func NewFontButton(parent ...tree.Node) *FontButton { return tree.New[FontButton](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.HighlightingButton", IDName: "highlighting-button", Doc: "HighlightingButton represents a [HighlightingName] with a button.", Embeds: []types.Field{{Name: "Button"}}, Fields: []types.Field{{Name: "HighlightingName"}}})

// NewHighlightingButton returns a new [HighlightingButton] with the given optional parent:
// HighlightingButton represents a [HighlightingName] with a button.
func NewHighlightingButton(parent ...tree.Node) *HighlightingButton {
        return tree.New[HighlightingButton](parent...)
}

// SetHighlightingName sets the [HighlightingButton.HighlightingName]
func (t *HighlightingButton) SetHighlightingName(v string) *HighlightingButton {
        t.HighlightingName = v
        return t
}

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/core.WidgetBase", IDName: "widget-base", Doc: "WidgetBase implements the [Widget] interface and provides the core functionality\nof a widget. You must use WidgetBase as an embedded struct in all higher-level\nwidget types. It renders the standard box model, but does not layout or render\nany children; see [Frame] for that.", Methods: []types.Method{{Name: "Update", Doc: "Update updates the widget and all of its children by running [WidgetBase.UpdateWidget]\nand [WidgetBase.Style] on each one, and triggering a new layout pass with\n[WidgetBase.NeedsLayout]. It is the main way that end users should trigger widget\nupdates, and it is guaranteed to fully update a widget to the current state.\nFor example, it should be called after making any changes to the core properties\nof a widget, such as the text of [Text], the icon of a [Button], or the slice\nof a [Table].\n\nUpdate differs from [WidgetBase.UpdateWidget] in that it updates the widget and all\nof its children down the tree, whereas [WidgetBase.UpdateWidget] only updates the widget\nitself. Also, Update also calls [WidgetBase.Style] and [WidgetBase.NeedsLayout],\nwhereas [WidgetBase.UpdateWidget] does not. End-user code should typically call Update,\nnot [WidgetBase.UpdateWidget].\n\nIf you are calling this in a separate goroutine outside of the main\nconfiguration, rendering, and event handling structure, you need to\ncall [WidgetBase.AsyncLock] and [WidgetBase.AsyncUnlock] before and\nafter this, respectively.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Tooltip", Doc: "Tooltip is the text for the tooltip for this widget,\nwhich can use HTML formatting."}, {Name: "Parts", Doc: "Parts are a separate tree of sub-widgets that can be used to store\northogonal parts of a widget when necessary to separate them from children.\nFor example, [Tree]s use parts to separate their internal parts from\nthe other child tree nodes. Composite widgets like buttons should\nNOT use parts to store their components; parts should only be used when\nabsolutely necessary. Use [WidgetBase.newParts] to make the parts."}, {Name: "Geom", Doc: "Geom has the full layout geometry for size and position of this widget."}, {Name: "OverrideStyle", Doc: "OverrideStyle, if true, indicates override the computed styles of the widget\nand allow directly editing [WidgetBase.Styles]. It is typically only set in\nthe inspector."}, {Name: "Styles", Doc: "Styles are styling settings for this widget. They are set by\n[WidgetBase.Stylers] in [WidgetBase.Style]."}, {Name: "Stylers", Doc: "Stylers is a tiered set of functions that are called in sequential\nascending order (so the last added styler is called last and\nthus can override all other stylers) to style the element.\nThese should be set using the [WidgetBase.Styler], [WidgetBase.FirstStyler],\nand [WidgetBase.FinalStyler] functions."}, {Name: "Listeners", Doc: "Listeners is a tiered set of event listener functions for processing events on this widget.\nThey are called in sequential descending order (so the last added listener\nis called first). They should be added using the [WidgetBase.On], [WidgetBase.OnFirst],\nand [WidgetBase.OnFinal] functions, or any of the various On{EventType} helper functions."}, {Name: "ContextMenus", Doc: "ContextMenus is a slice of menu functions to call to construct\nthe widget's context menu on an [events.ContextMenu]. The\nfunctions are called in reverse order such that the elements\nadded in the last function are the first in the menu.\nContext menus should be added through [WidgetBase.AddContextMenu].\nSeparators will be added between each context menu function.\n[Scene.ContextMenus] apply to all widgets in the scene."}, {Name: "Deferred", Doc: "Deferred is a slice of functions to call after the next [Scene] update/render.\nIn each function event sending etc will work as expected. Use\n[WidgetBase.Defer] to add a function."}, {Name: "Scene", Doc: "Scene is the overall Scene to which we belong. It is automatically\nby widgets whenever they are added to another widget parent."}, {Name: "ValueUpdate", Doc: "ValueUpdate is a function set by [Bind] that is called in\n[WidgetBase.UpdateWidget] to update the widget's value from the bound value.\nIt should not be accessed by end users."}, {Name: "ValueOnChange", Doc: "ValueOnChange is a function set by [Bind] that is called when\nthe widget receives an [events.Change] event to update the bound value\nfrom the widget's value. It should not be accessed by end users."}, {Name: "ValueTitle", Doc: "ValueTitle is the title to display for a dialog for this [Value]."}, {Name: "flags", Doc: "/ flags are atomic bit flags for [WidgetBase] state."}}})

// NewWidgetBase returns a new [WidgetBase] with the given optional parent:
// WidgetBase implements the [Widget] interface and provides the core functionality
// of a widget. You must use WidgetBase as an embedded struct in all higher-level
// widget types. It renders the standard box model, but does not layout or render
// any children; see [Frame] for that.
func NewWidgetBase(parent ...tree.Node) *WidgetBase { return tree.New[WidgetBase](parent...) }

// SetTooltip sets the [WidgetBase.Tooltip]:
// Tooltip is the text for the tooltip for this widget,
// which can use HTML formatting.
func (t *WidgetBase) SetTooltip(v string) *WidgetBase { t.Tooltip = v; return t }

// SetValueTitle sets the [WidgetBase.ValueTitle]:
// ValueTitle is the title to display for a dialog for this [Value].
func (t *WidgetBase) SetValueTitle(v string) *WidgetBase { t.ValueTitle = v; return t }

var _ = types.AddFunc(&types.Func{Name: "cogentcore.org/core/core.ProfileToggle", Doc: "ProfileToggle turns profiling on or off, which does both\ntargeted profiling and global CPU and memory profiling.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}})

var _ = types.AddFunc(&types.Func{Name: "cogentcore.org/core/core.resetAllSettings", Doc: "resetAllSettings resets all of the settings to their default values.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Returns: []string{"error"}})

var _ = types.AddFunc(&types.Func{Name: "cogentcore.org/core/core.UpdateAll", Doc: "UpdateAll updates all windows and triggers a full render rebuild.\nIt is typically called when user settings are changed.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}})

var _ = types.AddFunc(&types.Func{Name: "cogentcore.org/core/core.SettingsWindow", Doc: "SettingsWindow opens a window for editing user settings.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}})

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"

        "cogentcore.org/core/tree"
)

// UpdateWidget updates the widget by running [WidgetBase.Updaters] in
// sequential descending (reverse) order after calling [WidgetBase.ValueUpdate].
// This includes applying the result of [WidgetBase.Make].
//
// UpdateWidget differs from [WidgetBase.Update] in that it only updates the widget
// itself and not any of its children. Also, it does not restyle the widget or trigger
// a new layout pass, while [WidgetBase.Update] does. End-user code should typically
// call [WidgetBase.Update], not UpdateWidget.
func (wb *WidgetBase) UpdateWidget() *WidgetBase {
        if wb.ValueUpdate != nil {
                wb.ValueUpdate()
        }
        wb.RunUpdaters()
        return wb
}

// UpdateTree calls [WidgetBase.UpdateWidget] on every widget in the tree
// starting with this one and going down.
func (wb *WidgetBase) UpdateTree() {
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                cwb.UpdateWidget()
                return tree.Continue
        })
}

// Update updates the widget and all of its children by running [WidgetBase.UpdateWidget]
// and [WidgetBase.Style] on each one, and triggering a new layout pass with
// [WidgetBase.NeedsLayout]. It is the main way that end users should trigger widget
// updates, and it is guaranteed to fully update a widget to the current state.
// For example, it should be called after making any changes to the core properties
// of a widget, such as the text of [Text], the icon of a [Button], or the slice
// of a [Table].
//
// Update differs from [WidgetBase.UpdateWidget] in that it updates the widget and all
// of its children down the tree, whereas [WidgetBase.UpdateWidget] only updates the widget
// itself. Also, Update also calls [WidgetBase.Style] and [WidgetBase.NeedsLayout],
// whereas [WidgetBase.UpdateWidget] does not. End-user code should typically call Update,
// not [WidgetBase.UpdateWidget].
//
// If you are calling this in a separate goroutine outside of the main
// configuration, rendering, and event handling structure, you need to
// call [WidgetBase.AsyncLock] and [WidgetBase.AsyncUnlock] before and
// after this, respectively.
func (wb *WidgetBase) Update() { //types:add
        if DebugSettings.UpdateTrace {
                fmt.Println("\tDebugSettings.UpdateTrace Update:", wb)
        }
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                cwb.UpdateWidget()
                cw.Style()
                return tree.Continue
        })
        wb.NeedsLayout()
}

// UpdateRender is the same as [WidgetBase.Update], except that it calls
// [WidgetBase.NeedsRender] instead of [WidgetBase.NeedsLayout].
// This should be called when the changes made to the widget do not
// require a new layout pass (if you change the size, spacing, alignment,
// or other layout properties of the widget, you need a new layout pass
// and should call [WidgetBase.Update] instead).
func (wb *WidgetBase) UpdateRender() {
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                cwb.UpdateWidget()
                cw.Style()
                return tree.Continue
        })
        wb.NeedsRender()
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "reflect"
        "strings"

        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
)

// Value is a widget that has an associated value representation.
// It can be bound to a value using [Bind].
type Value interface {
        Widget

        // WidgetValue returns the pointer to the associated value of the widget.
        WidgetValue() any
}

// ValueSetter is an optional interface that [Value]s can implement
// to customize how the associated widget value is set from the given value.
type ValueSetter interface {

        // SetWidgetValue sets the associated widget value from the given value.
        SetWidgetValue(value any) error
}

// OnBinder is an optional interface that [Value]s can implement to
// do something when the widget is bound to the given value.
type OnBinder interface {

        // OnBind is called when the widget is bound to the given value
        // with the given optional struct tags.
        OnBind(value any, tags reflect.StructTag)
}

// Bind binds the given value to the given [Value] such that the values of
// the two will be linked and updated appropriately after [events.Change] events
// and during [WidgetBase.UpdateWidget]. It returns the widget to enable method chaining.
// It also accepts an optional [reflect.StructTag], which is used to set properties
// of certain value widgets.
func Bind[T Value](value any, vw T, tags ...string) T { //yaegi:add
        // TODO: make tags be reflect.StructTag once yaegi is fixed to work with that
        wb := vw.AsWidget()
        alreadyBound := wb.ValueUpdate != nil
        wb.ValueUpdate = func() {
                if vws, ok := any(vw).(ValueSetter); ok {
                        ErrorSnackbar(vw, vws.SetWidgetValue(value))
                } else {
                        ErrorSnackbar(vw, reflectx.SetRobust(vw.WidgetValue(), value))
                }
        }
        wb.ValueOnChange = func() {
                ErrorSnackbar(vw, reflectx.SetRobust(value, vw.WidgetValue()))
        }
        if alreadyBound {
                ResetWidgetValue(vw)
        }
        wb.ValueTitle = labels.FriendlyTypeName(reflectx.NonPointerType(reflect.TypeOf(value)))
        if ob, ok := any(vw).(OnBinder); ok {
                tag := reflect.StructTag("")
                if len(tags) > 0 {
                        tag = reflect.StructTag(tags[0])
                }
                ob.OnBind(value, tag)
        }
        wb.ValueUpdate() // we update it with the initial value immediately
        return vw
}

// ResetWidgetValue resets the [Value] if it was already bound to another value previously.
// We first need to reset the widget value to zero to avoid any issues with the pointer
// from the old value persisting and being updated. For example, that issue happened
// with slice and map pointers persisting in forms when a new struct was set.
// It should not be called by end-user code; it must be exported since it is referenced
// in a generic function added to yaegi ([Bind]).
func ResetWidgetValue(vw Value) {
        rv := reflect.ValueOf(vw.WidgetValue())
        if rv.IsValid() && rv.Type().Kind() == reflect.Pointer {
                rv.Elem().SetZero()
        }
}

// joinValueTitle returns a [WidgetBase.ValueTitle] string composed
// of two elements, with a • separator, handling the cases where
// either or both can be empty.
func joinValueTitle(a, b string) string {
        switch {
        case a == "":
                return b
        case b == "":
                return a
        default:
                return a + " • " + b
        }
}

const shiftNewWindow = "[Shift: new window]"

// InitValueButton configures the given [Value] to open a dialog representing
// its value in accordance with the given dialog construction function when clicked.
// It also sets the tooltip of the widget appropriately. If allowReadOnly is false,
// the dialog will not be opened if the widget is read only. It also takes an optional
// function to call after the dialog is accepted.
func InitValueButton(v Value, allowReadOnly bool, make func(d *Body), after ...func()) {
        wb := v.AsWidget()
        // windows are never new on mobile
        if !TheApp.Platform().IsMobile() {
                wb.SetTooltip(shiftNewWindow)
        }
        wb.OnClick(func(e events.Event) {
                if allowReadOnly || !wb.IsReadOnly() {
                        if e.HasAnyModifier(key.Shift) {
                                wb.setFlag(!wb.hasFlag(widgetValueNewWindow), widgetValueNewWindow)
                        }
                        openValueDialog(v, make, after...)
                }
        })
}

// openValueDialog opens a new value dialog for the given [Value] using the
// given function for constructing the dialog and the optional given function
// to call after the dialog is accepted.
func openValueDialog(v Value, make func(d *Body), after ...func()) {
        opv := reflectx.UnderlyingPointer(reflect.ValueOf(v.WidgetValue()))
        if !opv.IsValid() {
                return
        }
        obj := opv.Interface()
        if RecycleDialog(obj) {
                return
        }
        wb := v.AsWidget()
        d := NewBody(wb.ValueTitle)
        if text := strings.ReplaceAll(wb.Tooltip, shiftNewWindow, ""); text != "" {
                NewText(d).SetType(TextSupporting).SetText(text)
        }
        make(d)

        // if we don't have anything specific for ok events,
        // we just register an OnClose event and skip the
        // OK and Cancel buttons
        if len(after) == 0 {
                d.OnClose(func(e events.Event) {
                        wb.UpdateChange()
                })
        } else {
                // otherwise, we have to make the bottom bar
                d.AddBottomBar(func(bar *Frame) {
                        d.AddCancel(bar)
                        d.AddOK(bar).OnClick(func(e events.Event) {
                                after[0]()
                                wb.UpdateChange()
                        })
                })
        }

        if wb.hasFlag(widgetValueNewWindow) {
                d.RunWindowDialog(v)
        } else {
                d.RunFullDialog(v)
        }
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image/color"
        "reflect"
        "time"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

// Valuer is an interface that types can implement to specify the
// [Value] that should be used to represent them in the GUI.
type Valuer interface {

        // Value returns the [Value] that should be used to represent
        // the value in the GUI. If it returns nil, then [ToValue] will
        // fall back onto the next step. This function must NOT call [Bind].
        Value() Value
}

// ValueTypes is a map of functions that return a [Value]
// for a value of a certain fully package path qualified type name.
// It is used by [toValue]. If a function returns nil, it falls
// back onto the next step. You can add to this using the [AddValueType]
// helper function. These functions must NOT call [Bind].
var ValueTypes = map[string]func(value any) Value{}

// AddValueType binds the given value type to the given [Value] [tree.NodeValue]
// type, meaning that [toValue] will return a new [Value] of the given type
// when it receives values of the given value type. It uses [ValueTypes].
// This function is called with various standard types automatically.
func AddValueType[T any, W tree.NodeValue]() {
        var v T
        name := types.TypeNameValue(v)
        ValueTypes[name] = func(value any) Value {
                return any(tree.New[W]()).(Value)
        }
}

// NewValue converts the given value into an appropriate [Value]
// whose associated value is bound to the given value. The given value must
// be a pointer. It uses the given optional struct tags for additional context
// and to determine styling properties via [styleFromTags]. It also adds the
// resulting [Value] to the given optional parent if it specified. The specifics
// on how it determines what type of [Value] to make are further
// documented on [toValue].
func NewValue(value any, tags reflect.StructTag, parent ...tree.Node) Value {
        vw := toValue(value, tags)
        if tags != "" {
                styleFromTags(vw, tags)
        }
        Bind(value, vw, string(tags))
        if len(parent) > 0 {
                parent[0].AsTree().AddChild(vw)
        }
        return vw
}

// toValue converts the given value into an appropriate [Value],
// using the given optional struct tags for additional context.
// The given value should typically be a pointer. It does NOT call [Bind];
// see [NewValue] for a version that does. It first checks the
// [Valuer] interface, then the [ValueTypes], and finally it falls
// back on a set of default bindings. If any step results in nil,
// it falls back on the next step.
func toValue(value any, tags reflect.StructTag) Value {
        if vwr, ok := value.(Valuer); ok {
                if vw := vwr.Value(); vw != nil {
                        return vw
                }
        }
        rv := reflect.ValueOf(value)
        if !rv.IsValid() {
                return NewText()
        }
        uv := reflectx.Underlying(rv)
        typ := uv.Type()
        if vwt, ok := ValueTypes[types.TypeName(typ)]; ok {
                if vw := vwt(value); vw != nil {
                        return vw
                }
        }

        // Default bindings:

        if _, ok := value.(enums.BitFlag); ok {
                return NewSwitches()
        }
        if enum, ok := value.(enums.Enum); ok {
                if len(enum.Values()) < 4 {
                        return NewSwitches()
                }
                return NewChooser()
        }
        if _, ok := value.(color.Color); ok {
                return NewColorButton()
        }
        if _, ok := value.(tree.Node); ok {
                return NewTreeButton()
        }

        inline := tags.Get("display") == "inline"
        noInline := tags.Get("display") == "no-inline"

        kind := typ.Kind()
        switch {
        case kind >= reflect.Int && kind <= reflect.Float64:
                if _, ok := value.(fmt.Stringer); ok {
                        return NewTextField()
                }
                return NewSpinner()
        case kind == reflect.Bool:
                return NewSwitch()
        case kind == reflect.Struct:
                num := reflectx.NumAllFields(uv)
                if !noInline && (inline || num <= SystemSettings.StructInlineLength) {
                        return NewForm().SetInline(true)
                }
                return NewFormButton()
        case kind == reflect.Map:
                len := uv.Len()
                if !noInline && (inline || len <= SystemSettings.MapInlineLength) {
                        return NewKeyedList().SetInline(true)
                }
                return NewKeyedListButton()
        case kind == reflect.Array, kind == reflect.Slice:
                sz := uv.Len()
                elemType := reflectx.SliceElementType(value)
                if _, ok := value.([]byte); ok {
                        return NewTextField()
                }
                if _, ok := value.([]rune); ok {
                        return NewTextField()
                }
                isStruct := (reflectx.NonPointerType(elemType).Kind() == reflect.Struct)
                if !noInline && (inline || (!isStruct && sz <= SystemSettings.SliceInlineLength && !tree.IsNode(elemType))) {
                        return NewInlineList()
                }
                return NewListButton()
        case kind == reflect.Func:
                return NewFuncButton()
        }

        return NewTextField() // final fallback
}

func init() {
        AddValueType[icons.Icon, IconButton]()
        AddValueType[time.Time, TimeInput]()
        AddValueType[time.Duration, DurationInput]()
        AddValueType[types.Type, TypeChooser]()
        AddValueType[Filename, FileButton]()
        // AddValueType[FontName, FontButton]()
        AddValueType[FontName, TextField]()
        AddValueType[keymap.MapName, KeyMapButton]()
        AddValueType[key.Chord, KeyChordButton]()
        AddValueType[HighlightingName, HighlightingButton]()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "image"
        "reflect"

        "cogentcore.org/core/base/labels"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/text/fonts"
        "cogentcore.org/core/text/highlighting"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
        "golang.org/x/exp/maps"
)

// ListButton represents a slice or array value with a button that opens a [List].
type ListButton struct {
        Button
        Slice any
}

func (lb *ListButton) WidgetValue() any { return &lb.Slice }

func (lb *ListButton) Init() {
        lb.Button.Init()
        lb.SetType(ButtonTonal).SetIcon(icons.Edit)
        lb.Updater(func() {
                lb.SetText(labels.FriendlySliceLabel(reflect.ValueOf(lb.Slice)))
        })
        InitValueButton(lb, true, func(d *Body) {
                up := reflectx.Underlying(reflect.ValueOf(lb.Slice))
                if up.Type().Kind() != reflect.Array && reflectx.NonPointerType(reflectx.SliceElementType(lb.Slice)).Kind() == reflect.Struct {
                        tb := NewTable(d).SetSlice(lb.Slice)
                        tb.SetValueTitle(lb.ValueTitle).SetReadOnly(lb.IsReadOnly())
                        d.AddTopBar(func(bar *Frame) {
                                NewToolbar(bar).Maker(tb.MakeToolbar)
                        })
                } else {
                        sv := NewList(d).SetSlice(lb.Slice)
                        sv.SetValueTitle(lb.ValueTitle).SetReadOnly(lb.IsReadOnly())
                        d.AddTopBar(func(bar *Frame) {
                                NewToolbar(bar).Maker(sv.MakeToolbar)
                        })
                }
        })
}

// FormButton represents a struct value with a button that opens a [Form].
type FormButton struct {
        Button
        Struct any
}

func (fb *FormButton) WidgetValue() any { return &fb.Struct }

func (fb *FormButton) Init() {
        fb.Button.Init()
        fb.SetType(ButtonTonal).SetIcon(icons.Edit)
        fb.Updater(func() {
                fb.SetText(labels.FriendlyStructLabel(reflect.ValueOf(fb.Struct)))
        })
        InitValueButton(fb, true, func(d *Body) {
                fm := NewForm(d).SetStruct(fb.Struct)
                fm.SetValueTitle(fb.ValueTitle).SetReadOnly(fb.IsReadOnly())
                if tb, ok := fb.Struct.(ToolbarMaker); ok {
                        d.AddTopBar(func(bar *Frame) {
                                NewToolbar(bar).Maker(tb.MakeToolbar)
                        })
                }
        })
}

// KeyedListButton represents a map value with a button that opens a [KeyedList].
type KeyedListButton struct {
        Button
        Map any
}

func (kb *KeyedListButton) WidgetValue() any { return &kb.Map }

func (kb *KeyedListButton) Init() {
        kb.Button.Init()
        kb.SetType(ButtonTonal).SetIcon(icons.Edit)
        kb.Updater(func() {
                kb.SetText(labels.FriendlyMapLabel(reflect.ValueOf(kb.Map)))
        })
        InitValueButton(kb, true, func(d *Body) {
                kl := NewKeyedList(d).SetMap(kb.Map)
                kl.SetValueTitle(kb.ValueTitle).SetReadOnly(kb.IsReadOnly())
                d.AddTopBar(func(bar *Frame) {
                        NewToolbar(bar).Maker(kl.MakeToolbar)
                })
        })
}

// TreeButton represents a [tree.Node] value with a button.
type TreeButton struct {
        Button
        Tree tree.Node
}

func (tb *TreeButton) WidgetValue() any { return &tb.Tree }

func (tb *TreeButton) Init() {
        tb.Button.Init()
        tb.SetType(ButtonTonal).SetIcon(icons.Edit)
        tb.Updater(func() {
                path := "None"
                if !reflectx.UnderlyingPointer(reflect.ValueOf(tb.Tree)).IsNil() {
                        path = tb.Tree.AsTree().String()
                }
                tb.SetText(path)
        })
        InitValueButton(tb, true, func(d *Body) {
                if !reflectx.UnderlyingPointer(reflect.ValueOf(tb.Tree)).IsNil() {
                        makeInspector(d, tb.Tree)
                }
        })
}

func (tb *TreeButton) WidgetTooltip(pos image.Point) (string, image.Point) {
        if reflectx.UnderlyingPointer(reflect.ValueOf(tb.Tree)).IsNil() {
                return tb.Tooltip, tb.DefaultTooltipPos()
        }
        tpa := "(" + tb.Tree.AsTree().Path() + ")"
        if tb.Tooltip == "" {
                return tpa, tb.DefaultTooltipPos()
        }
        return tpa + " " + tb.Tooltip, tb.DefaultTooltipPos()
}

// TypeChooser represents a [types.Type] value with a chooser.
type TypeChooser struct {
        Chooser
}

func (tc *TypeChooser) Init() {
        tc.Chooser.Init()
        tc.SetTypes(maps.Values(types.Types)...)
}

// IconButton represents an [icons.Icon] with a [Button] that opens
// a dialog for selecting the icon.
type IconButton struct {
        Button
}

func (ib *IconButton) WidgetValue() any { return &ib.Icon }

func (ib *IconButton) Init() {
        ib.Button.Init()
        ib.Updater(func() {
                if !ib.Icon.IsSet() {
                        ib.SetText("Select an icon")
                } else {
                        ib.SetText("")
                }
                if ib.IsReadOnly() {
                        ib.SetType(ButtonText)
                        if !ib.Icon.IsSet() {
                                ib.SetText("").SetIcon(icons.Blank)
                        }
                } else {
                        ib.SetType(ButtonTonal)
                }
        })
        InitValueButton(ib, false, func(d *Body) {
                d.SetTitle("Select an icon")
                si := 0
                used := maps.Keys(icons.Used)
                ls := NewList(d)
                ls.SetSlice(&used).SetSelectedValue(ib.Icon).BindSelect(&si)
                ls.OnChange(func(e events.Event) {
                        ib.Icon = used[si]
                })
        })
}

// FontName is used to specify a font family name.
// It results in a [FontButton] [Value].
type FontName = rich.FontName

// FontButton represents a [FontName] with a [Button] that opens
// a dialog for selecting the font family.
type FontButton struct {
        Button
}

func (fb *FontButton) WidgetValue() any { return &fb.Text }

func (fb *FontButton) Init() {
        fb.Button.Init()
        fb.SetType(ButtonTonal)
        fb.Updater(func() {
                if fb.Text == "" {
                        fb.SetText("(default)")
                }
        })
        InitValueButton(fb, false, func(d *Body) {
                d.SetTitle("Select a font family")
                si := 0
                fi := fonts.Families(fb.Scene.TextShaper().FontList())
                tb := NewTable(d)
                tb.SetSlice(&fi).SetSelectedField("Family").SetSelectedValue(fb.Text).BindSelect(&si)
                tb.SetTableStyler(func(w Widget, s *styles.Style, row, col int) {
                        if col != 1 {
                                return
                        }
                        s.Font.CustomFont = rich.FontName(fi[row].Family)
                        s.Font.Family = rich.Custom
                        s.Font.Size.Dp(24)
                })
                tb.OnChange(func(e events.Event) {
                        fb.Text = fi[si].Family
                })
        })
}

// HighlightingName is a highlighting style name.
type HighlightingName = highlighting.HighlightingName

// HighlightingButton represents a [HighlightingName] with a button.
type HighlightingButton struct {
        Button
        HighlightingName string
}

func (hb *HighlightingButton) WidgetValue() any { return &hb.HighlightingName }

func (hb *HighlightingButton) Init() {
        hb.Button.Init()
        hb.SetType(ButtonTonal).SetIcon(icons.Brush)
        hb.Updater(func() {
                hb.SetText(hb.HighlightingName)
        })
        InitValueButton(hb, false, func(d *Body) {
                d.SetTitle("Select a syntax highlighting style")
                si := 0
                ls := NewList(d).SetSlice(&highlighting.StyleNames).SetSelectedValue(hb.HighlightingName).BindSelect(&si)
                ls.OnChange(func(e events.Event) {
                        hb.HighlightingName = highlighting.StyleNames[si]
                })
        })
}

// Editor opens an editor of highlighting styles.
func HighlightingEditor(st *highlighting.Styles) {
        if RecycleMainWindow(st) {
                return
        }

        d := NewBody("Highlighting styles").SetData(st)
        NewText(d).SetType(TextSupporting).SetText("View standard to see the builtin styles, from which you can add and customize by saving ones from the standard and then loading them into a custom file to modify.")
        kl := NewKeyedList(d).SetMap(st)
        highlighting.StylesChanged = false
        kl.OnChange(func(e events.Event) {
                highlighting.StylesChanged = true
        })
        d.AddTopBar(func(bar *Frame) {
                NewToolbar(bar).Maker(func(p *tree.Plan) {
                        tree.Add(p, func(w *FuncButton) {
                                w.SetFunc(st.OpenJSON).SetText("Open from file").SetIcon(icons.Open)
                                w.Args[0].SetTag(`extension:".highlighting"`)
                        })
                        tree.Add(p, func(w *FuncButton) {
                                w.SetFunc(st.SaveJSON).SetText("Save from file").SetIcon(icons.Save)
                                w.Args[0].SetTag(`extension:".highlighting"`)
                        })
                        tree.Add(p, func(w *Button) {
                                w.SetText("View standard").SetIcon(icons.Visibility).OnClick(func(e events.Event) {
                                        HighlightingEditor(&highlighting.StandardStyles)
                                })
                        })
                        tree.Add(p, func(w *Separator) {})
                        kl.MakeToolbar(p)
                })
        })
        d.RunWindow() // note: no context here so not dialog
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package core provides the core GUI functionality of Cogent Core.
package core

//go:generate core generate

import (
        "image"
        "log/slog"

        "cogentcore.org/core/base/tiered"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/system/composer"
        "cogentcore.org/core/tree"
        "golang.org/x/image/draw"
)

// Widget is the interface that all Cogent Core widgets satisfy.
// The core widget functionality is defined on [WidgetBase],
// and all higher-level widget types must embed it. This
// interface only contains the methods that higher-level
// widget types may need to override. You can call
// [Widget.AsWidget] to get the [WidgetBase] of a Widget
// and access the core widget functionality.
type Widget interface {
        tree.Node

        // AsWidget returns the [WidgetBase] of this Widget. Most
        // core widget functionality is implemented on [WidgetBase].
        AsWidget() *WidgetBase

        // Style updates the style properties of the widget based on [WidgetBase.Stylers].
        // To specify the style properties of a widget, use [WidgetBase.Styler].
        // Widgets can implement this method if necessary to add additional styling behavior,
        // such as calling [units.Value.ToDots] on a custom [units.Value] field.
        Style()

        // SizeUp (bottom-up) gathers Actual sizes from our Children & Parts,
        // based on Styles.Min / Max sizes and actual content sizing
        // (e.g., text size).  Flexible elements (e.g., [Text], Flex Wrap,
        // [Toolbar]) should reserve the _minimum_ size possible at this stage,
        // and then Grow based on SizeDown allocation.
        SizeUp()

        // SizeDown (top-down, multiple iterations possible) provides top-down
        // size allocations based initially on Scene available size and
        // the SizeUp Actual sizes.  If there is extra space available, it is
        // allocated according to the Grow factors.
        // Flexible elements (e.g., Flex Wrap layouts and Text with word wrap)
        // update their Actual size based on available Alloc size (re-wrap),
        // to fit the allocated shape vs. the initial bottom-up guess.
        // However, do NOT grow the Actual size to match Alloc at this stage,
        // as Actual sizes must always represent the minimums (see Position).
        // Returns true if any change in Actual size occurred.
        SizeDown(iter int) bool

        // SizeFinal: (bottom-up) similar to SizeUp but done at the end of the
        // Sizing phase: first grows widget Actual sizes based on their Grow
        // factors, up to their Alloc sizes.  Then gathers this updated final
        // actual Size information for layouts to register their actual sizes
        // prior to positioning, which requires accurate Actual vs. Alloc
        // sizes to perform correct alignment calculations.
        SizeFinal()

        // Position uses the final sizes to set relative positions within layouts
        // according to alignment settings, and Grow elements to their actual
        // Alloc size per Styles settings and widget-specific behavior.
        Position()

        // ApplyScenePos computes scene-based absolute positions and final BBox
        // bounding boxes for rendering, based on relative positions from
        // Position step and parents accumulated position and scroll offset.
        // This is the only step needed when scrolling (very fast).
        ApplyScenePos()

        // Render is the method that widgets should implement to define their
        // custom rendering steps. It should not typically be called outside of
        // [Widget.RenderWidget], which also does other steps applicable
        // for all widgets. The base [WidgetBase.Render] implementation
        // renders the standard box model.
        Render()

        // RenderWidget renders the widget and any parts and children that it has.
        // It does not render if the widget is invisible. It calls [Widget.Render]
        // for widget-specific rendering.
        RenderWidget()

        // WidgetTooltip returns the tooltip text that should be used for this
        // widget, and the window-relative position to use for the upper-left corner
        // of the tooltip. The current mouse position in scene-local coordinates
        // is passed to the function; if it is {-1, -1}, that indicates that
        // WidgetTooltip is being called in a Style function to determine whether
        // the widget should be [abilities.LongHoverable] and [abilities.LongPressable]
        // (if the return string is not "", then it will have those abilities
        // so that the tooltip can be displayed).
        //
        // By default, WidgetTooltip just returns [WidgetBase.Tooltip]
        // and [WidgetBase.DefaultTooltipPos], but widgets can override
        // it to do different things. For example, buttons add their
        // shortcut to the tooltip here.
        WidgetTooltip(pos image.Point) (string, image.Point)

        // ContextMenuPos returns the default position for popup menus;
        // by default in the middle its Bounding Box, but can be adapted as
        // appropriate for different widgets.
        ContextMenuPos(e events.Event) image.Point

        // ShowContextMenu displays the context menu of various actions
        // to perform on a Widget, activated by default on the ShowContextMenu
        // event, triggered by a Right mouse click.
        // Returns immediately, and actions are all executed directly
        // (later) via the action signals. Calls ContextMenu and
        // ContextMenuPos.
        ShowContextMenu(e events.Event)

        // ChildBackground returns the background color (Image) for the given child Widget.
        // By default, this is just our [styles.Style.ActualBackground] but it can be computed
        // specifically for the child (e.g., for zebra stripes in [ListGrid]).
        ChildBackground(child Widget) image.Image

        // RenderSource returns the self-contained [composer.Source] for
        // rendering this widget. The base widget returns nil, and the [Scene]
        // widget returns the [paint.Painter] rendering results.
        // Widgets that do direct rendering instead of drawing onto
        // the Scene painter should return a suitable render source.
        // Use [Scene.AddDirectRender] to register such widgets with the Scene.
        // The given draw operation is the suggested way to Draw onto existing images.
        RenderSource(op draw.Op) composer.Source
}

// WidgetBase implements the [Widget] interface and provides the core functionality
// of a widget. You must use WidgetBase as an embedded struct in all higher-level
// widget types. It renders the standard box model, but does not layout or render
// any children; see [Frame] for that.
type WidgetBase struct {
        tree.NodeBase

        // Tooltip is the text for the tooltip for this widget,
        // which can use HTML formatting.
        Tooltip string `json:",omitempty"`

        // Parts are a separate tree of sub-widgets that can be used to store
        // orthogonal parts of a widget when necessary to separate them from children.
        // For example, [Tree]s use parts to separate their internal parts from
        // the other child tree nodes. Composite widgets like buttons should
        // NOT use parts to store their components; parts should only be used when
        // absolutely necessary. Use [WidgetBase.newParts] to make the parts.
        Parts *Frame `copier:"-" json:"-" xml:"-" set:"-"`

        // Geom has the full layout geometry for size and position of this widget.
        Geom geomState `edit:"-" copier:"-" json:"-" xml:"-" set:"-"`

        // OverrideStyle, if true, indicates override the computed styles of the widget
        // and allow directly editing [WidgetBase.Styles]. It is typically only set in
        // the inspector.
        OverrideStyle bool `copier:"-" json:"-" xml:"-" set:"-"`

        // Styles are styling settings for this widget. They are set by
        // [WidgetBase.Stylers] in [WidgetBase.Style].
        Styles styles.Style `json:"-" xml:"-" set:"-"`

        // Stylers is a tiered set of functions that are called in sequential
        // ascending order (so the last added styler is called last and
        // thus can override all other stylers) to style the element.
        // These should be set using the [WidgetBase.Styler], [WidgetBase.FirstStyler],
        // and [WidgetBase.FinalStyler] functions.
        Stylers tiered.Tiered[[]func(s *styles.Style)] `copier:"-" json:"-" xml:"-" set:"-" edit:"-" display:"add-fields"`

        // Listeners is a tiered set of event listener functions for processing events on this widget.
        // They are called in sequential descending order (so the last added listener
        // is called first). They should be added using the [WidgetBase.On], [WidgetBase.OnFirst],
        // and [WidgetBase.OnFinal] functions, or any of the various On{EventType} helper functions.
        Listeners tiered.Tiered[events.Listeners] `copier:"-" json:"-" xml:"-" set:"-" edit:"-" display:"add-fields"`

        // ContextMenus is a slice of menu functions to call to construct
        // the widget's context menu on an [events.ContextMenu]. The
        // functions are called in reverse order such that the elements
        // added in the last function are the first in the menu.
        // Context menus should be added through [WidgetBase.AddContextMenu].
        // Separators will be added between each context menu function.
        // [Scene.ContextMenus] apply to all widgets in the scene.
        ContextMenus []func(m *Scene) `copier:"-" json:"-" xml:"-" set:"-" edit:"-"`

        // Deferred is a slice of functions to call after the next [Scene] update/render.
        // In each function event sending etc will work as expected. Use
        // [WidgetBase.Defer] to add a function.
        Deferred []func() `copier:"-" json:"-" xml:"-" set:"-" edit:"-"`

        // Scene is the overall Scene to which we belong. It is automatically
        // by widgets whenever they are added to another widget parent.
        Scene *Scene `copier:"-" json:"-" xml:"-" set:"-"`

        // ValueUpdate is a function set by [Bind] that is called in
        // [WidgetBase.UpdateWidget] to update the widget's value from the bound value.
        // It should not be accessed by end users.
        ValueUpdate func() `copier:"-" json:"-" xml:"-" set:"-"`

        // ValueOnChange is a function set by [Bind] that is called when
        // the widget receives an [events.Change] event to update the bound value
        // from the widget's value. It should not be accessed by end users.
        ValueOnChange func() `copier:"-" json:"-" xml:"-" set:"-"`

        // ValueTitle is the title to display for a dialog for this [Value].
        ValueTitle string

        /// flags are atomic bit flags for [WidgetBase] state.
        flags widgetFlags
}

// widgetFlags are atomic bit flags for [WidgetBase] state.
// They must be atomic to prevent race conditions.
type widgetFlags int64 //enums:bitflag -trim-prefix widget

const (
        // widgetValueNewWindow indicates that the dialog of a [Value] should be opened
        // as a new window, instead of a typical full window in the same current window.
        // This is set by [InitValueButton] and handled by [openValueDialog].
        // This is triggered by holding down the Shift key while clicking on a
        // [Value] button. Certain values such as [FileButton] may set this to true
        // in their [InitValueButton] function.
        widgetValueNewWindow widgetFlags = iota

        // widgetNeedsRender is whether the widget needs to be rendered on the next render iteration.
        widgetNeedsRender
)

// hasFlag returns whether the given flag is set.
func (wb *WidgetBase) hasFlag(f widgetFlags) bool {
        return wb.flags.HasFlag(f)
}

// setFlag sets the given flags to the given value.
func (wb *WidgetBase) setFlag(on bool, f ...enums.BitFlag) {
        wb.flags.SetFlag(on, f...)
}

// Init should be called by every [Widget] type in its custom
// Init if it has one to establish all the default styling
// and event handling that applies to all widgets.
func (wb *WidgetBase) Init() {
        wb.Styler(func(s *styles.Style) {
                s.MaxBorder.Style.Set(styles.BorderSolid)
                s.MaxBorder.Color.Set(colors.Scheme.Primary.Base)
                s.MaxBorder.Width.Set(units.Dp(1))

                // if we are disabled, we do not react to any state changes,
                // and instead always have the same gray colors
                if s.Is(states.Disabled) {
                        s.Cursor = cursors.NotAllowed
                        s.Opacity = 0.38
                        return
                }
                // TODO(kai): what about context menus on mobile?
                tt, _ := wb.This.(Widget).WidgetTooltip(image.Pt(-1, -1))
                s.SetAbilities(tt != "", abilities.LongHoverable, abilities.LongPressable)

                if s.Is(states.Selected) {
                        s.Background = colors.Scheme.Select.Container
                        s.Color = colors.Scheme.Select.OnContainer
                }
        })
        wb.FinalStyler(func(s *styles.Style) {
                if s.Is(states.Focused) {
                        s.Border.Style = s.MaxBorder.Style
                        s.Border.Color = s.MaxBorder.Color
                        s.Border.Width = s.MaxBorder.Width
                }
                if !s.AbilityIs(abilities.Focusable) {
                        // never need bigger border if not focusable
                        s.MaxBorder = s.Border
                }
        })

        // TODO(kai): maybe move all of these event handling functions into one function
        wb.handleWidgetClick()
        wb.handleWidgetStateFromMouse()
        wb.handleLongHoverTooltip()
        wb.handleWidgetStateFromFocus()
        wb.handleWidgetStateFromAttend()
        wb.handleWidgetContextMenu()
        wb.handleWidgetMagnify()
        wb.handleValueOnChange()

        wb.Updater(wb.UpdateFromMake)
}

// OnAdd is called when widgets are added to a parent.
// It sets the scene of the widget to its widget parent.
// It should be called by all other OnAdd functions defined
// by widget types.
func (wb *WidgetBase) OnAdd() {
        if pwb := wb.parentWidget(); pwb != nil {
                wb.Scene = pwb.Scene
        }
        if wb.Parts != nil {
                // the Scene of the Parts may not have been set yet if they were made in Init
                wb.Parts.Scene = wb.Scene
        }
        if wb.Scene != nil && wb.Scene.WidgetInit != nil {
                wb.Scene.WidgetInit(wb.This.(Widget))
        }
}

// setScene sets the Scene pointer for this widget and all of its children.
// This can be necessary when creating widgets outside the usual New* paradigm,
// e.g., when reading from a JSON file.
func (wb *WidgetBase) setScene(sc *Scene) {
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                cwb.Scene = sc
                return tree.Continue
        })
}

// AsWidget returns the given [tree.Node] as a [WidgetBase] or nil.
func AsWidget(n tree.Node) *WidgetBase {
        if w, ok := n.(Widget); ok {
                return w.AsWidget()
        }
        return nil
}

func (wb *WidgetBase) AsWidget() *WidgetBase {
        return wb
}

func (wb *WidgetBase) CopyFieldsFrom(from tree.Node) {
        wb.NodeBase.CopyFieldsFrom(from)
        frm := AsWidget(from)

        n := len(wb.ContextMenus)
        if len(frm.ContextMenus) > n {
                wb.ContextMenus = append(wb.ContextMenus, frm.ContextMenus[n:]...)
        }

        wb.Stylers.DoWith(&frm.Stylers, func(to, from *[]func(s *styles.Style)) {
                n := len(*to)
                if len(*from) > n {
                        *to = append(*to, (*from)[n:]...)
                }
        })

        wb.Listeners.DoWith(&frm.Listeners, func(to, from *events.Listeners) {
                to.CopyFromExtra(*from)
        })
}

func (wb *WidgetBase) Destroy() {
        wb.deleteParts()
        wb.NodeBase.Destroy()
}

// deleteParts deletes the widget's parts (and the children of the parts).
func (wb *WidgetBase) deleteParts() {
        if wb.Parts != nil {
                wb.Parts.Destroy()
        }
        wb.Parts = nil
}

// newParts makes the [WidgetBase.Parts] if they don't already exist.
// It returns the parts regardless.
func (wb *WidgetBase) newParts() *Frame {
        if wb.Parts != nil {
                return wb.Parts
        }
        wb.Parts = NewFrame()
        wb.Parts.SetName("parts")
        tree.SetParent(wb.Parts, wb) // don't add to children list
        wb.Parts.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 1)
                s.RenderBox = false
        })
        return wb.Parts
}

// parentWidget returns the parent as a [WidgetBase] or nil
// if this is the root and has no parent.
func (wb *WidgetBase) parentWidget() *WidgetBase {
        if wb.Parent == nil {
                return nil
        }
        pw, ok := wb.Parent.(Widget)
        if ok {
                return pw.AsWidget()
        }
        return nil // the parent may be a non-widget in [tree.UnmarshalRootJSON]
}

// IsDisplayable returns whether the widget has the potential of being displayed.
// If it or any of its parents are deleted or [states.Invisible], it is not
// displayable. Otherwise, it is displayable.
//
// This does *not* check if the widget is actually currently visible, for which you
// can use [WidgetBase.IsVisible]. In other words, if a widget is currently offscreen
// but can be scrolled onscreen, it is still displayable, but it is not visible until
// its bounding box is actually onscreen.
//
// Widgets that are not displayable are automatically not rendered and do not get
// window events.
//
// [styles.DisplayNone] can be set for [styles.Style.Display] to make a widget
// not displayable.
func (wb *WidgetBase) IsDisplayable() bool {
        if wb == nil || wb.This == nil || wb.StateIs(states.Invisible) || wb.Scene == nil {
                return false
        }
        if wb.Parent == nil {
                return true
        }
        return wb.parentWidget().IsDisplayable()
}

// IsVisible returns whether the widget is actually currently visible.
// A widget is visible if and only if it is both [WidgetBase.IsDisplayable]
// and it has a non-empty rendering bounding box (ie: it is currently onscreen).
// This means that widgets currently not visible due to scrolling will return false
// for this function, even though they are still displayable and return true for
// [WidgetBase.IsDisplayable].
func (wb *WidgetBase) IsVisible() bool {
        return wb.IsDisplayable() && !wb.Geom.TotalBBox.Empty()
}

// RenderSource returns the self-contained [composer.Source] for
// rendering this widget. The base widget returns nil, and the [Scene]
// widget returns the [paint.Painter] rendering results.
// Widgets that do direct rendering instead of drawing onto
// the Scene painter should return a suitable render source.
// Use [Scene.AddDirectRender] to register such widgets with the Scene.
// The given draw operation is the suggested way to Draw onto existing images.
func (wb *WidgetBase) RenderSource(op draw.Op) composer.Source { return nil }

// NodeWalkDown extends [tree.Node.WalkDown] to [WidgetBase.Parts],
// which is key for getting full tree traversal to work when updating,
// configuring, and styling. This implements [tree.Node.NodeWalkDown].
func (wb *WidgetBase) NodeWalkDown(fun func(tree.Node) bool) {
        if wb.Parts == nil {
                return
        }
        wb.Parts.WalkDown(fun)
}

// ForWidgetChildren iterates through the children as widgets, calling the given function.
// Return [tree.Continue] (true) to continue, and [tree.Break] (false) to terminate.
func (wb *WidgetBase) ForWidgetChildren(fun func(i int, cw Widget, cwb *WidgetBase) bool) {
        for i, c := range wb.Children {
                if tree.IsNil(c) {
                        continue
                }
                w, cwb := c.(Widget), AsWidget(c)
                if !fun(i, w, cwb) {
                        break
                }
        }
}

// forVisibleChildren iterates through the children,as widgets, calling the given function,
// excluding any with the *local* states.Invisible flag set (does not check parents).
// This is used e.g., for layout functions to exclude non-visible direct children.
// Return [tree.Continue] (true) to continue, and [tree.Break] (false) to terminate.
func (wb *WidgetBase) forVisibleChildren(fun func(i int, cw Widget, cwb *WidgetBase) bool) {
        for i, c := range wb.Children {
                if tree.IsNil(c) {
                        continue
                }
                w, cwb := c.(Widget), AsWidget(c)
                if cwb.StateIs(states.Invisible) {
                        continue
                }
                cont := fun(i, w, cwb)
                if !cont {
                        break
                }
        }
}

// WidgetWalkDown is a version of [tree.NodeBase.WalkDown] that operates on [Widget] types,
// calling the given function on the Widget and all of its children in a depth-first manner.
// Return [tree.Continue] to continue and [tree.Break] to terminate.
func (wb *WidgetBase) WidgetWalkDown(fun func(cw Widget, cwb *WidgetBase) bool) {
        wb.WalkDown(func(n tree.Node) bool {
                cw, cwb := n.(Widget), AsWidget(n)
                return fun(cw, cwb)
        })
}

// widgetNext returns the next widget in the tree,
// including Parts, which are considered to come after Children.
// returns nil if no more.
func widgetNext(w Widget) Widget {
        wb := w.AsWidget()
        if !wb.HasChildren() && wb.Parts == nil {
                return widgetNextSibling(w)
        }
        if wb.HasChildren() {
                return wb.Child(0).(Widget)
        }
        if wb.Parts != nil {
                return widgetNext(wb.Parts.This.(Widget))
        }
        return nil
}

// widgetNextSibling returns next sibling or nil if none,
// including Parts, which are considered to come after Children.
func widgetNextSibling(w Widget) Widget {
        wb := w.AsWidget()
        if wb.Parent == nil {
                return nil
        }
        parent := wb.Parent.(Widget)
        myidx := wb.IndexInParent()
        if myidx >= 0 && myidx < wb.Parent.AsTree().NumChildren()-1 {
                return parent.AsTree().Child(myidx + 1).(Widget)
        }
        return widgetNextSibling(parent)
}

// widgetPrev returns the previous widget in the tree,
// including Parts, which are considered to come after Children.
// nil if no more.
func widgetPrev(w Widget) Widget {
        wb := w.AsWidget()
        if wb.Parent == nil {
                return nil
        }
        parent := wb.Parent.(Widget)
        myidx := wb.IndexInParent()
        if myidx > 0 {
                nn := parent.AsTree().Child(myidx - 1).(Widget)
                return widgetLastChildParts(nn) // go to parts
        }
        // we were children, done
        return parent
}

// widgetLastChildParts returns the last child under given node,
// or node itself if no children.  Starts with Parts,
func widgetLastChildParts(w Widget) Widget {
        wb := w.AsWidget()
        if wb.Parts != nil && wb.Parts.HasChildren() {
                return widgetLastChildParts(wb.Parts.Child(wb.Parts.NumChildren() - 1).(Widget))
        }
        if wb.HasChildren() {
                return widgetLastChildParts(wb.Child(wb.NumChildren() - 1).(Widget))
        }
        return w
}

// widgetNextFunc returns the next widget in the tree,
// including Parts, which are considered to come after children,
// continuing until the given function returns true.
// nil if no more.
func widgetNextFunc(w Widget, fun func(w Widget) bool) Widget {
        for {
                nw := widgetNext(w)
                if nw == nil {
                        return nil
                }
                if fun(nw) {
                        return nw
                }
                if nw == w {
                        slog.Error("WidgetNextFunc", "start", w, "nw == wi", nw)
                        return nil
                }
                w = nw
        }
}

// widgetPrevFunc returns the previous widget in the tree,
// including Parts, which are considered to come after children,
// continuing until the given function returns true.
// nil if no more.
func widgetPrevFunc(w Widget, fun func(w Widget) bool) Widget {
        for {
                pw := widgetPrev(w)
                if pw == nil {
                        return nil
                }
                if fun(pw) {
                        return pw
                }
                if pw == w {
                        slog.Error("WidgetPrevFunc", "start", w, "pw == wi", pw)
                        return nil
                }
                w = pw
        }
}

// WidgetTooltip is the base implementation of [Widget.WidgetTooltip],
// which just returns [WidgetBase.Tooltip] and [WidgetBase.DefaultTooltipPos].
func (wb *WidgetBase) WidgetTooltip(pos image.Point) (string, image.Point) {
        return wb.Tooltip, wb.DefaultTooltipPos()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "image"
        "log/slog"

        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
)

// Events returns the higher-level core event manager
// for this [Widget]'s [Scene].
func (wb *WidgetBase) Events() *Events {
        if wb.Scene == nil {
                return nil
        }
        return &wb.Scene.Events
}

// SystemEvents returns the lower-level system event
// manager for this [Widget]'s [Scene].
func (wb *WidgetBase) SystemEvents() *events.Source {
        return wb.Scene.RenderWindow().SystemWindow.Events()
}

// Clipboard returns the clipboard for the [Widget] to use.
func (wb *WidgetBase) Clipboard() system.Clipboard {
        return wb.Events().Clipboard()
}

// On adds the given event handler to the [WidgetBase.Listeners.Normal] for the given
// event type. Listeners are called in sequential descending order, so this listener
// will be called before all of the ones added before it. On is one of the main ways
// to add an event handler to a widget, in addition to OnFirst and OnFinal, which add
// event handlers that are called before and after those added by this function,
// respectively.
func (wb *WidgetBase) On(etype events.Types, fun func(e events.Event)) {
        wb.Listeners.Normal.Add(etype, fun)
}

// OnFirst adds the given event handler to the [WidgetBase.Listeners.First] for the given
// event type. FirstListeners are called in sequential descending order, so this first
// listener will be called before all of the ones added before it. OnFirst is one of the
// main ways to add an event handler to a widget, in addition to On and OnFinal,
// which add event handlers that are called after those added by this function.
func (wb *WidgetBase) OnFirst(etype events.Types, fun func(e events.Event)) {
        wb.Listeners.First.Add(etype, fun)
}

// OnFinal adds the given event handler to the [WidgetBase.Listeners.Final] for the given
// event type. FinalListeners are called in sequential descending order, so this final
// listener will be called before all of the ones added before it. OnFinal is one of the
// main ways to add an event handler to a widget, in addition to OnFirst and On,
// which add event handlers that are called before those added by this function.
func (wb *WidgetBase) OnFinal(etype events.Types, fun func(e events.Event)) {
        wb.Listeners.Final.Add(etype, fun)
}

// Helper functions for common event types:

// OnClick adds an event listener function for [events.Click] events.
func (wb *WidgetBase) OnClick(fun func(e events.Event)) {
        wb.On(events.Click, fun)
}

// OnDoubleClick adds an event listener function for [events.DoubleClick] events.
func (wb *WidgetBase) OnDoubleClick(fun func(e events.Event)) {
        wb.On(events.DoubleClick, fun)
}

// OnChange adds an event listener function for [events.Change] events.
func (wb *WidgetBase) OnChange(fun func(e events.Event)) {
        wb.On(events.Change, fun)
}

// OnInput adds an event listener function for [events.Input] events.
func (wb *WidgetBase) OnInput(fun func(e events.Event)) {
        wb.On(events.Input, fun)
}

// OnKeyChord adds an event listener function for [events.KeyChord] events.
func (wb *WidgetBase) OnKeyChord(fun func(e events.Event)) {
        wb.On(events.KeyChord, fun)
}

// OnFocus adds an event listener function for [events.Focus] events.
func (wb *WidgetBase) OnFocus(fun func(e events.Event)) {
        wb.On(events.Focus, fun)
}

// OnFocusLost adds an event listener function for [events.FocusLost] events.
func (wb *WidgetBase) OnFocusLost(fun func(e events.Event)) {
        wb.On(events.FocusLost, fun)
}

// OnSelect adds an event listener function for [events.Select] events.
func (wb *WidgetBase) OnSelect(fun func(e events.Event)) {
        wb.On(events.Select, fun)
}

// OnShow adds an event listener function for [events.Show] events.
func (wb *WidgetBase) OnShow(fun func(e events.Event)) {
        wb.On(events.Show, fun)
}

// OnClose adds an event listener function for [events.Close] events.
func (wb *WidgetBase) OnClose(fun func(e events.Event)) {
        wb.On(events.Close, fun)
}

// AddCloseDialog adds a dialog that confirms that the user wants to close the Scene
// associated with this widget when they try to close it. It calls the given config
// function to configure the dialog. It is the responsibility of this config function
// to add the title and close button to the dialog, which is necessary so that the close
// dialog can be fully customized. If this function returns false, it does not make the
// dialog. This can be used to make the dialog conditional on other things, like whether
// something is saved.
func (wb *WidgetBase) AddCloseDialog(config func(d *Body) bool) {
        var inClose, canClose bool
        wb.OnClose(func(e events.Event) {
                if canClose {
                        return // let it close
                }
                if inClose {
                        e.SetHandled()
                        return
                }
                inClose = true
                d := NewBody()
                d.AddBottomBar(func(bar *Frame) {
                        d.AddCancel(bar).OnClick(func(e events.Event) {
                                inClose = false
                                canClose = false
                        })
                        bar.AsWidget().SetOnChildAdded(func(n tree.Node) {
                                if bt := AsButton(n); bt != nil {
                                        bt.OnFirst(events.Click, func(e events.Event) {
                                                // any button click gives us permission to close
                                                canClose = true
                                        })
                                }
                        })
                })
                if !config(d) {
                        return
                }
                e.SetHandled()
                d.RunDialog(wb)
        })
}

// Send sends an new event of the given type to this widget,
// optionally starting from values in the given original event
// (recommended to include where possible).
// Do not send an existing event using this method if you
// want the Handled state to persist throughout the call chain;
// call HandleEvent directly for any existing events.
func (wb *WidgetBase) Send(typ events.Types, original ...events.Event) {
        if wb.This == nil {
                return
        }
        if typ == events.Click {
                em := wb.Events()
                if em != nil && em.focus != wb.This.(Widget) {
                        // always clear any other focus before the click is processed.
                        // this causes textfields etc to apply their changes.
                        em.focusClear()
                }
        }
        var e events.Event
        if len(original) > 0 && original[0] != nil {
                e = original[0].NewFromClone(typ)
        } else {
                e = &events.Base{Typ: typ}
                e.Init()
        }
        wb.HandleEvent(e)
}

// SendChange sends a new [events.Change] event, which is widely used to signal
// value changing for most widgets. It takes the event that the new change event
// is derived from, if any.
func (wb *WidgetBase) SendChange(original ...events.Event) {
        wb.Send(events.Change, original...)
}

// UpdateChange is a helper function that calls [WidgetBase.SendChange]
// and then [WidgetBase.Update]. That is the correct order, since
// calling [WidgetBase.Update] first would cause the value of the widget
// to be incorrectly overridden in a [Value] context.
func (wb *WidgetBase) UpdateChange(original ...events.Event) {
        wb.SendChange(original...)
        wb.Update()
}

func (wb *WidgetBase) sendKey(kf keymap.Functions, original ...events.Event) {
        if wb.This == nil {
                return
        }
        kc := kf.Chord()
        wb.sendKeyChord(kc, original...)
}

func (wb *WidgetBase) sendKeyChord(kc key.Chord, original ...events.Event) {
        r, code, mods, err := kc.Decode()
        if err != nil {
                fmt.Println("SendKeyChord: Decode error:", err)
                return
        }
        wb.sendKeyChordRune(r, code, mods, original...)
}

func (wb *WidgetBase) sendKeyChordRune(r rune, code key.Codes, mods key.Modifiers, original ...events.Event) {
        ke := events.NewKey(events.KeyChord, r, code, mods)
        if len(original) > 0 && original[0] != nil {
                kb := *original[0].AsBase()
                ke.GenTime = kb.GenTime
                ke.ClearHandled()
        } else {
                ke.Init()
        }
        ke.Typ = events.KeyChord
        wb.HandleEvent(ke)
}

// HandleEvent sends the given event to all [WidgetBase.Listeners] for that event type.
// It also checks if the State has changed and calls [WidgetBase.Restyle] if so.
func (wb *WidgetBase) HandleEvent(e events.Event) {
        if DebugSettings.EventTrace {
                if e.Type() != events.MouseMove {
                        fmt.Println(e, "to", wb)
                }
        }
        if wb == nil || wb.This == nil {
                return
        }
        s := &wb.Styles
        state := s.State

        wb.Listeners.Do(func(l events.Listeners) {
                l.Call(e, func() bool {
                        return wb.This != nil
                })
        })

        if s.State != state && !(e.Type() == events.Attend || e.Type() == events.AttendLost) {
                wb.Restyle()
        }
}

// firstHandleEvent sends the given event to the Listeners.First for that event type.
// Does NOT do any state updating.
func (wb *WidgetBase) firstHandleEvent(e events.Event) {
        if DebugSettings.EventTrace {
                if e.Type() != events.MouseMove {
                        fmt.Println(e, "first to", wb)
                }
        }
        wb.Listeners.First.Call(e, func() bool {
                return wb.This != nil
        })
}

// finalHandleEvent sends the given event to the Listeners.Final for that event type.
// Does NOT do any state updating.
func (wb *WidgetBase) finalHandleEvent(e events.Event) {
        if DebugSettings.EventTrace {
                if e.Type() != events.MouseMove {
                        fmt.Println(e, "final to", wb)
                }
        }
        wb.Listeners.Final.Call(e, func() bool {
                return wb.This != nil
        })
}

// posInScBBox returns true if given position is within
// this node's scene bbox
func (wb *WidgetBase) posInScBBox(pos image.Point) bool {
        return pos.In(wb.Geom.TotalBBox)
}

// handleWidgetClick handles the Click event for basic Widget behavior.
// For Left button:
// If Checkable, toggles Checked. if Focusable, Focuses or clears,
// If Selectable, updates state and sends Select, Deselect.
func (wb *WidgetBase) handleWidgetClick() {
        wb.OnClick(func(e events.Event) {
                if wb.AbilityIs(abilities.Checkable) && !wb.IsReadOnly() {
                        wb.SetState(!wb.StateIs(states.Checked), states.Checked)
                }
                if wb.AbilityIs(abilities.Focusable) {
                        wb.SetFocusQuiet()
                } else {
                        wb.focusClear()
                }
                // note: read only widgets are automatically selectable
                if wb.AbilityIs(abilities.Selectable) || wb.IsReadOnly() {
                        wb.Send(events.Select, e)
                }
        })
}

// handleWidgetStateFromMouse updates all standard
// State flags based on mouse events,
// such as MouseDown / Up -> Active and MouseEnter / Leave -> Hovered.
// None of these "consume" the event by setting Handled flag, as they are
// designed to work in conjunction with more specific handlers.
// Note that Disabled and Invisible widgets do NOT receive
// these events so it is not necessary to check that.
func (wb *WidgetBase) handleWidgetStateFromMouse() {
        wb.On(events.MouseDown, func(e events.Event) {
                if wb.AbilityIs(abilities.Activatable) {
                        wb.SetState(true, states.Active)
                }
        })
        wb.On(events.MouseUp, func(e events.Event) {
                if wb.AbilityIs(abilities.Activatable) {
                        wb.SetState(false, states.Active)
                }
        })
        wb.On(events.LongPressStart, func(e events.Event) {
                if wb.AbilityIs(abilities.LongPressable) {
                        wb.SetState(true, states.LongPressed)
                }
        })
        wb.On(events.LongPressEnd, func(e events.Event) {
                if wb.AbilityIs(abilities.LongPressable) {
                        wb.SetState(false, states.LongPressed)
                }
        })
        wb.On(events.MouseEnter, func(e events.Event) {
                if wb.AbilityIs(abilities.Hoverable) {
                        wb.SetState(true, states.Hovered)
                }
        })
        wb.On(events.MouseLeave, func(e events.Event) {
                if wb.AbilityIs(abilities.Hoverable) {
                        wb.SetState(false, states.Hovered)
                }
        })
        wb.On(events.LongHoverStart, func(e events.Event) {
                if wb.AbilityIs(abilities.LongHoverable) {
                        wb.SetState(true, states.LongHovered)
                }
        })
        wb.On(events.LongHoverEnd, func(e events.Event) {
                if wb.AbilityIs(abilities.LongHoverable) {
                        wb.SetState(false, states.LongHovered)
                }
        })
        wb.On(events.SlideStart, func(e events.Event) {
                if wb.AbilityIs(abilities.Slideable) {
                        wb.SetState(true, states.Sliding)
                }
        })
        wb.On(events.SlideStop, func(e events.Event) {
                if wb.AbilityIs(abilities.Slideable) {
                        wb.SetState(false, states.Sliding, states.Active)
                }
        })
}

// handleLongHoverTooltip listens for LongHover and LongPress events and
// pops up and deletes tooltips based on those. Most widgets should call
// this as part of their event handler methods.
func (wb *WidgetBase) handleLongHoverTooltip() {
        wb.On(events.LongHoverStart, func(e events.Event) {
                wi := wb.This.(Widget)
                tt, pos := wi.WidgetTooltip(e.Pos())
                if tt == "" {
                        return
                }
                e.SetHandled()
                newTooltip(wi, tt, pos).Run()
        })
        wb.On(events.LongHoverEnd, func(e events.Event) {
                if wb.Scene.Stage != nil {
                        wb.Scene.Stage.popups.popDeleteType(TooltipStage)
                }
        })

        wb.On(events.LongPressStart, func(e events.Event) {
                if !TheApp.SystemPlatform().IsMobile() {
                        return
                }

                wb.Send(events.ContextMenu, e)
                wi := wb.This.(Widget)
                tt, pos := wi.WidgetTooltip(e.Pos())
                if tt == "" {
                        return
                }
                e.SetHandled()
                newTooltip(wi, tt, pos).Run()
        })
        wb.On(events.LongPressEnd, func(e events.Event) {
                if !TheApp.SystemPlatform().IsMobile() {
                        return
                }

                if wb.Scene.Stage != nil {
                        wb.Scene.Stage.popups.popDeleteType(TooltipStage)
                }
        })
}

// handleWidgetStateFromFocus updates standard State flags based on Focus events
func (wb *WidgetBase) handleWidgetStateFromFocus() {
        wb.OnFocus(func(e events.Event) {
                if wb.AbilityIs(abilities.Focusable) {
                        wb.ScrollToThis()
                        wb.SetState(true, states.Focused)
                        if !wb.IsReadOnly() && wb.Styles.VirtualKeyboard != styles.KeyboardNone {
                                TheApp.ShowVirtualKeyboard(wb.Styles.VirtualKeyboard)
                        }
                }
        })
        wb.OnFocusLost(func(e events.Event) {
                if wb.AbilityIs(abilities.Focusable) {
                        wb.SetState(false, states.Focused)
                        if !wb.IsReadOnly() && wb.Styles.VirtualKeyboard != styles.KeyboardNone {
                                TheApp.HideVirtualKeyboard()
                        }
                }
        })
}

// handleWidgetStateFromAttend updates standard State flags based on Attend events
func (wb *WidgetBase) handleWidgetStateFromAttend() {
        wb.On(events.Attend, func(e events.Event) {
                if wb.Styles.Abilities.IsPressable() {
                        wb.SetState(true, states.Attended)
                }
        })
        wb.On(events.AttendLost, func(e events.Event) {
                if wb.Styles.Abilities.IsPressable() {
                        wb.SetState(false, states.Attended)
                }
        })
}

// HandleWidgetMagnifyEvent calls [renderWindow.stepZoom] on [events.Magnify]
func (wb *WidgetBase) handleWidgetMagnify() {
        wb.On(events.Magnify, func(e events.Event) {
                ev := e.(*events.TouchMagnify)
                wb.Events().RenderWindow().stepZoom(ev.ScaleFactor - 1)
        })
}

// handleValueOnChange adds a handler that calls [WidgetBase.ValueOnChange].
func (wb *WidgetBase) handleValueOnChange() {
        // need to go before end-user OnChange handlers
        wb.OnFirst(events.Change, func(e events.Event) {
                if wb.ValueOnChange != nil {
                        wb.ValueOnChange()
                }
        })
}

// SendChangeOnInput adds an event handler that does [WidgetBase.SendChange]
// in [WidgetBase.OnInput]. This is not done by default, but you can call it
// if you want [events.Input] to trigger full change events, such as in a [Bind]
// context.
func (wb *WidgetBase) SendChangeOnInput() {
        wb.OnInput(func(e events.Event) {
                wb.SendChange(e)
        })
}

// SendClickOnEnter adds a key event handler for Enter and Space
// keys to generate an [events.Click] event. This is not added by default,
// but is added in [Button] and [Switch] for example.
func (wb *WidgetBase) SendClickOnEnter() {
        wb.OnKeyChord(func(e events.Event) {
                kf := keymap.Of(e.KeyChord())
                if DebugSettings.KeyEventTrace {
                        slog.Info("WidgetBase.SendClickOnEnter", "widget", wb, "keyFunction", kf)
                }
                if kf == keymap.Accept {
                        wb.Send(events.Click, e) // don't SetHandled
                } else if kf == keymap.Enter || e.KeyRune() == ' ' {
                        e.SetHandled()
                        wb.Send(events.Click, e)
                }
        })
}

// dragStateReset resets the drag related state flags, including [states.Active].
func (wb *WidgetBase) dragStateReset() {
        wb.SetState(false, states.Active, states.DragHovered, states.Dragging)
}

////////        Focus

// SetFocusQuiet sets the keyboard input focus on this item or the first item
// within it that can be focused (if none, then just sets focus to this widget).
// This does NOT send an [events.Focus] event, so the widget will NOT appear focused;
// it will however receive keyboard input, at which point it will get visible focus.
// See [WidgetBase.SetFocus] for a version that sends an event. Also see
// [WidgetBase.StartFocus].
func (wb *WidgetBase) SetFocusQuiet() {
        foc := wb.This.(Widget)
        if !wb.AbilityIs(abilities.Focusable) {
                foc = wb.focusableInThis()
                if foc == nil {
                        foc = wb.This.(Widget)
                }
        }
        em := wb.Events()
        if em != nil {
                em.setFocusQuiet(foc) // doesn't send event
        }
}

// SetFocus sets the keyboard input focus on this item or the first item within it
// that can be focused (if none, then just sets focus to this widget).
// This sends an [events.Focus] event, which typically results in
// the widget being styled as focused. See [WidgetBase.SetFocusQuiet] for
// a version that does not. Also see [WidgetBase.StartFocus].
//
// SetFocus only fully works for widgets that have already been shown, so for newly
// created widgets, you should use [WidgetBase.StartFocus], or [WidgetBase.Defer] your
// SetFocus call.
func (wb *WidgetBase) SetFocus() {
        foc := wb.This.(Widget)
        if !wb.AbilityIs(abilities.Focusable) {
                foc = wb.focusableInThis()
                if foc == nil {
                        foc = wb.This.(Widget)
                }
        }
        em := wb.Events()
        if em != nil {
                em.setFocus(foc)
        }
}

// focusableInThis returns the first Focusable element within this widget
func (wb *WidgetBase) focusableInThis() Widget {
        var foc Widget
        wb.WidgetWalkDown(func(cw Widget, cwb *WidgetBase) bool {
                if !cwb.AbilityIs(abilities.Focusable) {
                        return tree.Continue
                }
                foc = cw
                return tree.Break // done
        })
        return foc
}

// focusNext moves the focus onto the next item
func (wb *WidgetBase) focusNext() {
        em := wb.Events()
        if em != nil {
                em.focusNext()
        }
}

// focusPrev moves the focus onto the previous item
func (wb *WidgetBase) focusPrev() {
        em := wb.Events()
        if em != nil {
                em.focusPrev()
        }
}

// focusClear resets focus to nil, but keeps the previous focus to pick up next time..
func (wb *WidgetBase) focusClear() {
        em := wb.Events()
        if em != nil {
                em.focusClear()
        }
}

// StartFocus specifies that this widget should get focus when the [Scene] is shown,
// or when a major content managing widget (e.g., [Tabs], [Pages]) shows a
// tab/page/element that contains this widget. This is implemented via an
// [events.Show] event.
func (wb *WidgetBase) StartFocus() {
        em := wb.Events()
        if em != nil {
                em.SetStartFocus(wb.This.(Widget))
        }
}

// ContainsFocus returns whether this widget contains the current focus widget.
func (wb *WidgetBase) ContainsFocus() bool {
        em := wb.Events()
        if em == nil {
                return false
        }
        cur := em.focus
        if cur == nil {
                return false
        }
        if cur.AsTree().This == wb.This {
                return true
        }
        plev := cur.AsTree().ParentLevel(wb.This)
        return plev >= 0
}

// SetAttend sends [events.Attend] to this widget if it is pressable.
func (wb *WidgetBase) SetAttend() {
        if !wb.Styles.Abilities.IsPressable() {
                return
        }
        em := wb.Events()
        if em != nil {
                em.setAttend(wb.This.(Widget))
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "encoding/json"
        "fmt"
        "image"
        "log"
        "maps"
        "os"
        "path/filepath"
        "slices"
        "strings"
        "sync"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/system"
)

var (
        // theWindowGeometrySaver is the manager of window geometry settings
        theWindowGeometrySaver = windowGeometrySaver{}
)

// screenConfigGeometries has the window geometry data for different
// screen configurations, where a screen configuration is a specific
// set of available screens, naturally corresponding to the
// home vs. office vs. travel usage of a laptop, for example,
// with different sets of screens available in each location.
// Each such configuration has a different set of saved window geometries,
// which is restored when the set of screens changes, so your windows will
// be restored to their last positions and sizes for each such configuration.
type screenConfigGeometries map[string]map[string]windowGeometries

// screenConfig returns the current screen configuration string,
// which is the alpha-sorted list of current screen names.
func screenConfig() string {
        ns := TheApp.NScreens()
        if ns == 0 {
                return "none"
        }
        scs := make([]string, ns)
        for i := range ns {
                scs[i] = TheApp.Screen(i).Name
        }
        slices.Sort(scs)
        return strings.Join(scs, "|")
}

// windowGeometrySaver records window geometries in a persistent file,
// which is then used when opening new windows to restore.
type windowGeometrySaver struct {

        // the full set of window geometries
        geometries screenConfigGeometries

        // temporary cached geometries: saved to geometries after SaveDelay
        cache screenConfigGeometries

        // base name of the settings file in Cogent Core settings directory
        filename string

        // when settings were last saved: if we weren't the last to save,
        // then we need to re-open before modifying.
        lastSave time.Time

        // if true, we are setting geometry so don't save;
        // Caller must call SettingStart() SettingEnd() to block.
        settingNoSave bool

        // read-write mutex that protects updating of WindowGeometry
        mu sync.RWMutex

        // wait time before trying to lock file again
        lockSleep time.Duration

        // wait time before saving the Cache into Geometries
        saveDelay time.Duration

        // timer for delayed save
        saveTimer *time.Timer
}

// init does initialization if not yet initialized
func (ws *windowGeometrySaver) init() {
        if ws.geometries == nil {
                ws.geometries = make(screenConfigGeometries)
                ws.resetCache()
                ws.filename = "window-geometry-0.3.6"
                ws.lockSleep = 100 * time.Millisecond
                ws.saveDelay = 1 * time.Second
        }
}

// shouldSave returns whether the window geometry should be saved based on
// the platform: only for desktop native platforms.
func (ws *windowGeometrySaver) shouldSave() bool {
        return !TheApp.Platform().IsMobile() && TheApp.Platform() != system.Offscreen && !DebugSettings.DisableWindowGeometrySaver
}

// resetCache resets the cache; call under mutex
func (ws *windowGeometrySaver) resetCache() {
        ws.cache = make(screenConfigGeometries)
}

// lockFile attempts to create the window geometry lock file
func (ws *windowGeometrySaver) lockFile() error {
        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, ws.filename+".lck")
        for rep := 0; rep < 10; rep++ {
                if _, err := os.Stat(pnm); os.IsNotExist(err) {
                        b, _ := time.Now().MarshalJSON()
                        err = os.WriteFile(pnm, b, 0644)
                        if err == nil {
                                return nil
                        }
                }
                b, err := os.ReadFile(pnm)
                if err != nil {
                        time.Sleep(ws.lockSleep)
                        continue
                }
                var lts time.Time
                err = lts.UnmarshalJSON(b)
                if err != nil {
                        time.Sleep(ws.lockSleep)
                        continue
                }
                if time.Since(lts) > 1*time.Second {
                        // log.Printf("WindowGeometry: lock file stale: %v\n", lts.String())
                        os.Remove(pnm)
                        continue
                }
                // log.Printf("WindowGeometry: waiting for lock file: %v\n", lts.String())
                time.Sleep(ws.lockSleep)
        }
        return errors.New("WinGeom could not lock lock file")
}

// UnLockFile unlocks the window geometry lock file (just removes it)
func (ws *windowGeometrySaver) unlockFile() {
        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, ws.filename+".lck")
        os.Remove(pnm)
}

// needToReload returns true if the last save time of settings file is more recent than
// when we last saved.  Called under mutex.
func (ws *windowGeometrySaver) needToReload() bool {
        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, ws.filename+".lst")
        if _, err := os.Stat(pnm); os.IsNotExist(err) {
                return false
        }
        var lts time.Time
        b, err := os.ReadFile(pnm)
        if err != nil {
                return false
        }
        err = lts.UnmarshalJSON(b)
        if err != nil {
                return false
        }
        eq := lts.Equal(ws.lastSave)
        if !eq {
                // fmt.Printf("settings file saved more recently: %v than our last save: %v\n", lts.String(),
                //         mgr.LastSave.String())
                ws.lastSave = lts
        }
        return !eq
}

// saveLastSave saves timestamp (now) of last save to win geom
func (ws *windowGeometrySaver) saveLastSave() {
        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, ws.filename+".lst")
        ws.lastSave = time.Now()
        b, _ := ws.lastSave.MarshalJSON()
        os.WriteFile(pnm, b, 0644)
}

// open RenderWindow Geom settings from Cogent Core standard settings directory
// called under mutex or at start
func (ws *windowGeometrySaver) open() error {
        ws.init()
        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, ws.filename+".json")
        b, err := os.ReadFile(pnm)
        if err != nil {
                return err
        }
        return json.Unmarshal(b, &ws.geometries)
}

// save RenderWindow Geom Settings to Cogent Core standard prefs directory
// assumed to be under mutex and lock still
func (ws *windowGeometrySaver) save() error {
        if ws.geometries == nil {
                return nil
        }
        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, ws.filename+".json")
        b, err := json.Marshal(ws.geometries)
        if errors.Log(err) != nil {
                return err
        }
        err = os.WriteFile(pnm, b, 0644)
        if errors.Log(err) == nil {
                ws.saveLastSave()
        }
        return err
}

// windowName returns window name before first colon, if exists.
// This is the part of the name used to record settings
func (ws *windowGeometrySaver) windowName(winName string) string {
        if ci := strings.Index(winName, ":"); ci > 0 {
                return winName[:ci]
        }
        return winName
}

// settingStart turns on SettingNoSave to prevent subsequent redundant calls to
// save a geometry that was being set from already-saved settings.
// Must call SettingEnd to turn off (safe to call even if Start not called).
func (ws *windowGeometrySaver) settingStart() {
        ws.mu.Lock()
        ws.resetCache() // get rid of anything just saved prior to this -- sus.
        ws.settingNoSave = true
        ws.mu.Unlock()
}

// settingEnd turns off SettingNoSave -- safe to call even if Start not called.
func (ws *windowGeometrySaver) settingEnd() {
        ws.mu.Lock()
        ws.settingNoSave = false
        ws.mu.Unlock()
}

// record records current state of window as preference
func (ws *windowGeometrySaver) record(win *renderWindow) {
        if !ws.shouldSave() || !win.isVisible() || win.SystemWindow.Is(system.Fullscreen) {
                return
        }
        win.SystemWindow.Lock()
        wsz := win.SystemWindow.Size()
        win.SystemWindow.Unlock()
        if wsz == (image.Point{}) {
                if DebugSettings.WindowGeometryTrace {
                        log.Printf("WindowGeometry: Record: NOT storing null size for win: %v\n", win.name)
                }
                return
        }
        sc := win.SystemWindow.Screen()
        pos := win.SystemWindow.Position(sc)
        if TheApp.Platform() == system.Windows && pos.X == -32000 || pos.Y == -32000 { // windows badness
                if DebugSettings.WindowGeometryTrace {
                        log.Printf("WindowGeometry: Record: NOT storing very negative pos: %v for win: %v\n", pos, win.name)
                }
                return
        }
        ws.mu.Lock()
        if ws.settingNoSave {
                if DebugSettings.WindowGeometryTrace {
                        log.Printf("WindowGeometry: Record: SettingNoSave so NOT storing for win: %v\n", win.name)
                }
                ws.mu.Unlock()
                return
        }
        ws.init()

        cfg := screenConfig()
        winName := ws.windowName(win.title)
        wgr := windowGeometry{DPI: win.logicalDPI(), DPR: sc.DevicePixelRatio, Max: win.SystemWindow.Is(system.Maximized)}
        wgr.Pos = pos
        wgr.Size = wsz

        // first get copy of stored data
        sgs := ws.geometries[cfg]
        if sgs == nil {
                sgs = make(map[string]windowGeometries)
        }
        var wgs windowGeometries
        if swgs, ok := sgs[winName]; ok {
                wgs.Last = swgs.Last
                wgs.Screens = maps.Clone(swgs.Screens)
        } else {
                wgs.Screens = make(map[string]windowGeometry)
        }

        // then look for current cache data
        sgsc := ws.cache[cfg]
        if sgsc == nil {
                sgsc = make(map[string]windowGeometries)
        }
        wgsc, hasCache := sgsc[winName]
        if hasCache {
                wgs.Last = wgsc.Last
                for k, v := range wgsc.Screens {
                        wgs.Screens[k] = v
                }
        }
        wgs.Screens[sc.Name] = wgr
        wgs.Last = sc.Name
        sgsc[winName] = wgs
        ws.cache[cfg] = sgsc

        if DebugSettings.WindowGeometryTrace {
                log.Printf("WindowGeometry: Record win: %q screen: %q cfg: %q geom: %s", winName, sc.Name, cfg, wgr.String())
        }

        if ws.saveTimer == nil {
                ws.saveTimer = time.AfterFunc(time.Duration(ws.saveDelay), func() {
                        ws.mu.Lock()
                        ws.saveCached()
                        ws.saveTimer = nil
                        ws.mu.Unlock()
                })
        }
        ws.mu.Unlock()
}

// saveCached saves the cached prefs -- called after timer delay,
// under the Mu.Lock
func (ws *windowGeometrySaver) saveCached() {
        ws.lockFile() // not going to change our behavior if we can't lock!
        if ws.needToReload() {
                ws.open()
        }
        if DebugSettings.WindowGeometryTrace {
                log.Println("WindowGeometry: saveCached")
        }
        for cfg, sgsc := range ws.cache {
                for winName, wgs := range sgsc {
                        sg := ws.geometries[cfg]
                        if sg == nil {
                                sg = make(map[string]windowGeometries)
                        }
                        sg[winName] = wgs
                        ws.geometries[cfg] = sg
                }
        }
        ws.resetCache()
        ws.save()
        ws.unlockFile()
}

// get returns saved geometry for given window name, returning
// nil if there is no saved info. The last saved screen is used
// if it is currently available (connected); otherwise the given screen
// name is used if non-empty; otherwise the default screen 0 is used.
// If no saved info is found for any active screen, nil is returned.
// The screen used for the preferences is returned, and should be used
// to set the screen for a new window.
// If the window name has a colon, only the part prior to the colon is used.
func (ws *windowGeometrySaver) get(winName, screenName string) (*windowGeometry, *system.Screen) {
        if !ws.shouldSave() {
                return nil, nil
        }
        ws.mu.RLock()
        defer ws.mu.RUnlock()

        cfg := screenConfig()
        winName = ws.windowName(winName)
        var wgs windowGeometries

        fromMain := false
        sgs := ws.cache[cfg]
        ok := false
        if sgs != nil {
                wgs, ok = sgs[winName]
        }
        if !ok {
                sgs, ok = ws.geometries[cfg]
                if !ok {
                        return nil, nil
                }
                wgs, ok = sgs[winName]
                fromMain = true
        }
        if !ok {
                return nil, nil
        }
        wgr, sc := wgs.getForScreen(screenName)
        if wgr != nil {
                wgr.constrainGeom(sc)
                if DebugSettings.WindowGeometryTrace {
                        log.Printf("WindowGeometry: Got geom for window: %q screen: %q lastScreen: %q cfg: %q geom: %s fromMain: %v\n", winName, sc.Name, wgs.Last, cfg, wgr.String(), fromMain)
                }
                return wgr, sc
        }
        return nil, nil
}

// deleteAll deletes the file that saves the position and size of each window,
// by screen, and clear current in-memory cache.  You shouldn't need to use
// this but sometimes useful for testing.
func (ws *windowGeometrySaver) deleteAll() {
        ws.mu.Lock()
        defer ws.mu.Unlock()

        pdir := TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, ws.filename+".json")
        errors.Log(os.Remove(pnm))
        ws.geometries = make(screenConfigGeometries)
}

// restoreAll restores size and position of all windows, for current screen.
// Called when screen changes.
func (ws *windowGeometrySaver) restoreAll() {
        if !ws.shouldSave() {
                return
        }
        renderWindowGlobalMu.Lock()
        defer renderWindowGlobalMu.Unlock()
        if DebugSettings.WindowGeometryTrace {
                log.Printf("WindowGeometry: RestoreAll: starting\n")
        }
        ws.settingStart()
        for _, w := range AllRenderWindows {
                wgp, sc := ws.get(w.title, "")
                if wgp != nil && !w.SystemWindow.Is(system.Fullscreen) {
                        if DebugSettings.WindowGeometryTrace {
                                log.Printf("WindowGeometry: RestoreAll: restoring geom for window: %v screen: %s geom: %s\n", w.name, sc.Name, wgp.String())
                        }
                        w.SystemWindow.SetGeometry(false, wgp.Pos, wgp.Size, sc)
                }
        }
        ws.settingEnd()
        if DebugSettings.WindowGeometryTrace {
                log.Printf("WindowGeometry: RestoreAll: done\n")
        }
}

// windowGeometries holds the window geometries for a given window
// across different screens, and the last screen used.
type windowGeometries struct {
        Last    string                    // Last screen
        Screens map[string]windowGeometry // Screen map
}

// getForScreen returns saved geometry for an active (connected) Screen,
// searching in order of: last screen saved, given screen name, and then
// going through the list of available screens in order.
// returns nil if no saved geometry info is available for any active screen.
func (wgs *windowGeometries) getForScreen(screenName string) (*windowGeometry, *system.Screen) {
        sc := TheApp.ScreenByName(wgs.Last)
        if sc != nil {
                wgr := wgs.Screens[wgs.Last]
                return &wgr, sc
        }
        sc = TheApp.ScreenByName(screenName)
        if sc != nil {
                if wgr, ok := wgs.Screens[screenName]; ok {
                        return &wgr, sc
                }
        }
        ns := TheApp.NScreens()
        for i := range ns {
                sc = TheApp.Screen(i)
                if wgr, ok := wgs.Screens[sc.Name]; ok {
                        return &wgr, sc
                }
        }
        return nil, nil
}

// windowGeometry records the geometry settings used for
// a certain screen and window pair.
type windowGeometry struct {
        DPI  float32
        DPR  float32 // Device Pixel Ratio
        Size image.Point
        Pos  image.Point
        Max  bool // Maximized
}

func (wg *windowGeometry) String() string {
        return fmt.Sprintf("DPI: %g  DPR: %g  Size: %v  Pos: %v  Max: %v", wg.DPI, wg.DPR, wg.Size, wg.Pos, wg.Max)
}

// constrainGeom constrains geometry based on screen params
func (wg *windowGeometry) constrainGeom(sc *system.Screen) {
        wg.Pos, wg.Size = sc.ConstrainWindowGeometry(wg.Pos, wg.Size)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package core

import (
        "fmt"
        "reflect"
        "slices"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/system"
)

// renderWindowList is a list of [renderWindow]s.
type renderWindowList []*renderWindow

// add adds a window to the list.
func (wl *renderWindowList) add(w *renderWindow) {
        renderWindowGlobalMu.Lock()
        *wl = append(*wl, w)
        renderWindowGlobalMu.Unlock()
}

// delete removes a window from the list.
func (wl *renderWindowList) delete(w *renderWindow) {
        renderWindowGlobalMu.Lock()
        defer renderWindowGlobalMu.Unlock()
        *wl = slices.DeleteFunc(*wl, func(rw *renderWindow) bool {
                return rw == w
        })
}

// FindName finds the window with the given name or title
// on the list (case sensitive).
// It returns the window if found and nil otherwise.
func (wl *renderWindowList) FindName(name string) *renderWindow {
        renderWindowGlobalMu.Lock()
        defer renderWindowGlobalMu.Unlock()
        for _, w := range *wl {
                if w.name == name || w.title == name {
                        return w
                }
        }
        return nil
}

// findData finds window with given Data on list -- returns
// window and true if found, nil, false otherwise.
// data of type string works fine -- does equality comparison on string contents.
func (wl *renderWindowList) findData(data any) (*renderWindow, bool) {
        if reflectx.IsNil(reflect.ValueOf(data)) {
                return nil, false
        }
        typ := reflect.TypeOf(data)
        if !typ.Comparable() {
                fmt.Printf("programmer error in RenderWinList.FindData: Scene.Data type %s not comparable (value: %v)\n", typ.String(), data)
                return nil, false
        }
        renderWindowGlobalMu.Lock()
        defer renderWindowGlobalMu.Unlock()
        for _, wi := range *wl {
                msc := wi.MainScene()
                if msc == nil {
                        continue
                }
                if msc.Data == data {
                        return wi, true
                }
        }
        return nil, false
}

// focused returns the (first) window in this list that has the WinGotFocus flag set
// and the index in the list (nil, -1 if not present)
func (wl *renderWindowList) focused() (*renderWindow, int) {
        renderWindowGlobalMu.Lock()
        defer renderWindowGlobalMu.Unlock()

        for i, fw := range *wl {
                if fw.flags.HasFlag(winGotFocus) {
                        return fw, i
                }
        }
        return nil, -1
}

// focusNext focuses on the next window in the list, after the current Focused() one.
// It skips minimized windows.
func (wl *renderWindowList) focusNext() (*renderWindow, int) {
        fw, i := wl.focused()
        if fw == nil {
                return nil, -1
        }
        renderWindowGlobalMu.Lock()
        defer renderWindowGlobalMu.Unlock()
        sz := len(*wl)
        if sz == 1 {
                return nil, -1
        }

        for j := 0; j < sz-1; j++ {
                if i == sz-1 {
                        i = 0
                } else {
                        i++
                }
                fw = (*wl)[i]
                if !fw.SystemWindow.Is(system.Minimized) {
                        fw.SystemWindow.Raise()
                        break
                }
        }
        return fw, i
}

// AllRenderWindows is the list of all [renderWindow]s that have been created
// (dialogs, main windows, etc).
var AllRenderWindows renderWindowList

// dialogRenderWindows is the list of only dialog [renderWindow]s that
// have been created.
var dialogRenderWindows renderWindowList

// mainRenderWindows is the list of main [renderWindow]s (non-dialogs) that
// have been created.
var mainRenderWindows renderWindowList

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package cursorimg provides the cached rendering of SVG cursors to images.
package cursorimg

import (
        "bytes"
        "fmt"
        "image"
        "image/draw"
        _ "image/png"
        "io/fs"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/pimage"
        "cogentcore.org/core/svg"
)

// Cursor represents a cached rendered cursor, with the [image.Image]
// of the cursor and its hotspot.
type Cursor struct {
        // The cached image of the cursor.
        Image image.Image
        // The size of the cursor.
        Size int
        // The hotspot is expressed in terms of raw cursor pixels.
        Hotspot image.Point
}

// Cursors contains all of the cached rendered cursors, specified first
// by cursor enum and then by size.
var Cursors = map[enums.Enum]map[int]*Cursor{}

// Get returns the cursor object corresponding to the given cursor enum,
// with the given size. If it is not already cached in [Cursors], it renders and caches it.
//
// It automatically replaces literal colors in svg with appropriate scheme colors as follows:
//   - #fff: [colors.Palette].Neutral.ToneUniform(100)
//   - #000: [colors.Palette].Neutral.ToneUniform(0)
//   - #f00: [colors.Scheme].Error.Base
//   - #0f0: [colors.Scheme].Success.Base
//   - #ff0: [colors.Scheme].Warn.Base
func Get(cursor enums.Enum, size int) (*Cursor, error) {
        sm := Cursors[cursor]
        if sm == nil {
                sm = map[int]*Cursor{}
                Cursors[cursor] = sm
        }
        if c, ok := sm[size]; ok {
                return c, nil
        }

        name := cursor.String()
        hot, ok := cursors.Hotspots[cursor]
        if !ok {
                hot = image.Pt(128, 128)
        }

        sv := svg.NewSVG(math32.Vec2(float32(size), float32(size)))
        b, err := fs.ReadFile(cursors.Cursors, "svg/"+name+".svg")
        if err != nil {
                return nil, err
        }
        b = replaceColors(b)
        err = sv.ReadXML(bytes.NewReader(b))
        if err != nil {
                return nil, fmt.Errorf("error opening SVG file for cursor %q: %w", name, err)
        }
        img := sv.RenderImage()

        blurRadius := size / 16
        bounds := img.Bounds()
        // We need to add extra space so that the shadow doesn't get clipped.
        bounds.Max = bounds.Max.Add(image.Pt(blurRadius, blurRadius))
        shadow := image.NewRGBA(bounds)
        draw.DrawMask(shadow, shadow.Bounds(), gradient.ApplyOpacity(colors.Scheme.Shadow, 0.25), image.Point{}, img, image.Point{}, draw.Src)
        shadow = pimage.GaussianBlur(shadow, float64(blurRadius))
        draw.Draw(shadow, shadow.Bounds(), img, image.Point{}, draw.Over)

        return &Cursor{
                Image:   shadow,
                Size:    size,
                Hotspot: hot.Mul(size).Div(256),
        }, nil
}

// replaceColors replaces literal cursor colors in the given SVG with scheme colors.
func replaceColors(b []byte) []byte {
        m := map[string]image.Image{
                "#fff": colors.Palette.Neutral.ToneUniform(100),
                "#000": colors.Palette.Neutral.ToneUniform(0),
                "#f00": colors.Scheme.Error.Base,
                "#0f0": colors.Scheme.Success.Base,
                "#ff0": colors.Scheme.Warn.Base,
        }
        for old, clr := range m {
                b = bytes.ReplaceAll(b, []byte(fmt.Sprintf("%q", old)), []byte(fmt.Sprintf("%q", colors.AsHex(colors.ToUniform(clr)))))
        }
        return b
}

// Code generated by "core generate"; DO NOT EDIT.

package cursors

import (
        "cogentcore.org/core/enums"
)

var _CursorValues = []Cursor{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39}

// CursorN is the highest valid value for type Cursor, plus one.
const CursorN Cursor = 40

var _CursorValueMap = map[string]Cursor{`none`: 0, `arrow`: 1, `context-menu`: 2, `help`: 3, `pointer`: 4, `progress`: 5, `wait`: 6, `cell`: 7, `crosshair`: 8, `text`: 9, `vertical-text`: 10, `alias`: 11, `copy`: 12, `move`: 13, `not-allowed`: 14, `grab`: 15, `grabbing`: 16, `resize-col`: 17, `resize-row`: 18, `resize-up`: 19, `resize-right`: 20, `resize-down`: 21, `resize-left`: 22, `resize-n`: 23, `resize-e`: 24, `resize-s`: 25, `resize-w`: 26, `resize-ne`: 27, `resize-nw`: 28, `resize-se`: 29, `resize-sw`: 30, `resize-ew`: 31, `resize-ns`: 32, `resize-nesw`: 33, `resize-nwse`: 34, `zoom-in`: 35, `zoom-out`: 36, `screenshot-selection`: 37, `screenshot-window`: 38, `poof`: 39}

var _CursorDescMap = map[Cursor]string{0: `None indicates no preference for a cursor; will typically be inherited`, 1: `Arrow is a standard arrow cursor, which is the default window cursor`, 2: `ContextMenu indicates that a context menu is available`, 3: `Help indicates that help information is available`, 4: `Pointer is a pointing hand that indicates a link or an interactive element`, 5: `Progress indicates that the app is busy in the background, but can still be interacted with (use [Wait] to indicate that it can't be interacted with)`, 6: `Wait indicates that the app is busy and can not be interacted with (use [Progress] to indicate that it can be interacted with)`, 7: `Cell indicates a table cell, especially one that can be selected`, 8: `Crosshair is a cross cursor that typically indicates precision selection, such as in an image`, 9: `Text is an I-Beam that indicates text that can be selected`, 10: `VerticalText is a sideways I-Beam that indicates vertical text that can be selected`, 11: `Alias indicates that a shortcut or alias will be created`, 12: `Copy indicates that a copy of something will be created`, 13: `Move indicates that something is being moved`, 14: `NotAllowed indicates that something can not be done`, 15: `Grab indicates that something can be grabbed`, 16: `Grabbing indicates that something is actively being grabbed`, 17: `ResizeCol indicates that something can be resized in the horizontal direction`, 18: `ResizeRow indicates that something can be resized in the vertical direction`, 19: `ResizeUp indicates that something can be resized in the upper direction`, 20: `ResizeRight indicates that something can be resized in the right direction`, 21: `ResizeDown indicates that something can be resized in the downward direction`, 22: `ResizeLeft indicates that something can be resized in the left direction`, 23: `ResizeN indicates that something can be resized in the upper direction`, 24: `ResizeE indicates that something can be resized in the right direction`, 25: `ResizeS indicates that something can be resized in the downward direction`, 26: `ResizeW indicates that something can be resized in the left direction`, 27: `ResizeNE indicates that something can be resized in the upper-right direction`, 28: `ResizeNW indicates that something can be resized in the upper-left direction`, 29: `ResizeSE indicates that something can be resized in the lower-right direction`, 30: `ResizeSW indicates that something can be resized in the lower-left direction`, 31: `ResizeEW indicates that something can be resized bidirectionally in the right-left direction`, 32: `ResizeNS indicates that something can be resized bidirectionally in the top-bottom direction`, 33: `ResizeNESW indicates that something can be resized bidirectionally in the top-right to bottom-left direction`, 34: `ResizeNWSE indicates that something can be resized bidirectionally in the top-left to bottom-right direction`, 35: `ZoomIn indicates that something can be zoomed in`, 36: `ZoomOut indicates that something can be zoomed out`, 37: `ScreenshotSelection indicates that a screenshot selection box is being selected`, 38: `ScreenshotWindow indicates that a screenshot is being taken of an entire window`, 39: `Poof indicates that an item will dissapear when it is released`}

var _CursorMap = map[Cursor]string{0: `none`, 1: `arrow`, 2: `context-menu`, 3: `help`, 4: `pointer`, 5: `progress`, 6: `wait`, 7: `cell`, 8: `crosshair`, 9: `text`, 10: `vertical-text`, 11: `alias`, 12: `copy`, 13: `move`, 14: `not-allowed`, 15: `grab`, 16: `grabbing`, 17: `resize-col`, 18: `resize-row`, 19: `resize-up`, 20: `resize-right`, 21: `resize-down`, 22: `resize-left`, 23: `resize-n`, 24: `resize-e`, 25: `resize-s`, 26: `resize-w`, 27: `resize-ne`, 28: `resize-nw`, 29: `resize-se`, 30: `resize-sw`, 31: `resize-ew`, 32: `resize-ns`, 33: `resize-nesw`, 34: `resize-nwse`, 35: `zoom-in`, 36: `zoom-out`, 37: `screenshot-selection`, 38: `screenshot-window`, 39: `poof`}

// String returns the string representation of this Cursor value.
func (i Cursor) String() string { return enums.String(i, _CursorMap) }

// SetString sets the Cursor value from its string representation,
// and returns an error if the string is invalid.
func (i *Cursor) SetString(s string) error { return enums.SetString(i, s, _CursorValueMap, "Cursor") }

// Int64 returns the Cursor value as an int64.
func (i Cursor) Int64() int64 { return int64(i) }

// SetInt64 sets the Cursor value from an int64.
func (i *Cursor) SetInt64(in int64) { *i = Cursor(in) }

// Desc returns the description of the Cursor value.
func (i Cursor) Desc() string { return enums.Desc(i, _CursorDescMap) }

// CursorValues returns all possible values for the type Cursor.
func CursorValues() []Cursor { return _CursorValues }

// Values returns all possible values for the type Cursor.
func (i Cursor) Values() []enums.Enum { return enums.Values(_CursorValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Cursor) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Cursor) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Cursor") }

// Copyright 2024 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Command docs provides documentation of Cogent Core,
// hosted at https://cogentcore.org/core.
package main

import (
        "embed"
        "io/fs"
        "os"
        "path/filepath"
        "reflect"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/content"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/htmlcore"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/text/textcore"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/yaegicore"
        "cogentcore.org/core/yaegicore/coresymbols"
)

//go:embed content
var econtent embed.FS

//go:embed *.svg name.png weld-icon.png
var resources embed.FS

//go:embed image.png
var myImage embed.FS

//go:embed icon.svg
var mySVG embed.FS

//go:embed file.go
var myFile embed.FS

const defaultPlaygroundCode = `package main

func main() {
        b := core.NewBody()
        core.NewButton(b).SetText("Hello, World!")
        b.RunMainWindow()
}`

func main() {
        b := core.NewBody("Cogent Core Docs")
        ct := content.NewContent(b).SetContent(econtent)
        ctx := ct.Context
        ctx.AddWikilinkHandler(htmlcore.GoDocWikilink("doc", "cogentcore.org/core"))
        b.AddTopBar(func(bar *core.Frame) {
                tb := core.NewToolbar(bar)
                tb.Maker(ct.MakeToolbar)
                tb.Maker(func(p *tree.Plan) {
                        tree.Add(p, func(w *core.Button) {
                                ctx.LinkButton(w, "playground")
                                w.SetText("Playground").SetIcon(icons.PlayCircle)
                        })
                        tree.Add(p, func(w *core.Button) {
                                ctx.LinkButton(w, "https://youtube.com/@CogentCore")
                                w.SetText("Videos").SetIcon(icons.VideoLibrary)
                        })
                        tree.Add(p, func(w *core.Button) {
                                ctx.LinkButton(w, "https://cogentcore.org/blog")
                                w.SetText("Blog").SetIcon(icons.RssFeed)
                        })
                        tree.Add(p, func(w *core.Button) {
                                ctx.LinkButton(w, "https://github.com/cogentcore/core")
                                w.SetText("GitHub").SetIcon(icons.GitHub)
                        })
                        tree.Add(p, func(w *core.Button) {
                                ctx.LinkButton(w, "https://cogentcore.org/community")
                                w.SetText("Community").SetIcon(icons.Forum)
                        })
                        tree.Add(p, func(w *core.Button) {
                                ctx.LinkButton(w, "https://github.com/sponsors/cogentcore")
                                w.SetText("Sponsor").SetIcon(icons.Favorite)
                        })
                })
        })

        coresymbols.Symbols["."]["econtent"] = reflect.ValueOf(econtent)
        coresymbols.Symbols["."]["myImage"] = reflect.ValueOf(myImage)
        coresymbols.Symbols["."]["mySVG"] = reflect.ValueOf(mySVG)
        coresymbols.Symbols["."]["myFile"] = reflect.ValueOf(myFile)

        ctx.ElementHandlers["home-page"] = homePage
        ctx.ElementHandlers["core-playground"] = func(ctx *htmlcore.Context) bool {
                splits := core.NewSplits(ctx.BlockParent)
                ed := textcore.NewEditor(splits)
                playgroundFile := filepath.Join(core.TheApp.AppDataDir(), "playground.go")
                err := ed.Lines.Open(playgroundFile)
                if err != nil {
                        if errors.Is(err, fs.ErrNotExist) {
                                err := os.WriteFile(playgroundFile, []byte(defaultPlaygroundCode), 0666)
                                core.ErrorSnackbar(ed, err, "Error creating code file")
                                if err == nil {
                                        err := ed.Lines.Open(playgroundFile)
                                        core.ErrorSnackbar(ed, err, "Error loading code")
                                }
                        } else {
                                core.ErrorSnackbar(ed, err, "Error loading code")
                        }
                }
                ed.OnChange(func(e events.Event) {
                        core.ErrorSnackbar(ed, ed.SaveQuiet(), "Error saving code")
                })
                parent := core.NewFrame(splits)
                yaegicore.BindTextEditor(ed, parent, "Go")
                return true
        }
        ctx.ElementHandlers["style-demo"] = func(ctx *htmlcore.Context) bool {
                // same as demo styles tab
                sp := core.NewSplits(ctx.BlockParent)
                sp.Styler(func(s *styles.Style) {
                        s.Min.Y.Em(40)
                })
                fm := core.NewForm(sp)
                fr := core.NewFrame(core.NewFrame(sp)) // can not control layout when directly in splits
                fr.Styler(func(s *styles.Style) {
                        s.Background = colors.Scheme.Select.Container
                        s.Grow.Set(1, 1)
                })
                fr.Style() // must style immediately to get correct default values
                fm.SetStruct(&fr.Styles)
                fm.OnChange(func(e events.Event) {
                        fr.OverrideStyle = true
                        fr.Update()
                })
                frameSizes := []math32.Vector2{
                        {20, 100},
                        {80, 20},
                        {60, 80},
                        {40, 120},
                        {150, 100},
                }
                for _, sz := range frameSizes {
                        core.NewFrame(fr).Styler(func(s *styles.Style) {
                                s.Min.Set(units.Dp(sz.X), units.Dp(sz.Y))
                                s.Background = colors.Scheme.Primary.Base
                        })
                }
                return true
        }

        b.RunMainWindow()
}

var home *core.Frame

func makeBlock[T tree.NodeValue](title, txt string, graphic func(w *T), url ...string) {
        if len(url) > 0 {
                title = `<a target="_blank" href="` + url[0] + `">` + title + `</a>`
        }
        tree.AddChildAt(home, title, func(w *core.Frame) {
                w.Styler(func(s *styles.Style) {
                        s.Gap.Set(units.Em(1))
                        s.Grow.Set(1, 0)
                        if home.SizeClass() == core.SizeCompact {
                                s.Direction = styles.Column
                        }
                })
                w.Maker(func(p *tree.Plan) {
                        graphicFirst := w.IndexInParent()%2 != 0 && w.SizeClass() != core.SizeCompact
                        if graphicFirst {
                                tree.Add(p, graphic)
                        }
                        tree.Add(p, func(w *core.Frame) {
                                w.Styler(func(s *styles.Style) {
                                        s.Direction = styles.Column
                                        s.Text.Align = text.Start
                                        s.Grow.Set(1, 1)
                                })
                                tree.AddChild(w, func(w *core.Text) {
                                        w.SetType(core.TextHeadlineLarge).SetText(title)
                                        w.Styler(func(s *styles.Style) {
                                                s.Font.Weight = rich.Bold
                                                s.Color = colors.Scheme.Primary.Base
                                        })
                                })
                                tree.AddChild(w, func(w *core.Text) {
                                        w.SetType(core.TextTitleLarge).SetText(txt)
                                })
                        })
                        if !graphicFirst {
                                tree.Add(p, graphic)
                        }
                })
        })
}

func homePage(ctx *htmlcore.Context) bool {
        home = core.NewFrame(ctx.BlockParent)
        home.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
                s.Grow.Set(1, 1)
                s.CenterAll()
        })
        home.OnShow(func(e events.Event) {
                home.Update() // TODO: temporary workaround for #1037
        })

        tree.AddChild(home, func(w *core.SVG) {
                errors.Log(w.ReadString(core.AppIcon))
        })
        tree.AddChild(home, func(w *core.Image) {
                errors.Log(w.OpenFS(resources, "name.png"))
                w.Styler(func(s *styles.Style) {
                        s.Min.X.SetCustom(func(uc *units.Context) float32 {
                                return min(uc.Dp(612), uc.Vw(80))
                        })
                })
        })
        tree.AddChild(home, func(w *core.Text) {
                w.SetType(core.TextHeadlineMedium).SetText("A cross-platform framework for building powerful, fast, elegant 2D and 3D apps")
        })
        tree.AddChild(home, func(w *core.Frame) {
                tree.AddChild(w, func(w *core.Button) {
                        ctx.LinkButton(w, "basics")
                        w.SetText("Get started")
                })
                tree.AddChild(w, func(w *core.Button) {
                        ctx.LinkButton(w, "install")
                        w.SetText("Install").SetType(core.ButtonTonal)
                })
        })

        initIcon := func(w *core.Icon) *core.Icon {
                w.Styler(func(s *styles.Style) {
                        s.Min.Set(units.Dp(256))
                        s.Color = colors.Scheme.Primary.Base
                })
                return w
        }

        makeBlock("CODE ONCE, RUN EVERYWHERE (CORE)", "With Cogent Core, you can write your app once and it will run on macOS, Windows, Linux, iOS, Android, and the web, automatically scaling to any screen. Instead of struggling with platform-specific code in multiple languages, you can write and maintain a single Go codebase.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.Devices)
        })

        makeBlock("EFFORTLESS ELEGANCE", "Cogent Core is built on Go, a high-level language designed for building elegant, readable, and scalable code with type safety and a robust design that doesn't get in your way. Cogent Core makes it easy to get started with cross-platform app development in just two commands and three lines of simple code.", func(w *textcore.Editor) {
                w.Lines.SetLanguage(fileinfo.Go).SetString(`b := core.NewBody()
core.NewButton(b).SetText("Hello, World!")
b.RunMainWindow()`)
                w.SetReadOnly(true)
                w.Lines.Settings.LineNumbers = false
                w.Styler(func(s *styles.Style) {
                        if w.SizeClass() != core.SizeCompact {
                                s.Min.X.Em(20)
                        }
                })
        })

        makeBlock("COMPLETELY CUSTOMIZABLE", "Cogent Core allows developers and users to customize apps to fit their needs and preferences through a robust styling system and powerful color settings.", func(w *core.Form) {
                w.SetStruct(core.AppearanceSettings)
                w.OnChange(func(e events.Event) {
                        core.UpdateSettings(w, core.AppearanceSettings)
                })

        })

        makeBlock("POWERFUL FEATURES", "Cogent Core supports text editors, video players, interactive 3D graphics, customizable data plots, Markdown and HTML rendering, SVG and canvas vector graphics, and automatic views of any Go data structure for data binding and app inspection.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.ScatterPlot)
        })

        makeBlock("OPTIMIZED EXPERIENCE", "Cogent Core has editable, interactive, example-based documentation, video tutorials, command line tools, and support from the developers.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.PlayCircle)
        })

        makeBlock("EXTREMELY FAST", "Cogent Core is powered by WebGPU, a modern, cross-platform, high-performance graphics framework that allows apps to run at high speeds. Apps compile to machine code, allowing them to run without overhead.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.Bolt)
        })

        makeBlock("FREE AND OPEN SOURCE", "Cogent Core is completely free and open source under the permissive BSD-3 License, allowing you to use Cogent Core for any purpose, commercially or personally.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.Code)
        })

        makeBlock("USED AROUND THE WORLD", "Over seven years of development, Cogent Core has been used and tested by developers and scientists around the world for various use cases. Cogent Core is an advanced framework used to power everything from end-user apps to scientific research.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.GlobeAsia)
        })

        tree.AddChild(home, func(w *core.Text) {
                w.SetType(core.TextDisplaySmall).SetText("<b>What can Cogent Core do?</b>")
        })

        makeBlock("COGENT CODE", "Cogent Code is a Go IDE with support for syntax highlighting, code completion, symbol lookup, building and debugging, version control, keyboard shortcuts, and many other features.", func(w *core.SVG) {
                errors.Log(w.OpenFS(resources, "code-icon.svg"))
        }, "https://cogentcore.org/cogent/code")

        makeBlock("COGENT CANVAS", "Cogent Canvas is a vector graphics editor with support for shapes, paths, curves, text, images, gradients, groups, alignment, styling, importing, exporting, undo, redo, and various other features.", func(w *core.SVG) {
                errors.Log(w.OpenFS(resources, "canvas-icon.svg"))
        }, "https://cogentcore.org/cogent/canvas")

        makeBlock("COGENT LAB", "Cogent Lab is an extensible math, data science, and statistics platform and language.", func(w *core.SVG) {
                errors.Log(w.OpenFS(resources, "numbers-icon.svg"))
        }, "https://cogentcore.org/lab")

        makeBlock("COGENT MAIL", "Cogent Mail is a customizable email client with built-in Markdown support, automatic mail filtering, and keyboard shortcuts for mail filing.", func(w *core.SVG) {
                errors.Log(w.OpenFS(resources, "mail-icon.svg"))
        }, "https://github.com/cogentcore/cogent/tree/main/mail")

        makeBlock("COGENT CRAFT", "Cogent Craft is a 3D modeling app with support for creating, loading, and editing 3D object files using an interactive WYSIWYG editor.", func(w *core.SVG) {
                errors.Log(w.OpenFS(resources, "craft-icon.svg"))
        }, "https://github.com/cogentcore/cogent/tree/main/craft")

        makeBlock("EMERGENT", "Emergent is a collection of biologically based 3D neural network models of the brain that power ongoing research in computational cognitive neuroscience.", func(w *core.SVG) {
                errors.Log(w.OpenFS(resources, "emergent-icon.svg"))
        }, "https://emersim.org")

        // makeBlock("WELD", "WELD is a set of 3D computational models of a new approach to quantum physics based on the de Broglie-Bohm pilot wave theory.", func(w *core.Image) {
        //         errors.Log(w.OpenFS(resources, "weld-icon.png"))
        //         w.Styler(func(s *styles.Style) {
        //                 s.Min.Set(units.Dp(256))
        //         })
        // }, "https://github.com/WaveELD/WELDBook/blob/main/textmd/ch01_intro.md")

        tree.AddChild(home, func(w *core.Text) {
                w.SetType(core.TextDisplaySmall).SetText("<b>Why Cogent Core instead of something else?</b>")
        })

        makeBlock("THE PROBLEM", "After using other frameworks built on HTML and Qt for years to make apps ranging from simple tools to complex scientific models, we realized that we were spending more time dealing with excessive boilerplate, browser inconsistencies, and dependency management issues than actual app development.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.Problem)
        })

        makeBlock("THE SOLUTION", "We decided to make a framework that would allow us to focus on app content and logic by providing a consistent API that automatically handles cross-platform support, user customization, and app packaging and deployment.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.Lightbulb)
        })

        makeBlock("THE RESULT", "Instead of constantly jumping through hoops to create a consistent, easy-to-use, cross-platform app, you can now take advantage of a powerful featureset on all platforms and simplify your development experience.", func(w *core.Icon) {
                initIcon(w).SetIcon(icons.Check)
        })

        tree.AddChild(home, func(w *core.Button) {
                ctx.LinkButton(w, "basics")
                w.SetText("Get started")
        })

        return true
}

// Copyright 2024 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "fmt"

func exampleFile() {
        fmt.Println("This is an example file.")
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package main provides the actual command line
// implementation of the enumgen library.
package main

import (
        "cogentcore.org/core/cli"
        "cogentcore.org/core/enums/enumgen"
)

func main() {
        opts := cli.DefaultOptions("Enumgen", "Enumgen generates helpful methods for Go enums.")
        opts.DefaultFiles = []string{"enumgen.toml"}
        cli.Run(opts, &enumgen.Config{}, enumgen.Generate)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on http://github.com/dmarkham/enumer and
// golang.org/x/tools/cmd/stringer:

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package enumgen

import "text/template"

// BuildBitFlagMethods builds methods specific to bit flag types.
func (g *Generator) BuildBitFlagMethods(runs []Value, typ *Type) {
        g.Printf("\n")

        g.ExecTmpl(HasFlagMethodTmpl, typ)
        g.ExecTmpl(SetFlagMethodTmpl, typ)
}

var HasFlagMethodTmpl = template.Must(template.New("HasFlagMethod").Parse(
        `// HasFlag returns whether these bit flags have the given bit flag set.
func (i *{{.Name}}) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }
`))

var SetFlagMethodTmpl = template.Must(template.New("SetFlagMethod").Parse(
        `// SetFlag sets the value of the given flags in these flags to the given value.
func (i *{{.Name}}) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }
`))

var StringMethodBitFlagTmpl = template.Must(template.New("StringMethodBitFlag").Parse(
        `// String returns the string representation of this {{.Name}} value.
func (i {{.Name}}) String() string {
        {{- if eq .Extends ""}} return enums.BitFlagString(i, _{{.Name}}Values)
        {{- else}} return enums.BitFlagStringExtended(i, _{{.Name}}Values, {{.Extends}}Values()) {{end}} }
`))

var SetStringMethodBitFlagTmpl = template.Must(template.New("SetStringMethodBitFlag").Parse(
        `// SetString sets the {{.Name}} value from its string representation,
// and returns an error if the string is invalid.
func (i *{{.Name}}) SetString(s string) error { *i = 0; return i.SetStringOr(s) }
`))

var SetStringOrMethodBitFlagTmpl = template.Must(template.New("SetStringOrMethodBitFlag").Parse(
        `// SetStringOr sets the {{.Name}} value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *{{.Name}}) SetStringOr(s string) error {
        {{- if eq .Extends ""}} return enums.SetStringOr{{if .Config.AcceptLower}}Lower{{end}}(i, s, _{{.Name}}ValueMap, "{{.Name}}")
        {{- else}} return enums.SetStringOr{{if .Config.AcceptLower}}Lower{{end}}Extended(i, (*{{.Extends}})(i), s, _{{.Name}}ValueMap) {{end}} }
`))

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package enumgen provides functions for generating
// enum methods for enum types.
package enumgen

//go:generate core generate

import (
        "fmt"

        "cogentcore.org/core/base/generate"
        "cogentcore.org/core/base/logx"
        "golang.org/x/tools/go/packages"
)

// ParsePackages parses the package(s) located in the configuration source directory.
func ParsePackages(cfg *Config) ([]*packages.Package, error) {
        pcfg := &packages.Config{
                Mode: PackageModes(),
                // TODO: Need to think about constants in test files. Maybe write enumgen_test.go
                // in a separate pass? For later.
                Tests: false,
        }
        pkgs, err := generate.Load(pcfg, cfg.Dir)
        if err != nil {
                return nil, fmt.Errorf("enumgen: Generate: error parsing package: %w", err)
        }
        return pkgs, err
}

// Generate generates enum methods, using the
// configuration information, loading the packages from the
// configuration source directory, and writing the result
// to the configuration output file.
//
// It is a simple entry point to enumgen that does all
// of the steps; for more specific functionality, create
// a new [Generator] with [NewGenerator] and call methods on it.
//
//cli:cmd -root
func Generate(cfg *Config) error { //types:add
        pkgs, err := ParsePackages(cfg)
        if err != nil {
                logx.PrintlnInfo(err)
                return err
        }
        err = GeneratePkgs(cfg, pkgs)
        logx.PrintlnInfo(err)
        return err
}

// GeneratePkgs generates enum methods using
// the given configuration object and packages parsed
// from the configuration source directory,
// and writes the result to the config output file.
// It is a simple entry point to enumgen that does all
// of the steps; for more specific functionality, create
// a new [Generator] with [NewGenerator] and call methods on it.
func GeneratePkgs(cfg *Config, pkgs []*packages.Package) error {
        g := NewGenerator(cfg, pkgs)
        for _, pkg := range g.Pkgs {
                g.Pkg = pkg
                g.Buf.Reset()
                err := g.FindEnumTypes()
                if err != nil {
                        return fmt.Errorf("enumgen: Generate: error finding enum types for package %q: %w", pkg.Name, err)
                }
                g.PrintHeader()
                has, err := g.Generate()
                if !has {
                        continue
                }
                if err != nil {
                        return fmt.Errorf("enumgen: Generate: error generating code for package %q: %w", pkg.Name, err)
                }
                err = g.Write()
                if err != nil {
                        return fmt.Errorf("enumgen: Generate: error writing code for package %q: %w", pkg.Name, err)
                }
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on http://github.com/dmarkham/enumer and
// golang.org/x/tools/cmd/stringer:

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package enumgen

import (
        "bytes"
        "errors"
        "fmt"
        "go/ast"
        "go/constant"
        "go/token"
        "go/types"
        "html"
        "log/slog"
        "os"
        "strings"
        "text/template"

        "cogentcore.org/core/base/generate"
        "cogentcore.org/core/cli"
        "golang.org/x/tools/go/packages"
)

// Generator holds the state of the generator.
// It is primarily used to buffer the output.
type Generator struct {
        Config *Config             // The configuration information
        Buf    bytes.Buffer        // The accumulated output.
        Pkgs   []*packages.Package // The packages we are scanning.
        Pkg    *packages.Package   // The packages we are currently on.
        Types  []*Type             // The enum types
}

// NewGenerator returns a new generator with the
// given configuration information and parsed packages.
func NewGenerator(config *Config, pkgs []*packages.Package) *Generator {
        return &Generator{Config: config, Pkgs: pkgs}
}

// PackageModes returns the package load modes needed for this generator
func PackageModes() packages.LoadMode {
        return packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedTypesInfo
}

// Printf prints the formatted string to the
// accumulated output in [Generator.Buf]
func (g *Generator) Printf(format string, args ...any) {
        fmt.Fprintf(&g.Buf, format, args...)
}

// PrintHeader prints the header and package clause
// to the accumulated output
func (g *Generator) PrintHeader() {
        // we need a manual import of enums because it is
        // external, but goimports will handle everything else
        generate.PrintHeader(&g.Buf, g.Pkg.Name, "cogentcore.org/core/enums")
}

// FindEnumTypes goes through all of the types in the package
// and finds all integer (signed or unsigned) types labeled with enums:enum
// or enums:bitflag. It stores the resulting types in [Generator.Types].
func (g *Generator) FindEnumTypes() error {
        g.Types = []*Type{}
        return generate.Inspect(g.Pkg, g.InspectForType, "enumgen.go", "typegen.go")
}

// AllowedEnumTypes are the types that can be used for enums
// that are not bit flags (bit flags can only be int64s).
// It is stored as a map for quick and convenient access.
var AllowedEnumTypes = map[string]bool{"int": true, "int64": true, "int32": true, "int16": true, "int8": true, "uint": true, "uint64": true, "uint32": true, "uint16": true, "uint8": true}

// InspectForType looks at the given AST node and adds it
// to [Generator.Types] if it is marked with an appropriate
// comment directive. It returns whether the AST inspector should
// continue, and an error if there is one. It should only
// be called in [ast.Inspect].
func (g *Generator) InspectForType(n ast.Node) (bool, error) {
        ts, ok := n.(*ast.TypeSpec)
        if !ok {
                return true, nil
        }
        if ts.Comment == nil {
                return true, nil
        }
        for _, c := range ts.Comment.List {
                dir, err := cli.ParseDirective(c.Text)
                if err != nil {
                        return false, fmt.Errorf("error parsing comment directive %q: %w", c.Text, err)
                }
                if dir == nil {
                        continue
                }
                if dir.Tool != "enums" {
                        continue
                }
                if dir.Directive != "enum" && dir.Directive != "bitflag" {
                        return false, fmt.Errorf("unrecognized enums directive %q (from %q)", dir.Directive, c.Text)
                }

                typnm := types.ExprString(ts.Type)
                // ident, ok := ts.Type.(*ast.Ident)
                // if !ok {
                //         return false, fmt.Errorf("type of enum type (%v) is %T, not *ast.Ident (try using a standard [un]signed integer type instead)", ts.Type, ts.Type)
                // }
                cfg := &Config{}
                *cfg = *g.Config
                leftovers, err := cli.SetFromArgs(cfg, dir.Args, cli.ErrNotFound)
                if err != nil {
                        return false, fmt.Errorf("error setting config info from comment directive args: %w (from directive %q)", err, c.Text)
                }
                if len(leftovers) > 0 {
                        return false, fmt.Errorf("expected 0 positional arguments but got %d (list: %v) (from directive %q)", len(leftovers), leftovers, c.Text)
                }

                typ := g.Pkg.TypesInfo.Defs[ts.Name].Type()
                utyp := typ.Underlying()

                tt := &Type{Name: ts.Name.Name, Type: ts, Config: cfg}
                // if our direct type isn't the same as our underlying type, we are extending our direct type
                if cfg.Extend && typnm != utyp.String() {
                        tt.Extends = typnm
                }
                switch dir.Directive {
                case "enum":
                        if !AllowedEnumTypes[utyp.String()] {
                                return false, fmt.Errorf("enum type %s is not allowed; try using a standard [un]signed integer type instead", typnm)
                        }
                        tt.IsBitFlag = false
                case "bitflag":
                        if utyp.String() != "int64" {
                                return false, fmt.Errorf("bit flag enum type %s is not allowed; bit flag enums must be of type int64", typnm)
                        }
                        tt.IsBitFlag = true
                }
                g.Types = append(g.Types, tt)

        }
        return true, nil
}

// Generate produces the enum methods for the types
// stored in [Generator.Types] and stores them in
// [Generator.Buf]. It returns whether there were
// any enum types to generate methods for, and
// any error that occurred.
func (g *Generator) Generate() (bool, error) {
        if len(g.Types) == 0 {
                return false, nil
        }
        for _, typ := range g.Types {
                values := make([]Value, 0, 100)
                for _, file := range g.Pkg.Syntax {
                        if generate.ExcludeFile(g.Pkg, file, "enumgen.go", "typegen.go") {
                                continue
                        }
                        var terr error
                        ast.Inspect(file, func(n ast.Node) bool {
                                if terr != nil {
                                        return false
                                }
                                vals, cont, err := g.GenDecl(n, file, typ)
                                if err != nil {
                                        terr = err
                                } else {
                                        values = append(values, vals...)
                                }
                                return cont
                        })
                        if terr != nil {
                                return true, fmt.Errorf("Generate: error parsing declaration clauses: %w", terr)
                        }
                }

                if len(values) == 0 {
                        return true, errors.New("no values defined for type " + typ.Name)
                }

                g.TrimValueNames(values, typ.Config)

                err := g.TransformValueNames(values, typ.Config)
                if err != nil {
                        return true, fmt.Errorf("error transforming value names: %w", err)
                }

                g.PrefixValueNames(values, typ.Config)

                values = SortValues(values)

                g.BuildBasicMethods(values, typ)
                if typ.IsBitFlag {
                        g.BuildBitFlagMethods(values, typ)
                }

                if typ.Config.Text {
                        g.BuildTextMethods(values, typ)
                }
                if typ.Config.SQL {
                        g.AddValueAndScanMethod(typ)
                }
                if typ.Config.GQL {
                        g.BuildGQLMethods(values, typ)
                }
        }
        return true, nil
}

// GenDecl processes one declaration clause.
// It returns whether the AST inspector should continue,
// and an error if there is one. It should only be
// called in [ast.Inspect].
func (g *Generator) GenDecl(node ast.Node, file *ast.File, typ *Type) ([]Value, bool, error) {
        decl, ok := node.(*ast.GenDecl)
        if !ok || decl.Tok != token.CONST {
                // We only care about const declarations.
                return nil, true, nil
        }
        vals := []Value{}
        // The name of the type of the constants we are declaring.
        // Can change if this is a multi-element declaration.
        typName := ""
        // Loop over the elements of the declaration. Each element is a ValueSpec:
        // a list of names possibly followed by a type, possibly followed by values.
        // If the type and value are both missing, we carry down the type (and value,
        // but the "go/types" package takes care of that).
        for _, spec := range decl.Specs {
                vspec := spec.(*ast.ValueSpec) // Guaranteed to succeed as this is CONST.
                if vspec.Type == nil && len(vspec.Values) > 0 {
                        // "X = 1". With no type but a value, the constant is untyped.
                        // Skip this vspec and reset the remembered type.
                        typName = ""
                        continue
                }
                if vspec.Type != nil {
                        // "X T". We have a type. Remember it.
                        ident, ok := vspec.Type.(*ast.Ident)
                        if !ok {
                                continue
                        }
                        typName = ident.Name
                }
                if typName != typ.Name {
                        // This is not the type we're looking for.
                        continue
                }
                // We now have a list of names (from one line of source code) all being
                // declared with the desired type.
                // Grab their names and actual values and store them in f.values.
                for _, n := range vspec.Names {
                        if n.Name == "_" {
                                continue
                        }
                        // This dance lets the type checker find the values for us. It's a
                        // bit tricky: look up the object declared by the n, find its
                        // types.Const, and extract its value.
                        obj, ok := g.Pkg.TypesInfo.Defs[n]
                        if !ok {
                                return nil, false, errors.New("no value for constant " + n.String())
                        }
                        info := obj.Type().Underlying().(*types.Basic).Info()
                        if info&types.IsInteger == 0 {
                                return nil, false, errors.New("can't handle non-integer constant type " + typName)
                        }
                        value := obj.(*types.Const).Val() // Guaranteed to succeed as this is CONST.
                        if value.Kind() != constant.Int {
                                return nil, false, errors.New("can't happen: constant is not an integer " + n.String())
                        }
                        i64, isInt := constant.Int64Val(value)
                        u64, isUint := constant.Uint64Val(value)
                        if !isInt && !isUint {
                                return nil, false, errors.New("internal error: value of " + n.String() + " is not an integer: " + value.String())
                        }
                        if !isUint {
                                i64 = int64(u64)
                        }
                        v := Value{
                                OriginalName: n.Name,
                                Name:         n.Name,
                                Desc:         html.EscapeString(strings.Join(strings.Fields(vspec.Doc.Text()), " ")), // need to collapse whitespace and escape
                                Value:        i64,
                                Signed:       info&types.IsUnsigned == 0,
                                Str:          value.String(),
                        }
                        if c := vspec.Comment; typ.Config.LineComment && c != nil && len(c.List) == 1 {
                                v.Name = strings.TrimSpace(c.Text())
                        }

                        vals = append(vals, v)
                }
        }
        return vals, false, nil
}

// ExecTmpl executes the given template with the given type and
// writes the result to [Generator.Buf]. It fatally logs any error.
// All enumgen templates take a [Type] as their data.
func (g *Generator) ExecTmpl(t *template.Template, typ *Type) {
        err := t.Execute(&g.Buf, typ)
        if err != nil {
                slog.Error("programmer error: internal error: error executing template", "err", err)
                os.Exit(1)
        }
}

// Write formats the data in the the Generator's buffer
// ([Generator.Buf]) and writes it to the file specified by
// [Generator.Config.Output].
func (g *Generator) Write() error {
        return generate.Write(generate.Filepath(g.Pkg, g.Config.Output), g.Buf.Bytes(), nil)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on http://github.com/dmarkham/enumer and
// golang.org/x/tools/cmd/stringer:

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package enumgen

import "text/template"

var GQLMethodsTmpl = template.Must(template.New("GQLMethods").Parse(`
// MarshalGQL implements the [graphql.Marshaler] interface.
func (i {{.Name}}) MarshalGQL(w io.Writer) { w.Write([]byte(strconv.Quote(i.String()))) }

// UnmarshalGQL implements the [graphql.Unmarshaler] interface.
func (i *{{.Name}}) UnmarshalGQL(value any) error { return enums.Scan(i, value, "{{.Name}}") }
`))

func (g *Generator) BuildGQLMethods(runs []Value, typ *Type) {
        g.ExecTmpl(GQLMethodsTmpl, typ)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on http://github.com/dmarkham/enumer and
// golang.org/x/tools/cmd/stringer:

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package enumgen

import "text/template"

var TextMethodsTmpl = template.Must(template.New("TextMethods").Parse(
        `
// MarshalText implements the [encoding.TextMarshaler] interface.
func (i {{.Name}}) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *{{.Name}}) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "{{.Name}}") }
`))

func (g *Generator) BuildTextMethods(runs []Value, typ *Type) {
        g.ExecTmpl(TextMethodsTmpl, typ)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on http://github.com/dmarkham/enumer and
// golang.org/x/tools/cmd/stringer:

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package enumgen

import (
        "strings"
        "text/template"
)

// BuildString builds the string function using a map access approach.
func (g *Generator) BuildString(values []Value, typ *Type) {
        g.Printf("\n")
        g.Printf("\nvar _%sMap = map[%s]string{", typ.Name, typ.Name)
        n := 0
        for _, value := range values {
                g.Printf("%s: `%s`,", &value, value.Name)
                n += len(value.Name)
        }
        g.Printf("}\n\n")
        if typ.IsBitFlag {
                g.ExecTmpl(StringMethodBitFlagTmpl, typ)
        }
        g.ExecTmpl(StringMethodMapTmpl, typ)
}

var StringMethodMapTmpl = template.Must(template.New("StringMethodMap").Parse(
        `{{if .IsBitFlag}}
        // BitIndexString returns the string representation of this {{.Name}} value
        // if it is a bit index value (typically an enum constant), and
        // not an actual bit flag value.
        {{- else}}
        // String returns the string representation of this {{.Name}} value.
        {{- end}}
func (i {{.Name}}) {{if .IsBitFlag}} BitIndexString {{else}} String {{end}} () string { return enums.
        {{- if eq .Extends ""}}String {{else -}} {{if .IsBitFlag -}} BitIndexStringExtended {{else -}} StringExtended {{- end}}[{{.Name}}, {{.Extends}}]{{- end}}(i, _{{.Name}}Map) }
`))

var NConstantTmpl = template.Must(template.New("StringNConstant").Parse(
        `//{{.Name}}N is the highest valid value for type {{.Name}}, plus one.
const {{.Name}}N {{.Name}} = {{.MaxValueP1}}
`))

var NConstantTmplGosl = template.Must(template.New("StringNConstant").Parse(
        `//gosl:start
//{{.Name}}N is the highest valid value for type {{.Name}}, plus one.
const {{.Name}}N {{.Name}} = {{.MaxValueP1}}
//gosl:end
`))

var SetStringMethodTmpl = template.Must(template.New("SetStringMethod").Parse(
        `// SetString sets the {{.Name}} value from its string representation,
// and returns an error if the string is invalid.
func (i *{{.Name}}) SetString(s string) error {
        {{- if eq .Extends ""}} return enums.SetString{{if .Config.AcceptLower}}Lower{{end}}(i, s, _{{.Name}}ValueMap, "{{.Name}}")
        {{- else}} return enums.SetString{{if .Config.AcceptLower}}Lower{{end}}Extended(i, (*{{.Extends}})(i), s, _{{.Name}}ValueMap) {{end}} }
`))

var Int64MethodTmpl = template.Must(template.New("Int64Method").Parse(
        `// Int64 returns the {{.Name}} value as an int64.
func (i {{.Name}}) Int64() int64 { return int64(i) }
`))

var SetInt64MethodTmpl = template.Must(template.New("SetInt64Method").Parse(
        `// SetInt64 sets the {{.Name}} value from an int64.
func (i *{{.Name}}) SetInt64(in int64) { *i = {{.Name}}(in) }
`))

var DescMethodTmpl = template.Must(template.New("DescMethod").Parse(`// Desc returns the description of the {{.Name}} value.
func (i {{.Name}}) Desc() string {
        {{- if eq .Extends ""}} return enums.Desc(i, _{{.Name}}DescMap)
        {{- else}} return enums.DescExtended[{{.Name}}, {{.Extends}}](i, _{{.Name}}DescMap) {{end}} }
`))

var ValuesGlobalTmpl = template.Must(template.New("ValuesGlobal").Parse(
        `// {{.Name}}Values returns all possible values for the type {{.Name}}.
func {{.Name}}Values() []{{.Name}} {
        {{- if eq .Extends ""}} return _{{.Name}}Values
        {{- else}} return enums.ValuesGlobalExtended(_{{.Name}}Values, {{.Extends}}Values())
        {{- end}} }
`))

var ValuesMethodTmpl = template.Must(template.New("ValuesMethod").Parse(
        `// Values returns all possible values for the type {{.Name}}.
func (i {{.Name}}) Values() []enums.Enum {
        {{- if eq .Extends ""}} return enums.Values(_{{.Name}}Values)
        {{- else}} return enums.ValuesExtended(_{{.Name}}Values, {{.Extends}}Values())
        {{- end}} }
`))

var IsValidMethodMapTmpl = template.Must(template.New("IsValidMethodMap").Parse(
        `// IsValid returns whether the value is a valid option for type {{.Name}}.
func (i {{.Name}}) IsValid() bool { _, ok := _{{.Name}}Map[i]; return ok
        {{- if ne .Extends ""}} || {{.Extends}}(i).IsValid() {{end}} }
`))

// BuildBasicMethods builds methods common to all types, like Desc and SetString.
func (g *Generator) BuildBasicMethods(values []Value, typ *Type) {

        // Print the slice of values
        max := int64(0)
        g.Printf("\nvar _%sValues = []%s{", typ.Name, typ.Name)
        for _, value := range values {
                g.Printf("%s, ", &value)
                if value.Value > max {
                        max = value.Value
                }
        }
        g.Printf("}\n\n")

        typ.MaxValueP1 = max + 1

        if g.Config.Gosl {
                g.ExecTmpl(NConstantTmplGosl, typ)
        } else {
                g.ExecTmpl(NConstantTmpl, typ)
        }

        // Print the map between name and value
        g.PrintValueMap(values, typ)

        // Print the map of values to descriptions
        g.PrintDescMap(values, typ)

        g.BuildString(values, typ)

        // Print the basic extra methods
        if typ.IsBitFlag {
                g.ExecTmpl(SetStringMethodBitFlagTmpl, typ)
                g.ExecTmpl(SetStringOrMethodBitFlagTmpl, typ)
        } else {
                g.ExecTmpl(SetStringMethodTmpl, typ)
        }
        g.ExecTmpl(Int64MethodTmpl, typ)
        g.ExecTmpl(SetInt64MethodTmpl, typ)
        g.ExecTmpl(DescMethodTmpl, typ)
        g.ExecTmpl(ValuesGlobalTmpl, typ)
        g.ExecTmpl(ValuesMethodTmpl, typ)
        if typ.Config.IsValid {
                g.ExecTmpl(IsValidMethodMapTmpl, typ)
        }
}

// PrintValueMap prints the map between name and value
func (g *Generator) PrintValueMap(values []Value, typ *Type) {
        g.Printf("\nvar _%sValueMap = map[string]%s{", typ.Name, typ.Name)
        for _, value := range values {
                g.Printf("`%s`: %s,", value.Name, &value)
                if typ.Config.AcceptLower {
                        l := strings.ToLower(value.Name)
                        if l != value.Name { // avoid duplicate keys
                                g.Printf("`%s`: %s,", l, &value)
                        }
                }
        }
        g.Printf("}\n\n")
}

// PrintDescMap prints the map of values to descriptions
func (g *Generator) PrintDescMap(values []Value, typ *Type) {
        g.Printf("\n")
        g.Printf("\nvar _%sDescMap = map[%s]string{", typ.Name, typ.Name)
        i := 0
        for _, value := range values {
                g.Printf("%s: `%s`,", &value, value.Desc)
                i++
        }
        g.Printf("}\n\n")
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on http://github.com/dmarkham/enumer and
// golang.org/x/tools/cmd/stringer:

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package enumgen

import "text/template"

var ValueMethodTmpl = template.Must(template.New("ValueMethod").Parse(
        `// Value implements the [driver.Valuer] interface.
func (i {{.Name}}) Value() (driver.Value, error) { return i.String(), nil }
`))

var ScanMethodTmpl = template.Must(template.New("ScanMethod").Parse(
        `// Scan implements the [sql.Scanner] interface.
func (i *{{.Name}}) Scan(value any) error { return enums.Scan(i, value, "{{.Name}}") }
`))

func (g *Generator) AddValueAndScanMethod(typ *Type) {
        g.Printf("\n")
        g.ExecTmpl(ValueMethodTmpl, typ)
        g.Printf("\n\n")
        g.ExecTmpl(ScanMethodTmpl, typ)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on http://github.com/dmarkham/enumer and
// golang.org/x/tools/cmd/stringer:

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package enumgen

import (
        "fmt"
        "go/ast"
        "sort"
        "strings"
        "unicode/utf8"

        "cogentcore.org/core/base/strcase"
)

// Type represents a parsed enum type.
type Type struct {
        Name       string        // The name of the type
        Type       *ast.TypeSpec // The standard AST type value
        IsBitFlag  bool          // Whether the type is a bit flag type
        Extends    string        // The type that this type extends, if any ("" if it doesn't extend)
        MaxValueP1 int64         // the highest defined value for the type, plus one
        Config     *Config       // Configuration information set in the comment directive for the type; is initialized to generator config info first
}

// Value represents a declared constant.
type Value struct {
        OriginalName string // The name of the constant before transformation
        Name         string // The name of the constant after transformation (i.e. camel case => snake case)
        Desc         string // The comment description of the constant
        // The Value is stored as a bit pattern alone. The boolean tells us
        // whether to interpret it as an int64 or a uint64; the only place
        // this matters is when sorting.
        // Much of the time the str field is all we need; it is printed
        // by Value.String.
        Value  int64
        Signed bool   // Whether the constant is a signed type.
        Str    string // The string representation given by the "go/constant" package.
}

func (v *Value) String() string {
        return v.Str
}

// SortValues sorts the values and ensures there
// are no duplicates. The input slice is known
// to be non-empty.
func SortValues(values []Value) []Value {
        // We use stable sort so the lexically first name is chosen for equal elements.
        sort.Stable(ByValue(values))
        // Remove duplicates. Stable sort has put the one we want to print first,
        // so use that one. The String method won't care about which named constant
        // was the argument, so the first name for the given value is the only one to keep.
        // We need to do this because identical values would cause the switch or map
        // to fail to compile.
        j := 1
        for i := 1; i < len(values); i++ {
                if values[i].Value != values[i-1].Value {
                        values[j] = values[i]
                        j++
                }
        }
        return values[:j]
}

// TrimValueNames removes the prefixes specified
// in [Config.TrimPrefix] from each name
// of the given values.
func (g *Generator) TrimValueNames(values []Value, c *Config) {
        for _, prefix := range strings.Split(c.TrimPrefix, ",") {
                for i := range values {
                        values[i].Name = strings.TrimPrefix(values[i].Name, prefix)
                }
        }

}

// PrefixValueNames adds the prefix specified in
// [Config.AddPrefix] to each name of
// the given values.
func (g *Generator) PrefixValueNames(values []Value, c *Config) {
        for i := range values {
                values[i].Name = c.AddPrefix + values[i].Name
        }
}

// TransformValueNames transforms the names of the given values according
// to the transform method specified in [Config.Transform]
func (g *Generator) TransformValueNames(values []Value, c *Config) error {
        var fn func(src string) string
        switch c.Transform {
        case "upper":
                fn = strings.ToUpper
        case "lower":
                fn = strings.ToLower
        case "snake":
                fn = strcase.ToSnake
        case "SNAKE":
                fn = strcase.ToSNAKE
        case "kebab":
                fn = strcase.ToKebab
        case "KEBAB":
                fn = strcase.ToKEBAB
        case "camel":
                fn = strcase.ToCamel
        case "lower-camel":
                fn = strcase.ToLowerCamel
        case "title":
                fn = strcase.ToTitle
        case "sentence":
                fn = strcase.ToSentence
        case "first":
                fn = func(s string) string {
                        r, _ := utf8.DecodeRuneInString(s)
                        return string(r)
                }
        case "first-upper":
                fn = func(s string) string {
                        r, _ := utf8.DecodeRuneInString(s)
                        return strings.ToUpper(string(r))
                }
        case "first-lower":
                fn = func(s string) string {
                        r, _ := utf8.DecodeRuneInString(s)
                        return strings.ToLower(string(r))
                }
        case "":
                return nil
        default:
                return fmt.Errorf("unknown transformation method: %q", c.Transform)
        }

        for i, v := range values {
                after := fn(v.Name)
                // If the original one was "" or the one before the transformation
                // was "" (most commonly if linecomment defines it as empty) we
                // do not care if it's empty.
                // But if any of them was not empty before then it means that
                // the transformed emptied the value
                if v.OriginalName != "" && v.Name != "" && after == "" {
                        return fmt.Errorf("transformation of %q (%s) got an empty result", v.Name, v.OriginalName)
                }
                values[i].Name = after
        }
        return nil
}

// ByValue is a sorting method that sorts the constants into increasing order.
// We take care in the Less method to sort in signed or unsigned order,
// as appropriate.
type ByValue []Value

func (b ByValue) Len() int      { return len(b) }
func (b ByValue) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
func (b ByValue) Less(i, j int) bool {
        if b[i].Signed {
                return int64(b[i].Value) < int64(b[j].Value)
        }
        return b[i].Value < b[j].Value
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package enums

import (
        "errors"
        "fmt"
        "log/slog"
        "strconv"
        "strings"
        "sync/atomic"

        "cogentcore.org/core/base/num"
)

// This file contains implementations of enumgen methods.

// EnumConstraint is the generic type constraint that all enums satisfy.
type EnumConstraint interface {
        Enum
        num.Integer
}

// BitFlagConstraint is the generic type constraint that all bit flags satisfy.
type BitFlagConstraint interface {
        BitFlag
        num.Integer
}

// String returns the string representation of the given
// enum value with the given map.
func String[T EnumConstraint](i T, m map[T]string) string {
        if str, ok := m[i]; ok {
                return str
        }
        return strconv.FormatInt(int64(i), 10)
}

// StringExtended returns the string representation of the given enum value
// with the given map, with the enum type extending the given other enum type.
func StringExtended[T, E EnumConstraint](i T, m map[T]string) string {
        if str, ok := m[i]; ok {
                return str
        }
        return E(i).String()
}

// BitIndexStringExtended returns the string representation of the given bit flag enum
// bit index value with the given map, with the bit flag type extending the given other
// bit flag type.
func BitIndexStringExtended[T, E BitFlagConstraint](i T, m map[T]string) string {
        if str, ok := m[i]; ok {
                return str
        }
        return E(i).BitIndexString()
}

// BitFlagString returns the string representation of the given bit flag value
// with the given values available.
func BitFlagString[T BitFlagConstraint](i T, values []T) string {
        str := ""
        ip := any(&i).(BitFlagSetter)
        for _, ie := range values {
                if ip.HasFlag(ie) {
                        ies := ie.BitIndexString()
                        if str == "" {
                                str = ies
                        } else {
                                str += "|" + ies
                        }
                }
        }
        return str
}

// BitFlagStringExtended returns the string representation of the given bit flag value
// with the given values available, with the bit flag type extending the other given
// bit flag type that has the given values (extendedValues) available.
func BitFlagStringExtended[T, E BitFlagConstraint](i T, values []T, extendedValues []E) string {
        str := ""
        ip := any(&i).(BitFlagSetter)
        for _, ie := range extendedValues {
                if ip.HasFlag(ie) {
                        ies := ie.BitIndexString()
                        if str == "" {
                                str = ies
                        } else {
                                str += "|" + ies
                        }
                }
        }
        for _, ie := range values {
                if ip.HasFlag(ie) {
                        ies := ie.BitIndexString()
                        if str == "" {
                                str = ies
                        } else {
                                str += "|" + ies
                        }
                }
        }
        return str
}

// SetString sets the given enum value from its string representation, the map from
// enum names to values, and the name of the enum type, which is used for the error message.
func SetString[T EnumConstraint](i *T, s string, valueMap map[string]T, typeName string) error {
        if val, ok := valueMap[s]; ok {
                *i = val
                return nil
        }
        return errors.New(s + " is not a valid value for type " + typeName)
}

// SetStringLower sets the given enum value from its string representation, the map from
// enum names to values, and the name of the enum type, which is used for the error message.
// It also tries the lowercase version of the given string if the original version fails.
func SetStringLower[T EnumConstraint](i *T, s string, valueMap map[string]T, typeName string) error {
        if val, ok := valueMap[s]; ok {
                *i = val
                return nil
        }
        if val, ok := valueMap[strings.ToLower(s)]; ok {
                *i = val
                return nil
        }
        return errors.New(s + " is not a valid value for type " + typeName)
}

// SetStringExtended sets the given enum value from its string representation and the map from
// enum names to values, with the enum type extending the other given enum type. It also takes
// the enum value in terms of the extended enum type (ie).
func SetStringExtended[T EnumConstraint, E EnumSetter](i *T, ie E, s string, valueMap map[string]T) error {
        if val, ok := valueMap[s]; ok {
                *i = val
                return nil
        }
        return ie.SetString(s)
}

// SetStringLowerExtended sets the given enum value from its string representation and the map from
// enum names to values, with the enum type extending the other given enum type. It also takes
// the enum value in terms of the extended enum type (ie). It also tries the lowercase version
// of the given string if the original version fails.
func SetStringLowerExtended[T EnumConstraint, E EnumSetter](i *T, ie E, s string, valueMap map[string]T) error {
        if val, ok := valueMap[s]; ok {
                *i = val
                return nil
        }
        if val, ok := valueMap[strings.ToLower(s)]; ok {
                *i = val
                return nil
        }
        return ie.SetString(s)
}

// SetStringOr sets the given bit flag value from its string representation while
// preserving any bit flags already set.
func SetStringOr[T BitFlagConstraint, S BitFlagSetter](i S, s string, valueMap map[string]T, typeName string) error {
        flags := strings.Split(s, "|")
        for _, flag := range flags {
                if val, ok := valueMap[flag]; ok {
                        i.SetFlag(true, val)
                } else if flag == "" {
                        continue
                } else {
                        return fmt.Errorf("%q is not a valid value for type %s", flag, typeName)
                }
        }
        return nil
}

// SetStringOrLower sets the given bit flag value from its string representation while
// preserving any bit flags already set.
// It also tries the lowercase version of each flag string if the original version fails.
func SetStringOrLower[T BitFlagConstraint, S BitFlagSetter](i S, s string, valueMap map[string]T, typeName string) error {
        flags := strings.Split(s, "|")
        for _, flag := range flags {
                if val, ok := valueMap[flag]; ok {
                        i.SetFlag(true, val)
                } else if val, ok := valueMap[strings.ToLower(flag)]; ok {
                        i.SetFlag(true, val)
                } else if flag == "" {
                        continue
                } else {
                        return fmt.Errorf("%q is not a valid value for type %s", flag, typeName)
                }
        }
        return nil
}

// SetStringOrExtended sets the given bit flag value from its string representation while
// preserving any bit flags already set, with the enum type extending the other
// given enum type. It also takes the enum value in terms of the extended enum
// type (ie).
func SetStringOrExtended[T BitFlagConstraint, S BitFlagSetter, E BitFlagSetter](i S, ie E, s string, valueMap map[string]T) error {
        flags := strings.Split(s, "|")
        for _, flag := range flags {
                if val, ok := valueMap[flag]; ok {
                        i.SetFlag(true, val)
                } else if flag == "" {
                        continue
                } else {
                        err := ie.SetStringOr(flag)
                        if err != nil {
                                return err
                        }
                }
        }
        return nil
}

// SetStringOrLowerExtended sets the given bit flag value from its string representation while
// preserving any bit flags already set, with the enum type extending the other
// given enum type. It also takes the enum value in terms of the extended enum
// type (ie). It also tries the lowercase version of each flag string if the original version fails.
func SetStringOrLowerExtended[T BitFlagConstraint, S BitFlagSetter, E BitFlagSetter](i S, ie E, s string, valueMap map[string]T) error {
        flags := strings.Split(s, "|")
        for _, flag := range flags {
                if val, ok := valueMap[flag]; ok {
                        i.SetFlag(true, val)
                } else if val, ok := valueMap[strings.ToLower(flag)]; ok {
                        i.SetFlag(true, val)
                } else if flag == "" {
                        continue
                } else {
                        err := ie.SetStringOr(flag)
                        if err != nil {
                                return err
                        }
                }
        }
        return nil
}

// Desc returns the description of the given enum value.
func Desc[T EnumConstraint](i T, descMap map[T]string) string {
        if str, ok := descMap[i]; ok {
                return str
        }
        return i.String()
}

// DescExtended returns the description of the given enum value, with
// the enum type extending the other given enum type.
func DescExtended[T, E EnumConstraint](i T, descMap map[T]string) string {
        if str, ok := descMap[i]; ok {
                return str
        }
        return E(i).Desc()
}

// ValuesGlobalExtended returns also possible values for the given enum
// type that extends the other given enum type.
func ValuesGlobalExtended[T, E EnumConstraint](values []T, extendedValues []E) []T {
        res := make([]T, len(extendedValues))
        for i, e := range extendedValues {
                res[i] = T(e)
        }
        res = append(res, values...)
        return res
}

// Values returns all possible values for the given enum type.
func Values[T EnumConstraint](values []T) []Enum {
        res := make([]Enum, len(values))
        for i, d := range values {
                res[i] = d
        }
        return res
}

// ValuesExtended returns all possible values for the given enum type
// that extends the other given enum type.
func ValuesExtended[T, E EnumConstraint](values []T, extendedValues []E) []Enum {
        les := len(extendedValues)
        res := make([]Enum, les+len(values))
        for i, d := range extendedValues {
                res[i] = d
        }
        for i, d := range values {
                res[i+les] = d
        }
        return res
}

// HasFlag returns whether this bit flag value has the given bit flag set.
func HasFlag(i *int64, f BitFlag) bool {
        return atomic.LoadInt64(i)&(1<<uint32(f.Int64())) != 0
}

// HasAnyFlags returns whether this bit flag value has any of the given bit flags set.
func HasAnyFlags(i *int64, f ...BitFlag) bool {
        var mask int64
        for _, v := range f {
                mask |= 1 << v.Int64()
        }
        return atomic.LoadInt64(i)&mask != 0
}

// SetFlag sets the value of the given flags in these flags to the given value.
func SetFlag(i *int64, on bool, f ...BitFlag) {
        var mask int64
        for _, v := range f {
                mask |= 1 << v.Int64()
        }
        in := atomic.LoadInt64(i)
        if on {
                in |= mask
                atomic.StoreInt64(i, in)
        } else {
                in &^= mask
                atomic.StoreInt64(i, in)
        }
}

// UnmarshalText loads the enum from the given text.
// It logs any error instead of returning it to prevent
// one modified enum from tanking an entire object loading operation.
func UnmarshalText[T EnumSetter](i T, text []byte, typeName string) error {
        if err := i.SetString(string(text)); err != nil {
                slog.Error(typeName+".UnmarshalText", "err", err)
        }
        return nil
}

// Scan loads the enum from the given SQL scanner value.
func Scan[T EnumSetter](i T, value any, typeName string) error {
        if value == nil {
                return nil
        }

        var str string
        switch v := value.(type) {
        case []byte:
                str = string(v)
        case string:
                str = v
        case fmt.Stringer:
                str = v.String()
        default:
                return fmt.Errorf("invalid value for type %s: %T(%v)", typeName, value, value)
        }

        return i.SetString(str)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
        "image"
        "time"

        "cogentcore.org/core/base/nptime"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/events/key"
)

// Base is the base type for events.
// It is designed to support most event types so no further subtypes
// are needed.
type Base struct {
        // Typ is the type of event, returned as Type()
        Typ Types

        // Flags records event boolean state, using atomic flag operations
        Flags EventFlags

        // GenTime records the time when the event was first generated, using more
        // efficient nptime struct
        GenTime nptime.Time

        // Key Modifiers present when event occurred: for Key, Mouse, Touch events
        Mods key.Modifiers

        // Where is the window-based position in raw display dots
        // (pixels) where event took place.
        Where image.Point

        // Start is the window-based starting position in raw display dots
        // (pixels) where event started.
        Start image.Point

        // Prev is the window-based previous position in raw display dots
        // (pixels) -- e.g., for mouse dragging.
        Prev image.Point

        // StTime is the starting time, using more efficient nptime struct
        StTime nptime.Time

        // PrvTime is the time of the previous event, using more efficient nptime struct
        PrvTime nptime.Time

        // LocalOffset is the offset subtracted from original window coordinates
        // to compute the local coordinates.
        LocalOffset image.Point

        // WhereLocal is the local position, which can be adjusted from the window pos
        // via SubLocalOffset based on a local top-left coordinate for a region within
        // the window.
        WhereLocal image.Point

        // StartLocal is the local starting position
        StartLocal image.Point

        // PrevLocal is the local previous position
        PrevLocal image.Point

        // Button is the mouse button being pressed or released, for relevant events.
        Button Buttons

        // Rune is the meaning of the key event as determined by the
        // operating system. The mapping is determined by system-dependent
        // current layout, modifiers, lock-states, etc.
        Rune rune

        // Code is the identity of the physical key relative to a notional
        // "standard" keyboard, independent of current layout, modifiers,
        // lock-states, etc
        Code key.Codes

        // todo: add El info
        Data any
}

// SetTime sets the event time to Now
func (ev *Base) SetTime() {
        ev.GenTime.Now()
}

func (ev *Base) Init() {
        ev.SetTime()
        ev.SetLocalOff(image.Point{}) // ensure local is copied
}

func (ev Base) Type() Types {
        return ev.Typ
}

func (ev *Base) AsBase() *Base {
        return ev
}

func (ev Base) IsSame(oth Event) bool {
        return ev.Typ == oth.Type() // basic check.  redefine in subtypes
}

func (ev Base) IsUnique() bool {
        return ev.Flags.HasFlag(Unique)
}

func (ev *Base) SetUnique() {
        ev.Flags.SetFlag(true, Unique)
}

func (ev Base) Time() time.Time {
        return ev.GenTime.Time()
}

func (ev Base) StartTime() time.Time {
        return ev.StTime.Time()
}

func (ev Base) SinceStart() time.Duration {
        return ev.Time().Sub(ev.StartTime())
}

func (ev Base) PrevTime() time.Time {
        return ev.PrvTime.Time()
}

func (ev Base) SincePrev() time.Duration {
        return ev.Time().Sub(ev.PrevTime())
}

func (ev Base) IsHandled() bool {
        return ev.Flags.HasFlag(Handled)
}

func (ev *Base) SetHandled() {
        ev.Flags.SetFlag(true, Handled)
}

func (ev *Base) ClearHandled() {
        ev.Flags.SetFlag(false, Handled)
}

func (ev Base) String() string {
        return fmt.Sprintf("%v{Time: %v, Handled: %v}", ev.Typ, ev.Time().Format("04:05"), ev.IsHandled())
}

func (ev Base) OnWinFocus() bool {
        return true
}

// SetModifiers sets the bitflags based on a list of key.Modifiers
func (ev *Base) SetModifiers(mods ...enums.BitFlag) {
        ev.Mods.SetFlag(true, mods...)
}

// HasAllModifiers tests whether all of given modifier(s) were set
func (ev Base) HasAllModifiers(mods ...enums.BitFlag) bool {
        return key.HasAnyModifier(ev.Mods, mods...)
}

func (ev Base) HasAnyModifier(mods ...enums.BitFlag) bool {
        return key.HasAnyModifier(ev.Mods, mods...)
}

func (ev Base) NeedsFocus() bool {
        return false
}

func (ev Base) HasPos() bool {
        return false
}

func (ev Base) WindowPos() image.Point {
        return ev.Where
}

func (ev Base) WindowStartPos() image.Point {
        return ev.Start
}

func (ev Base) WindowPrevPos() image.Point {
        return ev.Prev
}

func (ev Base) StartDelta() image.Point {
        return ev.Pos().Sub(ev.StartPos())
}

func (ev Base) PrevDelta() image.Point {
        return ev.Pos().Sub(ev.PrevPos())
}

func (ev *Base) SetLocalOff(off image.Point) {
        ev.LocalOffset = off
        ev.WhereLocal = ev.Where.Sub(off)
        ev.StartLocal = ev.Start.Sub(off)
        ev.PrevLocal = ev.Prev.Sub(off)
}

func (ev Base) LocalOff() image.Point {
        return ev.LocalOffset
}

func (ev Base) Pos() image.Point {
        return ev.WhereLocal
}

func (ev Base) StartPos() image.Point {
        return ev.StartLocal
}

func (ev Base) PrevPos() image.Point {
        return ev.PrevLocal
}

// SelectMode returns the selection mode based on given modifiers on event
func (ev Base) SelectMode() SelectModes {
        return SelectModeBits(ev.Mods)
}

// MouseButton is the mouse button being pressed or released, for relevant events.
func (ev Base) MouseButton() Buttons {
        return ev.Button
}

// Modifiers returns the modifier keys present at time of event
func (ev Base) Modifiers() key.Modifiers {
        return ev.Mods
}

func (ev Base) KeyRune() rune {
        return ev.Rune
}

func (ev Base) KeyCode() key.Codes {
        return ev.Code
}

// KeyChord returns a string representation of the keyboard event suitable for
// keyboard function maps, etc. Printable runes are sent directly, and
// non-printable ones are converted to their corresponding code names without
// the "Code" prefix.
func (ev Base) KeyChord() key.Chord {
        return key.NewChord(ev.Rune, ev.Code, ev.Mods)
}

func (ev Base) Clone() Event {
        nb := &Base{}
        *nb = ev
        nb.Flags.SetFlag(false, Handled)
        return nb
}

func (ev Base) NewFromClone(typ Types) Event {
        e := ev.Clone()
        eb := e.AsBase()
        eb.Typ = typ
        eb.ClearHandled()
        return e
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
)

// CustomEvent is a user-specified event that can be sent and received
// as needed, and contains a Data field for arbitrary data, and
// optional position and focus parameters
type CustomEvent struct {
        Base

        // set to true if position is available
        PosAvail bool
}

func (ce CustomEvent) String() string {
        return fmt.Sprintf("%v{Data: %v, Time: %v}", ce.Type(), ce.Data, ce.Time())
}

func (ce CustomEvent) HasPos() bool {
        return ce.PosAvail
}

// Copyright 2018 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// based on golang.org/x/exp/shiny:
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
        "sync"
)

// TraceEventCompression can be set to true to see when events
// are being compressed to eliminate laggy behavior.
var TraceEventCompression = false

// Dequer is an infinitely buffered double-ended queue of events.
// If an event is not marked as Unique, and the last
// event in the queue is of the same type, then the new one
// replaces the last one.  This automatically implements
// event compression to manage the common situation where
// event processing is slower than event generation,
// such as with Mouse movement and Paint events.
// The zero value is usable, but a Deque value must not be copied.
type Deque struct {
        Back  []Event // FIFO.
        Front []Event // LIFO.

        Mu   sync.Mutex
        Cond sync.Cond // Cond.L is lazily initialized to &Deque.Mu.
}

func (q *Deque) LockAndInit() {
        q.Mu.Lock()
        if q.Cond.L == nil {
                q.Cond.L = &q.Mu
        }
}

// NextEvent returns the next event in the deque.
// It blocks until such an event has been sent.
func (q *Deque) NextEvent() Event {
        q.LockAndInit()
        defer q.Mu.Unlock()

        for {
                if n := len(q.Front); n > 0 {
                        e := q.Front[n-1]
                        q.Front[n-1] = nil
                        q.Front = q.Front[:n-1]
                        return e
                }

                if n := len(q.Back); n > 0 {
                        e := q.Back[0]
                        q.Back[0] = nil
                        q.Back = q.Back[1:]
                        return e
                }

                q.Cond.Wait()
        }
}

// PollEvent returns the next event in the deque if available,
// and returns true.
// If none are available, it returns false immediately.
func (q *Deque) PollEvent() (Event, bool) {
        q.LockAndInit()
        defer q.Mu.Unlock()

        if n := len(q.Front); n > 0 {
                e := q.Front[n-1]
                q.Front[n-1] = nil
                q.Front = q.Front[:n-1]
                return e, true
        }

        if n := len(q.Back); n > 0 {
                e := q.Back[0]
                q.Back[0] = nil
                q.Back = q.Back[1:]
                return e, true
        }
        return nil, false
}

// Send adds an event to the end of the deque,
// replacing the last of the same type unless marked
// as Unique.
// They are returned by NextEvent in FIFO order.
func (q *Deque) Send(ev Event) {
        q.LockAndInit()
        defer q.Mu.Unlock()

        n := len(q.Back)
        if !ev.IsUnique() && n > 0 {
                lev := q.Back[n-1]
                if ev.IsSame(lev) {
                        q.Back[n-1] = ev // replace
                        switch ev.Type() {
                        case MouseMove, MouseDrag:
                                me := ev.(*Mouse)
                                le := lev.(*Mouse)
                                me.Prev = le.Prev
                                me.PrvTime = le.PrvTime
                        case Scroll:
                                me := ev.(*MouseScroll)
                                le := lev.(*MouseScroll)
                                me.Delta = me.Delta.Add(le.Delta)
                        }
                        q.Cond.Signal()
                        if TraceEventCompression {
                                fmt.Println("compressed back:", ev)
                        }
                        return
                }
        }
        q.Back = append(q.Back, ev)
        q.Cond.Signal()
}

// SendFirst adds an event to the start of the deque.
// They are returned by NextEvent in LIFO order,
// and have priority over events sent via Send.
// This is typically reserved for window events.
func (q *Deque) SendFirst(ev Event) {
        q.LockAndInit()
        defer q.Mu.Unlock()

        n := len(q.Front)
        if !ev.IsUnique() && n > 0 {
                lev := q.Front[n-1]
                if ev.IsSame(lev) {
                        if TraceEventCompression {
                                fmt.Println("compressed front:", ev)
                        }
                        q.Front[n-1] = ev // replace
                        q.Cond.Signal()
                        return
                }
        }
        q.Front = append(q.Front, ev)
        q.Cond.Signal()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
        "image"

        "cogentcore.org/core/events/key"
)

// DragDrop represents the drag-and-drop Drop event
type DragDrop struct {
        Base

        // When event is received by target, DropMod indicates the suggested modifier
        // action associated with the drop (affected by holding down modifier
        // keys), suggesting what to do with the dropped item, where appropriate.
        // Receivers can ignore or process in their own relevant way as needed,
        // BUT it is essential to update the event with the actual type of Mod
        // action taken, because the event will be sent back to the source with
        // this Mod as set by the receiver.  The main consequence is that a
        // DropMove requires the drop source to delete itself once the event has
        // been received, otherwise it (typically) doesn't do anything, so just
        // be careful about that particular case.
        DropMod DropMods

        // Data contains the data from the Source of the drag,
        // typically a mimedata encoded representation.
        Data any

        // Source of the drop, only available for internal DND actions.
        // If it is an external drop, this will be nil.
        Source any

        // Target of the drop -- receiver of an accepted drop should set this to
        // itself, so Source (if internal) can see who got it
        Target any
}

func NewDragDrop(typ Types, mdrag *Mouse) *DragDrop {
        ev := &DragDrop{}
        ev.Base = mdrag.Base
        ev.Flags.SetFlag(false, Handled)
        ev.Typ = typ
        ev.DefaultMod()
        return ev
}

func NewExternalDrop(typ Types, but Buttons, where image.Point, mods key.Modifiers, data any) *DragDrop {
        ev := &DragDrop{}
        ev.Typ = typ
        ev.SetUnique()
        ev.Button = but
        ev.Where = where
        ev.Mods = mods
        ev.Data = data
        return ev
}

func (ev *DragDrop) String() string {
        return fmt.Sprintf("%v{Button: %v, Pos: %v, Mods: %v, Time: %v}", ev.Type(), ev.Button, ev.Where, ev.Mods.ModifiersString(), ev.Time().Format("04:05"))
}

func (ev *DragDrop) HasPos() bool {
        return true
}

// DropMods indicates the modifier associated with the drop action (affected by
// holding down modifier keys), suggesting what to do with the dropped item,
// where appropriate
type DropMods int32 //enums:enum -trim-prefix Drop

const (
        NoDropMod DropMods = iota

        // Copy is the default and implies data is just copied -- receiver can do
        // with it as they please and source does not need to take any further
        // action
        DropCopy

        // Move is signaled with a Shift or Meta key (by default) and implies that
        // the source should delete itself when it receives the DropFromSource event
        // action with this Mod value set -- receiver must update the Mod to
        // reflect actual action taken, and be particularly careful with this one
        DropMove

        // Link can be any other kind of alternative action -- link is applicable
        // to files (symbolic link)
        DropLink

        // Ignore means that the receiver chose to not process this drop
        DropIgnore
)

// DefaultModBits returns the default DropMod modifier action based on modifier keys
func DefaultModBits(mods key.Modifiers) DropMods {
        switch {
        case key.HasAnyModifier(mods, key.Control):
                return DropCopy
        case key.HasAnyModifier(mods, key.Shift, key.Meta):
                return DropMove
        case key.HasAnyModifier(mods, key.Alt):
                return DropLink
        default:
                return DropCopy
        }
}

// DefaultMod sets the default DropMod modifier action based on modifier keys
func (e *DragDrop) DefaultMod() {
        e.DropMod = DefaultModBits(e.Mods)
}

// Code generated by "core generate"; DO NOT EDIT.

package events

import (
        "cogentcore.org/core/enums"
)

var _DropModsValues = []DropMods{0, 1, 2, 3, 4}

// DropModsN is the highest valid value for type DropMods, plus one.
const DropModsN DropMods = 5

var _DropModsValueMap = map[string]DropMods{`NoDropMod`: 0, `Copy`: 1, `Move`: 2, `Link`: 3, `Ignore`: 4}

var _DropModsDescMap = map[DropMods]string{0: ``, 1: `Copy is the default and implies data is just copied -- receiver can do with it as they please and source does not need to take any further action`, 2: `Move is signaled with a Shift or Meta key (by default) and implies that the source should delete itself when it receives the DropFromSource event action with this Mod value set -- receiver must update the Mod to reflect actual action taken, and be particularly careful with this one`, 3: `Link can be any other kind of alternative action -- link is applicable to files (symbolic link)`, 4: `Ignore means that the receiver chose to not process this drop`}

var _DropModsMap = map[DropMods]string{0: `NoDropMod`, 1: `Copy`, 2: `Move`, 3: `Link`, 4: `Ignore`}

// String returns the string representation of this DropMods value.
func (i DropMods) String() string { return enums.String(i, _DropModsMap) }

// SetString sets the DropMods value from its string representation,
// and returns an error if the string is invalid.
func (i *DropMods) SetString(s string) error {
        return enums.SetString(i, s, _DropModsValueMap, "DropMods")
}

// Int64 returns the DropMods value as an int64.
func (i DropMods) Int64() int64 { return int64(i) }

// SetInt64 sets the DropMods value from an int64.
func (i *DropMods) SetInt64(in int64) { *i = DropMods(in) }

// Desc returns the description of the DropMods value.
func (i DropMods) Desc() string { return enums.Desc(i, _DropModsDescMap) }

// DropModsValues returns all possible values for the type DropMods.
func DropModsValues() []DropMods { return _DropModsValues }

// Values returns all possible values for the type DropMods.
func (i DropMods) Values() []enums.Enum { return enums.Values(_DropModsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i DropMods) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *DropMods) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "DropMods") }

var _ButtonsValues = []Buttons{0, 1, 2, 3}

// ButtonsN is the highest valid value for type Buttons, plus one.
const ButtonsN Buttons = 4

var _ButtonsValueMap = map[string]Buttons{`NoButton`: 0, `Left`: 1, `Middle`: 2, `Right`: 3}

var _ButtonsDescMap = map[Buttons]string{0: ``, 1: ``, 2: ``, 3: ``}

var _ButtonsMap = map[Buttons]string{0: `NoButton`, 1: `Left`, 2: `Middle`, 3: `Right`}

// String returns the string representation of this Buttons value.
func (i Buttons) String() string { return enums.String(i, _ButtonsMap) }

// SetString sets the Buttons value from its string representation,
// and returns an error if the string is invalid.
func (i *Buttons) SetString(s string) error {
        return enums.SetString(i, s, _ButtonsValueMap, "Buttons")
}

// Int64 returns the Buttons value as an int64.
func (i Buttons) Int64() int64 { return int64(i) }

// SetInt64 sets the Buttons value from an int64.
func (i *Buttons) SetInt64(in int64) { *i = Buttons(in) }

// Desc returns the description of the Buttons value.
func (i Buttons) Desc() string { return enums.Desc(i, _ButtonsDescMap) }

// ButtonsValues returns all possible values for the type Buttons.
func ButtonsValues() []Buttons { return _ButtonsValues }

// Values returns all possible values for the type Buttons.
func (i Buttons) Values() []enums.Enum { return enums.Values(_ButtonsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Buttons) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Buttons) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Buttons") }

var _SelectModesValues = []SelectModes{0, 1, 2, 3, 4, 5, 6}

// SelectModesN is the highest valid value for type SelectModes, plus one.
const SelectModesN SelectModes = 7

var _SelectModesValueMap = map[string]SelectModes{`SelectOne`: 0, `ExtendContinuous`: 1, `ExtendOne`: 2, `NoSelect`: 3, `Unselect`: 4, `SelectQuiet`: 5, `UnselectQuiet`: 6}

var _SelectModesDescMap = map[SelectModes]string{0: `SelectOne selects a single item, and is the default when no modifier key is pressed`, 1: `ExtendContinuous, activated by Shift key, extends the selection to select a continuous region of selected items, with no gaps`, 2: `ExtendOne, activated by Control or Meta / Command, extends the selection by adding the one additional item just clicked on, creating a potentially discontinuous set of selected items`, 3: `NoSelect means do not update selection -- this is used programmatically and not available via modifier key`, 4: `Unselect means unselect items -- this is used programmatically and not available via modifier key -- typically ExtendOne will unselect if already selected`, 5: `SelectQuiet means select without doing other updates or signals -- for bulk updates with a final update at the end -- used programmatically`, 6: `UnselectQuiet means unselect without doing other updates or signals -- for bulk updates with a final update at the end -- used programmatically`}

var _SelectModesMap = map[SelectModes]string{0: `SelectOne`, 1: `ExtendContinuous`, 2: `ExtendOne`, 3: `NoSelect`, 4: `Unselect`, 5: `SelectQuiet`, 6: `UnselectQuiet`}

// String returns the string representation of this SelectModes value.
func (i SelectModes) String() string { return enums.String(i, _SelectModesMap) }

// SetString sets the SelectModes value from its string representation,
// and returns an error if the string is invalid.
func (i *SelectModes) SetString(s string) error {
        return enums.SetString(i, s, _SelectModesValueMap, "SelectModes")
}

// Int64 returns the SelectModes value as an int64.
func (i SelectModes) Int64() int64 { return int64(i) }

// SetInt64 sets the SelectModes value from an int64.
func (i *SelectModes) SetInt64(in int64) { *i = SelectModes(in) }

// Desc returns the description of the SelectModes value.
func (i SelectModes) Desc() string { return enums.Desc(i, _SelectModesDescMap) }

// SelectModesValues returns all possible values for the type SelectModes.
func SelectModesValues() []SelectModes { return _SelectModesValues }

// Values returns all possible values for the type SelectModes.
func (i SelectModes) Values() []enums.Enum { return enums.Values(_SelectModesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i SelectModes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *SelectModes) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "SelectModes")
}

var _TypesValues = []Types{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47}

// TypesN is the highest valid value for type Types, plus one.
const TypesN Types = 48

var _TypesValueMap = map[string]Types{`UnknownType`: 0, `MouseDown`: 1, `MouseUp`: 2, `MouseMove`: 3, `MouseDrag`: 4, `Click`: 5, `DoubleClick`: 6, `TripleClick`: 7, `ContextMenu`: 8, `LongPressStart`: 9, `LongPressEnd`: 10, `MouseEnter`: 11, `MouseLeave`: 12, `LongHoverStart`: 13, `LongHoverEnd`: 14, `DragStart`: 15, `DragMove`: 16, `DragEnter`: 17, `DragLeave`: 18, `Drop`: 19, `DropDeleteSource`: 20, `SlideStart`: 21, `SlideMove`: 22, `SlideStop`: 23, `Scroll`: 24, `KeyDown`: 25, `KeyUp`: 26, `KeyChord`: 27, `TouchStart`: 28, `TouchEnd`: 29, `TouchMove`: 30, `Magnify`: 31, `Rotate`: 32, `Select`: 33, `Focus`: 34, `FocusLost`: 35, `Attend`: 36, `AttendLost`: 37, `Change`: 38, `Input`: 39, `Show`: 40, `Close`: 41, `Window`: 42, `WindowResize`: 43, `WindowPaint`: 44, `OS`: 45, `OSOpenFiles`: 46, `Custom`: 47}

var _TypesDescMap = map[Types]string{0: `zero value is an unknown type`, 1: `MouseDown happens when a mouse button is pressed down. See MouseButton() for which. See Click for a synthetic event representing a MouseDown followed by MouseUp on the same element with Left (primary) mouse button. Often that is the most useful.`, 2: `MouseUp happens when a mouse button is released. See MouseButton() for which.`, 3: `MouseMove is always sent when the mouse is moving but no button is down, even if there might be other higher-level events too. These can be numerous and thus it is typically more efficient to listen to other events derived from this. Not unique, and Prev position is updated during compression.`, 4: `MouseDrag is always sent when the mouse is moving and there is a button down, even if there might be other higher-level events too. The start pos indicates where (and when) button first was pressed. Not unique and Prev position is updated during compression.`, 5: `Click represents a MouseDown followed by MouseUp in sequence on the same element, with the Left (primary) button. This is the typical event for most basic user interaction.`, 6: `DoubleClick represents two Click events in a row in rapid succession.`, 7: `TripleClick represents three Click events in a row in rapid succession.`, 8: `ContextMenu represents a MouseDown/Up event with the Right mouse button (which is also activated by Control key + Left Click).`, 9: `LongPressStart is when the mouse has been relatively stable after MouseDown on an element for a minimum duration (500 msec default).`, 10: `LongPressEnd is sent after LongPressStart when the mouse has gone up, moved sufficiently, left the current element, or another input event has happened.`, 11: `MouseEnter is when the mouse enters the bounding box of a new element. It is used for setting the Hover state, and can trigger cursor changes. See DragEnter for alternative case during Drag events.`, 12: `MouseLeave is when the mouse leaves the bounding box of an element, that previously had a MouseEnter event. Given that elements can have overlapping bounding boxes (e.g., child elements within a container), it is not the case that a MouseEnter on a child triggers a MouseLeave on surrounding containers. See DragLeave for alternative case during Drag events.`, 13: `LongHoverStart is when the mouse has been relatively stable after MouseEnter on an element for a minimum duration (500 msec default). This triggers the LongHover state typically used for Tooltips.`, 14: `LongHoverEnd is after LongHoverStart when the mouse has moved sufficiently, left the current element, or another input event has happened, thereby terminating the LongHover state.`, 15: `DragStart is at the start of a drag-n-drop event sequence, when a Draggable element is Active and a sufficient distance of MouseDrag events has occurred to engage the DragStart event.`, 16: `DragMove is for a MouseDrag event during the drag-n-drop sequence. Usually don't need to listen to this one. MouseDrag is also sent.`, 17: `DragEnter is like MouseEnter but after a DragStart during a drag-n-drop sequence. MouseEnter is not sent in this case.`, 18: `DragLeave is like MouseLeave but after a DragStart during a drag-n-drop sequence. MouseLeave is not sent in this case.`, 19: `Drop is sent when an item being Dragged is dropped on top of a target element. The event struct should be DragDrop.`, 20: `DropDeleteSource is sent to the source Drag element if the Drag-n-Drop event is a Move type, which requires deleting the source element. The event struct should be DragDrop.`, 21: `SlideStart is for a Slideable element when Active and a sufficient distance of MouseDrag events has occurred to engage the SlideStart event. Sets the Sliding state.`, 22: `SlideMove is for a Slideable element after SlideStart is being dragged via MouseDrag events.`, 23: `SlideStop is when the mouse button is released on a Slideable element being dragged via MouseDrag events. This typically also accompanied by a Changed event for the new slider value.`, 24: `Scroll is for scroll wheel or other scrolling events (gestures). These are not unique and Delta is updated during compression. The [MouseScroll.Delta] on scroll events is always in real pixel/dot units; low-level sources may be in lines or pages, but we normalize everything to real pixels/dots.`, 25: `KeyDown is when a key is pressed down. This provides fine-grained data about each key as it happens. KeyChord is recommended for a more complete Key event.`, 26: `KeyUp is when a key is released. This provides fine-grained data about each key as it happens. KeyChord is recommended for a more complete Key event.`, 27: `KeyChord is only generated when a non-modifier key is released, and it also contains a string representation of the full chord, suitable for translation into keyboard commands, emacs-style etc. It can be somewhat delayed relative to the KeyUp.`, 28: `TouchStart is when a touch event starts, for the low-level touch event processing. TouchStart also activates MouseDown, Scroll, Magnify, or Rotate events depending on gesture recognition.`, 29: `TouchEnd is when a touch event ends, for the low-level touch event processing. TouchEnd also activates MouseUp events depending on gesture recognition.`, 30: `TouchMove is when a touch event moves, for the low-level touch event processing. TouchMove also activates MouseMove, Scroll, Magnify, or Rotate events depending on gesture recognition.`, 31: `Magnify is a touch-based magnify event (e.g., pinch)`, 32: `Rotate is a touch-based rotate event.`, 33: `Select is sent for any direction of selection change on (or within if relevant) a Selectable element. Typically need to query the element(s) to determine current selection state.`, 34: `Focus is sent when a Focusable element receives keyboard focus (ie: by tabbing).`, 35: `FocusLost is sent when a Focusable element loses keyboard focus.`, 36: `Attend is sent when a Pressable element is programmatically set as Attended through an event. Typically the Attended state is engaged by clicking. Attention is like Focus, in that there is only 1 element at a time in the Attended state, but it does not direct keyboard input. The primary effect of attention is on scrolling events via [abilities.ScrollableUnattended].`, 37: `AttendLost is sent when a different Pressable element is Attended.`, 38: `Change is when a value represented by the element has been changed by the user and committed (for example, someone has typed text in a textfield and then pressed enter). This is *not* triggered when the value has not been committed; see [Input] for that. This is for Editable, Checkable, and Slidable items.`, 39: `Input is when a value represented by the element has changed, but has not necessarily been committed (for example, this triggers each time someone presses a key in a text field). This *is* triggered when the value has not been committed; see [Change] for a version that only occurs when the value is committed. This is for Editable, Checkable, and Slidable items.`, 40: `Show is sent to widgets when their Scene is first shown to the user in its final form, and whenever a major content managing widget (e.g., [core.Tabs], [core.Pages]) shows a new tab/page/element (via [core.WidgetBase.Shown] or DeferShown). This can be used for updates that depend on other elements, or relatively expensive updates that should be only done when actually needed "at show time".`, 41: `Close is sent to widgets when their Scene is being closed. This is an opportunity to save unsaved edits, for example. This is guaranteed to only happen once per widget per Scene.`, 42: `Window reports on changes in the window position, visibility (iconify), focus changes, screen update, and closing. These are only sent once per event (Unique).`, 43: `WindowResize happens when the window has been resized, which can happen continuously during a user resizing episode. These are not Unique events, and are compressed to minimize lag.`, 44: `WindowPaint is sent continuously at FPS frequency (60 frames per second by default) to drive updating check on the window. It is not unique, will be compressed to keep pace with updating.`, 45: `OS is an operating system generated event (app level typically)`, 46: `OSOpenFiles is an event telling app to open given files`, 47: `Custom is a user-defined event with a data any field`}

var _TypesMap = map[Types]string{0: `UnknownType`, 1: `MouseDown`, 2: `MouseUp`, 3: `MouseMove`, 4: `MouseDrag`, 5: `Click`, 6: `DoubleClick`, 7: `TripleClick`, 8: `ContextMenu`, 9: `LongPressStart`, 10: `LongPressEnd`, 11: `MouseEnter`, 12: `MouseLeave`, 13: `LongHoverStart`, 14: `LongHoverEnd`, 15: `DragStart`, 16: `DragMove`, 17: `DragEnter`, 18: `DragLeave`, 19: `Drop`, 20: `DropDeleteSource`, 21: `SlideStart`, 22: `SlideMove`, 23: `SlideStop`, 24: `Scroll`, 25: `KeyDown`, 26: `KeyUp`, 27: `KeyChord`, 28: `TouchStart`, 29: `TouchEnd`, 30: `TouchMove`, 31: `Magnify`, 32: `Rotate`, 33: `Select`, 34: `Focus`, 35: `FocusLost`, 36: `Attend`, 37: `AttendLost`, 38: `Change`, 39: `Input`, 40: `Show`, 41: `Close`, 42: `Window`, 43: `WindowResize`, 44: `WindowPaint`, 45: `OS`, 46: `OSOpenFiles`, 47: `Custom`}

// String returns the string representation of this Types value.
func (i Types) String() string { return enums.String(i, _TypesMap) }

// SetString sets the Types value from its string representation,
// and returns an error if the string is invalid.
func (i *Types) SetString(s string) error { return enums.SetString(i, s, _TypesValueMap, "Types") }

// Int64 returns the Types value as an int64.
func (i Types) Int64() int64 { return int64(i) }

// SetInt64 sets the Types value from an int64.
func (i *Types) SetInt64(in int64) { *i = Types(in) }

// Desc returns the description of the Types value.
func (i Types) Desc() string { return enums.Desc(i, _TypesDescMap) }

// TypesValues returns all possible values for the type Types.
func TypesValues() []Types { return _TypesValues }

// Values returns all possible values for the type Types.
func (i Types) Values() []enums.Enum { return enums.Values(_TypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Types) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Types) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Types") }

var _EventFlagsValues = []EventFlags{0, 1}

// EventFlagsN is the highest valid value for type EventFlags, plus one.
const EventFlagsN EventFlags = 2

var _EventFlagsValueMap = map[string]EventFlags{`Handled`: 0, `Unique`: 1}

var _EventFlagsDescMap = map[EventFlags]string{0: `Handled indicates that the event has been handled`, 1: `EventUnique indicates that the event is Unique and not to be compressed with like events.`}

var _EventFlagsMap = map[EventFlags]string{0: `Handled`, 1: `Unique`}

// String returns the string representation of this EventFlags value.
func (i EventFlags) String() string { return enums.BitFlagString(i, _EventFlagsValues) }

// BitIndexString returns the string representation of this EventFlags value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i EventFlags) BitIndexString() string { return enums.String(i, _EventFlagsMap) }

// SetString sets the EventFlags value from its string representation,
// and returns an error if the string is invalid.
func (i *EventFlags) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the EventFlags value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *EventFlags) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _EventFlagsValueMap, "EventFlags")
}

// Int64 returns the EventFlags value as an int64.
func (i EventFlags) Int64() int64 { return int64(i) }

// SetInt64 sets the EventFlags value from an int64.
func (i *EventFlags) SetInt64(in int64) { *i = EventFlags(in) }

// Desc returns the description of the EventFlags value.
func (i EventFlags) Desc() string { return enums.Desc(i, _EventFlagsDescMap) }

// EventFlagsValues returns all possible values for the type EventFlags.
func EventFlagsValues() []EventFlags { return _EventFlagsValues }

// Values returns all possible values for the type EventFlags.
func (i EventFlags) Values() []enums.Enum { return enums.Values(_EventFlagsValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *EventFlags) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *EventFlags) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i EventFlags) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *EventFlags) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "EventFlags")
}

var _WinActionsValues = []WinActions{0, 1, 2, 3, 4, 5, 6, 7}

// WinActionsN is the highest valid value for type WinActions, plus one.
const WinActionsN WinActions = 8

var _WinActionsValueMap = map[string]WinActions{`NoWinAction`: 0, `Close`: 1, `Minimize`: 2, `Move`: 3, `Focus`: 4, `FocusLost`: 5, `Show`: 6, `ScreenUpdate`: 7}

var _WinActionsDescMap = map[WinActions]string{0: `NoWinAction is the zero value for special types (Resize, Paint)`, 1: `WinClose means that the window is about to close, but has not yet closed.`, 2: `WinMinimize means that the window has been iconified / miniaturized / is no longer visible.`, 3: `WinMove means that the window was moved but NOT resized or changed in any other way -- does not require a redraw, but anything tracking positions will want to update.`, 4: `WinFocus indicates that the window has been activated for receiving user input.`, 5: `WinFocusLost indicates that the window is no longer activated for receiving input.`, 6: `WinShow is for the WindowShow event -- sent by the system shortly after the window has opened, to ensure that full rendering is completed with the proper size, and to trigger one-time actions such as configuring the main menu after the window has opened.`, 7: `ScreenUpdate occurs when any of the screen information is updated This event is sent to the first window on the list of active windows and it should then perform any necessary updating`}

var _WinActionsMap = map[WinActions]string{0: `NoWinAction`, 1: `Close`, 2: `Minimize`, 3: `Move`, 4: `Focus`, 5: `FocusLost`, 6: `Show`, 7: `ScreenUpdate`}

// String returns the string representation of this WinActions value.
func (i WinActions) String() string { return enums.String(i, _WinActionsMap) }

// SetString sets the WinActions value from its string representation,
// and returns an error if the string is invalid.
func (i *WinActions) SetString(s string) error {
        return enums.SetString(i, s, _WinActionsValueMap, "WinActions")
}

// Int64 returns the WinActions value as an int64.
func (i WinActions) Int64() int64 { return int64(i) }

// SetInt64 sets the WinActions value from an int64.
func (i *WinActions) SetInt64(in int64) { *i = WinActions(in) }

// Desc returns the description of the WinActions value.
func (i WinActions) Desc() string { return enums.Desc(i, _WinActionsDescMap) }

// WinActionsValues returns all possible values for the type WinActions.
func WinActionsValues() []WinActions { return _WinActionsValues }

// Values returns all possible values for the type WinActions.
func (i WinActions) Values() []enums.Enum { return enums.Values(_WinActionsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i WinActions) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *WinActions) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "WinActions")
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"

        "cogentcore.org/core/events/key"
)

// events.Key is a low-level immediately generated key event, tracking press
// and release of keys -- suitable for fine-grained tracking of key events --
// see also events.Key for events that are generated only on key press,
// and that include the full chord information about all the modifier keys
// that were present when a non-modifier key was released
type Key struct {
        Base
}

func NewKey(typ Types, rn rune, code key.Codes, mods key.Modifiers) *Key {
        ev := &Key{}
        ev.Typ = typ
        ev.SetUnique()
        ev.Rune = rn
        ev.Code = code
        ev.Mods = mods
        return ev
}

func (ev *Key) HasPos() bool {
        return false
}

func (ev *Key) NeedsFocus() bool {
        return true
}

func (ev *Key) String() string {
        if ev.Typ == KeyChord {
                return fmt.Sprintf("%v{Chord: %v, Rune: %d, Hex: %X, Mods: %v, Time: %v, Handled: %v}", ev.Type(), ev.KeyChord(), ev.Rune, ev.Rune, ev.Mods.ModifiersString(), ev.Time().Format("04:05"), ev.IsHandled())
        }
        return fmt.Sprintf("%v{Code: %v, Mods: %v, Time: %v, Handled: %v}", ev.Type(), ev.Code, ev.Mods.ModifiersString(), ev.Time().Format("04:05"), ev.IsHandled())
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package key

import (
        "fmt"
        "runtime"
        "strings"
        "unicode"
)

// Chord represents the key chord associated with a given key function; it
// is linked to the [cogentcore.org/core/core.KeyChordValue] so you can just
// type keys to set key chords.
type Chord string

// SystemPlatform is the string version of [cogentcore.org/core/system.App.SystemPlatform],
// which is set by system during initialization so that this package can conditionalize
// shortcut formatting based on the underlying system platform without import cycles.
var SystemPlatform string

// NewChord returns a string representation of the keyboard event suitable for
// keyboard function maps, etc. Printable runes are sent directly, and
// non-printable ones are converted to their corresponding code names without
// the "Code" prefix.
func NewChord(rn rune, code Codes, mods Modifiers) Chord {
        modstr := mods.ModifiersString()
        if modstr != "" && code == CodeSpacebar { // modified space is not regular space
                return Chord(modstr + "Spacebar")
        }
        if unicode.IsPrint(rn) {
                if len(modstr) > 0 {
                        return Chord(modstr + string(unicode.ToUpper(rn))) // all modded keys are uppercase!
                }
                return Chord(string(rn))
        }
        // now convert code
        codestr := strings.TrimPrefix(code.String(), "Code")
        return Chord(modstr + codestr)
}

// PlatformChord translates Command into either Control or Meta depending on the platform
func (ch Chord) PlatformChord() Chord {
        sc := string(ch)
        if SystemPlatform == "MacOS" {
                sc = strings.ReplaceAll(sc, "Command+", "Meta+")
        } else {
                sc = strings.ReplaceAll(sc, "Command+", "Control+")
        }
        return Chord(sc)
}

// CodeIsModifier returns true if given code is a modifier key
func CodeIsModifier(c Codes) bool {
        return c >= CodeLeftControl && c <= CodeRightMeta
}

// IsMulti returns true if the Chord represents a multi-key sequence
func (ch Chord) IsMulti() bool {
        return strings.Contains(string(ch), " ")
}

// Chords returns the multiple keys represented in a multi-key sequence
func (ch Chord) Chords() []Chord {
        ss := strings.Fields(string(ch))
        nc := len(ss)
        if nc <= 1 {
                return []Chord{ch}
        }
        cc := make([]Chord, nc)
        for i, s := range ss {
                cc[i] = Chord(s)
        }
        return cc
}

// Decode decodes a chord string into rune and modifiers (set as bit flags)
func (ch Chord) Decode() (r rune, code Codes, mods Modifiers, err error) {
        cs := string(ch.PlatformChord())
        cs, _, _ = strings.Cut(cs, "\n") // we only care about the first chord
        mods, cs = ModifiersFromString(cs)
        rs := ([]rune)(cs)
        if len(rs) == 1 {
                r = rs[0]
                return
        }
        cstr := string(cs)
        code.SetString(cstr)
        if code != CodeUnknown {
                r = 0
                return
        }
        err = fmt.Errorf("system/events/key.DecodeChord got more/less than one rune: %v from remaining chord: %v", rs, string(cs))
        return
}

// Label transforms the chord string into a short form suitable for display to users.
func (ch Chord) Label() string {
        cs := string(ch.PlatformChord())
        cs = strings.ReplaceAll(cs, "Control", "Ctrl")
        switch SystemPlatform {
        case "MacOS":
                if runtime.GOOS == "js" { // no font to display symbol on web
                        cs = strings.ReplaceAll(cs, "Meta+", "Cmd+")
                } else {
                        cs = strings.ReplaceAll(cs, "Meta+", "⌘")
                        // need to have + after ⌘ when before other modifiers
                        cs = strings.ReplaceAll(cs, "⌘Alt", "⌘+Alt")
                        cs = strings.ReplaceAll(cs, "⌘Shift", "⌘+Shift")
                }
        case "Windows":
                cs = strings.ReplaceAll(cs, "Meta+", "Win+")
        }
        cs = strings.ReplaceAll(cs, "\n", " or ")
        return cs
}

// Code generated by "core generate"; DO NOT EDIT.

package key

import (
        "cogentcore.org/core/enums"
)

var _CodesValues = []Codes{0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 117, 127, 128, 129, 224, 225, 226, 227, 228, 229, 230, 231, 65536}

// CodesN is the highest valid value for type Codes, plus one.
const CodesN Codes = 65537

var _CodesValueMap = map[string]Codes{`Unknown`: 0, `A`: 4, `B`: 5, `C`: 6, `D`: 7, `E`: 8, `F`: 9, `G`: 10, `H`: 11, `I`: 12, `J`: 13, `K`: 14, `L`: 15, `M`: 16, `N`: 17, `O`: 18, `P`: 19, `Q`: 20, `R`: 21, `S`: 22, `T`: 23, `U`: 24, `V`: 25, `W`: 26, `X`: 27, `Y`: 28, `Z`: 29, `1`: 30, `2`: 31, `3`: 32, `4`: 33, `5`: 34, `6`: 35, `7`: 36, `8`: 37, `9`: 38, `0`: 39, `ReturnEnter`: 40, `Escape`: 41, `Backspace`: 42, `Tab`: 43, `Spacebar`: 44, `HyphenMinus`: 45, `EqualSign`: 46, `LeftSquareBracket`: 47, `RightSquareBracket`: 48, `Backslash`: 49, `Semicolon`: 51, `Apostrophe`: 52, `GraveAccent`: 53, `Comma`: 54, `FullStop`: 55, `Slash`: 56, `CapsLock`: 57, `F1`: 58, `F2`: 59, `F3`: 60, `F4`: 61, `F5`: 62, `F6`: 63, `F7`: 64, `F8`: 65, `F9`: 66, `F10`: 67, `F11`: 68, `F12`: 69, `Pause`: 72, `Insert`: 73, `Home`: 74, `PageUp`: 75, `Delete`: 76, `End`: 77, `PageDown`: 78, `RightArrow`: 79, `LeftArrow`: 80, `DownArrow`: 81, `UpArrow`: 82, `KeypadNumLock`: 83, `KeypadSlash`: 84, `KeypadAsterisk`: 85, `KeypadHyphenMinus`: 86, `KeypadPlusSign`: 87, `KeypadEnter`: 88, `Keypad1`: 89, `Keypad2`: 90, `Keypad3`: 91, `Keypad4`: 92, `Keypad5`: 93, `Keypad6`: 94, `Keypad7`: 95, `Keypad8`: 96, `Keypad9`: 97, `Keypad0`: 98, `KeypadFullStop`: 99, `KeypadEqualSign`: 103, `F13`: 104, `F14`: 105, `F15`: 106, `F16`: 107, `F17`: 108, `F18`: 109, `F19`: 110, `F20`: 111, `F21`: 112, `F22`: 113, `F23`: 114, `F24`: 115, `Help`: 117, `Mute`: 127, `VolumeUp`: 128, `VolumeDown`: 129, `LeftControl`: 224, `LeftShift`: 225, `LeftAlt`: 226, `LeftMeta`: 227, `RightControl`: 228, `RightShift`: 229, `RightAlt`: 230, `RightMeta`: 231, `Compose`: 65536}

var _CodesDescMap = map[Codes]string{0: ``, 4: ``, 5: ``, 6: ``, 7: ``, 8: ``, 9: ``, 10: ``, 11: ``, 12: ``, 13: ``, 14: ``, 15: ``, 16: ``, 17: ``, 18: ``, 19: ``, 20: ``, 21: ``, 22: ``, 23: ``, 24: ``, 25: ``, 26: ``, 27: ``, 28: ``, 29: ``, 30: ``, 31: ``, 32: ``, 33: ``, 34: ``, 35: ``, 36: ``, 37: ``, 38: ``, 39: ``, 40: ``, 41: ``, 42: ``, 43: ``, 44: ``, 45: ``, 46: ``, 47: ``, 48: ``, 49: ``, 51: ``, 52: ``, 53: ``, 54: ``, 55: ``, 56: ``, 57: ``, 58: ``, 59: ``, 60: ``, 61: ``, 62: ``, 63: ``, 64: ``, 65: ``, 66: ``, 67: ``, 68: ``, 69: ``, 72: ``, 73: ``, 74: ``, 75: ``, 76: ``, 77: ``, 78: ``, 79: ``, 80: ``, 81: ``, 82: ``, 83: ``, 84: ``, 85: ``, 86: ``, 87: ``, 88: ``, 89: ``, 90: ``, 91: ``, 92: ``, 93: ``, 94: ``, 95: ``, 96: ``, 97: ``, 98: ``, 99: ``, 103: ``, 104: ``, 105: ``, 106: ``, 107: ``, 108: ``, 109: ``, 110: ``, 111: ``, 112: ``, 113: ``, 114: ``, 115: ``, 117: ``, 127: ``, 128: ``, 129: ``, 224: ``, 225: ``, 226: ``, 227: ``, 228: ``, 229: ``, 230: ``, 231: ``, 65536: `CodeCompose is the Code for a compose key, sometimes called a multi key, used to input non-ASCII characters such as ñ being composed of n and ~. See https://en.wikipedia.org/wiki/Compose_key`}

var _CodesMap = map[Codes]string{0: `Unknown`, 4: `A`, 5: `B`, 6: `C`, 7: `D`, 8: `E`, 9: `F`, 10: `G`, 11: `H`, 12: `I`, 13: `J`, 14: `K`, 15: `L`, 16: `M`, 17: `N`, 18: `O`, 19: `P`, 20: `Q`, 21: `R`, 22: `S`, 23: `T`, 24: `U`, 25: `V`, 26: `W`, 27: `X`, 28: `Y`, 29: `Z`, 30: `1`, 31: `2`, 32: `3`, 33: `4`, 34: `5`, 35: `6`, 36: `7`, 37: `8`, 38: `9`, 39: `0`, 40: `ReturnEnter`, 41: `Escape`, 42: `Backspace`, 43: `Tab`, 44: `Spacebar`, 45: `HyphenMinus`, 46: `EqualSign`, 47: `LeftSquareBracket`, 48: `RightSquareBracket`, 49: `Backslash`, 51: `Semicolon`, 52: `Apostrophe`, 53: `GraveAccent`, 54: `Comma`, 55: `FullStop`, 56: `Slash`, 57: `CapsLock`, 58: `F1`, 59: `F2`, 60: `F3`, 61: `F4`, 62: `F5`, 63: `F6`, 64: `F7`, 65: `F8`, 66: `F9`, 67: `F10`, 68: `F11`, 69: `F12`, 72: `Pause`, 73: `Insert`, 74: `Home`, 75: `PageUp`, 76: `Delete`, 77: `End`, 78: `PageDown`, 79: `RightArrow`, 80: `LeftArrow`, 81: `DownArrow`, 82: `UpArrow`, 83: `KeypadNumLock`, 84: `KeypadSlash`, 85: `KeypadAsterisk`, 86: `KeypadHyphenMinus`, 87: `KeypadPlusSign`, 88: `KeypadEnter`, 89: `Keypad1`, 90: `Keypad2`, 91: `Keypad3`, 92: `Keypad4`, 93: `Keypad5`, 94: `Keypad6`, 95: `Keypad7`, 96: `Keypad8`, 97: `Keypad9`, 98: `Keypad0`, 99: `KeypadFullStop`, 103: `KeypadEqualSign`, 104: `F13`, 105: `F14`, 106: `F15`, 107: `F16`, 108: `F17`, 109: `F18`, 110: `F19`, 111: `F20`, 112: `F21`, 113: `F22`, 114: `F23`, 115: `F24`, 117: `Help`, 127: `Mute`, 128: `VolumeUp`, 129: `VolumeDown`, 224: `LeftControl`, 225: `LeftShift`, 226: `LeftAlt`, 227: `LeftMeta`, 228: `RightControl`, 229: `RightShift`, 230: `RightAlt`, 231: `RightMeta`, 65536: `Compose`}

// String returns the string representation of this Codes value.
func (i Codes) String() string { return enums.String(i, _CodesMap) }

// SetString sets the Codes value from its string representation,
// and returns an error if the string is invalid.
func (i *Codes) SetString(s string) error { return enums.SetString(i, s, _CodesValueMap, "Codes") }

// Int64 returns the Codes value as an int64.
func (i Codes) Int64() int64 { return int64(i) }

// SetInt64 sets the Codes value from an int64.
func (i *Codes) SetInt64(in int64) { *i = Codes(in) }

// Desc returns the description of the Codes value.
func (i Codes) Desc() string { return enums.Desc(i, _CodesDescMap) }

// CodesValues returns all possible values for the type Codes.
func CodesValues() []Codes { return _CodesValues }

// Values returns all possible values for the type Codes.
func (i Codes) Values() []enums.Enum { return enums.Values(_CodesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Codes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Codes) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Codes") }

var _ModifiersValues = []Modifiers{0, 1, 2, 3}

// ModifiersN is the highest valid value for type Modifiers, plus one.
const ModifiersN Modifiers = 4

var _ModifiersValueMap = map[string]Modifiers{`Control`: 0, `Meta`: 1, `Alt`: 2, `Shift`: 3}

var _ModifiersDescMap = map[Modifiers]string{0: `Control is the "Control" (Ctrl) key.`, 1: `Meta is the system meta key (the "Command" key on macOS and the Windows key on Windows).`, 2: `Alt is the "Alt" ("Option" on macOS) key.`, 3: `Shift is the "Shift" key.`}

var _ModifiersMap = map[Modifiers]string{0: `Control`, 1: `Meta`, 2: `Alt`, 3: `Shift`}

// String returns the string representation of this Modifiers value.
func (i Modifiers) String() string { return enums.BitFlagString(i, _ModifiersValues) }

// BitIndexString returns the string representation of this Modifiers value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i Modifiers) BitIndexString() string { return enums.String(i, _ModifiersMap) }

// SetString sets the Modifiers value from its string representation,
// and returns an error if the string is invalid.
func (i *Modifiers) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the Modifiers value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *Modifiers) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _ModifiersValueMap, "Modifiers")
}

// Int64 returns the Modifiers value as an int64.
func (i Modifiers) Int64() int64 { return int64(i) }

// SetInt64 sets the Modifiers value from an int64.
func (i *Modifiers) SetInt64(in int64) { *i = Modifiers(in) }

// Desc returns the description of the Modifiers value.
func (i Modifiers) Desc() string { return enums.Desc(i, _ModifiersDescMap) }

// ModifiersValues returns all possible values for the type Modifiers.
func ModifiersValues() []Modifiers { return _ModifiersValues }

// Values returns all possible values for the type Modifiers.
func (i Modifiers) Values() []enums.Enum { return enums.Values(_ModifiersValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *Modifiers) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *Modifiers) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Modifiers) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Modifiers) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Modifiers")
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package key

//go:generate core generate

import (
        "strings"

        "cogentcore.org/core/enums"
)

// Modifiers are used as bitflags representing a set of modifier keys.
type Modifiers int64 //enums:bitflag

const (
        // Control is the "Control" (Ctrl) key.
        Control Modifiers = iota

        // Meta is the system meta key (the "Command" key on macOS
        // and the Windows key on Windows).
        Meta

        // Alt is the "Alt" ("Option" on macOS) key.
        Alt

        // Shift is the "Shift" key.
        Shift
)

// ModifiersString returns the string representation of the modifiers using
// plus symbols as seperators. The order is given by Modifiers order:
// Control, Meta, Alt, Shift.
func (mo Modifiers) ModifiersString() string {
        modstr := ""
        for _, m := range ModifiersValues() {
                if mo.HasFlag(m) {
                        modstr += m.BitIndexString() + "+"
                }
        }
        return modstr
}

// ModifiersFromString returns the modifiers corresponding to given string
// and the remainder of the string after modifiers have been stripped
func ModifiersFromString(cs string) (Modifiers, string) {
        var mods Modifiers
        for _, m := range ModifiersValues() {
                mstr := m.BitIndexString() + "+"
                if strings.HasPrefix(cs, mstr) {
                        mods.SetFlag(true, m)
                        cs = strings.TrimPrefix(cs, mstr)
                }
        }
        return mods, cs
}

// HasAnyModifier tests whether any of given modifier(s) were set
func HasAnyModifier(flags Modifiers, mods ...enums.BitFlag) bool {
        for _, m := range mods {
                if flags.HasFlag(m) {
                        return true
                }
        }
        return false
}

// HasAllModifiers tests whether all of given modifier(s) were set
func HasAllModifiers(flags Modifiers, mods ...enums.BitFlag) bool {
        for _, m := range mods {
                if !flags.HasFlag(m) {
                        return false
                }
        }
        return true
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

// Listeners registers lists of event listener functions
// to receive different event types.
// Listeners are closure methods with all context captured.
// Functions are called in *reverse* order of when they are added:
// First In, Last Called, so that "base" functions are typically
// added first, and then can be overridden by later-added ones.
// Call SetHandled() on the event to stop further propagation.
type Listeners map[Types][]func(ev Event)

// Init ensures that the map is constructed.
func (ls *Listeners) Init() {
        if *ls != nil {
                return
        }
        *ls = make(map[Types][]func(Event))
}

// Add adds a listener for the given type to the end of the current stack
// such that it will be called before everything else already on the stack.
func (ls *Listeners) Add(typ Types, fun func(e Event)) {
        ls.Init()
        ets := (*ls)[typ]
        ets = append(ets, fun)
        (*ls)[typ] = ets
}

// HandlesEventType returns true if this listener handles the given event type.
func (ls *Listeners) HandlesEventType(typ Types) bool {
        if *ls == nil {
                return false
        }
        _, has := (*ls)[typ]
        return has
}

// Call calls all functions for given event.
// It goes in reverse order so the last functions added are the first called
// and it stops when the event is marked as Handled.  This allows for a natural
// and optional override behavior, as compared to requiring more complex
// priority-based mechanisms. Also, it takes an optional function that
// it calls before each event handler is run, returning if it returns
// false.
func (ls *Listeners) Call(ev Event, shouldContinue ...func() bool) {
        if ev.IsHandled() {
                return
        }
        typ := ev.Type()
        ets := (*ls)[typ]
        n := len(ets)
        for i := n - 1; i >= 0; i-- {
                if len(shouldContinue) > 0 && !shouldContinue[0]() {
                        break
                }
                fun := ets[i]
                fun(ev)
                if ev.IsHandled() {
                        break
                }
        }
}

// CopyFromExtra copies additional listeners from given source
// beyond those present in the receiver.
func (ls *Listeners) CopyFromExtra(fr Listeners) {
        for typ, l := range *ls {
                fl, has := fr[typ]
                if has {
                        n := len(l)
                        if len(fl) > n {
                                l = append(l, fl[n:]...)
                                (*ls)[typ] = l
                        }
                } else {
                        (*ls)[typ] = fl
                }
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
        "image"

        "cogentcore.org/core/events/key"
        "cogentcore.org/core/math32"
)

var (
        // ScrollWheelSpeed controls how fast the scroll wheel moves (typically
        // interpreted as pixels per wheel step).
        // This is also in core.DeviceSettings and updated from there
        ScrollWheelSpeed = float32(1)
)

// Buttons is a mouse button.
type Buttons int32 //enums:enum

// TODO: have a separate axis concept for wheel up/down? How does that relate
// to joystick events?

const (
        NoButton Buttons = iota
        Left
        Middle
        Right
)

// Mouse is a basic mouse event for all mouse events except Scroll
type Mouse struct {
        Base

        // TODO: have a field to hold what other buttons are down, for detecting
        // drags or button-chords.

        // TODO: add a Device ID, for multiple input devices?
}

func NewMouse(typ Types, but Buttons, where image.Point, mods key.Modifiers) *Mouse {
        ev := &Mouse{}
        ev.Typ = typ
        ev.SetUnique()
        ev.Button = but
        ev.Where = where
        ev.Mods = mods
        return ev
}

func (ev *Mouse) String() string {
        return fmt.Sprintf("%v{Button: %v, Pos: %v, Mods: %v, Time: %v}", ev.Type(), ev.Button, ev.Where, ev.Mods.ModifiersString(), ev.Time().Format("04:05"))
}

func (ev Mouse) HasPos() bool {
        return true
}

func NewMouseMove(but Buttons, where, prev image.Point, mods key.Modifiers) *Mouse {
        ev := &Mouse{}
        ev.Typ = MouseMove
        // not unique
        ev.Button = but
        ev.Where = where
        ev.Prev = prev
        ev.Mods = mods
        return ev
}

func NewMouseDrag(but Buttons, where, prev, start image.Point, mods key.Modifiers) *Mouse {
        ev := &Mouse{}
        ev.Typ = MouseDrag
        // not unique
        ev.Button = but
        ev.Where = where
        ev.Prev = prev
        ev.Start = start
        ev.Mods = mods
        return ev
}

// MouseScroll is for mouse scrolling, recording the delta of the scroll
type MouseScroll struct {
        Mouse

        // Delta is the amount of scrolling in each axis, which is always in pixel/dot
        // units (see [Scroll]).
        Delta math32.Vector2
}

func (ev *MouseScroll) String() string {
        return fmt.Sprintf("%v{Delta: %v, Pos: %v, Mods: %v, Time: %v}", ev.Type(), ev.Delta, ev.Where, ev.Mods.ModifiersString(), ev.Time().Format("04:05"))
}

func NewScroll(where image.Point, delta math32.Vector2, mods key.Modifiers) *MouseScroll {
        ev := &MouseScroll{}
        ev.Typ = Scroll
        // not unique, but delta integrated!
        ev.Where = where
        ev.Delta = delta
        ev.Mods = mods
        return ev
}

// Copyright (c) 2021 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
)

// OSEvent reports an OS level event
type OSEvent struct {
        Base
}

func NewOSEvent(typ Types) *OSEvent {
        ev := &OSEvent{}
        ev.Typ = typ
        return ev
}

func (ev *OSEvent) String() string {
        return fmt.Sprintf("%v{Time: %v}", ev.Type(), ev.Time().Format("04:05"))
}

// osevent.OpenFilesEvent is for OS open files action to open given files
type OSFiles struct {
        OSEvent

        // Files are a list of files to open
        Files []string
}

func NewOSFiles(typ Types, files []string) *OSFiles {
        ev := &OSFiles{}
        ev.Typ = typ
        ev.Files = files
        return ev
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "cogentcore.org/core/events/key"
)

// SelectModes interprets the modifier keys to determine what type of selection mode to use.
// This is also used for selection actions and has modes not directly activated by
// modifier keys.
type SelectModes int32 //enums:enum

const (
        // SelectOne selects a single item, and is the default when no modifier key
        // is pressed
        SelectOne SelectModes = iota

        // ExtendContinuous, activated by Shift key, extends the selection to
        // select a continuous region of selected items, with no gaps
        ExtendContinuous

        // ExtendOne, activated by Control or Meta / Command, extends the
        // selection by adding the one additional item just clicked on, creating a
        // potentially discontinuous set of selected items
        ExtendOne

        // NoSelect means do not update selection -- this is used programmatically
        // and not available via modifier key
        NoSelect

        // Unselect means unselect items -- this is used programmatically
        // and not available via modifier key -- typically ExtendOne will
        // unselect if already selected
        Unselect

        // SelectQuiet means select without doing other updates or signals -- for
        // bulk updates with a final update at the end -- used programmatically
        SelectQuiet

        // UnselectQuiet means unselect without doing other updates or signals -- for
        // bulk updates with a final update at the end -- used programmatically
        UnselectQuiet
)

// SelectModeBits returns the selection mode based on given modifiers bitflags
func SelectModeBits(mods key.Modifiers) SelectModes {
        if key.HasAnyModifier(mods, key.Shift) {
                return ExtendContinuous
        }
        if key.HasAnyModifier(mods, key.Meta) {
                return ExtendOne
        }
        return SelectOne
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
        "image"

        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/base/nptime"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/math32"
)

// TraceWindowPaint prints out a . for each WindowPaint event,
// - for other window events, and * for mouse move events.
// Makes it easier to see what is going on in the overall flow.
var TraceWindowPaint = false

// Source is a source of events that manages the event
// construction and sending process for its parent window.
// It caches state as needed to generate derived events such
// as [MouseDrag].
type Source struct {
        // Deque is the event queue
        Deque Deque

        // flag for ignoring mouse events when disabling mouse movement
        ResettingPos bool

        // Last has the prior state for key variables
        Last SourceState

        // PaintCount is used for printing paint events as .
        PaintCount int
}

// SourceState tracks basic event state over time
// to enable recognition and full data for generating events.
type SourceState struct {
        // last mouse button event type (down or up)
        MouseButtonType Types

        // last mouse button
        MouseButton Buttons

        // time of MouseDown
        MouseDownTime nptime.Time

        // position at MouseDown
        MouseDownPos image.Point

        // position of mouse from move events
        MousePos image.Point

        // time of last move
        MouseMoveTime nptime.Time

        // keyboard modifiers (Shift, Alt, etc)
        Mods key.Modifiers

        // Key event code
        Key key.Codes
}

// SendKey processes a basic key event and sends it
func (es *Source) Key(typ Types, rn rune, code key.Codes, mods key.Modifiers) {
        ev := NewKey(typ, rn, code, mods)
        es.Last.Mods = mods
        es.Last.Key = code
        ev.Init()
        es.Deque.Send(ev)

        _, mapped := key.CodeRuneMap[code]

        if typ == KeyDown && ev.Code < key.CodeLeftControl &&
                (ev.HasAnyModifier(key.Control, key.Meta) || !mapped || ev.Code == key.CodeTab) {
                che := NewKey(KeyChord, rn, code, mods)
                che.Init()
                es.Deque.Send(che)
        }
}

// KeyChord processes a basic KeyChord event and sends it
func (es *Source) KeyChord(rn rune, code key.Codes, mods key.Modifiers) {
        ev := NewKey(KeyChord, rn, code, mods)
        // no further processing of these
        ev.Init()
        es.Deque.Send(ev)
}

// MouseButton creates and sends a mouse button event with given values
func (es *Source) MouseButton(typ Types, but Buttons, where image.Point, mods key.Modifiers) {
        ev := NewMouse(typ, but, where, mods)
        if typ != MouseDown && es.Last.MouseButtonType == MouseDown {
                ev.StTime = es.Last.MouseDownTime
                ev.PrvTime = es.Last.MouseMoveTime
                ev.Start = es.Last.MouseDownPos
                ev.Prev = es.Last.MousePos
        }
        es.Last.Mods = mods
        es.Last.MouseButtonType = typ
        es.Last.MouseButton = but
        es.Last.MousePos = where
        ev.Init()
        if typ == MouseDown {
                es.Last.MouseDownPos = where
                es.Last.MouseDownTime = ev.GenTime
                es.Last.MouseMoveTime = ev.GenTime
        }
        es.Deque.Send(ev)
}

// MouseMove creates and sends a mouse move or drag event with given values
func (es *Source) MouseMove(where image.Point) {
        lastPos := es.Last.MousePos
        var ev *Mouse
        if es.Last.MouseButtonType == MouseDown {
                ev = NewMouseDrag(es.Last.MouseButton, where, lastPos, es.Last.MouseDownPos, es.Last.Mods)
                ev.StTime = es.Last.MouseDownTime
                ev.PrvTime = es.Last.MouseMoveTime
        } else {
                ev = NewMouseMove(es.Last.MouseButton, where, lastPos, es.Last.Mods)
                ev.PrvTime = es.Last.MouseMoveTime
        }
        ev.Init()
        es.Last.MouseMoveTime = ev.GenTime
        // if em.Win.IsCursorEnabled() {
        es.Last.MousePos = where
        // }
        if TraceWindowPaint {
                fmt.Printf("*")
        }
        es.Deque.Send(ev)
}

// Scroll creates and sends a scroll event with given values
func (es *Source) Scroll(where image.Point, delta math32.Vector2) {
        ev := NewScroll(where, delta, es.Last.Mods)
        ev.Init()
        es.Deque.Send(ev)
}

// DropExternal creates and sends a Drop event with given values
func (es *Source) DropExternal(where image.Point, md mimedata.Mimes) {
        ev := NewExternalDrop(Drop, es.Last.MouseButton, where, es.Last.Mods, md)
        es.Last.MousePos = where
        ev.Init()
        es.Deque.Send(ev)
}

// Touch creates and sends a touch event with the given values.
// It also creates and sends a corresponding mouse event.
func (es *Source) Touch(typ Types, seq Sequence, where image.Point) {
        ev := NewTouch(typ, seq, where)
        ev.Init()
        es.Deque.Send(ev)

        if typ == TouchStart {
                es.MouseButton(MouseDown, Left, where, 0) // TODO: modifiers
        } else if typ == TouchEnd {
                es.MouseButton(MouseUp, Left, where, 0) // TODO: modifiers
        } else {
                es.MouseMove(where)
        }
}

// Magnify creates and sends a [TouchMagnify] event with the given values.
func (es *Source) Magnify(scaleFactor float32, where image.Point) {
        ev := NewMagnify(scaleFactor, where)
        ev.Init()
        es.Deque.Send(ev)
}

//        func (es *Source) DND(act dnd.Actions, where image.Point, data mimedata.Mimes) {
//                ev := dnd.NewEvent(act, where, em.Last.Mods)
//                ev.Data = data
//                ev.Init()
//                es.Deque.Send(ev)
//        }

func (es *Source) Window(act WinActions) {
        ev := NewWindow(act)
        ev.Init()
        if TraceWindowPaint {
                fmt.Printf("-")
        }
        es.Deque.SendFirst(ev)
}

// WindowPaint sends a [NewWindowPaint] event.
func (es *Source) WindowPaint() {
        ev := NewWindowPaint()
        ev.Init()

        if TraceWindowPaint {
                fmt.Printf(".")
                es.PaintCount++
                if es.PaintCount > 60 {
                        fmt.Println("")
                        es.PaintCount = 0
                }
        }
        es.Deque.SendFirst(ev) // separate channel for window!
}

func (es *Source) WindowResize() {
        ev := NewWindowResize()
        ev.Init()
        if TraceWindowPaint {
                fmt.Printf("r")
        }
        es.Deque.SendFirst(ev)
}

func (es *Source) Custom(data any) {
        ce := &CustomEvent{}
        ce.Typ = Custom
        ce.Data = data
        ce.Init()
        es.Deque.Send(ce)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
        "image"
)

// The best source on android input events is the NDK: include/android/input.h
//
// iOS event handling guide:
// https://developer.apple.com/library/ios/documentation/EventHandling/Conceptual/EventHandlingiPhoneOS

// Touch is a touch event.
type Touch struct {
        Base

        // Sequence is the sequence number. The same number is shared by all events
        // in a sequence. A sequence begins with a single Begin, is followed by
        // zero or more Moves, and ends with a single End. A Sequence
        // distinguishes concurrent sequences but its value is subsequently reused.
        Sequence Sequence
}

// Sequence identifies a sequence of touch events.
type Sequence int64

// NewTouch creates a new touch event from the given values.
func NewTouch(typ Types, seq Sequence, where image.Point) *Touch {
        ev := &Touch{}
        ev.Typ = typ
        ev.SetUnique()
        ev.Sequence = seq
        ev.Where = where
        return ev
}

func (ev *Touch) HasPos() bool {
        return true
}

func (ev *Touch) String() string {
        return fmt.Sprintf("%v{Pos: %v, Sequence: %v, Time: %v}", ev.Type(), ev.Where, ev.Sequence, ev.Time().Format("04:05"))
}

// todo: what about these higher-level abstractions of touch-like events?

// TouchMagnify is a touch magnification (scaling) gesture event.
// It is the event struct corresponding to events of type [Magnify].
type TouchMagnify struct {
        Touch
        // the multiplicative scale factor relative to the previous
        // zoom of the screen
        ScaleFactor float32
}

// NewMagnify creates a new [TouchMagnify] event based on
// the given multiplicative scale factor.
func NewMagnify(scaleFactor float32, where image.Point) *TouchMagnify {
        ev := &TouchMagnify{}
        ev.Typ = Magnify
        ev.ScaleFactor = scaleFactor
        ev.Where = where
        return ev
}

// // check for interface implementation
// var _ Event = &MagnifyEvent{}

// ////////////////////////////////////////////

// // RotateEvent is used to represent a rotation gesture.
// type RotateEvent struct {
//         GestureEvent
//         Rotation float64 // measured in degrees; positive == clockwise
// }

// func (ev *RotateEvent) EventTypes() EventTypes {
//         return RotateEventTypes
// }

// // check for interface implementation
// var _ Event = &RotateEvent{}

// // Scroll Event is used to represent a scrolling gesture.
// type ScrollEvent struct {
//         GestureEvent
//         Delta image.Point
// }

// func (ev *ScrollEvent) EventTypes() EventTypes {
//         return ScrollEventTypes
// }

// // check for interface implementation
// var _ Event = &ScrollEvent{}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

//go:generate core generate

// Types determines the type of GUI event, and also the
// level at which one can select which events to listen to.
// The type should include both the source / nature of the event
// and the "action" type of the event (e.g., MouseDown, MouseUp
// are separate event types). The standard
// [JavaScript Event](https://developer.mozilla.org/en-US/docs/Web/Events)
// provide the basis for most of the event type names and categories.
// Most events use the same Base type and only need
// to set relevant fields and the type.
// Unless otherwise noted, all events are marked as Unique,
// meaning they are always sent.  Non-Unique events are subject
// to compression, where if the last event added (and not yet
// processed and therefore removed from the queue) is of the same type
// then it is replaced with the new one, instead of adding.
type Types int32 //enums:enum

const (
        // zero value is an unknown type
        UnknownType Types = iota

        // MouseDown happens when a mouse button is pressed down.
        // See MouseButton() for which.
        // See Click for a synthetic event representing a MouseDown
        // followed by MouseUp on the same element with Left (primary)
        // mouse button. Often that is the most useful.
        MouseDown

        // MouseUp happens when a mouse button is released.
        // See MouseButton() for which.
        MouseUp

        // MouseMove is always sent when the mouse is moving but no
        // button is down, even if there might be other higher-level events too.
        // These can be numerous and thus it is typically more efficient
        // to listen to other events derived from this.
        // Not unique, and Prev position is updated during compression.
        MouseMove

        // MouseDrag is always sent when the mouse is moving and there
        // is a button down, even if there might be other higher-level
        // events too.
        // The start pos indicates where (and when) button first was pressed.
        // Not unique and Prev position is updated during compression.
        MouseDrag

        // Click represents a MouseDown followed by MouseUp
        // in sequence on the same element, with the Left (primary) button.
        // This is the typical event for most basic user interaction.
        Click

        // DoubleClick represents two Click events in a row in rapid
        // succession.
        DoubleClick

        // TripleClick represents three Click events in a row in rapid
        // succession.
        TripleClick

        // ContextMenu represents a MouseDown/Up event with the
        // Right mouse button (which is also activated by
        // Control key + Left Click).
        ContextMenu

        // LongPressStart is when the mouse has been relatively stable
        // after MouseDown on an element for a minimum duration (500 msec default).
        LongPressStart

        // LongPressEnd is sent after LongPressStart when the mouse has
        // gone up, moved sufficiently, left the current element,
        // or another input event has happened.
        LongPressEnd

        // MouseEnter is when the mouse enters the bounding box
        // of a new element.  It is used for setting the Hover state,
        // and can trigger cursor changes.
        // See DragEnter for alternative case during Drag events.
        MouseEnter

        // MouseLeave is when the mouse leaves the bounding box
        // of an element, that previously had a MouseEnter event.
        // Given that elements can have overlapping bounding boxes
        // (e.g., child elements within a container), it is not the case
        // that a MouseEnter on a child triggers a MouseLeave on
        // surrounding containers.
        // See DragLeave for alternative case during Drag events.
        MouseLeave

        // LongHoverStart is when the mouse has been relatively stable
        // after MouseEnter on an element for a minimum duration
        // (500 msec default).
        // This triggers the LongHover state typically used for Tooltips.
        LongHoverStart

        // LongHoverEnd is after LongHoverStart when the mouse has
        // moved sufficiently, left the current element,
        // or another input event has happened,
        // thereby terminating the LongHover state.
        LongHoverEnd

        // DragStart is at the start of a drag-n-drop event sequence, when
        // a Draggable element is Active and a sufficient distance of
        // MouseDrag events has occurred to engage the DragStart event.
        DragStart

        // DragMove is for a MouseDrag event during the drag-n-drop sequence.
        // Usually don't need to listen to this one.  MouseDrag is also sent.
        DragMove

        // DragEnter is like MouseEnter but after a DragStart during a
        // drag-n-drop sequence.  MouseEnter is not sent in this case.
        DragEnter

        // DragLeave is like MouseLeave but after a DragStart during a
        // drag-n-drop sequence.  MouseLeave is not sent in this case.
        DragLeave

        // Drop is sent when an item being Dragged is dropped on top of a
        // target element. The event struct should be DragDrop.
        Drop

        // DropDeleteSource is sent to the source Drag element if the
        // Drag-n-Drop event is a Move type, which requires deleting
        // the source element.  The event struct should be DragDrop.
        DropDeleteSource

        // SlideStart is for a Slideable element when Active and a
        // sufficient distance of MouseDrag events has occurred to
        // engage the SlideStart event.  Sets the Sliding state.
        SlideStart

        // SlideMove is for a Slideable element after SlideStart
        // is being dragged via MouseDrag events.
        SlideMove

        // SlideStop is when the mouse button is released on a Slideable
        // element being dragged via MouseDrag events.  This typically
        // also accompanied by a Changed event for the new slider value.
        SlideStop

        // Scroll is for scroll wheel or other scrolling events (gestures).
        // These are not unique and Delta is updated during compression.
        // The [MouseScroll.Delta] on scroll events is always in real pixel/dot units;
        // low-level sources may be in lines or pages, but we normalize everything
        // to real pixels/dots.
        Scroll

        // KeyDown is when a key is pressed down.
        // This provides fine-grained data about each key as it happens.
        // KeyChord is recommended for a more complete Key event.
        KeyDown

        // KeyUp is when a key is released.
        // This provides fine-grained data about each key as it happens.
        // KeyChord is recommended for a more complete Key event.
        KeyUp

        // KeyChord is only generated when a non-modifier key is released,
        // and it also contains a string representation of the full chord,
        // suitable for translation into keyboard commands, emacs-style etc.
        // It can be somewhat delayed relative to the KeyUp.
        KeyChord

        // TouchStart is when a touch event starts, for the low-level touch
        // event processing.  TouchStart also activates MouseDown, Scroll,
        // Magnify, or Rotate events depending on gesture recognition.
        TouchStart

        // TouchEnd is when a touch event ends, for the low-level touch
        // event processing.  TouchEnd also activates MouseUp events
        // depending on gesture recognition.
        TouchEnd

        // TouchMove is when a touch event moves, for the low-level touch
        // event processing.  TouchMove also activates MouseMove, Scroll,
        // Magnify, or Rotate events depending on gesture recognition.
        TouchMove

        // Magnify is a touch-based magnify event (e.g., pinch)
        Magnify

        // Rotate is a touch-based rotate event.
        Rotate

        // Select is sent for any direction of selection change
        // on (or within if relevant) a Selectable element.
        // Typically need to query the element(s) to determine current
        // selection state.
        Select

        // Focus is sent when a Focusable element receives keyboard focus (ie: by tabbing).
        Focus

        // FocusLost is sent when a Focusable element loses keyboard focus.
        FocusLost

        // Attend is sent when a Pressable element is programmatically set
        // as Attended through an event. Typically the Attended state is engaged
        // by clicking. Attention is like Focus, in that there is only 1 element
        // at a time in the Attended state, but it does not direct keyboard input.
        // The primary effect of attention is on scrolling events via
        // [abilities.ScrollableUnattended].
        Attend

        // AttendLost is sent when a different Pressable element is Attended.
        AttendLost

        // Change is when a value represented by the element has been changed
        // by the user and committed (for example, someone has typed text in a
        // textfield and then pressed enter). This is *not* triggered when
        // the value has not been committed; see [Input] for that.
        // This is for Editable, Checkable, and Slidable items.
        Change

        // Input is when a value represented by the element has changed, but
        // has not necessarily been committed (for example, this triggers each
        // time someone presses a key in a text field). This *is* triggered when
        // the value has not been committed; see [Change] for a version that only
        // occurs when the value is committed.
        // This is for Editable, Checkable, and Slidable items.
        Input

        // Show is sent to widgets when their Scene is first shown to the user
        // in its final form, and whenever a major content managing widget
        // (e.g., [core.Tabs], [core.Pages]) shows a new tab/page/element (via
        // [core.WidgetBase.Shown] or DeferShown). This can be used for updates
        // that depend on other elements, or relatively expensive updates that
        // should be only done when actually needed "at show time".
        Show

        // Close is sent to widgets when their Scene is being closed. This is an
        // opportunity to save unsaved edits, for example. This is guaranteed to
        // only happen once per widget per Scene.
        Close

        // Window reports on changes in the window position,
        // visibility (iconify), focus changes, screen update, and closing.
        // These are only sent once per event (Unique).
        Window

        // WindowResize happens when the window has been resized,
        // which can happen continuously during a user resizing
        // episode.  These are not Unique events, and are compressed
        // to minimize lag.
        WindowResize

        // WindowPaint is sent continuously at FPS frequency
        // (60 frames per second by default) to drive updating check
        // on the window.  It is not unique, will be compressed
        // to keep pace with updating.
        WindowPaint

        // OS is an operating system generated event (app level typically)
        OS

        // OSOpenFiles is an event telling app to open given files
        OSOpenFiles

        // Custom is a user-defined event with a data any field
        Custom
)

// IsKey returns true if event type is a Key type
func (tp Types) IsKey() bool {
        return tp >= KeyDown && tp <= KeyChord
}

// IsMouse returns true if event type is a Mouse type
func (tp Types) IsMouse() bool {
        return tp >= MouseDown && tp <= LongHoverEnd
}

// IsTouch returns true if event type is a Touch type
func (tp Types) IsTouch() bool {
        return tp >= TouchStart && tp <= Rotate
}

// IsDrag returns true if event type is a Drag type
func (tp Types) IsDrag() bool {
        return tp >= DragStart && tp <= DragLeave
}

// IsSlide returns true if event type is a Slide type
func (tp Types) IsSlide() bool {
        return tp >= SlideStart && tp <= SlideStop
}

// IsWindow returns true if event type is a Window type
func (tp Types) IsWindow() bool {
        return tp >= Window && tp <= WindowPaint
}

// EventFlags encode boolean event properties
type EventFlags int64 //enums:bitflag

const (
        // Handled indicates that the event has been handled
        Handled EventFlags = iota

        // EventUnique indicates that the event is Unique and not
        // to be compressed with like events.
        Unique
)

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package events

import (
        "fmt"
)

// WindowEvent reports on actions taken on a window.
// The system.Window Flags and other state information
// will always be updated prior to this event being sent,
// so those should be consulted directly for the new current state.
type WindowEvent struct {
        Base

        // Action taken on the window -- what has changed.
        // Window state fields have current values.
        Action WinActions
}

func NewWindow(act WinActions) *WindowEvent {
        ev := &WindowEvent{}
        ev.Action = act
        ev.Typ = Window
        ev.SetUnique()
        return ev
}

func NewWindowResize() *WindowEvent {
        ev := &WindowEvent{}
        ev.Typ = WindowResize
        // not unique
        return ev
}

func NewWindowPaint() *WindowEvent {
        ev := &WindowEvent{}
        ev.Typ = WindowPaint
        // not unique
        return ev
}

func (ev *WindowEvent) HasPos() bool {
        return false
}

func (ev *WindowEvent) String() string {
        return fmt.Sprintf("%v{Action: %v, Time: %v}", ev.Type(), ev.Action, ev.Time().Format("04:05"))
}

// WinActions is the action taken on the window by the user.
type WinActions int32 //enums:enum -trim-prefix Win

const (
        // NoWinAction is the zero value for special types (Resize, Paint)
        NoWinAction WinActions = iota

        // WinClose means that the window is about to close, but has not yet closed.
        WinClose

        // WinMinimize means that the window has been iconified / miniaturized / is no
        // longer visible.
        WinMinimize

        // WinMove means that the window was moved but NOT resized or changed in any
        // other way -- does not require a redraw, but anything tracking positions
        // will want to update.
        WinMove

        // WinFocus indicates that the window has been activated for receiving user
        // input.
        WinFocus

        // WinFocusLost indicates that the window is no longer activated for
        // receiving input.
        WinFocusLost

        // WinShow is for the WindowShow event -- sent by the system shortly
        // after the window has opened, to ensure that full rendering
        // is completed with the proper size, and to trigger one-time actions such as
        // configuring the main menu after the window has opened.
        WinShow

        // ScreenUpdate occurs when any of the screen information is updated
        // This event is sent to the first window on the list of active windows
        // and it should then perform any necessary updating
        ScreenUpdate
)

// Command async demonstrates async updating in Cogent Core.
package main

import (
        "time"

        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
)

type tableStruct struct {
        Icon       icons.Icon
        IntField   int
        FloatField float32
        StrField   string
        File       core.Filename
}

const rows = 100000

func main() {
        table := make([]*tableStruct, 0, rows)
        b := core.NewBody("Async Updating")
        tv := core.NewTable(b)
        tv.SetReadOnly(true)
        tv.SetSlice(&table)

        b.OnShow(func(e events.Event) {
                go func() {
                        for i := 0; i < rows; i++ {
                                b.AsyncLock()
                                table = append(table, &tableStruct{IntField: i, FloatField: float32(i) / 10.0})
                                tv.Update()
                                if len(table) > 0 {
                                        tv.ScrollToIndex(len(table) - 1)
                                }
                                b.AsyncUnlock()
                                time.Sleep(1 * time.Millisecond)
                        }
                }()
        })

        b.RunMainWindow()
}

package main

import "cogentcore.org/core/core"

func main() {
        b := core.NewBody()
        core.NewButton(b).SetText("Hello, World!")
        b.RunMainWindow()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

//go:generate core generate

import (
        "embed"
        "fmt"
        "image"
        "strconv"
        "strings"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/textcore"
        "cogentcore.org/core/tree"
)

//go:embed demo.go
var demoFile embed.FS

func main() {
        b := core.NewBody("Cogent Core Demo")
        ts := core.NewTabs(b)

        home(ts)
        widgets(ts)
        collections(ts)
        valueBinding(ts)
        makeStyles(ts)

        b.RunMainWindow()
}

func home(ts *core.Tabs) {
        tab, _ := ts.NewTab("Home")
        tab.Styler(func(s *styles.Style) {
                s.CenterAll()
        })

        errors.Log(core.NewSVG(tab).ReadString(core.AppIcon))

        core.NewText(tab).SetType(core.TextDisplayLarge).SetText("The Cogent Core Demo")
        core.NewText(tab).SetType(core.TextTitleLarge).SetText(`A <b>demonstration</b> of the <i>various</i> features of the <a href="https://cogentcore.org/core">Cogent Core</a> 2D and 3D Go GUI <u>framework</u>`)
}

func widgets(ts *core.Tabs) {
        wts := core.NewTabs(ts.NewTab("Widgets"))

        text(wts)
        buttons(wts)
        inputs(wts)
        sliders(wts)
        dialogs(wts)
        textEditors(wts)
}

func text(ts *core.Tabs) {
        tab, _ := ts.NewTab("Text")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Text")
        core.NewText(tab).SetText("Cogent Core provides fully customizable text elements that can be styled in any way you want. Also, there are pre-configured style types for text that allow you to easily create common text types.")

        for _, typ := range core.TextTypesValues() {
                s := strcase.ToSentence(typ.String())
                core.NewText(tab).SetType(typ).SetText(s)
        }
        core.NewText(tab).SetText("Emojis: 🧁🍰🎁")
        core.NewText(tab).SetText("Hebrew/RTL: אָהַבְתָּ אֵת יְיָ | אֱלֹהֶיךָ, בְּכָל-לְבָֽבְךָ, Let there be light וּבְכָל-נַפְשְׁךָ,")
        core.NewText(tab).SetText("Chinese/Japanese/Korean: 国際化活動・計算機科学を勉強する・한국어")
}

func makeRow(parent core.Widget) *core.Frame {
        row := core.NewFrame(parent)
        row.Styler(func(s *styles.Style) {
                s.Wrap = true
                s.Align.Items = styles.Center
        })
        return row
}

func buttons(ts *core.Tabs) {
        tab, _ := ts.NewTab("Buttons")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Buttons")

        core.NewText(tab).SetText("Cogent Core provides customizable buttons that support various events and can be styled in any way you want. Also, there are pre-configured style types for buttons that allow you to achieve common functionality with ease. All buttons support any combination of text, an icon, and an indicator.")

        rowm := makeRow(tab)
        rowti := makeRow(tab)
        rowt := makeRow(tab)
        rowi := makeRow(tab)

        menu := func(m *core.Scene) {
                m1 := core.NewButton(m).SetText("Menu Item 1").SetIcon(icons.Save).SetShortcut("Control+Shift+1")
                m1.SetTooltip("A standard menu item with an icon")
                m1.OnClick(func(e events.Event) {
                        fmt.Println("Clicked on menu item 1")
                })

                m2 := core.NewButton(m).SetText("Menu Item 2").SetIcon(icons.Open)
                m2.SetTooltip("A menu item with an icon and a sub menu")

                m2.Menu = func(m *core.Scene) {
                        sm2 := core.NewButton(m).SetText("Sub Menu Item 2").SetIcon(icons.InstallDesktop).
                                SetTooltip("A sub menu item with an icon")
                        sm2.OnClick(func(e events.Event) {
                                fmt.Println("Clicked on sub menu item 2")
                        })
                }

                core.NewSeparator(m)

                m3 := core.NewButton(m).SetText("Menu Item 3").SetIcon(icons.Favorite).SetShortcut("Control+3").
                        SetTooltip("A standard menu item with an icon, below a separator")
                m3.OnClick(func(e events.Event) {
                        fmt.Println("Clicked on menu item 3")
                })
        }

        ics := []icons.Icon{
                icons.Search, icons.Home, icons.Close, icons.Done, icons.Favorite, icons.PlayArrow,
                icons.Add, icons.Delete, icons.ArrowBack, icons.Info, icons.Refresh, icons.VideoCall,
                icons.Menu, icons.Settings, icons.AccountCircle, icons.Download, icons.Sort, icons.DateRange,
        }

        for _, typ := range core.ButtonTypesValues() {
                // not really a real button, so not worth including in demo
                if typ == core.ButtonMenu {
                        continue
                }

                s := strings.TrimPrefix(typ.String(), "Button")
                sl := strings.ToLower(s)
                art := "A "
                if typ == core.ButtonElevated || typ == core.ButtonOutlined || typ == core.ButtonAction {
                        art = "An "
                }

                core.NewButton(rowm).SetType(typ).SetText(s).SetIcon(ics[typ]).SetMenu(menu).
                        SetTooltip(art + sl + " menu button with text and an icon")

                b := core.NewButton(rowti).SetType(typ).SetText(s).SetIcon(ics[typ+6]).
                        SetTooltip("A " + sl + " button with text and an icon")
                b.OnClick(func(e events.Event) {
                        fmt.Println("Got click event on", b.Name)
                })

                bt := core.NewButton(rowt).SetType(typ).SetText(s).
                        SetTooltip("A " + sl + " button with text")
                bt.OnClick(func(e events.Event) {
                        fmt.Println("Got click event on", bt.Name)
                })

                bi := core.NewButton(rowi).SetType(typ).SetIcon(ics[typ+12]).
                        SetTooltip("A " + sl + " button with an icon")
                bi.OnClick(func(e events.Event) {
                        fmt.Println("Got click event on", bi.Name)
                })
        }
}

func inputs(ts *core.Tabs) {
        tab, _ := ts.NewTab("Inputs")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Inputs")
        core.NewText(tab).SetText("Cogent Core provides various customizable input widgets that cover all common uses. Various events can be bound to inputs, and their data can easily be fetched and used wherever needed. There are also pre-configured style types for most inputs that allow you to easily switch among common styling patterns.")

        core.NewTextField(tab).SetPlaceholder("Text field")
        core.NewTextField(tab).AddClearButton().SetLeadingIcon(icons.Search)
        core.NewTextField(tab).SetType(core.TextFieldOutlined).SetTypePassword().SetPlaceholder("Password")
        core.NewTextField(tab).SetText("Text field with relatively long initial text")

        spinners := core.NewFrame(tab)

        core.NewSpinner(spinners).SetStep(5).SetMin(-50).SetMax(100).SetValue(15)
        core.NewSpinner(spinners).SetFormat("%X").SetStep(1).SetMax(255).SetValue(44)

        choosers := core.NewFrame(tab)

        fruits := []core.ChooserItem{
                {Value: "Apple", Tooltip: "A round, edible fruit that typically has red skin"},
                {Value: "Apricot", Tooltip: "A stonefruit with a yellow or orange color"},
                {Value: "Blueberry", Tooltip: "A small blue or purple berry"},
                {Value: "Blackberry", Tooltip: "A small, edible, dark fruit"},
                {Value: "Peach", Tooltip: "A fruit with yellow or white flesh and a large seed"},
                {Value: "Strawberry", Tooltip: "A widely consumed small, red fruit"},
        }

        core.NewChooser(choosers).SetPlaceholder("Select a fruit").SetItems(fruits...).SetAllowNew(true)
        core.NewChooser(choosers).SetPlaceholder("Select a fruit").SetItems(fruits...).SetType(core.ChooserOutlined)
        core.NewChooser(tab).SetEditable(true).SetPlaceholder("Select or type a fruit").SetItems(fruits...).SetAllowNew(true)
        core.NewChooser(tab).SetEditable(true).SetPlaceholder("Select or type a fruit").SetItems(fruits...).SetType(core.ChooserOutlined)

        core.NewSwitch(tab).SetText("Toggle")

        core.NewSwitches(tab).SetItems(
                core.SwitchItem{Value: "Switch 1", Tooltip: "The first switch"},
                core.SwitchItem{Value: "Switch 2", Tooltip: "The second switch"},
                core.SwitchItem{Value: "Switch 3", Tooltip: "The third switch"})

        core.NewSwitches(tab).SetType(core.SwitchChip).SetStrings("Chip 1", "Chip 2", "Chip 3")
        core.NewSwitches(tab).SetType(core.SwitchCheckbox).SetStrings("Checkbox 1", "Checkbox 2", "Checkbox 3")
        cs := core.NewSwitches(tab).SetType(core.SwitchCheckbox).SetStrings("Indeterminate 1", "Indeterminate 2", "Indeterminate 3")
        cs.SetOnChildAdded(func(n tree.Node) {
                core.AsWidget(n).SetState(true, states.Indeterminate)
        })

        core.NewSwitches(tab).SetType(core.SwitchRadioButton).SetMutex(true).SetStrings("Radio Button 1", "Radio Button 2", "Radio Button 3")
        rs := core.NewSwitches(tab).SetType(core.SwitchRadioButton).SetMutex(true).SetStrings("Indeterminate 1", "Indeterminate 2", "Indeterminate 3")
        rs.SetOnChildAdded(func(n tree.Node) {
                core.AsWidget(n).SetState(true, states.Indeterminate)
        })

        core.NewSwitches(tab).SetType(core.SwitchSegmentedButton).SetMutex(true).SetStrings("Segmented Button 1", "Segmented Button 2", "Segmented Button 3")
}

func sliders(ts *core.Tabs) {
        tab, _ := ts.NewTab("Sliders")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Sliders and meters")
        core.NewText(tab).SetText("Cogent Core provides interactive sliders and customizable meters, allowing you to edit and display bounded numbers.")

        core.NewSlider(tab)
        core.NewSlider(tab).SetValue(0.7).SetState(true, states.Disabled)

        csliders := core.NewFrame(tab)

        core.NewSlider(csliders).SetValue(0.3).Styler(func(s *styles.Style) {
                s.Direction = styles.Column
        })
        core.NewSlider(csliders).SetValue(0.2).SetState(true, states.Disabled).Styler(func(s *styles.Style) {
                s.Direction = styles.Column
        })

        core.NewMeter(tab).SetType(core.MeterCircle).SetValue(0.7).SetText("70%")
        core.NewMeter(tab).SetType(core.MeterSemicircle).SetValue(0.7).SetText("70%")
        core.NewMeter(tab).SetValue(0.7)
        core.NewMeter(tab).SetValue(0.7).Styler(func(s *styles.Style) {
                s.Direction = styles.Column
        })
}

func textEditors(ts *core.Tabs) {
        tab, _ := ts.NewTab("Text editors")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Text editors")
        core.NewText(tab).SetText("Cogent Core provides powerful text editors that support advanced code editing features, like syntax highlighting, completion, undo and redo, copy and paste, rectangular selection, and word, line, and page based navigation, selection, and deletion.")

        sp := core.NewSplits(tab)
        ed := textcore.NewEditor(sp)
        ed.Styler(func(s *styles.Style) {
                s.Padding.Set(units.Em(core.ConstantSpacing(1)))
        })
        ed.Lines.OpenFS(demoFile, "demo.go")
        textcore.NewEditor(sp).Lines.SetLanguage(fileinfo.Svg).SetString(core.AppIcon)
}

func valueBinding(ts *core.Tabs) {
        tab, _ := ts.NewTab("Value binding")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Value binding")
        core.NewText(tab).SetText("Cogent Core provides the value binding system, which allows you to instantly bind Go values to interactive widgets with just a single simple line of code.")

        name := "Gopher"
        core.Bind(&name, core.NewTextField(tab)).OnChange(func(e events.Event) {
                fmt.Println("Your name is now", name)
        })

        age := 35
        core.Bind(&age, core.NewSpinner(tab)).OnChange(func(e events.Event) {
                fmt.Println("Your age is now", age)
        })

        on := true
        core.Bind(&on, core.NewSwitch(tab)).OnChange(func(e events.Event) {
                fmt.Println("The switch is now", on)
        })

        theme := core.ThemeLight
        core.Bind(&theme, core.NewSwitches(tab)).OnChange(func(e events.Event) {
                fmt.Println("The theme is now", theme)
        })

        var state states.States
        state.SetFlag(true, states.Hovered)
        state.SetFlag(true, states.Dragging)
        core.Bind(&state, core.NewSwitches(tab)).OnChange(func(e events.Event) {
                fmt.Println("The state is now", state)
        })

        color := colors.Orange
        core.Bind(&color, core.NewColorButton(tab)).OnChange(func(e events.Event) {
                fmt.Println("The color is now", color)
        })

        colorMap := core.ColorMapName("ColdHot")
        core.Bind(&colorMap, core.NewColorMapButton(tab)).OnChange(func(e events.Event) {
                fmt.Println("The color map is now", colorMap)
        })

        t := time.Now()
        core.Bind(&t, core.NewTimeInput(tab)).OnChange(func(e events.Event) {
                fmt.Println("The time is now", t)
        })

        duration := 5 * time.Minute
        core.Bind(&duration, core.NewDurationInput(tab)).OnChange(func(e events.Event) {
                fmt.Println("The duration is now", duration)
        })

        file := core.Filename("demo.go")
        core.Bind(&file, core.NewFileButton(tab)).OnChange(func(e events.Event) {
                fmt.Println("The file is now", file)
        })

        font := core.AppearanceSettings.Text.SansSerif
        core.Bind(&font, core.NewFontButton(tab)).OnChange(func(e events.Event) {
                fmt.Println("The font is now", font)
        })

        core.Bind(hello, core.NewFuncButton(tab)).SetShowReturn(true)
        core.Bind(styles.NewStyle, core.NewFuncButton(tab)).SetConfirm(true).SetShowReturn(true)

        core.NewButton(tab).SetText("Inspector").OnClick(func(e events.Event) {
                core.InspectorWindow(ts.Scene)
        })
}

// Hello displays a greeting message and an age in weeks based on the given information.
func hello(firstName string, lastName string, age int, likesGo bool) (greeting string, weeksOld int) { //types:add
        weeksOld = age * 52
        greeting = "Hello, " + firstName + " " + lastName + "! "
        if likesGo {
                greeting += "I'm glad to hear that you like the best programming language!"
        } else {
                greeting += "You should reconsider what programming languages you like."
        }
        return
}

func collections(ts *core.Tabs) {
        tab, _ := ts.NewTab("Collections")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Collections")
        core.NewText(tab).SetText("Cogent Core provides powerful collection widgets that allow you to easily view and edit complex data types like structs, maps, and slices, allowing you to easily create widgets like lists, tables, and forms.")

        vts := core.NewTabs(tab)

        str := testStruct{
                Name:      "Go",
                Condition: 2,
                Value:     3.1415,
                Vector:    math32.Vec2(5, 7),
                Inline:    inlineStruct{Value: 3},
                Condition2: tableStruct{
                        Age:   22,
                        Score: 44.4,
                        Name:  "foo",
                        File:  "core.go",
                },
                Table: make([]tableStruct, 2),
                List:  []float32{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7},
        }

        ftab, _ := vts.NewTab("Forms")
        core.NewForm(ftab).SetStruct(&str)

        sl := make([]string, 50)
        for i := 0; i < len(sl); i++ {
                sl[i] = fmt.Sprintf("element %d", i)
        }
        sl[10] = "this is a particularly long value"
        ltab, _ := vts.NewTab("Lists")
        core.NewList(ltab).SetSlice(&sl)

        mp := map[string]string{}

        mp["Go"] = "Elegant, fast, and easy-to-use"
        mp["Python"] = "Slow and duck-typed"
        mp["C++"] = "Hard to use and slow to compile"

        ktab, _ := vts.NewTab("Keyed lists")
        core.NewKeyedList(ktab).SetMap(&mp)

        tbl := make([]*tableStruct, 50)
        for i := range tbl {
                ts := &tableStruct{Age: i, Score: float32(i) / 10}
                tbl[i] = ts
        }
        tbl[0].Name = "this is a particularly long field"
        ttab, _ := vts.NewTab("Tables")
        core.NewTable(ttab).SetSlice(&tbl)

        sp := core.NewSplits(vts.NewTab("Trees")).SetSplits(0.3, 0.7)
        tr := core.NewTree(core.NewFrame(sp)).SetText("Root")
        makeTree(tr, 0)

        sv := core.NewForm(sp).SetStruct(tr)

        tr.OnSelect(func(e events.Event) {
                if len(tr.SelectedNodes) > 0 {
                        sv.SetStruct(tr.SelectedNodes[0]).Update()
                }
        })
}

func makeTree(tr *core.Tree, round int) {
        if round > 2 {
                return
        }
        for i := range 3 {
                n := core.NewTree(tr).SetText("Child " + strconv.Itoa(i))
                makeTree(n, round+1)
        }
}

type tableStruct struct { //types:add

        // an icon
        Icon icons.Icon

        // an integer field
        Age int `default:"2"`

        // a float field
        Score float32

        // a string field
        Name string

        // a file
        File core.Filename
}

type inlineStruct struct { //types:add

        // this is now showing
        ShowMe string

        // click to show next
        On bool

        // a condition
        Condition int `default:"0"`

        // if On && Condition == 0
        Condition1 string

        // if On && Condition <= 1
        Condition2 tableStruct

        // a value
        Value float32 `default:"1"`
}

func (il *inlineStruct) ShouldDisplay(field string) bool {
        switch field {
        case "ShowMe", "Condition":
                return il.On
        case "Condition1":
                return il.On && il.Condition == 0
        case "Condition2":
                return il.On && il.Condition <= 1
        }
        return true
}

type testStruct struct { //types:add

        // An enum value
        Enum core.ButtonTypes

        // a string
        Name string `default:"Go" width:"50"`

        // click to show next
        ShowNext bool

        // this is now showing
        ShowMe string

        // inline struct
        Inline inlineStruct `display:"inline"`

        // a condition
        Condition int

        // if Condition == 0
        Condition1 string

        // if Condition >= 0
        Condition2 tableStruct

        // a value
        Value float32

        // a vector
        Vector math32.Vector2

        // a slice of structs
        Table []tableStruct

        // a slice of floats
        List []float32

        // a file
        File core.Filename
}

func (ts *testStruct) ShouldDisplay(field string) bool {
        switch field {
        case "Name":
                return ts.Enum <= core.ButtonElevated
        case "ShowMe":
                return ts.ShowNext
        case "Condition1":
                return ts.Condition == 0
        case "Condition2":
                return ts.Condition >= 0
        }
        return true
}

func dialogs(ts *core.Tabs) {
        tab, _ := ts.NewTab("Dialogs")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Dialogs, snackbars, and windows")
        core.NewText(tab).SetText("Cogent Core provides completely customizable dialogs, snackbars, and windows that allow you to easily display, obtain, and organize information.")

        core.NewText(tab).SetType(core.TextHeadlineSmall).SetText("Dialogs")
        drow := makeRow(tab)

        md := core.NewButton(drow).SetText("Message")
        md.OnClick(func(e events.Event) {
                core.MessageDialog(md, "Something happened", "Message")
        })

        ed := core.NewButton(drow).SetText("Error")
        ed.OnClick(func(e events.Event) {
                core.ErrorDialog(ed, errors.New("invalid encoding format"), "Error loading file")
        })

        cd := core.NewButton(drow).SetText("Confirm")
        cd.OnClick(func(e events.Event) {
                d := core.NewBody("Confirm")
                core.NewText(d).SetType(core.TextSupporting).SetText("Send message?")
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddCancel(bar).OnClick(func(e events.Event) {
                                core.MessageSnackbar(cd, "Dialog canceled")
                        })
                        d.AddOK(bar).OnClick(func(e events.Event) {
                                core.MessageSnackbar(cd, "Dialog accepted")
                        })
                })
                d.RunDialog(cd)
        })

        td := core.NewButton(drow).SetText("Input")
        td.OnClick(func(e events.Event) {
                d := core.NewBody("Input")
                core.NewText(d).SetType(core.TextSupporting).SetText("What is your name?")
                tf := core.NewTextField(d)
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddCancel(bar)
                        d.AddOK(bar).OnClick(func(e events.Event) {
                                core.MessageSnackbar(td, "Your name is "+tf.Text())
                        })
                })
                d.RunDialog(td)
        })

        fd := core.NewButton(drow).SetText("Full window")
        u := &core.User{}
        fd.OnClick(func(e events.Event) {
                d := core.NewBody("Full window dialog")
                core.NewText(d).SetType(core.TextSupporting).SetText("Edit your information")
                core.NewForm(d).SetStruct(u).OnInput(func(e events.Event) {
                        fmt.Println("Got input event")
                })
                d.OnClose(func(e events.Event) {
                        fmt.Println("Your information is:", u)
                })
                d.RunFullDialog(td)
        })

        nd := core.NewButton(drow).SetText("New window")
        nd.OnClick(func(e events.Event) {
                d := core.NewBody("New window dialog")
                core.NewText(d).SetType(core.TextSupporting).SetText("This dialog opens in a new window on multi-window platforms")
                d.RunWindowDialog(nd)
        })

        core.NewText(tab).SetType(core.TextHeadlineSmall).SetText("Snackbars")
        srow := makeRow(tab)

        ms := core.NewButton(srow).SetText("Message")
        ms.OnClick(func(e events.Event) {
                core.MessageSnackbar(ms, "New messages loaded")
        })

        es := core.NewButton(srow).SetText("Error")
        es.OnClick(func(e events.Event) {
                core.ErrorSnackbar(es, errors.New("file not found"), "Error loading page")
        })

        cs := core.NewButton(srow).SetText("Custom")
        cs.OnClick(func(e events.Event) {
                core.NewBody().AddSnackbarText("Files updated").
                        AddSnackbarButton("Refresh", func(e events.Event) {
                                core.MessageSnackbar(cs, "Refreshed files")
                        }).AddSnackbarIcon(icons.Close).RunSnackbar(cs)
        })

        core.NewText(tab).SetType(core.TextHeadlineSmall).SetText("Windows")
        wrow := makeRow(tab)

        nw := core.NewButton(wrow).SetText("New window")
        nw.OnClick(func(e events.Event) {
                d := core.NewBody("New window")
                core.NewText(d).SetType(core.TextHeadlineSmall).SetText("New window")
                core.NewText(d).SetType(core.TextSupporting).SetText("A standalone window that opens in a new window on multi-window platforms")
                d.RunWindow()
        })

        fw := core.NewButton(wrow).SetText("Full window")
        fw.OnClick(func(e events.Event) {
                d := core.NewBody("Full window")
                core.NewText(d).SetType(core.TextSupporting).SetText("A standalone window that opens in the same system window")
                d.NewWindow().SetNewWindow(false).SetDisplayTitle(true).Run()
        })

        core.NewText(tab).SetType(core.TextHeadlineSmall).SetText("Window manipulations")
        mrow := makeRow(tab)

        rw := core.NewButton(mrow).SetText("Resize to content")
        rw.SetTooltip("Resizes this window to fit the current content on multi-window platforms")
        rw.OnClick(func(e events.Event) {
                mrow.Scene.ResizeToContent(image.Pt(0, 40)) // note: size is not correct due to wrapping? #1307
        })

        fs := core.NewButton(mrow).SetText("Fullscreen")
        fs.SetTooltip("Toggle fullscreen mode on desktop and web platforms")
        fs.OnClick(func(e events.Event) {
                mrow.Scene.SetFullscreen(!mrow.Scene.IsFullscreen())
        })

        sg := core.NewButton(mrow).SetText("Set geometry")
        sg.SetTooltip("Move the window to the top-left corner of the second screen and resize it on desktop platforms")
        sg.OnClick(func(e events.Event) {
                mrow.Scene.SetGeometry(false, image.Pt(30, 100), image.Pt(1000, 1000), 1)
        })
}

func makeStyles(ts *core.Tabs) {
        tab, _ := ts.NewTab("Styles")

        core.NewText(tab).SetType(core.TextHeadlineLarge).SetText("Styles and layouts")
        core.NewText(tab).SetText("Cogent Core provides a fully customizable styling and layout system that allows you to easily control the position, size, and appearance of all widgets. You can edit the style properties of the outer frame below.")

        // same as docs advanced styling demo
        sp := core.NewSplits(tab)
        fm := core.NewForm(sp)
        fr := core.NewFrame(core.NewFrame(sp)) // can not control layout when directly in splits
        fr.Styler(func(s *styles.Style) {
                s.Background = colors.Scheme.Select.Container
                s.Grow.Set(1, 1)
        })
        fr.Style() // must style immediately to get correct default values
        fm.SetStruct(&fr.Styles)
        fm.OnChange(func(e events.Event) {
                fr.OverrideStyle = true
                fr.Update()
        })
        frameSizes := []math32.Vector2{
                {20, 100},
                {80, 20},
                {60, 80},
                {40, 120},
                {150, 100},
        }
        for _, sz := range frameSizes {
                core.NewFrame(fr).Styler(func(s *styles.Style) {
                        s.Min.Set(units.Dp(sz.X), units.Dp(sz.Y))
                        s.Background = colors.Scheme.Primary.Base
                })
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

import (
        "fmt"
        "io"
        "log/slog"
        "os"
        "path/filepath"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/text/textcore"
)

// MimeData adds mimedata for this node: a text/plain of the Path,
// text/plain of filename, and text/
func (fn *Node) MimeData(md *mimedata.Mimes) {
        froot := fn.FileRoot()
        path := string(fn.Filepath)
        punq := fn.PathFrom(froot) // note: tree paths have . escaped -> \,
        *md = append(*md, mimedata.NewTextData(punq))
        *md = append(*md, mimedata.NewTextData(path))
        if int(fn.Info.Size) < core.SystemSettings.BigFileSize {
                in, err := os.Open(path)
                if err != nil {
                        slog.Error(err.Error())
                        return
                }
                b, err := io.ReadAll(in)
                if err != nil {
                        slog.Error(err.Error())
                        return
                }
                fd := &mimedata.Data{fn.Info.Mime, b}
                *md = append(*md, fd)
        } else {
                *md = append(*md, mimedata.NewTextData("File exceeds BigFileSize"))
        }
}

// Cut copies the selected files to the clipboard and then deletes them.
func (fn *Node) Cut() { //types:add
        if fn.IsRoot("Cut") {
                return
        }
        fn.Copy()
        // todo: move files somewhere temporary, then use those temps for paste..
        core.MessageDialog(fn, "File names were copied to clipboard and can be pasted to copy elsewhere, but files are not deleted because contents of files are not placed on the clipboard and thus cannot be pasted as such.  Use Delete to delete files.")
}

// Paste inserts files from the clipboard.
func (fn *Node) Paste() { //types:add
        md := fn.Clipboard().Read([]string{fileinfo.TextPlain})
        if md != nil {
                fn.pasteFiles(md, false, nil)
        }
}

func (fn *Node) DragDrop(e events.Event) {
        de := e.(*events.DragDrop)
        md := de.Data.(mimedata.Mimes)
        fn.pasteFiles(md, de.Source == nil, func() {
                fn.DropFinalize(de)
        })
}

// pasteCheckExisting checks for existing files in target node directory if
// that is non-nil (otherwise just uses absolute path), and returns list of existing
// and node for last one if exists.
func (fn *Node) pasteCheckExisting(tfn *Node, md mimedata.Mimes, externalDrop bool) ([]string, *Node) {
        froot := fn.FileRoot()
        tpath := ""
        if tfn != nil {
                tpath = string(tfn.Filepath)
        }
        nf := len(md)
        if !externalDrop {
                nf /= 3
        }
        var sfn *Node
        var existing []string
        for i := 0; i < nf; i++ {
                var d *mimedata.Data
                if !externalDrop {
                        d = md[i*3+1]
                        npath := string(md[i*3].Data)
                        sfni := froot.FindPath(npath)
                        if sfni != nil {
                                sfn = AsNode(sfni)
                        }
                } else {
                        d = md[i] // just a list
                }
                if d.Type != fileinfo.TextPlain {
                        continue
                }
                path := string(d.Data)
                path = strings.TrimPrefix(path, "file://")
                if tfn != nil {
                        _, fnm := filepath.Split(path)
                        path = filepath.Join(tpath, fnm)
                }
                if errors.Log1(fsx.FileExists(path)) {
                        existing = append(existing, path)
                }
        }
        return existing, sfn
}

// pasteCopyFiles copies files in given data into given target directory
func (fn *Node) pasteCopyFiles(tdir *Node, md mimedata.Mimes, externalDrop bool) {
        froot := fn.FileRoot()
        nf := len(md)
        if !externalDrop {
                nf /= 3
        }
        for i := 0; i < nf; i++ {
                var d *mimedata.Data
                mode := os.FileMode(0664)
                if !externalDrop {
                        d = md[i*3+1]
                        npath := string(md[i*3].Data)
                        sfni := froot.FindPath(npath)
                        if sfni == nil {
                                slog.Error("filetree.Node: could not find path", "path", npath)
                                continue
                        }
                        sfn := AsNode(sfni)
                        mode = sfn.Info.Mode
                } else {
                        d = md[i] // just a list
                }
                if d.Type != fileinfo.TextPlain {
                        continue
                }
                path := string(d.Data)
                path = strings.TrimPrefix(path, "file://")
                tdir.copyFileToDir(path, mode)
        }
}

// pasteCopyFilesCheck copies files into given directory node,
// first checking if any already exist -- if they exist, prompts.
func (fn *Node) pasteCopyFilesCheck(tdir *Node, md mimedata.Mimes, externalDrop bool, dropFinal func()) {
        existing, _ := fn.pasteCheckExisting(tdir, md, externalDrop)
        if len(existing) == 0 {
                fn.pasteCopyFiles(tdir, md, externalDrop)
                if dropFinal != nil {
                        dropFinal()
                }
                return
        }
        d := core.NewBody("File(s) Exist in Target Dir, Overwrite?")
        core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("File(s): %v exist, do you want to overwrite?", existing))
        d.AddBottomBar(func(bar *core.Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).SetText("Overwrite").OnClick(func(e events.Event) {
                        fn.pasteCopyFiles(tdir, md, externalDrop)
                        if dropFinal != nil {
                                dropFinal()
                        }
                })
        })
        d.RunDialog(fn)
}

// pasteFiles applies a paste / drop of mime data onto this node.
// always does a copy of files into / onto target.
// externalDrop is true if this is an externally generated Drop event (from OS)
func (fn *Node) pasteFiles(md mimedata.Mimes, externalDrop bool, dropFinal func()) {
        if len(md) == 0 {
                return
        }
        if fn == nil || fn.isExternal() {
                return
        }

        tpath := string(fn.Filepath)
        isdir := fn.IsDir()
        if isdir {
                fn.pasteCopyFilesCheck(fn, md, externalDrop, dropFinal)
                return
        }
        if len(md) > 3 { // multiple files -- automatically goes into parent dir
                tdir := AsNode(fn.Parent)
                fn.pasteCopyFilesCheck(tdir, md, externalDrop, dropFinal)
                return
        }
        // single file dropped onto a single target file
        srcpath := ""
        if externalDrop || len(md) < 2 {
                srcpath = string(md[0].Data) // just file path
        } else {
                srcpath = string(md[1].Data) // 1 has file path, 0 = tree path, 2 = file data
        }
        fname := filepath.Base(srcpath)
        tdir := AsNode(fn.Parent)
        existing, sfn := fn.pasteCheckExisting(tdir, md, externalDrop)
        mode := os.FileMode(0664)
        if sfn != nil {
                mode = sfn.Info.Mode
        }
        switch {
        case len(existing) == 1 && fname == fn.Name:
                d := core.NewBody("Overwrite?")
                core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("Overwrite target file: %s with source file of same name?, or diff (compare) two files?", fn.Name))
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddCancel(bar)
                        d.AddOK(bar).SetText("Diff (compare)").OnClick(func(e events.Event) {
                                textcore.DiffFiles(fn, tpath, srcpath)
                        })
                        d.AddOK(bar).SetText("Overwrite").OnClick(func(e events.Event) {
                                fsx.CopyFile(tpath, srcpath, mode)
                                if dropFinal != nil {
                                        dropFinal()
                                }
                        })
                })
                d.RunDialog(fn)
        case len(existing) > 0:
                d := core.NewBody("Overwrite?")
                core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("Overwrite target file: %s with source file: %s, or overwrite existing file with same name as source file (%s), or diff (compare) files?", fn.Name, fname, fname))
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddCancel(bar)
                        d.AddOK(bar).SetText("Diff to target").OnClick(func(e events.Event) {
                                textcore.DiffFiles(fn, tpath, srcpath)
                        })
                        d.AddOK(bar).SetText("Diff to existing").OnClick(func(e events.Event) {
                                npath := filepath.Join(string(tdir.Filepath), fname)
                                textcore.DiffFiles(fn, npath, srcpath)
                        })
                        d.AddOK(bar).SetText("Overwrite target").OnClick(func(e events.Event) {
                                fsx.CopyFile(tpath, srcpath, mode)
                                if dropFinal != nil {
                                        dropFinal()
                                }
                        })
                        d.AddOK(bar).SetText("Overwrite existing").OnClick(func(e events.Event) {
                                npath := filepath.Join(string(tdir.Filepath), fname)
                                fsx.CopyFile(npath, srcpath, mode)
                                if dropFinal != nil {
                                        dropFinal()
                                }
                        })
                })
                d.RunDialog(fn)
        default:
                d := core.NewBody("Overwrite?")
                core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("Overwrite target file: %s with source file: %s, or copy to: %s in current folder (which doesn't yet exist), or diff (compare) the two files?", fn.Name, fname, fname))
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddCancel(bar)
                        d.AddOK(bar).SetText("Diff (compare)").OnClick(func(e events.Event) {
                                textcore.DiffFiles(fn, tpath, srcpath)
                        })
                        d.AddOK(bar).SetText("Overwrite target").OnClick(func(e events.Event) {
                                fsx.CopyFile(tpath, srcpath, mode)
                                if dropFinal != nil {
                                        dropFinal()
                                }
                        })
                        d.AddOK(bar).SetText("Copy new file").OnClick(func(e events.Event) {
                                tdir.copyFileToDir(srcpath, mode)
                                if dropFinal != nil {
                                        dropFinal()
                                }
                        })
                })
                d.RunDialog(fn)
        }
}

// Dragged is called after target accepts the drop -- we just remove
// elements that were moved
// satisfies core.DragNDropper interface and can be overridden by subtypes
func (fn *Node) DropDeleteSource(e events.Event) {
        de := e.(*events.DragDrop)
        froot := fn.FileRoot()
        if froot == nil || fn.isExternal() {
                return
        }
        md := de.Data.(mimedata.Mimes)
        nf := len(md) / 3 // always internal
        for i := 0; i < nf; i++ {
                npath := string(md[i*3].Data)
                sfni := froot.FindPath(npath)
                if sfni == nil {
                        slog.Error("filetree.Node: could not find path", "path", npath)
                        continue
                }
                sfn := AsNode(sfni)
                if sfn == nil {
                        continue
                }
                // fmt.Printf("dnd deleting: %v  path: %v\n", sfn.Path(), sfn.FPath)
                sfn.DeleteFile()
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

import (
        "os"
        "path/filepath"
        "slices"
        "sync"
)

// dirFlags are flags on directories: Open, SortBy, etc.
// These flags are stored in the DirFlagMap for persistence.
// This map is saved to a file, so these flags must be stored
// as bit flags instead of a struct to ensure efficient serialization.
type dirFlags int64 //enums:bitflag -trim-prefix dir

const (
        // dirIsOpen means directory is open -- else closed
        dirIsOpen dirFlags = iota

        // dirSortByName means sort the directory entries by name.
        // this overrides SortByModTime default on Tree if set.
        dirSortByName

        // dirSortByModTime means sort the directory entries by modification time.
        dirSortByModTime
)

// DirFlagMap is a map for encoding open directories and sorting preferences.
// The strings are typically relative paths. Map access is protected by Mutex.
type DirFlagMap struct {

        // map of paths and associated flags
        Map map[string]dirFlags

        // mutex for accessing map
        sync.Mutex
}

// init initializes the map, and sets the Mutex lock; must unlock manually.
func (dm *DirFlagMap) init() {
        dm.Lock()
        if dm.Map == nil {
                dm.Map = make(map[string]dirFlags)
        }
}

// isOpen returns true if path has isOpen bit flag set
func (dm *DirFlagMap) isOpen(path string) bool {
        dm.init()
        defer dm.Unlock()
        if df, ok := dm.Map[path]; ok {
                return df.HasFlag(dirIsOpen)
        }
        return false
}

// SetOpenState sets the given directory's open flag
func (dm *DirFlagMap) setOpen(path string, open bool) {
        dm.init()
        defer dm.Unlock()
        df := dm.Map[path]
        df.SetFlag(open, dirIsOpen)
        dm.Map[path] = df
}

// sortByName returns true if path is sorted by name (default if not in map)
func (dm *DirFlagMap) sortByName(path string) bool {
        dm.init()
        defer dm.Unlock()
        if df, ok := dm.Map[path]; ok {
                return df.HasFlag(dirSortByName)
        }
        return true
}

// sortByModTime returns true if path is sorted by mod time
func (dm *DirFlagMap) sortByModTime(path string) bool {
        dm.init()
        defer dm.Unlock()
        if df, ok := dm.Map[path]; ok {
                return df.HasFlag(dirSortByModTime)
        }
        return false
}

// setSortBy sets the given directory's sort by option
func (dm *DirFlagMap) setSortBy(path string, modTime bool) {
        dm.init()
        defer dm.Unlock()
        df := dm.Map[path]
        if modTime {
                df.SetFlag(true, dirSortByModTime)
                df.SetFlag(false, dirSortByName)
        } else {
                df.SetFlag(false, dirSortByModTime)
                df.SetFlag(true, dirSortByName)
        }
        dm.Map[path] = df
}

// openPaths returns a list of open paths
func (dm *DirFlagMap) openPaths(root string) []string {
        dm.init()
        defer dm.Unlock()

        var paths []string
        for fn, df := range dm.Map {
                if !df.HasFlag(dirIsOpen) {
                        continue
                }
                fpath := filepath.Join(root, fn)
                _, err := os.Stat(fpath)
                if err != nil {
                        delete(dm.Map, fn)
                        continue
                }
                rootClosed := false
                par := fn
                for {
                        par = filepath.Dir(par)
                        if par == "" || par == "." {
                                break
                        }
                        if pdf, ook := dm.Map[par]; ook {
                                if !pdf.HasFlag(dirIsOpen) {
                                        rootClosed = true
                                        break
                                }
                        }
                }
                if rootClosed {
                        continue
                }
                paths = append(paths, fpath)
        }
        slices.Sort(paths)
        return paths
}

// Code generated by "core generate"; DO NOT EDIT.

package filetree

import (
        "cogentcore.org/core/enums"
)

var _dirFlagsValues = []dirFlags{0, 1, 2}

// dirFlagsN is the highest valid value for type dirFlags, plus one.
const dirFlagsN dirFlags = 3

var _dirFlagsValueMap = map[string]dirFlags{`IsOpen`: 0, `SortByName`: 1, `SortByModTime`: 2}

var _dirFlagsDescMap = map[dirFlags]string{0: `dirIsOpen means directory is open -- else closed`, 1: `dirSortByName means sort the directory entries by name. this overrides SortByModTime default on Tree if set.`, 2: `dirSortByModTime means sort the directory entries by modification time.`}

var _dirFlagsMap = map[dirFlags]string{0: `IsOpen`, 1: `SortByName`, 2: `SortByModTime`}

// String returns the string representation of this dirFlags value.
func (i dirFlags) String() string { return enums.BitFlagString(i, _dirFlagsValues) }

// BitIndexString returns the string representation of this dirFlags value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i dirFlags) BitIndexString() string { return enums.String(i, _dirFlagsMap) }

// SetString sets the dirFlags value from its string representation,
// and returns an error if the string is invalid.
func (i *dirFlags) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the dirFlags value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *dirFlags) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _dirFlagsValueMap, "dirFlags")
}

// Int64 returns the dirFlags value as an int64.
func (i dirFlags) Int64() int64 { return int64(i) }

// SetInt64 sets the dirFlags value from an int64.
func (i *dirFlags) SetInt64(in int64) { *i = dirFlags(in) }

// Desc returns the description of the dirFlags value.
func (i dirFlags) Desc() string { return enums.Desc(i, _dirFlagsDescMap) }

// dirFlagsValues returns all possible values for the type dirFlags.
func dirFlagsValues() []dirFlags { return _dirFlagsValues }

// Values returns all possible values for the type dirFlags.
func (i dirFlags) Values() []enums.Enum { return enums.Values(_dirFlagsValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *dirFlags) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *dirFlags) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i dirFlags) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *dirFlags) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "dirFlags") }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

import (
        "errors"
        "fmt"
        "os"
        "path/filepath"
        "syscall"

        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
)

// Filer is an interface for file tree file actions that all [Node]s satisfy.
// This allows apps to intervene and apply any additional logic for these actions.
type Filer interface { //types:add
        core.Treer

        // AsFileNode returns the [Node]
        AsFileNode() *Node

        // RenameFiles renames any selected files.
        RenameFiles()

        // DeleteFiles deletes any selected files.
        DeleteFiles()

        // GetFileInfo updates the .Info for this file
        GetFileInfo() error

        // OpenFile opens the file for node. This is called by OpenFilesDefault
        OpenFile() error
}

var _ Filer = (*Node)(nil)

// SelectedPaths returns the paths of selected nodes.
func (fn *Node) SelectedPaths() []string {
        sels := fn.GetSelectedNodes()
        n := len(sels)
        if n == 0 {
                return nil
        }
        paths := make([]string, n)
        fn.SelectedFunc(func(sn *Node) {
                paths = append(paths, string(sn.Filepath))
        })
        return paths
}

// OpenFilesDefault opens selected files with default app for that file type (os defined).
// runs open on Mac, xdg-open on Linux, and start on Windows
func (fn *Node) OpenFilesDefault() { //types:add
        fn.SelectedFunc(func(sn *Node) {
                sn.This.(Filer).OpenFile()
        })
}

// OpenFile just does OpenFileDefault
func (fn *Node) OpenFile() error {
        return fn.OpenFileDefault()
}

// OpenFileDefault opens file with default app for that file type (os defined)
// runs open on Mac, xdg-open on Linux, and start on Windows
func (fn *Node) OpenFileDefault() error {
        core.TheApp.OpenURL("file://" + string(fn.Filepath))
        return nil
}

// duplicateFiles makes a copy of selected files
func (fn *Node) duplicateFiles() { //types:add
        fn.FileRoot().NeedsLayout()
        fn.SelectedFunc(func(sn *Node) {
                sn.duplicateFile()
        })
}

// duplicateFile creates a copy of given file -- only works for regular files, not
// directories
func (fn *Node) duplicateFile() error {
        _, err := fn.Info.Duplicate()
        if err == nil && fn.Parent != nil {
                fnp := AsNode(fn.Parent)
                fnp.Update()
        }
        return err
}

// DeleteFiles deletes any selected files or directories. If any directory is selected,
// all files and subdirectories in that directory are also deleted.
func (fn *Node) DeleteFiles() { //types:add
        d := core.NewBody("Delete Files?")
        core.NewText(d).SetType(core.TextSupporting).SetText("OK to delete file(s)?  This is not undoable and files are not moving to trash / recycle bin. If any selections are directories all files and subdirectories will also be deleted.")
        d.AddBottomBar(func(bar *core.Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).SetText("Delete Files").OnClick(func(e events.Event) {
                        fn.DeleteFilesNoPrompts()
                })
        })
        d.RunDialog(fn)
}

// DeleteFilesNoPrompts does the actual deletion, no prompts.
func (fn *Node) DeleteFilesNoPrompts() {
        fn.FileRoot().NeedsLayout()
        fn.SelectedFunc(func(sn *Node) {
                if !sn.Info.IsDir() {
                        sn.DeleteFile()
                        return
                }
                sn.DeleteFile()
        })
}

// DeleteFile deletes this file
func (fn *Node) DeleteFile() error {
        if fn.isExternal() {
                return nil
        }
        pari := fn.Parent
        var parent *Node
        if pari != nil {
                parent = AsNode(pari)
        }
        repo, _ := fn.Repo()
        var err error
        if !fn.Info.IsDir() && repo != nil && fn.Info.VCS >= vcs.Stored {
                // fmt.Printf("del repo: %v\n", fn.FPath)
                err = repo.Delete(string(fn.Filepath))
        } else {
                // fmt.Printf("del raw: %v\n", fn.FPath)
                err = fn.Info.Delete()
        }
        if err == nil {
                fn.Delete()
        }
        if parent != nil {
                parent.Update()
        }
        return err
}

// renames any selected files
func (fn *Node) RenameFiles() { //types:add
        fn.FileRoot().NeedsLayout()
        fn.SelectedFunc(func(sn *Node) {
                fb := core.NewSoloFuncButton(sn).SetFunc(sn.RenameFile)
                fb.Args[0].SetValue(sn.Name)
                fb.CallFunc()
        })
}

// RenameFile renames file to new name
func (fn *Node) RenameFile(newpath string) error { //types:add
        if fn.isExternal() {
                return nil
        }
        root := fn.FileRoot()
        var err error
        orgpath := fn.Filepath
        newpath, err = fn.Info.Rename(newpath)
        if len(newpath) == 0 || err != nil {
                return err
        }
        if fn.IsDir() {
                if fn.FileRoot().isDirOpen(orgpath) {
                        fn.FileRoot().setDirOpen(core.Filename(newpath))
                }
        }
        repo, _ := fn.Repo()
        stored := false
        if fn.IsDir() && !fn.HasChildren() {
                err = os.Rename(string(orgpath), newpath)
        } else if repo != nil && fn.Info.VCS >= vcs.Stored {
                stored = true
                err = repo.Move(string(orgpath), newpath)
        } else {
                err = os.Rename(string(orgpath), newpath)
                if err != nil && errors.Is(err, syscall.ENOENT) { // some kind of bogus error it seems?
                        err = nil
                }
        }
        if err == nil {
                err = fn.Info.InitFile(newpath)
        }
        if err == nil {
                fn.Filepath = core.Filename(fn.Info.Path)
                fn.SetName(fn.Info.Name)
                fn.SetText(fn.Info.Name)
        }
        // todo: if you add orgpath here to git, then it will show the rename in status
        if stored {
                fn.AddToVCS()
        }
        if root != nil {
                root.UpdatePath(string(orgpath))
                root.UpdatePath(newpath)
        }
        return err
}

// newFiles makes a new file in selected directory
func (fn *Node) newFiles(filename string, addToVCS bool) { //types:add
        done := false
        fn.SelectedFunc(func(sn *Node) {
                if !done {
                        sn.newFile(filename, addToVCS)
                        done = true
                }
        })
}

// newFile makes a new file in this directory node
func (fn *Node) newFile(filename string, addToVCS bool) { //types:add
        if fn.isExternal() {
                return
        }
        ppath := string(fn.Filepath)
        if !fn.IsDir() {
                ppath, _ = filepath.Split(ppath)
        }
        np := filepath.Join(ppath, filename)
        _, err := os.Create(np)
        if err != nil {
                core.ErrorSnackbar(fn, err)
                return
        }
        if addToVCS {
                fn.FileRoot().UpdatePath(ppath)
                nfn, ok := fn.FileRoot().FindFile(np)
                if ok && !nfn.IsRoot() && string(nfn.Filepath) == np {
                        core.MessageSnackbar(fn, "Adding new file to VCS: "+fsx.DirAndFile(string(nfn.Filepath)))
                        nfn.AddToVCS()
                }
        }
        fn.FileRoot().UpdatePath(ppath)
}

// makes a new folder in the given selected directory
func (fn *Node) newFolders(foldername string) { //types:add
        done := false
        fn.SelectedFunc(func(sn *Node) {
                if !done {
                        sn.newFolder(foldername)
                        done = true
                }
        })
}

// newFolder makes a new folder (directory) in this directory node
func (fn *Node) newFolder(foldername string) { //types:add
        if fn.isExternal() {
                return
        }
        ppath := string(fn.Filepath)
        if !fn.IsDir() {
                ppath, _ = filepath.Split(ppath)
        }
        np := filepath.Join(ppath, foldername)
        err := os.MkdirAll(np, 0775)
        if err != nil {
                core.ErrorSnackbar(fn, err)
                return
        }
        fn.FileRoot().UpdatePath(ppath)
}

// copyFileToDir copies given file path into node that is a directory.
// This does NOT check for overwriting -- that must be done at higher level!
func (fn *Node) copyFileToDir(filename string, perm os.FileMode) {
        if fn.isExternal() {
                return
        }
        ppath := string(fn.Filepath)
        sfn := filepath.Base(filename)
        tpath := filepath.Join(ppath, sfn)
        fsx.CopyFile(tpath, filename, perm)
        fn.FileRoot().UpdatePath(ppath)
        ofn, ok := fn.FileRoot().FindFile(filename)
        if ok && ofn.Info.VCS >= vcs.Stored {
                nfn, ok := fn.FileRoot().FindFile(tpath)
                if ok && !nfn.IsRoot() {
                        if string(nfn.Filepath) != tpath {
                                fmt.Printf("error: nfn.FPath != tpath; %q != %q, see bug #453\n", nfn.Filepath, tpath)
                        } else {
                                nfn.AddToVCS() // todo: this sometimes is not just tpath!  See bug #453
                        }
                        nfn.Update()
                }
        }
}

// Shows file information about selected file(s)
func (fn *Node) showFileInfo() { //types:add
        fn.SelectedFunc(func(sn *Node) {
                d := core.NewBody("File info")
                core.NewForm(d).SetStruct(&sn.Info).SetReadOnly(true)
                d.AddOKOnly().RunWindowDialog(sn)
        })
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

import (
        "fmt"
        "path/filepath"
        "sort"
        "strings"
        "time"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/core"
        "cogentcore.org/core/tree"
)

// findDirNode finds directory node by given path.
// Must be a relative path already rooted at tree, or absolute path within tree.
func (fn *Node) findDirNode(path string) (*Node, error) {
        rp := fn.RelativePathFrom(core.Filename(path))
        if rp == "" {
                return nil, fmt.Errorf("FindDirNode: path: %s is not relative to this node's path: %s", path, fn.Filepath)
        }
        if rp == "." {
                return fn, nil
        }
        dirs := filepath.SplitList(rp)
        dir := dirs[0]
        dni := fn.ChildByName(dir, 0)
        if dni == nil {
                return nil, fmt.Errorf("could not find child %q", dir)
        }
        dn := AsNode(dni)
        if len(dirs) == 1 {
                if dn.IsDir() {
                        return dn, nil
                }
                return nil, fmt.Errorf("FindDirNode: item at path: %s is not a Directory", path)
        }
        return dn.findDirNode(filepath.Join(dirs[1:]...))
}

// FindFile finds first node representing given file (false if not found) --
// looks for full path names that have the given string as their suffix, so
// you can include as much of the path (including whole thing) as is relevant
// to disambiguate.  See FilesMatching for a list of files that match a given
// string.
func (fn *Node) FindFile(fnm string) (*Node, bool) {
        if fnm == "" {
                return nil, false
        }
        fneff := fnm
        if len(fneff) > 2 && fneff[:2] == ".." { // relative path -- get rid of it and just look for relative part
                dirs := strings.Split(fneff, string(filepath.Separator))
                for i, dr := range dirs {
                        if dr != ".." {
                                fneff = filepath.Join(dirs[i:]...)
                                break
                        }
                }
        }

        if efn, err := fn.FileRoot().externalNodeByPath(fnm); err == nil {
                return efn, true
        }

        if strings.HasPrefix(fneff, string(fn.Filepath)) { // full path
                ffn, err := fn.dirsTo(fneff)
                if err == nil {
                        return ffn, true
                }
                return nil, false
        }

        var ffn *Node
        found := false
        fn.WidgetWalkDown(func(cw core.Widget, cwb *core.WidgetBase) bool {
                sfn := AsNode(cw)
                if sfn == nil {
                        return tree.Continue
                }
                if strings.HasSuffix(string(sfn.Filepath), fneff) {
                        ffn = sfn
                        found = true
                        return tree.Break
                }
                return tree.Continue
        })
        return ffn, found
}

// NodeNameCount is used to report counts of different string-based things
// in the file tree
type NodeNameCount struct {
        Name  string
        Count int
}

func NodeNameCountSort(ecs []NodeNameCount) {
        sort.Slice(ecs, func(i, j int) bool {
                return ecs[i].Count > ecs[j].Count
        })
}

// FileExtensionCounts returns a count of all the different file extensions, sorted
// from highest to lowest.
// If cat is != fileinfo.Unknown then it only uses files of that type
// (e.g., fileinfo.Code to find any code files)
func (fn *Node) FileExtensionCounts(cat fileinfo.Categories) []NodeNameCount {
        cmap := make(map[string]int)
        fn.WidgetWalkDown(func(cw core.Widget, cwb *core.WidgetBase) bool {
                sfn := AsNode(cw)
                if sfn == nil {
                        return tree.Continue
                }
                if cat != fileinfo.UnknownCategory {
                        if sfn.Info.Cat != cat {
                                return tree.Continue
                        }
                }
                ext := strings.ToLower(filepath.Ext(sfn.Name))
                if ec, has := cmap[ext]; has {
                        cmap[ext] = ec + 1
                } else {
                        cmap[ext] = 1
                }
                return tree.Continue
        })
        ecs := make([]NodeNameCount, len(cmap))
        idx := 0
        for key, val := range cmap {
                ecs[idx] = NodeNameCount{Name: key, Count: val}
                idx++
        }
        NodeNameCountSort(ecs)
        return ecs
}

// LatestFileMod returns the most recent mod time of files in the tree.
// If cat is != fileinfo.Unknown then it only uses files of that type
// (e.g., fileinfo.Code to find any code files)
func (fn *Node) LatestFileMod(cat fileinfo.Categories) time.Time {
        tmod := time.Time{}
        fn.WidgetWalkDown(func(cw core.Widget, cwb *core.WidgetBase) bool {
                sfn := AsNode(cw)
                if sfn == nil {
                        return tree.Continue
                }
                if cat != fileinfo.UnknownCategory {
                        if sfn.Info.Cat != cat {
                                return tree.Continue
                        }
                }
                ft := (time.Time)(sfn.Info.ModTime)
                if ft.After(tmod) {
                        tmod = ft
                }
                return tree.Continue
        })
        return tmod
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

import (
        "strings"

        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/core"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/system"
)

// vcsLabelFunc gets the appropriate label for removing from version control
func vcsLabelFunc(fn *Node, label string) string {
        repo, _ := fn.Repo()
        if repo != nil {
                label = strings.Replace(label, "VCS", string(repo.Vcs()), 1)
        }
        return label
}

func (fn *Node) VCSContextMenu(m *core.Scene) {
        if fn.FileRoot().FS != nil {
                return
        }
        core.NewFuncButton(m).SetFunc(fn.addToVCSSelected).SetText(vcsLabelFunc(fn, "Add to VCS")).SetIcon(icons.Add).
                Styler(func(s *styles.Style) {
                        s.SetState(!fn.HasSelection() || fn.Info.VCS != vcs.Untracked, states.Disabled)
                })
        core.NewFuncButton(m).SetFunc(fn.deleteFromVCSSelected).SetText(vcsLabelFunc(fn, "Delete from VCS")).SetIcon(icons.Delete).
                Styler(func(s *styles.Style) {
                        s.SetState(!fn.HasSelection() || fn.Info.VCS == vcs.Untracked, states.Disabled)
                })
        core.NewFuncButton(m).SetFunc(fn.commitToVCSSelected).SetText(vcsLabelFunc(fn, "Commit to VCS")).SetIcon(icons.Star).
                Styler(func(s *styles.Style) {
                        s.SetState(!fn.HasSelection() || fn.Info.VCS == vcs.Untracked, states.Disabled)
                })
        core.NewFuncButton(m).SetFunc(fn.revertVCSSelected).SetText(vcsLabelFunc(fn, "Revert from VCS")).SetIcon(icons.Undo).
                Styler(func(s *styles.Style) {
                        s.SetState(!fn.HasSelection() || fn.Info.VCS == vcs.Untracked, states.Disabled)
                })
        core.NewSeparator(m)

        core.NewFuncButton(m).SetFunc(fn.diffVCSSelected).SetText(vcsLabelFunc(fn, "Diff VCS")).SetIcon(icons.Add).
                Styler(func(s *styles.Style) {
                        s.SetState(!fn.HasSelection() || fn.Info.VCS == vcs.Untracked, states.Disabled)
                })
        core.NewFuncButton(m).SetFunc(fn.logVCSSelected).SetText(vcsLabelFunc(fn, "Log VCS")).SetIcon(icons.List).
                Styler(func(s *styles.Style) {
                        s.SetState(!fn.HasSelection() || fn.Info.VCS == vcs.Untracked, states.Disabled)
                })
        core.NewFuncButton(m).SetFunc(fn.blameVCSSelected).SetText(vcsLabelFunc(fn, "Blame VCS")).SetIcon(icons.CreditScore).
                Styler(func(s *styles.Style) {
                        s.SetState(!fn.HasSelection() || fn.Info.VCS == vcs.Untracked, states.Disabled)
                })
}

func (fn *Node) contextMenu(m *core.Scene) {
        core.NewFuncButton(m).SetFunc(fn.showFileInfo).SetText("Info").
                SetIcon(icons.Info).SetEnabled(fn.HasSelection())

        open := core.NewFuncButton(m).SetFunc(fn.OpenFilesDefault).SetText("Open").
                SetIcon(icons.Open)
        open.SetEnabled(fn.HasSelection())

        if core.TheApp.Platform() == system.Web {
                open.SetText("Download").SetIcon(icons.Download).SetTooltip("Download this file to your device")
        }

        core.NewSeparator(m)

        core.NewFuncButton(m).SetFunc(fn.duplicateFiles).SetText("Duplicate").
                SetIcon(icons.Copy).SetKey(keymap.Duplicate).SetEnabled(fn.HasSelection())

        core.NewFuncButton(m).SetFunc(fn.This.(Filer).DeleteFiles).SetText("Delete").
                SetIcon(icons.Delete).SetKey(keymap.Delete).SetEnabled(fn.HasSelection())

        core.NewFuncButton(m).SetFunc(fn.This.(Filer).RenameFiles).SetText("Rename").
                SetIcon(icons.NewLabel).SetEnabled(fn.HasSelection())

        core.NewSeparator(m)

        core.NewFuncButton(m).SetFunc(fn.openAll).SetText("Open all").
                SetIcon(icons.KeyboardArrowDown).SetEnabled(fn.HasSelection() && fn.IsDir())

        core.NewFuncButton(m).SetFunc(fn.CloseAll).SetIcon(icons.KeyboardArrowRight).
                SetEnabled(fn.HasSelection() && fn.IsDir())

        core.NewFuncButton(m).SetFunc(fn.sortBys).SetText("Sort by").
                SetIcon(icons.Sort).SetEnabled(fn.HasSelection() && fn.IsDir())

        core.NewSeparator(m)

        fb := core.NewFuncButton(m).SetFunc(fn.newFiles)
        fb.SetText("New file").SetIcon(icons.OpenInNew).SetEnabled(fn.HasSelection())
        fb.Args[1].SetValue(true) // todo: not working

        core.NewFuncButton(m).SetFunc(fn.newFolders).SetText("New folder").
                SetIcon(icons.CreateNewFolder).SetEnabled(fn.HasSelection())

        core.NewSeparator(m)

        fn.VCSContextMenu(m)
        core.NewSeparator(m)

        core.NewFuncButton(m).SetFunc(fn.removeFromExterns).
                SetIcon(icons.Delete).SetEnabled(fn.HasSelection())

        core.NewSeparator(m)

        core.NewFuncButton(m).SetFunc(fn.Copy).SetIcon(icons.Copy).
                SetKey(keymap.Copy).SetEnabled(fn.HasSelection())

        core.NewFuncButton(m).SetFunc(fn.Cut).SetIcon(icons.Cut).
                SetKey(keymap.Cut).SetEnabled(fn.HasSelection())

        paste := core.NewFuncButton(m).SetFunc(fn.Paste).
                SetIcon(icons.Paste).SetKey(keymap.Paste).SetEnabled(fn.HasSelection())

        cb := fn.Events().Clipboard()
        if cb != nil {
                paste.SetState(cb.IsEmpty(), states.Disabled)
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

//go:generate core generate

import (
        "fmt"
        "io/fs"
        "log"
        "log/slog"
        "os"
        "path/filepath"
        "slices"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/highlighting"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/tree"
)

// NodeHighlighting is the default style for syntax highlighting to use for
// file node buffers
var NodeHighlighting = highlighting.StyleDefault

// Node represents a file in the file system, as a [core.Tree] node.
// The name of the node is the name of the file.
// Folders have children containing further nodes.
type Node struct { //core:embedder
        core.Tree

        // Filepath is the full path to this file.
        Filepath core.Filename `edit:"-" set:"-" json:"-" xml:"-" copier:"-"`

        // Info is the full standard file info about this file.
        Info fileinfo.FileInfo `edit:"-" set:"-" json:"-" xml:"-" copier:"-"`

        // FileIsOpen indicates that this file has been opened, indicated by Italics.
        FileIsOpen bool

        // DirRepo is the version control system repository for this directory,
        // only non-nil if this is the highest-level directory in the tree under vcs control.
        DirRepo vcs.Repo `edit:"-" set:"-" json:"-" xml:"-" copier:"-"`
}

func (fn *Node) AsFileNode() *Node {
        return fn
}

// FileRoot returns the Root node as a [Tree].
func (fn *Node) FileRoot() *Tree {
        return AsTree(fn.Root)
}

func (fn *Node) Init() {
        fn.Tree.Init()
        fn.IconOpen = icons.FolderOpen
        fn.IconClosed = icons.Folder
        fn.ContextMenus = nil // do not include tree
        fn.AddContextMenu(fn.contextMenu)
        fn.Styler(func(s *styles.Style) {
                fn.styleFromStatus()
        })
        fn.On(events.KeyChord, func(e events.Event) {
                if core.DebugSettings.KeyEventTrace {
                        fmt.Printf("Tree KeyInput: %v\n", fn.Path())
                }
                kf := keymap.Of(e.KeyChord())
                selMode := events.SelectModeBits(e.Modifiers())

                if selMode == events.SelectOne {
                        if fn.SelectMode {
                                selMode = events.ExtendContinuous
                        }
                }

                // first all the keys that work for ReadOnly and active
                if !fn.IsReadOnly() && !e.IsHandled() {
                        switch kf {
                        case keymap.Delete:
                                fn.This.(Filer).DeleteFiles()
                                e.SetHandled()
                        case keymap.Backspace:
                                fn.This.(Filer).DeleteFiles()
                                e.SetHandled()
                        case keymap.Duplicate:
                                fn.duplicateFiles()
                                e.SetHandled()
                        case keymap.Insert: // New File
                                core.CallFunc(fn, fn.newFile)
                                e.SetHandled()
                        case keymap.InsertAfter: // New Folder
                                core.CallFunc(fn, fn.newFolder)
                                e.SetHandled()
                        }
                }
        })

        fn.Parts.Styler(func(s *styles.Style) {
                s.Gap.X.Em(0.4)
        })
        fn.Parts.OnClick(func(e events.Event) {
                if !e.HasAnyModifier(key.Control, key.Meta, key.Alt, key.Shift) {
                        fn.Open()
                }
        })
        fn.Parts.OnDoubleClick(func(e events.Event) {
                e.SetHandled()
                if fn.IsDir() {
                        fn.ToggleClose()
                } else {
                        fn.This.(Filer).OpenFile()
                }
        })
        tree.AddChildInit(fn.Parts, "branch", func(w *core.Switch) {
                tree.AddChildInit(w, "stack", func(w *core.Frame) {
                        f := func(name string) {
                                tree.AddChildInit(w, name, func(w *core.Icon) {
                                        w.Styler(func(s *styles.Style) {
                                                s.Min.Set(units.Em(1))
                                        })
                                })
                        }
                        f("icon-on")
                        f("icon-off")
                        f("icon-indeterminate")
                })
        })
        tree.AddChildInit(fn.Parts, "text", func(w *core.Text) {
                w.Styler(func(s *styles.Style) {
                        if fn.IsExec() && !fn.IsDir() {
                                s.Font.Weight = rich.Bold
                        }
                        if fn.FileIsOpen {
                                s.Font.Slant = rich.Italic
                        }
                })
        })

        fn.Updater(func() {
                fn.setFileIcon()
                if fn.IsDir() {
                        repo, rnode := fn.Repo()
                        if repo != nil && rnode.This == fn.This {
                                rnode.updateRepoFiles()
                        }
                } else {
                        fn.This.(Filer).GetFileInfo()
                }
                fn.Text = fn.Info.Name
                cc := fn.Styles.Color
                fn.styleFromStatus()
                if fn.Styles.Color != cc && fn.Parts != nil {
                        fn.Parts.StyleTree()
                }
        })

        fn.Maker(func(p *tree.Plan) {
                if fn.Filepath == "" {
                        return
                }
                if fn.Name == externalFilesName {
                        files := fn.FileRoot().externalFiles
                        for _, fi := range files {
                                tree.AddNew(p, fi, func() Filer {
                                        return tree.NewOfType(fn.FileRoot().FileNodeType).(Filer)
                                }, func(wf Filer) {
                                        w := wf.AsFileNode()
                                        w.Root = fn.Root
                                        w.NeedsLayout()
                                        w.Filepath = core.Filename(fi)
                                        w.Info.Mode = os.ModeIrregular
                                        w.Info.VCS = vcs.Stored
                                })
                        }
                        return
                }
                if !fn.IsDir() || fn.IsIrregular() {
                        return
                }
                if !((fn.FileRoot().inOpenAll && !fn.Info.IsHidden()) || fn.FileRoot().isDirOpen(fn.Filepath)) {
                        return
                }
                repo, _ := fn.Repo()
                files := fn.dirFileList()
                for _, fi := range files {
                        fpath := filepath.Join(string(fn.Filepath), fi.Name())
                        if fn.FileRoot().FilterFunc != nil && !fn.FileRoot().FilterFunc(fpath, fi) {
                                continue
                        }
                        tree.AddNew(p, fi.Name(), func() Filer {
                                return tree.NewOfType(fn.FileRoot().FileNodeType).(Filer)
                        }, func(wf Filer) {
                                w := wf.AsFileNode()
                                w.Root = fn.Root
                                w.NeedsLayout()
                                w.Filepath = core.Filename(fpath)
                                w.This.(Filer).GetFileInfo()
                                if w.FileRoot().FS == nil {
                                        if w.IsDir() && repo == nil {
                                                w.detectVCSRepo()
                                        }
                                }
                        })
                }
        })
}

// styleFromStatus updates font color from
func (fn *Node) styleFromStatus() {
        status := fn.Info.VCS
        hex := ""
        switch {
        case status == vcs.Untracked:
                hex = "#808080"
        case status == vcs.Modified:
                hex = "#4b7fd1"
        case status == vcs.Added:
                hex = "#008800"
        case status == vcs.Deleted:
                hex = "#ff4252"
        case status == vcs.Conflicted:
                hex = "#ce8020"
        case status == vcs.Updated:
                hex = "#008060"
        case status == vcs.Stored:
                fn.Styles.Color = colors.Scheme.OnSurface
        }
        if fn.Info.Generated {
                hex = "#8080C0"
        }
        if hex != "" {
                fn.Styles.Color = colors.Uniform(colors.ToBase(errors.Must1(colors.FromHex(hex))))
        } else {
                fn.Styles.Color = colors.Scheme.OnSurface
        }
        // if fn.Name == "test.go" {
        //         rep, err := fn.Repo()
        //         fmt.Println("style updt:", status, hex, rep != nil, err)
        // }
}

// IsDir returns true if file is a directory (folder)
func (fn *Node) IsDir() bool {
        return fn.Info.IsDir()
}

// IsIrregular  returns true if file is a special "Irregular" node
func (fn *Node) IsIrregular() bool {
        return (fn.Info.Mode & os.ModeIrregular) != 0
}

// isExternal returns true if file is external to main file tree
func (fn *Node) isExternal() bool {
        isExt := false
        fn.WalkUp(func(k tree.Node) bool {
                sfn := AsNode(k)
                if sfn == nil {
                        return tree.Break
                }
                if sfn.IsIrregular() {
                        isExt = true
                        return tree.Break
                }
                return tree.Continue
        })
        return isExt
}

// IsExec returns true if file is an executable file
func (fn *Node) IsExec() bool {
        return fn.Info.IsExec()
}

// isOpen returns true if file is flagged as open
func (fn *Node) isOpen() bool {
        return !fn.Closed
}

// isAutoSave returns true if file is an auto-save file (starts and ends with #)
func (fn *Node) isAutoSave() bool {
        return strings.HasPrefix(fn.Info.Name, "#") && strings.HasSuffix(fn.Info.Name, "#")
}

// RelativePath returns the relative path from root for this node
func (fn *Node) RelativePath() string {
        if fn.IsIrregular() || fn.FileRoot() == nil {
                return fn.Name
        }
        return fsx.RelativeFilePath(string(fn.Filepath), string(fn.FileRoot().Filepath))
}

// dirFileList returns the list of files in this directory,
// sorted according to DirsOnTop and SortByModTime options
func (fn *Node) dirFileList() []fs.FileInfo {
        path := string(fn.Filepath)
        var files []fs.FileInfo
        var dirs []fs.FileInfo // for DirsOnTop mode
        var di []fs.DirEntry
        isFS := false
        if fn.FileRoot().FS == nil {
                di = errors.Log1(os.ReadDir(path))
        } else {
                isFS = true
                di = errors.Log1(fs.ReadDir(fn.FileRoot().FS, path))
        }
        for _, d := range di {
                info := errors.Log1(d.Info())
                if fn.FileRoot().DirsOnTop {
                        if d.IsDir() {
                                dirs = append(dirs, info)
                        } else {
                                files = append(files, info)
                        }
                } else {
                        files = append(files, info)
                }
        }
        doModSort := fn.FileRoot().SortByModTime
        if doModSort {
                doModSort = !fn.FileRoot().dirSortByName(core.Filename(path))
        } else {
                doModSort = fn.FileRoot().dirSortByModTime(core.Filename(path))
        }

        if fn.FileRoot().DirsOnTop {
                if doModSort {
                        sortByModTime(dirs, isFS) // note: FS = ascending, otherwise descending
                        sortByModTime(files, isFS)
                }
                files = append(dirs, files...)
        } else {
                if doModSort {
                        sortByModTime(files, isFS)
                }
        }
        return files
}

// sortByModTime sorts by _reverse_ mod time (newest first)
func sortByModTime(files []fs.FileInfo, ascending bool) {
        slices.SortFunc(files, func(a, b fs.FileInfo) int {
                if ascending {
                        return a.ModTime().Compare(b.ModTime())
                }
                return b.ModTime().Compare(a.ModTime())
        })
}

func (fn *Node) setFileIcon() {
        if fn.Info.Ic == "" {
                ic, hasic := fn.Info.FindIcon()
                if hasic {
                        fn.Info.Ic = ic
                } else {
                        fn.Info.Ic = icons.Blank
                }
        }
        fn.IconLeaf = fn.Info.Ic
        if br := fn.Branch; br != nil {
                if br.IconIndeterminate != fn.IconLeaf {
                        br.SetIconOn(icons.FolderOpen).SetIconOff(icons.Folder).SetIconIndeterminate(fn.IconLeaf)
                        br.UpdateTree()
                }
        }
}

// GetFileInfo is a Filer interface method that can be overwritten
// to do custom file info.
func (fn *Node) GetFileInfo() error {
        return fn.InitFileInfo()
}

// InitFileInfo initializes file info
func (fn *Node) InitFileInfo() error {
        if fn.Filepath == "" {
                return nil
        }
        var err error
        if fn.FileRoot().FS == nil { // deal with symlinks
                ls, err := os.Lstat(string(fn.Filepath))
                if errors.Log(err) != nil {
                        return err
                }
                if ls.Mode()&os.ModeSymlink != 0 {
                        effpath, err := filepath.EvalSymlinks(string(fn.Filepath))
                        if err != nil {
                                // this happens too often for links -- skip
                                // log.Printf("filetree.Node Path: %v could not be opened -- error: %v\n", fn.Filepath, err)
                                return err
                        }
                        fn.Filepath = core.Filename(effpath)
                }
                err = fn.Info.InitFile(string(fn.Filepath))
        } else {
                err = fn.Info.InitFileFS(fn.FileRoot().FS, string(fn.Filepath))
        }
        if err != nil {
                emsg := fmt.Errorf("filetree.Node InitFileInfo Path %q: Error: %v", fn.Filepath, err)
                log.Println(emsg)
                return emsg
        }
        repo, rnode := fn.Repo()
        if repo != nil {
                if fn.IsDir() {
                        fn.Info.VCS = vcs.Stored // always
                } else {
                        rstat := rnode.DirRepo.StatusFast(string(fn.Filepath))
                        if rstat != fn.Info.VCS {
                                fn.Info.VCS = rstat
                                fn.NeedsRender()
                        }
                }
        } else {
                fn.Info.VCS = vcs.Stored
        }
        return nil
}

// SelectedFunc runs the given function on all selected nodes in reverse order.
func (fn *Node) SelectedFunc(fun func(n *Node)) {
        sels := fn.GetSelectedNodes()
        for i := len(sels) - 1; i >= 0; i-- {
                sn := AsNode(sels[i])
                if sn == nil {
                        continue
                }
                fun(sn)
        }
}

func (fn *Node) OnOpen() {
        fn.openDir()
}

func (fn *Node) OnClose() {
        if !fn.IsDir() {
                return
        }
        fn.FileRoot().setDirClosed(fn.Filepath)
}

func (fn *Node) CanOpen() bool {
        return fn.HasChildren() || fn.IsDir()
}

// openDir opens given directory node
func (fn *Node) openDir() {
        if !fn.IsDir() {
                return
        }
        fn.FileRoot().setDirOpen(fn.Filepath)
        fn.Update()
}

// sortBys determines how to sort the selected files in the directory.
// Default is alpha by name, optionally can be sorted by modification time.
func (fn *Node) sortBys(modTime bool) { //types:add
        fn.SelectedFunc(func(sn *Node) {
                sn.sortBy(modTime)
        })
}

// sortBy determines how to sort the files in the directory -- default is alpha by name,
// optionally can be sorted by modification time.
func (fn *Node) sortBy(modTime bool) {
        fn.FileRoot().setDirSortBy(fn.Filepath, modTime)
        fn.Update()
}

// openAll opens all directories under this one
func (fn *Node) openAll() { //types:add
        fn.FileRoot().inOpenAll = true // causes chaining of opening
        fn.Tree.OpenAll()
        fn.FileRoot().inOpenAll = false
}

// removeFromExterns removes file from list of external files
func (fn *Node) removeFromExterns() { //types:add
        fn.SelectedFunc(func(sn *Node) {
                if !sn.isExternal() {
                        return
                }
                sn.FileRoot().removeExternalFile(string(sn.Filepath))
                sn.Delete()
        })
}

// RelativePathFrom returns the relative path from node for given full path
func (fn *Node) RelativePathFrom(fpath core.Filename) string {
        return fsx.RelativeFilePath(string(fpath), string(fn.Filepath))
}

// dirsTo opens all the directories above the given filename, and returns the node
// for element at given path (can be a file or directory itself -- not opened -- just returned)
func (fn *Node) dirsTo(path string) (*Node, error) {
        pth, err := filepath.Abs(path)
        if err != nil {
                log.Printf("filetree.Node DirsTo path %v could not be turned into an absolute path: %v\n", path, err)
                return nil, err
        }
        rpath := fn.RelativePathFrom(core.Filename(pth))
        if rpath == "." {
                return fn, nil
        }
        dirs := strings.Split(rpath, string(filepath.Separator))
        cfn := fn
        sz := len(dirs)
        for i := 0; i < sz; i++ {
                dr := dirs[i]
                sfni := cfn.ChildByName(dr, 0)
                if sfni == nil {
                        if i == sz-1 { // ok for terminal -- might not exist yet
                                return cfn, nil
                        }
                        err = fmt.Errorf("filetree.Node could not find node %v in: %v, orig: %v, rel: %v", dr, cfn.Filepath, pth, rpath)
                        // slog.Error(err.Error()) // note: this is expected sometimes
                        return nil, err
                }
                sfn := AsNode(sfni)
                if sfn.IsDir() || i == sz-1 {
                        if i < sz-1 && !sfn.isOpen() {
                                sfn.openDir()
                        } else {
                                cfn = sfn
                        }
                } else {
                        err := fmt.Errorf("filetree.Node non-terminal node %v is not a directory in: %v", dr, cfn.Filepath)
                        slog.Error(err.Error())
                        return nil, err
                }
                cfn = sfn
        }
        return cfn, nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

import (
        "fmt"
        "io/fs"
        "log/slog"
        "os"
        "path/filepath"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/core"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
        "github.com/fsnotify/fsnotify"
)

const (
        // externalFilesName is the name of the node that represents external files
        externalFilesName = "[external files]"
)

// Treer is an interface for getting the Root node if it implements [Treer].
type Treer interface {
        AsFileTree() *Tree
}

// AsTree returns the given value as a [Tree] if it has
// an AsFileTree() method, or nil otherwise.
func AsTree(n tree.Node) *Tree {
        if t, ok := n.(Treer); ok {
                return t.AsFileTree()
        }
        return nil
}

// Tree is the root widget of a file tree representing files in a given directory
// (and subdirectories thereof), and has some overall management state for how to
// view things.
type Tree struct {
        Node

        // externalFiles are external files outside the root path of the tree.
        // They are stored in terms of their absolute paths. These are shown
        // in the first sub-node if present; use [Tree.AddExternalFile] to add one.
        externalFiles []string

        // Dirs records state of directories within the tree (encoded using paths relative to root),
        // e.g., open (have been opened by the user) -- can persist this to restore prior view of a tree
        Dirs DirFlagMap `set:"-"`

        // DirsOnTop indicates whether all directories are placed at the top of the tree.
        // Otherwise everything is mixed.  This is the default.
        DirsOnTop bool

        // SortByModTime causes files to be sorted by modification time by default.
        // Otherwise it is a per-directory option.
        SortByModTime bool

        // FileNodeType is the type of node to create; defaults to [Node] but can use custom node types
        FileNodeType *types.Type `display:"-" json:"-" xml:"-"`

        // FilterFunc, if set, determines whether to include the given node in the tree.
        // return true to include, false to not.  This applies to files and directories alike.
        FilterFunc func(path string, info fs.FileInfo) bool

        // FS is the file system we are browsing, if it is an FS (nil = os filesystem)
        FS fs.FS

        // inOpenAll indicates whether we are in midst of an OpenAll call; nodes should open all dirs.
        inOpenAll bool

        // watcher does change notify for all dirs
        watcher *fsnotify.Watcher

        // doneWatcher is channel to close watcher watcher
        doneWatcher chan bool

        // watchedPaths is map of paths that have been added to watcher; only active if bool = true
        watchedPaths map[string]bool

        // lastWatchUpdate is last path updated by watcher
        lastWatchUpdate string

        // lastWatchTime is timestamp of last update
        lastWatchTime time.Time
}

func (ft *Tree) Init() {
        ft.Node.Init()
        ft.Root = ft
        ft.FileNodeType = types.For[Node]()
        ft.OpenDepth = 4
        ft.DirsOnTop = true
        ft.FirstMaker(func(p *tree.Plan) {
                if len(ft.externalFiles) == 0 {
                        return
                }
                tree.AddNew(p, externalFilesName, func() Filer {
                        return tree.NewOfType(ft.FileNodeType).(Filer)
                }, func(wf Filer) {
                        w := wf.AsFileNode()
                        w.Root = ft.Root
                        w.Filepath = externalFilesName
                        w.Info.Mode = os.ModeDir
                        w.Info.VCS = vcs.Stored
                })
        })
}

func (fv *Tree) Destroy() {
        if fv.watcher != nil {
                fv.watcher.Close()
                fv.watcher = nil
        }
        if fv.doneWatcher != nil {
                fv.doneWatcher <- true
                close(fv.doneWatcher)
                fv.doneWatcher = nil
        }
        fv.Tree.Destroy()
}

func (ft *Tree) AsFileTree() *Tree {
        return ft
}

// OpenPath opens the filetree at the given os file system directory path.
// It reads all the files at the given path into this tree.
// Only paths listed in [Tree.Dirs] will be opened.
func (ft *Tree) OpenPath(path string) *Tree {
        if ft.FileNodeType == nil {
                ft.FileNodeType = types.For[Node]()
        }
        effpath, err := filepath.EvalSymlinks(path)
        if err != nil {
                effpath = path
        }
        abs, err := filepath.Abs(effpath)
        if errors.Log(err) != nil {
                abs = effpath
        }
        ft.FS = nil
        ft.Filepath = core.Filename(abs)
        ft.setDirOpen(core.Filename(abs))
        ft.detectVCSRepo()
        ft.This.(Filer).GetFileInfo()
        ft.Open()
        ft.Update()
        return ft
}

// OpenPathFS opens the filetree at the given [fs] file system directory path.
// It reads all the files at the given path into this tree.
// Only paths listed in [Tree.Dirs] will be opened.
func (ft *Tree) OpenPathFS(fsys fs.FS, path string) *Tree {
        if ft.FileNodeType == nil {
                ft.FileNodeType = types.For[Node]()
        }
        ft.FS = fsys
        ft.Filepath = core.Filename(path)
        ft.setDirOpen(core.Filename(path))
        ft.This.(Filer).GetFileInfo()
        ft.Open()
        ft.Update()
        return ft
}

// UpdatePath updates the tree at the directory level for given path
// and everything below it. It flags that it needs render update,
// but if a deletion or insertion happened, then NeedsLayout should also
// be called.
func (ft *Tree) UpdatePath(path string) {
        ft.NeedsRender()
        path = filepath.Clean(path)
        ft.dirsTo(path)
        if fn, ok := ft.FindFile(path); ok {
                if fn.IsDir() {
                        fn.Update()
                        return
                }
        }
        fpath, _ := filepath.Split(path)
        if fn, ok := ft.FindFile(fpath); ok {
                fn.Update()
                return
        }
        // core.MessageSnackbar(ft, "UpdatePath: path not found in tree: "+path)
}

// OpenPaths returns a list of open paths.
func (ft *Tree) OpenPaths() []string {
        return ft.Dirs.openPaths(string(ft.Filepath))
}

// configWatcher configures a new watcher for tree
func (ft *Tree) configWatcher() error {
        if ft.watcher != nil {
                return nil
        }
        ft.watchedPaths = make(map[string]bool)
        var err error
        ft.watcher, err = fsnotify.NewWatcher()
        return err
}

// watchWatcher monitors the watcher channel for update events.
// It must be called once some paths have been added to watcher --
// safe to call multiple times.
func (ft *Tree) watchWatcher() {
        if ft.watcher == nil || ft.watcher.Events == nil {
                return
        }
        if ft.doneWatcher != nil {
                return
        }
        ft.doneWatcher = make(chan bool)
        go func() {
                watch := ft.watcher
                done := ft.doneWatcher
                for {
                        select {
                        case <-done:
                                return
                        case event := <-watch.Events:
                                switch {
                                case event.Op&fsnotify.Create == fsnotify.Create ||
                                        event.Op&fsnotify.Remove == fsnotify.Remove ||
                                        event.Op&fsnotify.Rename == fsnotify.Rename:
                                        ft.watchUpdate(event.Name)
                                }
                        case err := <-watch.Errors:
                                _ = err
                        }
                }
        }()
}

// watchUpdate does the update for given path
func (ft *Tree) watchUpdate(path string) {
        ft.AsyncLock()
        defer ft.AsyncUnlock()
        // fmt.Println(path)

        dir, _ := filepath.Split(path)
        rp := ft.RelativePathFrom(core.Filename(dir))
        if rp == ft.lastWatchUpdate {
                now := time.Now()
                lagMs := int(now.Sub(ft.lastWatchTime) / time.Millisecond)
                if lagMs < 100 {
                        // fmt.Printf("skipping update to: %s  due to lag: %v\n", rp, lagMs)
                        return // no update
                }
        }
        fn, err := ft.findDirNode(rp)
        if err != nil {
                // slog.Error(err.Error())
                return
        }
        ft.lastWatchUpdate = rp
        ft.lastWatchTime = time.Now()
        if !fn.isOpen() {
                // fmt.Printf("warning: watcher updating closed node: %s\n", rp)
                return // shouldn't happen
        }
        fn.Update()
}

// watchPath adds given path to those watched
func (ft *Tree) watchPath(path core.Filename) error {
        return nil // TODO(#424): disable for all platforms for now; causing issues
        if core.TheApp.Platform() == system.MacOS {
                return nil // mac is not supported in a high-capacity fashion at this point
        }
        rp := ft.RelativePathFrom(path)
        on, has := ft.watchedPaths[rp]
        if on || has {
                return nil
        }
        ft.configWatcher()
        // fmt.Printf("watching path: %s\n", path)
        err := ft.watcher.Add(string(path))
        if err == nil {
                ft.watchedPaths[rp] = true
                ft.watchWatcher()
        } else {
                slog.Error(err.Error())
        }
        return err
}

// unWatchPath removes given path from those watched
func (ft *Tree) unWatchPath(path core.Filename) {
        rp := ft.RelativePathFrom(path)
        on, has := ft.watchedPaths[rp]
        if !on || !has {
                return
        }
        ft.configWatcher()
        ft.watcher.Remove(string(path))
        ft.watchedPaths[rp] = false
}

// isDirOpen returns true if given directory path is open (i.e., has been
// opened in the view)
func (ft *Tree) isDirOpen(fpath core.Filename) bool {
        if fpath == ft.Filepath { // we are always open
                return true
        }
        return ft.Dirs.isOpen(ft.RelativePathFrom(fpath))
}

// setDirOpen sets the given directory path to be open
func (ft *Tree) setDirOpen(fpath core.Filename) {
        rp := ft.RelativePathFrom(fpath)
        // fmt.Printf("setdiropen: %s\n", rp)
        ft.Dirs.setOpen(rp, true)
        ft.watchPath(fpath)
}

// setDirClosed sets the given directory path to be closed
func (ft *Tree) setDirClosed(fpath core.Filename) {
        rp := ft.RelativePathFrom(fpath)
        ft.Dirs.setOpen(rp, false)
        ft.unWatchPath(fpath)
}

// setDirSortBy sets the given directory path sort by option
func (ft *Tree) setDirSortBy(fpath core.Filename, modTime bool) {
        ft.Dirs.setSortBy(ft.RelativePathFrom(fpath), modTime)
}

// dirSortByModTime returns true if dir is sorted by mod time
func (ft *Tree) dirSortByModTime(fpath core.Filename) bool {
        return ft.Dirs.sortByModTime(ft.RelativePathFrom(fpath))
}

// dirSortByName returns true if dir is sorted by name
func (ft *Tree) dirSortByName(fpath core.Filename) bool {
        return ft.Dirs.sortByName(ft.RelativePathFrom(fpath))
}

// AddExternalFile adds an external file outside of root of file tree
// and triggers an update, returning the Node for it, or
// error if [filepath.Abs] fails.
func (ft *Tree) AddExternalFile(fpath string) (*Node, error) {
        pth, err := filepath.Abs(fpath)
        if err != nil {
                return nil, err
        }
        if _, err := os.Stat(pth); err != nil {
                return nil, err
        }
        if has, _ := ft.hasExternalFile(pth); has {
                return ft.externalNodeByPath(pth)
        }
        newExt := len(ft.externalFiles) == 0
        ft.externalFiles = append(ft.externalFiles, pth)
        if newExt {
                ft.Update()
        } else {
                ft.Child(0).(Filer).AsFileNode().Update()
        }
        return ft.externalNodeByPath(pth)
}

// removeExternalFile removes external file from maintained list; returns true if removed.
func (ft *Tree) removeExternalFile(fpath string) bool {
        for i, ef := range ft.externalFiles {
                if ef == fpath {
                        ft.externalFiles = append(ft.externalFiles[:i], ft.externalFiles[i+1:]...)
                        return true
                }
        }
        return false
}

// hasExternalFile returns true and index if given abs path exists on ExtFiles list.
// false and -1 if not.
func (ft *Tree) hasExternalFile(fpath string) (bool, int) {
        for i, f := range ft.externalFiles {
                if f == fpath {
                        return true, i
                }
        }
        return false, -1
}

// externalNodeByPath returns Node for given file path, and true, if it
// exists in the external files list.  Otherwise returns nil, false.
func (ft *Tree) externalNodeByPath(fpath string) (*Node, error) {
        ehas, i := ft.hasExternalFile(fpath)
        if !ehas {
                return nil, fmt.Errorf("ExtFile not found on list: %v", fpath)
        }
        ekid := ft.ChildByName(externalFilesName, 0)
        if ekid == nil {
                return nil, errors.New("ExtFile not updated -- no ExtFiles node")
        }
        if n := ekid.AsTree().Child(i); n != nil {
                return AsNode(n), nil
        }
        return nil, errors.New("ExtFile not updated; index invalid")
}

// Code generated by "core generate"; DO NOT EDIT.

package filetree

import (
        "io/fs"

        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/filetree.Filer", IDName: "filer", Doc: "Filer is an interface for file tree file actions that all [Node]s satisfy.\nThis allows apps to intervene and apply any additional logic for these actions.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Methods: []types.Method{{Name: "AsFileNode", Doc: "AsFileNode returns the [Node]", Returns: []string{"Node"}}, {Name: "RenameFiles", Doc: "RenameFiles renames any selected files."}, {Name: "DeleteFiles", Doc: "DeleteFiles deletes any selected files."}, {Name: "GetFileInfo", Doc: "GetFileInfo updates the .Info for this file", Returns: []string{"error"}}, {Name: "OpenFile", Doc: "OpenFile opens the file for node. This is called by OpenFilesDefault", Returns: []string{"error"}}}})

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/filetree.Node", IDName: "node", Doc: "Node represents a file in the file system, as a [core.Tree] node.\nThe name of the node is the name of the file.\nFolders have children containing further nodes.", Directives: []types.Directive{{Tool: "core", Directive: "embedder"}}, Methods: []types.Method{{Name: "Cut", Doc: "Cut copies the selected files to the clipboard and then deletes them.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "Paste", Doc: "Paste inserts files from the clipboard.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "OpenFilesDefault", Doc: "OpenFilesDefault opens selected files with default app for that file type (os defined).\nruns open on Mac, xdg-open on Linux, and start on Windows", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "duplicateFiles", Doc: "duplicateFiles makes a copy of selected files", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "DeleteFiles", Doc: "DeleteFiles deletes any selected files or directories. If any directory is selected,\nall files and subdirectories in that directory are also deleted.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "RenameFiles", Doc: "renames any selected files", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "RenameFile", Doc: "RenameFile renames file to new name", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"newpath"}, Returns: []string{"error"}}, {Name: "newFiles", Doc: "newFiles makes a new file in selected directory", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename", "addToVCS"}}, {Name: "newFile", Doc: "newFile makes a new file in this directory node", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename", "addToVCS"}}, {Name: "newFolders", Doc: "makes a new folder in the given selected directory", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"foldername"}}, {Name: "newFolder", Doc: "newFolder makes a new folder (directory) in this directory node", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"foldername"}}, {Name: "showFileInfo", Doc: "Shows file information about selected file(s)", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "sortBys", Doc: "sortBys determines how to sort the selected files in the directory.\nDefault is alpha by name, optionally can be sorted by modification time.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"modTime"}}, {Name: "openAll", Doc: "openAll opens all directories under this one", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "removeFromExterns", Doc: "removeFromExterns removes file from list of external files", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "addToVCSSelected", Doc: "addToVCSSelected adds selected files to version control system", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "deleteFromVCSSelected", Doc: "deleteFromVCSSelected removes selected files from version control system", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "commitToVCSSelected", Doc: "commitToVCSSelected commits to version control system based on last selected file", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "revertVCSSelected", Doc: "revertVCSSelected removes selected files from version control system", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "diffVCSSelected", Doc: "diffVCSSelected shows the diffs between two versions of selected files, given by the\nrevision specifiers -- if empty, defaults to A = current HEAD, B = current WC file.\n-1, -2 etc also work as universal ways of specifying prior revisions.\nDiffs are shown in a DiffEditorDialog.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"rev_a", "rev_b"}}, {Name: "logVCSSelected", Doc: "logVCSSelected shows the VCS log of commits for selected files.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "blameVCSSelected", Doc: "blameVCSSelected shows the VCS blame report for this file, reporting for each line\nthe revision and author of the last change.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "Tree"}}, Fields: []types.Field{{Name: "Filepath", Doc: "Filepath is the full path to this file."}, {Name: "Info", Doc: "Info is the full standard file info about this file."}, {Name: "FileIsOpen", Doc: "FileIsOpen indicates that this file has been opened, indicated by Italics."}, {Name: "DirRepo", Doc: "DirRepo is the version control system repository for this directory,\nonly non-nil if this is the highest-level directory in the tree under vcs control."}, {Name: "repoFiles", Doc: "repoFiles has the version control system repository file status,\nproviding a much faster way to get file status, vs. the repo.Status\ncall which is exceptionally slow."}}})

// NewNode returns a new [Node] with the given optional parent:
// Node represents a file in the file system, as a [core.Tree] node.
// The name of the node is the name of the file.
// Folders have children containing further nodes.
func NewNode(parent ...tree.Node) *Node { return tree.New[Node](parent...) }

// NodeEmbedder is an interface that all types that embed Node satisfy
type NodeEmbedder interface {
        AsNode() *Node
}

// AsNode returns the given value as a value of type Node if the type
// of the given value embeds Node, or nil otherwise
func AsNode(n tree.Node) *Node {
        if t, ok := n.(NodeEmbedder); ok {
                return t.AsNode()
        }
        return nil
}

// AsNode satisfies the [NodeEmbedder] interface
func (t *Node) AsNode() *Node { return t }

// SetFileIsOpen sets the [Node.FileIsOpen]:
// FileIsOpen indicates that this file has been opened, indicated by Italics.
func (t *Node) SetFileIsOpen(v bool) *Node { t.FileIsOpen = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/filetree.Tree", IDName: "tree", Doc: "Tree is the root widget of a file tree representing files in a given directory\n(and subdirectories thereof), and has some overall management state for how to\nview things.", Embeds: []types.Field{{Name: "Node"}}, Fields: []types.Field{{Name: "externalFiles", Doc: "externalFiles are external files outside the root path of the tree.\nThey are stored in terms of their absolute paths. These are shown\nin the first sub-node if present; use [Tree.AddExternalFile] to add one."}, {Name: "Dirs", Doc: "Dirs records state of directories within the tree (encoded using paths relative to root),\ne.g., open (have been opened by the user) -- can persist this to restore prior view of a tree"}, {Name: "DirsOnTop", Doc: "DirsOnTop indicates whether all directories are placed at the top of the tree.\nOtherwise everything is mixed.  This is the default."}, {Name: "SortByModTime", Doc: "SortByModTime causes files to be sorted by modification time by default.\nOtherwise it is a per-directory option."}, {Name: "FileNodeType", Doc: "FileNodeType is the type of node to create; defaults to [Node] but can use custom node types"}, {Name: "FilterFunc", Doc: "FilterFunc, if set, determines whether to include the given node in the tree.\nreturn true to include, false to not.  This applies to files and directories alike."}, {Name: "FS", Doc: "FS is the file system we are browsing, if it is an FS (nil = os filesystem)"}, {Name: "inOpenAll", Doc: "inOpenAll indicates whether we are in midst of an OpenAll call; nodes should open all dirs."}, {Name: "watcher", Doc: "watcher does change notify for all dirs"}, {Name: "doneWatcher", Doc: "doneWatcher is channel to close watcher watcher"}, {Name: "watchedPaths", Doc: "watchedPaths is map of paths that have been added to watcher; only active if bool = true"}, {Name: "lastWatchUpdate", Doc: "lastWatchUpdate is last path updated by watcher"}, {Name: "lastWatchTime", Doc: "lastWatchTime is timestamp of last update"}}})

// NewTree returns a new [Tree] with the given optional parent:
// Tree is the root widget of a file tree representing files in a given directory
// (and subdirectories thereof), and has some overall management state for how to
// view things.
func NewTree(parent ...tree.Node) *Tree { return tree.New[Tree](parent...) }

// SetDirsOnTop sets the [Tree.DirsOnTop]:
// DirsOnTop indicates whether all directories are placed at the top of the tree.
// Otherwise everything is mixed.  This is the default.
func (t *Tree) SetDirsOnTop(v bool) *Tree { t.DirsOnTop = v; return t }

// SetSortByModTime sets the [Tree.SortByModTime]:
// SortByModTime causes files to be sorted by modification time by default.
// Otherwise it is a per-directory option.
func (t *Tree) SetSortByModTime(v bool) *Tree { t.SortByModTime = v; return t }

// SetFileNodeType sets the [Tree.FileNodeType]:
// FileNodeType is the type of node to create; defaults to [Node] but can use custom node types
func (t *Tree) SetFileNodeType(v *types.Type) *Tree { t.FileNodeType = v; return t }

// SetFilterFunc sets the [Tree.FilterFunc]:
// FilterFunc, if set, determines whether to include the given node in the tree.
// return true to include, false to not.  This applies to files and directories alike.
func (t *Tree) SetFilterFunc(v func(path string, info fs.FileInfo) bool) *Tree {
        t.FilterFunc = v
        return t
}

// SetFS sets the [Tree.FS]:
// FS is the file system we are browsing, if it is an FS (nil = os filesystem)
func (t *Tree) SetFS(v fs.FS) *Tree { t.FS = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/filetree.VCSLog", IDName: "vcs-log", Doc: "VCSLog is a widget that represents VCS log data.", Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Log", Doc: "current log"}, {Name: "File", Doc: "file that this is a log of -- if blank then it is entire repository"}, {Name: "Since", Doc: "date expression for how long ago to include log entries from"}, {Name: "Repo", Doc: "version control system repository"}, {Name: "revisionA", Doc: "revision A -- defaults to HEAD"}, {Name: "revisionB", Doc: "revision B -- blank means current working copy"}, {Name: "setA", Doc: "double-click will set the A revision -- else B"}, {Name: "arev"}, {Name: "brev"}, {Name: "atf"}, {Name: "btf"}}})

// NewVCSLog returns a new [VCSLog] with the given optional parent:
// VCSLog is a widget that represents VCS log data.
func NewVCSLog(parent ...tree.Node) *VCSLog { return tree.New[VCSLog](parent...) }

// SetLog sets the [VCSLog.Log]:
// current log
func (t *VCSLog) SetLog(v vcs.Log) *VCSLog { t.Log = v; return t }

// SetFile sets the [VCSLog.File]:
// file that this is a log of -- if blank then it is entire repository
func (t *VCSLog) SetFile(v string) *VCSLog { t.File = v; return t }

// SetSince sets the [VCSLog.Since]:
// date expression for how long ago to include log entries from
func (t *VCSLog) SetSince(v string) *VCSLog { t.Since = v; return t }

// SetRepo sets the [VCSLog.Repo]:
// version control system repository
func (t *VCSLog) SetRepo(v vcs.Repo) *VCSLog { t.Repo = v; return t }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

import (
        "bytes"
        "fmt"
        "log/slog"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/core"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/text/textcore"
        "cogentcore.org/core/tree"
)

// FirstVCS returns the first VCS repository starting from this node and going down.
// also returns the node having that repository
func (fn *Node) FirstVCS() (vcs.Repo, *Node) {
        if fn.FileRoot().FS != nil {
                return nil, nil
        }
        var repo vcs.Repo
        var rnode *Node
        fn.WidgetWalkDown(func(cw core.Widget, cwb *core.WidgetBase) bool {
                sfn := AsNode(cw)
                if sfn == nil {
                        return tree.Continue
                }
                sfn.detectVCSRepo()
                if sfn.DirRepo != nil {
                        repo = sfn.DirRepo
                        rnode = sfn
                        return tree.Break
                }
                return tree.Continue
        })
        return repo, rnode
}

// detectVCSRepo detects and configures DirRepo if this directory is root of
// a VCS repository. returns true if a repository was newly found here.
func (fn *Node) detectVCSRepo() bool {
        repo, _ := fn.Repo()
        if repo != nil {
                return false
        }
        path := string(fn.Filepath)
        rtyp := vcs.DetectRepo(path)
        if rtyp == vcs.NoVCS {
                return false
        }
        var err error
        repo, err = vcs.NewRepo("origin", path)
        if err != nil {
                slog.Error(err.Error())
                return false
        }
        fn.DirRepo = repo
        return true
}

// Repo returns the version control repository associated with this file,
// and the node for the directory where the repo is based.
// Goes up the tree until a repository is found.
func (fn *Node) Repo() (vcs.Repo, *Node) {
        fr := fn.FileRoot()
        if fr == nil {
                return nil, nil
        }
        if fn.isExternal() || fr == nil || fr.FS != nil {
                return nil, nil
        }
        if fn.DirRepo != nil {
                return fn.DirRepo, fn
        }
        var repo vcs.Repo
        var rnode *Node
        fn.WalkUpParent(func(k tree.Node) bool {
                sfn := AsNode(k)
                if sfn == nil {
                        return tree.Break
                }
                if sfn.IsIrregular() {
                        return tree.Break
                }
                if sfn.DirRepo != nil {
                        repo = sfn.DirRepo
                        rnode = sfn
                        return tree.Break
                }
                return tree.Continue
        })
        return repo, rnode
}

func (fn *Node) updateRepoFiles() {
        if fn.DirRepo == nil {
                return
        }
        fn.DirRepo.Files(func(f vcs.Files) { // need the func to make it work
                fr := fn.FileRoot()
                fr.AsyncLock()
                fn.Update()
                fr.AsyncUnlock()
        })
}

// addToVCSSelected adds selected files to version control system
func (fn *Node) addToVCSSelected() { //types:add
        fn.SelectedFunc(func(sn *Node) {
                sn.AddToVCS()
        })
}

// AddToVCS adds file to version control
func (fn *Node) AddToVCS() {
        repo, _ := fn.Repo()
        if repo == nil {
                return
        }
        err := repo.Add(string(fn.Filepath))
        if errors.Log(err) == nil {
                fn.Info.VCS = vcs.Added
                fn.Update()
        }
}

// deleteFromVCSSelected removes selected files from version control system
func (fn *Node) deleteFromVCSSelected() { //types:add
        fn.SelectedFunc(func(sn *Node) {
                sn.deleteFromVCS()
        })
}

// deleteFromVCS removes file from version control
func (fn *Node) deleteFromVCS() {
        repo, _ := fn.Repo()
        if repo == nil {
                return
        }
        // fmt.Printf("deleting remote from vcs: %v\n", fn.FPath)
        err := repo.DeleteRemote(string(fn.Filepath))
        if fn != nil && errors.Log(err) == nil {
                fn.Info.VCS = vcs.Deleted
                fn.Update()
        }
}

// commitToVCSSelected commits to version control system based on last selected file
func (fn *Node) commitToVCSSelected() { //types:add
        done := false
        fn.SelectedFunc(func(sn *Node) {
                if !done {
                        core.CallFunc(sn, fn.commitToVCS)
                        done = true
                }
        })
}

// commitToVCS commits file changes to version control system
func (fn *Node) commitToVCS(message string) (err error) {
        repo, _ := fn.Repo()
        if repo == nil {
                return
        }
        if fn.Info.VCS == vcs.Untracked {
                return errors.New("file not in vcs repo: " + string(fn.Filepath))
        }
        err = repo.CommitFile(string(fn.Filepath), message)
        if err != nil {
                return err
        }
        fn.Info.VCS = vcs.Stored
        fn.Update()
        return err
}

// revertVCSSelected removes selected files from version control system
func (fn *Node) revertVCSSelected() { //types:add
        fn.SelectedFunc(func(sn *Node) {
                sn.revertVCS()
        })
}

// revertVCS reverts file changes since last commit
func (fn *Node) revertVCS() (err error) {
        repo, _ := fn.Repo()
        if repo == nil {
                return
        }
        if fn.Info.VCS == vcs.Untracked {
                return errors.New("file not in vcs repo: " + string(fn.Filepath))
        }
        err = repo.RevertFile(string(fn.Filepath))
        if err != nil {
                return err
        }
        if fn.Info.VCS == vcs.Modified {
                fn.Info.VCS = vcs.Stored
        } else if fn.Info.VCS == vcs.Added {
                // do nothing - leave in "added" state
        }
        // todo:
        // if fn.Lines != nil {
        //         fn.Lines.Revert()
        // }
        fn.Update()
        return err
}

// diffVCSSelected shows the diffs between two versions of selected files, given by the
// revision specifiers -- if empty, defaults to A = current HEAD, B = current WC file.
// -1, -2 etc also work as universal ways of specifying prior revisions.
// Diffs are shown in a DiffEditorDialog.
func (fn *Node) diffVCSSelected(rev_a string, rev_b string) { //types:add
        fn.SelectedFunc(func(sn *Node) {
                sn.diffVCS(rev_a, rev_b)
        })
}

// diffVCS shows the diffs between two versions of this file, given by the
// revision specifiers -- if empty, defaults to A = current HEAD, B = current WC file.
// -1, -2 etc also work as universal ways of specifying prior revisions.
// Diffs are shown in a DiffEditorDialog.
func (fn *Node) diffVCS(rev_a, rev_b string) error {
        repo, _ := fn.Repo()
        if repo == nil {
                return errors.New("file not in vcs repo: " + string(fn.Filepath))
        }
        if fn.Info.VCS == vcs.Untracked {
                return errors.New("file not in vcs repo: " + string(fn.Filepath))
        }
        // todo:
        _, err := textcore.DiffEditorDialogFromRevs(fn, repo, string(fn.Filepath) /*fn.Lines*/, nil, rev_a, rev_b)
        return err
}

// logVCSSelected shows the VCS log of commits for selected files.
func (fn *Node) logVCSSelected() { //types:add
        fn.SelectedFunc(func(sn *Node) {
                sn.LogVCS(false, "")
        })
}

// LogVCS shows the VCS log of commits for this file, optionally with a
// since date qualifier: If since is non-empty, it should be
// a date-like expression that the VCS will understand, such as
// 1/1/2020, yesterday, last year, etc.  SVN only understands a
// number as a maximum number of items to return.
// If allFiles is true, then the log will show revisions for all files, not just
// this one.
// Returns the Log and also shows it in a VCSLog which supports further actions.
func (fn *Node) LogVCS(allFiles bool, since string) (vcs.Log, error) {
        repo, _ := fn.Repo()
        if repo == nil {
                return nil, errors.New("file not in vcs repo: " + string(fn.Filepath))
        }
        if fn.Info.VCS == vcs.Untracked {
                return nil, errors.New("file not in vcs repo: " + string(fn.Filepath))
        }
        fnm := string(fn.Filepath)
        if allFiles {
                fnm = ""
        }
        lg, err := repo.Log(fnm, since)
        if err != nil {
                return lg, err
        }
        vcsLogDialog(nil, repo, lg, fnm, since)
        return lg, nil
}

// blameVCSSelected shows the VCS blame report for this file, reporting for each line
// the revision and author of the last change.
func (fn *Node) blameVCSSelected() { //types:add
        fn.SelectedFunc(func(sn *Node) {
                sn.blameVCS()
        })
}

// blameDialog opens a dialog for displaying VCS blame data using textview.TwinViews.
// blame is the annotated blame code, while fbytes is the original file contents.
func blameDialog(ctx core.Widget, fname string, blame, fbytes []byte) *textcore.TwinEditors {
        title := "VCS Blame: " + fsx.DirAndFile(fname)

        d := core.NewBody(title)
        tv := textcore.NewTwinEditors(d)
        tv.SetSplits(.3, .7)
        tv.SetFiles(fname, fname)
        flns := bytes.Split(fbytes, []byte("\n"))
        lns := bytes.Split(blame, []byte("\n"))
        nln := min(len(lns), len(flns))
        blns := make([][]byte, nln)
        stidx := 0
        for i := 0; i < nln; i++ {
                fln := flns[i]
                bln := lns[i]
                if stidx == 0 {
                        if len(fln) == 0 {
                                stidx = len(bln)
                        } else {
                                stidx = bytes.LastIndex(bln, fln)
                        }
                }
                blns[i] = bln[:stidx]
        }
        btxt := bytes.Join(blns, []byte("\n")) // makes a copy, so blame is disposable now
        tv.BufferA.SetText(btxt)
        tv.BufferB.SetText(fbytes)
        tv.Update()

        tva, tvb := tv.Editors()
        tva.Styler(func(s *styles.Style) {
                s.Text.WhiteSpace = text.WhiteSpacePre
                s.Min.X.Ch(30)
                s.Min.Y.Em(40)
        })
        tvb.Styler(func(s *styles.Style) {
                s.Text.WhiteSpace = text.WhiteSpacePre
                s.Min.X.Ch(80)
                s.Min.Y.Em(40)
        })
        d.AddOKOnly()
        d.RunWindowDialog(ctx)
        return tv
}

// blameVCS shows the VCS blame report for this file, reporting for each line
// the revision and author of the last change.
func (fn *Node) blameVCS() ([]byte, error) {
        repo, _ := fn.Repo()
        if repo == nil {
                return nil, errors.New("file not in vcs repo: " + string(fn.Filepath))
        }
        if fn.Info.VCS == vcs.Untracked {
                return nil, errors.New("file not in vcs repo: " + string(fn.Filepath))
        }
        fnm := string(fn.Filepath)
        fb, err := lines.FileBytes(fnm)
        if err != nil {
                return nil, err
        }
        blm, err := repo.Blame(fnm)
        if err != nil {
                return blm, err
        }
        blameDialog(nil, fnm, blm, fb)
        return blm, nil
}

// UpdateAllVCS does an update on any repositories below this one in file tree
func (fn *Node) UpdateAllVCS() {
        fn.WidgetWalkDown(func(cw core.Widget, cwb *core.WidgetBase) bool {
                sfn := AsNode(cw)
                if sfn == nil {
                        return tree.Continue
                }
                if !sfn.IsDir() {
                        return tree.Continue
                }
                if sfn.DirRepo == nil {
                        if !sfn.detectVCSRepo() {
                                return tree.Continue
                        }
                }
                repo := sfn.DirRepo
                fmt.Printf("Updating %v repository: %s from: %s\n", repo.Vcs(), sfn.RelativePath(), repo.Remote())
                err := repo.Update()
                if err != nil {
                        fmt.Printf("error: %v\n", err)
                }
                return tree.Break
        })
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package filetree

import (
        "log/slog"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/text/diffbrowser"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/textcore"
        "cogentcore.org/core/tree"
)

// VCSLog is a widget that represents VCS log data.
type VCSLog struct {
        core.Frame

        // current log
        Log vcs.Log

        // file that this is a log of -- if blank then it is entire repository
        File string

        // date expression for how long ago to include log entries from
        Since string

        // version control system repository
        Repo vcs.Repo `json:"-" xml:"-" copier:"-"`

        // revision A -- defaults to HEAD
        revisionA string

        // revision B -- blank means current working copy
        revisionB string

        // double-click will set the A revision -- else B
        setA bool

        arev, brev *core.Switch
        atf, btf   *core.TextField
}

func (lv *VCSLog) Init() {
        lv.Frame.Init()
        lv.revisionA = "HEAD"
        lv.revisionB = ""
        lv.setA = true
        lv.Styler(func(s *styles.Style) {
                s.Direction = styles.Column
                s.Grow.Set(1, 1)
        })
        tree.AddChildAt(lv, "toolbar", func(w *core.Toolbar) {
                w.Maker(lv.makeToolbar)
        })
        tree.AddChildAt(lv, "log", func(w *core.Table) {
                w.SetReadOnly(true)
                w.SetSlice(&lv.Log)
                w.AddContextMenu(func(m *core.Scene) {
                        core.NewButton(m).SetText("Set Revision A").
                                SetTooltip("Set Buffer A's revision to this").
                                OnClick(func(e events.Event) {
                                        cmt := lv.Log[w.SelectedIndex]
                                        lv.setRevisionA(cmt.Rev)
                                })
                        core.NewButton(m).SetText("Set Revision B").
                                SetTooltip("Set Buffer B's revision to this").
                                OnClick(func(e events.Event) {
                                        cmt := lv.Log[w.SelectedIndex]
                                        lv.setRevisionB(cmt.Rev)
                                })
                        core.NewButton(m).SetText("Copy Revision ID").
                                SetTooltip("Copies the revision number / hash for this").
                                OnClick(func(e events.Event) {
                                        cmt := lv.Log[w.SelectedIndex]
                                        w.Clipboard().Write(mimedata.NewText(cmt.Rev))
                                })
                        core.NewButton(m).SetText("View Revision").
                                SetTooltip("Views the file at this revision").
                                OnClick(func(e events.Event) {
                                        cmt := lv.Log[w.SelectedIndex]
                                        fileAtRevisionDialog(lv, lv.Repo, lv.File, cmt.Rev)
                                })
                        core.NewButton(m).SetText("Checkout Revision").
                                SetTooltip("Checks out this revision").
                                OnClick(func(e events.Event) {
                                        cmt := lv.Log[w.SelectedIndex]
                                        errors.Log(lv.Repo.UpdateVersion(cmt.Rev))
                                })
                })
                w.OnSelect(func(e events.Event) {
                        idx := w.SelectedIndex
                        if idx < 0 || idx >= len(lv.Log) {
                                return
                        }
                        cmt := lv.Log[idx]
                        if lv.setA {
                                lv.setRevisionA(cmt.Rev)
                        } else {
                                lv.setRevisionB(cmt.Rev)
                        }
                        lv.toggleRevision()
                })
                w.OnDoubleClick(func(e events.Event) {
                        idx := w.SelectedIndex
                        if idx < 0 || idx >= len(lv.Log) {
                                return
                        }
                        cmt := lv.Log[idx]
                        if lv.File != "" {
                                if lv.setA {
                                        lv.setRevisionA(cmt.Rev)
                                } else {
                                        lv.setRevisionB(cmt.Rev)
                                }
                                lv.toggleRevision()
                        }
                        cinfo, err := lv.Repo.CommitDesc(cmt.Rev, false)
                        if err != nil {
                                slog.Error(err.Error())
                                return
                        }
                        d := core.NewBody("Commit Info: " + cmt.Rev)
                        buf := lines.NewLines()
                        buf.SetFilename(lv.File)
                        buf.Settings.LineNumbers = true
                        buf.Stat()
                        textcore.NewEditor(d).SetLines(buf).Styler(func(s *styles.Style) {
                                s.Grow.Set(1, 1)
                        })
                        buf.SetText(cinfo)
                        d.AddBottomBar(func(bar *core.Frame) {
                                core.NewButton(bar).SetText("Copy to clipboard").SetIcon(icons.ContentCopy).
                                        OnClick(func(e events.Event) {
                                                d.Clipboard().Write(mimedata.NewTextBytes(cinfo))
                                        })
                                d.AddOK(bar)
                        })
                        d.RunFullDialog(lv)
                })
        })
}

// setRevisionA sets the revision to use for buffer A
func (lv *VCSLog) setRevisionA(rev string) {
        lv.revisionA = rev
        lv.atf.Update()
}

// setRevisionB sets the revision to use for buffer B
func (lv *VCSLog) setRevisionB(rev string) {
        lv.revisionB = rev
        lv.btf.Update()
}

// toggleRevision switches the active revision to set
func (lv *VCSLog) toggleRevision() {
        lv.setA = !lv.setA
        lv.arev.UpdateRender()
        lv.brev.UpdateRender()
}

func (lv *VCSLog) makeToolbar(p *tree.Plan) {
        tree.Add(p, func(w *core.Text) {
                w.SetText("File: " + fsx.DirAndFile(lv.File))
        })

        tree.AddAt(p, "a-rev", func(w *core.Switch) {
                lv.arev = w
                core.Bind(&lv.setA, w)
                w.SetText("A Rev: ")
                w.SetTooltip("If selected, clicking in log will set this A Revision to use for Diff")
                w.OnChange(func(e events.Event) {
                        lv.brev.UpdateRender()
                })
        })
        tree.AddAt(p, "a-tf", func(w *core.TextField) {
                lv.atf = w
                core.Bind(&lv.revisionA, w)
                w.SetTooltip("A revision: typically this is the older, base revision to compare")
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("View A").SetIcon(icons.Document).
                        SetTooltip("View file at revision A").
                        OnClick(func(e events.Event) {
                                fileAtRevisionDialog(lv, lv.Repo, lv.File, lv.revisionA)
                        })
        })

        tree.Add(p, func(w *core.Separator) {})

        tree.AddAt(p, "b-rev", func(w *core.Switch) {
                lv.brev = w
                w.SetText("B Rev: ")
                w.SetTooltip("If selected, clicking in log will set this B Revision to use for Diff")
                w.Updater(func() {
                        w.SetChecked(!lv.setA)
                })
                w.OnChange(func(e events.Event) {
                        lv.setA = !w.IsChecked()
                        lv.arev.UpdateRender()
                })
        })

        tree.AddAt(p, "b-tf", func(w *core.TextField) {
                lv.btf = w
                core.Bind(&lv.revisionB, w)
                w.SetTooltip("B revision: typically this is the newer revision to compare.  Leave blank for the current working directory.")
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("View B").SetIcon(icons.Document).
                        SetTooltip("View file at revision B").
                        OnClick(func(e events.Event) {
                                fileAtRevisionDialog(lv, lv.Repo, lv.File, lv.revisionB)
                        })
        })

        tree.Add(p, func(w *core.Separator) {})

        tree.Add(p, func(w *core.Button) {
                w.SetText("Diff").SetIcon(icons.Difference).
                        SetTooltip("Show the diffs between two revisions; if blank, A is current HEAD, and B is current working copy").
                        OnClick(func(e events.Event) {
                                if lv.File == "" {
                                        diffbrowser.NewDiffBrowserVCS(lv.Repo, lv.revisionA, lv.revisionB)
                                } else {
                                        textcore.DiffEditorDialogFromRevs(lv, lv.Repo, lv.File, nil, lv.revisionA, lv.revisionB)
                                }
                        })
        })
}

// vcsLogDialog returns a VCS Log View for given repo, log and file (file could be empty)
func vcsLogDialog(ctx core.Widget, repo vcs.Repo, lg vcs.Log, file, since string) *core.Body {
        title := "VCS Log: "
        if file == "" {
                title += "All files"
        } else {
                title += fsx.DirAndFile(file)
        }
        if since != "" {
                title += " since: " + since
        }
        d := core.NewBody(title)
        lv := NewVCSLog(d)
        lv.SetRepo(repo).SetLog(lg).SetFile(file).SetSince(since)
        d.RunWindowDialog(ctx)
        return d
}

// fileAtRevisionDialog shows a file at a given revision in a new dialog window
func fileAtRevisionDialog(ctx core.Widget, repo vcs.Repo, file, rev string) *core.Body {
        fb, err := repo.FileContents(file, rev)
        if err != nil {
                core.ErrorDialog(ctx, err)
                return nil
        }
        if rev == "" {
                rev = "HEAD"
        }
        title := "File at VCS Revision: " + fsx.DirAndFile(file) + "@" + rev
        d := core.NewBody(title)

        tb := lines.NewLines().SetText(fb).SetFilename(file) // file is key for getting lang
        textcore.NewEditor(d).SetLines(tb).SetReadOnly(true).Styler(func(s *styles.Style) {
                s.Grow.Set(1, 1)
        })
        d.RunWindowDialog(ctx)
        tb.ReMarkup() // update markup
        return d
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmlcore

import (
        "io"
        "net/http"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/system"
        "cogentcore.org/core/tree"
        "github.com/aymerick/douceur/css"
        "github.com/aymerick/douceur/parser"
        selcss "github.com/ericchiang/css"
        "github.com/gomarkdown/markdown/ast"
        "golang.org/x/net/html"
)

// Context contains context information about the current state of a htmlcore
// reader and its surrounding context. It should be created with [NewContext].
type Context struct {

        // Node is the node that is currently being read.
        Node *html.Node

        // styles are the CSS styling rules for each node.
        styles map[*html.Node][]*css.Rule

        // NewParent is the current parent widget that children of
        // the previously read element should be added to, if any.
        NewParent core.Widget

        // BlockParent is the current parent widget that non-inline elements
        // should be added to.
        BlockParent core.Widget

        // TableParent is the current table being generated.
        TableParent *core.Frame

        firstRow bool

        // inlineParent is the current parent widget that inline
        // elements should be added to; it must be got through
        // [Context.InlineParent], as it may need to be constructed
        // on the fly. However, it can be set directly.
        inlineParent core.Widget

        // PageURL, if not "", is the URL of the current page.
        // Otherwise, there is no current page.
        PageURL string

        // OpenURL is the function used to open URLs,
        // which defaults to [system.App.OpenURL].
        OpenURL func(url string)

        // GetURL is the function used to get resources from URLs,
        // which defaults to [http.Get].
        GetURL func(url string) (*http.Response, error)

        // ElementHandlers is a map of handler functions for each HTML element
        // type (eg: "button", "input", "p"). It is empty by default, but can be
        // used by anyone in need of behavior different than the default behavior
        // defined in [handleElement] (for example, for custom elements).
        // If the handler for an element returns false, then the default behavior
        // for an element is used.
        ElementHandlers map[string]func(ctx *Context) bool

        // WikilinkHandlers is a list of handlers to use for wikilinks.
        // If one returns "", "", the next ones will be tried instead.
        // The functions are tried in sequential ascending order.
        // See [Context.AddWikilinkHandler] to add a new handler.
        WikilinkHandlers []WikilinkHandler

        // AttributeHandlers is a map of markdown render handler functions
        // for custom attribute values that are specified in {tag: value}
        // attributes prior to markdown elements in the markdown source.
        // The map key is the tag in the attribute, which is then passed
        // to the function, along with the markdown node being rendered.
        // Alternative or additional HTML output can be written to the given writer.
        // If the handler function returns true, then the default HTML code
        // will not be generated.
        AttributeHandlers map[string]func(ctx *Context, w io.Writer, node ast.Node, entering bool, tag, value string) bool
}

// NewContext returns a new [Context] with basic defaults.
func NewContext() *Context {
        return &Context{
                styles:            map[*html.Node][]*css.Rule{},
                OpenURL:           system.TheApp.OpenURL,
                GetURL:            http.Get,
                ElementHandlers:   map[string]func(ctx *Context) bool{},
                AttributeHandlers: map[string]func(ctx *Context, w io.Writer, node ast.Node, entering bool, tag, value string) bool{},
        }
}

// Parent returns the current parent widget that a widget
// associated with the current node should be added to.
// It may make changes to the widget tree, so the widget
// must be added to the resulting parent immediately.
func (c *Context) Parent() core.Widget {
        rules := c.styles[c.Node]
        display := ""
        for _, rule := range rules {
                for _, decl := range rule.Declarations {
                        if decl.Property == "display" {
                                display = decl.Value
                        }
                }
        }
        var parent core.Widget
        switch display {
        case "inline", "inline-block", "":
                parent = c.InlineParent()
        default:
                parent = c.BlockParent
                c.inlineParent = nil
        }
        return parent
}

// config configures the given widget. It needs to be called
// on all widgets that are not configured through the [New]
// pathway.
func (c *Context) config(w core.Widget) {
        wb := w.AsWidget()
        for _, attr := range c.Node.Attr {
                switch attr.Key {
                case "id":
                        wb.SetName(attr.Val)
                case "style":
                        // our CSS parser is strict about semicolons, but
                        // they aren't needed in normal inline styles in HTML
                        if !strings.HasSuffix(attr.Val, ";") {
                                attr.Val += ";"
                        }
                        decls, err := parser.ParseDeclarations(attr.Val)
                        if errors.Log(err) != nil {
                                continue
                        }
                        rule := &css.Rule{Declarations: decls}
                        if c.styles == nil {
                                c.styles = map[*html.Node][]*css.Rule{}
                        }
                        c.styles[c.Node] = append(c.styles[c.Node], rule)
                default:
                        wb.SetProperty(attr.Key, attr.Val)
                }
        }
        wb.SetProperty("tag", c.Node.Data)
        rules := c.styles[c.Node]
        wb.Styler(func(s *styles.Style) {
                for _, rule := range rules {
                        for _, decl := range rule.Declarations {
                                // TODO(kai/styproperties): parent style and context
                                s.FromProperty(s, decl.Property, decl.Value, colors.BaseContext(colors.ToUniform(s.Color)))
                        }
                }
        })
}

// InlineParent returns the current parent widget that inline
// elements should be added to.
func (c *Context) InlineParent() core.Widget {
        if c.inlineParent != nil {
                return c.inlineParent
        }
        c.inlineParent = core.NewFrame(c.BlockParent)
        c.inlineParent.AsTree().SetName("inline-container")
        tree.SetUniqueName(c.inlineParent)
        c.inlineParent.AsWidget().Styler(func(s *styles.Style) {
                s.Grow.Set(1, 0)
        })
        return c.inlineParent
}

// addStyle adds the given CSS style string to the page's compiled styles.
func (c *Context) addStyle(style string) {
        ss, err := parser.Parse(style)
        if errors.Log(err) != nil {
                return
        }

        root := rootNode(c.Node)

        for _, rule := range ss.Rules {
                var sel *selcss.Selector
                if len(rule.Selectors) > 0 {
                        s, err := selcss.Parse(strings.Join(rule.Selectors, ","))
                        if errors.Log(err) != nil {
                                s = &selcss.Selector{}
                        }
                        sel = s
                } else {
                        sel = &selcss.Selector{}
                }

                matches := sel.Select(root)
                for _, match := range matches {
                        c.styles[match] = append(c.styles[match], rule)
                }
        }
}

// LinkButton is a helper function that makes the given button
// open the given link when clicked on, using [Context.OpenURL].
// The advantage of using this is that it does [tree.NodeBase.SetProperty]
// of "href" to the given url, allowing generatehtml to create an <a> element
// for HTML preview and SEO purposes.
//
// See also [Context.LinkButtonUpdating] for a dynamic version.
func (c *Context) LinkButton(bt *core.Button, url string) *core.Button {
        bt.SetProperty("tag", "a")
        bt.SetProperty("href", url)
        bt.OnClick(func(e events.Event) {
                c.OpenURL(url)
        })
        return bt
}

// LinkButtonUpdating is a version of [Context.LinkButton] that is robust to a changing/dynamic
// URL, using an Updater and a URL function instead of a variable.
func (c *Context) LinkButtonUpdating(bt *core.Button, url func() string) *core.Button {
        bt.SetProperty("tag", "a")
        bt.Updater(func() {
                bt.SetProperty("href", url())
        })
        bt.OnClick(func(e events.Event) {
                c.OpenURL(url())
        })
        return bt
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        _ "embed"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/htmlcore"
)

//go:embed example.html
var content string

func main() {
        b := core.NewBody("HTML Example")
        errors.Log(htmlcore.ReadHTMLString(htmlcore.NewContext(), b, content))
        b.RunMainWindow()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        _ "embed"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/htmlcore"
        _ "cogentcore.org/core/text/tex" // include this to get math
)

//go:embed example.md
var content string

func main() {
        b := core.NewBody("MD Example")
        errors.Log(htmlcore.ReadMDString(htmlcore.NewContext(), b, content))
        b.RunMainWindow()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmlcore

import (
        "fmt"
        "io"
        "log/slog"
        "net/http"
        "slices"
        "strconv"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/text/textcore"
        "cogentcore.org/core/tree"
        "golang.org/x/net/html"
)

// New adds a new widget of the given type to the context parent.
// It automatically calls [Context.config] on the resulting widget.
func New[T tree.NodeValue](ctx *Context) *T {
        parent := ctx.Parent()
        w := tree.New[T](parent)
        ctx.config(any(w).(core.Widget)) // TODO: better htmlcore structure with new config paradigm?
        return w
}

// handleElement calls the handler in [Context.ElementHandlers] associated with the current node
// using the given context. If there is no handler associated with it, it uses default
// hardcoded configuration code.
func handleElement(ctx *Context) {
        tag := ctx.Node.Data
        h, ok := ctx.ElementHandlers[tag]
        if ok {
                if h(ctx) {
                        return
                }
        }

        if slices.Contains(textTags, tag) {
                handleTextTag(ctx)
                return
        }

        switch tag {
        case "script", "title", "meta":
                // we don't render anything
        case "link":
                rel := GetAttr(ctx.Node, "rel")
                // TODO(kai/htmlcore): maybe handle preload
                if rel == "preload" {
                        return
                }
                // TODO(kai/htmlcore): support links other than stylesheets
                if rel != "stylesheet" {
                        return
                }
                resp, err := Get(ctx, GetAttr(ctx.Node, "href"))
                if errors.Log(err) != nil {
                        return
                }
                defer resp.Body.Close()
                b, err := io.ReadAll(resp.Body)
                if errors.Log(err) != nil {
                        return
                }
                ctx.addStyle(string(b))
        case "style":
                ctx.addStyle(ExtractText(ctx))
        case "body", "main", "div", "section", "nav", "footer", "header", "ol", "ul", "blockquote":
                w := New[core.Frame](ctx)
                ctx.NewParent = w
                switch tag {
                case "body":
                        w.Styler(func(s *styles.Style) {
                                s.Grow.Set(1, 1)
                        })
                case "ol", "ul":
                        w.Styler(func(s *styles.Style) {
                                s.Grow.Set(1, 0)
                        })
                case "div":
                        w.Styler(func(s *styles.Style) {
                                s.Grow.Set(1, 1)
                                s.Overflow.Y = styles.OverflowAuto
                        })
                case "blockquote":
                        w.Styler(func(s *styles.Style) { // todo: need a better marker
                                s.Grow.Set(1, 0)
                                s.Background = colors.Scheme.SurfaceContainer
                        })
                }
        case "button":
                New[core.Button](ctx).SetText(ExtractText(ctx))
        case "h1":
                handleText(ctx).SetType(core.TextDisplaySmall)
        case "h2":
                handleText(ctx).SetType(core.TextHeadlineMedium)
        case "h3":
                handleText(ctx).SetType(core.TextTitleLarge)
        case "h4":
                handleText(ctx).SetType(core.TextTitleMedium)
        case "h5":
                handleText(ctx).SetType(core.TextTitleSmall)
        case "h6":
                handleText(ctx).SetType(core.TextLabelSmall)
        case "p":
                handleText(ctx)
        case "pre":
                hasCode := ctx.Node.FirstChild != nil && ctx.Node.FirstChild.Data == "code"
                if hasCode {
                        codeEl := ctx.Node.FirstChild
                        collapsed := GetAttr(codeEl, "collapsed")
                        lang := getLanguage(GetAttr(codeEl, "class"))
                        id := GetAttr(codeEl, "id")
                        var ed *textcore.Editor
                        var parent tree.Node
                        if collapsed != "" {
                                cl := New[core.Collapser](ctx)
                                summary := core.NewText(cl.Summary).SetText("Code")
                                if title := GetAttr(codeEl, "title"); title != "" {
                                        summary.SetText(title)
                                }
                                ed = textcore.NewEditor(cl.Details)
                                if id != "" {
                                        cl.Summary.Name = id
                                }
                                parent = cl.Parent
                                if collapsed == "false" || collapsed == "-" {
                                        cl.Open = true
                                }
                        } else {
                                ed = New[textcore.Editor](ctx)
                                if id != "" {
                                        ed.SetName(id)
                                }
                                parent = ed.Parent
                        }
                        ctx.Node = codeEl
                        if lang != "" {
                                ed.Lines.SetFileExt(lang)
                        }
                        ed.Lines.SetString(ExtractText(ctx))
                        if BindTextEditor != nil && (lang == "Go" || lang == "Goal") {
                                ed.Lines.SpacesToTabs(0, ed.Lines.NumLines()) // Go uses tabs
                                parFrame := core.NewFrame(parent)
                                parFrame.Styler(func(s *styles.Style) {
                                        s.Direction = styles.Column
                                        s.Grow.Set(1, 0)
                                })
                                // we inherit our Grow.Y from our first child so that
                                // elements that want to grow can do so
                                parFrame.SetOnChildAdded(func(n tree.Node) {
                                        if _, ok := n.(*core.Body); ok { // Body should not grow
                                                return
                                        }
                                        wb := core.AsWidget(n)
                                        if wb.IndexInParent() != 0 {
                                                return
                                        }
                                        wb.FinalStyler(func(s *styles.Style) {
                                                parFrame.Styles.Grow.Y = s.Grow.Y
                                        })
                                })
                                BindTextEditor(ed, parFrame, lang)
                        } else {
                                ed.SetReadOnly(true)
                                ed.Lines.Settings.LineNumbers = false
                                ed.Styler(func(s *styles.Style) {
                                        s.Border.Width.Zero()
                                        s.MaxBorder.Width.Zero()
                                        s.StateLayer = 0
                                        s.Background = colors.Scheme.SurfaceContainer
                                })
                        }
                } else {
                        handleText(ctx).Styler(func(s *styles.Style) {
                                s.Text.WhiteSpace = text.WhiteSpacePreWrap
                        })
                }
        case "li":
                // if we have a p as our first or second child, which is typical
                // for markdown-generated HTML, we use it directly for data extraction
                // to prevent double elements and unnecessary line breaks.
                hasPChild := false
                if ctx.Node.FirstChild != nil && ctx.Node.FirstChild.Data == "p" {
                        ctx.Node = ctx.Node.FirstChild
                        hasPChild = true
                } else if ctx.Node.FirstChild != nil && ctx.Node.FirstChild.NextSibling != nil && ctx.Node.FirstChild.NextSibling.Data == "p" {
                        ctx.Node = ctx.Node.FirstChild.NextSibling
                }

                text := handleText(ctx)
                start := ""
                if pw, ok := text.Parent.(core.Widget); ok {
                        switch pw.AsTree().Property("tag") {
                        case "ol":
                                number := 0
                                for _, k := range pw.AsTree().Children {
                                        // we only consider text for the number (frames may be
                                        // added for nested lists, interfering with the number)
                                        if _, ok := k.(*core.Text); ok {
                                                number++
                                        }
                                }
                                start = strconv.Itoa(number) + ". "
                        case "ul":
                                // TODO(kai/htmlcore): have different bullets for different depths
                                start = "• "
                        }
                }
                text.SetText(start + text.Text)
                if hasPChild { // handle potential additional <p> blocks that should be indented
                        cnode := ctx.Node
                        ctx.BlockParent = text.Parent.(core.Widget)
                        for cnode.NextSibling != nil {
                                cnode = cnode.NextSibling
                                ctx.Node = cnode
                                if cnode.Data != "p" {
                                        continue
                                }
                                txt := handleText(ctx)
                                txt.SetText("&nbsp;&nbsp; " + txt.Text)
                        }
                }
        case "img":
                n := ctx.Node
                src := GetAttr(n, "src")
                alt := GetAttr(n, "alt")
                pid := ""
                if ctx.BlockParent != nil {
                        pid = GetAttr(n.Parent, "id")
                }
                // Can be either image or svg.
                var img *core.Image
                var svg *core.SVG
                if strings.HasSuffix(src, ".svg") {
                        svg = New[core.SVG](ctx)
                        svg.SetTooltip(alt)
                        if pid != "" {
                                svg.SetName(pid)
                        }
                } else {
                        img = New[core.Image](ctx)
                        img.SetTooltip(alt)
                        if pid != "" {
                                img.SetName(pid)
                        }
                }

                go func() {
                        resp, err := Get(ctx, src)
                        if errors.Log(err) != nil {
                                return
                        }
                        defer resp.Body.Close()
                        if svg != nil {
                                svg.AsyncLock()
                                svg.Read(resp.Body)
                                svg.Update()
                                svg.AsyncUnlock()
                        } else {
                                im, _, err := imagex.Read(resp.Body)
                                if err != nil {
                                        slog.Error("error loading image", "url", src, "err", err)
                                        return
                                }
                                img.AsyncLock()
                                img.SetImage(im)
                                img.Update()
                                img.AsyncUnlock()
                        }
                }()
        case "input":
                ityp := GetAttr(ctx.Node, "type")
                val := GetAttr(ctx.Node, "value")
                switch ityp {
                case "number":
                        fval := float32(errors.Log1(strconv.ParseFloat(val, 32)))
                        New[core.Spinner](ctx).SetValue(fval)
                case "checkbox":
                        New[core.Switch](ctx).SetType(core.SwitchCheckbox).
                                SetState(HasAttr(ctx.Node, "checked"), states.Checked)
                case "radio":
                        New[core.Switch](ctx).SetType(core.SwitchRadioButton).
                                SetState(HasAttr(ctx.Node, "checked"), states.Checked)
                case "range":
                        fval := float32(errors.Log1(strconv.ParseFloat(val, 32)))
                        New[core.Slider](ctx).SetValue(fval)
                case "button", "submit":
                        New[core.Button](ctx).SetText(val)
                case "color":
                        core.Bind(val, New[core.ColorButton](ctx))
                case "datetime":
                        core.Bind(val, New[core.TimeInput](ctx))
                case "file":
                        core.Bind(val, New[core.FileButton](ctx))
                default:
                        New[core.TextField](ctx).SetText(val)
                }
        case "textarea":
                buf := lines.NewLines()
                buf.SetText([]byte(ExtractText(ctx)))
                New[textcore.Editor](ctx).SetLines(buf)
        case "table":
                w := New[core.Frame](ctx)
                ctx.NewParent = w
                ctx.TableParent = w
                ctx.firstRow = true
                w.SetProperty("cols", 0)
                w.Styler(func(s *styles.Style) {
                        s.Display = styles.Grid
                        s.Grow.Set(1, 1)
                        s.Columns = w.Property("cols").(int)
                        s.Gap.X.Dp(core.ConstantSpacing(6))
                        s.Justify.Content = styles.Center
                })
        case "th", "td":
                if ctx.TableParent != nil && ctx.firstRow {
                        cols := ctx.TableParent.Property("cols").(int)
                        cols++
                        ctx.TableParent.SetProperty("cols", cols)
                }
                tx := handleText(ctx)
                if tag == "th" {
                        tx.Styler(func(s *styles.Style) {
                                s.Font.Weight = rich.Bold
                                s.Border.Width.Bottom.Dp(2)
                                s.Margin.Bottom.Dp(6)
                                s.Margin.Top.Dp(6)
                        })
                } else {
                        tx.Styler(func(s *styles.Style) {
                                s.Margin.Bottom.Dp(6)
                                s.Margin.Top.Dp(6)
                        })
                }
        case "thead", "tbody":
                ctx.NewParent = ctx.TableParent
        case "tr":
                if ctx.TableParent != nil && ctx.firstRow && ctx.TableParent.NumChildren() > 0 {
                        ctx.firstRow = false
                }
                ctx.NewParent = ctx.TableParent
        default:
                ctx.NewParent = ctx.Parent()
        }
}

func (ctx *Context) textStyler(s *styles.Style) {
        s.Margin.SetVertical(units.Em(core.ConstantSpacing(0.25)))
        s.Font.Size.Value *= core.AppearanceSettings.DocsFontSize / 100
        // TODO: it would be ideal for htmlcore to automatically save a scale factor
        // in general and for each domain, that is applied only to page content
        // scale := float32(1.2)
        // s.Font.Size.Value *= scale
        // s.Text.LineHeight.Value *= scale
        // s.Text.LetterSpacing.Value *= scale
}

// handleText creates a new [core.Text] from the given information, setting the text and
// the text click function so that URLs are opened according to [Context.OpenURL].
func handleText(ctx *Context) *core.Text {
        et := ExtractText(ctx)
        if et == "" {
                // Empty text elements do not render, so we just return a fake one (to avoid panics).
                return core.NewText()
        }
        tx := New[core.Text](ctx).SetText(et)
        tx.Styler(ctx.textStyler)
        tx.HandleTextClick(func(tl *rich.Hyperlink) {
                ctx.OpenURL(tl.URL)
        })
        return tx
}

// handleTextTag creates a new [core.Text] from the given information, setting the text and
// the text click function so that URLs are opened according to [Context.OpenURL]. Also,
// it wraps the text with the [nodeString] of the given node, meaning that it
// should be used for standalone elements that are meant to only exist in text
// (eg: a, span, b, code, etc).
func handleTextTag(ctx *Context) *core.Text {
        start, end := nodeString(ctx.Node)
        str := start + ExtractText(ctx) + end
        tx := New[core.Text](ctx).SetText(str)
        tx.Styler(ctx.textStyler)
        tx.HandleTextClick(func(tl *rich.Hyperlink) {
                ctx.OpenURL(tl.URL)
        })
        return tx
}

// GetAttr gets the given attribute from the given node, returning ""
// if the attribute is not found.
func GetAttr(n *html.Node, attr string) string {
        res := ""
        for _, a := range n.Attr {
                if a.Key == attr {
                        res = a.Val
                }
        }
        return res
}

// HasAttr returns whether the given node has the given attribute defined.
func HasAttr(n *html.Node, attr string) bool {
        return slices.ContainsFunc(n.Attr, func(a html.Attribute) bool {
                return a.Key == attr
        })
}

// getLanguage returns the 'x' in a `language-x` class from the given
// string of class(es).
func getLanguage(class string) string {
        fields := strings.Fields(class)
        for _, field := range fields {
                if strings.HasPrefix(field, "language-") {
                        return strings.TrimPrefix(field, "language-")
                }
        }
        return ""
}

// Get is a helper function that calls [Context.GetURL] with the given URL, parsed
// relative to the page URL of the given context. It also checks the status
// code of the response and closes the response body and returns an error if
// it is not [http.StatusOK]. If the error is nil, then the response body is
// not closed and must be closed by the caller.
func Get(ctx *Context, url string) (*http.Response, error) {
        u, err := parseRelativeURL(url, ctx.PageURL)
        if err != nil {
                return nil, err
        }
        resp, err := ctx.GetURL(u.String())
        if err != nil {
                return nil, err
        }
        if resp.StatusCode != http.StatusOK {
                resp.Body.Close()
                return resp, fmt.Errorf("got error status %q (code %d)", resp.Status, resp.StatusCode)
        }
        return resp, nil
}

// BindTextEditor is a function set to [cogentcore.org/core/yaegicore.BindTextEditor]
// when importing yaegicore, which provides interactive editing functionality for Go
// code blocks in text editors.
var BindTextEditor func(ed *textcore.Editor, parent *core.Frame, language string)

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package htmlcore converts HTML and MD into Cogent Core widget trees.
package htmlcore

import (
        "bytes"
        "fmt"
        "io"
        "strings"

        "cogentcore.org/core/core"
        "golang.org/x/net/html"
)

// ReadHTML reads HTML from the given [io.Reader] and adds corresponding
// Cogent Core widgets to the given [core.Widget], using the given context.
func ReadHTML(ctx *Context, parent core.Widget, r io.Reader) error {
        n, err := html.Parse(r)
        if err != nil {
                return fmt.Errorf("error parsing HTML: %w", err)
        }
        return readHTMLNode(ctx, parent, n)
}

// ReadHTMLString reads HTML from the given string and adds corresponding
// Cogent Core widgets to the given [core.Widget], using the given context.
func ReadHTMLString(ctx *Context, parent core.Widget, s string) error {
        b := bytes.NewBufferString(s)
        return ReadHTML(ctx, parent, b)
}

// readHTMLNode reads HTML from the given [*html.Node] and adds corresponding
// Cogent Core widgets to the given [core.Widget], using the given context.
func readHTMLNode(ctx *Context, parent core.Widget, n *html.Node) error {
        // nil parent means we are root, so we add user agent styles here
        if n.Parent == nil {
                ctx.Node = n
                ctx.addStyle(userAgentStyles)
        }

        switch n.Type {
        case html.TextNode:
                str := strings.TrimSpace(n.Data)
                if str != "" {
                        New[core.Text](ctx).SetText(str)
                }
        case html.ElementNode:
                ctx.Node = n
                ctx.BlockParent = parent
                ctx.NewParent = nil

                handleElement(ctx)
        default:
                ctx.NewParent = parent
        }

        if ctx.NewParent != nil && n.FirstChild != nil {
                readHTMLNode(ctx, ctx.NewParent, n.FirstChild)
        }

        if n.NextSibling != nil {
                readHTMLNode(ctx, parent, n.NextSibling)
        }
        return nil
}

// rootNode returns the root node of the given node.
func rootNode(n *html.Node) *html.Node {
        for n.Parent != nil {
                n = n.Parent
        }
        return n
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmlcore

import (
        "bytes"
        "io"
        "regexp"

        "cogentcore.org/core/core"
        "github.com/gomarkdown/markdown"
        "github.com/gomarkdown/markdown/ast"
        "github.com/gomarkdown/markdown/html"
        "github.com/gomarkdown/markdown/parser"
)

var divRegex = regexp.MustCompile("<p(.*?)><div></p>")

func mdToHTML(ctx *Context, md []byte) []byte {
        // create markdown parser with extensions
        extensions := parser.CommonExtensions | parser.AutoHeadingIDs | parser.NoEmptyLineBeforeBlock | parser.Attributes | parser.Mmark
        p := parser.NewWithExtensions(extensions)
        prev := p.RegisterInline('[', nil)
        p.RegisterInline('[', wikilink(ctx, prev))
        // this allows div to work properly:
        // https://github.com/gomarkdown/markdown/issues/5
        md = bytes.ReplaceAll(md, []byte("</div>"), []byte("</div><!-- dummy -->"))
        doc := p.Parse(md)

        // create HTML renderer with extensions
        htmlFlags := html.CommonFlags | html.HrefTargetBlank
        opts := html.RendererOptions{Flags: htmlFlags, RenderNodeHook: ctx.mdRenderHook}
        renderer := html.NewRenderer(opts)

        htm := markdown.Render(doc, renderer)
        htm = bytes.ReplaceAll(htm, []byte("<p></div><!-- dummy --></p>"), []byte("</div>"))
        htm = divRegex.ReplaceAll(htm, []byte("<div${1}>"))
        return htm
}

// ReadMD reads MD (markdown) from the given bytes and adds corresponding
// Cogent Core widgets to the given [core.Widget], using the given context.
func ReadMD(ctx *Context, parent core.Widget, b []byte) error {
        htm := mdToHTML(ctx, b)
        // os.WriteFile("htmlcore_tmp.html", htm, 0666) // note: keep here, needed for debugging
        buf := bytes.NewBuffer(htm)
        return ReadHTML(ctx, parent, buf)
}

// ReadMDString reads MD (markdown) from the given string and adds
// corresponding Cogent Core widgets to the given [core.Widget], using the given context.
func ReadMDString(ctx *Context, parent core.Widget, s string) error {
        return ReadMD(ctx, parent, []byte(s))
}

func (ctx *Context) attrRenderHooks(attr *ast.Attribute, w io.Writer, node ast.Node, entering bool) (ast.WalkStatus, bool) {
        for tag, val := range attr.Attrs {
                f, has := ctx.AttributeHandlers[tag]
                if has {
                        b := f(ctx, w, node, entering, tag, string(val))
                        return ast.GoToNext, b
                }
        }
        return ast.GoToNext, false
}

func (ctx *Context) mdRenderHook(w io.Writer, node ast.Node, entering bool) (ast.WalkStatus, bool) {
        cont := node.AsContainer()
        if cont != nil && cont.Attribute != nil {
                return ctx.attrRenderHooks(cont.Attribute, w, node, entering)
        }
        leaf := node.AsLeaf()
        if leaf != nil && leaf.Attribute != nil {
                return ctx.attrRenderHooks(leaf.Attribute, w, node, entering)
        }
        return ast.GoToNext, false
}

// MDGetAttr gets the given attribute from the given markdown node, returning ""
// if the attribute is not found.
func MDGetAttr(n ast.Node, attr string) string {
        res := ""
        cont := n.AsContainer()
        leaf := n.AsLeaf()
        if cont != nil {
                if cont.Attribute != nil {
                        res = string(cont.Attribute.Attrs[attr])
                }
        } else if leaf != nil {
                if leaf.Attribute != nil {
                        res = string(leaf.Attribute.Attrs[attr])
                }
        }
        return res
}

// MDSetAttr sets the given attribute on the given markdown node
func MDSetAttr(n ast.Node, attr, value string) {
        var attrs *ast.Attribute
        cont := n.AsContainer()
        leaf := n.AsLeaf()
        if cont != nil {
                attrs = cont.Attribute
        } else if leaf != nil {
                attrs = leaf.Attribute
        }
        if attrs == nil {
                attrs = &ast.Attribute{}
        }
        if attrs.Attrs == nil {
                attrs.Attrs = make(map[string][]byte)
        }
        attrs.Attrs[attr] = []byte(value)
        if cont != nil {
                cont.Attribute = attrs
        } else if leaf != nil {
                leaf.Attribute = attrs
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmlcore

import (
        "slices"

        "golang.org/x/net/html"
)

// ExtractText recursively extracts all of the text from the children
// of the given [*html.Node], adding any appropriate inline markup for
// formatted text. It adds any non-text elements to the given [core.Widget]
// using [readHTMLNode]. It should not be called on text nodes themselves;
// for that, you can directly access the [html.Node.Data] field. It uses
// the given page URL for context when resolving URLs, but it can be
// omitted if not available.
func ExtractText(ctx *Context) string {
        if ctx.Node.FirstChild == nil {
                return ""
        }
        return extractText(ctx, ctx.Node.FirstChild)
}

func extractText(ctx *Context, n *html.Node) string {
        str := ""
        if n.Type == html.TextNode {
                str += n.Data
        }
        it := isText(n)
        if !it {
                readHTMLNode(ctx, ctx.Parent(), n)
                // readHTMLNode already handles children and siblings, so we return.
                // TODO: for something like [TestButtonInHeadingBug] this will not
                // have the right behavior, but that is a rare use case and this
                // heuristic is much simpler.
                return str
        }
        if n.FirstChild != nil {
                start, end := nodeString(n)
                str = start + extractText(ctx, n.FirstChild) + end
        }
        if n.NextSibling != nil {
                str += extractText(ctx, n.NextSibling)
        }
        return str
}

// nodeString returns the given node as starting and ending strings in the format:
//
//        <tag attr0="value0" attr1="value1">
//
// and
//
//        </tag>
//
// It returns "", "" if the given node is not an [html.ElementNode]
func nodeString(n *html.Node) (start, end string) {
        if n.Type != html.ElementNode {
                return
        }
        tag := n.Data
        start = "<" + tag
        for _, a := range n.Attr {
                start += " " + a.Key + "=" + `"` + a.Val + `"`
        }
        start += ">"
        end = "</" + tag + ">"
        return
}

// textTags are all of the node tags that result in a true return value for [isText].
var textTags = []string{
        "a", "abbr", "b", "bdi", "bdo", "br", "cite", "code", "data", "dfn",
        "em", "i", "kbd", "mark", "q", "rp", "rt", "ruby", "s", "samp", "small",
        "span", "strong", "sub", "sup", "time", "u", "var", "wbr",
}

// isText returns true if the given node is a [html.TextNode] or
// an [html.ElementNode] designed for holding text (a, span, b, code, etc),
// and false otherwise.
func isText(n *html.Node) bool {
        if n.Type == html.TextNode {
                return true
        }
        if n.Type == html.ElementNode {
                tag := n.Data
                return slices.Contains(textTags, tag)
        }
        return false
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmlcore

import (
        "io/fs"
        "net/http"
        "net/url"
        "strings"
)

// parseRelativeURL parses the given raw URL relative to the given base URL.
func parseRelativeURL(rawURL, base string) (*url.URL, error) {
        u, err := url.Parse(rawURL)
        if err != nil {
                return u, err
        }
        b, err := url.Parse(base)
        if err != nil {
                return u, err
        }
        return b.ResolveReference(u), nil
}

// GetURLFromFS can be used for [Context.GetURL] to get
// resources from the given file system.
func GetURLFromFS(fsys fs.FS, rawURL string) (*http.Response, error) {
        u, err := url.Parse(rawURL)
        if err != nil {
                return nil, err
        }
        if u.Scheme != "" {
                return http.Get(rawURL)
        }
        rawURL = strings.TrimPrefix(rawURL, "/")
        rawURL, _, _ = strings.Cut(rawURL, "?")
        f, err := fsys.Open(rawURL)
        if err != nil {
                return nil, err
        }
        return &http.Response{
                Status:        http.StatusText(http.StatusOK),
                StatusCode:    http.StatusOK,
                Body:          f,
                ContentLength: -1,
        }, nil
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmlcore

import (
        "log/slog"
        "strings"
        "unicode"

        "github.com/gomarkdown/markdown/ast"
        "github.com/gomarkdown/markdown/parser"
)

// WikilinkHandler is a function that converts wikilink text to
// a corresponding URL and label text. If it returns "", "", the
// handler will be skipped in favor of the next possible handlers.
// Wikilinks are of the form [[wikilink text]]. Only the text inside
// of the brackets is passed to the handler. If there is additional
// text directly after the closing brackets without spaces or punctuation,
// it will be appended to the label text after the handler is run
// (ex: [[widget]]s).
type WikilinkHandler func(text string) (url string, label string)

// AddWikilinkHandler adds a new [WikilinkHandler] to [Context.WikilinkHandlers].
// If it returns "", "", the next handlers will be tried instead.
// The functions are tried in sequential ascending order.
func (c *Context) AddWikilinkHandler(h WikilinkHandler) {
        c.WikilinkHandlers = append(c.WikilinkHandlers, h)
}

// GoDocWikilink returns a [WikilinkHandler] that converts wikilinks of the form
// [[prefix:identifier]] to a pkg.go.dev URL starting at pkg. For example, with
// prefix="doc" and pkg="cogentcore.org/core", the wikilink [[doc:core.Button]] will
// result in the URL "https://pkg.go.dev/cogentcore.org/core/core#Button".
func GoDocWikilink(prefix string, pkg string) WikilinkHandler {
        return func(text string) (url string, label string) {
                if !strings.HasPrefix(text, prefix+":") {
                        return "", ""
                }
                text = strings.TrimPrefix(text, prefix+":")
                // pkg.go.dev uses fragments for first dot within package
                t := strings.Replace(text, ".", "#", 1)
                url = "https://pkg.go.dev/" + pkg + "/" + t
                return url, text
        }
}

// note: this is from: https://github.com/kensanata/oddmu/blob/main/parser.go

// wikilink returns an inline parser function. This indirection is
// required because we want to call the previous definition in case
// this is not a wikilink.
func wikilink(ctx *Context, fn func(p *parser.Parser, data []byte, offset int) (int, ast.Node)) func(p *parser.Parser, data []byte, offset int) (int, ast.Node) {
        return func(p *parser.Parser, original []byte, offset int) (int, ast.Node) {
                data := original[offset:]
                // minimum: [[X]]
                if len(data) < 5 || data[1] != '[' {
                        return fn(p, original, offset)
                }
                inside, after := getWikilinkText(data)
                url, label := runWikilinkHandlers(ctx, inside)

                var node ast.Node
                if len(url) == 0 && len(label) == 0 {
                        slog.Error("invalid wikilink", "link", string(inside))
                        // TODO: we just treat broken wikilinks like plaintext for now, but we should
                        // make red links instead at some point
                        node = &ast.Text{Leaf: ast.Leaf{Literal: append(inside, after...)}}
                } else {
                        node = &ast.Link{Destination: url}
                        ast.AppendChild(node, &ast.Text{Leaf: ast.Leaf{Literal: append(label, after...)}})
                }
                return len(inside) + len(after) + 4, node
        }
}

// getWikilinkText gets the wikilink text from the given raw text data starting with [[.
// Inside contains the text inside the [[]], and after contains all of the text
// after the ]] until there is a space or punctuation.
func getWikilinkText(data []byte) (inside, after []byte) {
        i := 2
        for ; i < len(data); i++ {
                if data[i] == ']' && data[i-1] == ']' {
                        inside = data[2 : i-1]
                        continue
                }
                r := rune(data[i])
                // Space or punctuation after ]] means we are done.
                if inside != nil && (unicode.IsSpace(r) || unicode.IsPunct(r)) {
                        break
                }
        }
        after = data[len(inside)+4 : i]
        return
}

// runWikilinkHandlers returns the first non-blank URL and label returned
// by [Context.WikilinkHandlers].
func runWikilinkHandlers(ctx *Context, text []byte) (url, label []byte) {
        for _, h := range ctx.WikilinkHandlers {
                u, l := h(string(text))
                if u == "" && l == "" {
                        continue
                }
                url, label = []byte(u), []byte(l)
                break
        }
        return
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package icons provides Material Design Symbols as SVG icon variables.
package icons

import _ "embed"

//go:generate core generate -icons svg

// Icon represents the SVG data of an icon. It can be
// set to "" or [None] to indicate that no icon should be used.
type Icon string

var (
        // None is an icon that indicates to not use an icon.
        // It completely prevents the rendering of an icon,
        // whereas [Blank] renders a blank icon.
        None Icon = "none"

        // Blank is a blank icon that can be used as a
        // placeholder when no other icon is appropriate.
        // It still renders an icon, just a blank one,
        // whereas [None] indicates to not render one at all.
        //
        //go:embed svg/blank.svg
        Blank Icon
)

// IsSet returns whether the icon is set to a value other than "" or [None].
func (i Icon) IsSet() bool {
        return i != "" && i != None
}

// Used is a map containing all icons that have been used.
// It is added to by [cogentcore.org/core/core.Icon].
var Used = map[Icon]struct{}{}

// Code generated by "core generate"; DO NOT EDIT.

package keymap

import (
        "cogentcore.org/core/enums"
)

var _FunctionsValues = []Functions{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65}

// FunctionsN is the highest valid value for type Functions, plus one.
const FunctionsN Functions = 66

var _FunctionsValueMap = map[string]Functions{`None`: 0, `MoveUp`: 1, `MoveDown`: 2, `MoveRight`: 3, `MoveLeft`: 4, `PageUp`: 5, `PageDown`: 6, `Home`: 7, `End`: 8, `DocHome`: 9, `DocEnd`: 10, `WordRight`: 11, `WordLeft`: 12, `FocusNext`: 13, `FocusPrev`: 14, `Enter`: 15, `Accept`: 16, `CancelSelect`: 17, `SelectMode`: 18, `SelectAll`: 19, `Abort`: 20, `Copy`: 21, `Cut`: 22, `Paste`: 23, `PasteHist`: 24, `Backspace`: 25, `BackspaceWord`: 26, `Delete`: 27, `DeleteWord`: 28, `Kill`: 29, `Duplicate`: 30, `Transpose`: 31, `TransposeWord`: 32, `Undo`: 33, `Redo`: 34, `Insert`: 35, `InsertAfter`: 36, `ZoomOut`: 37, `ZoomIn`: 38, `Refresh`: 39, `Recenter`: 40, `Complete`: 41, `Lookup`: 42, `Search`: 43, `Find`: 44, `Replace`: 45, `Jump`: 46, `HistPrev`: 47, `HistNext`: 48, `Menu`: 49, `WinFocusNext`: 50, `WinClose`: 51, `WinSnapshot`: 52, `New`: 53, `NewAlt1`: 54, `NewAlt2`: 55, `Open`: 56, `OpenAlt1`: 57, `OpenAlt2`: 58, `Save`: 59, `SaveAs`: 60, `SaveAlt`: 61, `CloseAlt1`: 62, `CloseAlt2`: 63, `MultiA`: 64, `MultiB`: 65}

var _FunctionsDescMap = map[Functions]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``, 5: ``, 6: ``, 7: `PageRight PageLeft`, 8: ``, 9: ``, 10: ``, 11: ``, 12: ``, 13: ``, 14: ``, 15: ``, 16: ``, 17: ``, 18: ``, 19: ``, 20: ``, 21: `EditItem`, 22: ``, 23: ``, 24: ``, 25: ``, 26: ``, 27: ``, 28: ``, 29: ``, 30: ``, 31: ``, 32: ``, 33: ``, 34: ``, 35: ``, 36: ``, 37: ``, 38: ``, 39: ``, 40: ``, 41: ``, 42: ``, 43: ``, 44: ``, 45: ``, 46: ``, 47: ``, 48: ``, 49: ``, 50: ``, 51: ``, 52: ``, 53: `Below are menu specific functions -- use these as shortcuts for menu buttons allows uniqueness of mapping and easy customization of all key buttons`, 54: ``, 55: ``, 56: ``, 57: ``, 58: ``, 59: ``, 60: ``, 61: ``, 62: ``, 63: ``, 64: ``, 65: ``}

var _FunctionsMap = map[Functions]string{0: `None`, 1: `MoveUp`, 2: `MoveDown`, 3: `MoveRight`, 4: `MoveLeft`, 5: `PageUp`, 6: `PageDown`, 7: `Home`, 8: `End`, 9: `DocHome`, 10: `DocEnd`, 11: `WordRight`, 12: `WordLeft`, 13: `FocusNext`, 14: `FocusPrev`, 15: `Enter`, 16: `Accept`, 17: `CancelSelect`, 18: `SelectMode`, 19: `SelectAll`, 20: `Abort`, 21: `Copy`, 22: `Cut`, 23: `Paste`, 24: `PasteHist`, 25: `Backspace`, 26: `BackspaceWord`, 27: `Delete`, 28: `DeleteWord`, 29: `Kill`, 30: `Duplicate`, 31: `Transpose`, 32: `TransposeWord`, 33: `Undo`, 34: `Redo`, 35: `Insert`, 36: `InsertAfter`, 37: `ZoomOut`, 38: `ZoomIn`, 39: `Refresh`, 40: `Recenter`, 41: `Complete`, 42: `Lookup`, 43: `Search`, 44: `Find`, 45: `Replace`, 46: `Jump`, 47: `HistPrev`, 48: `HistNext`, 49: `Menu`, 50: `WinFocusNext`, 51: `WinClose`, 52: `WinSnapshot`, 53: `New`, 54: `NewAlt1`, 55: `NewAlt2`, 56: `Open`, 57: `OpenAlt1`, 58: `OpenAlt2`, 59: `Save`, 60: `SaveAs`, 61: `SaveAlt`, 62: `CloseAlt1`, 63: `CloseAlt2`, 64: `MultiA`, 65: `MultiB`}

// String returns the string representation of this Functions value.
func (i Functions) String() string { return enums.String(i, _FunctionsMap) }

// SetString sets the Functions value from its string representation,
// and returns an error if the string is invalid.
func (i *Functions) SetString(s string) error {
        return enums.SetString(i, s, _FunctionsValueMap, "Functions")
}

// Int64 returns the Functions value as an int64.
func (i Functions) Int64() int64 { return int64(i) }

// SetInt64 sets the Functions value from an int64.
func (i *Functions) SetInt64(in int64) { *i = Functions(in) }

// Desc returns the description of the Functions value.
func (i Functions) Desc() string { return enums.Desc(i, _FunctionsDescMap) }

// FunctionsValues returns all possible values for the type Functions.
func FunctionsValues() []Functions { return _FunctionsValues }

// Values returns all possible values for the type Functions.
func (i Functions) Values() []enums.Enum { return enums.Values(_FunctionsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Functions) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Functions) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Functions")
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package keymap

import (
        "cogentcore.org/core/system"

        // we have to import system/driver here so that it is initialized
        // in time for us to the get the system platform
        _ "cogentcore.org/core/system/driver"
)

func init() {
        AvailableMaps.CopyFrom(StandardMaps)
        switch system.TheApp.SystemPlatform() {
        case system.MacOS:
                DefaultMap = "MacStandard"
        case system.Windows:
                DefaultMap = "WindowsStandard"
        default:
                DefaultMap = "LinuxStandard"
        }
        SetActiveMapName(DefaultMap)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package keymap implements maps from keyboard shortcuts to
// semantic GUI keyboard functions.
package keymap

//go:generate core generate

import (
        "encoding/json"
        "log/slog"
        "slices"
        "sort"
        "strings"

        "cogentcore.org/core/events/key"
)

// https://en.wikipedia.org/wiki/Table_of_keyboard_shortcuts
// https://www.cs.colorado.edu/~main/cs1300/lab/emacs.html
// https://help.ubuntu.com/community/KeyboardShortcuts

// Functions are semantic functions that keyboard events
// can perform in the GUI.
type Functions int32 //enums:enum

const (
        None Functions = iota
        MoveUp
        MoveDown
        MoveRight
        MoveLeft
        PageUp
        PageDown
        // PageRight
        // PageLeft
        Home    // start-of-line
        End     // end-of-line
        DocHome // start-of-doc -- Control / Alt / Shift +Home
        DocEnd  // end-of-doc Control / Alt / Shift +End
        WordRight
        WordLeft
        // WordLeft is the final navigation function -- all above also allow Shift+ for selection.

        FocusNext // Tab
        FocusPrev // Shift-Tab
        Enter     // Enter / return key -- has various special functions
        Accept    // Ctrl+Enter = accept any changes and close dialog / move to next
        CancelSelect
        SelectMode
        SelectAll
        Abort
        // EditItem
        Copy
        Cut
        Paste
        PasteHist // from history
        Backspace
        BackspaceWord
        Delete
        DeleteWord
        Kill
        Duplicate
        Transpose
        TransposeWord
        Undo
        Redo
        Insert
        InsertAfter
        ZoomOut
        ZoomIn
        Refresh
        Recenter // Ctrl+L in emacs
        Complete
        Lookup
        Search // Ctrl+S in emacs -- more interactive type of search
        Find   // Command+F full-dialog find
        Replace
        Jump // jump to line
        HistPrev
        HistNext
        Menu // put focus on menu
        WinFocusNext
        WinClose
        WinSnapshot
        // Below are menu specific functions -- use these as shortcuts for menu buttons
        // allows uniqueness of mapping and easy customization of all key buttons
        New
        NewAlt1 // alternative version (e.g., shift)
        NewAlt2 // alternative version (e.g., alt)
        Open
        OpenAlt1 // alternative version (e.g., shift)
        OpenAlt2 // alternative version (e.g., alt)
        Save
        SaveAs
        SaveAlt   // another alt (e.g., alt)
        CloseAlt1 // alternative version (e.g., shift)
        CloseAlt2 // alternative version (e.g., alt)
        MultiA    // multi-key sequence A: Emacs Control+C
        MultiB    // multi-key sequence B: Emacs Control+X
)

// Map is a map between a key sequence (chord) and a specific key
// function.  This mapping must be unique, in that each chord has a
// unique function, but multiple chords can trigger the same function.
type Map map[key.Chord]Functions

// ActiveMap points to the active map -- users can set this to an
// alternative map in Settings
var ActiveMap *Map

// MapName has an associated Value for selecting from the list of
// available key map names, for use in preferences etc.
type MapName string

// ActiveMapName is the name of the active keymap
var ActiveMapName MapName

// SetActiveMap sets the current ActiveKeyMap, calling Update on the map
// prior to setting it to ensure that it is a valid, complete map
func SetActiveMap(km *Map, kmName MapName) {
        km.Update(kmName)
        ActiveMap = km
        ActiveMapName = kmName
}

// SetActiveMapName sets the current ActiveKeyMap by name from those
// defined in AvailKeyMaps, calling Update on the map prior to setting it to
// ensure that it is a valid, complete map
func SetActiveMapName(mapnm MapName) {
        km, _, ok := AvailableMaps.MapByName(mapnm)
        if ok {
                SetActiveMap(km, mapnm)
        } else {
                slog.Error("keymap.SetActiveKeyMapName: key map named not found, using default", "requested", mapnm, "default", DefaultMap)
                km, _, ok = AvailableMaps.MapByName(DefaultMap)
                if ok {
                        SetActiveMap(km, DefaultMap)
                } else {
                        avail := make([]string, len(AvailableMaps))
                        for i, km := range AvailableMaps {
                                avail[i] = km.Name
                        }
                        slog.Error("keymap.SetActiveKeyMapName: DefaultKeyMap not found either; trying first one", "default", DefaultMap, "available", avail)
                        if len(AvailableMaps) > 0 {
                                nkm := AvailableMaps[0]
                                SetActiveMap(&nkm.Map, MapName(nkm.Name))
                        }
                }
        }
}

// Of converts the given [key.Chord] into a keyboard function.
func Of(chord key.Chord) Functions {
        f, ok := (*ActiveMap)[chord]
        if ok {
                return f
        }
        if strings.Contains(string(chord), "Shift+") {
                nsc := key.Chord(strings.ReplaceAll(string(chord), "Shift+", ""))
                if f, ok = (*ActiveMap)[nsc]; ok && f <= WordLeft { // automatically allow +Shift for nav
                        return f
                }
        }
        return None
}

// MapItem records one element of the key map, which is used for organizing the map.
type MapItem struct {

        // the key chord that activates a function
        Key key.Chord

        // the function of that key
        Fun Functions
}

// ToSlice copies this keymap to a slice of [MapItem]s.
func (km *Map) ToSlice() []MapItem {
        kms := make([]MapItem, len(*km))
        idx := 0
        for key, fun := range *km {
                kms[idx] = MapItem{key, fun}
                idx++
        }
        return kms
}

// ChordFor returns all of the key chord triggers for the given
// key function in the map, separating them with newlines.
func (km *Map) ChordFor(kf Functions) key.Chord {
        res := []string{}
        for key, fun := range *km {
                if fun == kf {
                        res = append(res, string(key))
                }
        }
        slices.Sort(res)
        return key.Chord(strings.Join(res, "\n"))
}

// Chord returns all of the key chord triggers for this
// key function in the current active map, separating them with newlines.
func (kf Functions) Chord() key.Chord {
        return ActiveMap.ChordFor(kf)
}

// Label transforms the key function into a string representing
// its underlying key chord(s) in a form suitable for display to users.
func (kf Functions) Label() string {
        return kf.Chord().Label()
}

// Update ensures that the given keymap has at least one entry for every
// defined key function, grabbing ones from the default map if not, and
// also eliminates any [None] entries which might reflect out-of-date
// functions.
func (km *Map) Update(kmName MapName) {
        for key, val := range *km {
                if val == None {
                        slog.Error("keymap.KeyMap: key function is nil; probably renamed", "key", key)
                        delete(*km, key)
                }
        }
        kms := km.ToSlice()
        addkm := make([]MapItem, 0)

        sort.Slice(kms, func(i, j int) bool {
                return kms[i].Fun < kms[j].Fun
        })

        lfun := None
        for _, ki := range kms {
                fun := ki.Fun
                if fun != lfun {
                        del := fun - lfun
                        if del > 1 {
                                for mi := lfun + 1; mi < fun; mi++ {
                                        // slog.Error("keymap.KeyMap: key map is missing a key for a key function", "keyMap", kmName, "function", mi)
                                        s := mi.String()
                                        s = "- Not Set - " + s
                                        nski := MapItem{Key: key.Chord(s), Fun: mi}
                                        addkm = append(addkm, nski)
                                }
                        }
                        lfun = fun
                }
        }

        for _, ai := range addkm {
                (*km)[ai.Key] = ai.Fun
        }
}

// DefaultMap is the overall default keymap, which is set in init
// depending on the platform
var DefaultMap MapName = "LinuxStandard"

// MapsItem is an entry in a Maps list
type MapsItem struct { //types:add -setters

        // name of keymap
        Name string `width:"20"`

        // description of keymap; good idea to include source it was derived from
        Desc string

        // to edit key sequence click button and type new key combination; to edit function mapped to key sequence choose from menu
        Map Map
}

// Label satisfies the Labeler interface
func (km MapsItem) Label() string {
        return km.Name
}

// Maps is a list of [MapsItem]s; users can edit these in their settings.
type Maps []MapsItem //types:add

// AvailableMaps is the current list of available keymaps for use.
// This can be loaded / saved / edited in user settings. This is set
// to [StandardMaps] at startup.
var AvailableMaps Maps

// MapByName returns a [Map] and index by name. It returns false
// and prints an error message if not found.
func (km *Maps) MapByName(name MapName) (*Map, int, bool) {
        for i, it := range *km {
                if it.Name == string(name) {
                        return &it.Map, i, true
                }
        }
        slog.Error("keymap.KeyMaps.MapByName: key map not found", "name", name)
        return nil, -1, false
}

// CopyFrom copies keymaps from given other map
func (km *Maps) CopyFrom(cp Maps) {
        *km = make(Maps, 0, len(cp)) // reset
        b, _ := json.Marshal(cp)
        json.Unmarshal(b, km)
}

// MergeFrom merges keymaps from given other map
func (km *Maps) MergeFrom(cp Maps) {
        for nm, mi := range cp {
                tmi := (*km)[nm]
                for ch, kf := range mi.Map {
                        tmi.Map[ch] = kf
                }
        }
}

// order is: Shift, Control, Alt, Meta
// note: shift and meta modifiers for navigation keys do select + move

// note: where multiple shortcuts exist for a given function, any shortcut
// display of such items in menus will randomly display one of the
// options. This can be considered a feature, not a bug!

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package keymap

import (
        "strings"

        "cogentcore.org/core/events/key"
)

// MarkdownDoc generates a markdown table of all the key mappings
func (km *Maps) MarkdownDoc() string { //types:add
        mods := []string{"", "Shift", "Control", "Control+Shift", "Meta", "Meta+Shift", "Alt", "Alt+Shift", "Control+Alt", "Meta+Alt"}

        var b strings.Builder

        fmap := make([][][]string, len(*km)) // km, kf, ch
        for i := range *km {
                fmap[i] = make([][]string, FunctionsN)
        }

        for _, md := range mods {
                if md == "" {
                        b.WriteString("### No Modifiers\n\n")
                } else {
                        b.WriteString("### " + md + "\n\n")
                }
                b.WriteString("| Key                          ")
                for _, m := range *km {
                        b.WriteString("| `" + m.Name + "` ")
                }
                b.WriteString("|\n")
                b.WriteString("| ---------------------------- ")
                for _, m := range *km {
                        b.WriteString("| " + strings.Repeat("-", len(m.Name)+2) + " ")
                }
                b.WriteString("|\n")

                for cd := key.CodeA; cd < key.CodesN; cd++ {
                        ch := key.Chord(md + "+" + cd.String())
                        if md == "" {
                                ch = key.Chord(cd.String())
                        }
                        has := false
                        for _, m := range *km {
                                _, ok := m.Map[ch]
                                if ok {
                                        has = true
                                        break
                                }
                        }
                        if !has {
                                continue
                        }
                        b.WriteString("| " + string(ch) + " ")
                        for mi, m := range *km {
                                kf, ok := m.Map[ch]
                                if ok {
                                        b.WriteString("| " + kf.String() + " ")
                                        fmap[mi][kf] = append(fmap[mi][kf], string(ch))
                                } else {
                                        b.WriteString("| " + strings.Repeat(" ", len(m.Name)+2) + " ")
                                }
                        }
                        b.WriteString("|\n")
                }
                b.WriteString("\n\n")
        }

        // By function
        b.WriteString("### By function\n\n")

        b.WriteString("| Function                         ")
        for _, m := range *km {
                b.WriteString("| `" + m.Name + "` ")
        }
        b.WriteString("|\n")
        b.WriteString("| ---------------------------- ")
        for _, m := range *km {
                b.WriteString("| " + strings.Repeat("-", len(m.Name)+2) + " ")
        }
        b.WriteString("|\n")

        for kf := MoveUp; kf < FunctionsN; kf++ {
                b.WriteString("| " + kf.String() + " ")
                for mi, m := range *km {
                        f := fmap[mi][kf]
                        b.WriteString("| ")
                        if len(f) > 0 {
                                for fi, fs := range f {
                                        b.WriteString(fs)
                                        if fi < len(f)-1 {
                                                b.WriteString(", ")
                                        } else {
                                                b.WriteString(" ")
                                        }
                                }
                        } else {
                                b.WriteString(strings.Repeat(" ", len(m.Name)+2) + " ")
                        }
                }
                b.WriteString("|\n")
        }
        b.WriteString("\n\n")

        return b.String()
}

// Code generated by "core generate"; DO NOT EDIT.

package keymap

import (
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/keymap.MapsItem", IDName: "maps-item", Doc: "MapsItem is an entry in a Maps list", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Fields: []types.Field{{Name: "Name", Doc: "name of keymap"}, {Name: "Desc", Doc: "description of keymap; good idea to include source it was derived from"}, {Name: "Map", Doc: "to edit key sequence click button and type new key combination; to edit function mapped to key sequence choose from menu"}}})

// SetName sets the [MapsItem.Name]:
// name of keymap
func (t *MapsItem) SetName(v string) *MapsItem { t.Name = v; return t }

// SetDesc sets the [MapsItem.Desc]:
// description of keymap; good idea to include source it was derived from
func (t *MapsItem) SetDesc(v string) *MapsItem { t.Desc = v; return t }

// SetMap sets the [MapsItem.Map]:
// to edit key sequence click button and type new key combination; to edit function mapped to key sequence choose from menu
func (t *MapsItem) SetMap(v Map) *MapsItem { t.Map = v; return t }

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import (
        "unsafe"

        "cogentcore.org/core/base/slicesx"
)

// ArrayF32 is a slice of float32 with additional convenience methods
// for other math32 data types.  Use slicesx.SetLength to set length
// efficiently.
type ArrayF32 []float32

// NewArrayF32 creates a returns a new array of floats
// with the specified initial size and capacity
func NewArrayF32(size, capacity int) ArrayF32 {
        return make([]float32, size, capacity)
}

// NumBytes returns the size of the array in bytes
func (a *ArrayF32) NumBytes() int {
        return len(*a) * int(unsafe.Sizeof(float32(0)))
}

// Append appends any number of values to the array
func (a *ArrayF32) Append(v ...float32) {
        *a = append(*a, v...)
}

// AppendVector2 appends any number of Vector2 to the array
func (a *ArrayF32) AppendVector2(v ...Vector2) {
        for i := 0; i < len(v); i++ {
                *a = append(*a, v[i].X, v[i].Y)
        }
}

// AppendVector3 appends any number of Vector3 to the array
func (a *ArrayF32) AppendVector3(v ...Vector3) {
        for i := 0; i < len(v); i++ {
                *a = append(*a, v[i].X, v[i].Y, v[i].Z)
        }
}

// AppendVector4 appends any number of Vector4 to the array
func (a *ArrayF32) AppendVector4(v ...Vector4) {
        for i := 0; i < len(v); i++ {
                *a = append(*a, v[i].X, v[i].Y, v[i].Z, v[i].W)
        }
}

// CopyFloat32s copies a []float32 slice from src into target,
// ensuring that the target is the correct size.
func CopyFloat32s(trg *[]float32, src []float32) {
        *trg = slicesx.SetLength(*trg, len(src))
        copy(*trg, src)
}

// CopyFloat64s copies a []float64 slice from src into target,
// ensuring that the target is the correct size.
func CopyFloat64s(trg *[]float64, src []float64) {
        *trg = slicesx.SetLength(*trg, len(src))
        copy(*trg, src)
}

func (a *ArrayF32) CopyFrom(src ArrayF32) {
        CopyFloat32s((*[]float32)(a), src)
}

// GetVector2 stores in the specified Vector2 the
// values from the array starting at the specified pos.
func (a ArrayF32) GetVector2(pos int, v *Vector2) {
        v.X = a[pos]
        v.Y = a[pos+1]
}

// GetVector3 stores in the specified Vector3 the
// values from the array starting at the specified pos.
func (a ArrayF32) GetVector3(pos int, v *Vector3) {
        v.X = a[pos]
        v.Y = a[pos+1]
        v.Z = a[pos+2]
}

// GetVector4 stores in the specified Vector4 the
// values from the array starting at the specified pos.
func (a ArrayF32) GetVector4(pos int, v *Vector4) {
        v.X = a[pos]
        v.Y = a[pos+1]
        v.Z = a[pos+2]
        v.W = a[pos+3]
}

// GetMatrix4 stores in the specified Matrix4 the
// values from the array starting at the specified pos.
func (a ArrayF32) GetMatrix4(pos int, m *Matrix4) {
        m[0] = a[pos]
        m[1] = a[pos+1]
        m[2] = a[pos+2]
        m[3] = a[pos+3]
        m[4] = a[pos+4]
        m[5] = a[pos+5]
        m[6] = a[pos+6]
        m[7] = a[pos+7]
        m[8] = a[pos+8]
        m[9] = a[pos+9]
        m[10] = a[pos+10]
        m[11] = a[pos+11]
        m[12] = a[pos+12]
        m[13] = a[pos+13]
        m[14] = a[pos+14]
        m[15] = a[pos+15]
}

// Set sets the values of the array starting at the specified pos
// from the specified values
func (a ArrayF32) Set(pos int, v ...float32) {
        for i, vv := range v {
                a[pos+i] = vv
        }
}

// SetVector2 sets the values of the array at the specified pos
// from the XY values of the specified Vector2
func (a ArrayF32) SetVector2(pos int, v Vector2) {
        a[pos] = v.X
        a[pos+1] = v.Y
}

// SetVector3 sets the values of the array at the specified pos
// from the XYZ values of the specified Vector3
func (a ArrayF32) SetVector3(pos int, v Vector3) {
        a[pos] = v.X
        a[pos+1] = v.Y
        a[pos+2] = v.Z
}

// SetVector4 sets the values of the array at the specified pos
// from the XYZ values of the specified Vector4
func (a ArrayF32) SetVector4(pos int, v Vector4) {
        a[pos] = v.X
        a[pos+1] = v.Y
        a[pos+2] = v.Z
        a[pos+3] = v.W
}

/////////////////////////////////////////////////////////////////////////////////////
//   ArrayU32

// ArrayU32 is a slice of uint32 with additional convenience methods.
// Use slicesx.SetLength to set length efficiently.
type ArrayU32 []uint32

// NewArrayU32 creates a returns a new array of uint32
// with the specified initial size and capacity
func NewArrayU32(size, capacity int) ArrayU32 {
        return make([]uint32, size, capacity)
}

// NumBytes returns the size of the array in bytes
func (a *ArrayU32) NumBytes() int {
        return len(*a) * int(unsafe.Sizeof(uint32(0)))
}

// Append appends n elements to the array updating the slice if necessary
func (a *ArrayU32) Append(v ...uint32) {
        *a = append(*a, v...)
}

// Set sets the values of the array starting at the specified pos
// from the specified values
func (a ArrayU32) Set(pos int, v ...uint32) {
        for i, vv := range v {
                a[pos+i] = vv
        }
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import (
        "image"

        "golang.org/x/image/math/fixed"
)

// Box2 represents a 2D bounding box defined by two points:
// the point with minimum coordinates and the point with maximum coordinates.
type Box2 struct {
        Min Vector2
        Max Vector2
}

// B2 returns a new [Box2] from the given minimum and maximum x and y coordinates.
func B2(x0, y0, x1, y1 float32) Box2 {
        return Box2{Vec2(x0, y0), Vec2(x1, y1)}
}

// B2Empty returns a new [Box2] with empty minimum and maximum values
func B2Empty() Box2 {
        bx := Box2{}
        bx.SetEmpty()
        return bx
}

// B2FromRect returns a new [Box2] from the given [image.Rectangle].
func B2FromRect(rect image.Rectangle) Box2 {
        b := Box2{}
        b.SetFromRect(rect)
        return b
}

// B2FromFixed returns a new [Box2] from the given [fixed.Rectangle26_6].
func B2FromFixed(rect fixed.Rectangle26_6) Box2 {
        b := Box2{}
        b.Min.SetFixed(rect.Min)
        b.Max.SetFixed(rect.Max)
        return b
}

// SetEmpty set this bounding box to empty (min / max +/- Infinity)
func (b *Box2) SetEmpty() {
        b.Min.SetScalar(Infinity)
        b.Max.SetScalar(-Infinity)
}

// IsEmpty returns if this bounding box is empty (max < min on any coord).
func (b *Box2) IsEmpty() bool {
        return (b.Max.X < b.Min.X) || (b.Max.Y < b.Min.Y)
}

// Set sets this bounding box minimum and maximum coordinates.
// If either min or max are nil, then corresponding values are set to +/- Infinity.
func (b *Box2) Set(min, max *Vector2) {
        if min != nil {
                b.Min = *min
        } else {
                b.Min.SetScalar(Infinity)
        }
        if max != nil {
                b.Max = *max
        } else {
                b.Max.SetScalar(-Infinity)
        }
}

// SetFromPoints set this bounding box from the specified array of points.
func (b *Box2) SetFromPoints(points []Vector2) {
        b.SetEmpty()
        for i := 0; i < len(points); i++ {
                b.ExpandByPoint(points[i])
        }
}

// SetFromRect set this bounding box from an image.Rectangle
func (b *Box2) SetFromRect(rect image.Rectangle) {
        b.Min = FromPoint(rect.Min)
        b.Max = FromPoint(rect.Max)
}

// ToRect returns image.Rectangle version of this bbox, using floor for min
// and Ceil for max.
func (b Box2) ToRect() image.Rectangle {
        rect := image.Rectangle{}
        rect.Min = b.Min.ToPointFloor()
        rect.Max = b.Max.ToPointCeil()
        return rect
}

// ToFixed returns fixed.Rectangle26_6 version of this bbox.
func (b Box2) ToFixed() fixed.Rectangle26_6 {
        rect := fixed.Rectangle26_6{Min: b.Min.ToFixed(), Max: b.Max.ToFixed()}
        return rect
}

// RectInNotEmpty returns true if rect r is contained within b box
// and r is not empty.
// The existing image.Rectangle.In method returns true if r is empty,
// but we typically expect that case to be false (out of range box)
func RectInNotEmpty(r, b image.Rectangle) bool {
        if r.Empty() {
                return false
        }
        return r.In(b)
}

// Canon returns the canonical version of the box.
// The returned rectangle has minimum and maximum coordinates swapped
// if necessary so that it is well-formed.
func (b Box2) Canon() Box2 {
        if b.Max.X < b.Min.X {
                b.Min.X, b.Max.X = b.Max.X, b.Min.X
        }
        if b.Max.Y < b.Min.Y {
                b.Min.Y, b.Max.Y = b.Max.Y, b.Min.Y
        }
        return b
}

// ExpandByPoint may expand this bounding box to include the specified point.
func (b *Box2) ExpandByPoint(point Vector2) {
        b.Min.SetMin(point)
        b.Max.SetMax(point)
}

// ExpandByVector expands this bounding box by the specified vector.
func (b *Box2) ExpandByVector(vector Vector2) {
        b.Min.SetSub(vector)
        b.Max.SetAdd(vector)
}

// ExpandByScalar expands this bounding box by the specified scalar.
func (b *Box2) ExpandByScalar(scalar float32) {
        b.Min.SetSubScalar(scalar)
        b.Max.SetAddScalar(scalar)
}

// ExpandByBox may expand this bounding box to include the specified box
func (b *Box2) ExpandByBox(box Box2) {
        b.ExpandByPoint(box.Min)
        b.ExpandByPoint(box.Max)
}

// MulMatrix2 multiplies the specified matrix to the vertices of this bounding box
// and computes the resulting spanning Box2 of the transformed points
func (b Box2) MulMatrix2(m Matrix2) Box2 {
        var cs [4]Vector2
        cs[0] = m.MulVector2AsPoint(Vec2(b.Min.X, b.Min.Y))
        cs[1] = m.MulVector2AsPoint(Vec2(b.Min.X, b.Max.Y))
        cs[2] = m.MulVector2AsPoint(Vec2(b.Max.X, b.Min.Y))
        cs[3] = m.MulVector2AsPoint(Vec2(b.Max.X, b.Max.Y))

        nb := B2Empty()
        for i := 0; i < 4; i++ {
                nb.ExpandByPoint(cs[i])
        }
        return nb
}

// SetFromCenterAndSize set this bounding box from a center point and size.
// Size is a vector from the minimum point to the maximum point.
func (b *Box2) SetFromCenterAndSize(center, size Vector2) {
        halfSize := size.MulScalar(0.5)
        b.Min = center.Sub(halfSize)
        b.Max = center.Add(halfSize)
}

// Center calculates the center point of this bounding box.
func (b Box2) Center() Vector2 {
        return b.Min.Add(b.Max).MulScalar(0.5)
}

// Size calculates the size of this bounding box: the vector from
// its minimum point to its maximum point.
func (b Box2) Size() Vector2 {
        return b.Max.Sub(b.Min)
}

// ContainsPoint returns if this bounding box contains the specified point.
func (b Box2) ContainsPoint(point Vector2) bool {
        if point.X < b.Min.X || point.X > b.Max.X ||
                point.Y < b.Min.Y || point.Y > b.Max.Y {
                return false
        }
        return true
}

// ContainsBox returns if this bounding box contains other box.
func (b Box2) ContainsBox(box Box2) bool {
        return (b.Min.X <= box.Min.X) && (box.Max.X <= b.Max.X) && (b.Min.Y <= box.Min.Y) && (box.Max.Y <= b.Max.Y)
}

// IntersectsBox returns if other box intersects this one.
func (b Box2) IntersectsBox(other Box2) bool {
        if other.Max.X < b.Min.X || other.Min.X > b.Max.X ||
                other.Max.Y < b.Min.Y || other.Min.Y > b.Max.Y {
                return false
        }
        return true
}

// ClampPoint calculates a new point which is the specified point clamped inside this box.
func (b Box2) ClampPoint(point Vector2) Vector2 {
        point.Clamp(b.Min, b.Max)
        return point
}

// DistanceToPoint returns the distance from this box to the specified point.
func (b Box2) DistanceToPoint(point Vector2) float32 {
        clamp := b.ClampPoint(point)
        return clamp.Sub(point).Length()
}

// Intersect returns the intersection with other box.
func (b Box2) Intersect(other Box2) Box2 {
        other.Min.SetMax(b.Min)
        other.Max.SetMin(b.Max)
        return other
}

// Union returns the union with other box.
func (b Box2) Union(other Box2) Box2 {
        other.Min.SetMin(b.Min)
        other.Max.SetMax(b.Max)
        return other
}

// Translate returns translated position of this box by offset.
func (b Box2) Translate(offset Vector2) Box2 {
        nb := Box2{}
        nb.Min = b.Min.Add(offset)
        nb.Max = b.Max.Add(offset)
        return nb
}

// ProjectX projects normalized value along the X dimension of this box
func (b Box2) ProjectX(v float32) float32 {
        return b.Min.X + v*(b.Max.X-b.Min.X)
}

// ProjectY projects normalized value along the Y dimension of this box
func (b Box2) ProjectY(v float32) float32 {
        return b.Min.Y + v*(b.Max.Y-b.Min.Y)
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

// Box3 represents a 3D bounding box defined by two points:
// the point with minimum coordinates and the point with maximum coordinates.
type Box3 struct {
        Min Vector3
        Max Vector3
}

// B3 returns a new [Box3] from the given minimum and maximum x, y, and z coordinates.
func B3(x0, y0, z0, x1, y1, z1 float32) Box3 {
        return Box3{Vec3(x0, y0, z0), Vec3(x1, y1, z1)}
}

// B3Empty returns a new [Box3] with empty minimum and maximum values.
func B3Empty() Box3 {
        bx := Box3{}
        bx.SetEmpty()
        return bx
}

// SetEmpty set this bounding box to empty (min / max +/- Infinity)
func (b *Box3) SetEmpty() {
        b.Min.SetScalar(Infinity)
        b.Max.SetScalar(-Infinity)
}

// IsEmpty returns true if this bounding box is empty (max < min on any coord).
func (b Box3) IsEmpty() bool {
        return (b.Max.X < b.Min.X) || (b.Max.Y < b.Min.Y) || (b.Max.Z < b.Min.Z)
}

// Set sets this bounding box minimum and maximum coordinates.
// If either min or max are nil, then corresponding values are set to +/- Infinity.
func (b *Box3) Set(min, max *Vector3) {
        if min != nil {
                b.Min = *min
        } else {
                b.Min.SetScalar(Infinity)
        }
        if max != nil {
                b.Max = *max
        } else {
                b.Max.SetScalar(-Infinity)
        }
}

// SetFromPoints sets this bounding box from the specified array of points.
func (b *Box3) SetFromPoints(points []Vector3) {
        b.SetEmpty()
        b.ExpandByPoints(points)
}

// ExpandByPoints may expand this bounding box from the specified array of points.
func (b *Box3) ExpandByPoints(points []Vector3) {
        for i := 0; i < len(points); i++ {
                b.ExpandByPoint(points[i])
        }
}

// ExpandByPoint may expand this bounding box to include the specified point.
func (b *Box3) ExpandByPoint(point Vector3) {
        b.Min.SetMin(point)
        b.Max.SetMax(point)
}

// ExpandByBox may expand this bounding box to include the specified box
func (b *Box3) ExpandByBox(box Box3) {
        b.ExpandByPoint(box.Min)
        b.ExpandByPoint(box.Max)
}

// ExpandByVector expands this bounding box by the specified vector
// subtracting from min and adding to max.
func (b *Box3) ExpandByVector(vector Vector3) {
        b.Min.SetSub(vector)
        b.Max.SetAdd(vector)
}

// ExpandByScalar expands this bounding box by the specified scalar
// subtracting from min and adding to max.
func (b *Box3) ExpandByScalar(scalar float32) {
        b.Min.SetSubScalar(scalar)
        b.Max.SetAddScalar(scalar)
}

// SetFromCenterAndSize sets this bounding box from a center point and size.
// Size is a vector from the minimum point to the maximum point.
func (b *Box3) SetFromCenterAndSize(center, size Vector3) {
        halfSize := size.MulScalar(0.5)
        b.Min = center.Sub(halfSize)
        b.Max = center.Add(halfSize)
}

// Center returns the center of the bounding box.
func (b Box3) Center() Vector3 {
        return b.Min.Add(b.Max).MulScalar(0.5)
}

// Size calculates the size of this bounding box: the vector from
// its minimum point to its maximum point.
func (b Box3) Size() Vector3 {
        return b.Max.Sub(b.Min)
}

// ContainsPoint returns if this bounding box contains the specified point.
func (b Box3) ContainsPoint(point Vector3) bool {
        if point.X < b.Min.X || point.X > b.Max.X ||
                point.Y < b.Min.Y || point.Y > b.Max.Y ||
                point.Z < b.Min.Z || point.Z > b.Max.Z {
                return false
        }
        return true
}

// ContainsBox returns if this bounding box contains other box.
func (b Box3) ContainsBox(box Box3) bool {
        return (b.Min.X <= box.Max.X) && (box.Max.X <= b.Max.X) &&
                (b.Min.Y <= box.Min.Y) && (box.Max.Y <= b.Max.Y) &&
                (b.Min.Z <= box.Min.Z) && (box.Max.Z <= b.Max.Z)
}

// IntersectsBox returns if other box intersects this one.
func (b Box3) IntersectsBox(other Box3) bool {
        // using 6 splitting planes to rule out intersections.
        if other.Max.X < b.Min.X || other.Min.X > b.Max.X ||
                other.Max.Y < b.Min.Y || other.Min.Y > b.Max.Y ||
                other.Max.Z < b.Min.Z || other.Min.Z > b.Max.Z {
                return false
        }
        return true
}

// ClampPoint returns a new point which is the specified point clamped inside this box.
func (b Box3) ClampPoint(point Vector3) Vector3 {
        point.Clamp(b.Min, b.Max)
        return point
}

// DistanceToPoint returns the distance from this box to the specified point.
func (b Box3) DistanceToPoint(point Vector3) float32 {
        clamp := b.ClampPoint(point)
        return clamp.Sub(point).Length()
}

// GetBoundingSphere returns a bounding sphere to this bounding box.
func (b Box3) GetBoundingSphere() Sphere {
        return Sphere{b.Center(), b.Size().Length() * 0.5}
}

// Intersect returns the intersection with other box.
func (b Box3) Intersect(other Box3) Box3 {
        other.Min.SetMax(b.Min)
        other.Max.SetMin(b.Max)
        return other
}

// Union returns the union with other box.
func (b Box3) Union(other Box3) Box3 {
        other.Min.SetMin(b.Min)
        other.Max.SetMax(b.Max)
        return other
}

// MulMatrix4 multiplies the specified matrix to the vertices of this bounding box
// and computes the resulting spanning Box3 of the transformed points
func (b Box3) MulMatrix4(m *Matrix4) Box3 {
        xax := m[0] * b.Min.X
        xay := m[1] * b.Min.X
        xaz := m[2] * b.Min.X
        xbx := m[0] * b.Max.X
        xby := m[1] * b.Max.X
        xbz := m[2] * b.Max.X
        yax := m[4] * b.Min.Y
        yay := m[5] * b.Min.Y
        yaz := m[6] * b.Min.Y
        ybx := m[4] * b.Max.Y
        yby := m[5] * b.Max.Y
        ybz := m[6] * b.Max.Y
        zax := m[8] * b.Min.Z
        zay := m[9] * b.Min.Z
        zaz := m[10] * b.Min.Z
        zbx := m[8] * b.Max.Z
        zby := m[9] * b.Max.Z
        zbz := m[10] * b.Max.Z

        nb := Box3{}
        nb.Min.X = Min(xax, xbx) + Min(yax, ybx) + Min(zax, zbx) + m[12]
        nb.Min.Y = Min(xay, xby) + Min(yay, yby) + Min(zay, zby) + m[13]
        nb.Min.Z = Min(xaz, xbz) + Min(yaz, ybz) + Min(zaz, zbz) + m[14]
        nb.Max.X = Max(xax, xbx) + Max(yax, ybx) + Max(zax, zbx) + m[12]
        nb.Max.Y = Max(xay, xby) + Max(yay, yby) + Max(zay, zby) + m[13]
        nb.Max.Z = Max(xaz, xbz) + Max(yaz, ybz) + Max(zaz, zbz) + m[14]
        return nb
}

// MulQuat multiplies the specified quaternion to the vertices of this bounding box
// and computes the resulting spanning Box3 of the transformed points
func (b Box3) MulQuat(q Quat) Box3 {
        var cs [8]Vector3
        cs[0] = Vec3(b.Min.X, b.Min.Y, b.Min.Z).MulQuat(q)
        cs[1] = Vec3(b.Min.X, b.Min.Y, b.Max.Z).MulQuat(q)
        cs[2] = Vec3(b.Min.X, b.Max.Y, b.Min.Z).MulQuat(q)
        cs[3] = Vec3(b.Max.X, b.Min.Y, b.Min.Z).MulQuat(q)

        cs[4] = Vec3(b.Max.X, b.Max.Y, b.Max.Z).MulQuat(q)
        cs[5] = Vec3(b.Max.X, b.Max.Y, b.Min.Z).MulQuat(q)
        cs[6] = Vec3(b.Max.X, b.Min.Y, b.Max.Z).MulQuat(q)
        cs[7] = Vec3(b.Min.X, b.Max.Y, b.Max.Z).MulQuat(q)

        nb := B3Empty()
        for i := 0; i < 8; i++ {
                nb.ExpandByPoint(cs[i])
        }
        return nb
}

// Translate returns translated position of this box by offset.
func (b Box3) Translate(offset Vector3) Box3 {
        nb := Box3{}
        nb.Min = b.Min.Add(offset)
        nb.Max = b.Max.Add(offset)
        return nb
}

// MVProjToNDC projects bounding box through given MVP model-view-projection Matrix4
// with perspective divide to return normalized display coordinates (NDC).
func (b Box3) MVProjToNDC(m *Matrix4) Box3 {
        // all corners: i = min, a = max
        var cs [8]Vector3
        cs[0] = Vector4{b.Min.X, b.Min.Y, b.Min.Z, 1}.MulMatrix4(m).PerspDiv()
        cs[1] = Vector4{b.Min.X, b.Min.Y, b.Max.Z, 1}.MulMatrix4(m).PerspDiv()
        cs[2] = Vector4{b.Min.X, b.Max.Y, b.Min.Z, 1}.MulMatrix4(m).PerspDiv()
        cs[3] = Vector4{b.Max.X, b.Min.Y, b.Min.Z, 1}.MulMatrix4(m).PerspDiv()

        cs[4] = Vector4{b.Max.X, b.Max.Y, b.Max.Z, 1}.MulMatrix4(m).PerspDiv()
        cs[5] = Vector4{b.Max.X, b.Max.Y, b.Min.Z, 1}.MulMatrix4(m).PerspDiv()
        cs[6] = Vector4{b.Max.X, b.Min.Y, b.Max.Z, 1}.MulMatrix4(m).PerspDiv()
        cs[7] = Vector4{b.Min.X, b.Max.Y, b.Max.Z, 1}.MulMatrix4(m).PerspDiv()

        nb := B3Empty()
        for i := 0; i < 8; i++ {
                nb.ExpandByPoint(cs[i])
        }
        return nb
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math32

import "image/color"

// official correct ones:

// SRGBFromLinear converts a color with linear gamma correction to SRGB standard 2.4 gamma
// with offsets.
func SRGBFromLinear(lin float32) float32 {
        if lin <= 0.0031308 {
                return lin * 12.92
        }
        return Pow(lin, 1.0/2.4)*1.055 - 0.055
}

// SRGBToLinear converts a color with SRGB gamma correction to SRGB standard 2.4 gamma
// with offsets
func SRGBToLinear(sr float32) float32 {
        if sr <= 0.04045 {
                return sr / 12.92
        }
        return Pow((sr+0.055)/1.055, 2.4)
}

/*
// rough-and-ready approx used in many cases:

func SRGBFromLinear(lin float32) float32 {
        return Pow(lin, 1.0/2.2)
}

func SRGBToLinear(sr float32) float32 {
        return Pow(sr, 2.2)
}

*/

// NewVector3Color returns a Vector3 from Go standard color.Color
// (R,G,B components only)
func NewVector3Color(clr color.Color) Vector3 {
        v3 := Vector3{}
        v3.SetColor(clr)
        return v3
}

// SetColor sets from Go standard color.Color
// (R,G,B components only)
func (v *Vector3) SetColor(clr color.Color) {
        r, g, b, _ := clr.RGBA()
        v.X = float32(r) / 0xffff
        v.Y = float32(g) / 0xffff
        v.Z = float32(b) / 0xffff
}

// NewVector4Color returns a Vector4 from Go standard color.Color
// (full R,G,B,A components)
func NewVector4Color(clr color.Color) Vector4 {
        v4 := Vector4{}
        v4.SetColor(clr)
        return v4
}

// SetColor sets a Vector4 from Go standard color.Color
func (v *Vector4) SetColor(clr color.Color) {
        r, g, b, a := clr.RGBA()
        v.X = float32(r) / 0xffff
        v.Y = float32(g) / 0xffff
        v.Z = float32(b) / 0xffff
        v.W = float32(a) / 0xffff
}

// SRGBFromLinear returns an SRGB color space value from a linear source
func (v Vector3) SRGBFromLinear() Vector3 {
        nv := Vector3{}
        nv.X = SRGBFromLinear(v.X)
        nv.Y = SRGBFromLinear(v.Y)
        nv.Z = SRGBFromLinear(v.Z)
        return nv
}

// SRGBToLinear returns a linear color space value from a SRGB source
func (v Vector3) SRGBToLinear() Vector3 {
        nv := Vector3{}
        nv.X = SRGBToLinear(v.X)
        nv.Y = SRGBToLinear(v.Y)
        nv.Z = SRGBToLinear(v.Z)
        return nv
}

// SRGBFromLinear returns an SRGB color space value from a linear source
func (v Vector4) SRGBFromLinear() Vector4 {
        nv := Vector4{}
        nv.X = SRGBFromLinear(v.X)
        nv.Y = SRGBFromLinear(v.Y)
        nv.Z = SRGBFromLinear(v.Z)
        nv.W = v.W
        return nv
}

// SRGBToLinear returns a linear color space value from a SRGB source
func (v Vector4) SRGBToLinear() Vector4 {
        nv := Vector4{}
        nv.X = SRGBToLinear(v.X)
        nv.Y = SRGBToLinear(v.Y)
        nv.Z = SRGBToLinear(v.Z)
        nv.W = v.W
        return nv
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math32

// Dims is a list of vector dimension (component) names
type Dims int32 //enums:enum

const (
        X Dims = iota
        Y
        Z
        W
)

// OtherDim returns the other dimension for 2D X,Y
func OtherDim(d Dims) Dims {
        switch d {
        case X:
                return Y
        default:
                return X
        }
}

func (d Dims) Other() Dims {
        return OtherDim(d)
}

// Code generated by "core generate"; DO NOT EDIT.

package math32

import (
        "cogentcore.org/core/enums"
)

var _DimsValues = []Dims{0, 1, 2, 3}

// DimsN is the highest valid value for type Dims, plus one.
const DimsN Dims = 4

var _DimsValueMap = map[string]Dims{`X`: 0, `Y`: 1, `Z`: 2, `W`: 3}

var _DimsDescMap = map[Dims]string{0: ``, 1: ``, 2: ``, 3: ``}

var _DimsMap = map[Dims]string{0: `X`, 1: `Y`, 2: `Z`, 3: `W`}

// String returns the string representation of this Dims value.
func (i Dims) String() string { return enums.String(i, _DimsMap) }

// SetString sets the Dims value from its string representation,
// and returns an error if the string is invalid.
func (i *Dims) SetString(s string) error { return enums.SetString(i, s, _DimsValueMap, "Dims") }

// Int64 returns the Dims value as an int64.
func (i Dims) Int64() int64 { return int64(i) }

// SetInt64 sets the Dims value from an int64.
func (i *Dims) SetInt64(in int64) { *i = Dims(in) }

// Desc returns the description of the Dims value.
func (i Dims) Desc() string { return enums.Desc(i, _DimsDescMap) }

// DimsValues returns all possible values for the type Dims.
func DimsValues() []Dims { return _DimsValues }

// Values returns all possible values for the type Dims.
func (i Dims) Values() []enums.Enum { return enums.Values(_DimsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Dims) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Dims) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Dims") }

// Copyright 2021 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math32

import (
        "math"
)

// This is a fast version of the natural exponential function, for highly
// time-sensitive uses where precision is less important.

// based on: N. N. Schraudolph. "A fast, compact approximation of the exponential function." Neural Computation, 11(4), May 1999, pp.853-862.

// as discussed and elaborated here: https://stackoverflow.com/questions/47025373/fastest-implementation-of-the-natural-exponential-function-using-sse

/*
// FastExpBad is the basic original N.N. Schraudolph version
// which has bad error and is no faster than the better cubic
// and quadratic cases.
func FastExpBad(x float32) float32 {
        i := int32(1512775*x + 1072632447)
        if x <= -88.76731 { // this doesn't add anything and -exp is main use-case anyway
                return 0
        }
        return math.Float32frombits(uint32(i << 32))
}

// FastExp3 is less accurate and no faster than quartic version.

// FastExp3 is a cubic spline approximation to the Exp function, by N.N. Schraudolph
// It does not have any of the sanity checking of a standard method -- returns
// nonsense when arg is out of range.  Runs in .24ns vs. 8.7ns for 64bit which is faster
// than math32.Exp actually.
func FastExp3(x float32) float32 {
        // const (
        //         Overflow  = 88.43114
        //         Underflow = -88.76731
        //         NearZero  = 1.0 / (1 << 28) // 2**-28
        // )

        // special cases
        // switch {
        // these "sanity check" cases cost about 1 ns
        // case IsNaN(x) || IsInf(x, 1): /
        //         return x
        // case IsInf(x, -1):
        //         return 0
        // these cases cost about 4+ ns
        // case x >= Overflow:
        //         return Inf(1)
        // case x <= Underflow:
        //         return 0
        // case -NearZero < x && x < NearZero:
        //         return 1 + x
        // }
        if x <= -88.76731 { // this doesn't add anything and -exp is main use-case anyway
                return 0
        }
        i := int32(12102203*x) + 127*(1<<23)
        m := i >> 7 & 0xFFFF // copy mantissa
        i += ((((((((1277 * m) >> 14) + 14825) * m) >> 14) - 79749) * m) >> 11) - 626
        return math.Float32frombits(uint32(i))
}
*/

//gosl:start

// FastExp is a quartic spline approximation to the Exp function, by N.N. Schraudolph
// It does not have any of the sanity checking of a standard method -- returns
// nonsense when arg is out of range.  Runs in 2.23ns vs. 6.3ns for 64bit which is faster
// than math32.Exp actually.
func FastExp(x float32) float32 {
        if x <= -88.02969 { // this doesn't add anything and -exp is main use-case anyway
                return 0.0
        }
        i := int32(12102203*x) + int32(127)*(int32(1)<<23)
        m := (i >> 7) & 0xFFFF // copy mantissa
        i += (((((((((((3537 * m) >> 16) + 13668) * m) >> 18) + 15817) * m) >> 14) - 80470) * m) >> 11)
        return math.Float32frombits(uint32(i))
}

//gosl:end

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math32

import "golang.org/x/image/math/fixed"

// ToFixed converts a float32 value to a fixed.Int26_6
func ToFixed(x float32) fixed.Int26_6 {
        return fixed.Int26_6(x * 64)
}

// FromFixed converts a fixed.Int26_6 to a float32
func FromFixed(x fixed.Int26_6) float32 {
        const shift, mask = 6, 1<<6 - 1
        if x >= 0 {
                return float32(x>>shift) + float32(x&mask)/64
        }
        x = -x
        if x >= 0 {
                return -(float32(x>>shift) + float32(x&mask)/64)
        }
        return 0
}

// ToFixedPoint converts  float32 x,y values to a fixed.Point26_6
func ToFixedPoint(x, y float32) fixed.Point26_6 {
        return fixed.Point26_6{X: ToFixed(x), Y: ToFixed(y)}
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

// Frustum represents a frustum
type Frustum struct {
        Planes [6]Plane
}

// NewFrustumFromMatrix creates and returns a Frustum based on the provided matrix
func NewFrustumFromMatrix(m *Matrix4) *Frustum {
        f := new(Frustum)
        f.SetFromMatrix(m)
        return f
}

// NewFrustum returns a pointer to a new Frustum object made of 6 explicit planes
func NewFrustum(p0, p1, p2, p3, p4, p5 *Plane) *Frustum {
        f := new(Frustum)
        f.Set(p0, p1, p2, p3, p4, p5)
        return f
}

// Set sets the frustum's planes
func (f *Frustum) Set(p0, p1, p2, p3, p4, p5 *Plane) {
        if p0 != nil {
                f.Planes[0] = *p0
        }
        if p1 != nil {
                f.Planes[1] = *p1
        }
        if p2 != nil {
                f.Planes[2] = *p2
        }
        if p3 != nil {
                f.Planes[3] = *p3
        }
        if p4 != nil {
                f.Planes[4] = *p4
        }
        if p5 != nil {
                f.Planes[5] = *p5
        }
}

// SetFromMatrix sets the frustum's planes based on the specified Matrix4
func (f *Frustum) SetFromMatrix(m *Matrix4) {
        me0 := m[0]
        me1 := m[1]
        me2 := m[2]
        me3 := m[3]
        me4 := m[4]
        me5 := m[5]
        me6 := m[6]
        me7 := m[7]
        me8 := m[8]
        me9 := m[9]
        me10 := m[10]
        me11 := m[11]
        me12 := m[12]
        me13 := m[13]
        me14 := m[14]
        me15 := m[15]

        f.Planes[0].SetDims(me3-me0, me7-me4, me11-me8, me15-me12)
        f.Planes[1].SetDims(me3+me0, me7+me4, me11+me8, me15+me12)
        f.Planes[2].SetDims(me3+me1, me7+me5, me11+me9, me15+me13)
        f.Planes[3].SetDims(me3-me1, me7-me5, me11-me9, me15-me13)
        f.Planes[4].SetDims(me3-me2, me7-me6, me11-me10, me15-me14)
        f.Planes[5].SetDims(me3+me2, me7+me6, me11+me10, me15+me14)

        for i := 0; i < 6; i++ {
                f.Planes[i].Normalize()
        }
}

// IntersectsSphere determines whether the specified sphere is intersecting the frustum
func (f *Frustum) IntersectsSphere(sphere Sphere) bool {
        negRadius := -sphere.Radius
        for i := 0; i < 6; i++ {
                dist := f.Planes[i].DistanceToPoint(sphere.Center)
                if dist < negRadius {
                        return false
                }
        }
        return true
}

// IntersectsBox determines whether the specified box is intersecting the frustum
func (f *Frustum) IntersectsBox(box Box3) bool {
        var p1 Vector3
        var p2 Vector3

        for i := 0; i < 6; i++ {
                plane := &f.Planes[i]
                if plane.Norm.X > 0 {
                        p1.X = box.Min.X
                } else {
                        p1.X = box.Max.X
                }
                if plane.Norm.X > 0 {
                        p2.X = box.Max.X
                } else {
                        p2.X = box.Min.X
                }
                if plane.Norm.Y > 0 {
                        p1.Y = box.Min.Y
                } else {
                        p1.Y = box.Max.Y
                }
                if plane.Norm.Y > 0 {
                        p2.Y = box.Max.Y
                } else {
                        p2.Y = box.Min.Y
                }
                if plane.Norm.Z > 0 {
                        p1.Z = box.Min.Z
                } else {
                        p1.Z = box.Max.Z
                }
                if plane.Norm.Z > 0 {
                        p2.Z = box.Max.Z
                } else {
                        p2.Z = box.Min.Z
                }

                d1 := plane.DistanceToPoint(p1)
                d2 := plane.DistanceToPoint(p2)

                // if both outside plane, no intersection
                if d1 < 0 && d2 < 0 {
                        return false
                }
        }
        return true
}

// ContainsPoint determines whether the frustum contains the specified point
func (f *Frustum) ContainsPoint(point Vector3) bool {
        for i := 0; i < 6; i++ {
                if f.Planes[i].DistanceToPoint(point) < 0 {
                        return false
                }
        }
        return true
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math32

import (
        "image"
)

// Geom2DInt defines a geometry in 2D dots units (int) -- this is just a more
// convenient format than image.Rectangle for cases where the size and
// position are independently updated (e.g., Viewport)
type Geom2DInt struct {
        Pos  image.Point
        Size image.Point
}

// Bounds converts geom to equivalent image.Rectangle
func (gm *Geom2DInt) Bounds() image.Rectangle {
        return image.Rect(gm.Pos.X, gm.Pos.Y, gm.Pos.X+gm.Size.X, gm.Pos.Y+gm.Size.Y)
}

// SizeRect converts geom to rect version of size at 0 pos
func (gm *Geom2DInt) SizeRect() image.Rectangle {
        return image.Rect(0, 0, gm.Size.X, gm.Size.Y)
}

// SetRect sets values from image.Rectangle
func (gm *Geom2DInt) SetRect(r image.Rectangle) {
        gm.Pos = r.Min
        gm.Size = r.Size()
}

// FitGeomInWindow returns a position and size for a region (sub-window)
// within a larger window geom (pos and size) that fits entirely
// within that window to the extent possible,
// given an initial starting position and size.
// The position is first adjusted to try to fit the size, and then the size
// is adjusted to make it fit if it is still too big.
func FitGeomInWindow(stPos, stSz, winPos, winSz int) (pos, sz int) {
        pos = stPos
        sz = stSz
        // we go through two iterations: one to fix our position and one to fix
        // our size. this ensures that we adjust position and not size if we can,
        // but we still always end up with valid dimensions by using size as a fallback.
        if pos < winPos {
                pos = winPos
        }
        if pos+sz > winPos+winSz { // our max > window max
                pos = winPos + winSz - sz // window max - our size
        }
        if pos < winPos {
                pos = winPos
        }
        if pos+sz > winPos+winSz { // our max > window max
                sz = winSz + winPos - pos // window max - our min
        }
        return
}

// FitInWindow returns a position and size for a region (sub-window)
// within a larger window geom that fits entirely within that window to the
// extent possible, for the initial "ideal" starting position and size.
// The position is first adjusted to try to fit the size, and then the size
// is adjusted to make it fit if it is still too big.
func (gm *Geom2DInt) FitInWindow(win Geom2DInt) Geom2DInt {
        var fit Geom2DInt
        fit.Pos.X, fit.Size.X = FitGeomInWindow(gm.Pos.X, gm.Size.X, win.Pos.X, win.Size.X)
        fit.Pos.Y, fit.Size.Y = FitGeomInWindow(gm.Pos.Y, gm.Size.Y, win.Pos.Y, win.Size.Y)
        return fit
}

// Copyright 2024 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math32

// Line2 represents a 2D line segment defined by a start and an end point.
type Line2 struct {
        Start Vector2
        End   Vector2
}

// NewLine2 creates and returns a new Line2 with the
// specified start and end points.
func NewLine2(start, end Vector2) Line2 {
        return Line2{start, end}
}

// Set sets this line segment start and end points.
func (l *Line2) Set(start, end Vector2) {
        l.Start = start
        l.End = end
}

// Center calculates this line segment center point.
func (l *Line2) Center() Vector2 {
        return l.Start.Add(l.End).MulScalar(0.5)
}

// Delta calculates the vector from the start to end point of this line segment.
func (l *Line2) Delta() Vector2 {
        return l.End.Sub(l.Start)
}

// LengthSquared returns the square of the distance from the start point to the end point.
func (l *Line2) LengthSquared() float32 {
        return l.Start.DistanceToSquared(l.End)
}

// Length returns the length from the start point to the end point.
func (l *Line2) Length() float32 {
        return l.Start.DistanceTo(l.End)
}

// note: ClosestPointToPoint is adapted from https://math.stackexchange.com/questions/2193720/find-a-point-on-a-line-segment-which-is-the-closest-to-other-point-not-on-the-li

// ClosestPointToPoint returns the point along the line that is
// closest to the given point.
func (l *Line2) ClosestPointToPoint(point Vector2) Vector2 {
        v := l.Delta()
        u := point.Sub(l.Start)
        vu := v.Dot(u)
        ds := v.LengthSquared()
        t := vu / ds
        switch {
        case t <= 0:
                return l.Start
        case t >= 1:
                return l.End
        default:
                return l.Start.Add(v.MulScalar(t))
        }
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

// Line3 represents a 3D line segment defined by a start and an end point.
type Line3 struct {
        Start Vector3
        End   Vector3
}

// NewLine3 creates and returns a new Line3 with the
// specified start and end points.
func NewLine3(start, end Vector3) Line3 {
        return Line3{start, end}
}

// Set sets this line segment start and end points.
func (l *Line3) Set(start, end Vector3) {
        l.Start = start
        l.End = end
}

// Center calculates this line segment center point.
func (l *Line3) Center() Vector3 {
        return l.Start.Add(l.End).MulScalar(0.5)
}

// Delta calculates the vector from the start to end point of this line segment.
func (l *Line3) Delta() Vector3 {
        return l.End.Sub(l.Start)
}

// DistanceSquared returns the square of the distance from the start point to the end point.
func (l *Line3) DistanceSquared() float32 {
        return l.Start.DistanceToSquared(l.End)
}

// Dist returns the distance from the start point to the end point.
func (l *Line3) Dist() float32 {
        return l.Start.DistanceTo(l.End)
}

// MulMatrix4 returns specified matrix multiplied to this line segment start and end points.
func (l *Line3) MulMatrix4(mat *Matrix4) Line3 {
        return Line3{l.Start.MulMatrix4(mat), l.End.MulMatrix4(mat)}
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

// Package math32 is a float32 based vector, matrix, and math package
// for 2D & 3D graphics.
package math32

//go:generate core generate

import (
        "cmp"
        "math"
        "strconv"

        "github.com/chewxy/math32"
)

// These are mostly just wrappers around chewxy/math32, which has
// some optimized implementations.

// Mathematical constants.
const (
        E   = math.E
        Pi  = math.Pi
        Phi = math.Phi

        Sqrt2   = math.Sqrt2
        SqrtE   = math.SqrtE
        SqrtPi  = math.SqrtPi
        SqrtPhi = math.SqrtPhi

        Ln2    = math.Ln2
        Log2E  = math.Log2E
        Ln10   = math.Ln10
        Log10E = math.Log10E
)

// Floating-point limit values.
// Max is the largest finite value representable by the type.
// SmallestNonzero is the smallest positive, non-zero value representable by the type.
const (
        MaxFloat32             = math.MaxFloat32
        SmallestNonzeroFloat32 = math.SmallestNonzeroFloat32
)

const (
        // DegToRadFactor is the number of radians per degree.
        DegToRadFactor = Pi / 180

        // RadToDegFactor is the number of degrees per radian.
        RadToDegFactor = 180 / Pi
)

// Infinity is positive infinity.
var Infinity = float32(math.Inf(1))

// DegToRad converts a number from degrees to radians
func DegToRad(degrees float32) float32 {
        return degrees * DegToRadFactor
}

// RadToDeg converts a number from radians to degrees
func RadToDeg(radians float32) float32 {
        return radians * RadToDegFactor
}

// Abs returns the absolute value of x.
//
// Special cases are:
//
//        Abs(±Inf) = +Inf
//        Abs(NaN) = NaN
func Abs(x float32) float32 {
        return math32.Abs(x)
}

// Sign returns -1 if x < 0 and 1 otherwise.
func Sign(x float32) float32 {
        if x < 0 {
                return -1
        }
        return 1
}

// Acos returns the arccosine, in radians, of x.
//
// Special case is:
//
//        Acos(x) = NaN if x < -1 or x > 1
func Acos(x float32) float32 {
        return math32.Acos(x)
}

// Acosh returns the inverse hyperbolic cosine of x.
//
// Special cases are:
//
//        Acosh(+Inf) = +Inf
//        Acosh(x) = NaN if x < 1
//        Acosh(NaN) = NaN
func Acosh(x float32) float32 {
        return math32.Acosh(x)
}

// Asin returns the arcsine, in radians, of x.
//
// Special cases are:
//
//        Asin(±0) = ±0
//        Asin(x) = NaN if x < -1 or x > 1
func Asin(x float32) float32 {
        return math32.Asin(x)
}

// Asinh returns the inverse hyperbolic sine of x.
//
// Special cases are:
//
//        Asinh(±0) = ±0
//        Asinh(±Inf) = ±Inf
//        Asinh(NaN) = NaN
func Asinh(x float32) float32 {
        return math32.Asinh(x)
}

// Atan returns the arctangent, in radians, of x.
//
// Special cases are:
//
//        Atan(±0) = ±0
//        Atan(±Inf) = ±Pi/2
func Atan(x float32) float32 {
        return math32.Atan(x)
}

// Atan2 returns the arc tangent of y/x, using the signs of the two to determine the quadrant of the return value.
// Special cases are (in order):
//
//        Atan2(y, NaN) = NaN
//        Atan2(NaN, x) = NaN
//        Atan2(+0, x>=0) = +0
//        Atan2(-0, x>=0) = -0
//        Atan2(+0, x<=-0) = +Pi
//        Atan2(-0, x<=-0) = -Pi
//        Atan2(y>0, 0) = +Pi/2
//        Atan2(y<0, 0) = -Pi/2
//        Atan2(+Inf, +Inf) = +Pi/4
//        Atan2(-Inf, +Inf) = -Pi/4
//        Atan2(+Inf, -Inf) = 3Pi/4
//        Atan2(-Inf, -Inf) = -3Pi/4
//        Atan2(y, +Inf) = 0
//        Atan2(y>0, -Inf) = +Pi
//        Atan2(y<0, -Inf) = -Pi
//        Atan2(+Inf, x) = +Pi/2
//        Atan2(-Inf, x) = -Pi/2
func Atan2(y, x float32) float32 {
        return math32.Atan2(y, x)
}

// Atanh returns the inverse hyperbolic tangent of x.
//
// Special cases are:
//
//        Atanh(1) = +Inf
//        Atanh(±0) = ±0
//        Atanh(-1) = -Inf
//        Atanh(x) = NaN if x < -1 or x > 1
//        Atanh(NaN) = NaN
func Atanh(x float32) float32 {
        return math32.Atanh(x)
}

// Cbrt returns the cube root of x.
//
// Special cases are:
//
//        Cbrt(±0) = ±0
//        Cbrt(±Inf) = ±Inf
//        Cbrt(NaN) = NaN
func Cbrt(x float32) float32 {
        return math32.Cbrt(x)
}

// Ceil returns the least integer value greater than or equal to x.
//
// Special cases are:
//
//        Ceil(±0) = ±0
//        Ceil(±Inf) = ±Inf
//        Ceil(NaN) = NaN
func Ceil(x float32) float32 {
        return math32.Ceil(x)
}

// Copysign returns a value with the magnitude of f
// and the sign of sign.
func Copysign(f, sign float32) float32 {
        return math32.Copysign(f, sign)
}

// Cos returns the cosine of the radian argument x.
//
// Special cases are:
//
//        Cos(±Inf) = NaN
//        Cos(NaN) = NaN
func Cos(x float32) float32 {
        return math32.Cos(x)
}

// Cosh returns the hyperbolic cosine of x.
//
// Special cases are:
//
//        Cosh(±0) = 1
//        Cosh(±Inf) = +Inf
//        Cosh(NaN) = NaN
func Cosh(x float32) float32 {
        return math32.Cosh(x)
}

// Dim returns the maximum of x-y or 0.
//
// Special cases are:
//
//        Dim(+Inf, +Inf) = NaN
//        Dim(-Inf, -Inf) = NaN
//        Dim(x, NaN) = Dim(NaN, x) = NaN
func Dim(x, y float32) float32 {
        return math32.Dim(x, y)
}

// Erf returns the error function of x.
//
// Special cases are:
//
//        Erf(+Inf) = 1
//        Erf(-Inf) = -1
//        Erf(NaN) = NaN
func Erf(x float32) float32 {
        return math32.Erf(x)
}

// Erfc returns the complementary error function of x.
//
// Special cases are:
//
//        Erfc(+Inf) = 0
//        Erfc(-Inf) = 2
//        Erfc(NaN) = NaN
func Erfc(x float32) float32 {
        return math32.Erfc(x)
}

// Erfcinv returns the inverse of Erfc(x).
//
// Special cases are:
//
//        Erfcinv(0) = +Inf
//        Erfcinv(2) = -Inf
//        Erfcinv(x) = NaN if x < 0 or x > 2
//        Erfcinv(NaN) = NaN
func Erfcinv(x float32) float32 {
        return float32(math.Erfcinv(float64(x)))
}

// Erfinv returns the inverse error function of x.
//
// Special cases are:
//
//        Erfinv(1) = +Inf
//        Erfinv(-1) = -Inf
//        Erfinv(x) = NaN if x < -1 or x > 1
//        Erfinv(NaN) = NaN
func Erfinv(x float32) float32 {
        return float32(math.Erfinv(float64(x)))
}

// Exp returns e**x, the base-e exponential of x.
//
// Special cases are:
//
//        Exp(+Inf) = +Inf
//        Exp(NaN) = NaN
//
// Very large values overflow to 0 or +Inf.
// Very small values underflow to 1.
func Exp(x float32) float32 {
        return math32.Exp(x)
}

// Exp2 returns 2**x, the base-2 exponential of x.
//
// Special cases are the same as Exp.
func Exp2(x float32) float32 {
        return math32.Exp2(x)
}

// Expm1 returns e**x - 1, the base-e exponential of x minus 1.
// It is more accurate than Exp(x) - 1 when x is near zero.
//
// Special cases are:
//
//        Expm1(+Inf) = +Inf
//        Expm1(-Inf) = -1
//        Expm1(NaN) = NaN
//
// Very large values overflow to -1 or +Inf.
func Expm1(x float32) float32 {
        return math32.Expm1(x)
}

// FMA returns x * y + z, computed with only one rounding.
// (That is, FMA returns the fused multiply add of x, y, and z.)
func FMA(x, y, z float32) float32 {
        return float32(math.FMA(float64(x), float64(y), float64(z)))
}

// Floor returns the greatest integer value less than or equal to x.
//
// Special cases are:
//
//        Floor(±0) = ±0
//        Floor(±Inf) = ±Inf
//        Floor(NaN) = NaN
func Floor(x float32) float32 {
        return math32.Floor(x)
}

// Frexp breaks f into a normalized fraction
// and an integral power of two.
// It returns frac and exp satisfying f == frac × 2**exp,
// with the absolute value of frac in the interval [½, 1).
//
// Special cases are:
//
//        Frexp(±0) = ±0, 0
//        Frexp(±Inf) = ±Inf, 0
//        Frexp(NaN) = NaN, 0
func Frexp(f float32) (frac float32, exp int) {
        return math32.Frexp(f)
}

// Gamma returns the Gamma function of x.
//
// Special cases are:
//
//        Gamma(+Inf) = +Inf
//        Gamma(+0) = +Inf
//        Gamma(-0) = -Inf
//        Gamma(x) = NaN for integer x < 0
//        Gamma(-Inf) = NaN
//        Gamma(NaN) = NaN
func Gamma(x float32) float32 {
        return math32.Gamma(x)
}

// Hypot returns Sqrt(p*p + q*q), taking care to avoid
// unnecessary overflow and underflow.
//
// Special cases are:
//
//        Hypot(±Inf, q) = +Inf
//        Hypot(p, ±Inf) = +Inf
//        Hypot(NaN, q) = NaN
//        Hypot(p, NaN) = NaN
func Hypot(p, q float32) float32 {
        return math32.Hypot(p, q)
}

// Ilogb returns the binary exponent of x as an integer.
//
// Special cases are:
//
//        Ilogb(±Inf) = MaxInt32
//        Ilogb(0) = MinInt32
//        Ilogb(NaN) = MaxInt32
func Ilogb(x float32) float32 {
        return float32(math32.Ilogb(x))
}

// Inf returns positive infinity if sign >= 0, negative infinity if sign < 0.
func Inf(sign int) float32 {
        return math32.Inf(sign)
}

// IsInf reports whether f is an infinity, according to sign.
// If sign > 0, IsInf reports whether f is positive infinity.
// If sign < 0, IsInf reports whether f is negative infinity.
// If sign == 0, IsInf reports whether f is either infinity.
func IsInf(x float32, sign int) bool {
        return math32.IsInf(x, sign)
}

// IsNaN reports whether f is an IEEE 754 “not-a-number” value.
func IsNaN(x float32) bool {
        return math32.IsNaN(x)
}

// J0 returns the order-zero Bessel function of the first kind.
//
// Special cases are:
//
//        J0(±Inf) = 0
//        J0(0) = 1
//        J0(NaN) = NaN
func J0(x float32) float32 {
        return math32.J0(x)
}

// J1 returns the order-one Bessel function of the first kind.
//
// Special cases are:
//
//        J1(±Inf) = 0
//        J1(NaN) = NaN
func J1(x float32) float32 {
        return math32.J1(x)
}

// Jn returns the order-n Bessel function of the first kind.
//
// Special cases are:
//
//        Jn(n, ±Inf) = 0
//        Jn(n, NaN) = NaN
func Jn(n int, x float32) float32 {
        return math32.Jn(n, x)
}

// Ldexp is the inverse of Frexp.
// It returns frac × 2**exp.
//
// Special cases are:
//
//        Ldexp(±0, exp) = ±0
//        Ldexp(±Inf, exp) = ±Inf
//        Ldexp(NaN, exp) = NaN
func Ldexp(frac float32, exp int) float32 {
        return math32.Ldexp(frac, exp)
}

// Lerp returns the linear interpolation between start and stop in proportion to amount
func Lerp(start, stop, amount float32) float32 {
        return (1-amount)*start + amount*stop
}

// Lgamma returns the natural logarithm and sign (-1 or +1) of Gamma(x).
//
// Special cases are:
//
//        Lgamma(+Inf) = +Inf
//        Lgamma(0) = +Inf
//        Lgamma(-integer) = +Inf
//        Lgamma(-Inf) = -Inf
//        Lgamma(NaN) = NaN
func Lgamma(x float32) (lgamma float32, sign int) {
        return math32.Lgamma(x)
}

// Log returns the natural logarithm of x.
//
// Special cases are:
//
//        Log(+Inf) = +Inf
//        Log(0) = -Inf
//        Log(x < 0) = NaN
//        Log(NaN) = NaN
func Log(x float32) float32 {
        return math32.Log(x)
}

// Log10 returns the decimal logarithm of x.
// The special cases are the same as for Log.
func Log10(x float32) float32 {
        return math32.Log10(x)
}

// Log1p returns the natural logarithm of 1 plus its argument x.
// It is more accurate than Log(1 + x) when x is near zero.
//
// Special cases are:
//
//        Log1p(+Inf) = +Inf
//        Log1p(±0) = ±0
//        Log1p(-1) = -Inf
//        Log1p(x < -1) = NaN
//        Log1p(NaN) = NaN
func Log1p(x float32) float32 {
        return math32.Log1p(x)
}

// Log2 returns the binary logarithm of x.
// The special cases are the same as for Log.
func Log2(x float32) float32 {
        return math32.Log2(x)
}

// Logb returns the binary exponent of x.
//
// Special cases are:
//
//        Logb(±Inf) = +Inf
//        Logb(0) = -Inf
//        Logb(NaN) = NaN
func Logb(x float32) float32 {
        return math32.Logb(x)
}

// TODO(kai): should we use builtin max and min?

// Max returns the larger of x or y.
//
// Special cases are:
//
//        Max(x, +Inf) = Max(+Inf, x) = +Inf
//        Max(x, NaN) = Max(NaN, x) = NaN
//        Max(+0, ±0) = Max(±0, +0) = +0
//        Max(-0, -0) = -0
//
// Note that this differs from the built-in function max when called
// with NaN and +Inf.
func Max(x, y float32) float32 {
        return math32.Max(x, y)
}

// Min returns the smaller of x or y.
//
// Special cases are:
//
//        Min(x, -Inf) = Min(-Inf, x) = -Inf
//        Min(x, NaN) = Min(NaN, x) = NaN
//        Min(-0, ±0) = Min(±0, -0) = -0
//
// Note that this differs from the built-in function min when called
// with NaN and -Inf.
func Min(x, y float32) float32 {
        return math32.Min(x, y)
}

// Mod returns the floating-point remainder of x/y.
// The magnitude of the result is less than y and its
// sign agrees with that of x.
//
// Special cases are:
//
//        Mod(±Inf, y) = NaN
//        Mod(NaN, y) = NaN
//        Mod(x, 0) = NaN
//        Mod(x, ±Inf) = x
//        Mod(x, NaN) = NaN
func Mod(x, y float32) float32 {
        return math32.Mod(x, y)
}

// Modf returns integer and fractional floating-point numbers
// that sum to f. Both values have the same sign as f.
//
// Special cases are:
//
//        Modf(±Inf) = ±Inf, NaN
//        Modf(NaN) = NaN, NaN
func Modf(f float32) (it float32, frac float32) {
        return math32.Modf(f)
}

// NaN returns an IEEE 754 “not-a-number” value.
func NaN() float32 {
        return math32.NaN()
}

// Nextafter returns the next representable float32 value after x towards y.
//
// Special cases are:
//
//        Nextafter32(x, x)   = x
//        Nextafter32(NaN, y) = NaN
//        Nextafter32(x, NaN) = NaN
func Nextafter(x, y float32) float32 {
        return math32.Nextafter(x, y)
}

// Pow returns x**y, the base-x exponential of y.
//
// Special cases are (in order):
//
//        Pow(x, ±0) = 1 for any x
//        Pow(1, y) = 1 for any y
//        Pow(x, 1) = x for any x
//        Pow(NaN, y) = NaN
//        Pow(x, NaN) = NaN
//        Pow(±0, y) = ±Inf for y an odd integer < 0
//        Pow(±0, -Inf) = +Inf
//        Pow(±0, +Inf) = +0
//        Pow(±0, y) = +Inf for finite y < 0 and not an odd integer
//        Pow(±0, y) = ±0 for y an odd integer > 0
//        Pow(±0, y) = +0 for finite y > 0 and not an odd integer
//        Pow(-1, ±Inf) = 1
//        Pow(x, +Inf) = +Inf for |x| > 1
//        Pow(x, -Inf) = +0 for |x| > 1
//        Pow(x, +Inf) = +0 for |x| < 1
//        Pow(x, -Inf) = +Inf for |x| < 1
//        Pow(+Inf, y) = +Inf for y > 0
//        Pow(+Inf, y) = +0 for y < 0
//        Pow(-Inf, y) = Pow(-0, -y)
//        Pow(x, y) = NaN for finite x < 0 and finite non-integer y
func Pow(x, y float32) float32 {
        return math32.Pow(x, y)
}

// Pow10 returns 10**n, the base-10 exponential of n.
//
// Special cases are:
//
//        Pow10(n) =    0 for n < -323
//        Pow10(n) = +Inf for n > 308
func Pow10(n int) float32 {
        return math32.Pow10(n)
}

// Remainder returns the IEEE 754 floating-point remainder of x/y.
//
// Special cases are:
//
//        Remainder(±Inf, y) = NaN
//        Remainder(NaN, y) = NaN
//        Remainder(x, 0) = NaN
//        Remainder(x, ±Inf) = x
//        Remainder(x, NaN) = NaN
func Remainder(x, y float32) float32 {
        return math32.Remainder(x, y)
}

// Round returns the nearest integer, rounding half away from zero.
//
// Special cases are:
//
//        Round(±0) = ±0
//        Round(±Inf) = ±Inf
//        Round(NaN) = NaN
func Round(x float32) float32 {
        return math32.Round(x)
}

// RoundToEven returns the nearest integer, rounding ties to even.
//
// Special cases are:
//
//        RoundToEven(±0) = ±0
//        RoundToEven(±Inf) = ±Inf
//        RoundToEven(NaN) = NaN
func RoundToEven(x float32) float32 {
        return float32(math.RoundToEven(float64(x)))
}

// Signbit returns true if x is negative or negative zero.
func Signbit(x float32) bool {
        return math32.Signbit(x)
}

// Sin returns the sine of the radian argument x.
//
// Special cases are:
//
//        Sin(±0) = ±0
//        Sin(±Inf) = NaN
//        Sin(NaN) = NaN
func Sin(x float32) float32 {
        return math32.Sin(x)
}

// Sincos returns Sin(x), Cos(x).
//
// Special cases are:
//
//        Sincos(±0) = ±0, 1
//        Sincos(±Inf) = NaN, NaN
//        Sincos(NaN) = NaN, NaN
func Sincos(x float32) (sin, cos float32) {
        return math32.Sincos(x)
}

// Sinh returns the hyperbolic sine of x.
//
// Special cases are:
//
//        Sinh(±0) = ±0
//        Sinh(±Inf) = ±Inf
//        Sinh(NaN) = NaN
func Sinh(x float32) float32 {
        return math32.Sinh(x)
}

// Sqrt returns the square root of x.
//
// Special cases are:
//
//        Sqrt(+Inf) = +Inf
//        Sqrt(±0) = ±0
//        Sqrt(x < 0) = NaN
//        Sqrt(NaN) = NaN
func Sqrt(x float32) float32 {
        return math32.Sqrt(x)
}

// Tan returns the tangent of the radian argument x.
//
// Special cases are:
//
//        Tan(±0) = ±0
//        Tan(±Inf) = NaN
//        Tan(NaN) = NaN
func Tan(x float32) float32 {
        return math32.Tan(x)
}

// Tanh returns the hyperbolic tangent of x.
//
// Special cases are:
//
//        Tanh(±0) = ±0
//        Tanh(±Inf) = ±1
//        Tanh(NaN) = NaN
func Tanh(x float32) float32 {
        return math32.Tanh(x)
}

// Trunc returns the integer value of x.
//
// Special cases are:
//
//        Trunc(±0) = ±0
//        Trunc(±Inf) = ±Inf
//        Trunc(NaN) = NaN
func Trunc(x float32) float32 {
        return math32.Trunc(x)
}

// Y0 returns the order-zero Bessel function of the second kind.
//
// Special cases are:
//
//        Y0(+Inf) = 0
//        Y0(0) = -Inf
//        Y0(x < 0) = NaN
//        Y0(NaN) = NaN
func Y0(x float32) float32 {
        return math32.Y0(x)
}

// Y1 returns the order-one Bessel function of the second kind.
//
// Special cases are:
//
//        Y1(+Inf) = 0
//        Y1(0) = -Inf
//        Y1(x < 0) = NaN
//        Y1(NaN) = NaN
func Y1(x float32) float32 {
        return math32.Y1(x)
}

// Yn returns the order-n Bessel function of the second kind.
//
// Special cases are:
//
//        Yn(n, +Inf) = 0
//        Yn(n ≥ 0, 0) = -Inf
//        Yn(n < 0, 0) = +Inf if n is odd, -Inf if n is even
//        Yn(n, x < 0) = NaN
//        Yn(n, NaN) = NaN
func Yn(n int, x float32) float32 {
        return math32.Yn(n, x)
}

//////////////////////////////////////////////////////////////
// Special additions to math. functions

// Clamp clamps x to the provided closed interval [a, b]
func Clamp[T cmp.Ordered](x, a, b T) T {
        if x < a {
                return a
        }
        if x > b {
                return b
        }
        return x
}

// MinPos returns the minimum of the two values, excluding any that are <= 0
func MinPos(a, b float32) float32 {
        if a > 0 && b > 0 {
                return Min(a, b)
        } else if a > 0 {
                return a
        } else if b > 0 {
                return b
        }
        return a
}

// MaxPos returns the minimum of the two values, excluding any that are <= 0
func MaxPos(a, b float32) float32 {
        if a > 0 && b > 0 {
                return Max(a, b)
        } else if a > 0 {
                return a
        } else if b > 0 {
                return b
        }
        return a
}

// IntMultiple returns the interger multiple of mod closest to given value:
// Round(val / mod) * mod
func IntMultiple(val, mod float32) float32 {
        return Round(val/mod) * mod
}

// IntMultipleGE returns the interger multiple of mod >= given value:
// Ceil(val / mod) * mod
func IntMultipleGE(val, mod float32) float32 {
        return Ceil(val/mod) * mod
}

// TODO: maybe make these functions faster at some point

// Truncate rounds a float32 number to the given level of precision,
// which the number of significant digits to include in the result.
func Truncate(val float32, prec int) float32 {
        frep := strconv.FormatFloat(float64(val), 'g', prec, 32)
        tval, _ := strconv.ParseFloat(frep, 32)
        return float32(tval)
        // note: this unfortunately does not work.  also Pow(prec) is not likely to be that much faster ;)
        // pow := Pow(10, float32(prec))
        // return Round(val*pow) / pow
}

// Truncate64 rounds a float64 number to the given level of precision,
// which the number of significant digits to include in the result.
func Truncate64(val float64, prec int) float64 {
        frep := strconv.FormatFloat(val, 'g', prec, 64)
        val, _ = strconv.ParseFloat(frep, 64)
        return val
        // note: this unfortunately does not work.  also Pow(prec) is not likely to be that much faster ;)
        // pow := math.Pow(10, float64(prec))
        // return math.Round(val*pow) / pow
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math32

import (
        "fmt"
        "log"
        "strconv"
        "strings"
        "unicode"

        "cogentcore.org/core/base/errors"
        "golang.org/x/image/math/fixed"
)

/*
This is heavily modified from: https://github.com/fogleman/gg

Copyright (C) 2016 Michael Fogleman

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

// Matrix2 is a 3x2 matrix.
// [XX YX]
// [XY YY]
// [X0 Y0]
type Matrix2 struct {
        XX, YX, XY, YY, X0, Y0 float32
}

// Identity2 returns a new identity [Matrix2] matrix.
func Identity2() Matrix2 {
        return Matrix2{
                1, 0,
                0, 1,
                0, 0,
        }
}

func (m Matrix2) IsIdentity() bool {
        return m.XX == 1 && m.YX == 0 && m.XY == 0 && m.YY == 1 && m.X0 == 0 && m.Y0 == 0
}

// Translate2D returns a Matrix2 2D matrix with given translations
func Translate2D(x, y float32) Matrix2 {
        return Matrix2{
                1, 0,
                0, 1,
                x, y,
        }
}

// Scale2D returns a Matrix2 2D matrix with given scaling factors
func Scale2D(x, y float32) Matrix2 {
        return Matrix2{
                x, 0,
                0, y,
                0, 0,
        }
}

// Rotate2D returns a Matrix2 2D matrix with given rotation, specified in radians.
// This uses the standard graphics convention where increasing Y goes _down_ instead
// of up, in contrast with the mathematical coordinate system where Y is up.
func Rotate2D(angle float32) Matrix2 {
        s, c := Sincos(angle)
        return Matrix2{
                c, s,
                -s, c,
                0, 0,
        }
}

// Rotate2DAround returns a Matrix2 2D matrix with given rotation, specified in radians,
// around given offset point that is translated to and from.
// This uses the standard graphics convention where increasing Y goes _down_ instead
// of up, in contrast with the mathematical coordinate system where Y is up.
func Rotate2DAround(angle float32, pos Vector2) Matrix2 {
        return Identity2().Translate(pos.X, pos.Y).Rotate(angle).Translate(-pos.X, -pos.Y)
}

// Shear2D returns a Matrix2 2D matrix with given shearing
func Shear2D(x, y float32) Matrix2 {
        return Matrix2{
                1, y,
                x, 1,
                0, 0,
        }
}

// Skew2D returns a Matrix2 2D matrix with given skewing
func Skew2D(x, y float32) Matrix2 {
        return Matrix2{
                1, Tan(y),
                Tan(x), 1,
                0, 0,
        }
}

// Mul returns a*b
func (a Matrix2) Mul(b Matrix2) Matrix2 {
        return Matrix2{
                XX: a.XX*b.XX + a.XY*b.YX,
                YX: a.YX*b.XX + a.YY*b.YX,
                XY: a.XX*b.XY + a.XY*b.YY,
                YY: a.YX*b.XY + a.YY*b.YY,
                X0: a.XX*b.X0 + a.XY*b.Y0 + a.X0,
                Y0: a.YX*b.X0 + a.YY*b.Y0 + a.Y0,
        }
}

// SetMul sets a to a*b
func (a *Matrix2) SetMul(b Matrix2) {
        *a = a.Mul(b)
}

// MulVector2AsVector multiplies the Vector2 as a vector without adding translations.
// This is for directional vectors and not points.
func (a Matrix2) MulVector2AsVector(v Vector2) Vector2 {
        tx := a.XX*v.X + a.XY*v.Y
        ty := a.YX*v.X + a.YY*v.Y
        return Vec2(tx, ty)
}

// MulVector2AsPoint multiplies the Vector2 as a point, including adding translations.
func (a Matrix2) MulVector2AsPoint(v Vector2) Vector2 {
        tx := a.XX*v.X + a.XY*v.Y + a.X0
        ty := a.YX*v.X + a.YY*v.Y + a.Y0
        return Vec2(tx, ty)
}

// MulVector2AsPointCenter multiplies the Vector2 as a point relative to given center-point
// including adding translations.
func (a Matrix2) MulVector2AsPointCenter(v, ctr Vector2) Vector2 {
        rel := v.Sub(ctr)
        tx := ctr.X + a.XX*rel.X + a.XY*rel.Y + a.X0
        ty := ctr.Y + a.YX*rel.X + a.YY*rel.Y + a.Y0
        return Vec2(tx, ty)
}

// MulCenter multiplies the Matrix2, first subtracting given translation center point
// from the translation components, and then adding it back in.
func (a Matrix2) MulCenter(b Matrix2, ctr Vector2) Matrix2 {
        a.X0 -= ctr.X
        a.Y0 -= ctr.Y
        rv := a.Mul(b)
        rv.X0 += ctr.X
        rv.Y0 += ctr.Y
        return rv
}

// SetMulCenter sets the matrix to the result of [Matrix2.MulCenter].
func (a *Matrix2) SetMulCenter(b Matrix2, ctr Vector2) {
        *a = a.MulCenter(b, ctr)
}

// MulFixedAsPoint multiplies the fixed point as a point, including adding translations.
func (a Matrix2) MulFixedAsPoint(fp fixed.Point26_6) fixed.Point26_6 {
        x := fixed.Int26_6((float32(fp.X)*a.XX + float32(fp.Y)*a.XY) + a.X0*32)
        y := fixed.Int26_6((float32(fp.X)*a.YX + float32(fp.Y)*a.YY) + a.Y0*32)
        return fixed.Point26_6{x, y}
}

func (a Matrix2) Translate(x, y float32) Matrix2 {
        return a.Mul(Translate2D(x, y))
}

func (a Matrix2) Scale(x, y float32) Matrix2 {
        return a.Mul(Scale2D(x, y))
}

// ScaleAbout adds a scaling transformation about (x,y) in sx and sy.
// When scale is negative it will flip those axes.
func (m Matrix2) ScaleAbout(sx, sy, x, y float32) Matrix2 {
        return m.Translate(x, y).Scale(sx, sy).Translate(-x, -y)
}

func (a Matrix2) Rotate(angle float32) Matrix2 {
        return a.Mul(Rotate2D(angle))
}

// RotateAbout adds a rotation transformation about (x,y)
// with rot in radians counter clockwise.
func (m Matrix2) RotateAbout(rot, x, y float32) Matrix2 {
        return m.Translate(x, y).Rotate(rot).Translate(-x, -y)
}

func (a Matrix2) Shear(x, y float32) Matrix2 {
        return a.Mul(Shear2D(x, y))
}

func (a Matrix2) Skew(x, y float32) Matrix2 {
        return a.Mul(Skew2D(x, y))
}

// ExtractRot does a simple extraction of the rotation matrix for
// a single rotation. See [Matrix2.Decompose] for two rotations.
func (a Matrix2) ExtractRot() float32 {
        return Atan2(-a.XY, a.XX)
}

// ExtractXYScale extracts the X and Y scale factors after undoing any
// rotation present -- i.e., in the original X, Y coordinates
func (a Matrix2) ExtractScale() (scx, scy float32) {
        // rot := a.ExtractRot()
        // tx := a.Rotate(-rot)
        // scxv := tx.MulVector2AsVector(Vec2(1, 0))
        // scyv := tx.MulVector2AsVector(Vec2(0, 1))
        // return scxv.X, scyv.Y
        _, _, _, scx, scy, _ = a.Decompose()
        return
}

// Pos returns the translation values, X0, Y0
func (a Matrix2) Pos() (tx, ty float32) {
        return a.X0, a.Y0
}

// Decompose extracts the translation, rotation, scaling and rotation components
// (applied in the reverse order) as (tx, ty, theta, sx, sy, phi) with rotation
// counter clockwise. This corresponds to:
// Identity.Translate(tx, ty).Rotate(phi).Scale(sx, sy).Rotate(theta).
func (m Matrix2) Decompose() (tx, ty, phi, sx, sy, theta float32) {
        // see https://math.stackexchange.com/questions/861674/decompose-a-2d-arbitrary-transform-into-only-scaling-and-rotation
        E := (m.XX + m.YY) / 2.0
        F := (m.XX - m.YY) / 2.0
        G := (m.YX + m.XY) / 2.0
        H := (m.YX - m.XY) / 2.0

        Q, R := Sqrt(E*E+H*H), Sqrt(F*F+G*G)
        sx, sy = Q+R, Q-R

        a1, a2 := Atan2(G, F), Atan2(H, E)
        // note: our rotation matrix is inverted so we reverse the sign on these.
        theta = -(a2 - a1) / 2.0
        phi = -(a2 + a1) / 2.0
        if sx == 1 && sy == 1 {
                theta += phi
                phi = 0
        }
        tx = m.X0
        ty = m.Y0
        return
}

// Transpose returns the transpose of the matrix
func (a Matrix2) Transpose() Matrix2 {
        a.XY, a.YX = a.YX, a.XY
        return a
}

// Det returns the determinant of the matrix
func (a Matrix2) Det() float32 {
        return a.XX*a.YY - a.XY*a.YX // ad - bc
}

// Inverse returns inverse of matrix, for inverting transforms
func (a Matrix2) Inverse() Matrix2 {
        // homogenous rep, rc indexes, mapping into Matrix3 code
        // XX YX X0   n11 n12 n13    a b x
        // XY YY Y0   n21 n22 n23    c d y
        // 0  0  1    n31 n32 n33    0 0 1

        // t11 := a.YY
        // t12 := -a.YX
        // t13 := a.Y0*a.YX - a.YY*a.X0
        det := a.Det()
        detInv := 1 / det

        b := Matrix2{}
        b.XX = a.YY * detInv  // a = d
        b.XY = -a.XY * detInv // c = -c
        b.YX = -a.YX * detInv // b = -b
        b.YY = a.XX * detInv  // d = a
        b.X0 = (a.Y0*a.XY - a.YY*a.X0) * detInv
        b.Y0 = (a.X0*a.YX - a.XX*a.Y0) * detInv
        return b
}

// mapping onto canvas, [col][row] matrix:
// m[0][0] = XX
// m[1][0] = YX
// m[0][1] = XY
// m[1][1] = YY
// m[0][2] = X0
// m[1][2] = Y0

// Eigen returns the matrix eigenvalues and eigenvectors.
// The first eigenvalue is related to the first eigenvector,
// and so for the second pair. Eigenvectors are normalized.
func (m Matrix2) Eigen() (float32, float32, Vector2, Vector2) {
        if Abs(m.YX) < 1.0e-7 && Abs(m.XY) < 1.0e-7 {
                return m.XX, m.YY, Vector2{1.0, 0.0}, Vector2{0.0, 1.0}
        }

        lambda1, lambda2 := solveQuadraticFormula(1.0, -m.XX-m.YY, m.Det())
        if IsNaN(lambda1) && IsNaN(lambda2) {
                // either m.XX or m.YY is NaN or the the affine matrix has no real eigenvalues
                return lambda1, lambda2, Vector2{}, Vector2{}
        } else if IsNaN(lambda2) {
                lambda2 = lambda1
        }

        // see http://www.math.harvard.edu/archive/21b_fall_04/exhibits/2dmatrices/index.html
        var v1, v2 Vector2
        if m.YX != 0 {
                v1 = Vector2{lambda1 - m.YY, m.YX}.Normal()
                v2 = Vector2{lambda2 - m.YY, m.YX}.Normal()
        } else if m.XY != 0 {
                v1 = Vector2{m.XY, lambda1 - m.XX}.Normal()
                v2 = Vector2{m.XY, lambda2 - m.XX}.Normal()
        }
        return lambda1, lambda2, v1, v2
}

// Numerically stable quadratic formula, lowest root is returned first,
// see https://math.stackexchange.com/a/2007723
func solveQuadraticFormula(a, b, c float32) (float32, float32) {
        if a == 0 {
                if b == 0 {
                        if c == 0 {
                                // all terms disappear, all x satisfy the solution
                                return 0.0, NaN()
                        }
                        // linear term disappears, no solutions
                        return NaN(), NaN()
                }
                // quadratic term disappears, solve linear equation
                return -c / b, NaN()
        }

        if c == 0 {
                // no constant term, one solution at zero and one from solving linearly
                if b == 0 {
                        return 0.0, NaN()
                }
                return 0.0, -b / a
        }

        discriminant := b*b - 4.0*a*c
        if discriminant < 0.0 {
                return NaN(), NaN()
        } else if discriminant == 0 {
                return -b / (2.0 * a), NaN()
        }

        // Avoid catastrophic cancellation, which occurs when we subtract
        // two nearly equal numbers and causes a large error.
        // This can be the case when 4*a*c is small so that sqrt(discriminant) -> b,
        // and the sign of b and in front of the radical are the same.
        // Instead, we calculate x where b and the radical have different signs,
        // and then use this result in the analytical equivalent of the formula,
        // called the Citardauq Formula.
        q := Sqrt(discriminant)
        if b < 0.0 {
                // apply sign of b
                q = -q
        }
        x1 := -(b + q) / (2.0 * a)
        x2 := c / (a * x1)
        if x2 < x1 {
                x1, x2 = x2, x1
        }
        return x1, x2
}

// ParseFloat32 logs any strconv.ParseFloat errors
func ParseFloat32(pstr string) (float32, error) {
        r, err := strconv.ParseFloat(pstr, 32)
        if err != nil {
                log.Printf("core.ParseFloat32: error parsing float32 number from: %v, %v\n", pstr, err)
                return float32(0.0), err
        }
        return float32(r), nil
}

// ParseAngle32 returns radians angle from string that can specify units (deg,
// grad, rad) -- deg is assumed if not specified
func ParseAngle32(pstr string) (float32, error) {
        units := "deg"
        lstr := strings.ToLower(pstr)
        if strings.Contains(lstr, "deg") {
                units = "deg"
                lstr = strings.TrimSuffix(lstr, "deg")
        } else if strings.Contains(lstr, "grad") {
                units = "grad"
                lstr = strings.TrimSuffix(lstr, "grad")
        } else if strings.Contains(lstr, "rad") {
                units = "rad"
                lstr = strings.TrimSuffix(lstr, "rad")
        }
        r, err := strconv.ParseFloat(lstr, 32)
        if err != nil {
                log.Printf("core.ParseAngle32: error parsing float32 number from: %v, %v\n", lstr, err)
                return float32(0.0), err
        }
        switch units {
        case "deg":
                return DegToRad(float32(r)), nil
        case "grad":
                return float32(r) * Pi / 200, nil
        case "rad":
                return float32(r), nil
        }
        return float32(r), nil
}

// ReadPoints reads a set of floating point values from a SVG format number
// string -- returns a slice or nil if there was an error
func ReadPoints(pstr string) []float32 {
        lastIndex := -1
        var pts []float32
        lr := ' '
        for i, r := range pstr {
                if !unicode.IsNumber(r) && r != '.' && !(r == '-' && lr == 'e') && r != 'e' {
                        if lastIndex != -1 {
                                s := pstr[lastIndex:i]
                                p, err := ParseFloat32(s)
                                if err != nil {
                                        return nil
                                }
                                pts = append(pts, p)
                        }
                        if r == '-' {
                                lastIndex = i
                        } else {
                                lastIndex = -1
                        }
                } else if lastIndex == -1 {
                        lastIndex = i
                }
                lr = r
        }
        if lastIndex != -1 && lastIndex != len(pstr) {
                s := pstr[lastIndex:]
                p, err := ParseFloat32(s)
                if err != nil {
                        return nil
                }
                pts = append(pts, p)
        }
        return pts
}

// PointsCheckN checks the number of points read and emits an error if not equal to n
func PointsCheckN(pts []float32, n int, errmsg string) error {
        if len(pts) != n {
                return fmt.Errorf("%v incorrect number of points: %v != %v", errmsg, len(pts), n)
        }
        return nil
}

// SetString processes the standard SVG-style transform strings
func (a *Matrix2) SetString(str string) error {
        errmsg := "math32.Matrix2.SetString:"
        str = strings.ToLower(strings.TrimSpace(str))
        *a = Identity2()
        if str == "none" {
                *a = Identity2()
                return nil
        }
        // could have multiple transforms
        for {
                pidx := strings.IndexByte(str, '(')
                if pidx < 0 {
                        err := fmt.Errorf("%s no params for transform: %v", errmsg, str)
                        return errors.Log(err)
                }
                cmd := str[:pidx]
                vals := str[pidx+1:]
                nxt := ""
                eidx := strings.IndexByte(vals, ')')
                if eidx > 0 {
                        nxt = strings.TrimSpace(vals[eidx+1:])
                        if strings.HasPrefix(nxt, ";") {
                                nxt = strings.TrimSpace(strings.TrimPrefix(nxt, ";"))
                        }
                        vals = vals[:eidx]
                }
                pts := ReadPoints(vals)
                switch cmd {
                case "matrix":
                        if err := PointsCheckN(pts, 6, errmsg); err != nil {
                                errors.Log(err)
                        } else {
                                *a = Matrix2{pts[0], pts[1], pts[2], pts[3], pts[4], pts[5]}
                        }
                case "translate":
                        if len(pts) == 1 {
                                *a = a.Translate(pts[0], 0)
                        } else if len(pts) == 2 {
                                *a = a.Translate(pts[0], pts[1])
                        } else {
                                errors.Log(PointsCheckN(pts, 2, errmsg))
                        }
                case "translatex":
                        if err := PointsCheckN(pts, 1, errmsg); err != nil {
                                errors.Log(err)
                        } else {
                                *a = a.Translate(pts[0], 0)
                        }
                case "translatey":
                        if err := PointsCheckN(pts, 1, errmsg); err != nil {
                                errors.Log(err)
                        } else {
                                *a = a.Translate(0, pts[0])
                        }
                case "scale":
                        if len(pts) == 1 {
                                *a = a.Scale(pts[0], pts[0])
                        } else if len(pts) == 2 {
                                *a = a.Scale(pts[0], pts[1])
                        } else {
                                err := fmt.Errorf("%v incorrect number of points: 2 != %v", errmsg, len(pts))
                                errors.Log(err)
                        }
                case "scalex":
                        if err := PointsCheckN(pts, 1, errmsg); err != nil {
                                errors.Log(err)
                        } else {
                                *a = a.Scale(pts[0], 1)
                        }
                case "scaley":
                        if err := PointsCheckN(pts, 1, errmsg); err != nil {
                                errors.Log(err)
                        } else {
                                *a = a.Scale(1, pts[0])
                        }
                case "rotate":
                        ang := DegToRad(pts[0]) // always in degrees in this form
                        if len(pts) == 3 {
                                *a = a.Translate(pts[1], pts[2]).Rotate(ang).Translate(-pts[1], -pts[2])
                        } else if len(pts) == 1 {
                                *a = a.Rotate(ang)
                        } else {
                                errors.Log(PointsCheckN(pts, 1, errmsg))
                        }
                case "skew":
                        if err := PointsCheckN(pts, 2, errmsg); err != nil {
                                errors.Log(err)
                        } else {
                                *a = a.Skew(pts[0], pts[1])
                        }
                case "skewx":
                        if err := PointsCheckN(pts, 1, errmsg); err != nil {
                                errors.Log(err)
                        } else {
                                *a = a.Skew(pts[0], 0)
                        }
                case "skewy":
                        if err := PointsCheckN(pts, 1, errmsg); err != nil {
                                errors.Log(err)
                        } else {
                                *a = a.Skew(0, pts[0])
                        }
                default:
                        return fmt.Errorf("unknown command %q", cmd)
                }
                if nxt == "" {
                        break
                }
                if !strings.Contains(nxt, "(") {
                        break
                }
                str = nxt
        }
        return nil
}

// String returns the XML-based string representation of the transform
func (a *Matrix2) String() string {
        if a.IsIdentity() {
                return "none"
        }
        if a.YX == 0 && a.XY == 0 { // no rotation, emit scale and translate
                str := ""
                if a.X0 != 0 || a.Y0 != 0 {
                        str += fmt.Sprintf("translate(%g,%g)", a.X0, a.Y0)
                }
                if a.XX != 1 || a.YY != 1 {
                        if str != "" {
                                str += " "
                        }
                        str += fmt.Sprintf("scale(%g,%g)", a.XX, a.YY)
                }
                return str
        }
        // just report the whole matrix
        return fmt.Sprintf("matrix(%g,%g,%g,%g,%g,%g)", a.XX, a.YX, a.XY, a.YY, a.X0, a.Y0)
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import "errors"

// Matrix3 is 3x3 matrix organized internally as column matrix.
type Matrix3 [9]float32

// Identity3 returns a new identity [Matrix3] matrix.
func Identity3() Matrix3 {
        m := Matrix3{}
        m.SetIdentity()
        return m
}

func Matrix3FromMatrix2(m Matrix2) Matrix3 {
        nm := Matrix3{}
        nm.SetFromMatrix2(m)
        return nm
}

func Matrix3FromMatrix4(m *Matrix4) Matrix3 {
        nm := Matrix3{}
        nm.SetFromMatrix4(m)
        return nm
}

// Matrix3Translate2D returns a Matrix3 2D matrix with given translations
func Matrix3Translate2D(x, y float32) Matrix3 {
        return Matrix3FromMatrix2(Translate2D(x, y))
}

// Matrix3Scale2D returns a Matrix3 2D matrix with given scaling factors
func Matrix3Scale2D(x, y float32) Matrix3 {
        return Matrix3FromMatrix2(Scale2D(x, y))
}

// Rotate2D returns a Matrix2 2D matrix with given rotation, specified in radians
func Matrix3Rotate2D(angle float32) Matrix3 {
        return Matrix3FromMatrix2(Rotate2D(angle))
}

// Set sets all the elements of the matrix row by row starting at row1, column1,
// row1, column2, row1, column3 and so forth.
func (m *Matrix3) Set(n11, n12, n13, n21, n22, n23, n31, n32, n33 float32) {
        m[0] = n11
        m[3] = n12
        m[6] = n13
        m[1] = n21
        m[4] = n22
        m[7] = n23
        m[2] = n31
        m[5] = n32
        m[8] = n33
}

// SetFromMatrix4 sets the matrix elements based on a Matrix4.
func (m *Matrix3) SetFromMatrix4(src *Matrix4) {
        m.Set(
                src[0], src[4], src[8],
                src[1], src[5], src[9],
                src[2], src[6], src[10],
        )
}

// note: following use of [2], [5] for translation works
// exactly as the 2x3 Matrix2 case works.  But vulkan and wikipedia
// use [6][7] for translation.  Not sure exactly what is going on.

// SetFromMatrix2 sets the matrix elements based on a Matrix2.
func (m *Matrix3) SetFromMatrix2(src Matrix2) {
        m.Set(
                src.XX, src.YX, src.X0,
                src.XY, src.YY, src.Y0,
                src.X0, src.Y0, 1,
        )
}

// FromArray sets this matrix array starting at offset.
func (m *Matrix3) FromArray(array []float32, offset int) {
        copy(m[:], array[offset:])
}

// ToArray copies this matrix to array starting at offset.
func (m Matrix3) ToArray(array []float32, offset int) {
        copy(array[offset:], m[:])
}

// SetIdentity sets this matrix as the identity matrix.
func (m *Matrix3) SetIdentity() {
        m.Set(
                1, 0, 0,
                0, 1, 0,
                0, 0, 1,
        )
}

// SetZero sets this matrix as the zero matrix.
func (m *Matrix3) SetZero() {
        m.Set(
                0, 0, 0,
                0, 0, 0,
                0, 0, 0,
        )
}

// CopyFrom copies from source matrix into this matrix
// (a regular = assign does not copy data, just the pointer!)
func (m *Matrix3) CopyFrom(src Matrix3) {
        copy(m[:], src[:])
}

// MulMatrices sets ths matrix as matrix multiplication a by b (i.e., a*b).
func (m *Matrix3) MulMatrices(a, b Matrix3) {
        a11 := a[0]
        a12 := a[3]
        a13 := a[6]
        a21 := a[1]
        a22 := a[4]
        a23 := a[7]
        a31 := a[2]
        a32 := a[5]
        a33 := a[8]

        b11 := b[0]
        b12 := b[3]
        b13 := b[6]
        b21 := b[1]
        b22 := b[4]
        b23 := b[7]
        b31 := b[2]
        b32 := b[5]
        b33 := b[8]

        m[0] = b11*a11 + b12*a21 + b13*a31
        m[3] = b11*a12 + b12*a22 + b13*a32
        m[6] = b11*a13 + b12*a23 + b13*a33

        m[1] = b21*a11 + b22*a21 + b23*a31
        m[4] = b21*a12 + b22*a22 + b23*a32
        m[7] = b21*a13 + b22*a23 + b23*a33

        m[2] = b31*a11 + b32*a21 + b33*a31
        m[5] = b31*a12 + b32*a22 + b33*a32
        m[8] = b31*a13 + b32*a23 + b33*a33
}

// Mul returns this matrix times other matrix (this matrix is unchanged)
func (m Matrix3) Mul(other Matrix3) Matrix3 {
        nm := Matrix3{}
        nm.MulMatrices(m, other)
        return nm
}

// SetMul sets this matrix to this matrix * other
func (m *Matrix3) SetMul(other Matrix3) {
        m.MulMatrices(*m, other)
}

// MulScalar returns each of this matrix's components multiplied by the specified
// scalar, leaving the original matrix unchanged.
func (m Matrix3) MulScalar(s float32) Matrix3 {
        m.SetMulScalar(s)
        return m
}

// SetMulScalar multiplies each of this matrix's components by the specified scalar.
func (m *Matrix3) SetMulScalar(s float32) {
        m[0] *= s
        m[3] *= s
        m[6] *= s
        m[1] *= s
        m[4] *= s
        m[7] *= s
        m[2] *= s
        m[5] *= s
        m[8] *= s
}

// MulVector2AsVector multiplies the Vector2 as a vector without adding translations.
// This is for directional vectors and not points.
func (a Matrix3) MulVector2AsVector(v Vector2) Vector2 {
        tx := a[0]*v.X + a[1]*v.Y
        ty := a[3]*v.X + a[4]*v.Y
        return Vec2(tx, ty)
}

// MulVector2AsPoint multiplies the Vector2 as a point, including adding translations.
func (a Matrix3) MulVector2AsPoint(v Vector2) Vector2 {
        tx := a[0]*v.X + a[1]*v.Y + a[2]
        ty := a[3]*v.X + a[4]*v.Y + a[5]
        return Vec2(tx, ty)
}

// MulVector3Array multiplies count vectors (i.e., 3 sequential array values per each increment in count)
// in the array starting at start index by this matrix.
func (m *Matrix3) MulVector3Array(array []float32, start, count int) {
        var v1 Vector3
        j := start
        for i := 0; i < count; i++ {
                v1.FromSlice(array, j)
                mv := v1.MulMatrix3(m)
                mv.ToSlice(array, j)
                j += 3
        }
}

// Determinant calculates and returns the determinant of this matrix.
func (m *Matrix3) Determinant() float32 {
        return m[0]*m[4]*m[8] -
                m[0]*m[5]*m[7] -
                m[1]*m[3]*m[8] +
                m[1]*m[5]*m[6] +
                m[2]*m[3]*m[7] -
                m[2]*m[4]*m[6]
}

// SetInverse sets this matrix to the inverse of the src matrix.
// If the src matrix cannot be inverted returns error and
// sets this matrix to the identity matrix.
func (m *Matrix3) SetInverse(src Matrix3) error {
        n11 := src[0]
        n21 := src[1]
        n31 := src[2]
        n12 := src[3]
        n22 := src[4]
        n32 := src[5]
        n13 := src[6]
        n23 := src[7]
        n33 := src[8]

        t11 := n33*n22 - n32*n23
        t12 := n32*n13 - n33*n12
        t13 := n23*n12 - n22*n13

        det := n11*t11 + n21*t12 + n31*t13

        // no inverse
        if det == 0 {
                m.SetIdentity()
                return errors.New("cannot invert matrix, determinant is 0")
        }

        detInv := 1 / det

        m[0] = t11 * detInv
        m[1] = (n31*n23 - n33*n21) * detInv
        m[2] = (n32*n21 - n31*n22) * detInv
        m[3] = t12 * detInv
        m[4] = (n33*n11 - n31*n13) * detInv
        m[5] = (n31*n12 - n32*n11) * detInv
        m[6] = t13 * detInv
        m[7] = (n21*n13 - n23*n11) * detInv
        m[8] = (n22*n11 - n21*n12) * detInv

        return nil
}

// Inverse returns the inverse of this matrix.
// If the matrix cannot be inverted it silently
// sets this matrix to the identity matrix.
// See Try version for error.
func (m Matrix3) Inverse() Matrix3 {
        nm := Matrix3{}
        nm.SetInverse(m)
        return nm
}

// InverseTry returns the inverse of this matrix.
// If the matrix cannot be inverted returns error and
// sets this matrix to the identity matrix.
func (m Matrix3) InverseTry() (Matrix3, error) {
        nm := Matrix3{}
        err := nm.SetInverse(m)
        return nm, err
}

// SetTranspose transposes this matrix.
func (m *Matrix3) SetTranspose() {
        m[1], m[3] = m[3], m[1]
        m[2], m[6] = m[6], m[2]
        m[5], m[7] = m[7], m[5]
}

// Transpose returns the transpose of this matrix.
func (m Matrix3) Transpose() Matrix3 {
        nm := m
        nm.SetTranspose()
        return nm
}

// ScaleCols returns matrix with columns multiplied by the vector components.
// This can be used when multiplying this matrix by a diagonal matrix if we store
// the diagonal components as a vector.
func (m *Matrix3) ScaleCols(v Vector3) *Matrix3 {
        nm := &Matrix3{}
        *nm = *m
        nm.SetScaleCols(v)
        return nm
}

// SetScaleCols multiplies the matrix columns by the vector components.
// This can be used when multiplying this matrix by a diagonal matrix if we store
// the diagonal components as a vector.
func (m *Matrix3) SetScaleCols(v Vector3) {
        m[0] *= v.X
        m[1] *= v.X
        m[2] *= v.X
        m[3] *= v.Y
        m[4] *= v.Y
        m[5] *= v.Y
        m[6] *= v.Z
        m[7] *= v.Z
        m[8] *= v.Z
}

/////////////////////////////////////////////////////////////////////////////
//   Special functions

// SetNormalMatrix set this matrix to the matrix that can transform the normal vectors
// from the src matrix which is used transform the vertices (e.g., a ModelView matrix).
// If the src matrix cannot be inverted returns error.
func (m *Matrix3) SetNormalMatrix(src *Matrix4) error {
        var err error
        *m, err = Matrix3FromMatrix4(src).InverseTry()
        m.SetTranspose()
        return err
}

// SetRotationFromQuat sets this matrix as a rotation matrix from the specified [Quat].
func (m *Matrix3) SetRotationFromQuat(q Quat) {
        x := q.X
        y := q.Y
        z := q.Z
        w := q.W
        x2 := x + x
        y2 := y + y
        z2 := z + z
        xx := x * x2
        xy := x * y2
        xz := x * z2
        yy := y * y2
        yz := y * z2
        zz := z * z2
        wx := w * x2
        wy := w * y2
        wz := w * z2

        m[0] = 1 - (yy + zz)
        m[3] = xy - wz
        m[6] = xz + wy

        m[1] = xy + wz
        m[4] = 1 - (xx + zz)
        m[7] = yz - wx

        m[2] = xz - wy
        m[5] = yz + wx
        m[8] = 1 - (xx + yy)
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import "errors"

// Matrix4 is 4x4 matrix organized internally as column matrix.
type Matrix4 [16]float32

// Identity4 returns a new identity [Matrix4] matrix.
func Identity4() *Matrix4 {
        m := &Matrix4{}
        m.SetIdentity()
        return m
}

// Set sets all the elements of this matrix row by row starting at row1, column1,
// row1, column2, row1, column3 and so forth.
func (m *Matrix4) Set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 float32) {
        m[0] = n11
        m[4] = n12
        m[8] = n13
        m[12] = n14
        m[1] = n21
        m[5] = n22
        m[9] = n23
        m[13] = n24
        m[2] = n31
        m[6] = n32
        m[10] = n33
        m[14] = n34
        m[3] = n41
        m[7] = n42
        m[11] = n43
        m[15] = n44
}

// SetFromMatrix3 sets the matrix elements based on a Matrix3,
// filling in 0's for missing off-diagonal elements,
// and 1 on the diagonal.
func (m *Matrix4) SetFromMatrix3(src *Matrix3) {
        m.Set(
                src[0], src[3], src[6], 0,
                src[1], src[4], src[7], 0,
                src[2], src[5], src[8], 0,
                0, 0, 0, 1,
        )
}

// FromArray set this matrix elements from the array starting at offset.
func (m *Matrix4) FromArray(array []float32, offset int) {
        copy(m[:], array[offset:])
}

// ToArray copies this matrix elements to array starting at offset.
func (m *Matrix4) ToArray(array []float32, offset int) {
        copy(array[offset:], m[:])
}

// SetIdentity sets this matrix as the identity matrix.
func (m *Matrix4) SetIdentity() {
        m.Set(
                1, 0, 0, 0,
                0, 1, 0, 0,
                0, 0, 1, 0,
                0, 0, 0, 1,
        )
}

// SetZero sets this matrix as the zero matrix.
func (m *Matrix4) SetZero() {
        m.Set(
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 0,
        )
}

// CopyFrom copies from source matrix into this matrix
// (a regular = assign does not copy data, just the pointer!)
func (m *Matrix4) CopyFrom(src *Matrix4) {
        copy(m[:], src[:])
}

// CopyPos copies the position elements of the src matrix into this one.
func (m *Matrix4) CopyPos(src *Matrix4) {
        m[12] = src[12]
        m[13] = src[13]
        m[14] = src[14]
}

// ExtractBasis returns the x,y,z basis vectors of this matrix.
func (m *Matrix4) ExtractBasis() (xAxis, yAxis, zAxis Vector3) {
        xAxis.Set(m[0], m[1], m[2])
        yAxis.Set(m[4], m[5], m[6])
        zAxis.Set(m[8], m[9], m[10])
        return
}

// SetBasis sets this matrix basis vectors from the specified vectors.
func (m *Matrix4) SetBasis(xAxis, yAxis, zAxis Vector3) {
        m.Set(
                xAxis.X, yAxis.X, zAxis.X, 0,
                xAxis.Y, yAxis.Y, zAxis.Y, 0,
                xAxis.Z, yAxis.Z, zAxis.Z, 0,
                0, 0, 0, 1,
        )
}

// MulMatrices sets this matrix as matrix multiplication a by b (i.e. a*b).
func (m *Matrix4) MulMatrices(a, b *Matrix4) {
        a11 := a[0]
        a12 := a[4]
        a13 := a[8]
        a14 := a[12]
        a21 := a[1]
        a22 := a[5]
        a23 := a[9]
        a24 := a[13]
        a31 := a[2]
        a32 := a[6]
        a33 := a[10]
        a34 := a[14]
        a41 := a[3]
        a42 := a[7]
        a43 := a[11]
        a44 := a[15]

        b11 := b[0]
        b12 := b[4]
        b13 := b[8]
        b14 := b[12]
        b21 := b[1]
        b22 := b[5]
        b23 := b[9]
        b24 := b[13]
        b31 := b[2]
        b32 := b[6]
        b33 := b[10]
        b34 := b[14]
        b41 := b[3]
        b42 := b[7]
        b43 := b[11]
        b44 := b[15]

        m[0] = a11*b11 + a12*b21 + a13*b31 + a14*b41
        m[4] = a11*b12 + a12*b22 + a13*b32 + a14*b42
        m[8] = a11*b13 + a12*b23 + a13*b33 + a14*b43
        m[12] = a11*b14 + a12*b24 + a13*b34 + a14*b44

        m[1] = a21*b11 + a22*b21 + a23*b31 + a24*b41
        m[5] = a21*b12 + a22*b22 + a23*b32 + a24*b42
        m[9] = a21*b13 + a22*b23 + a23*b33 + a24*b43
        m[13] = a21*b14 + a22*b24 + a23*b34 + a24*b44

        m[2] = a31*b11 + a32*b21 + a33*b31 + a34*b41
        m[6] = a31*b12 + a32*b22 + a33*b32 + a34*b42
        m[10] = a31*b13 + a32*b23 + a33*b33 + a34*b43
        m[14] = a31*b14 + a32*b24 + a33*b34 + a34*b44

        m[3] = a41*b11 + a42*b21 + a43*b31 + a44*b41
        m[7] = a41*b12 + a42*b22 + a43*b32 + a44*b42
        m[11] = a41*b13 + a42*b23 + a43*b33 + a44*b43
        m[15] = a41*b14 + a42*b24 + a43*b34 + a44*b44
}

// Mul returns this matrix times other matrix (this matrix is unchanged)
func (m *Matrix4) Mul(other *Matrix4) *Matrix4 {
        nm := &Matrix4{}
        nm.MulMatrices(m, other)
        return nm
}

// SetMul sets this matrix to this matrix times other
func (m *Matrix4) SetMul(other *Matrix4) {
        m.MulMatrices(m, other)
}

// SetMulScalar multiplies each element of this matrix by the specified scalar.
func (m *Matrix4) MulScalar(s float32) {
        m[0] *= s
        m[4] *= s
        m[8] *= s
        m[12] *= s
        m[1] *= s
        m[5] *= s
        m[9] *= s
        m[13] *= s
        m[2] *= s
        m[6] *= s
        m[10] *= s
        m[14] *= s
        m[3] *= s
        m[7] *= s
        m[11] *= s
        m[15] *= s
}

// MulVector3Array multiplies count vectors (i.e., 3 sequential array values per each increment in count)
// in the array starting at start index by this matrix.
func (m *Matrix4) MulVector3Array(array []float32, start, count int) {
        var v1 Vector3
        j := start
        for i := 0; i < count; i++ {
                v1.FromSlice(array, j)
                mv := v1.MulMatrix4(m)
                mv.ToSlice(array, j)
                j += 3
        }
}

// Determinant calculates and returns the determinant of this matrix.
func (m *Matrix4) Determinant() float32 {
        n11 := m[0]
        n12 := m[4]
        n13 := m[8]
        n14 := m[12]
        n21 := m[1]
        n22 := m[5]
        n23 := m[9]
        n24 := m[13]
        n31 := m[2]
        n32 := m[6]
        n33 := m[10]
        n34 := m[14]
        n41 := m[3]
        n42 := m[7]
        n43 := m[11]
        n44 := m[15]

        return n41*(+n14*n23*n32-n13*n24*n32-n14*n22*n33+n12*n24*n33+n13*n22*n34-n12*n23*n34) +
                n42*(+n11*n23*n34-n11*n24*n33+n14*n21*n33-n13*n21*n34+n13*n24*n31-n14*n23*n31) +
                n43*(+n11*n24*n32-n11*n22*n34-n14*n21*n32+n12*n21*n34+n14*n22*n31-n12*n24*n31) +
                n44*(-n13*n22*n31-n11*n23*n32+n11*n22*n33+n13*n21*n32-n12*n21*n33+n12*n23*n31)
}

// SetInverse sets this matrix to the inverse of the src matrix.
// If the src matrix cannot be inverted returns error and
// sets this matrix to the identity matrix.
func (m *Matrix4) SetInverse(src *Matrix4) error {
        n11 := src[0]
        n12 := src[4]
        n13 := src[8]
        n14 := src[12]
        n21 := src[1]
        n22 := src[5]
        n23 := src[9]
        n24 := src[13]
        n31 := src[2]
        n32 := src[6]
        n33 := src[10]
        n34 := src[14]
        n41 := src[3]
        n42 := src[7]
        n43 := src[11]
        n44 := src[15]

        t11 := n23*n34*n42 - n24*n33*n42 + n24*n32*n43 - n22*n34*n43 - n23*n32*n44 + n22*n33*n44
        t12 := n14*n33*n42 - n13*n34*n42 - n14*n32*n43 + n12*n34*n43 + n13*n32*n44 - n12*n33*n44
        t13 := n13*n24*n42 - n14*n23*n42 + n14*n22*n43 - n12*n24*n43 - n13*n22*n44 + n12*n23*n44
        t14 := n14*n23*n32 - n13*n24*n32 - n14*n22*n33 + n12*n24*n33 + n13*n22*n34 - n12*n23*n34

        det := n11*t11 + n21*t12 + n31*t13 + n41*t14

        if det == 0 {
                m.SetIdentity()
                return errors.New("cannot invert matrix, determinant is 0")
        }

        detInv := 1 / det

        m[0] = t11 * detInv
        m[1] = (n24*n33*n41 - n23*n34*n41 - n24*n31*n43 + n21*n34*n43 + n23*n31*n44 - n21*n33*n44) * detInv
        m[2] = (n22*n34*n41 - n24*n32*n41 + n24*n31*n42 - n21*n34*n42 - n22*n31*n44 + n21*n32*n44) * detInv
        m[3] = (n23*n32*n41 - n22*n33*n41 - n23*n31*n42 + n21*n33*n42 + n22*n31*n43 - n21*n32*n43) * detInv

        m[4] = t12 * detInv
        m[5] = (n13*n34*n41 - n14*n33*n41 + n14*n31*n43 - n11*n34*n43 - n13*n31*n44 + n11*n33*n44) * detInv
        m[6] = (n14*n32*n41 - n12*n34*n41 - n14*n31*n42 + n11*n34*n42 + n12*n31*n44 - n11*n32*n44) * detInv
        m[7] = (n12*n33*n41 - n13*n32*n41 + n13*n31*n42 - n11*n33*n42 - n12*n31*n43 + n11*n32*n43) * detInv

        m[8] = t13 * detInv
        m[9] = (n14*n23*n41 - n13*n24*n41 - n14*n21*n43 + n11*n24*n43 + n13*n21*n44 - n11*n23*n44) * detInv
        m[10] = (n12*n24*n41 - n14*n22*n41 + n14*n21*n42 - n11*n24*n42 - n12*n21*n44 + n11*n22*n44) * detInv
        m[11] = (n13*n22*n41 - n12*n23*n41 - n13*n21*n42 + n11*n23*n42 + n12*n21*n43 - n11*n22*n43) * detInv

        m[12] = t14 * detInv
        m[13] = (n13*n24*n31 - n14*n23*n31 + n14*n21*n33 - n11*n24*n33 - n13*n21*n34 + n11*n23*n34) * detInv
        m[14] = (n14*n22*n31 - n12*n24*n31 - n14*n21*n32 + n11*n24*n32 + n12*n21*n34 - n11*n22*n34) * detInv
        m[15] = (n12*n23*n31 - n13*n22*n31 + n13*n21*n32 - n11*n23*n32 - n12*n21*n33 + n11*n22*n33) * detInv

        return nil
}

// Inverse returns the inverse of this matrix.
// If the matrix cannot be inverted returns error and
// sets this matrix to the identity matrix.
func (m *Matrix4) Inverse() (*Matrix4, error) {
        nm := &Matrix4{}
        err := nm.SetInverse(m)
        return nm, err
}

// SetTranspose transposes this matrix.
func (m *Matrix4) SetTranspose() {
        m[1], m[4] = m[4], m[1]
        m[2], m[8] = m[8], m[2]
        m[6], m[9] = m[9], m[6]
        m[3], m[12] = m[12], m[3]
        m[7], m[13] = m[13], m[7]
        m[11], m[14] = m[14], m[11]
}

// Transpose returns the transpose of this matrix.
func (m *Matrix4) Transpose() *Matrix4 {
        nm := *m
        nm.SetTranspose()
        return &nm
}

/////////////////////////////////////////////////////////////////////////////
//   Translation, Rotation, Scaling transform

// ScaleCols returns matrix with first column of this matrix multiplied by the vector X component,
// the second column by the vector Y component and the third column by
// the vector Z component. The matrix fourth column is unchanged.
func (m *Matrix4) ScaleCols(v Vector3) *Matrix4 {
        nm := &Matrix4{}
        nm.SetScaleCols(v)
        return nm
}

// SetScaleCols multiplies the first column of this matrix by the vector X component,
// the second column by the vector Y component and the third column by
// the vector Z component. The matrix fourth column is unchanged.
func (m *Matrix4) SetScaleCols(v Vector3) {
        m[0] *= v.X
        m[4] *= v.Y
        m[8] *= v.Z
        m[1] *= v.X
        m[5] *= v.Y
        m[9] *= v.Z
        m[2] *= v.X
        m[6] *= v.Y
        m[10] *= v.Z
        m[3] *= v.X
        m[7] *= v.Y
        m[11] *= v.Z
}

// GetMaxScaleOnAxis returns the maximum scale value of the 3 axes.
func (m *Matrix4) GetMaxScaleOnAxis() float32 {
        scaleXSq := m[0]*m[0] + m[1]*m[1] + m[2]*m[2]
        scaleYSq := m[4]*m[4] + m[5]*m[5] + m[6]*m[6]
        scaleZSq := m[8]*m[8] + m[9]*m[9] + m[10]*m[10]
        return Sqrt(Max(scaleXSq, Max(scaleYSq, scaleZSq)))
}

// SetTranslation sets this matrix to a translation matrix from the specified x, y and z values.
func (m *Matrix4) SetTranslation(x, y, z float32) {
        m.Set(
                1, 0, 0, x,
                0, 1, 0, y,
                0, 0, 1, z,
                0, 0, 0, 1,
        )
}

// SetRotationX sets this matrix to a rotation matrix of angle theta around the X axis.
func (m *Matrix4) SetRotationX(theta float32) {
        c := Cos(theta)
        s := Sin(theta)

        m.Set(
                1, 0, 0, 0,
                0, c, -s, 0,
                0, s, c, 0,
                0, 0, 0, 1,
        )
}

// SetRotationY sets this matrix to a rotation matrix of angle theta around the Y axis.
func (m *Matrix4) SetRotationY(theta float32) {
        c := Cos(theta)
        s := Sin(theta)
        m.Set(
                c, 0, s, 0,
                0, 1, 0, 0,
                -s, 0, c, 0,
                0, 0, 0, 1,
        )
}

// SetRotationZ sets this matrix to a rotation matrix of angle theta around the Z axis.
func (m *Matrix4) SetRotationZ(theta float32) {
        c := Cos(theta)
        s := Sin(theta)
        m.Set(
                c, -s, 0, 0,
                s, c, 0, 0,
                0, 0, 1, 0,
                0, 0, 0, 1,
        )
}

// SetRotationAxis sets this matrix to a rotation matrix of the specified angle around the specified axis.
func (m *Matrix4) SetRotationAxis(axis *Vector3, angle float32) {
        c := Cos(angle)
        s := Sin(angle)
        t := 1 - c
        x := axis.X
        y := axis.Y
        z := axis.Z
        tx := t * x
        ty := t * y
        m.Set(
                tx*x+c, tx*y-s*z, tx*z+s*y, 0,
                tx*y+s*z, ty*y+c, ty*z-s*x, 0,
                tx*z-s*y, ty*z+s*x, t*z*z+c, 0,
                0, 0, 0, 1,
        )
}

// SetScale sets this matrix to a scale transformation matrix using the specified x, y and z values.
func (m *Matrix4) SetScale(x, y, z float32) {
        m.Set(
                x, 0, 0, 0,
                0, y, 0, 0,
                0, 0, z, 0,
                0, 0, 0, 1,
        )
}

// SetPos sets this transformation matrix position fields from the specified vector v.
func (m *Matrix4) SetPos(v Vector3) {
        m[12] = v.X
        m[13] = v.Y
        m[14] = v.Z
}

// Pos returns the position component of the matrix
func (m *Matrix4) Pos() Vector3 {
        pos := Vector3{}
        pos.X = m[12]
        pos.Y = m[13]
        pos.Z = m[14]
        return pos
}

// SetTransform sets this matrix to a transformation matrix for the specified position,
// rotation specified by the quaternion and scale.
func (m *Matrix4) SetTransform(pos Vector3, quat Quat, scale Vector3) {
        m.SetRotationFromQuat(quat)
        m.SetScaleCols(scale)
        m.SetPos(pos)
}

// Decompose updates the position vector, quaternion and scale from this transformation matrix.
func (m *Matrix4) Decompose() (pos Vector3, quat Quat, scale Vector3) {
        sx := Vec3(m[0], m[1], m[2]).Length()
        sy := Vec3(m[4], m[5], m[6]).Length()
        sz := Vec3(m[8], m[9], m[10]).Length()

        // If determinant is negative, we need to invert one scale
        det := m.Determinant()
        if det < 0 {
                sx = -sx
        }

        pos.X = m[12]
        pos.Y = m[13]
        pos.Z = m[14]

        // Scale the rotation part
        invSX := 1 / sx
        invSY := 1 / sy
        invSZ := 1 / sz

        mat := *m
        mat[0] *= invSX
        mat[1] *= invSX
        mat[2] *= invSX

        mat[4] *= invSY
        mat[5] *= invSY
        mat[6] *= invSY

        mat[8] *= invSZ
        mat[9] *= invSZ
        mat[10] *= invSZ

        quat.SetFromRotationMatrix(&mat)

        scale.X = sx
        scale.Y = sy
        scale.Z = sz
        return
}

// ExtractRotation sets this matrix as rotation matrix from the src transformation matrix.
func (m *Matrix4) ExtractRotation(src *Matrix4) {
        scaleX := 1 / Vec3(src[0], src[1], src[2]).Length()
        scaleY := 1 / Vec3(src[4], src[5], src[6]).Length()
        scaleZ := 1 / Vec3(src[8], src[9], src[10]).Length()

        m[0] = src[0] * scaleX
        m[1] = src[1] * scaleX
        m[2] = src[2] * scaleX

        m[4] = src[4] * scaleY
        m[5] = src[5] * scaleY
        m[6] = src[6] * scaleY

        m[8] = src[8] * scaleZ
        m[9] = src[9] * scaleZ
        m[10] = src[10] * scaleZ
}

// SetRotationFromEuler set this a matrix as a rotation matrix from the specified euler angles.
func (m *Matrix4) SetRotationFromEuler(euler Vector3) {
        x := euler.X
        y := euler.Y
        z := euler.Z
        a := Cos(x)
        b := Sin(x)
        c := Cos(y)
        d := Sin(y)
        e := Cos(z)
        f := Sin(z)

        ae := a * e
        af := a * f
        be := b * e
        bf := b * f
        m[0] = c * e
        m[4] = -c * f
        m[8] = d
        m[1] = af + be*d
        m[5] = ae - bf*d
        m[9] = -b * c
        m[2] = bf - ae*d
        m[6] = be + af*d
        m[10] = a * c

        // Last column
        m[3] = 0
        m[7] = 0
        m[11] = 0
        // Bottom row
        m[12] = 0
        m[13] = 0
        m[14] = 0
        m[15] = 1
}

// SetRotationFromQuat sets this matrix as a rotation matrix from the specified quaternion.
func (m *Matrix4) SetRotationFromQuat(q Quat) {
        x := q.X
        y := q.Y
        z := q.Z
        w := q.W
        x2 := x + x
        y2 := y + y
        z2 := z + z
        xx := x * x2
        xy := x * y2
        xz := x * z2
        yy := y * y2
        yz := y * z2
        zz := z * z2
        wx := w * x2
        wy := w * y2
        wz := w * z2

        m[0] = 1 - (yy + zz)
        m[4] = xy - wz
        m[8] = xz + wy

        m[1] = xy + wz
        m[5] = 1 - (xx + zz)
        m[9] = yz - wx

        m[2] = xz - wy
        m[6] = yz + wx
        m[10] = 1 - (xx + yy)

        // last column
        m[3] = 0
        m[7] = 0
        m[11] = 0

        // bottom row
        m[12] = 0
        m[13] = 0
        m[14] = 0
        m[15] = 1
}

// LookAt sets this matrix as view transform matrix with origin at eye,
// looking at target and using the up vector.
func (m *Matrix4) LookAt(eye, target, up Vector3) {
        z := eye.Sub(target)
        if z.LengthSquared() == 0 {
                // Eye and target are in the same position
                z.Z = 1
        }
        z.SetNormal()

        x := up.Cross(z)
        if x.LengthSquared() == 0 { // Up and Z are parallel
                if Abs(up.Z) == 1 {
                        z.X += 0.0001
                } else {
                        z.Z += 0.0001
                }
                z.SetNormal()
                x = up.Cross(z)
        }
        x.SetNormal()

        y := z.Cross(x)

        m[0] = x.X
        m[1] = x.Y
        m[2] = x.Z

        m[4] = y.X
        m[5] = y.Y
        m[6] = y.Z

        m[8] = z.X
        m[9] = z.Y
        m[10] = z.Z
}

// NewLookAt returns Matrix4 matrix as view transform matrix with origin at eye,
// looking at target and using the up vector.
func NewLookAt(eye, target, up Vector3) *Matrix4 {
        rotMat := &Matrix4{}
        rotMat.LookAt(eye, target, up)
        return rotMat
}

// SetFrustum sets this matrix to a projection frustum matrix bounded
// by the specified planes.
func (m *Matrix4) SetFrustum(left, right, bottom, top, near, far float32) {
        fmn := far - near
        m[0] = 2 * near / (right - left)
        m[1] = 0
        m[2] = 0
        m[3] = 0
        m[4] = 0
        m[5] = 2 * near / (top - bottom)
        m[6] = 0
        m[7] = 0
        m[8] = (right + left) / (right - left)
        m[9] = (top + bottom) / (top - bottom)
        m[10] = -(far + near) / fmn
        m[11] = -1
        m[12] = 0
        m[13] = 0
        m[14] = -(2 * far * near) / fmn
        m[15] = 0
}

// SetPerspective sets this matrix to a perspective projection matrix
// with the specified field of view in degrees,
// aspect ratio (width/height) and near and far planes.
func (m *Matrix4) SetPerspective(fov, aspect, near, far float32) {
        ymax := near * Tan(DegToRad(fov*0.5))
        ymin := -ymax
        xmin := ymin * aspect
        xmax := ymax * aspect
        m.SetFrustum(xmin, xmax, ymin, ymax, near, far)
}

// SetOrthographic sets this matrix to an orthographic projection matrix.
func (m *Matrix4) SetOrthographic(width, height, near, far float32) {
        p := far - near
        z := (far + near) / p

        m[0] = 2 / width
        m[4] = 0
        m[8] = 0
        m[12] = 0
        m[1] = 0
        m[5] = 2 / height
        m[9] = 0
        m[13] = 0
        m[2] = 0
        m[6] = 0
        m[10] = -2 / p
        m[14] = -z
        m[3] = 0
        m[7] = 0
        m[11] = 0
        m[15] = 1
}

// SetVkFrustum sets this matrix to a projection frustum matrix bounded by the specified planes.
// This version is for use with Vulkan, and does the equivalent of GLM_DEPTH_ZERO_ONE in glm
// and also multiplies the Y axis by -1, preserving the original OpenGL Y-up system.
// OpenGL provides a "natural" coordinate system for the physical world
// so it is useful to retain that for the world system and just convert
// on the way out to the render using this projection matrix.
func (m *Matrix4) SetVkFrustum(left, right, bottom, top, near, far float32) {
        fmn := far - near
        m[0] = 2 * near / (right - left)
        m[1] = 0
        m[2] = 0
        m[3] = 0
        m[4] = 0
        m[5] = -2 * near / (top - bottom)
        m[6] = 0
        m[7] = 0
        m[8] = (right + left) / (right - left)
        m[9] = (top + bottom) / (top - bottom)
        m[10] = -far / fmn
        m[11] = -1
        m[12] = 0
        m[13] = 0
        m[14] = -(far * near) / fmn
        m[15] = 0
}

// SetVkPerspective sets this matrix to a vulkan appropriate perspective
// projection matrix, assuming the use of the OpenGL Y-up
// coordinate system for the geometry points.
// OpenGL provides a "natural" coordinate system for the physical world
// so it is useful to retain that for the world system and just convert
// on the way out to the render using this projection matrix.
// The specified field of view is in degrees,
// aspect ratio (width/height) and near and far planes.
func (m *Matrix4) SetVkPerspective(fov, aspect, near, far float32) {
        ymax := near * Tan(DegToRad(fov*0.5))
        ymin := -ymax
        xmin := ymin * aspect
        xmax := ymax * aspect
        m.SetVkFrustum(xmin, xmax, ymin, ymax, near, far)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package minmax

import (
        "fmt"
        "math"
)

//gosl:start

const (
        MaxFloat32 float32 = 3.402823466e+38
        MinFloat32 float32 = 1.175494351e-38
)

// AvgMax holds average and max statistics
type AvgMax32 struct {
        Avg float32
        Max float32

        // sum for computing average
        Sum float32

        // index of max item
        MaxIndex int32

        // number of items in sum
        N int32

        pad, pad1, pad2 int32
}

// Init initializes prior to new updates
func (am *AvgMax32) Init() {
        am.Avg = 0
        am.Sum = 0
        am.N = 0
        am.Max = -MaxFloat32
        am.MaxIndex = -1
}

// UpdateVal updates stats from given value
func (am *AvgMax32) UpdateValue(val float32, idx int32) {
        am.Sum += val
        am.N++
        if val > am.Max {
                am.Max = val
                am.MaxIndex = idx
        }
}

// UpdateFromOther updates these values from other AvgMax32 values
func (am *AvgMax32) UpdateFromOther(oSum, oMax float32, oN, oMaxIndex int32) {
        am.Sum += oSum
        am.N += oN
        if oMax > am.Max {
                am.Max = oMax
                am.MaxIndex = oMaxIndex
        }
}

// CalcAvg computes the average given the current Sum and N values
func (am *AvgMax32) CalcAvg() {
        if am.N > 0 {
                am.Avg = am.Sum / float32(am.N)
        } else {
                am.Avg = am.Sum
                am.Max = am.Avg // prevents Max from being -MaxFloat..
        }
}

//gosl:end

func (am *AvgMax32) String() string {
        return fmt.Sprintf("{Avg: %g, Max: %g, Sum: %g, MaxIndex: %d, N: %d}", am.Avg, am.Max, am.Sum, am.MaxIndex, am.N)
}

// UpdateFrom updates these values from other AvgMax32 values
func (am *AvgMax32) UpdateFrom(oth *AvgMax32) {
        am.UpdateFromOther(oth.Sum, oth.Max, oth.N, oth.MaxIndex)
        am.Sum += oth.Sum
        am.N += oth.N
        if oth.Max > am.Max {
                am.Max = oth.Max
                am.MaxIndex = oth.MaxIndex
        }
}

// CopyFrom copies from other AvgMax32
func (am *AvgMax32) CopyFrom(oth *AvgMax32) {
        *am = *oth
}

///////////////////////////////////////////////////////////////////////////
//  64

// AvgMax holds average and max statistics
type AvgMax64 struct {
        Avg float64
        Max float64

        // sum for computing average
        Sum float64

        // index of max item
        MaxIndex int32

        // number of items in sum
        N int32
}

// Init initializes prior to new updates
func (am *AvgMax64) Init() {
        am.Avg = 0
        am.Sum = 0
        am.N = 0
        am.Max = math.Inf(-1)
        am.MaxIndex = -1
}

// UpdateVal updates stats from given value
func (am *AvgMax64) UpdateValue(val float64, idx int) {
        am.Sum += val
        am.N++
        if val > am.Max {
                am.Max = val
                am.MaxIndex = int32(idx)
        }
}

// CalcAvg computes the average given the current Sum and N values
func (am *AvgMax64) CalcAvg() {
        if am.N > 0 {
                am.Avg = am.Sum / float64(am.N)
        } else {
                am.Avg = am.Sum
                am.Max = am.Avg // prevents Max from being -MaxFloat..
        }
}

// UpdateFrom updates these values from other AvgMax64
func (am *AvgMax64) UpdateFrom(oth *AvgMax64) {
        am.Sum += oth.Sum
        am.N += oth.N
        if oth.Max > am.Max {
                am.Max = oth.Max
                am.MaxIndex = oth.MaxIndex
        }
}

// CopyFrom copies from other AvgMax64
func (am *AvgMax64) CopyFrom(oth *AvgMax64) {
        am.Avg = oth.Avg
        am.Max = oth.Max
        am.MaxIndex = oth.MaxIndex
        am.Sum = oth.Sum
        am.N = oth.N
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package minmax

import (
        "fmt"

        "cogentcore.org/core/math32"
)

//gosl:start

// F32 represents a min / max range for float32 values.
// Supports clipping, renormalizing, etc
type F32 struct {
        Min float32
        Max float32

        pad, pad1 int32 // for gpu use
}

// Set sets the min and max values
func (mr *F32) Set(mn, mx float32) {
        mr.Min = mn
        mr.Max = mx
}

// SetInfinity sets the Min to +Inf, Max to -Inf -- suitable for
// iteratively calling Fit*InRange. See also Sanitize when done.
func (mr *F32) SetInfinity() {
        mr.Min = math32.Inf(1)
        mr.Max = math32.Inf(-1)
}

// IsValid returns true if Min <= Max
func (mr *F32) IsValid() bool {
        return mr.Min <= mr.Max
}

// InRange tests whether value is within the range (>= Min and <= Max)
func (mr *F32) InRange(val float32) bool {
        return ((val >= mr.Min) && (val <= mr.Max))
}

// IsLow tests whether value is lower than the minimum
func (mr *F32) IsLow(val float32) bool {
        return (val < mr.Min)
}

// IsHigh tests whether value is higher than the maximum
func (mr *F32) IsHigh(val float32) bool {
        return (val > mr.Min)
}

// Range returns Max - Min
func (mr *F32) Range() float32 {
        return mr.Max - mr.Min
}

// Scale returns 1 / Range -- if Range = 0 then returns 0
func (mr *F32) Scale() float32 {
        r := mr.Range()
        if r != 0 {
                return 1.0 / r
        }
        return 0
}

// Midpoint returns point halfway between Min and Max
func (mr *F32) Midpoint() float32 {
        return 0.5 * (mr.Max + mr.Min)
}

// FitValInRange adjusts our Min, Max to fit given value within Min, Max range
// returns true if we had to adjust to fit.
func (mr *F32) FitValInRange(val float32) bool {
        adj := false
        if val < mr.Min {
                mr.Min = val
                adj = true
        }
        if val > mr.Max {
                mr.Max = val
                adj = true
        }
        return adj
}

// NormVal normalizes value to 0-1 unit range relative to current Min / Max range
// Clips the value within Min-Max range first.
func (mr *F32) NormValue(val float32) float32 {
        return (mr.ClampValue(val) - mr.Min) * mr.Scale()
}

// ProjVal projects a 0-1 normalized unit value into current Min / Max range (inverse of NormVal)
func (mr *F32) ProjValue(val float32) float32 {
        return mr.Min + (val * mr.Range())
}

// ClampValue clamps given value within Min / Max range
// Note: a NaN will remain as a NaN.
func (mr *F32) ClampValue(val float32) float32 {
        if val < mr.Min {
                return mr.Min
        }
        if val > mr.Max {
                return mr.Max
        }
        return val
}

// ClipNormVal clips then normalizes given value within 0-1
// Note: a NaN will remain as a NaN
func (mr *F32) ClipNormValue(val float32) float32 {
        if val < mr.Min {
                return 0
        }
        if val > mr.Max {
                return 1
        }
        return mr.NormValue(val)
}

//gosl:end

func (mr *F32) String() string {
        return fmt.Sprintf("{%g %g}", mr.Min, mr.Max)
}

// FitInRange adjusts our Min, Max to fit within those of other F32
// returns true if we had to adjust to fit.
func (mr *F32) FitInRange(oth F32) bool {
        adj := false
        if oth.Min < mr.Min {
                mr.Min = oth.Min
                adj = true
        }
        if oth.Max > mr.Max {
                mr.Max = oth.Max
                adj = true
        }
        return adj
}

// Sanitize ensures that the Min / Max range is not infinite or contradictory.
func (mr *F32) Sanitize() {
        if math32.IsInf(mr.Min, 0) {
                mr.Min = 0
        }
        if math32.IsInf(mr.Max, 0) {
                mr.Max = 0
        }
        if mr.Min > mr.Max {
                mr.Min, mr.Max = mr.Max, mr.Min
        }
        if mr.Min == mr.Max {
                mr.Min--
                mr.Max++
        }
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package minmax provides a struct that holds Min and Max values.
package minmax

import "math"

//go:generate core generate

// F64 represents a min / max range for float64 values.
// Supports clipping, renormalizing, etc
type F64 struct {
        Min float64
        Max float64
}

// Set sets the min and max values
func (mr *F64) Set(mn, mx float64) {
        mr.Min = mn
        mr.Max = mx
}

// SetInfinity sets the Min to +Inf, Max to -Inf, suitable for
// iteratively calling Fit*InRange. See also Sanitize when done.
func (mr *F64) SetInfinity() {
        mr.Min = math.Inf(1)
        mr.Max = math.Inf(-1)
}

// IsValid returns true if Min <= Max.
func (mr *F64) IsValid() bool {
        return mr.Min <= mr.Max
}

// InRange tests whether value is within the range (>= Min and <= Max).
func (mr *F64) InRange(val float64) bool {
        return ((val >= mr.Min) && (val <= mr.Max))
}

// IsLow tests whether value is lower than the minimum.
func (mr *F64) IsLow(val float64) bool {
        return (val < mr.Min)
}

// IsHigh tests whether value is higher than the maximum.
func (mr *F64) IsHigh(val float64) bool {
        return (val > mr.Min)
}

// Range returns Max - Min.
func (mr *F64) Range() float64 {
        return mr.Max - mr.Min
}

// Scale returns 1 / Range -- if Range = 0 then returns 0.
func (mr *F64) Scale() float64 {
        r := mr.Range()
        if r != 0 {
                return 1 / r
        }
        return 0
}

// Midpoint returns point halfway between Min and Max
func (mr *F64) Midpoint() float64 {
        return 0.5 * (mr.Max + mr.Min)
}

// FitValInRange adjusts our Min, Max to fit given value within Min, Max range
// returns true if we had to adjust to fit.
func (mr *F64) FitValInRange(val float64) bool {
        adj := false
        if val < mr.Min {
                mr.Min = val
                adj = true
        }
        if val > mr.Max {
                mr.Max = val
                adj = true
        }
        return adj
}

// NormVal normalizes value to 0-1 unit range relative to current Min / Max range
// Clips the value within Min-Max range first.
func (mr *F64) NormValue(val float64) float64 {
        return (mr.ClampValue(val) - mr.Min) * mr.Scale()
}

// ProjVal projects a 0-1 normalized unit value into current Min / Max range (inverse of NormVal)
func (mr *F64) ProjValue(val float64) float64 {
        return mr.Min + (val * mr.Range())
}

// ClampValue clips given value within Min / Max range
// Note: a NaN will remain as a NaN
func (mr *F64) ClampValue(val float64) float64 {
        if val < mr.Min {
                return mr.Min
        }
        if val > mr.Max {
                return mr.Max
        }
        return val
}

// ClipNormVal clips then normalizes given value within 0-1
// Note: a NaN will remain as a NaN
func (mr *F64) ClipNormValue(val float64) float64 {
        if val < mr.Min {
                return 0
        }
        if val > mr.Max {
                return 1
        }
        return mr.NormValue(val)
}

// FitInRange adjusts our Min, Max to fit within those of other F64
// returns true if we had to adjust to fit.
func (mr *F64) FitInRange(oth F64) bool {
        adj := false
        if oth.Min < mr.Min {
                mr.Min = oth.Min
                adj = true
        }
        if oth.Max > mr.Max {
                mr.Max = oth.Max
                adj = true
        }
        return adj
}

// Sanitize ensures that the Min / Max range is not infinite or contradictory.
func (mr *F64) Sanitize() {
        if math.IsInf(mr.Min, 0) {
                mr.Min = 0
        }
        if math.IsInf(mr.Max, 0) {
                mr.Max = 0
        }
        if mr.Min > mr.Max {
                mr.Min, mr.Max = mr.Max, mr.Min
        }
        if mr.Min == mr.Max {
                mr.Min--
                mr.Max++
        }
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package minmax

import "math"

// Int represents a min / max range for int values.
// Supports clipping, renormalizing, etc
type Int struct {
        Min int
        Max int
}

// Set sets the min and max values
func (mr *Int) Set(mn, mx int) {
        mr.Min, mr.Max = mn, mx
}

// SetInfinity sets the Min to +MaxFloat, Max to -MaxFloat -- suitable for
// iteratively calling Fit*InRange
func (mr *Int) SetInfinity() {
        mr.Min, mr.Max = math.MaxInt, -math.MaxInt
}

// IsValid returns true if Min <= Max
func (mr *Int) IsValid() bool {
        return mr.Min <= mr.Max
}

// InRange tests whether value is within the range (>= Min and <= Max)
func (mr *Int) InRange(val int) bool {
        return ((val >= mr.Min) && (val <= mr.Max))
}

// IsLow tests whether value is lower than the minimum
func (mr *Int) IsLow(val int) bool {
        return (val < mr.Min)
}

// IsHigh tests whether value is higher than the maximum
func (mr *Int) IsHigh(val int) bool {
        return (val > mr.Min)
}

// Range returns Max - Min
func (mr *Int) Range() int {
        return mr.Max - mr.Min
}

// Scale returns 1 / Range -- if Range = 0 then returns 0
func (mr *Int) Scale() float32 {
        r := mr.Range()
        if r != 0 {
                return 1 / float32(r)
        }
        return 0
}

// Midpoint returns point halfway between Min and Max
func (mr *Int) Midpoint() float32 {
        return 0.5 * float32(mr.Max+mr.Min)
}

// FitInRange adjusts our Min, Max to fit within those of other Int
// returns true if we had to adjust to fit.
func (mr *Int) FitInRange(oth Int) bool {
        adj := false
        if oth.Min < mr.Min {
                mr.Min = oth.Min
                adj = true
        }
        if oth.Max > mr.Max {
                mr.Max = oth.Max
                adj = true
        }
        return adj
}

// FitValInRange adjusts our Min, Max to fit given value within Min, Max range
// returns true if we had to adjust to fit.
func (mr *Int) FitValInRange(val int) bool {
        adj := false
        if val < mr.Min {
                mr.Min = val
                adj = true
        }
        if val > mr.Max {
                mr.Max = val
                adj = true
        }
        return adj
}

// NormVal normalizes value to 0-1 unit range relative to current Min / Max range
// Clips the value within Min-Max range first.
func (mr *Int) NormValue(val int) float32 {
        return float32(mr.Clamp(val)-mr.Min) * mr.Scale()
}

// ProjVal projects a 0-1 normalized unit value into current Min / Max range (inverse of NormVal)
func (mr *Int) ProjValue(val float32) float32 {
        return float32(mr.Min) + (val * float32(mr.Range()))
}

// ClipVal clips given value within Min / Max rangee
func (mr *Int) Clamp(val int) int {
        if val < mr.Min {
                return mr.Min
        }
        if val > mr.Max {
                return mr.Max
        }
        return val
}

// ClipNormVal clips then normalizes given value within 0-1
func (mr *Int) ClipNormValue(val int) float32 {
        if val < mr.Min {
                return 0
        }
        if val > mr.Max {
                return 1
        }
        return mr.NormValue(val)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package minmax

import "math"

// notes: gonum/plot has function labelling: talbotLinHanrahan
// based on this algorithm: http://vis.stanford.edu/files/2010-TickLabels-InfoVis.pdf
// but it is goes beyond this basic functionality, and is not exported in any case..
// but could be accessed using DefaultTicks api.

// NiceRoundNumber returns the closest nice round number either above or below
// the given number, based on the observation that numbers 1, 2, 5
// at any power are "nice".
// This is used for choosing graph labels, and auto-scaling ranges to contain
// a given value.
// if below == true then returned number is strictly less than given number
// otherwise it is strictly larger.
func NiceRoundNumber(x float64, below bool) float64 {
        rn := x
        neg := false
        if x < 0 {
                neg = true
                below = !below // reverses..
        }
        abs := math.Abs(x)
        exp := int(math.Floor(math.Log10(abs)))
        order := math.Pow(10, float64(exp))
        f := abs / order // fraction between 1 and 10
        if below {
                switch {
                case f >= 5:
                        rn = 5
                case f >= 2:
                        rn = 2
                default:
                        rn = 1
                }
        } else {
                switch {
                case f <= 1:
                        rn = 1
                case f <= 2:
                        rn = 2
                case f <= 5:
                        rn = 5
                default:
                        rn = 10
                }
        }
        if neg {
                return -rn * order
        }
        return rn * order
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package minmax

// Range32 represents a range of values for plotting, where the min or max can optionally be fixed
type Range32 struct {
        F32

        // fix the minimum end of the range
        FixMin bool

        // fix the maximum end of the range
        FixMax bool
}

// SetMin sets a fixed min value
func (rr *Range32) SetMin(mn float32) *Range32 {
        rr.FixMin = true
        rr.Min = mn
        return rr
}

// SetMax sets a fixed max value
func (rr *Range32) SetMax(mx float32) *Range32 {
        rr.FixMax = true
        rr.Max = mx
        return rr
}

// Range returns Max - Min
func (rr *Range32) Range() float32 {
        return rr.Max - rr.Min
}

// Clamp returns min, max values clamped according to Fixed min / max of range.
func (rr *Range32) Clamp(mnIn, mxIn float32) (mn, mx float32) {
        mn, mx = mnIn, mxIn
        if rr.FixMin && rr.Min < mn {
                mn = rr.Min
        }
        if rr.FixMax && rr.Max > mx {
                mx = rr.Max
        }
        return
}

///////////////////////////////////////////////////////////////////////
//  64

// Range64 represents a range of values for plotting, where the min or max can optionally be fixed
type Range64 struct {
        F64

        // fix the minimum end of the range
        FixMin bool

        // fix the maximum end of the range
        FixMax bool
}

// SetMin sets a fixed min value
func (rr *Range64) SetMin(mn float64) *Range64 {
        rr.FixMin = true
        rr.Min = mn
        return rr
}

// SetMax sets a fixed max value
func (rr *Range64) SetMax(mx float64) *Range64 {
        rr.FixMax = true
        rr.Max = mx
        return rr
}

// Range returns Max - Min
func (rr *Range64) Range() float64 {
        return rr.Max - rr.Min
}

// Clamp returns min, max values clamped according to Fixed min / max of range.
func (rr *Range64) Clamp(mnIn, mxIn float64) (mn, mx float64) {
        mn, mx = mnIn, mxIn
        if rr.FixMin && rr.Min < mn {
                mn = rr.Min
        }
        if rr.FixMax && rr.Max > mx {
                mx = rr.Max
        }
        return
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import "log"

// Plane represents a plane in 3D space by its normal vector and a constant offset.
// When the the normal vector is the unit vector the offset is the distance from the origin.
type Plane struct {
        Norm Vector3
        Off  float32
}

// NewPlane creates and returns a new plane from a normal vector and a offset.
func NewPlane(normal Vector3, offset float32) *Plane {
        p := &Plane{normal, offset}
        return p
}

// Set sets this plane normal vector and offset.
func (p *Plane) Set(normal Vector3, offset float32) {
        p.Norm = normal
        p.Off = offset
}

// SetDims sets this plane normal vector dimensions and offset.
func (p *Plane) SetDims(x, y, z, w float32) {
        p.Norm.Set(x, y, z)
        p.Off = w
}

// SetFromNormalAndCoplanarPoint sets this plane from a normal vector and a point on the plane.
func (p *Plane) SetFromNormalAndCoplanarPoint(normal Vector3, point Vector3) {
        p.Norm = normal
        p.Off = -point.Dot(p.Norm)
}

// SetFromCoplanarPoints sets this plane from three coplanar points.
func (p *Plane) SetFromCoplanarPoints(a, b, c Vector3) {
        norm := c.Sub(b).Cross(a.Sub(b))
        norm.SetNormal()
        if norm == (Vector3{}) {
                log.Printf("math32.SetFromCoplanarPonts: points not actually coplanar: %v %v %v\n", a, b, c)
        }
        p.SetFromNormalAndCoplanarPoint(norm, a)
}

// Normalize normalizes this plane normal vector and adjusts the offset.
// Note: will lead to a divide by zero if the plane is invalid.
func (p *Plane) Normalize() {
        invLen := 1.0 / p.Norm.Length()
        p.Norm.SetMulScalar(invLen)
        p.Off *= invLen
}

// Negate negates this plane normal.
func (p *Plane) Negate() {
        p.Off *= -1
        p.Norm = p.Norm.Negate()
}

// DistanceToPoint returns the distance of this plane from point.
func (p *Plane) DistanceToPoint(point Vector3) float32 {
        return p.Norm.Dot(point) + p.Off
}

// DistanceToSphere returns the distance of this place from the sphere.
func (p *Plane) DistanceToSphere(sphere Sphere) float32 {
        return p.DistanceToPoint(sphere.Center) - sphere.Radius
}

// IsIntersectionLine returns the line intersects this plane.
func (p *Plane) IsIntersectionLine(line Line3) bool {
        startSign := p.DistanceToPoint(line.Start)
        endSign := p.DistanceToPoint(line.End)
        return (startSign < 0 && endSign > 0) || (endSign < 0 && startSign > 0)
}

// IntersectLine calculates the point in the plane which intersets the specified line.
// Returns false if the line does not intersects the plane.
func (p *Plane) IntersectLine(line Line3) (Vector3, bool) {
        dir := line.Delta()
        denom := p.Norm.Dot(dir)
        if denom == 0 {
                // line is coplanar, return origin
                if p.DistanceToPoint(line.Start) == 0 {
                        return line.Start, true
                }
                // Unsure if this is the correct method to handle this case.
                return dir, false
        }
        var t = -(line.Start.Dot(p.Norm) + p.Off) / denom
        if t < 0 || t > 1 {
                return dir, false
        }
        return dir.MulScalar(t).Add(line.Start), true
}

// CoplanarPoint returns a point in the plane that is the closest point from the origin.
func (p *Plane) CoplanarPoint() Vector3 {
        return p.Norm.MulScalar(-p.Off)
}

// SetTranslate translates this plane in the direction of its normal by offset.
func (p *Plane) SetTranslate(offset Vector3) {
        p.Off -= offset.Dot(p.Norm)
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import "fmt"

// Quat is quaternion with X,Y,Z and W components.
type Quat struct {
        X float32
        Y float32
        Z float32
        W float32
}

// NewQuat returns a new quaternion from the specified components.
func NewQuat(x, y, z, w float32) Quat {
        return Quat{X: x, Y: y, Z: z, W: w}
}

// NewQuatAxisAngle returns a new quaternion from given axis and angle rotation (radians).
func NewQuatAxisAngle(axis Vector3, angle float32) Quat {
        nq := Quat{}
        nq.SetFromAxisAngle(axis, angle)
        return nq
}

// NewQuatEuler returns a new quaternion from given Euler angles.
func NewQuatEuler(euler Vector3) Quat {
        nq := Quat{}
        nq.SetFromEuler(euler)
        return nq
}

// Set sets this quaternion's components.
func (q *Quat) Set(x, y, z, w float32) {
        q.X = x
        q.Y = y
        q.Z = z
        q.W = w
}

// FromArray sets this quaternion's components from array starting at offset.
func (q *Quat) FromArray(array []float32, offset int) {
        q.X = array[offset]
        q.Y = array[offset+1]
        q.Z = array[offset+2]
        q.W = array[offset+3]
}

// ToArray copies this quaternions's components to array starting at offset.
func (q *Quat) ToArray(array []float32, offset int) {
        array[offset] = q.X
        array[offset+1] = q.Y
        array[offset+2] = q.Z
        array[offset+3] = q.W
}

// SetIdentity sets this quanternion to the identity quaternion.
func (q *Quat) SetIdentity() {
        q.X = 0
        q.Y = 0
        q.Z = 0
        q.W = 1
}

// IsIdentity returns if this is an identity quaternion.
func (q *Quat) IsIdentity() bool {
        return q.X == 0 && q.Y == 0 && q.Z == 0 && q.W == 1
}

// IsNil returns true if all values are 0 (uninitialized).
func (q *Quat) IsNil() bool {
        return q.X == 0 && q.Y == 0 && q.Z == 0 && q.W == 0
}

func (q Quat) String() string {
        return fmt.Sprintf("(%v, %v, %v, %v)", q.X, q.Y, q.Z, q.W)
}

// SetFromEuler sets this quaternion from the specified vector with
// Euler angles for each axis. It is assumed that the Euler angles
// are in XYZ order.
func (q *Quat) SetFromEuler(euler Vector3) {
        c1 := Cos(euler.X / 2)
        c2 := Cos(euler.Y / 2)
        c3 := Cos(euler.Z / 2)
        s1 := Sin(euler.X / 2)
        s2 := Sin(euler.Y / 2)
        s3 := Sin(euler.Z / 2)

        q.X = s1*c2*c3 - c1*s2*s3
        q.Y = c1*s2*c3 + s1*c2*s3
        q.Z = c1*c2*s3 - s1*s2*c3
        q.W = c1*c2*c3 + s1*s2*s3
}

// ToEuler returns a Vector3 with components as the Euler angles
// from the given quaternion.
func (q *Quat) ToEuler() Vector3 {
        rot := Vector3{}
        rot.SetEulerAnglesFromQuat(*q)
        return rot
}

// SetFromAxisAngle sets this quaternion with the rotation
// specified by the given axis and angle.
func (q *Quat) SetFromAxisAngle(axis Vector3, angle float32) {
        halfAngle := angle / 2
        s := Sin(halfAngle)
        q.X = axis.X * s
        q.Y = axis.Y * s
        q.Z = axis.Z * s
        q.W = Cos(halfAngle)
}

// ToAxisAngle returns the Vector4 holding axis and angle of this Quaternion
func (q *Quat) ToAxisAngle() Vector4 {
        aa := Vector4{}
        aa.SetAxisAngleFromQuat(*q)
        return aa
}

// GenGoSet returns code to set values in object at given path (var.member etc)
func (q *Quat) GenGoSet(path string) string {
        aa := q.ToAxisAngle()
        return fmt.Sprintf("%s.SetFromAxisAngle(math32.Vec3(%g, %g, %g), %g)", path, aa.X, aa.Y, aa.Z, aa.W)
}

// GenGoNew returns code to create new
func (q *Quat) GenGoNew() string {
        return fmt.Sprintf("math32.Quat{%g, %g, %g, %g}", q.X, q.Y, q.Z, q.W)
}

// SetFromRotationMatrix sets this quaternion from the specified rotation matrix.
func (q *Quat) SetFromRotationMatrix(m *Matrix4) {
        m11 := m[0]
        m12 := m[4]
        m13 := m[8]
        m21 := m[1]
        m22 := m[5]
        m23 := m[9]
        m31 := m[2]
        m32 := m[6]
        m33 := m[10]
        trace := m11 + m22 + m33

        var s float32
        if trace > 0 {
                s = 0.5 / Sqrt(trace+1.0)
                q.W = 0.25 / s
                q.X = (m32 - m23) * s
                q.Y = (m13 - m31) * s
                q.Z = (m21 - m12) * s
        } else if m11 > m22 && m11 > m33 {
                s = 2.0 * Sqrt(1.0+m11-m22-m33)
                q.W = (m32 - m23) / s
                q.X = 0.25 * s
                q.Y = (m12 + m21) / s
                q.Z = (m13 + m31) / s
        } else if m22 > m33 {
                s = 2.0 * Sqrt(1.0+m22-m11-m33)
                q.W = (m13 - m31) / s
                q.X = (m12 + m21) / s
                q.Y = 0.25 * s
                q.Z = (m23 + m32) / s
        } else {
                s = 2.0 * Sqrt(1.0+m33-m11-m22)
                q.W = (m21 - m12) / s
                q.X = (m13 + m31) / s
                q.Y = (m23 + m32) / s
                q.Z = 0.25 * s
        }
}

// SetFromUnitVectors sets this quaternion to the rotation from vector vFrom to vTo.
// The vectors must be normalized.
func (q *Quat) SetFromUnitVectors(vFrom, vTo Vector3) {
        var v1 Vector3
        var EPS float32 = 0.000001

        r := vFrom.Dot(vTo) + 1
        if r < EPS {
                r = 0
                if Abs(vFrom.X) > Abs(vFrom.Z) {
                        v1.Set(-vFrom.Y, vFrom.X, 0)
                } else {
                        v1.Set(0, -vFrom.Z, vFrom.Y)
                }

        } else {
                v1 = vFrom.Cross(vTo)
        }
        q.X = v1.X
        q.Y = v1.Y
        q.Z = v1.Z
        q.W = r

        q.Normalize()
}

// SetInverse sets this quaternion to its inverse.
func (q *Quat) SetInverse() {
        q.SetConjugate()
        q.Normalize()
}

// Inverse returns the inverse of this quaternion.
func (q *Quat) Inverse() Quat {
        nq := *q
        nq.SetInverse()
        return nq
}

// SetConjugate sets this quaternion to its conjugate.
func (q *Quat) SetConjugate() {
        q.X *= -1
        q.Y *= -1
        q.Z *= -1
}

// Conjugate returns the conjugate of this quaternion.
func (q *Quat) Conjugate() Quat {
        nq := *q
        nq.SetConjugate()
        return nq
}

// Dot returns the dot products of this quaternion with other.
func (q *Quat) Dot(other Quat) float32 {
        return q.X*other.X + q.Y*other.Y + q.Z*other.Z + q.W*other.W
}

// LengthSq returns this quanternion's length squared
func (q Quat) LengthSq() float32 {
        return q.X*q.X + q.Y*q.Y + q.Z*q.Z + q.W*q.W
}

// Length returns the length of this quaternion
func (q Quat) Length() float32 {
        return Sqrt(q.X*q.X + q.Y*q.Y + q.Z*q.Z + q.W*q.W)
}

// Normalize normalizes this quaternion.
func (q *Quat) Normalize() {
        l := q.Length()
        if l == 0 {
                q.X = 0
                q.Y = 0
                q.Z = 0
                q.W = 1
        } else {
                l = 1 / l
                q.X *= l
                q.Y *= l
                q.Z *= l
                q.W *= l
        }
}

// NormalizeFast approximates normalizing this quaternion.
// Works best when the quaternion is already almost-normalized.
func (q *Quat) NormalizeFast() {
        f := (3.0 - (q.X*q.X + q.Y*q.Y + q.Z*q.Z + q.W*q.W)) / 2.0
        if f == 0 {
                q.X = 0
                q.Y = 0
                q.Z = 0
                q.W = 1
        } else {
                q.X *= f
                q.Y *= f
                q.Z *= f
                q.W *= f
        }
}

// MulQuats set this quaternion to the multiplication of a by b.
func (q *Quat) MulQuats(a, b Quat) {
        // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
        qax := a.X
        qay := a.Y
        qaz := a.Z
        qaw := a.W
        qbx := b.X
        qby := b.Y
        qbz := b.Z
        qbw := b.W

        q.X = qax*qbw + qaw*qbx + qay*qbz - qaz*qby
        q.Y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz
        q.Z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx
        q.W = qaw*qbw - qax*qbx - qay*qby - qaz*qbz
}

// SetMul sets this quaternion to the multiplication of itself by other.
func (q *Quat) SetMul(other Quat) {
        q.MulQuats(*q, other)
}

// Mul returns returns multiplication of this quaternion with other
func (q *Quat) Mul(other Quat) Quat {
        nq := *q
        nq.SetMul(other)
        return nq
}

// Slerp sets this quaternion to another quaternion which is the spherically linear interpolation
// from this quaternion to other using t.
func (q *Quat) Slerp(other Quat, t float32) {
        if t == 0 {
                return
        }
        if t == 1 {
                *q = other
                return
        }

        x := q.X
        y := q.Y
        z := q.Z
        w := q.W

        cosHalfTheta := w*other.W + x*other.X + y*other.Y + z*other.Z

        if cosHalfTheta < 0 {
                q.W = -other.W
                q.X = -other.X
                q.Y = -other.Y
                q.Z = -other.Z
                cosHalfTheta = -cosHalfTheta
        } else {
                *q = other
        }

        if cosHalfTheta >= 1.0 {
                q.W = w
                q.X = x
                q.Y = y
                q.Z = z
                return
        }

        sqrSinHalfTheta := 1.0 - cosHalfTheta*cosHalfTheta
        if sqrSinHalfTheta < 0.001 {
                s := 1 - t
                q.W = s*w + t*q.W
                q.X = s*x + t*q.X
                q.Y = s*y + t*q.Y
                q.Z = s*z + t*q.Z
                q.Normalize()
                return
        }

        sinHalfTheta := Sqrt(sqrSinHalfTheta)
        halfTheta := Atan2(sinHalfTheta, cosHalfTheta)
        ratioA := Sin((1-t)*halfTheta) / sinHalfTheta
        ratioB := Sin(t*halfTheta) / sinHalfTheta

        q.W = w*ratioA + q.W*ratioB
        q.X = x*ratioA + q.X*ratioB
        q.Y = y*ratioA + q.Y*ratioB
        q.Z = z*ratioA + q.Z*ratioB
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

// Ray represents an oriented 3D line segment defined by an origin point and a direction vector.
type Ray struct {
        Origin Vector3
        Dir    Vector3
}

// NewRay creates and returns a pointer to a Ray object with
// the specified origin and direction vectors.
// If a nil pointer is supplied for any of the parameters,
// the zero vector will be used.
func NewRay(origin, dir Vector3) *Ray {
        return &Ray{origin, dir}
}

// Set sets the origin and direction vectors of this Ray.
func (ray *Ray) Set(origin, dir Vector3) {
        ray.Origin = origin
        ray.Dir = dir
}

// At calculates the point in the ray which is at the specified t distance from the origin
// along its direction.
func (ray *Ray) At(t float32) Vector3 {
        return ray.Dir.MulScalar(t).Add(ray.Origin)
}

// Recast sets the new origin of the ray at the specified distance t
// from its origin along its direction.
func (ray *Ray) Recast(t float32) {
        ray.Origin = ray.At(t)
}

// ClosestPointToPoint calculates the point in the ray which is closest to the specified point.
func (ray *Ray) ClosestPointToPoint(point Vector3) Vector3 {
        dirDist := point.Sub(ray.Origin).Dot(ray.Dir)
        if dirDist < 0 {
                return ray.Origin
        }
        return ray.Dir.MulScalar(dirDist).Add(ray.Origin)
}

// DistanceToPoint returns the smallest distance
// from the ray direction vector to the specified point.
func (ray *Ray) DistanceToPoint(point Vector3) float32 {
        return Sqrt(ray.DistanceSquaredToPoint(point))
}

// DistanceSquaredToPoint returns the smallest squared distance
// from the ray direction vector to the specified point.
// If the ray was pointed directly at the point this distance would be 0.
func (ray *Ray) DistanceSquaredToPoint(point Vector3) float32 {
        dirDist := point.Sub(ray.Origin).Dot(ray.Dir)
        // point behind the ray
        if dirDist < 0 {
                return ray.Origin.DistanceTo(point)
        }
        return ray.Dir.MulScalar(dirDist).Add(ray.Origin).DistanceToSquared(point)
}

// DistanceSquaredToSegment returns the smallest squared distance
// from this ray to the line segment from v0 to v1.
// If optPointOnRay Vector3 is not nil,
// it is set with the coordinates of the point on the ray.
// if optPointOnSegment Vector3 is not nil,
// it is set with the coordinates of the point on the segment.
func (ray *Ray) DistanceSquaredToSegment(v0, v1 Vector3, optPointOnRay, optPointOnSegment *Vector3) float32 {
        segCenter := v0.Add(v1).MulScalar(0.5)
        segDir := v1.Sub(v0).Normal()
        diff := ray.Origin.Sub(segCenter)

        segExtent := v0.DistanceTo(v1) * 0.5
        a01 := -ray.Dir.Dot(segDir)
        b0 := diff.Dot(ray.Dir)
        b1 := -diff.Dot(segDir)
        c := diff.LengthSquared()
        det := Abs(1 - a01*a01)

        var s0, s1, sqrDist, extDet float32
        if det > 0 {
                // The ray and segment are not parallel.
                s0 = a01*b1 - b0
                s1 = a01*b0 - b1
                extDet = segExtent * det

                if s0 >= 0 {
                        if s1 >= -extDet {
                                if s1 <= extDet {
                                        // region 0
                                        // Minimum at interior points of ray and segment.
                                        invDet := 1 / det
                                        s0 *= invDet
                                        s1 *= invDet
                                        sqrDist = s0*(s0+a01*s1+2*b0) + s1*(a01*s0+s1+2*b1) + c
                                } else {
                                        // region 1
                                        s1 = segExtent
                                        s0 = Max(0, -(a01*s1 + b0))
                                        sqrDist = -s0*s0 + s1*(s1+2*b1) + c
                                }
                        } else {
                                // region 5
                                s1 = -segExtent
                                s0 = Max(0, -(a01*s1 + b0))
                                sqrDist = -s0*s0 + s1*(s1+2*b1) + c
                        }
                } else {
                        if s1 <= -extDet {
                                // region 4
                                s0 = Max(0, -(-a01*segExtent + b0))
                                if s0 > 0 {
                                        s1 = -segExtent
                                } else {
                                        s1 = Min(Max(-segExtent, -b1), segExtent)
                                }
                                sqrDist = -s0*s0 + s1*(s1+2*b1) + c
                        } else if s1 <= extDet {
                                // region 3
                                s0 = 0
                                s1 = Min(Max(-segExtent, -b1), segExtent)
                                sqrDist = s1*(s1+2*b1) + c

                        } else {
                                // region 2
                                s0 = Max(0, -(a01*segExtent + b0))
                                if s0 > 0 {
                                        s1 = segExtent
                                } else {
                                        s1 = Min(Max(-segExtent, -b1), segExtent)
                                }
                                sqrDist = -s0*s0 + s1*(s1+2*b1) + c
                        }
                }
        } else {
                // Ray and segment are parallel.
                if a01 > 0 {
                        s1 = -segExtent
                } else {
                        s1 = segExtent
                }
                s0 = Max(0, -(a01*s1 + b0))
                sqrDist = -s0*s0 + s1*(s1+2*b1) + c
        }

        if optPointOnRay != nil {
                *optPointOnRay = ray.Dir.MulScalar(s0).Add(ray.Origin)
        }

        if optPointOnSegment != nil {
                *optPointOnSegment = segDir.MulScalar(s1).Add(segCenter)
        }
        return sqrDist
}

// IsIntersectionSphere returns if this ray intersects with the specified sphere.
func (ray *Ray) IsIntersectionSphere(sphere Sphere) bool {
        return ray.DistanceToPoint(sphere.Center) <= sphere.Radius
}

// IntersectSphere calculates the point which is the intersection of this ray with the specified sphere.
// If no intersection is found it returns false.
func (ray *Ray) IntersectSphere(sphere Sphere) (Vector3, bool) {
        v1 := sphere.Center.Sub(ray.Origin)
        tca := v1.Dot(ray.Dir)
        d2 := v1.Dot(v1) - tca*tca
        radius2 := sphere.Radius * sphere.Radius

        if d2 > radius2 {
                return v1, false
        }
        thc := Sqrt(radius2 - d2)
        // t0 = first intersect point - entrance on front of sphere
        t0 := tca - thc
        // t1 = second intersect point - exit point on back of sphere
        t1 := tca + thc
        // test to see if both t0 and t1 are behind the ray - if so, return null
        if t0 < 0 && t1 < 0 {
                return v1, false
        }

        // test to see if t0 is behind the ray:
        // if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
        // in order to always return an intersect point that is in front of the ray.
        if t0 < 0 {
                return ray.At(t1), true
        }
        // else t0 is in front of the ray, so return the first collision point scaled by t0
        return ray.At(t0), true
}

// IsIntersectPlane returns if this ray intersects the specified plane.
func (ray *Ray) IsIntersectPlane(plane Plane) bool {
        distToPoint := plane.DistanceToPoint(ray.Origin)
        if distToPoint == 0 {
                return true
        }
        denom := plane.Norm.Dot(ray.Dir)
        // if false, ray origin is behind the plane (and is pointing behind it)
        return denom*distToPoint < 0
}

// DistanceToPlane returns the distance of this ray origin to its intersection point in the plane.
// If the ray does not intersects the plane, returns NaN.
func (ray *Ray) DistanceToPlane(plane Plane) float32 {
        denom := plane.Norm.Dot(ray.Dir)
        if denom == 0 {
                // line is coplanar, return origin
                if plane.DistanceToPoint(ray.Origin) == 0 {
                        return 0
                }
                return NaN()
        }
        t := -(ray.Origin.Dot(plane.Norm) + plane.Off) / denom
        // Return if the ray never intersects the plane
        if t >= 0 {
                return t
        }
        return NaN()
}

// IntersectPlane calculates the point which is the intersection of this ray with the specified plane.
// If no intersection is found false is returned.
func (ray *Ray) IntersectPlane(plane Plane) (Vector3, bool) {
        t := ray.DistanceToPlane(plane)
        if IsNaN(t) {
                return ray.Origin, false
        }
        return ray.At(t), true
}

// IntersectBox calculates the point which is the intersection of this ray with the specified box.
// If no intersection is found false is returned.
func (ray *Ray) IntersectBox(box Box3) (Vector3, bool) {
        // http://www.scratchapixel.com/lessons/3d-basic-lessons/lesson-7-intersecting-simple-shapes/ray-box-intersection/

        var tmin, tmax, tymin, tymax, tzmin, tzmax float32

        invdirx := 1 / ray.Dir.X
        invdiry := 1 / ray.Dir.Y
        invdirz := 1 / ray.Dir.Z

        var origin = ray.Origin

        if invdirx >= 0 {
                tmin = (box.Min.X - origin.X) * invdirx
                tmax = (box.Max.X - origin.X) * invdirx
        } else {
                tmin = (box.Max.X - origin.X) * invdirx
                tmax = (box.Min.X - origin.X) * invdirx
        }

        if invdiry >= 0 {
                tymin = (box.Min.Y - origin.Y) * invdiry
                tymax = (box.Max.Y - origin.Y) * invdiry
        } else {
                tymin = (box.Max.Y - origin.Y) * invdiry
                tymax = (box.Min.Y - origin.Y) * invdiry
        }

        if (tmin > tymax) || (tymin > tmax) {
                return ray.Origin, false
        }

        if tymin > tmin || IsNaN(tmin) {
                tmin = tymin
        }

        if tymax < tmax || IsNaN(tmax) {
                tmax = tymax
        }

        if invdirz >= 0 {
                tzmin = (box.Min.Z - origin.Z) * invdirz
                tzmax = (box.Max.Z - origin.Z) * invdirz
        } else {
                tzmin = (box.Max.Z - origin.Z) * invdirz
                tzmax = (box.Min.Z - origin.Z) * invdirz
        }

        if (tmin > tzmax) || (tzmin > tmax) {
                return ray.Origin, false
        }

        if tzmin > tmin || IsNaN(tmin) {
                tmin = tzmin
        }

        if tzmax < tmax || IsNaN(tmax) {
                tmax = tzmax
        }

        // return point closest to the ray (positive side)

        if tmax < 0 {
                return ray.Origin, false
        }

        if tmin >= 0 {
                return ray.At(tmin), true
        }
        return ray.At(tmax), true
}

// IntersectTriangle returns if this ray intersects the triangle with the face
// defined by points a, b, c. Returns true if it intersects and the point
// parameter with the intersected point coordinates.
// If backfaceCulling is false it ignores the intersection if the face is not oriented
// in the ray direction.
func (ray *Ray) IntersectTriangle(a, b, c Vector3, backfaceCulling bool) (Vector3, bool) {
        edge1 := b.Sub(a)
        edge2 := c.Sub(a)
        normal := edge1.Cross(edge2)

        // Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,
        // E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by
        //   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
        //   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
        //   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
        DdN := ray.Dir.Dot(normal)
        var sign float32

        if DdN > 0 {
                if backfaceCulling {
                        return ray.Origin, false
                }
                sign = 1
        } else if DdN < 0 {
                sign = -1
                DdN = -DdN
        } else {
                return ray.Origin, false
        }

        diff := ray.Origin.Sub(a)
        DdQxE2 := sign * ray.Dir.Dot(diff.Cross(edge2))

        // b1 < 0, no intersection
        if DdQxE2 < 0 {
                return ray.Origin, false
        }

        DdE1xQ := sign * ray.Dir.Dot(edge1.Cross(diff))
        // b2 < 0, no intersection
        if DdE1xQ < 0 {
                return ray.Origin, false
        }

        // b1+b2 > 1, no intersection
        if DdQxE2+DdE1xQ > DdN {
                return ray.Origin, false
        }

        // Line intersects triangle, check if ray does.
        QdN := -sign * diff.Dot(normal)

        // t < 0, no intersection
        if QdN < 0 {
                return ray.Origin, false
        }

        // Ray intersects triangle.
        return ray.At(QdN / DdN), true
}

// MulMatrix4 multiplies this ray origin and direction
// by the specified matrix4, basically transforming this ray coordinates.
func (ray *Ray) ApplyMatrix4(mat4 *Matrix4) {
        ray.Dir = ray.Dir.Add(ray.Origin).MulMatrix4(mat4)
        ray.Origin = ray.Origin.MulMatrix4(mat4)
        ray.Dir.SetSub(ray.Origin)
        ray.Dir.SetNormal()
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

// Sphere represents a 3D sphere defined by its center point and a radius
type Sphere struct {
        Center Vector3 // center of the sphere
        Radius float32 // radius of the sphere
}

// NewSphere creates and returns a pointer to a new sphere with
// the specified center and radius.
func NewSphere(center Vector3, radius float32) *Sphere {
        return &Sphere{center, radius}
}

// Set sets the center and radius of this sphere.
func (s *Sphere) Set(center Vector3, radius float32) {
        s.Center = center
        s.Radius = radius
}

// SetFromBox sets the center and radius of this sphere to surround given box
func (s *Sphere) SetFromBox(box Box3) {
        s.Center = box.Center()
        s.Radius = 0.5 * box.Size().Length()
}

// SetFromPoints sets this sphere from the specified points array and optional center.
func (s *Sphere) SetFromPoints(points []Vector3, optCenter *Vector3) {
        box := B3Empty()
        if optCenter != nil {
                s.Center = *optCenter
        } else {
                box.SetFromPoints(points)
                s.Center = box.Center()
        }
        var maxRadiusSq float32
        for i := 0; i < len(points); i++ {
                maxRadiusSq = Max(maxRadiusSq, s.Center.DistanceToSquared(points[i]))
        }
        s.Radius = Sqrt(maxRadiusSq)
}

// IsEmpty checks if this sphere is empty (radius <= 0)
func (s *Sphere) IsEmpty(sphere *Sphere) bool {
        return s.Radius <= 0
}

// ContainsPoint returns if this sphere contains the specified point.
func (s *Sphere) ContainsPoint(point Vector3) bool {
        return point.DistanceToSquared(s.Center) <= (s.Radius * s.Radius)
}

// DistanceToPoint returns the distance from the sphere surface to the specified point.
func (s *Sphere) DistanceToPoint(point Vector3) float32 {
        return point.DistanceTo(s.Center) - s.Radius
}

// IntersectSphere returns if other sphere intersects this one.
func (s *Sphere) IntersectSphere(other Sphere) bool {
        radiusSum := s.Radius + other.Radius
        return other.Center.DistanceToSquared(s.Center) <= (radiusSum * radiusSum)
}

// ClampPoint clamps the specified point inside the sphere.
// If the specified point is inside the sphere, it is the clamped point.
// Otherwise the clamped point is the the point in the sphere surface in the
// nearest of the specified point.
func (s *Sphere) ClampPoint(point Vector3) Vector3 {
        deltaLengthSq := s.Center.DistanceToSquared(point)
        rv := point
        if deltaLengthSq > (s.Radius * s.Radius) {
                rv = point.Sub(s.Center).Normal().MulScalar(s.Radius).Add(s.Center)
        }
        return rv
}

// GetBoundingBox calculates a [Box3] which bounds this sphere.
func (s *Sphere) GetBoundingBox() Box3 {
        box := Box3{s.Center, s.Center}
        box.ExpandByScalar(s.Radius)
        return box
}

// MulMatrix4 applies the specified matrix transform to this sphere.
func (s *Sphere) MulMatrix4(mat *Matrix4) {
        s.Center = s.Center.MulMatrix4(mat)
        s.Radius = s.Radius * mat.GetMaxScaleOnAxis()
}

// Translate translates this sphere by the specified offset.
func (s *Sphere) Translate(offset Vector3) {
        s.Center.SetAdd(offset)
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

// Triangle represents a triangle made of three vertices.
type Triangle struct {
        A Vector3
        B Vector3
        C Vector3
}

// NewTriangle returns a new Triangle object.
func NewTriangle(a, b, c Vector3) Triangle {
        return Triangle{a, b, c}
}

// Normal returns the triangle's normal.
func Normal(a, b, c Vector3) Vector3 {
        nv := c.Sub(b).Cross(a.Sub(b))
        lenSq := nv.LengthSquared()
        if lenSq > 0 {
                return nv.MulScalar(1 / Sqrt(lenSq))
        }
        return Vector3{}
}

// BarycoordFromPoint returns the barycentric coordinates for the specified point.
func BarycoordFromPoint(point, a, b, c Vector3) Vector3 {
        v0 := c.Sub(a)
        v1 := b.Sub(a)
        v2 := point.Sub(a)

        dot00 := v0.Dot(v0)
        dot01 := v0.Dot(v1)
        dot02 := v0.Dot(v2)
        dot11 := v1.Dot(v1)
        dot12 := v1.Dot(v2)

        denom := dot00*dot11 - dot01*dot01

        // colinear or singular triangle
        if denom == 0 {
                // arbitrary location outside of triangle?
                // not sure if this is the best idea, maybe should be returning undefined
                return Vec3(-2, -1, -1)
        }

        invDenom := 1 / denom
        u := (dot11*dot02 - dot01*dot12) * invDenom
        v := (dot00*dot12 - dot01*dot02) * invDenom

        // barycoordinates must always sum to 1
        return Vec3(1-u-v, v, u)
}

// ContainsPoint returns whether a triangle contains a point.
func ContainsPoint(point, a, b, c Vector3) bool {
        rv := BarycoordFromPoint(point, a, b, c)
        return (rv.X >= 0) && (rv.Y >= 0) && ((rv.X + rv.Y) <= 1)
}

// Set sets the triangle's three vertices.
func (t *Triangle) Set(a, b, c Vector3) {
        t.A = a
        t.B = b
        t.C = c
}

// SetFromPointsAndIndices sets the triangle's vertices based on the specified points and indices.
func (t *Triangle) SetFromPointsAndIndices(points []Vector3, i0, i1, i2 int) {
        t.A = points[i0]
        t.B = points[i1]
        t.C = points[i2]
}

// Area returns the triangle's area.
func (t *Triangle) Area() float32 {
        v0 := t.C.Sub(t.B)
        v1 := t.A.Sub(t.B)
        return v0.Cross(v1).Length() * 0.5
}

// Midpoint returns the triangle's midpoint.
func (t *Triangle) Midpoint() Vector3 {
        return t.A.Add(t.B).Add(t.C).MulScalar(float32(1) / 3)
}

// Normal returns the triangle's normal.
func (t *Triangle) Normal() Vector3 {
        return Normal(t.A, t.B, t.C)
}

// Plane returns a Plane object aligned with the triangle.
func (t *Triangle) Plane() Plane {
        pv := Plane{}
        pv.SetFromCoplanarPoints(t.A, t.B, t.C)
        return pv
}

// BarycoordFromPoint returns the barycentric coordinates for the specified point.
func (t *Triangle) BarycoordFromPoint(point Vector3) Vector3 {
        return BarycoordFromPoint(point, t.A, t.B, t.C)
}

// ContainsPoint returns whether the triangle contains a point.
func (t *Triangle) ContainsPoint(point Vector3) bool {
        return ContainsPoint(point, t.A, t.B, t.C)
}

// Copyright (c) 2019, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

// Package vecint has vector types for emergent, including Vector2i which is a 2D
// vector with int values, using the API based on math32.Vector2i.
// This is distinct from math32.Vector2i because it uses int instead of int32, and
// the int is significantly easier to deal with for some use-cases.
package vecint

//go:generate core generate

import "cogentcore.org/core/math32"

// Vector2i is a 2D vector/point with X and Y int components.
type Vector2i struct {
        X int
        Y int
}

// Vec2i returns a new [Vector2i] with the given x and y components.
func Vec2i(x, y int) Vector2i {
        return Vector2i{X: x, Y: y}
}

// Vector2iScalar returns a new Vector2i with all components set to scalar.
func Vector2iScalar(scalar int) Vector2i {
        return Vector2i{X: scalar, Y: scalar}
}

// Vector2iFromVector2Round converts from floating point math32.Vector2 vector to int, using rounding
func Vector2iFromVector2Round(v math32.Vector2) Vector2i {
        return Vector2i{int(math32.Round(v.X)), int(math32.Round(v.Y))}
}

// Vector2iFromVector2Floor converts from floating point math32.Vector2 vector to int, using floor
func Vector2iFromVector2Floor(v math32.Vector2) Vector2i {
        return Vector2i{int(math32.Floor(v.X)), int(math32.Floor(v.Y))}
}

// Vector2iFromVector2Ceil converts from floating point math32.Vector2 vector to int, using ceil
func Vector2iFromVector2Ceil(v math32.Vector2) Vector2i {
        return Vector2i{X: int(math32.Ceil(v.X)), Y: int(math32.Ceil(v.Y))}
}

// ToVector2 returns floating point [math32.Vector2] from int.
func (v Vector2i) ToVector2() math32.Vector2 {
        return math32.Vec2(float32(v.X), float32(v.Y))
}

// Set sets this vector X and Y components.
func (v *Vector2i) Set(x, y int) {
        v.X = x
        v.Y = y
}

// SetScalar sets all vector components to same scalar value.
func (v *Vector2i) SetScalar(scalar int) {
        v.X = scalar
        v.Y = scalar
}

// SetDim sets this vector component value by its dimension index
func (v *Vector2i) SetDim(dim math32.Dims, value int) {
        switch dim {
        case math32.X:
                v.X = value
        case math32.Y:
                v.Y = value
        default:
                panic("dim is out of range")
        }
}

// Dim returns this vector component
func (v Vector2i) Dim(dim math32.Dims) int {
        switch dim {
        case math32.X:
                return v.X
        case math32.Y:
                return v.Y
        default:
                panic("dim is out of range")
        }
}

// SetZero sets all of the vector's components to zero.
func (v *Vector2i) SetZero() {
        v.SetScalar(0)
}

// FromSlice sets this vector's components from the given slice, starting at offset.
func (v *Vector2i) FromSlice(array []int, offset int) {
        v.X = array[offset]
        v.Y = array[offset+1]
}

// ToSlice copies this vector's components to the given slice, starting at offset.
func (v Vector2i) ToSlice(array []int, offset int) {
        array[offset] = v.X
        array[offset+1] = v.Y
}

// Basic math operations:

// Add adds the other given vector to this one and returns the result as a new vector.
func (v Vector2i) Add(other Vector2i) Vector2i {
        return Vector2i{v.X + other.X, v.Y + other.Y}
}

// AddScalar adds scalar s to each component of this vector and returns new vector.
func (v Vector2i) AddScalar(s int) Vector2i {
        return Vector2i{v.X + s, v.Y + s}
}

// SetAdd sets this to addition with other vector (i.e., += or plus-equals).
func (v *Vector2i) SetAdd(other Vector2i) {
        v.X += other.X
        v.Y += other.Y
}

// SetAddScalar sets this to addition with scalar.
func (v *Vector2i) SetAddScalar(s int) {
        v.X += s
        v.Y += s
}

// Sub subtracts other vector from this one and returns result in new vector.
func (v Vector2i) Sub(other Vector2i) Vector2i {
        return Vector2i{v.X - other.X, v.Y - other.Y}
}

// SubScalar subtracts scalar s from each component of this vector and returns new vector.
func (v Vector2i) SubScalar(s int) Vector2i {
        return Vector2i{v.X - s, v.Y - s}
}

// SetSub sets this to subtraction with other vector (i.e., -= or minus-equals).
func (v *Vector2i) SetSub(other Vector2i) {
        v.X -= other.X
        v.Y -= other.Y
}

// SetSubScalar sets this to subtraction of scalar.
func (v *Vector2i) SetSubScalar(s int) {
        v.X -= s
        v.Y -= s
}

// Mul multiplies each component of this vector by the corresponding one from other
// and returns resulting vector.
func (v Vector2i) Mul(other Vector2i) Vector2i {
        return Vector2i{v.X * other.X, v.Y * other.Y}
}

// MulScalar multiplies each component of this vector by the scalar s and returns resulting vector.
func (v Vector2i) MulScalar(s int) Vector2i {
        return Vector2i{v.X * s, v.Y * s}
}

// SetMul sets this to multiplication with other vector (i.e., *= or times-equals).
func (v *Vector2i) SetMul(other Vector2i) {
        v.X *= other.X
        v.Y *= other.Y
}

// SetMulScalar sets this to multiplication by scalar.
func (v *Vector2i) SetMulScalar(s int) {
        v.X *= s
        v.Y *= s
}

// Div divides each component of this vector by the corresponding one from other vector
// and returns resulting vector.
func (v Vector2i) Div(other Vector2i) Vector2i {
        return Vector2i{v.X / other.X, v.Y / other.Y}
}

// DivScalar divides each component of this vector by the scalar s and returns resulting vector.
// If scalar is zero, returns zero.
func (v Vector2i) DivScalar(scalar int) Vector2i {
        if scalar != 0 {
                return Vector2i{v.X / scalar, v.Y / scalar}
        }
        return Vector2i{}
}

// SetDiv sets this to division by other vector (i.e., /= or divide-equals).
func (v *Vector2i) SetDiv(other Vector2i) {
        v.X /= other.X
        v.Y /= other.Y
}

// SetDivScalar sets this to division by scalar.
func (v *Vector2i) SetDivScalar(scalar int) {
        if scalar != 0 {
                v.X /= scalar
                v.Y /= scalar
        } else {
                v.SetZero()
        }
}

// Min returns min of this vector components vs. other vector.
func (v Vector2i) Min(other Vector2i) Vector2i {
        return Vector2i{min(v.X, other.X), min(v.Y, other.Y)}
}

// SetMin sets this vector components to the minimum values of itself and other vector.
func (v *Vector2i) SetMin(other Vector2i) {
        v.X = min(v.X, other.X)
        v.Y = min(v.Y, other.Y)
}

// Max returns max of this vector components vs. other vector.
func (v Vector2i) Max(other Vector2i) Vector2i {
        return Vector2i{max(v.X, other.X), max(v.Y, other.Y)}
}

// SetMax sets this vector components to the maximum value of itself and other vector.
func (v *Vector2i) SetMax(other Vector2i) {
        v.X = max(v.X, other.X)
        v.Y = max(v.Y, other.Y)
}

// Clamp sets this vector's components to be no less than the corresponding
// components of min and not greater than the corresponding component of max.
// Assumes min < max; if this assumption isn't true, it will not operate correctly.
func (v *Vector2i) Clamp(min, max Vector2i) {
        if v.X < min.X {
                v.X = min.X
        } else if v.X > max.X {
                v.X = max.X
        }
        if v.Y < min.Y {
                v.Y = min.Y
        } else if v.Y > max.Y {
                v.Y = max.Y
        }
}

// Negate returns the vector with each component negated.
func (v Vector2i) Negate() Vector2i {
        return Vector2i{-v.X, -v.Y}
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import (
        "fmt"
        "image"

        "github.com/chewxy/math32"
        "golang.org/x/image/math/fixed"
)

// Vector2 is a 2D vector/point with X and Y components.
type Vector2 struct {
        X float32
        Y float32
}

// Vec2 returns a new [Vector2] with the given x and y components.
func Vec2(x, y float32) Vector2 {
        return Vector2{x, y}
}

// Vector2Scalar returns a new [Vector2] with all components set to the given scalar value.
func Vector2Scalar(scalar float32) Vector2 {
        return Vector2{scalar, scalar}
}

// Vector2Polar returns a new [Vector2] from polar coordinates,
// with angle in radians CCW and radius the distance from (0,0).
func Vector2Polar(angle, radius float32) Vector2 {
        return Vector2{radius * math32.Cos(angle), radius * math32.Sin(angle)}
}

// FromPoint returns a new [Vector2] from the given [image.Point].
func FromPoint(pt image.Point) Vector2 {
        v := Vector2{}
        v.SetPoint(pt)
        return v
}

// Vector2FromFixed returns a new [Vector2] from the given [fixed.Point26_6].
func Vector2FromFixed(pt fixed.Point26_6) Vector2 {
        v := Vector2{}
        v.SetFixed(pt)
        return v
}

// Set sets this vector's X and Y components.
func (v *Vector2) Set(x, y float32) {
        v.X = x
        v.Y = y
}

// SetScalar sets all vector components to the same scalar value.
func (v *Vector2) SetScalar(scalar float32) {
        v.X = scalar
        v.Y = scalar
}

// SetFromVector2i sets from a [Vector2i] (int32) vector.
func (v *Vector2) SetFromVector2i(vi Vector2i) {
        v.X = float32(vi.X)
        v.Y = float32(vi.Y)
}

// SetDim sets the given vector component value by its dimension index.
func (v *Vector2) SetDim(dim Dims, value float32) {
        switch dim {
        case X:
                v.X = value
        case Y:
                v.Y = value
        default:
                panic("dim is out of range")
        }
}

// Dim returns the given vector component.
func (v Vector2) Dim(dim Dims) float32 {
        switch dim {
        case X:
                return v.X
        case Y:
                return v.Y
        default:
                panic("dim is out of range")
        }
}

// SetPointDim sets the given dimension of the given [image.Point] to the given value.
func SetPointDim(pt *image.Point, dim Dims, value int) {
        switch dim {
        case X:
                pt.X = value
        case Y:
                pt.Y = value
        default:
                panic("dim is out of range")
        }
}

// PointDim returns the given dimension of the given [image.Point].
func PointDim(pt image.Point, dim Dims) int {
        switch dim {
        case X:
                return pt.X
        case Y:
                return pt.Y
        default:
                panic("dim is out of range")
        }
}

func (a Vector2) String() string {
        return fmt.Sprintf("(%v, %v)", a.X, a.Y)
}

// SetPoint sets the vector from the given [image.Point].
func (a *Vector2) SetPoint(pt image.Point) {
        a.X = float32(pt.X)
        a.Y = float32(pt.Y)
}

// SetFixed sets the vector from the given [fixed.Point26_6].
func (a *Vector2) SetFixed(pt fixed.Point26_6) {
        a.X = FromFixed(pt.X)
        a.Y = FromFixed(pt.Y)
}

// ToPoint returns the vector as an [image.Point].
func (a Vector2) ToPoint() image.Point {
        return image.Point{int(a.X), int(a.Y)}
}

// ToPointFloor returns the vector as an [image.Point] with all values [Floor]ed.
func (a Vector2) ToPointFloor() image.Point {
        return image.Point{int(Floor(a.X)), int(Floor(a.Y))}
}

// ToPointCeil returns the vector as an [image.Point] with all values [Ceil]ed.
func (a Vector2) ToPointCeil() image.Point {
        return image.Point{int(Ceil(a.X)), int(Ceil(a.Y))}
}

// ToPointRound returns the vector as an [image.Point] with all values [Round]ed.
func (a Vector2) ToPointRound() image.Point {
        return image.Point{int(Round(a.X)), int(Round(a.Y))}
}

// ToFixed returns the vector as a [fixed.Point26_6].
func (a Vector2) ToFixed() fixed.Point26_6 {
        return ToFixedPoint(a.X, a.Y)
}

// RectFromPosSizeMax returns an [image.Rectangle] from the floor of pos
// and ceil of size.
func RectFromPosSizeMax(pos, size Vector2) image.Rectangle {
        tp := pos.ToPointFloor()
        ts := size.ToPointCeil()
        return image.Rect(tp.X, tp.Y, tp.X+ts.X, tp.Y+ts.Y)
}

// RectFromPosSizeMin returns an [image.Rectangle] from the ceil of pos
// and floor of size.
func RectFromPosSizeMin(pos, size Vector2) image.Rectangle {
        tp := pos.ToPointCeil()
        ts := size.ToPointFloor()
        return image.Rect(tp.X, tp.Y, tp.X+ts.X, tp.Y+ts.Y)
}

// SetZero sets all of the vector's components to zero.
func (v *Vector2) SetZero() {
        v.SetScalar(0)
}

// FromSlice sets this vector's components from the given slice, starting at offset.
func (v *Vector2) FromSlice(slice []float32, offset int) {
        v.X = slice[offset]
        v.Y = slice[offset+1]
}

// ToSlice copies this vector's components to the given slice, starting at offset.
func (v Vector2) ToSlice(slice []float32, offset int) {
        slice[offset] = v.X
        slice[offset+1] = v.Y
}

// Basic math operations:

// Add adds the other given vector to this one and returns the result as a new vector.
func (v Vector2) Add(other Vector2) Vector2 {
        return Vec2(v.X+other.X, v.Y+other.Y)
}

// AddScalar adds scalar s to each component of this vector and returns new vector.
func (v Vector2) AddScalar(s float32) Vector2 {
        return Vec2(v.X+s, v.Y+s)
}

// SetAdd sets this to addition with other vector (i.e., += or plus-equals).
func (v *Vector2) SetAdd(other Vector2) {
        v.X += other.X
        v.Y += other.Y
}

// SetAddScalar sets this to addition with scalar.
func (v *Vector2) SetAddScalar(s float32) {
        v.X += s
        v.Y += s
}

// Sub subtracts other vector from this one and returns result in new vector.
func (v Vector2) Sub(other Vector2) Vector2 {
        return Vec2(v.X-other.X, v.Y-other.Y)
}

// SubScalar subtracts scalar s from each component of this vector and returns new vector.
func (v Vector2) SubScalar(s float32) Vector2 {
        return Vec2(v.X-s, v.Y-s)
}

// SetSub sets this to subtraction with other vector (i.e., -= or minus-equals).
func (v *Vector2) SetSub(other Vector2) {
        v.X -= other.X
        v.Y -= other.Y
}

// SetSubScalar sets this to subtraction of scalar.
func (v *Vector2) SetSubScalar(s float32) {
        v.X -= s
        v.Y -= s
}

// Mul multiplies each component of this vector by the corresponding one from other
// and returns resulting vector.
func (v Vector2) Mul(other Vector2) Vector2 {
        return Vec2(v.X*other.X, v.Y*other.Y)
}

// MulScalar multiplies each component of this vector by the scalar s and returns resulting vector.
func (v Vector2) MulScalar(s float32) Vector2 {
        return Vec2(v.X*s, v.Y*s)
}

// SetMul sets this to multiplication with other vector (i.e., *= or times-equals).
func (v *Vector2) SetMul(other Vector2) {
        v.X *= other.X
        v.Y *= other.Y
}

// SetMulScalar sets this to multiplication by scalar.
func (v *Vector2) SetMulScalar(s float32) {
        v.X *= s
        v.Y *= s
}

// Div divides each component of this vector by the corresponding one from other vector
// and returns resulting vector.
func (v Vector2) Div(other Vector2) Vector2 {
        return Vec2(v.X/other.X, v.Y/other.Y)
}

// DivScalar divides each component of this vector by the scalar s and returns resulting vector.
// If scalar is zero, returns zero.
func (v Vector2) DivScalar(scalar float32) Vector2 {
        if scalar != 0 {
                return v.MulScalar(1 / scalar)
        }
        return Vector2{}
}

// SetDiv sets this to division by other vector (i.e., /= or divide-equals).
func (v *Vector2) SetDiv(other Vector2) {
        v.X /= other.X
        v.Y /= other.Y
}

// SetDivScalar sets this to division by scalar.
func (v *Vector2) SetDivScalar(scalar float32) {
        if scalar != 0 {
                v.SetMulScalar(1 / scalar)
        } else {
                v.SetZero()
        }
}

// Abs returns the vector with [Abs] applied to each component.
func (v Vector2) Abs() Vector2 {
        return Vec2(Abs(v.X), Abs(v.Y))
}

// Min returns min of this vector components vs. other vector.
func (v Vector2) Min(other Vector2) Vector2 {
        return Vec2(Min(v.X, other.X), Min(v.Y, other.Y))
}

// SetMin sets this vector components to the minimum values of itself and other vector.
func (v *Vector2) SetMin(other Vector2) {
        v.X = Min(v.X, other.X)
        v.Y = Min(v.Y, other.Y)
}

// Max returns max of this vector components vs. other vector.
func (v Vector2) Max(other Vector2) Vector2 {
        return Vec2(Max(v.X, other.X), Max(v.Y, other.Y))
}

// SetMax sets this vector components to the maximum value of itself and other vector.
func (v *Vector2) SetMax(other Vector2) {
        v.X = Max(v.X, other.X)
        v.Y = Max(v.Y, other.Y)
}

// Clamp sets this vector's components to be no less than the corresponding
// components of min and not greater than the corresponding component of max.
// Assumes min < max; if this assumption isn't true, it will not operate correctly.
func (v *Vector2) Clamp(min, max Vector2) {
        if v.X < min.X {
                v.X = min.X
        } else if v.X > max.X {
                v.X = max.X
        }
        if v.Y < min.Y {
                v.Y = min.Y
        } else if v.Y > max.Y {
                v.Y = max.Y
        }
}

// Floor returns this vector with [Floor] applied to each of its components.
func (v Vector2) Floor() Vector2 {
        return Vec2(Floor(v.X), Floor(v.Y))
}

// Ceil returns this vector with [Ceil] applied to each of its components.
func (v Vector2) Ceil() Vector2 {
        return Vec2(Ceil(v.X), Ceil(v.Y))
}

// Round returns this vector with [Round] applied to each of its components.
func (v Vector2) Round() Vector2 {
        return Vec2(Round(v.X), Round(v.Y))
}

// Negate returns the vector with each component negated.
func (v Vector2) Negate() Vector2 {
        return Vec2(-v.X, -v.Y)
}

// AddDim returns the vector with the given value added on the given dimension.
func (a Vector2) AddDim(d Dims, value float32) Vector2 {
        switch d {
        case X:
                a.X += value
        case Y:
                a.Y += value
        }
        return a
}

// SubDim returns the vector with the given value subtracted on the given dimension.
func (a Vector2) SubDim(d Dims, value float32) Vector2 {
        switch d {
        case X:
                a.X -= value
        case Y:
                a.Y -= value
        }
        return a
}

// MulDim returns the vector with the given value multiplied by on the given dimension.
func (a Vector2) MulDim(d Dims, value float32) Vector2 {
        switch d {
        case X:
                a.X *= value
        case Y:
                a.Y *= value
        }
        return a
}

// DivDim returns the vector with the given value divided by on the given dimension.
func (a Vector2) DivDim(d Dims, value float32) Vector2 {
        switch d {
        case X:
                a.X /= value
        case Y:
                a.Y /= value
        }
        return a
}

// Distance, Normal:

// Dot returns the dot product of this vector with the given other vector.
func (v Vector2) Dot(other Vector2) float32 {
        return v.X*other.X + v.Y*other.Y
}

// Length returns the length (magnitude) of this vector.
func (v Vector2) Length() float32 {
        return Sqrt(v.LengthSquared())
}

// LengthSquared returns the length squared of this vector.
// LengthSquared can be used to compare the lengths of vectors
// without the need to perform a square root.
func (v Vector2) LengthSquared() float32 {
        return v.X*v.X + v.Y*v.Y
}

// Normal returns this vector divided by its length (its unit vector).
func (v Vector2) Normal() Vector2 {
        l := v.Length()
        if l == 0 {
                return Vector2{}
        }
        return v.DivScalar(l)
}

// DistanceTo returns the distance between these two vectors as points.
func (v Vector2) DistanceTo(other Vector2) float32 {
        return Sqrt(v.DistanceToSquared(other))
}

// DistanceToSquared returns the squared distance between these two vectors as points.
func (v Vector2) DistanceToSquared(other Vector2) float32 {
        dx := v.X - other.X
        dy := v.Y - other.Y
        return dx*dx + dy*dy
}

// Cross returns the cross product of this vector with other.
func (v Vector2) Cross(other Vector2) float32 {
        return v.X*other.Y - v.Y*other.X
}

// CosTo returns the cosine (normalized dot product) between this vector and other.
func (v Vector2) CosTo(other Vector2) float32 {
        return v.Dot(other) / (v.Length() * other.Length())
}

// AngleTo returns the angle between this vector and other.
// Returns angles in range of -PI to PI (not 0 to 2 PI).
func (v Vector2) AngleTo(other Vector2) float32 {
        ang := Acos(Clamp(v.CosTo(other), -1, 1))
        cross := v.Cross(other)
        if cross > 0 {
                ang = -ang
        }
        return ang
}

// Lerp returns vector with each components as the linear interpolated value of
// alpha between itself and the corresponding other component.
func (v Vector2) Lerp(other Vector2, alpha float32) Vector2 {
        return Vec2(v.X+(other.X-v.X)*alpha, v.Y+(other.Y-v.Y)*alpha)
}

// InTriangle returns whether the vector is inside the specified triangle.
func (v Vector2) InTriangle(p0, p1, p2 Vector2) bool {
        A := 0.5 * (-p1.Y*p2.X + p0.Y*(-p1.X+p2.X) + p0.X*(p1.Y-p2.Y) + p1.X*p2.Y)
        sign := float32(1)
        if A < 0 {
                sign = float32(-1)
        }
        s := (p0.Y*p2.X - p0.X*p2.Y + (p2.Y-p0.Y)*v.X + (p0.X-p2.X)*v.Y) * sign
        t := (p0.X*p1.Y - p0.Y*p1.X + (p0.Y-p1.Y)*v.X + (p1.X-p0.X)*v.Y) * sign

        return s >= 0 && t >= 0 && (s+t) < 2*A*sign
}

// Rot90CW rotates the line OP by 90 degrees CW.
func (v Vector2) Rot90CW() Vector2 {
        return Vector2{v.Y, -v.X}
}

// Rot90CCW rotates the line OP by 90 degrees CCW.
func (v Vector2) Rot90CCW() Vector2 {
        return Vector2{-v.Y, v.X}
}

// Rot rotates the line OP by phi radians CCW.
func (v Vector2) Rot(phi float32, p0 Vector2) Vector2 {
        sinphi, cosphi := math32.Sincos(phi)
        return Vector2{
                p0.X + cosphi*(v.X-p0.X) - sinphi*(v.Y-p0.Y),
                p0.Y + sinphi*(v.X-p0.X) + cosphi*(v.Y-p0.Y),
        }
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

// Vector2i is a 2D vector/point with X and Y int32 components.
type Vector2i struct {
        X int32
        Y int32
}

// Vec2i returns a new [Vector2i] with the given x and y components.
func Vec2i(x, y int32) Vector2i {
        return Vector2i{X: x, Y: y}
}

// Vector2iScalar returns a new [Vector2i] with all components set to the given scalar value.
func Vector2iScalar(scalar int32) Vector2i {
        return Vector2i{X: scalar, Y: scalar}
}

// Set sets this vector X and Y components.
func (v *Vector2i) Set(x, y int32) {
        v.X = x
        v.Y = y
}

// SetScalar sets all vector components to the same scalar value.
func (v *Vector2i) SetScalar(scalar int32) {
        v.X = scalar
        v.Y = scalar
}

// SetFromVector2 sets from a [Vector2] (float32) vector.
func (v *Vector2i) SetFromVector2(vf Vector2) {
        v.X = int32(vf.X)
        v.Y = int32(vf.Y)
}

// SetDim sets the given vector component value by its dimension index.
func (v *Vector2i) SetDim(dim Dims, value int32) {
        switch dim {
        case X:
                v.X = value
        case Y:
                v.Y = value
        default:
                panic("dim is out of range")
        }
}

// Dim returns the given vector component.
func (v Vector2i) Dim(dim Dims) int32 {
        switch dim {
        case X:
                return v.X
        case Y:
                return v.Y
        default:
                panic("dim is out of range")
        }
}

// SetZero sets all of the vector's components to zero.
func (v *Vector2i) SetZero() {
        v.SetScalar(0)
}

// FromSlice sets this vector's components from the given slice, starting at offset.
func (v *Vector2i) FromSlice(array []int32, offset int) {
        v.X = array[offset]
        v.Y = array[offset+1]
}

// ToSlice copies this vector's components to the given slice, starting at offset.
func (v Vector2i) ToSlice(array []int32, offset int) {
        array[offset] = v.X
        array[offset+1] = v.Y
}

// Basic math operations:

// Add adds the other given vector to this one and returns the result as a new vector.
func (v Vector2i) Add(other Vector2i) Vector2i {
        return Vector2i{v.X + other.X, v.Y + other.Y}
}

// AddScalar adds scalar s to each component of this vector and returns new vector.
func (v Vector2i) AddScalar(s int32) Vector2i {
        return Vector2i{v.X + s, v.Y + s}
}

// SetAdd sets this to addition with other vector (i.e., += or plus-equals).
func (v *Vector2i) SetAdd(other Vector2i) {
        v.X += other.X
        v.Y += other.Y
}

// SetAddScalar sets this to addition with scalar.
func (v *Vector2i) SetAddScalar(s int32) {
        v.X += s
        v.Y += s
}

// Sub subtracts other vector from this one and returns result in new vector.
func (v Vector2i) Sub(other Vector2i) Vector2i {
        return Vector2i{v.X - other.X, v.Y - other.Y}
}

// SubScalar subtracts scalar s from each component of this vector and returns new vector.
func (v Vector2i) SubScalar(s int32) Vector2i {
        return Vector2i{v.X - s, v.Y - s}
}

// SetSub sets this to subtraction with other vector (i.e., -= or minus-equals).
func (v *Vector2i) SetSub(other Vector2i) {
        v.X -= other.X
        v.Y -= other.Y
}

// SetSubScalar sets this to subtraction of scalar.
func (v *Vector2i) SetSubScalar(s int32) {
        v.X -= s
        v.Y -= s
}

// Mul multiplies each component of this vector by the corresponding one from other
// and returns resulting vector.
func (v Vector2i) Mul(other Vector2i) Vector2i {
        return Vector2i{v.X * other.X, v.Y * other.Y}
}

// MulScalar multiplies each component of this vector by the scalar s and returns resulting vector.
func (v Vector2i) MulScalar(s int32) Vector2i {
        return Vector2i{v.X * s, v.Y * s}
}

// SetMul sets this to multiplication with other vector (i.e., *= or times-equals).
func (v *Vector2i) SetMul(other Vector2i) {
        v.X *= other.X
        v.Y *= other.Y
}

// SetMulScalar sets this to multiplication by scalar.
func (v *Vector2i) SetMulScalar(s int32) {
        v.X *= s
        v.Y *= s
}

// Div divides each component of this vector by the corresponding one from other vector
// and returns resulting vector.
func (v Vector2i) Div(other Vector2i) Vector2i {
        return Vector2i{v.X / other.X, v.Y / other.Y}
}

// DivScalar divides each component of this vector by the scalar s and returns resulting vector.
// If scalar is zero, returns zero.
func (v Vector2i) DivScalar(scalar int32) Vector2i {
        if scalar != 0 {
                return Vector2i{v.X / scalar, v.Y / scalar}
        }
        return Vector2i{}
}

// SetDiv sets this to division by other vector (i.e., /= or divide-equals).
func (v *Vector2i) SetDiv(other Vector2i) {
        v.X /= other.X
        v.Y /= other.Y
}

// SetDivScalar sets this to division by scalar.
func (v *Vector2i) SetDivScalar(scalar int32) {
        if scalar != 0 {
                v.X /= scalar
                v.Y /= scalar
        } else {
                v.SetZero()
        }
}

// Min returns min of this vector components vs. other vector.
func (v Vector2i) Min(other Vector2i) Vector2i {
        return Vector2i{min(v.X, other.X), min(v.Y, other.Y)}
}

// SetMin sets this vector components to the minimum values of itself and other vector.
func (v *Vector2i) SetMin(other Vector2i) {
        v.X = min(v.X, other.X)
        v.Y = min(v.Y, other.Y)
}

// Max returns max of this vector components vs. other vector.
func (v Vector2i) Max(other Vector2i) Vector2i {
        return Vector2i{max(v.X, other.X), max(v.Y, other.Y)}
}

// SetMax sets this vector components to the maximum value of itself and other vector.
func (v *Vector2i) SetMax(other Vector2i) {
        v.X = max(v.X, other.X)
        v.Y = max(v.Y, other.Y)
}

// Clamp sets this vector's components to be no less than the corresponding
// components of min and not greater than the corresponding component of max.
// Assumes min < max; if this assumption isn't true, it will not operate correctly.
func (v *Vector2i) Clamp(min, max Vector2i) {
        if v.X < min.X {
                v.X = min.X
        } else if v.X > max.X {
                v.X = max.X
        }
        if v.Y < min.Y {
                v.Y = min.Y
        } else if v.Y > max.Y {
                v.Y = max.Y
        }
}

// Negate returns the vector with each component negated.
func (v Vector2i) Negate() Vector2i {
        return Vector2i{-v.X, -v.Y}
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import "fmt"

// Vector3 is a 3D vector/point with X, Y and Z components.
type Vector3 struct {
        X float32
        Y float32
        Z float32
}

// Vec3 returns a new [Vector3] with the given x, y and z components.
func Vec3(x, y, z float32) Vector3 {
        return Vector3{x, y, z}
}

// Vector3Scalar returns a new [Vector3] with all components set to the given scalar value.
func Vector3Scalar(scalar float32) Vector3 {
        return Vector3{scalar, scalar, scalar}
}

// Vector3FromVector4 returns a new [Vector3] from the given [Vector4].
func Vector3FromVector4(v Vector4) Vector3 {
        nv := Vector3{}
        nv.SetFromVector4(v)
        return nv
}

// Set sets this vector X, Y and Z components.
func (v *Vector3) Set(x, y, z float32) {
        v.X = x
        v.Y = y
        v.Z = z
}

// SetScalar sets all vector components to the same scalar value.
func (v *Vector3) SetScalar(scalar float32) {
        v.X = scalar
        v.Y = scalar
        v.Z = scalar
}

// SetFromVector4 sets this vector from a Vector4
func (v *Vector3) SetFromVector4(other Vector4) {
        v.X = other.X
        v.Y = other.Y
        v.Z = other.Z
}

// SetFromVector3i sets from a Vector3i (int32) vector.
func (v *Vector3) SetFromVector3i(vi Vector3i) {
        v.X = float32(vi.X)
        v.Y = float32(vi.Y)
        v.Z = float32(vi.Z)
}

// SetDim sets this vector component value by dimension index.
func (v *Vector3) SetDim(dim Dims, value float32) {
        switch dim {
        case X:
                v.X = value
        case Y:
                v.Y = value
        case Z:
                v.Z = value
        default:
                panic("dim is out of range: ")
        }
}

// Dim returns this vector component
func (v Vector3) Dim(dim Dims) float32 {
        switch dim {
        case X:
                return v.X
        case Y:
                return v.Y
        case Z:
                return v.Z
        default:
                panic("dim is out of range")
        }
}

func (a Vector3) String() string {
        return fmt.Sprintf("(%v, %v, %v)", a.X, a.Y, a.Z)
}

// GenGoSet returns code to set values in object at given path (var.member etc).
func (v *Vector3) GenGoSet(path string) string {
        return fmt.Sprintf("%s.Set(%g, %g, %g)", path, v.X, v.Y, v.Z)
}

// SetZero sets all of the vector's components to zero.
func (v *Vector3) SetZero() {
        v.SetScalar(0)
}

// FromSlice sets this vector's components from the given slice, starting at offset.
func (v *Vector3) FromSlice(array []float32, offset int) {
        v.X = array[offset]
        v.Y = array[offset+1]
        v.Z = array[offset+2]
}

// ToSlice copies this vector's components to the given slice, starting at offset.
func (v Vector3) ToSlice(array []float32, offset int) {
        array[offset] = v.X
        array[offset+1] = v.Y
        array[offset+2] = v.Z
}

// Basic math operations:

// Add adds the other given vector to this one and returns the result as a new vector.
func (v Vector3) Add(other Vector3) Vector3 {
        return Vec3(v.X+other.X, v.Y+other.Y, v.Z+other.Z)
}

// AddScalar adds scalar s to each component of this vector and returns new vector.
func (v Vector3) AddScalar(s float32) Vector3 {
        return Vec3(v.X+s, v.Y+s, v.Z+s)
}

// SetAdd sets this to addition with other vector (i.e., += or plus-equals).
func (v *Vector3) SetAdd(other Vector3) {
        v.X += other.X
        v.Y += other.Y
        v.Z += other.Z
}

// SetAddScalar sets this to addition with scalar.
func (v *Vector3) SetAddScalar(s float32) {
        v.X += s
        v.Y += s
        v.Z += s
}

// Sub subtracts other vector from this one and returns result in new vector.
func (v Vector3) Sub(other Vector3) Vector3 {
        return Vec3(v.X-other.X, v.Y-other.Y, v.Z-other.Z)
}

// SubScalar subtracts scalar s from each component of this vector and returns new vector.
func (v Vector3) SubScalar(s float32) Vector3 {
        return Vec3(v.X-s, v.Y-s, v.Z-s)
}

// SetSub sets this to subtraction with other vector (i.e., -= or minus-equals).
func (v *Vector3) SetSub(other Vector3) {
        v.X -= other.X
        v.Y -= other.Y
        v.Z -= other.Z
}

// SetSubScalar sets this to subtraction of scalar.
func (v *Vector3) SetSubScalar(s float32) {
        v.X -= s
        v.Y -= s
        v.Z -= s
}

// Mul multiplies each component of this vector by the corresponding one from other
// and returns resulting vector.
func (v Vector3) Mul(other Vector3) Vector3 {
        return Vec3(v.X*other.X, v.Y*other.Y, v.Z*other.Z)
}

// MulScalar multiplies each component of this vector by the scalar s and returns resulting vector.
func (v Vector3) MulScalar(s float32) Vector3 {
        return Vec3(v.X*s, v.Y*s, v.Z*s)
}

// SetMul sets this to multiplication with other vector (i.e., *= or times-equals).
func (v *Vector3) SetMul(other Vector3) {
        v.X *= other.X
        v.Y *= other.Y
        v.Z *= other.Z
}

// SetMulScalar sets this to multiplication by scalar.
func (v *Vector3) SetMulScalar(s float32) {
        v.X *= s
        v.Y *= s
        v.Z *= s
}

// Div divides each component of this vector by the corresponding one from other vector
// and returns resulting vector.
func (v Vector3) Div(other Vector3) Vector3 {
        return Vec3(v.X/other.X, v.Y/other.Y, v.Z/other.Z)
}

// DivScalar divides each component of this vector by the scalar s and returns resulting vector.
// If scalar is zero, returns zero.
func (v Vector3) DivScalar(scalar float32) Vector3 {
        if scalar != 0 {
                return v.MulScalar(1 / scalar)
        }
        return Vector3{}
}

// SetDiv sets this to division by other vector (i.e., /= or divide-equals).
func (v *Vector3) SetDiv(other Vector3) {
        v.X /= other.X
        v.Y /= other.Y
        v.Z /= other.Z
}

// SetDivScalar sets this to division by scalar.
func (v *Vector3) SetDivScalar(scalar float32) {
        if scalar != 0 {
                v.SetMulScalar(1 / scalar)
        } else {
                v.SetZero()
        }
}

// Min returns min of this vector components vs. other vector.
func (v Vector3) Min(other Vector3) Vector3 {
        return Vec3(Min(v.X, other.X), Min(v.Y, other.Y), Min(v.Z, other.Z))
}

// SetMin sets this vector components to the minimum values of itself and other vector.
func (v *Vector3) SetMin(other Vector3) {
        v.X = Min(v.X, other.X)
        v.Y = Min(v.Y, other.Y)
        v.Z = Min(v.Z, other.Z)
}

// Max returns max of this vector components vs. other vector.
func (v Vector3) Max(other Vector3) Vector3 {
        return Vec3(Max(v.X, other.X), Max(v.Y, other.Y), Max(v.Z, other.Z))
}

// SetMax sets this vector components to the maximum value of itself and other vector.
func (v *Vector3) SetMax(other Vector3) {
        v.X = Max(v.X, other.X)
        v.Y = Max(v.Y, other.Y)
        v.Z = Max(v.Z, other.Z)
}

// Clamp sets this vector's components to be no less than the corresponding
// components of min and not greater than the corresponding component of max.
// Assumes min < max; if this assumption isn't true, it will not operate correctly.
func (v *Vector3) Clamp(min, max Vector3) {
        if v.X < min.X {
                v.X = min.X
        } else if v.X > max.X {
                v.X = max.X
        }
        if v.Y < min.Y {
                v.Y = min.Y
        } else if v.Y > max.Y {
                v.Y = max.Y
        }
        if v.Z < min.Z {
                v.Z = min.Z
        } else if v.Z > max.Z {
                v.Z = max.Z
        }
}

// Floor returns this vector with [Floor] applied to each of its components.
func (v Vector3) Floor() Vector3 {
        return Vec3(Floor(v.X), Floor(v.Y), Floor(v.Z))
}

// Ceil returns this vector with [Ceil] applied to each of its components.
func (v Vector3) Ceil() Vector3 {
        return Vec3(Ceil(v.X), Ceil(v.Y), Ceil(v.Z))
}

// Round returns this vector with [Round] applied to each of its components.
func (v Vector3) Round() Vector3 {
        return Vec3(Round(v.X), Round(v.Y), Round(v.Z))
}

// Negate returns the vector with each component negated.
func (v Vector3) Negate() Vector3 {
        return Vec3(-v.X, -v.Y, -v.Z)
}

// Abs returns the vector with [Abs] applied to each component.
func (v Vector3) Abs() Vector3 {
        return Vec3(Abs(v.X), Abs(v.Y), Abs(v.Z))
}

// Distance, Normal:

// Dot returns the dot product of this vector with the given other vector.
func (v Vector3) Dot(other Vector3) float32 {
        return v.X*other.X + v.Y*other.Y + v.Z*other.Z
}

// Length returns the length (magnitude) of this vector.
func (v Vector3) Length() float32 {
        return Sqrt(v.X*v.X + v.Y*v.Y + v.Z*v.Z)
}

// LengthSquared returns the length squared of this vector.
// LengthSquared can be used to compare the lengths of vectors
// without the need to perform a square root.
func (v Vector3) LengthSquared() float32 {
        return v.X*v.X + v.Y*v.Y + v.Z*v.Z
}

// Normal returns this vector divided by its length (its unit vector).
func (v Vector3) Normal() Vector3 {
        return v.DivScalar(v.Length())
}

// SetNormal normalizes this vector so its length will be 1.
func (v *Vector3) SetNormal() {
        v.SetDivScalar(v.Length())
}

// DistanceTo returns the distance between these two vectors as points.
func (v Vector3) DistanceTo(other Vector3) float32 {
        return Sqrt(v.DistanceToSquared(other))
}

// DistanceToSquared returns the squared distance between these two vectors as points.
func (v Vector3) DistanceToSquared(other Vector3) float32 {
        dx := v.X - other.X
        dy := v.Y - other.Y
        dz := v.Z - other.Z
        return dx*dx + dy*dy + dz*dz
}

// Lerp returns vector with each components as the linear interpolated value of
// alpha between itself and the corresponding other component.
func (v Vector3) Lerp(other Vector3, alpha float32) Vector3 {
        return Vec3(v.X+(other.X-v.X)*alpha, v.Y+(other.Y-v.Y)*alpha, v.Z+(other.Z-v.Z)*alpha)
}

// Matrix operations:

// MulMatrix3 returns the vector multiplied by the given 3x3 matrix.
func (v Vector3) MulMatrix3(m *Matrix3) Vector3 {
        return Vector3{m[0]*v.X + m[3]*v.Y + m[6]*v.Z,
                m[1]*v.X + m[4]*v.Y + m[7]*v.Z,
                m[2]*v.X + m[5]*v.Y + m[8]*v.Z}
}

// MulMatrix4 returns the vector multiplied by the given 4x4 matrix.
func (v Vector3) MulMatrix4(m *Matrix4) Vector3 {
        return Vector3{m[0]*v.X + m[4]*v.Y + m[8]*v.Z + m[12],
                m[1]*v.X + m[5]*v.Y + m[9]*v.Z + m[13],
                m[2]*v.X + m[6]*v.Y + m[10]*v.Z + m[14]}
}

// MulMatrix4AsVector4 returns 3-dim vector multiplied by specified 4x4 matrix
// using a 4-dim vector with given 4th dimensional value, then reduced back to
// a 3-dimensional vector.  This is somehow different from just straight
// MulMatrix4 on the 3-dim vector.  Use 0 for normals and 1 for positions
// as the 4th dim to set.
func (v Vector3) MulMatrix4AsVector4(m *Matrix4, w float32) Vector3 {
        return Vector3FromVector4(Vector4FromVector3(v, w).MulMatrix4(m))
}

// NDCToWindow converts normalized display coordinates (NDC) to window
// (pixel) coordinates, using given window size parameters.
// near, far are 0, 1 by default (glDepthRange defaults).
// flipY if true means flip the Y axis (top = 0 for windows vs. bottom = 0 for 3D coords)
func (v Vector3) NDCToWindow(size, off Vector2, near, far float32, flipY bool) Vector3 {
        w := Vector3{}
        half := size.MulScalar(0.5)
        w.X = half.X*v.X + half.X
        w.Y = half.Y*v.Y + half.Y
        w.Z = 0.5*(far-near)*v.Z + 0.5*(far+near)
        if flipY {
                w.Y = size.Y - w.Y
        }
        w.X += off.X
        w.Y += off.Y
        return w
}

// WindowToNDC converts window (pixel) coordinates to
// normalized display coordinates (NDC), using given window size parameters.
// The Z depth coordinate (0-1) must be set manually or by reading from framebuffer
// flipY if true means flip the Y axis (top = 0 for windows vs. bottom = 0 for 3D coords)
func (v Vector2) WindowToNDC(size, off Vector2, flipY bool) Vector3 {
        n := Vector3{}
        half := size.MulScalar(0.5)
        n.X = v.X - off.X
        n.Y = v.Y - off.Y
        if flipY {
                n.Y = size.Y - n.Y
        }
        n.X = n.X/half.X - 1
        n.Y = n.Y/half.Y - 1
        return n
}

// MulProjection returns vector multiplied by the projection matrix m.
func (v Vector3) MulProjection(m *Matrix4) Vector3 {
        d := 1 / (m[3]*v.X + m[7]*v.Y + m[11]*v.Z + m[15]) // perspective divide
        return Vector3{(m[0]*v.X + m[4]*v.Y + m[8]*v.Z + m[12]) * d,
                (m[1]*v.X + m[5]*v.Y + m[9]*v.Z + m[13]) * d,
                (m[2]*v.X + m[6]*v.Y + m[10]*v.Z + m[14]) * d}
}

// MulQuat returns vector multiplied by specified quaternion and
// then by the quaternion inverse.
// It basically applies the rotation encoded in the quaternion to this vector.
func (v Vector3) MulQuat(q Quat) Vector3 {
        qx := q.X
        qy := q.Y
        qz := q.Z
        qw := q.W
        // calculate quat * vector
        ix := qw*v.X + qy*v.Z - qz*v.Y
        iy := qw*v.Y + qz*v.X - qx*v.Z
        iz := qw*v.Z + qx*v.Y - qy*v.X
        iw := -qx*v.X - qy*v.Y - qz*v.Z
        // calculate result * inverse quat
        return Vector3{ix*qw + iw*-qx + iy*-qz - iz*-qy,
                iy*qw + iw*-qy + iz*-qx - ix*-qz,
                iz*qw + iw*-qz + ix*-qy - iy*-qx}
}

// Cross returns the cross product of this vector with other.
func (v Vector3) Cross(other Vector3) Vector3 {
        return Vec3(v.Y*other.Z-v.Z*other.Y, v.Z*other.X-v.X*other.Z, v.X*other.Y-v.Y*other.X)
}

// ProjectOnVector returns vector projected on other vector.
func (v *Vector3) ProjectOnVector(other Vector3) Vector3 {
        on := other.Normal()
        return on.MulScalar(v.Dot(on))
}

// ProjectOnPlane returns vector projected on the plane specified by normal vector.
func (v *Vector3) ProjectOnPlane(planeNormal Vector3) Vector3 {
        return v.Sub(v.ProjectOnVector(planeNormal))
}

// Reflect returns vector reflected relative to the normal vector (assumed to be
// already normalized).
func (v *Vector3) Reflect(normal Vector3) Vector3 {
        return v.Sub(normal.MulScalar(2 * v.Dot(normal)))
}

// CosTo returns the cosine (normalized dot product) between this vector and other.
func (v Vector3) CosTo(other Vector3) float32 {
        return v.Dot(other) / (v.Length() * other.Length())
}

// AngleTo returns the angle between this vector and other.
// Returns angles in range of -PI to PI (not 0 to 2 PI).
func (v Vector3) AngleTo(other Vector3) float32 {
        ang := Acos(Clamp(v.CosTo(other), -1, 1))
        cross := v.Cross(other)
        switch {
        case Abs(cross.Z) >= Abs(cross.Y) && Abs(cross.Z) >= Abs(cross.X):
                if cross.Z > 0 {
                        ang = -ang
                }
        case Abs(cross.Y) >= Abs(cross.Z) && Abs(cross.Y) >= Abs(cross.X):
                if cross.Y > 0 {
                        ang = -ang
                }
        case Abs(cross.X) >= Abs(cross.Z) && Abs(cross.X) >= Abs(cross.Y):
                if cross.X > 0 {
                        ang = -ang
                }
        }
        return ang
}

// SetFromMatrixPos set this vector from the translation coordinates
// in the specified transformation matrix.
func (v *Vector3) SetFromMatrixPos(m *Matrix4) {
        v.X = m[12]
        v.Y = m[13]
        v.Z = m[14]
}

// SetEulerAnglesFromMatrix sets this vector components to the Euler angles
// from the specified pure rotation matrix.
func (v *Vector3) SetEulerAnglesFromMatrix(m *Matrix4) {
        m11 := m[0]
        m12 := m[4]
        m13 := m[8]
        m22 := m[5]
        m23 := m[9]
        m32 := m[6]
        m33 := m[10]

        v.Y = Asin(Clamp(m13, -1, 1))
        if Abs(m13) < 0.99999 {
                v.X = Atan2(-m23, m33)
                v.Z = Atan2(-m12, m11)
        } else {
                v.X = Atan2(m32, m22)
                v.Z = 0
        }
}

// NewEulerAnglesFromMatrix returns a Vector3 with components as the Euler angles
// from the specified pure rotation matrix.
func NewEulerAnglesFromMatrix(m *Matrix4) Vector3 {
        rot := Vector3{}
        rot.SetEulerAnglesFromMatrix(m)
        return rot
}

// SetEulerAnglesFromQuat sets this vector components to the Euler angles
// from the specified quaternion.
func (v *Vector3) SetEulerAnglesFromQuat(q Quat) {
        mat := Identity4()
        mat.SetRotationFromQuat(q)
        v.SetEulerAnglesFromMatrix(mat)
}

// RandomTangents computes and returns two arbitrary tangents to the vector.
func (v *Vector3) RandomTangents() (Vector3, Vector3) {
        t1 := Vector3{}
        t2 := Vector3{}
        length := v.Length()
        if length > 0 {
                n := v.Normal()
                randVec := Vector3{}
                if Abs(n.X) < 0.9 {
                        randVec.X = 1
                        t1 = n.Cross(randVec)
                } else if Abs(n.Y) < 0.9 {
                        randVec.Y = 1
                        t1 = n.Cross(randVec)
                } else {
                        randVec.Z = 1
                        t1 = n.Cross(randVec)
                }
                t2 = n.Cross(t1)
        } else {
                t1.X = 1
                t2.Y = 1
        }
        return t1, t2
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

// Vector3i is a 3D vector/point with X, Y and Z int32 components.
type Vector3i struct {
        X int32
        Y int32
        Z int32
}

// Vec3i returns a new [Vector3i] with the given x, y and y components.
func Vec3i(x, y, z int32) Vector3i {
        return Vector3i{X: x, Y: y, Z: z}
}

// Vector3iScalar returns a new [Vector3i] with all components set to the given scalar value.
func Vector3iScalar(scalar int32) Vector3i {
        return Vector3i{X: scalar, Y: scalar, Z: scalar}
}

// Set sets this vector X, Y and Z components.
func (v *Vector3i) Set(x, y, z int32) {
        v.X = x
        v.Y = y
        v.Z = z
}

// SetScalar sets all vector components to the same scalar value.
func (v *Vector3i) SetScalar(scalar int32) {
        v.X = scalar
        v.Y = scalar
        v.Z = scalar
}

// SetFromVector3 sets from a Vector3 (float32) vector.
func (v *Vector3i) SetFromVector3(vf Vector3) {
        v.X = int32(vf.X)
        v.Y = int32(vf.Y)
        v.Z = int32(vf.Z)
}

// SetDim sets the given vector component value by its dimension index.
func (v *Vector3i) SetDim(dim Dims, value int32) {
        switch dim {
        case X:
                v.X = value
        case Y:
                v.Y = value
        case Z:
                v.Z = value
        default:
                panic("dim is out of range: ")
        }
}

// Dim returns the given vector component.
func (v Vector3i) Dim(dim Dims) int32 {
        switch dim {
        case X:
                return v.X
        case Y:
                return v.Y
        case Z:
                return v.Z
        default:
                panic("dim is out of range")
        }
}

// SetZero sets all of the vector's components to zero.
func (v *Vector3i) SetZero() {
        v.SetScalar(0)
}

// FromSlice sets this vector's components from the given slice, starting at offset.
func (v *Vector3i) FromSlice(array []int32, offset int) {
        v.X = array[offset]
        v.Y = array[offset+1]
        v.Z = array[offset+2]
}

// ToSlice copies this vector's components to the given slice, starting at offset.
func (v Vector3i) ToSlice(array []int32, offset int) {
        array[offset] = v.X
        array[offset+1] = v.Y
        array[offset+2] = v.Z
}

// Basic math operations:

// Add adds the other given vector to this one and returns the result as a new vector.
func (v Vector3i) Add(other Vector3i) Vector3i {
        return Vector3i{v.X + other.X, v.Y + other.Y, v.Z + other.Z}
}

// AddScalar adds scalar s to each component of this vector and returns new vector.
func (v Vector3i) AddScalar(s int32) Vector3i {
        return Vector3i{v.X + s, v.Y + s, v.Z + s}
}

// SetAdd sets this to addition with other vector (i.e., += or plus-equals).
func (v *Vector3i) SetAdd(other Vector3i) {
        v.X += other.X
        v.Y += other.Y
        v.Z += other.Z
}

// SetAddScalar sets this to addition with scalar.
func (v *Vector3i) SetAddScalar(s int32) {
        v.X += s
        v.Y += s
        v.Z += s
}

// Sub subtracts other vector from this one and returns result in new vector.
func (v Vector3i) Sub(other Vector3i) Vector3i {
        return Vector3i{v.X - other.X, v.Y - other.Y, v.Z - other.Z}
}

// SubScalar subtracts scalar s from each component of this vector and returns new vector.
func (v Vector3i) SubScalar(s int32) Vector3i {
        return Vector3i{v.X - s, v.Y - s, v.Z - s}
}

// SetSub sets this to subtraction with other vector (i.e., -= or minus-equals).
func (v *Vector3i) SetSub(other Vector3i) {
        v.X -= other.X
        v.Y -= other.Y
        v.Z -= other.Z
}

// SetSubScalar sets this to subtraction of scalar.
func (v *Vector3i) SetSubScalar(s int32) {
        v.X -= s
        v.Y -= s
        v.Z -= s
}

// Mul multiplies each component of this vector by the corresponding one from other
// and returns resulting vector.
func (v Vector3i) Mul(other Vector3i) Vector3i {
        return Vector3i{v.X * other.X, v.Y * other.Y, v.Z * other.Z}
}

// MulScalar multiplies each component of this vector by the scalar s and returns resulting vector.
func (v Vector3i) MulScalar(s int32) Vector3i {
        return Vector3i{v.X * s, v.Y * s, v.Z * s}
}

// SetMul sets this to multiplication with other vector (i.e., *= or times-equals).
func (v *Vector3i) SetMul(other Vector3i) {
        v.X *= other.X
        v.Y *= other.Y
        v.Z *= other.Z
}

// SetMulScalar sets this to multiplication by scalar.
func (v *Vector3i) SetMulScalar(s int32) {
        v.X *= s
        v.Y *= s
        v.Z *= s
}

// Div divides each component of this vector by the corresponding one from other vector
// and returns resulting vector.
func (v Vector3i) Div(other Vector3i) Vector3i {
        return Vector3i{v.X / other.X, v.Y / other.Y, v.Z / other.Z}
}

// DivScalar divides each component of this vector by the scalar s and returns resulting vector.
// If scalar is zero, returns zero.
func (v Vector3i) DivScalar(scalar int32) Vector3i {
        if scalar != 0 {
                return Vector3i{v.X / scalar, v.Y / scalar, v.Z / scalar}
        }
        return Vector3i{}
}

// SetDiv sets this to division by other vector (i.e., /= or divide-equals).
func (v *Vector3i) SetDiv(other Vector3i) {
        v.X /= other.X
        v.Y /= other.Y
        v.Z /= other.Z
}

// SetDivScalar sets this to division by scalar.
func (v *Vector3i) SetDivScalar(scalar int32) {
        if scalar != 0 {
                v.X /= scalar
                v.Y /= scalar
                v.Z /= scalar
        } else {
                v.SetZero()
        }
}

// Min returns min of this vector components vs. other vector.
func (v Vector3i) Min(other Vector3i) Vector3i {
        return Vector3i{min(v.X, other.X), min(v.Y, other.Y), min(v.Z, other.Z)}
}

// SetMin sets this vector components to the minimum values of itself and other vector.
func (v *Vector3i) SetMin(other Vector3i) {
        v.X = min(v.X, other.X)
        v.Y = min(v.Y, other.Y)
        v.Z = min(v.Z, other.Z)
}

// Max returns max of this vector components vs. other vector.
func (v Vector3i) Max(other Vector3i) Vector3i {
        return Vector3i{max(v.X, other.X), max(v.Y, other.Y), max(v.Z, other.Z)}
}

// SetMax sets this vector components to the maximum value of itself and other vector.
func (v *Vector3i) SetMax(other Vector3i) {
        v.X = max(v.X, other.X)
        v.Y = max(v.Y, other.Y)
        v.Z = max(v.Z, other.Z)
}

// Clamp sets this vector's components to be no less than the corresponding
// components of min and not greater than the corresponding component of max.
// Assumes min < max; if this assumption isn't true, it will not operate correctly.
func (v *Vector3i) Clamp(min, max Vector3i) {
        if v.X < min.X {
                v.X = min.X
        } else if v.X > max.X {
                v.X = max.X
        }
        if v.Y < min.Y {
                v.Y = min.Y
        } else if v.Y > max.Y {
                v.Y = max.Y
        }
        if v.Z < min.Z {
                v.Z = min.Z
        } else if v.Z > max.Z {
                v.Z = max.Z
        }
}

// Negate returns the vector with each component negated.
func (v Vector3i) Negate() Vector3i {
        return Vector3i{-v.X, -v.Y, -v.Z}
}

// Copyright 2019 Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Initially copied from G3N: github.com/g3n/engine/math32
// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// with modifications needed to suit Cogent Core functionality.

package math32

import "fmt"

// Vector4 is a vector/point in homogeneous coordinates with X, Y, Z and W components.
type Vector4 struct {
        X float32
        Y float32
        Z float32
        W float32
}

// Vec4 returns a new [Vector4] with the given x, y, z, and w components.
func Vec4(x, y, z, w float32) Vector4 {
        return Vector4{X: x, Y: y, Z: z, W: w}
}

// Vector4Scalar returns a new [Vector4] with all components set to the given scalar value.
func Vector4Scalar(scalar float32) Vector4 {
        return Vector4{X: scalar, Y: scalar, Z: scalar, W: scalar}
}

// Vector4FromVector3 returns a new [Vector4] from the given [Vector3] and w component.
func Vector4FromVector3(v Vector3, w float32) Vector4 {
        nv := Vector4{}
        nv.SetFromVector3(v, w)
        return nv
}

// Set sets this vector X, Y, Z and W components.
func (v *Vector4) Set(x, y, z, w float32) {
        v.X = x
        v.Y = y
        v.Z = z
        v.W = w
}

// SetScalar sets all vector components to the same scalar value.
func (v *Vector4) SetScalar(scalar float32) {
        v.X = scalar
        v.Y = scalar
        v.Z = scalar
        v.W = scalar
}

// SetFromVector3 sets this vector from a Vector3 and W
func (v *Vector4) SetFromVector3(other Vector3, w float32) {
        v.X = other.X
        v.Y = other.Y
        v.Z = other.Z
        v.W = w
}

// SetFromVector2 sets this vector from a Vector2 with 0,1 for Z,W
func (v *Vector4) SetFromVector2(other Vector2) {
        v.X = other.X
        v.Y = other.Y
        v.Z = 0
        v.W = 1
}

// SetDim sets this vector component value by dimension index.
func (v *Vector4) SetDim(dim Dims, value float32) {
        switch dim {
        case X:
                v.X = value
        case Y:
                v.Y = value
        case Z:
                v.Z = value
        case W:
                v.W = value
        default:
                panic("dim is out of range")
        }
}

// Dim returns this vector component.
func (v Vector4) Dim(dim Dims) float32 {
        switch dim {
        case X:
                return v.X
        case Y:
                return v.Y
        case Z:
                return v.Z
        case W:
                return v.W
        default:
                panic("dim is out of range")
        }
}

func (v Vector4) String() string {
        return fmt.Sprintf("(%v, %v, %v, %v)", v.X, v.Y, v.Z, v.W)
}

// SetZero sets all of the vector's components to zero,
// except for the W component, which it sets to 1, as is standard.
func (v *Vector4) SetZero() {
        v.X = 0
        v.Y = 0
        v.Z = 0
        v.W = 1
}

// FromSlice sets this vector's components from the given slice, starting at offset.
func (v *Vector4) FromSlice(array []float32, offset int) {
        v.X = array[offset]
        v.Y = array[offset+1]
        v.Z = array[offset+2]
        v.W = array[offset+3]
}

// ToSlice copies this vector's components to the given slice, starting at offset.
func (v Vector4) ToSlice(array []float32, offset int) {
        array[offset] = v.X
        array[offset+1] = v.Y
        array[offset+2] = v.Z
        array[offset+3] = v.W
}

// Basic math operations:

// Add adds the other given vector to this one and returns the result as a new vector.
func (v Vector4) Add(other Vector4) Vector4 {
        return Vector4{v.X + other.X, v.Y + other.Y, v.Z + other.Z, v.W + other.W}
}

// AddScalar adds scalar s to each component of this vector and returns new vector.
func (v Vector4) AddScalar(s float32) Vector4 {
        return Vector4{v.X + s, v.Y + s, v.Z + s, v.W + s}
}

// SetAdd sets this to addition with other vector (i.e., += or plus-equals).
func (v *Vector4) SetAdd(other Vector4) {
        v.X += other.X
        v.Y += other.Y
        v.Z += other.Z
        v.W += other.W
}

// SetAddScalar sets this to addition with scalar.
func (v *Vector4) SetAddScalar(s float32) {
        v.X += s
        v.Y += s
        v.Z += s
        v.W += s
}

// Sub subtracts other vector from this one and returns result in new vector.
func (v Vector4) Sub(other Vector4) Vector4 {
        return Vector4{v.X - other.X, v.Y - other.Y, v.Z - other.Z, v.W - other.W}
}

// SubScalar subtracts scalar s from each component of this vector and returns new vector.
func (v Vector4) SubScalar(s float32) Vector4 {
        return Vector4{v.X - s, v.Y - s, v.Z - s, v.W - s}
}

// SetSub sets this to subtraction with other vector (i.e., -= or minus-equals).
func (v *Vector4) SetSub(other Vector4) {
        v.X -= other.X
        v.Y -= other.Y
        v.Z -= other.Z
        v.W -= other.W
}

// SetSubScalar sets this to subtraction of scalar.
func (v *Vector4) SetSubScalar(s float32) {
        v.X -= s
        v.Y -= s
        v.Z -= s
        v.W -= s
}

// Mul multiplies each component of this vector by the corresponding one from other
// and returns resulting vector.
func (v Vector4) Mul(other Vector4) Vector4 {
        return Vector4{v.X * other.X, v.Y * other.Y, v.Z * other.Z, v.W * other.W}
}

// MulScalar multiplies each component of this vector by the scalar s and returns resulting vector.
func (v Vector4) MulScalar(s float32) Vector4 {
        return Vector4{v.X * s, v.Y * s, v.Z * s, v.W * s}
}

// SetMul sets this to multiplication with other vector (i.e., *= or times-equals).
func (v *Vector4) SetMul(other Vector4) {
        v.X *= other.X
        v.Y *= other.Y
        v.Z *= other.Z
        v.W *= other.W
}

// SetMulScalar sets this to multiplication by scalar.
func (v *Vector4) SetMulScalar(s float32) {
        v.X *= s
        v.Y *= s
        v.Z *= s
        v.W *= s
}

// Div divides each component of this vector by the corresponding one from other vector
// and returns resulting vector.
func (v Vector4) Div(other Vector4) Vector4 {
        return Vector4{v.X / other.X, v.Y / other.Y, v.Z / other.Z, v.W / other.W}
}

// DivScalar divides each component of this vector by the scalar s and returns resulting vector.
// If scalar is zero, returns zero.
func (v Vector4) DivScalar(scalar float32) Vector4 {
        if scalar != 0 {
                return v.MulScalar(1 / scalar)
        }
        return Vector4{}
}

// SetDiv sets this to division by other vector (i.e., /= or divide-equals).
func (v *Vector4) SetDiv(other Vector4) {
        v.X /= other.X
        v.Y /= other.Y
        v.Z /= other.Z
        v.W /= other.W
}

// SetDivScalar sets this to division by scalar.
func (v *Vector4) SetDivScalar(s float32) {
        if s != 0 {
                v.SetMulScalar(1 / s)
        } else {
                v.SetZero()
        }
}

// Min returns min of this vector components vs. other vector.
func (v Vector4) Min(other Vector4) Vector4 {
        return Vector4{Min(v.X, other.X), Min(v.Y, other.Y), Min(v.Z, other.Z), Min(v.W, other.W)}
}

// SetMin sets this vector components to the minimum values of itself and other vector.
func (v *Vector4) SetMin(other Vector4) {
        v.X = Min(v.X, other.X)
        v.Y = Min(v.Y, other.Y)
        v.Z = Min(v.Z, other.Z)
        v.W = Min(v.W, other.W)
}

// Max returns max of this vector components vs. other vector.
func (v Vector4) Max(other Vector4) Vector4 {
        return Vector4{Max(v.X, other.X), Max(v.Y, other.Y), Max(v.Z, other.Z), Max(v.W, other.W)}
}

// SetMax sets this vector components to the maximum value of itself and other vector.
func (v *Vector4) SetMax(other Vector4) {
        v.X = Max(v.X, other.X)
        v.Y = Max(v.Y, other.Y)
        v.Z = Max(v.Z, other.Z)
        v.W = Max(v.W, other.W)
}

// Clamp sets this vector's components to be no less than the corresponding
// components of min and not greater than the corresponding component of max.
// Assumes min < max; if this assumption isn't true, it will not operate correctly.
func (v *Vector4) Clamp(min, max Vector4) {
        if v.X < min.X {
                v.X = min.X
        } else if v.X > max.X {
                v.X = max.X
        }
        if v.Y < min.Y {
                v.Y = min.Y
        } else if v.Y > max.Y {
                v.Y = max.Y
        }
        if v.Z < min.Z {
                v.Z = min.Z
        } else if v.Z > max.Z {
                v.Z = max.Z
        }
        if v.W < min.W {
                v.W = min.W
        } else if v.W > max.W {
                v.W = max.W
        }
}

// Floor returns this vector with [Floor] applied to each of its components.
func (v Vector4) Floor() Vector4 {
        return Vector4{Floor(v.X), Floor(v.Y), Floor(v.Z), Floor(v.W)}
}

// Ceil returns this vector with [Ceil] applied to each of its components.
func (v Vector4) Ceil() Vector4 {
        return Vector4{Ceil(v.X), Ceil(v.Y), Ceil(v.Z), Ceil(v.W)}
}

// Round returns this vector with [Round] applied to each of its components.
func (v Vector4) Round() Vector4 {
        return Vector4{Round(v.X), Round(v.Y), Round(v.Z), Round(v.W)}
}

// Negate returns the vector with each component negated.
func (v Vector4) Negate() Vector4 {
        return Vector4{-v.X, -v.Y, -v.Z, -v.W}
}

// Distance, Normal:

// Dot returns the dot product of this vector with the given other vector.
func (v Vector4) Dot(other Vector4) float32 {
        return v.X*other.X + v.Y*other.Y + v.Z*other.Z + v.W*other.W
}

// Length returns the length (magnitude) of this vector.
func (v Vector4) Length() float32 {
        return Sqrt(v.X*v.X + v.Y*v.Y + v.Z*v.Z + v.W*v.W)
}

// LengthSquared returns the length squared of this vector.
// LengthSquared can be used to compare the lengths of vectors
// without the need to perform a square root.
func (v Vector4) LengthSquared() float32 {
        return v.X*v.X + v.Y*v.Y + v.Z*v.Z + v.W*v.W
}

// Normal returns this vector divided by its length (its unit vector).
func (v Vector4) Normal() Vector4 {
        return v.DivScalar(v.Length())
}

// SetNormal normalizes this vector so its length will be 1.
func (v *Vector4) SetNormal() {
        v.SetDivScalar(v.Length())
}

// Lerp returns vector with each components as the linear interpolated value of
// alpha between itself and the corresponding other component.
func (v Vector4) Lerp(other Vector4, alpha float32) Vector4 {
        return Vector4{v.X + (other.X-v.X)*alpha, v.Y + (other.Y-v.Y)*alpha, v.Z + (other.Z-v.Z)*alpha,
                v.W + (other.W-v.W)*alpha}
}

// Matrix operations:

// MulMatrix4 returns vector multiplied by specified 4x4 matrix.
func (v Vector4) MulMatrix4(m *Matrix4) Vector4 {
        return Vector4{m[0]*v.X + m[4]*v.Y + m[8]*v.Z + m[12]*v.W,
                m[1]*v.X + m[5]*v.Y + m[9]*v.Z + m[13]*v.W,
                m[2]*v.X + m[6]*v.Y + m[10]*v.Z + m[14]*v.W,
                m[3]*v.X + m[7]*v.Y + m[11]*v.Z + m[15]*v.W}
}

// SetAxisAngleFromQuat set this vector to be the axis (x, y, z) and angle (w)
// of a rotation specified the quaternion q.
// Assumes q is normalized.
func (v *Vector4) SetAxisAngleFromQuat(q Quat) {
        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
        qw := Clamp(q.W, -1, 1)
        v.W = 2 * Acos(qw)
        s := Sqrt(1 - qw*qw)
        if s < 0.0001 {
                v.X = 1
                v.Y = 0
                v.Z = 0
        } else {
                v.X = q.X / s
                v.Y = q.Y / s
                v.Z = q.Z / s
        }
}

// PerspDiv returns the 3-vector of normalized display coordinates (NDC) from given 4-vector
// By dividing by the 4th W component
func (v Vector4) PerspDiv() Vector3 {
        return Vec3(v.X/v.W, v.Y/v.W, v.Z/v.W)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package paint

import (
        "cogentcore.org/core/math32"
)

// EdgeBlurFactors returns multiplicative factors that replicate the effect
// of a Gaussian kernel applied to a sharp edge transition in the middle of
// a line segment, with a given Gaussian sigma, and radius = sigma * radiusFactor.
// The returned line factors go from -radius to +radius.
// For low-contrast (opacity) cases, radiusFactor = 1 works well,
// because values beyond 1 sigma are effectively invisible, but 2 looks
// better for greater contrast cases.
func EdgeBlurFactors(sigma, radiusFactor float32) []float32 {
        radius := math32.Ceil(sigma * radiusFactor)
        irad := int(radius)
        klen := irad*2 + 1
        sfactor := -0.5 / (sigma * sigma)

        if klen < 0 {
                return []float32{}
        }
        k := make([]float32, klen)
        sum := float32(0)
        rstart := -radius + 0.5
        for i, x := 0, rstart; i < klen; i, x = i+1, x+1 {
                v := math32.FastExp(sfactor * (x * x))
                sum += v
                k[i] = v
        }
        for i, v := range k {
                k[i] = v / sum
        }

        line := make([]float32, klen)
        for li := range line {
                sum := float32(0)
                for ki, v := range k {
                        if ki >= (klen - li) {
                                break
                        }
                        sum += v
                }
                line[li] = sum
        }
        return line
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package paint

import (
        "image"

        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/sides"
)

// StandardBox draws the CSS standard box model using the given styling information,
// position, size, and parent actual background. This is used for rendering
// widgets such as buttons, text fields, etc in a GUI.
func (pc *Painter) StandardBox(st *styles.Style, pos math32.Vector2, size math32.Vector2, pabg image.Image) {
        if !st.RenderBox || size == (math32.Vector2{}) {
                return
        }

        encroach, pr := pc.boundsEncroachParent(pos, size)
        tm := st.TotalMargin().Round()
        mpos := pos.Add(tm.Pos())
        msize := size.Sub(tm.Size())
        if msize == (math32.Vector2{}) {
                return
        }
        radius := st.Border.Radius.Dots()
        if encroach { // if we encroach, we must limit ourselves to the parent radius
                radius = radius.Max(pr)
        }

        if st.ActualBackground == nil {
                // we need to do this to prevent
                // elements from rendering over themselves
                // (see https://github.com/cogentcore/core/issues/565)
                st.ActualBackground = pabg
        }

        // note that we always set the fill opacity to 1 because we are already applying
        // the opacity of the background color in ComputeActualBackground above
        pc.Fill.Opacity = 1

        if st.FillMargin {
                // We need to fill the whole box where the
                // box shadows / element can go to prevent growing
                // box shadows and borders. We couldn't just
                // do this when there are box shadows, as they
                // may be removed and then need to be covered up.
                // This also fixes https://github.com/cogentcore/core/issues/579.
                // This isn't an ideal solution because of performance,
                // so TODO: maybe come up with a better solution for this.
                // We need to use raw geom data because we need to clear
                // any box shadow that may have gone in margin.
                if encroach { // if we encroach, we must limit ourselves to the parent radius
                        pc.Fill.Color = pabg
                        pc.RoundedRectangleSides(pos.X, pos.Y, size.X, size.Y, radius)
                        pc.Draw()
                } else {
                        pc.BlitBox(pos, size, pabg)
                }
        }

        pc.Stroke.Opacity = st.Opacity
        // pc.Font.Opacity = st.Opacity // todo:

        // first do any shadow
        if st.HasBoxShadow() {
                // CSS effectively goes in reverse order
                for i := len(st.BoxShadow) - 1; i >= 0; i-- {
                        shadow := st.BoxShadow[i]
                        pc.Stroke.Color = nil
                        // note: applying 0.5 here does a reasonable job of matching
                        // material design shadows, at their specified alpha levels.
                        pc.Fill.Color = gradient.ApplyOpacity(shadow.Color, 0.5)
                        spos := shadow.BasePos(mpos)
                        ssz := shadow.BaseSize(msize)

                        // note: we are using EdgeBlurFactors with radiusFactor = 1
                        // (sigma == radius), so we divide Blur / 2 relative to the
                        // CSS standard of sigma = blur / 2 (i.e., our sigma = blur,
                        // so we divide Blur / 2 to achieve the same effect).
                        // This works fine for low-opacity blur factors (the edges are
                        // so transparent that you can't really see beyond 1 sigma,
                        // if you used radiusFactor = 2).
                        // If a higher-contrast shadow is used, it would look better
                        // with radiusFactor = 2, and you'd have to remove this /2 factor.

                        pc.RoundedShadowBlur(shadow.Blur.Dots/2, 1, spos.X, spos.Y, ssz.X, ssz.Y, radius)
                }
        }

        // then draw the box over top of that.
        // we need to draw things twice here because we need to clear
        // the whole area with the background color first so the border
        // doesn't render weirdly
        if sides.AreZero(radius.Sides) {
                pc.FillBox(mpos, msize, st.ActualBackground)
        } else {
                pc.Fill.Color = st.ActualBackground
                // no border; fill on
                pc.RoundedRectangleSides(mpos.X, mpos.Y, msize.X, msize.Y, radius)
                pc.Draw()
        }

        // now that we have drawn background color
        // above, we can draw the border
        mpos.SetSub(st.Border.Width.Dots().Pos().MulScalar(0.5))
        msize.SetAdd(st.Border.Width.Dots().Size().MulScalar(0.5))
        mpos.SetSub(st.Border.Offset.Dots().Pos())
        msize.SetAdd(st.Border.Offset.Dots().Size())
        pc.Fill.Color = nil
        pc.Border(mpos.X, mpos.Y, msize.X, msize.Y, st.Border)
}

// boundsEncroachParent returns whether the current box encroaches on the
// parent bounds, taking into account the parent radius, which is also returned.
func (pc *Painter) boundsEncroachParent(pos, size math32.Vector2) (bool, sides.Floats) {
        if len(pc.Stack) <= 1 {
                return false, sides.Floats{}
        }

        ctx := pc.Stack[len(pc.Stack)-2]
        pr := ctx.Bounds.Radius
        if sides.AreZero(pr.Sides) {
                return false, pr
        }

        pbox := ctx.Bounds.Rect.ToRect()
        psz := ctx.Bounds.Rect.Size()
        pr = ClampBorderRadius(pr, psz.X, psz.Y)

        rect := math32.Box2{Min: pos, Max: pos.Add(size)}

        // logic is currently based on consistent radius for all corners
        radius := max(pr.Top, pr.Left, pr.Right, pr.Bottom)

        // each of these is how much the element is encroaching into each
        // side of the bounding rectangle, within the radius curve.
        // if the number is negative, then it isn't encroaching at all and can
        // be ignored.
        top := radius - (rect.Min.Y - float32(pbox.Min.Y))
        left := radius - (rect.Min.X - float32(pbox.Min.X))
        right := radius - (float32(pbox.Max.X) - rect.Max.X)
        bottom := radius - (float32(pbox.Max.Y) - rect.Max.Y)

        return top > 0 || left > 0 || right > 0 || bottom > 0, pr
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package paint

import (
        "image"
        "image/color"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/pimage"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/sides"
        "cogentcore.org/core/text/shaped"
        "golang.org/x/image/draw"
)

/*
The original version borrowed heavily from: https://github.com/fogleman/gg
Copyright (C) 2016 Michael Fogleman

and https://github.com/srwiley/rasterx:
Copyright 2018 by the rasterx Authors. All rights reserved.
Created 2018 by S.R.Wiley

The new version is more strongly based on https://github.com/tdewolff/canvas
Copyright (c) 2015 Taco de Wolff, under an MIT License.
*/

// Painter provides the rendering state, styling parameters, and methods for
// painting. It accumulates all painting actions in a [render.Render]
// list, which should be obtained by a call to the [Painter.RenderDone] method
// when  done painting (resets list to start fresh).
//
// Pass this [render.Render] list to one or more [render.Renderers] to actually
// generate the resulting output. Renderers are independent of the Painter
// and the [render.Render] state is entirely self-contained, so rendering
// can be done in a separate goroutine etc.
//
// You must import _ "cogentcore.org/core/paint/renderers" to get the default
// renderers if using this outside of core which already does this for you.
// This sets the New*Renderer functions to point to default implementations.
type Painter struct {
        *State
        *styles.Paint
}

// NewPainter returns a new [Painter] with default styles and given size.
func NewPainter(size math32.Vector2) *Painter {
        pc := &Painter{&State{}, styles.NewPaint()}
        pc.State.Init(pc.Paint, size)
        pc.SetUnitContextExt(size.ToPointCeil())
        return pc
}

func (pc *Painter) Transform() math32.Matrix2 {
        return pc.Context().Transform.Mul(pc.Paint.Transform)
}

//////// Path basics

// MoveTo starts a new subpath within the current path starting at the
// specified point.
func (pc *Painter) MoveTo(x, y float32) {
        pc.State.Path.MoveTo(x, y)
}

// LineTo adds a line segment to the current path starting at the current
// point. If there is no current point, it is equivalent to MoveTo(x, y)
func (pc *Painter) LineTo(x, y float32) {
        pc.State.Path.LineTo(x, y)
}

// QuadTo adds a quadratic Bézier path with control point (cpx,cpy) and end point (x,y).
func (pc *Painter) QuadTo(cpx, cpy, x, y float32) {
        pc.State.Path.QuadTo(cpx, cpy, x, y)
}

// CubeTo adds a cubic Bézier path with control points
// (cpx1,cpy1) and (cpx2,cpy2) and end point (x,y).
func (pc *Painter) CubeTo(cp1x, cp1y, cp2x, cp2y, x, y float32) {
        pc.State.Path.CubeTo(cp1x, cp1y, cp2x, cp2y, x, y)
}

// ArcTo adds an arc with radii rx and ry, with rot the counter clockwise
// rotation with respect to the coordinate system in radians, large and sweep booleans
// (see https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Arcs),
// and (x,y) the end position of the pen. The start position of the pen was
// given by a previous command's end point.
func (pc *Painter) ArcTo(rx, ry, rot float32, large, sweep bool, x, y float32) {
        pc.State.Path.ArcTo(rx, ry, rot, large, sweep, x, y)
}

// Close closes a (sub)path with a LineTo to the start of the path
// (the most recent MoveTo command). It also signals the path closes
// as opposed to being just a LineTo command, which can be significant
// for stroking purposes for example.
func (pc *Painter) Close() {
        pc.State.Path.Close()
}

// Draw puts the current path on the render stack, capturing the style
// settings present at this point, which will be used to render the path,
// and creates a new current path.
func (pc *Painter) Draw() {
        pc.Paint.ToDots()
        pt := render.NewPath(pc.State.Path.Clone(), pc.Paint, pc.Context())
        pc.Render.Add(pt)
        pc.State.Path.Reset()
}

//////// basic shape functions

// note: the path shapes versions can be used when you want to add to an existing path
// using ppath.Join. These functions produce distinct standalone shapes, starting with
// a MoveTo generally.

// Line adds a separate line (MoveTo, LineTo).
func (pc *Painter) Line(x1, y1, x2, y2 float32) {
        pc.State.Path.Line(x1, y1, x2, y2)
}

// Polyline adds multiple connected lines, with no final Close.
func (pc *Painter) Polyline(points ...math32.Vector2) {
        pc.State.Path.Polyline(points...)
}

// Polyline adds multiple connected lines, with no final Close,
// with coordinates in Px units.
func (pc *Painter) PolylinePx(points ...math32.Vector2) {
        pu := &pc.UnitContext
        sz := len(points)
        if sz < 2 {
                return
        }
        p := &pc.State.Path
        p.MoveTo(pu.PxToDots(points[0].X), pu.PxToDots(points[0].Y))
        for i := 1; i < sz; i++ {
                p.LineTo(pu.PxToDots(points[i].X), pu.PxToDots(points[i].Y))
        }
}

// Polygon adds multiple connected lines with a final Close.
func (pc *Painter) Polygon(points ...math32.Vector2) {
        pc.Polyline(points...)
        pc.Close()
}

// Polygon adds multiple connected lines with a final Close,
// with coordinates in Px units.
func (pc *Painter) PolygonPx(points ...math32.Vector2) {
        pc.PolylinePx(points...)
        pc.Close()
}

// Rectangle adds a rectangle of width w and height h at position x,y.
func (pc *Painter) Rectangle(x, y, w, h float32) {
        pc.State.Path.Rectangle(x, y, w, h)
}

// RoundedRectangle adds a rectangle of width w and height h
// with rounded corners of radius r at postion x,y.
// A negative radius will cast the corners inwards (i.e. concave).
func (pc *Painter) RoundedRectangle(x, y, w, h, r float32) {
        pc.State.Path.RoundedRectangle(x, y, w, h, r)
}

// RoundedRectangleSides adds a standard rounded rectangle
// with a consistent border and with the given x and y position,
// width and height, and border radius for each corner.
func (pc *Painter) RoundedRectangleSides(x, y, w, h float32, r sides.Floats) {
        pc.State.Path.RoundedRectangleSides(x, y, w, h, r)
}

// BeveledRectangle adds a rectangle of width w and height h
// with beveled corners at distance r from the corner.
func (pc *Painter) BeveledRectangle(x, y, w, h, r float32) {
        pc.State.Path.BeveledRectangle(x, y, w, h, r)
}

// Circle adds a circle at given center coordinates of radius r.
func (pc *Painter) Circle(cx, cy, r float32) {
        pc.Ellipse(cx, cy, r, r)
}

// Ellipse adds an ellipse at given center coordinates of radii rx and ry.
func (pc *Painter) Ellipse(cx, cy, rx, ry float32) {
        pc.State.Path.Ellipse(cx, cy, rx, ry)
}

// CircularArc adds a circular arc centered at given coordinates with radius r
// and theta0 and theta1 as the angles in degrees of the ellipse
// (before rot is applied) between which the arc will run.
// If theta0 < theta1, the arc will run in a CCW direction.
// If the difference between theta0 and theta1 is bigger than 360 degrees,
// one full circle will be drawn and the remaining part of diff % 360,
// e.g. a difference of 810 degrees will draw one full circle and an arc
// over 90 degrees.
func (pc *Painter) CircularArc(x, y, r, theta0, theta1 float32) {
        pc.State.Path.EllipticalArc(x, y, r, r, 0, theta0, theta1)
}

// EllipticalArc adds an elliptical arc centered at given coordinates with
// radii rx and ry, with rot the counter clockwise rotation in degrees,
// and theta0 and theta1 the angles in degrees of the ellipse
// (before rot is applied) between which the arc will run.
// If theta0 < theta1, the arc will run in a CCW direction.
// If the difference between theta0 and theta1 is bigger than 360 degrees,
// one full circle will be drawn and the remaining part of diff % 360,
// e.g. a difference of 810 degrees will draw one full circle and an arc
// over 90 degrees.
func (pc *Painter) EllipticalArc(x, y, rx, ry, rot, theta0, theta1 float32) {
        pc.State.Path.EllipticalArc(x, y, rx, ry, rot, theta0, theta1)
}

// Triangle adds a triangle of radius r pointing upwards.
func (pc *Painter) Triangle(x, y, r float32) {
        pc.State.Path.RegularPolygon(3, r, true).Translate(x, y) // todo: just make these take a position.
}

// RegularPolygon adds a regular polygon with radius r.
// It uses n vertices/edges, so when n approaches infinity
// this will return a path that approximates a circle.
// n must be 3 or more. The up boolean defines whether
// the first point will point upwards or downwards.
func (pc *Painter) RegularPolygon(x, y float32, n int, r float32, up bool) {
        pc.State.Path.RegularPolygon(n, r, up).Translate(x, y)
}

// RegularStarPolygon adds a regular star polygon with radius r.
// It uses n vertices of density d. This will result in a
// self-intersection star in counter clockwise direction.
// If n/2 < d the star will be clockwise and if n and d are not coprime
// a regular polygon will be obtained, possible with multiple windings.
// n must be 3 or more and d 2 or more. The up boolean defines whether
// the first point will point upwards or downwards.
func (pc *Painter) RegularStarPolygon(x, y float32, n, d int, r float32, up bool) {
        pc.State.Path.RegularStarPolygon(n, d, r, up).Translate(x, y)
}

// StarPolygon returns a star polygon of n points with alternating
// radius R and r. The up boolean defines whether the first point
// will be point upwards or downwards.
func (pc *Painter) StarPolygon(x, y float32, n int, R, r float32, up bool) {
        pc.State.Path.StarPolygon(n, R, r, up).Translate(x, y)
}

// Grid returns a stroked grid of width w and height h,
// with grid line thickness r, and the number of cells horizontally
// and vertically as nx and ny respectively.
func (pc *Painter) Grid(x, y, w, h float32, nx, ny int, r float32) {
        pc.State.Path.Grid(w, y, nx, ny, r).Translate(x, y)
}

// ClampBorderRadius returns the given border radius clamped to fit based
// on the given width and height of the object.
func ClampBorderRadius(r sides.Floats, w, h float32) sides.Floats {
        min := math32.Min(w/2, h/2)
        r.Top = math32.Clamp(r.Top, 0, min)
        r.Right = math32.Clamp(r.Right, 0, min)
        r.Bottom = math32.Clamp(r.Bottom, 0, min)
        r.Left = math32.Clamp(r.Left, 0, min)
        return r
}

// Border is a higher-level function that draws, strokes, and fills
// an potentially rounded border box with the given position, size, and border styles.
func (pc *Painter) Border(x, y, w, h float32, bs styles.Border) {
        origStroke := pc.Stroke
        origFill := pc.Fill
        defer func() {
                pc.Stroke = origStroke
                pc.Fill = origFill
        }()
        r := bs.Radius.Dots()
        if sides.AreSame(bs.Style) && sides.AreSame(bs.Color) && sides.AreSame(bs.Width.Dots().Sides) {
                // set the color if it is not nil and the stroke style
                // is not set to the correct color
                if bs.Color.Top != nil && bs.Color.Top != pc.Stroke.Color {
                        pc.Stroke.Color = bs.Color.Top
                }
                pc.Stroke.Width = bs.Width.Top
                pc.Stroke.ApplyBorderStyle(bs.Style.Top)
                if sides.AreZero(r.Sides) {
                        pc.Rectangle(x, y, w, h)
                } else {
                        pc.RoundedRectangleSides(x, y, w, h, r)
                }
                pc.Draw()
                return
        }

        // use consistent rounded rectangle for fill, and then draw borders side by side
        pc.RoundedRectangleSides(x, y, w, h, r)
        pc.Draw()

        r = ClampBorderRadius(r, w, h)

        // position values
        var (
                xtl, ytl   = x, y                 // top left
                xtli, ytli = x + r.Top, y + r.Top // top left inset

                xtr, ytr   = x + w, y                     // top right
                xtri, ytri = x + w - r.Right, y + r.Right // top right inset

                xbr, ybr   = x + w, y + h                       // bottom right
                xbri, ybri = x + w - r.Bottom, y + h - r.Bottom // bottom right inset

                xbl, ybl   = x, y + h                   // bottom left
                xbli, ybli = x + r.Left, y + h - r.Left // bottom left inset
        )

        // SidesTODO: need to figure out how to style rounded corners correctly
        // (in CSS they are split in the middle between different border side styles)

        pc.MoveTo(xtli, ytl)

        // set the color if it is not the same as the already set color
        if bs.Color.Top != pc.Stroke.Color {
                pc.Stroke.Color = bs.Color.Top
        }
        pc.Stroke.Width = bs.Width.Top
        pc.LineTo(xtri, ytr)
        if r.Right != 0 {
                pc.CircularArc(xtri, ytri, r.Right, math32.DegToRad(270), math32.DegToRad(360))
        }
        // if the color or width is changing for the next one, we have to stroke now
        if bs.Color.Top != bs.Color.Right || bs.Width.Top.Dots != bs.Width.Right.Dots {
                pc.Draw()
                pc.MoveTo(xtr, ytri)
        }

        if bs.Color.Right != pc.Stroke.Color {
                pc.Stroke.Color = bs.Color.Right
        }
        pc.Stroke.Width = bs.Width.Right
        pc.LineTo(xbr, ybri)
        if r.Bottom != 0 {
                pc.CircularArc(xbri, ybri, r.Bottom, math32.DegToRad(0), math32.DegToRad(90))
        }
        if bs.Color.Right != bs.Color.Bottom || bs.Width.Right.Dots != bs.Width.Bottom.Dots {
                pc.Draw()
                pc.MoveTo(xbri, ybr)
        }

        if bs.Color.Bottom != pc.Stroke.Color {
                pc.Stroke.Color = bs.Color.Bottom
        }
        pc.Stroke.Width = bs.Width.Bottom
        pc.LineTo(xbli, ybl)
        if r.Left != 0 {
                pc.CircularArc(xbli, ybli, r.Left, math32.DegToRad(90), math32.DegToRad(180))
        }
        if bs.Color.Bottom != bs.Color.Left || bs.Width.Bottom.Dots != bs.Width.Left.Dots {
                pc.Draw()
                pc.MoveTo(xbl, ybli)
        }

        if bs.Color.Left != pc.Stroke.Color {
                pc.Stroke.Color = bs.Color.Left
        }
        pc.Stroke.Width = bs.Width.Left
        pc.LineTo(xtl, ytli)
        if r.Top != 0 {
                pc.CircularArc(xtli, ytli, r.Top, math32.DegToRad(180), math32.DegToRad(270))
        }
        pc.LineTo(xtli, ytl)
        pc.Draw()
}

// RoundedShadowBlur draws a standard rounded rectangle
// with a consistent border and with the given x and y position,
// width and height, and border radius for each corner.
// The blurSigma and radiusFactor args add a blurred shadow with
// an effective Gaussian sigma = blurSigma, and radius = radiusFactor * sigma.
// This shadow is rendered around the given box size up to given radius.
// See EdgeBlurFactors for underlying blur factor code.
// Using radiusFactor = 1 works well for weak shadows, where the fringe beyond
// 1 sigma is essentially invisible.  To match the CSS standard, you then
// pass blurSigma = blur / 2, radiusFactor = 1.  For darker shadows,
// use blurSigma = blur / 2, radiusFactor = 2, and reserve extra space for the full shadow.
// The effective blurRadius is clamped to be <= w-2 and h-2.
func (pc *Painter) RoundedShadowBlur(blurSigma, radiusFactor, x, y, w, h float32, r sides.Floats) {
        if blurSigma <= 0 || radiusFactor <= 0 {
                pc.RoundedRectangleSides(x, y, w, h, r)
                pc.Draw()
                return
        }
        x = math32.Floor(x)
        y = math32.Floor(y)
        w = math32.Ceil(w)
        h = math32.Ceil(h)
        br := math32.Ceil(radiusFactor * blurSigma)
        br = math32.Clamp(br, 1, w/2-2)
        br = math32.Clamp(br, 1, h/2-2)
        // radiusFactor = math32.Ceil(br / blurSigma)
        radiusFactor = br / blurSigma
        blurs := EdgeBlurFactors(blurSigma, radiusFactor)

        origStroke := pc.Stroke
        origFill := pc.Fill
        origOpacity := pc.Fill.Opacity

        pc.Stroke.Color = nil
        pc.RoundedRectangleSides(x+br, y+br, w-2*br, h-2*br, r)
        pc.Draw()
        pc.Stroke.Color = pc.Fill.Color
        pc.Fill.Color = nil
        pc.Stroke.Width.Dots = 1.5 // 1.5 is the key number: 1 makes lines very transparent overall
        for i, b := range blurs {
                bo := br - float32(i)
                pc.Stroke.Opacity = b * origOpacity
                pc.RoundedRectangleSides(x+bo, y+bo, w-2*bo, h-2*bo, r)
                pc.Draw()

        }
        pc.Stroke = origStroke
        pc.Fill = origFill
}

//////// Image drawing

// FillBox performs an optimized fill of the given
// rectangular region with the given image. It is equivalent
// to [Painter.DrawBox] with [draw.Over].
func (pc *Painter) FillBox(pos, size math32.Vector2, img image.Image) {
        pc.DrawBox(pos, size, img, draw.Over)
}

// BlitBox performs an optimized overwriting fill (blit) of the given
// rectangular region with the given image. It is equivalent
// to [Painter.DrawBox] with [draw.Src].
func (pc *Painter) BlitBox(pos, size math32.Vector2, img image.Image) {
        pc.DrawBox(pos, size, img, draw.Src)
}

// DrawBox performs an optimized fill/blit of the given rectangular region
// with the given image, using the given draw operation.
// If the image is nil, a new transparent color is used.
func (pc *Painter) DrawBox(pos, size math32.Vector2, img image.Image, op draw.Op) {
        if img == nil {
                img = colors.Uniform(color.RGBA{})
        }
        pos = pc.Transform().MulVector2AsPoint(pos)
        size = pc.Transform().MulVector2AsVector(size)
        br := math32.RectFromPosSizeMax(pos, size)
        cb := pc.Context().Bounds.Rect.ToRect()
        b := cb.Intersect(br)
        if b.Size() == (image.Point{}) {
                return
        }
        if g, ok := img.(gradient.Gradient); ok {
                g.Update(pc.Fill.Opacity, math32.B2FromRect(b), pc.Transform())
        } else {
                img = gradient.ApplyOpacity(img, pc.Fill.Opacity)
        }
        pc.Render.Add(pimage.NewDraw(b, img, b.Min, op))
}

// BlurBox blurs the given already drawn region with the given blur radius.
// The blur radius passed to this function is the actual Gaussian
// standard deviation (σ). This means that you need to divide a CSS-standard
// blur radius value by two before passing it this function
// (see https://stackoverflow.com/questions/65454183/how-does-blur-radius-value-in-box-shadow-property-affect-the-resulting-blur).
func (pc *Painter) BlurBox(pos, size math32.Vector2, blurRadius float32) {
        rect := math32.RectFromPosSizeMax(pos, size)
        pc.Render.Add(pimage.NewBlur(rect, blurRadius))
}

// SetMask allows you to directly set the *image.Alpha to be used as a clipping
// mask. It must be the same size as the context, else an error is returned
// and the mask is unchanged.
func (pc *Painter) SetMask(mask *image.Alpha) error {
        // if mask.Bounds() != pc.Image.Bounds() {
        //         return errors.New("mask size must match context size")
        // }
        pc.Mask = mask
        return nil
}

// AsMask returns an *image.Alpha representing the alpha channel of this
// context. This can be useful for advanced clipping operations where you first
// render the mask geometry and then use it as a mask.
// func (pc *Painter) AsMask() *image.Alpha {
//         b := pc.Image.Bounds()
//         mask := image.NewAlpha(b)
//         draw.Draw(mask, b, pc.Image, image.Point{}, draw.Src)
//         return mask
// }

// Clear fills the entire image with the current fill color.
func (pc *Painter) Clear() {
        src := pc.Fill.Color
        pc.Render.Add(pimage.NewClear(src, image.Point{}, draw.Src))
}

// SetPixel sets the color of the specified pixel using the current stroke color.
func (pc *Painter) SetPixel(x, y int) {
        pc.Render.Add(pimage.NewSetPixel(image.Point{x, y}, pc.Stroke.Color))
}

// DrawImage draws the given image at the specified starting point,
// using the bounds of the source image in rectangle rect, using
// the given draw operration: Over = overlay (alpha blend with destination)
// Src = copy source directly, overwriting destination pixels.
func (pc *Painter) DrawImage(src image.Image, rect image.Rectangle, srcStart image.Point, op draw.Op) {
        pc.Render.Add(pimage.NewDraw(rect, src, srcStart, op))
}

// DrawImageAnchored draws the specified image at the specified anchor point.
// The anchor point is x - w * ax, y - h * ay, where w, h is the size of the
// image. Use ax=0.5, ay=0.5 to center the image at the specified point.
func (pc *Painter) DrawImageAnchored(src image.Image, x, y, ax, ay float32) {
        s := src.Bounds().Size()
        x -= ax * float32(s.X)
        y -= ay * float32(s.Y)
        m := pc.Transform().Translate(x, y)
        if pc.Mask == nil {
                pc.Render.Add(pimage.NewTransform(m, src.Bounds(), src, draw.Over))
        } else {
                pc.Render.Add(pimage.NewTransformMask(m, src.Bounds(), src, draw.Over, pc.Mask, image.Point{}))
        }
}

// DrawImageScaled draws the specified image starting at given upper-left point,
// such that the size of the image is rendered as specified by w, h parameters
// (an additional scaling is applied to the transform matrix used in rendering)
func (pc *Painter) DrawImageScaled(src image.Image, x, y, w, h float32) {
        s := src.Bounds().Size()
        isz := math32.FromPoint(s)
        isc := math32.Vec2(w, h).Div(isz)

        m := pc.Transform().Translate(x, y).Scale(isc.X, isc.Y)
        if pc.Mask == nil {
                pc.Render.Add(pimage.NewTransform(m, src.Bounds(), src, draw.Over))
        } else {
                pc.Render.Add(pimage.NewTransformMask(m, src.Bounds(), src, draw.Over, pc.Mask, image.Point{}))
        }
}

// BoundingBox computes the bounding box for an element in pixel int
// coordinates, applying current transform
func (pc *Painter) BoundingBox(minX, minY, maxX, maxY float32) image.Rectangle {
        sw := float32(0.0)
        // if pc.Stroke.Color != nil {// todo
        //         sw = 0.5 * pc.StrokeWidth()
        // }
        tmin := pc.Transform().MulVector2AsPoint(math32.Vec2(minX, minY))
        tmax := pc.Transform().MulVector2AsPoint(math32.Vec2(maxX, maxY))
        tp1 := math32.Vec2(tmin.X-sw, tmin.Y-sw).ToPointFloor()
        tp2 := math32.Vec2(tmax.X+sw, tmax.Y+sw).ToPointCeil()
        return image.Rect(tp1.X, tp1.Y, tp2.X, tp2.Y)
}

// BoundingBoxFromPoints computes the bounding box for a slice of points
func (pc *Painter) BoundingBoxFromPoints(points []math32.Vector2) image.Rectangle {
        sz := len(points)
        if sz == 0 {
                return image.Rectangle{}
        }
        min := points[0]
        max := points[1]
        for i := 1; i < sz; i++ {
                min.SetMin(points[i])
                max.SetMax(points[i])
        }
        return pc.BoundingBox(min.X, min.Y, max.X, max.Y)
}

/////// DrawText

// DrawText adds given [shaped] text lines to the rendering list,
// at given position. Note that all rendering is subject to the
// current active transform, including the position:
// e.g., use math32.Rotate2DAround to just rotate the text at a given
// absolute position offset.
func (pc *Painter) DrawText(tx *shaped.Lines, pos math32.Vector2) {
        pc.Render.Add(render.NewText(tx, pc.Paint, pc.Context(), pos))
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package pimage

import (
        "image"
        "math"

        "github.com/anthonynsimon/bild/clone"
        "github.com/anthonynsimon/bild/convolution"
)

// scipy impl:
// https://github.com/scipy/scipy/blob/4bfc152f6ee1ca48c73c06e27f7ef021d729f496/scipy/ndimage/filters.py#L136
// #L214 has the invocation: radius = Ceil(sigma)

// bild uses:
// math.Exp(-0.5 * (x * x / (2 * radius))
// so   sigma = sqrt(radius) / 2
// and radius = sigma * sigma * 2

// GaussianBlurKernel1D returns a 1D Gaussian kernel.
// Sigma is the standard deviation,
// and the radius of the kernel is 4 * sigma.
func GaussianBlurKernel1D(sigma float64) *convolution.Kernel {
        sigma2 := sigma * sigma
        sfactor := -0.5 / sigma2
        radius := math.Ceil(4 * sigma) // truncate = 4 in scipy
        length := 2*int(radius) + 1

        // Create the 1-d gaussian kernel
        k := convolution.NewKernel(length, 1)
        for i, x := 0, -radius; i < length; i, x = i+1, x+1 {
                k.Matrix[i] = math.Exp(sfactor * (x * x))
        }
        return k
}

// GaussianBlur returns a smoothly blurred version of the image using
// a Gaussian function. Sigma is the standard deviation of the Gaussian
// function, and a kernel of radius = 4 * Sigma is used.
func GaussianBlur(src image.Image, sigma float64) *image.RGBA {
        if sigma <= 0 {
                return clone.AsRGBA(src)
        }

        k := GaussianBlurKernel1D(sigma).Normalized()

        // Perform separable convolution
        options := convolution.Options{Bias: 0, Wrap: false, KeepAlpha: false}
        result := convolution.Convolve(src, k, &options)
        result = convolution.Convolve(result, k.Transposed(), &options)

        return result
}

// Code generated by "core generate"; DO NOT EDIT.

package pimage

import (
        "cogentcore.org/core/enums"
)

var _CmdsValues = []Cmds{0, 1, 2, 3}

// CmdsN is the highest valid value for type Cmds, plus one.
const CmdsN Cmds = 4

var _CmdsValueMap = map[string]Cmds{`Draw`: 0, `Transform`: 1, `Blur`: 2, `SetPixel`: 3}

var _CmdsDescMap = map[Cmds]string{0: `Draw Source image using draw.Draw equivalent function, without any transformation. If Mask is non-nil it is used.`, 1: `Draw Source image with transform. If Mask is non-nil, it is used.`, 2: `blurs the Rect region with the given blur radius. The blur radius passed to this function is the actual Gaussian standard deviation (σ).`, 3: `Sets pixel from Source image at Pos`}

var _CmdsMap = map[Cmds]string{0: `Draw`, 1: `Transform`, 2: `Blur`, 3: `SetPixel`}

// String returns the string representation of this Cmds value.
func (i Cmds) String() string { return enums.String(i, _CmdsMap) }

// SetString sets the Cmds value from its string representation,
// and returns an error if the string is invalid.
func (i *Cmds) SetString(s string) error { return enums.SetString(i, s, _CmdsValueMap, "Cmds") }

// Int64 returns the Cmds value as an int64.
func (i Cmds) Int64() int64 { return int64(i) }

// SetInt64 sets the Cmds value from an int64.
func (i *Cmds) SetInt64(in int64) { *i = Cmds(in) }

// Desc returns the description of the Cmds value.
func (i Cmds) Desc() string { return enums.Desc(i, _CmdsDescMap) }

// CmdsValues returns all possible values for the type Cmds.
func CmdsValues() []Cmds { return _CmdsValues }

// Values returns all possible values for the type Cmds.
func (i Cmds) Values() []enums.Enum { return enums.Values(_CmdsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Cmds) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Cmds) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Cmds") }

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package pimage

//go:generate core generate

import (
        "image"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/math32"
        "golang.org/x/image/draw"
        "golang.org/x/image/math/f64"
)

// Cmds are possible commands to perform for [Params].
type Cmds int32 //enums:enum

const (
        // Draw Source image using draw.Draw equivalent function,
        // without any transformation. If Mask is non-nil it is used.
        Draw Cmds = iota

        // Draw Source image with transform. If Mask is non-nil, it is used.
        Transform

        // blurs the Rect region with the given blur radius.
        // The blur radius passed to this function is the actual Gaussian
        // standard deviation (σ).
        Blur

        // Sets pixel from Source image at Pos
        SetPixel
)

// Params for image operations. This is a Render Item.
type Params struct {
        // Command to perform.
        Cmd Cmds

        // Rect is the rectangle to draw into. This is the bounds for Transform source.
        // If empty, the entire destination image Bounds() are used.
        Rect image.Rectangle

        // SourcePos is the position for the source image in Draw,
        // and the location for SetPixel.
        SourcePos image.Point

        // Draw operation: Src or Over
        Op draw.Op

        // Source to draw.
        Source image.Image

        // Mask, used if non-nil.
        Mask image.Image

        // MaskPos is the position for the mask
        MaskPos image.Point

        // Transform for image transform.
        Transform math32.Matrix2

        // BlurRadius is the Gaussian standard deviation for Blur function
        BlurRadius float32
}

func (pr *Params) IsRenderItem() {}

// NewClear returns a new Clear that renders entire image with given source image.
func NewClear(src image.Image, sp image.Point, op draw.Op) *Params {
        pr := &Params{Cmd: Draw, Rect: image.Rectangle{}, Source: imagex.WrapJS(src), SourcePos: sp, Op: op}
        return pr
}

// NewDraw returns a new Draw operation with given parameters.
// Does nothing if rect is empty.
func NewDraw(rect image.Rectangle, src image.Image, sp image.Point, op draw.Op) *Params {
        if rect == (image.Rectangle{}) {
                return nil
        }
        pr := &Params{Cmd: Draw, Rect: rect, Source: imagex.WrapJS(src), SourcePos: sp, Op: op}
        return pr
}

// NewDrawMask returns a new DrawMask operation with given parameters.
// Does nothing if rect is empty.
func NewDrawMask(rect image.Rectangle, src image.Image, sp image.Point, op draw.Op, mask image.Image, mp image.Point) *Params {
        if rect == (image.Rectangle{}) {
                return nil
        }
        pr := &Params{Cmd: Draw, Rect: rect, Source: imagex.WrapJS(src), SourcePos: sp, Op: op, Mask: imagex.WrapJS(mask), MaskPos: mp}
        return pr
}

// NewTransform returns a new Transform operation with given parameters.
// Does nothing if rect is empty.
func NewTransform(m math32.Matrix2, rect image.Rectangle, src image.Image, op draw.Op) *Params {
        if rect == (image.Rectangle{}) {
                return nil
        }
        pr := &Params{Cmd: Transform, Transform: m, Rect: rect, Source: imagex.WrapJS(src), Op: op}
        return pr
}

// NewTransformMask returns a new Transform Mask operation with given parameters.
// Does nothing if rect is empty.
func NewTransformMask(m math32.Matrix2, rect image.Rectangle, src image.Image, op draw.Op, mask image.Image, mp image.Point) *Params {
        if rect == (image.Rectangle{}) {
                return nil
        }
        pr := &Params{Cmd: Transform, Transform: m, Rect: rect, Source: imagex.WrapJS(src), Op: op, Mask: imagex.WrapJS(mask), MaskPos: mp}
        return pr
}

// NewBlur returns a new Blur operation with given parameters.
// Does nothing if rect is empty.
func NewBlur(rect image.Rectangle, blurRadius float32) *Params {
        if rect == (image.Rectangle{}) {
                return nil
        }
        pr := &Params{Cmd: Blur, Rect: rect, BlurRadius: blurRadius}
        return pr
}

// NewSetPixel returns a new SetPixel operation with given parameters.
func NewSetPixel(at image.Point, clr image.Image) *Params {
        pr := &Params{Cmd: SetPixel, SourcePos: at, Source: clr}
        return pr
}

// Render performs the image operation on given destination image.
func (pr *Params) Render(dest *image.RGBA) {
        switch pr.Cmd {
        case Draw:
                if pr.Rect == (image.Rectangle{}) {
                        pr.Rect = dest.Bounds()
                }
                if pr.Mask != nil {
                        draw.DrawMask(dest, pr.Rect, imagex.Unwrap(pr.Source), pr.SourcePos, imagex.Unwrap(pr.Mask), pr.MaskPos, pr.Op)
                } else {
                        if pr.Source == nil {
                                return
                        }
                        draw.Draw(dest, pr.Rect, imagex.Unwrap(pr.Source), pr.SourcePos, pr.Op)
                }
        case Transform:
                m := pr.Transform
                s2d := f64.Aff3{float64(m.XX), float64(m.XY), float64(m.X0), float64(m.YX), float64(m.YY), float64(m.Y0)}
                tdraw := draw.BiLinear
                if pr.Mask != nil {
                        tdraw.Transform(dest, s2d, imagex.Unwrap(pr.Source), pr.Rect, pr.Op, &draw.Options{
                                DstMask:  imagex.Unwrap(pr.Mask),
                                DstMaskP: pr.MaskPos,
                        })
                } else {
                        tdraw.Transform(dest, s2d, imagex.Unwrap(pr.Source), pr.Rect, pr.Op, nil)
                }
        case Blur:
                sub := dest.SubImage(pr.Rect)
                sub = GaussianBlur(sub, float64(pr.BlurRadius))
                draw.Draw(dest, pr.Rect, sub, pr.Rect.Min, draw.Src)
        case SetPixel:
                x := pr.SourcePos.X
                y := pr.SourcePos.Y
                dest.Set(x, y, imagex.Unwrap(pr.Source).At(x, y))
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import "cogentcore.org/core/math32"

func QuadraticToCubicBezier(p0, p1, p2 math32.Vector2) (math32.Vector2, math32.Vector2) {
        c1 := p0.Lerp(p1, 2.0/3.0)
        c2 := p2.Lerp(p1, 2.0/3.0)
        return c1, c2
}

func QuadraticBezierDeriv(p0, p1, p2 math32.Vector2, t float32) math32.Vector2 {
        p0 = p0.MulScalar(-2.0 + 2.0*t)
        p1 = p1.MulScalar(2.0 - 4.0*t)
        p2 = p2.MulScalar(2.0 * t)
        return p0.Add(p1).Add(p2)
}

func CubicBezierDeriv(p0, p1, p2, p3 math32.Vector2, t float32) math32.Vector2 {
        p0 = p0.MulScalar(-3.0 + 6.0*t - 3.0*t*t)
        p1 = p1.MulScalar(3.0 - 12.0*t + 9.0*t*t)
        p2 = p2.MulScalar(6.0*t - 9.0*t*t)
        p3 = p3.MulScalar(3.0 * t * t)
        return p0.Add(p1).Add(p2).Add(p3)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import "cogentcore.org/core/math32"

// FastBounds returns the maximum bounding box rectangle of the path.
// It is quicker than Bounds but less accurate.
func (p Path) FastBounds() math32.Box2 {
        if len(p) < 4 {
                return math32.Box2{}
        }

        // first command is MoveTo
        start, end := math32.Vec2(p[1], p[2]), math32.Vector2{}
        xmin, xmax := start.X, start.X
        ymin, ymax := start.Y, start.Y
        for i := 4; i < len(p); {
                cmd := p[i]
                switch cmd {
                case MoveTo, LineTo, Close:
                        end = math32.Vec2(p[i+1], p[i+2])
                        xmin = math32.Min(xmin, end.X)
                        xmax = math32.Max(xmax, end.X)
                        ymin = math32.Min(ymin, end.Y)
                        ymax = math32.Max(ymax, end.Y)
                case QuadTo:
                        cp := math32.Vec2(p[i+1], p[i+2])
                        end = math32.Vec2(p[i+3], p[i+4])
                        xmin = math32.Min(xmin, math32.Min(cp.X, end.X))
                        xmax = math32.Max(xmax, math32.Max(cp.X, end.X))
                        ymin = math32.Min(ymin, math32.Min(cp.Y, end.Y))
                        ymax = math32.Max(ymax, math32.Max(cp.Y, end.Y))
                case CubeTo:
                        cp1 := math32.Vec2(p[i+1], p[i+2])
                        cp2 := math32.Vec2(p[i+3], p[i+4])
                        end = math32.Vec2(p[i+5], p[i+6])
                        xmin = math32.Min(xmin, math32.Min(cp1.X, math32.Min(cp2.X, end.X)))
                        xmax = math32.Max(xmax, math32.Max(cp1.X, math32.Min(cp2.X, end.X)))
                        ymin = math32.Min(ymin, math32.Min(cp1.Y, math32.Min(cp2.Y, end.Y)))
                        ymax = math32.Max(ymax, math32.Max(cp1.Y, math32.Min(cp2.Y, end.Y)))
                case ArcTo:
                        var rx, ry, phi float32
                        var large, sweep bool
                        rx, ry, phi, large, sweep, end = p.ArcToPoints(i)
                        cx, cy, _, _ := EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)
                        r := math32.Max(rx, ry)
                        xmin = math32.Min(xmin, cx-r)
                        xmax = math32.Max(xmax, cx+r)
                        ymin = math32.Min(ymin, cy-r)
                        ymax = math32.Max(ymax, cy+r)

                }
                i += CmdLen(cmd)
                start = end
        }
        return math32.B2(xmin, ymin, xmax, ymax)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import (
        "cogentcore.org/core/math32"
)

func EllipseDeriv(rx, ry, phi float32, sweep bool, theta float32) math32.Vector2 {
        sintheta, costheta := math32.Sincos(theta)
        sinphi, cosphi := math32.Sincos(phi)
        dx := -rx*sintheta*cosphi - ry*costheta*sinphi
        dy := -rx*sintheta*sinphi + ry*costheta*cosphi
        if !sweep {
                return math32.Vector2{-dx, -dy}
        }
        return math32.Vector2{dx, dy}
}

// EllipsePos adds the position on the ellipse at angle theta.
func EllipsePos(rx, ry, phi, cx, cy, theta float32) math32.Vector2 {
        sintheta, costheta := math32.Sincos(theta)
        sinphi, cosphi := math32.Sincos(phi)
        x := cx + rx*costheta*cosphi - ry*sintheta*sinphi
        y := cy + rx*costheta*sinphi + ry*sintheta*cosphi
        return math32.Vector2{x, y}
}

// EllipseToCenter converts to the center arc format and returns
// (centerX, centerY, angleFrom, angleTo) with angles in radians.
// When angleFrom with range [0, 2*PI) is bigger than angleTo with range
// (-2*PI, 4*PI), the ellipse runs clockwise.
// The angles are from before the ellipse has been stretched and rotated.
// See https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
func EllipseToCenter(x1, y1, rx, ry, phi float32, large, sweep bool, x2, y2 float32) (float32, float32, float32, float32) {
        if Equal(x1, x2) && Equal(y1, y2) {
                return x1, y1, 0.0, 0.0
        } else if Equal(math32.Abs(x2-x1), rx) && Equal(y1, y2) && Equal(phi, 0.0) {
                // common case since circles are defined as two arcs from (+dx,0) to (-dx,0) and back
                cx, cy := x1+(x2-x1)/2.0, y1
                theta := float32(0.0)
                if x1 < x2 {
                        theta = math32.Pi
                }
                delta := float32(math32.Pi)
                if !sweep {
                        delta = -delta
                }
                return cx, cy, theta, theta + delta
        }

        // compute the half distance between start and end point for the unrotated ellipse
        sinphi, cosphi := math32.Sincos(phi)
        x1p := cosphi*(x1-x2)/2.0 + sinphi*(y1-y2)/2.0
        y1p := -sinphi*(x1-x2)/2.0 + cosphi*(y1-y2)/2.0

        // check that radii are large enough to reduce rounding errors
        radiiCheck := x1p*x1p/rx/rx + y1p*y1p/ry/ry
        if 1.0 < radiiCheck {
                radiiScale := math32.Sqrt(radiiCheck)
                rx *= radiiScale
                ry *= radiiScale
        }

        // calculate the center point (cx,cy)
        sq := (rx*rx*ry*ry - rx*rx*y1p*y1p - ry*ry*x1p*x1p) / (rx*rx*y1p*y1p + ry*ry*x1p*x1p)
        if sq <= Epsilon {
                // Epsilon instead of 0.0 improves numerical stability for coef near zero
                // this happens when start and end points are at two opposites of the ellipse and
                // the line between them passes through the center, a common case
                sq = 0.0
        }
        coef := math32.Sqrt(sq)
        if large == sweep {
                coef = -coef
        }
        cxp := coef * rx * y1p / ry
        cyp := coef * -ry * x1p / rx
        cx := cosphi*cxp - sinphi*cyp + (x1+x2)/2.0
        cy := sinphi*cxp + cosphi*cyp + (y1+y2)/2.0

        // specify U and V vectors; theta = arccos(U*V / sqrt(U*U + V*V))
        ux := (x1p - cxp) / rx
        uy := (y1p - cyp) / ry
        vx := -(x1p + cxp) / rx
        vy := -(y1p + cyp) / ry

        // calculate the start angle (theta) and extent angle (delta)
        theta := math32.Acos(ux / math32.Sqrt(ux*ux+uy*uy))
        if uy < 0.0 {
                theta = -theta
        }
        theta = AngleNorm(theta)

        deltaAcos := (ux*vx + uy*vy) / math32.Sqrt((ux*ux+uy*uy)*(vx*vx+vy*vy))
        deltaAcos = math32.Min(1.0, math32.Max(-1.0, deltaAcos))
        delta := math32.Acos(deltaAcos)
        if ux*vy-uy*vx < 0.0 {
                delta = -delta
        }
        if !sweep && 0.0 < delta { // clockwise in Cartesian
                delta -= 2.0 * math32.Pi
        } else if sweep && delta < 0.0 { // counter clockwise in Cartesian
                delta += 2.0 * math32.Pi
        }
        return cx, cy, theta, theta + delta
}

// scale ellipse if rx and ry are too small, see https://www.w3.org/TR/SVG/implnote.html#ArcCorrectionOutOfRangeRadii
func EllipseRadiiCorrection(start math32.Vector2, rx, ry, phi float32, end math32.Vector2) float32 {
        diff := start.Sub(end)
        sinphi, cosphi := math32.Sincos(phi)
        x1p := (cosphi*diff.X + sinphi*diff.Y) / 2.0
        y1p := (-sinphi*diff.X + cosphi*diff.Y) / 2.0
        return math32.Sqrt(x1p*x1p/rx/rx + y1p*y1p/ry/ry)
}

// see Drawing and elliptical arc using polylines, quadratic or cubic Bézier curves (2003), L. Maisonobe, https://spaceroots.org/documents/ellipse/elliptical-arc.pdf
func ellipseToCubicBeziers(start math32.Vector2, rx, ry, phi float32, large, sweep bool, end math32.Vector2) [][4]math32.Vector2 {
        cx, cy, theta0, theta1 := EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)

        dtheta := float32(math32.Pi / 2.0) // TODO: use error measure to determine dtheta?
        n := int(math32.Ceil(math32.Abs(theta1-theta0) / dtheta))
        dtheta = math32.Abs(theta1-theta0) / float32(n) // evenly spread the n points, dalpha will get smaller
        kappa := math32.Sin(dtheta) * (math32.Sqrt(4.0+3.0*math32.Pow(math32.Tan(dtheta/2.0), 2.0)) - 1.0) / 3.0
        if !sweep {
                dtheta = -dtheta
        }

        beziers := [][4]math32.Vector2{}
        startDeriv := EllipseDeriv(rx, ry, phi, sweep, theta0)
        for i := 1; i < n+1; i++ {
                theta := theta0 + float32(i)*dtheta
                end := EllipsePos(rx, ry, phi, cx, cy, theta)
                endDeriv := EllipseDeriv(rx, ry, phi, sweep, theta)

                cp1 := start.Add(startDeriv.MulScalar(kappa))
                cp2 := end.Sub(endDeriv.MulScalar(kappa))
                beziers = append(beziers, [4]math32.Vector2{start, cp1, cp2, end})

                startDeriv = endDeriv
                start = end
        }
        return beziers
}

// see Drawing and elliptical arc using polylines, quadratic or cubic Bézier curves (2003), L. Maisonobe, https://spaceroots.org/documents/ellipse/elliptical-arc.pdf
func ellipseToQuadraticBeziers(start math32.Vector2, rx, ry, phi float32, large, sweep bool, end math32.Vector2) [][3]math32.Vector2 {
        cx, cy, theta0, theta1 := EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)

        dtheta := float32(math32.Pi / 2.0) // TODO: use error measure to determine dtheta?
        n := int(math32.Ceil(math32.Abs(theta1-theta0) / dtheta))
        dtheta = math32.Abs(theta1-theta0) / float32(n) // evenly spread the n points, dalpha will get smaller
        kappa := math32.Tan(dtheta / 2.0)
        if !sweep {
                dtheta = -dtheta
        }

        beziers := [][3]math32.Vector2{}
        startDeriv := EllipseDeriv(rx, ry, phi, sweep, theta0)
        for i := 1; i < n+1; i++ {
                theta := theta0 + float32(i)*dtheta
                end := EllipsePos(rx, ry, phi, cx, cy, theta)
                endDeriv := EllipseDeriv(rx, ry, phi, sweep, theta)

                cp := start.Add(startDeriv.MulScalar(kappa))
                beziers = append(beziers, [3]math32.Vector2{start, cp, end})

                startDeriv = endDeriv
                start = end
        }
        return beziers
}

// Code generated by "core generate"; DO NOT EDIT.

package ppath

import (
        "cogentcore.org/core/enums"
)

var _FillRulesValues = []FillRules{0, 1, 2, 3}

// FillRulesN is the highest valid value for type FillRules, plus one.
const FillRulesN FillRules = 4

var _FillRulesValueMap = map[string]FillRules{`nonzero`: 0, `evenodd`: 1, `positive`: 2, `negative`: 3}

var _FillRulesDescMap = map[FillRules]string{0: ``, 1: ``, 2: ``, 3: ``}

var _FillRulesMap = map[FillRules]string{0: `nonzero`, 1: `evenodd`, 2: `positive`, 3: `negative`}

// String returns the string representation of this FillRules value.
func (i FillRules) String() string { return enums.String(i, _FillRulesMap) }

// SetString sets the FillRules value from its string representation,
// and returns an error if the string is invalid.
func (i *FillRules) SetString(s string) error {
        return enums.SetString(i, s, _FillRulesValueMap, "FillRules")
}

// Int64 returns the FillRules value as an int64.
func (i FillRules) Int64() int64 { return int64(i) }

// SetInt64 sets the FillRules value from an int64.
func (i *FillRules) SetInt64(in int64) { *i = FillRules(in) }

// Desc returns the description of the FillRules value.
func (i FillRules) Desc() string { return enums.Desc(i, _FillRulesDescMap) }

// FillRulesValues returns all possible values for the type FillRules.
func FillRulesValues() []FillRules { return _FillRulesValues }

// Values returns all possible values for the type FillRules.
func (i FillRules) Values() []enums.Enum { return enums.Values(_FillRulesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i FillRules) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *FillRules) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "FillRules")
}

var _VectorEffectsValues = []VectorEffects{0, 1}

// VectorEffectsN is the highest valid value for type VectorEffects, plus one.
const VectorEffectsN VectorEffects = 2

var _VectorEffectsValueMap = map[string]VectorEffects{`none`: 0, `non-scaling-stroke`: 1}

var _VectorEffectsDescMap = map[VectorEffects]string{0: ``, 1: `VectorEffectNonScalingStroke means that the stroke width is not affected by transform properties`}

var _VectorEffectsMap = map[VectorEffects]string{0: `none`, 1: `non-scaling-stroke`}

// String returns the string representation of this VectorEffects value.
func (i VectorEffects) String() string { return enums.String(i, _VectorEffectsMap) }

// SetString sets the VectorEffects value from its string representation,
// and returns an error if the string is invalid.
func (i *VectorEffects) SetString(s string) error {
        return enums.SetString(i, s, _VectorEffectsValueMap, "VectorEffects")
}

// Int64 returns the VectorEffects value as an int64.
func (i VectorEffects) Int64() int64 { return int64(i) }

// SetInt64 sets the VectorEffects value from an int64.
func (i *VectorEffects) SetInt64(in int64) { *i = VectorEffects(in) }

// Desc returns the description of the VectorEffects value.
func (i VectorEffects) Desc() string { return enums.Desc(i, _VectorEffectsDescMap) }

// VectorEffectsValues returns all possible values for the type VectorEffects.
func VectorEffectsValues() []VectorEffects { return _VectorEffectsValues }

// Values returns all possible values for the type VectorEffects.
func (i VectorEffects) Values() []enums.Enum { return enums.Values(_VectorEffectsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i VectorEffects) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *VectorEffects) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "VectorEffects")
}

var _CapsValues = []Caps{0, 1, 2}

// CapsN is the highest valid value for type Caps, plus one.
const CapsN Caps = 3

var _CapsValueMap = map[string]Caps{`butt`: 0, `round`: 1, `square`: 2}

var _CapsDescMap = map[Caps]string{0: `CapButt indicates to draw no line caps; it draws a line with the length of the specified length.`, 1: `CapRound indicates to draw a semicircle on each line end with a diameter of the stroke width.`, 2: `CapSquare indicates to draw a rectangle on each line end with a height of the stroke width and a width of half of the stroke width.`}

var _CapsMap = map[Caps]string{0: `butt`, 1: `round`, 2: `square`}

// String returns the string representation of this Caps value.
func (i Caps) String() string { return enums.String(i, _CapsMap) }

// SetString sets the Caps value from its string representation,
// and returns an error if the string is invalid.
func (i *Caps) SetString(s string) error { return enums.SetString(i, s, _CapsValueMap, "Caps") }

// Int64 returns the Caps value as an int64.
func (i Caps) Int64() int64 { return int64(i) }

// SetInt64 sets the Caps value from an int64.
func (i *Caps) SetInt64(in int64) { *i = Caps(in) }

// Desc returns the description of the Caps value.
func (i Caps) Desc() string { return enums.Desc(i, _CapsDescMap) }

// CapsValues returns all possible values for the type Caps.
func CapsValues() []Caps { return _CapsValues }

// Values returns all possible values for the type Caps.
func (i Caps) Values() []enums.Enum { return enums.Values(_CapsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Caps) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Caps) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Caps") }

var _JoinsValues = []Joins{0, 1, 2, 3, 4, 5}

// JoinsN is the highest valid value for type Joins, plus one.
const JoinsN Joins = 6

var _JoinsValueMap = map[string]Joins{`miter`: 0, `miter-clip`: 1, `round`: 2, `bevel`: 3, `arcs`: 4, `arcs-clip`: 5}

var _JoinsDescMap = map[Joins]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``, 5: ``}

var _JoinsMap = map[Joins]string{0: `miter`, 1: `miter-clip`, 2: `round`, 3: `bevel`, 4: `arcs`, 5: `arcs-clip`}

// String returns the string representation of this Joins value.
func (i Joins) String() string { return enums.String(i, _JoinsMap) }

// SetString sets the Joins value from its string representation,
// and returns an error if the string is invalid.
func (i *Joins) SetString(s string) error { return enums.SetString(i, s, _JoinsValueMap, "Joins") }

// Int64 returns the Joins value as an int64.
func (i Joins) Int64() int64 { return int64(i) }

// SetInt64 sets the Joins value from an int64.
func (i *Joins) SetInt64(in int64) { *i = Joins(in) }

// Desc returns the description of the Joins value.
func (i Joins) Desc() string { return enums.Desc(i, _JoinsDescMap) }

// JoinsValues returns all possible values for the type Joins.
func JoinsValues() []Joins { return _JoinsValues }

// Values returns all possible values for the type Joins.
func (i Joins) Values() []enums.Enum { return enums.Values(_JoinsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Joins) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Joins) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Joins") }

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package intersect

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
)

func cubicBezierDeriv2(p0, p1, p2, p3 math32.Vector2, t float32) math32.Vector2 {
        p0 = p0.MulScalar(6.0 - 6.0*t)
        p1 = p1.MulScalar(18.0*t - 12.0)
        p2 = p2.MulScalar(6.0 - 18.0*t)
        p3 = p3.MulScalar(6.0 * t)
        return p0.Add(p1).Add(p2).Add(p3)
}

func cubicBezierDeriv3(p0, p1, p2, p3 math32.Vector2, t float32) math32.Vector2 {
        p0 = p0.MulScalar(-6.0)
        p1 = p1.MulScalar(18.0)
        p2 = p2.MulScalar(-18.0)
        p3 = p3.MulScalar(6.0)
        return p0.Add(p1).Add(p2).Add(p3)
}

func cubicBezierPos(p0, p1, p2, p3 math32.Vector2, t float32) math32.Vector2 {
        p0 = p0.MulScalar(1.0 - 3.0*t + 3.0*t*t - t*t*t)
        p1 = p1.MulScalar(3.0*t - 6.0*t*t + 3.0*t*t*t)
        p2 = p2.MulScalar(3.0*t*t - 3.0*t*t*t)
        p3 = p3.MulScalar(t * t * t)
        return p0.Add(p1).Add(p2).Add(p3)
}

func quadraticBezierDeriv2(p0, p1, p2 math32.Vector2) math32.Vector2 {
        p0 = p0.MulScalar(2.0)
        p1 = p1.MulScalar(-4.0)
        p2 = p2.MulScalar(2.0)
        return p0.Add(p1).Add(p2)
}

func quadraticBezierPos(p0, p1, p2 math32.Vector2, t float32) math32.Vector2 {
        p0 = p0.MulScalar(1.0 - 2.0*t + t*t)
        p1 = p1.MulScalar(2.0*t - 2.0*t*t)
        p2 = p2.MulScalar(t * t)
        return p0.Add(p1).Add(p2)
}

// negative when curve bends CW while following t
func CubicBezierCurvatureRadius(p0, p1, p2, p3 math32.Vector2, t float32) float32 {
        dp := ppath.CubicBezierDeriv(p0, p1, p2, p3, t)
        ddp := cubicBezierDeriv2(p0, p1, p2, p3, t)
        a := dp.Cross(ddp) // negative when bending right ie. curve is CW at this point
        if ppath.Equal(a, 0.0) {
                return math32.NaN()
        }
        return math32.Pow(dp.X*dp.X+dp.Y*dp.Y, 1.5) / a
}

// negative when curve bends CW while following t
func quadraticBezierCurvatureRadius(p0, p1, p2 math32.Vector2, t float32) float32 {
        dp := ppath.QuadraticBezierDeriv(p0, p1, p2, t)
        ddp := quadraticBezierDeriv2(p0, p1, p2)
        a := dp.Cross(ddp) // negative when bending right ie. curve is CW at this point
        if ppath.Equal(a, 0.0) {
                return math32.NaN()
        }
        return math32.Pow(dp.X*dp.X+dp.Y*dp.Y, 1.5) / a
}

// see https://malczak.linuxpl.com/blog/quadratic-bezier-curve-length/
func quadraticBezierLength(p0, p1, p2 math32.Vector2) float32 {
        a := p0.Sub(p1.MulScalar(2.0)).Add(p2)
        b := p1.MulScalar(2.0).Sub(p0.MulScalar(2.0))
        A := 4.0 * a.Dot(a)
        B := 4.0 * a.Dot(b)
        C := b.Dot(b)
        if ppath.Equal(A, 0.0) {
                // p1 is in the middle between p0 and p2, so it is a straight line from p0 to p2
                return p2.Sub(p0).Length()
        }

        Sabc := 2.0 * math32.Sqrt(A+B+C)
        A2 := math32.Sqrt(A)
        A32 := 2.0 * A * A2
        C2 := 2.0 * math32.Sqrt(C)
        BA := B / A2
        return (A32*Sabc + A2*B*(Sabc-C2) + (4.0*C*A-B*B)*math32.Log((2.0*A2+BA+Sabc)/(BA+C2))) / (4.0 * A32)
}

func findInflectionPointCubicBezier(p0, p1, p2, p3 math32.Vector2) (float32, float32) {
        // see www.faculty.idc.ac.il/arik/quality/appendixa.html
        // we omit multiplying bx,by,cx,cy with 3.0, so there is no need for divisions when calculating a,b,c
        ax := -p0.X + 3.0*p1.X - 3.0*p2.X + p3.X
        ay := -p0.Y + 3.0*p1.Y - 3.0*p2.Y + p3.Y
        bx := p0.X - 2.0*p1.X + p2.X
        by := p0.Y - 2.0*p1.Y + p2.Y
        cx := -p0.X + p1.X
        cy := -p0.Y + p1.Y

        a := (ay*bx - ax*by)
        b := (ay*cx - ax*cy)
        c := (by*cx - bx*cy)
        x1, x2 := solveQuadraticFormula(a, b, c)
        if x1 < ppath.Epsilon/2.0 || 1.0-ppath.Epsilon/2.0 < x1 {
                x1 = math32.NaN()
        }
        if x2 < ppath.Epsilon/2.0 || 1.0-ppath.Epsilon/2.0 < x2 {
                x2 = math32.NaN()
        } else if math32.IsNaN(x1) {
                x1, x2 = x2, x1
        }
        return x1, x2
}

func findInflectionPointRangeCubicBezier(p0, p1, p2, p3 math32.Vector2, t, tolerance float32) (float32, float32) {
        // find the range around an inflection point that we consider flat within the flatness criterion
        if math32.IsNaN(t) {
                return math32.Inf(1), math32.Inf(1)
        }
        if t < 0.0 || t > 1.0 {
                panic("t outside 0.0--1.0 range")
        }

        // we state that s(t) = 3*s2*t^2 + (s3 - 3*s2)*t^3 (see paper on the r-s coordinate system)
        // with s(t) aligned perpendicular to the curve at t = 0
        // then we impose that s(tf) = flatness and find tf
        // at inflection points however, s2 = 0, so that s(t) = s3*t^3

        if !ppath.Equal(t, 0.0) {
                _, _, _, _, p0, p1, p2, p3 = cubicBezierSplit(p0, p1, p2, p3, t)
        }
        nr := p1.Sub(p0)
        ns := p3.Sub(p0)
        if ppath.Equal(nr.X, 0.0) && ppath.Equal(nr.Y, 0.0) {
                // if p0=p1, then rn (the velocity at t=0) needs adjustment
                // nr = lim[t->0](B'(t)) = 3*(p1-p0) + 6*t*((p1-p0)+(p2-p1)) + second order terms of t
                // if (p1-p0)->0, we use (p2-p1)=(p2-p0)
                nr = p2.Sub(p0)
        }

        if ppath.Equal(nr.X, 0.0) && ppath.Equal(nr.Y, 0.0) {
                // if rn is still zero, this curve has p0=p1=p2, so it is straight
                return 0.0, 1.0
        }

        s3 := math32.Abs(ns.X*nr.Y-ns.Y*nr.X) / math32.Hypot(nr.X, nr.Y)
        if ppath.Equal(s3, 0.0) {
                return 0.0, 1.0 // can approximate whole curve linearly
        }

        tf := math32.Cbrt(tolerance / s3)
        return t - tf*(1.0-t), t + tf*(1.0-t)
}

// cubicBezierLength calculates the length of the Bézier, taking care of inflection points. It uses Gauss-Legendre (n=5) and has an error of ~1% or less (empirical).
func cubicBezierLength(p0, p1, p2, p3 math32.Vector2) float32 {
        t1, t2 := findInflectionPointCubicBezier(p0, p1, p2, p3)
        var beziers [][4]math32.Vector2
        if t1 > 0.0 && t1 < 1.0 && t2 > 0.0 && t2 < 1.0 {
                p0, p1, p2, p3, q0, q1, q2, q3 := cubicBezierSplit(p0, p1, p2, p3, t1)
                t2 = (t2 - t1) / (1.0 - t1)
                q0, q1, q2, q3, r0, r1, r2, r3 := cubicBezierSplit(q0, q1, q2, q3, t2)
                beziers = append(beziers, [4]math32.Vector2{p0, p1, p2, p3})
                beziers = append(beziers, [4]math32.Vector2{q0, q1, q2, q3})
                beziers = append(beziers, [4]math32.Vector2{r0, r1, r2, r3})
        } else if t1 > 0.0 && t1 < 1.0 {
                p0, p1, p2, p3, q0, q1, q2, q3 := cubicBezierSplit(p0, p1, p2, p3, t1)
                beziers = append(beziers, [4]math32.Vector2{p0, p1, p2, p3})
                beziers = append(beziers, [4]math32.Vector2{q0, q1, q2, q3})
        } else {
                beziers = append(beziers, [4]math32.Vector2{p0, p1, p2, p3})
        }

        length := float32(0.0)
        for _, bezier := range beziers {
                speed := func(t float32) float32 {
                        return ppath.CubicBezierDeriv(bezier[0], bezier[1], bezier[2], bezier[3], t).Length()
                }
                length += gaussLegendre7(speed, 0.0, 1.0)
        }
        return length
}

func quadraticBezierSplit(p0, p1, p2 math32.Vector2, t float32) (math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2) {
        q0 := p0
        q1 := p0.Lerp(p1, t)

        r2 := p2
        r1 := p1.Lerp(p2, t)

        r0 := q1.Lerp(r1, t)
        q2 := r0
        return q0, q1, q2, r0, r1, r2
}

func cubicBezierSplit(p0, p1, p2, p3 math32.Vector2, t float32) (math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2) {
        pm := p1.Lerp(p2, t)

        q0 := p0
        q1 := p0.Lerp(p1, t)
        q2 := q1.Lerp(pm, t)

        r3 := p3
        r2 := p2.Lerp(p3, t)
        r1 := pm.Lerp(r2, t)

        r0 := q2.Lerp(r1, t)
        q3 := r0
        return q0, q1, q2, q3, r0, r1, r2, r3
}

func cubicBezierNumInflections(p0, p1, p2, p3 math32.Vector2) int {
        t1, t2 := findInflectionPointCubicBezier(p0, p1, p2, p3)
        if !math32.IsNaN(t2) {
                return 2
        } else if !math32.IsNaN(t1) {
                return 1
        }
        return 0
}

func xmonotoneCubicBezier(p0, p1, p2, p3 math32.Vector2) ppath.Path {
        a := -p0.X + 3*p1.X - 3*p2.X + p3.X
        b := 2*p0.X - 4*p1.X + 2*p2.X
        c := -p0.X + p1.X

        p := ppath.Path{}
        p.MoveTo(p0.X, p0.Y)

        split := false
        t1, t2 := solveQuadraticFormula(a, b, c)
        if !math32.IsNaN(t1) && inIntervalExclusive(t1, 0.0, 1.0) {
                _, q1, q2, q3, r0, r1, r2, r3 := cubicBezierSplit(p0, p1, p2, p3, t1)
                p.CubeTo(q1.X, q1.Y, q2.X, q2.Y, q3.X, q3.Y)
                p0, p1, p2, p3 = r0, r1, r2, r3
                split = true
        }
        if !math32.IsNaN(t2) && inIntervalExclusive(t2, 0.0, 1.0) {
                if split {
                        t2 = (t2 - t1) / (1.0 - t1)
                }
                _, q1, q2, q3, _, r1, r2, r3 := cubicBezierSplit(p0, p1, p2, p3, t2)
                p.CubeTo(q1.X, q1.Y, q2.X, q2.Y, q3.X, q3.Y)
                p1, p2, p3 = r1, r2, r3
        }
        p.CubeTo(p1.X, p1.Y, p2.X, p2.Y, p3.X, p3.Y)
        return p
}

func quadraticBezierDistance(p0, p1, p2, q math32.Vector2) float32 {
        f := p0.Sub(p1.MulScalar(2.0)).Add(p2)
        g := p1.MulScalar(2.0).Sub(p0.MulScalar(2.0))
        h := p0.Sub(q)

        a := 4.0 * (f.X*f.X + f.Y*f.Y)
        b := 6.0 * (f.X*g.X + f.Y*g.Y)
        c := 2.0 * (2.0*(f.X*h.X+f.Y*h.Y) + g.X*g.X + g.Y*g.Y)
        d := 2.0 * (g.X*h.X + g.Y*h.Y)

        dist := math32.Inf(1.0)
        t0, t1, t2 := solveCubicFormula(a, b, c, d)
        ts := []float32{t0, t1, t2, 0.0, 1.0}
        for _, t := range ts {
                if !math32.IsNaN(t) {
                        if t < 0.0 {
                                t = 0.0
                        } else if 1.0 < t {
                                t = 1.0
                        }
                        if tmpDist := quadraticBezierPos(p0, p1, p2, t).Sub(q).Length(); tmpDist < dist {
                                dist = tmpDist
                        }
                }
        }
        return dist
}

func xmonotoneQuadraticBezier(p0, p1, p2 math32.Vector2) ppath.Path {
        p := ppath.Path{}
        p.MoveTo(p0.X, p0.Y)
        if tdenom := (p0.X - 2*p1.X + p2.X); !ppath.Equal(tdenom, 0.0) {
                if t := (p0.X - p1.X) / tdenom; 0.0 < t && t < 1.0 {
                        _, q1, q2, _, r1, r2 := quadraticBezierSplit(p0, p1, p2, t)
                        p.QuadTo(q1.X, q1.Y, q2.X, q2.Y)
                        p1, p2 = r1, r2
                }
        }
        p.QuadTo(p1.X, p1.Y, p2.X, p2.Y)
        return p
}

// return the normal at the right-side of the curve (when increasing t)
func CubicBezierNormal(p0, p1, p2, p3 math32.Vector2, t, d float32) math32.Vector2 {
        // TODO: remove and use CubicBezierDeriv + Rot90CW?
        if t == 0.0 {
                n := p1.Sub(p0)
                if n.X == 0 && n.Y == 0 {
                        n = p2.Sub(p0)
                }
                if n.X == 0 && n.Y == 0 {
                        n = p3.Sub(p0)
                }
                if n.X == 0 && n.Y == 0 {
                        return math32.Vector2{}
                }
                return n.Rot90CW().Normal().MulScalar(d)
        } else if t == 1.0 {
                n := p3.Sub(p2)
                if n.X == 0 && n.Y == 0 {
                        n = p3.Sub(p1)
                }
                if n.X == 0 && n.Y == 0 {
                        n = p3.Sub(p0)
                }
                if n.X == 0 && n.Y == 0 {
                        return math32.Vector2{}
                }
                return n.Rot90CW().Normal().MulScalar(d)
        }
        panic("not implemented") // not needed
}

func addCubicBezierLine(p *ppath.Path, p0, p1, p2, p3 math32.Vector2, t, d float32) {
        if ppath.EqualPoint(p0, p3) && (ppath.EqualPoint(p0, p1) || ppath.EqualPoint(p0, p2)) {
                // Bézier has p0=p1=p3 or p0=p2=p3 and thus has no surface or length
                return
        }

        pos := math32.Vector2{}
        if t == 0.0 {
                // line to beginning of path
                pos = p0
                if d != 0.0 {
                        n := CubicBezierNormal(p0, p1, p2, p3, t, d)
                        pos = pos.Add(n)
                }
        } else if t == 1.0 {
                // line to the end of the path
                pos = p3
                if d != 0.0 {
                        n := CubicBezierNormal(p0, p1, p2, p3, t, d)
                        pos = pos.Add(n)
                }
        } else {
                panic("not implemented")
        }
        p.LineTo(pos.X, pos.Y)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package intersect

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
)

func ellipseDeriv2(rx, ry, phi float32, theta float32) math32.Vector2 {
        sintheta, costheta := math32.Sincos(theta)
        sinphi, cosphi := math32.Sincos(phi)
        ddx := -rx*costheta*cosphi + ry*sintheta*sinphi
        ddy := -rx*costheta*sinphi - ry*sintheta*cosphi
        return math32.Vector2{ddx, ddy}
}

// ellipseLength calculates the length of the elliptical arc
// it uses Gauss-Legendre (n=5) and has an error of ~1% or less (empirical)
func ellipseLength(rx, ry, theta1, theta2 float32) float32 {
        if theta2 < theta1 {
                theta1, theta2 = theta2, theta1
        }
        speed := func(theta float32) float32 {
                return ppath.EllipseDeriv(rx, ry, 0.0, true, theta).Length()
        }
        return gaussLegendre5(speed, theta1, theta2)
}

func EllipseCurvatureRadius(rx, ry float32, sweep bool, theta float32) float32 {
        // positive for ccw / sweep
        // phi has no influence on the curvature
        dp := ppath.EllipseDeriv(rx, ry, 0.0, sweep, theta)
        ddp := ellipseDeriv2(rx, ry, 0.0, theta)
        a := dp.Cross(ddp)
        if ppath.Equal(a, 0.0) {
                return math32.NaN()
        }
        return math32.Pow(dp.X*dp.X+dp.Y*dp.Y, 1.5) / a
}

// ellipseSplit returns the new mid point, the two large parameters and the ok bool, the rest stays the same
func ellipseSplit(rx, ry, phi, cx, cy, theta0, theta1, theta float32) (math32.Vector2, bool, bool, bool) {
        if !ppath.IsAngleBetween(theta, theta0, theta1) {
                return math32.Vector2{}, false, false, false
        }

        mid := ppath.EllipsePos(rx, ry, phi, cx, cy, theta)
        large0, large1 := false, false
        if math32.Abs(theta-theta0) > math32.Pi {
                large0 = true
        } else if math32.Abs(theta-theta1) > math32.Pi {
                large1 = true
        }
        return mid, large0, large1, true
}

func xmonotoneEllipticArc(start math32.Vector2, rx, ry, phi float32, large, sweep bool, end math32.Vector2) ppath.Path {
        sign := float32(1.0)
        if !sweep {
                sign = -1.0
        }

        cx, cy, theta0, theta1 := ppath.EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)
        sinphi, cosphi := math32.Sincos(phi)
        thetaRight := math32.Atan2(-ry*sinphi, rx*cosphi)
        thetaLeft := thetaRight + math32.Pi

        p := ppath.Path{}
        p.MoveTo(start.X, start.Y)
        left := !ppath.AngleEqual(thetaLeft, theta0) && ppath.AngleNorm(sign*(thetaLeft-theta0)) < ppath.AngleNorm(sign*(thetaRight-theta0))
        for t := theta0; !ppath.AngleEqual(t, theta1); {
                dt := ppath.AngleNorm(sign * (theta1 - t))
                if left {
                        dt = math32.Min(dt, ppath.AngleNorm(sign*(thetaLeft-t)))
                } else {
                        dt = math32.Min(dt, ppath.AngleNorm(sign*(thetaRight-t)))
                }
                t += sign * dt

                pos := ppath.EllipsePos(rx, ry, phi, cx, cy, t)
                p.ArcTo(rx, ry, phi, false, sweep, pos.X, pos.Y)
                left = !left
        }
        return p
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package intersect

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
)

// Flatten flattens all Bézier and arc curves into linear segments
// and returns a new path. It uses tolerance as the maximum deviation.
func Flatten(p ppath.Path, tolerance float32) ppath.Path {
        quad := func(p0, p1, p2 math32.Vector2) ppath.Path {
                return FlattenQuadraticBezier(p0, p1, p2, tolerance)
        }
        cube := func(p0, p1, p2, p3 math32.Vector2) ppath.Path {
                return FlattenCubicBezier(p0, p1, p2, p3, 0.0, tolerance)
        }
        arc := func(start math32.Vector2, rx, ry, phi float32, large, sweep bool, end math32.Vector2) ppath.Path {
                return FlattenEllipticArc(start, rx, ry, phi, large, sweep, end, tolerance)
        }
        return p.Replace(nil, quad, cube, arc)
}

func FlattenEllipticArc(start math32.Vector2, rx, ry, phi float32, large, sweep bool, end math32.Vector2, tolerance float32) ppath.Path {
        if ppath.Equal(rx, ry) {
                // circle
                r := rx
                cx, cy, theta0, theta1 := ppath.EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)
                theta0 += phi
                theta1 += phi

                // draw line segments from arc+tolerance to arc+tolerance, touching arc-tolerance in between
                // we start and end at the arc itself
                dtheta := math32.Abs(theta1 - theta0)
                thetaEnd := math32.Acos((r - tolerance) / r)               // half angle of first/last segment
                thetaMid := math32.Acos((r - tolerance) / (r + tolerance)) // half angle of middle segments
                n := math32.Ceil((dtheta - thetaEnd*2.0) / (thetaMid * 2.0))

                // evenly space out points along arc
                ratio := dtheta / (thetaEnd*2.0 + thetaMid*2.0*n)
                thetaEnd *= ratio
                thetaMid *= ratio

                // adjust distance from arc to lower total deviation area, add points on the outer circle
                // of the tolerance since the middle of the line segment touches the inner circle and thus
                // even out. Ratio < 1 is when the line segments are shorter (and thus not touch the inner
                // tolerance circle).
                r += ratio * tolerance

                p := ppath.Path{}
                p.MoveTo(start.X, start.Y)
                theta := thetaEnd + thetaMid
                for i := 0; i < int(n); i++ {
                        t := theta0 + math32.Copysign(theta, theta1-theta0)
                        pos := math32.Vector2Polar(t, r).Add(math32.Vector2{cx, cy})
                        p.LineTo(pos.X, pos.Y)
                        theta += 2.0 * thetaMid
                }
                p.LineTo(end.X, end.Y)
                return p
        }
        // TODO: (flatten ellipse) use direct algorithm
        return Flatten(ppath.ArcToCube(start, rx, ry, phi, large, sweep, end), tolerance)
}

func FlattenQuadraticBezier(p0, p1, p2 math32.Vector2, tolerance float32) ppath.Path {
        // see Flat, precise flattening of cubic Bézier path and offset curves, by T.F. Hain et al., 2005,  https://www.sciencedirect.com/science/article/pii/S0097849305001287
        t := float32(0.0)
        p := ppath.Path{}
        p.MoveTo(p0.X, p0.Y)
        for t < 1.0 {
                D := p1.Sub(p0)
                if ppath.EqualPoint(p0, p1) {
                        // p0 == p1, curve is a straight line from p0 to p2
                        // should not occur directly from paths as this is prevented in QuadTo, but may appear in other subroutines
                        break
                }
                denom := math32.Hypot(D.X, D.Y) // equal to r1
                s2nom := D.Cross(p2.Sub(p0))
                //effFlatness := tolerance / (1.0 - d*s2nom/(denom*denom*denom)/2.0)
                t = 2.0 * math32.Sqrt(tolerance*math32.Abs(denom/s2nom))
                if t >= 1.0 {
                        break
                }

                _, _, _, p0, p1, p2 = quadraticBezierSplit(p0, p1, p2, t)
                p.LineTo(p0.X, p0.Y)
        }
        p.LineTo(p2.X, p2.Y)
        return p
}

// see Flat, precise flattening of cubic Bézier path and offset curves, by T.F. Hain et al., 2005,  https://www.sciencedirect.com/science/article/pii/S0097849305001287
// see https://github.com/Manishearth/stylo-flat/blob/master/gfx/2d/Path.cpp for an example implementation
// or https://docs.rs/crate/lyon_bezier/0.4.1/source/src/flatten_cubic.rs
// p0, p1, p2, p3 are the start points, two control points and the end points respectively. With flatness defined as the maximum error from the orinal curve, and d the half width of the curve used for stroking (positive is to the right).
func FlattenCubicBezier(p0, p1, p2, p3 math32.Vector2, d, tolerance float32) ppath.Path {
        tolerance = math32.Max(tolerance, ppath.Epsilon) // prevent infinite loop if user sets tolerance to zero

        p := ppath.Path{}
        start := p0.Add(CubicBezierNormal(p0, p1, p2, p3, 0.0, d))
        p.MoveTo(start.X, start.Y)

        // 0 <= t1 <= 1 if t1 exists
        // 0 <= t1 <= t2 <= 1 if t1 and t2 both exist
        t1, t2 := findInflectionPointCubicBezier(p0, p1, p2, p3)
        if math32.IsNaN(t1) && math32.IsNaN(t2) {
                // There are no inflection points or cusps, approximate linearly by subdivision.
                FlattenSmoothCubicBezier(&p, p0, p1, p2, p3, d, tolerance)
                return p
        }

        // t1min <= t1max; with 0 <= t1max and t1min <= 1
        // t2min <= t2max; with 0 <= t2max and t2min <= 1
        t1min, t1max := findInflectionPointRangeCubicBezier(p0, p1, p2, p3, t1, tolerance)
        t2min, t2max := findInflectionPointRangeCubicBezier(p0, p1, p2, p3, t2, tolerance)

        if math32.IsNaN(t2) && t1min <= 0.0 && 1.0 <= t1max {
                // There is no second inflection point, and the first inflection point can be entirely approximated linearly.
                addCubicBezierLine(&p, p0, p1, p2, p3, 1.0, d)
                return p
        }

        if 0.0 < t1min {
                // Flatten up to t1min
                q0, q1, q2, q3, _, _, _, _ := cubicBezierSplit(p0, p1, p2, p3, t1min)
                FlattenSmoothCubicBezier(&p, q0, q1, q2, q3, d, tolerance)
        }

        if 0.0 < t1max && t1max < 1.0 && t1max < t2min {
                // t1 and t2 ranges do not overlap, approximate t1 linearly
                _, _, _, _, q0, q1, q2, q3 := cubicBezierSplit(p0, p1, p2, p3, t1max)
                addCubicBezierLine(&p, q0, q1, q2, q3, 0.0, d)
                if 1.0 <= t2min {
                        // No t2 present, approximate the rest linearly by subdivision
                        FlattenSmoothCubicBezier(&p, q0, q1, q2, q3, d, tolerance)
                        return p
                }
        } else if 1.0 <= t2min {
                // No t2 present and t1max is past the end of the curve, approximate linearly
                addCubicBezierLine(&p, p0, p1, p2, p3, 1.0, d)
                return p
        }

        // t1 and t2 exist and ranges might overlap
        if 0.0 < t2min {
                if t2min < t1max {
                        // t2 range starts inside t1 range, approximate t1 range linearly
                        _, _, _, _, q0, q1, q2, q3 := cubicBezierSplit(p0, p1, p2, p3, t1max)
                        addCubicBezierLine(&p, q0, q1, q2, q3, 0.0, d)
                } else {
                        // no overlap
                        _, _, _, _, q0, q1, q2, q3 := cubicBezierSplit(p0, p1, p2, p3, t1max)
                        t2minq := (t2min - t1max) / (1 - t1max)
                        q0, q1, q2, q3, _, _, _, _ = cubicBezierSplit(q0, q1, q2, q3, t2minq)
                        FlattenSmoothCubicBezier(&p, q0, q1, q2, q3, d, tolerance)
                }
        }

        // handle (the rest of) t2
        if t2max < 1.0 {
                _, _, _, _, q0, q1, q2, q3 := cubicBezierSplit(p0, p1, p2, p3, t2max)
                addCubicBezierLine(&p, q0, q1, q2, q3, 0.0, d)
                FlattenSmoothCubicBezier(&p, q0, q1, q2, q3, d, tolerance)
        } else {
                // t2max extends beyond 1
                addCubicBezierLine(&p, p0, p1, p2, p3, 1.0, d)
        }
        return p
}

// split the curve and replace it by lines as long as (maximum deviation <= tolerance) is maintained
func FlattenSmoothCubicBezier(p *ppath.Path, p0, p1, p2, p3 math32.Vector2, d, tolerance float32) {
        t := float32(0.0)
        for t < 1.0 {
                D := p1.Sub(p0)
                if ppath.EqualPoint(p0, p1) {
                        // p0 == p1, base on p2
                        D = p2.Sub(p0)
                        if ppath.EqualPoint(p0, p2) {
                                // p0 == p1 == p2, curve is a straight line from p0 to p3
                                p.LineTo(p3.X, p3.Y)
                                return
                        }
                }
                denom := D.Length() // equal to r1

                // effective flatness distorts the stroke width as both sides have different cuts
                //effFlatness := flatness / (1.0 - d*s2nom/(denom*denom*denom)*2.0/3.0)
                s2nom := D.Cross(p2.Sub(p0))
                s2inv := denom / s2nom
                t2 := 2.0 * math32.Sqrt(tolerance*math32.Abs(s2inv)/3.0)

                // if s2 is small, s3 may represent the curvature more accurately
                // we cannot calculate the effective flatness here
                s3nom := D.Cross(p3.Sub(p0))
                s3inv := denom / s3nom
                t3 := 2.0 * math32.Cbrt(tolerance*math32.Abs(s3inv))

                // choose whichever is most curved, P2-P0 or P3-P0
                t = math32.Min(t2, t3)
                if 1.0 <= t {
                        break
                }
                _, _, _, _, p0, p1, p2, p3 = cubicBezierSplit(p0, p1, p2, p3, t)
                addCubicBezierLine(p, p0, p1, p2, p3, 0.0, d)
        }
        addCubicBezierLine(p, p0, p1, p2, p3, 1.0, d)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package intersect

import (
        "slices"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
)

// curvature returns the curvature of the path at the given index
// into ppath.Path and t in [0.0,1.0]. ppath.Path must not contain subpaths,
// and will return the path's starting curvature when i points
// to a MoveTo, or the path's final curvature when i points to
// a Close of zero-length.
func curvature(p ppath.Path, i int, t float32) float32 {
        last := len(p)
        if p[last-1] == ppath.Close && ppath.EqualPoint(math32.Vec2(p[last-ppath.CmdLen(ppath.Close)-3], p[last-ppath.CmdLen(ppath.Close)-2]), math32.Vec2(p[last-3], p[last-2])) {
                // point-closed
                last -= ppath.CmdLen(ppath.Close)
        }

        if i == 0 {
                // get path's starting direction when i points to MoveTo
                i = 4
                t = 0.0
        } else if i < len(p) && i == last {
                // get path's final direction when i points to zero-length Close
                i -= ppath.CmdLen(p[i-1])
                t = 1.0
        }
        if i < 0 || len(p) <= i || last < i+ppath.CmdLen(p[i]) {
                return 0.0
        }

        cmd := p[i]
        var start math32.Vector2
        if i == 0 {
                start = math32.Vec2(p[last-3], p[last-2])
        } else {
                start = math32.Vec2(p[i-3], p[i-2])
        }

        i += ppath.CmdLen(cmd)
        end := math32.Vec2(p[i-3], p[i-2])
        switch cmd {
        case ppath.LineTo, ppath.Close:
                return 0.0
        case ppath.QuadTo:
                cp := math32.Vec2(p[i-5], p[i-4])
                return 1.0 / quadraticBezierCurvatureRadius(start, cp, end, t)
        case ppath.CubeTo:
                cp1 := math32.Vec2(p[i-7], p[i-6])
                cp2 := math32.Vec2(p[i-5], p[i-4])
                return 1.0 / CubicBezierCurvatureRadius(start, cp1, cp2, end, t)
        case ppath.ArcTo:
                rx, ry, phi := p[i-7], p[i-6], p[i-5]
                large, sweep := ppath.ToArcFlags(p[i-4])
                _, _, theta0, theta1 := ppath.EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)
                theta := theta0 + t*(theta1-theta0)
                return 1.0 / EllipseCurvatureRadius(rx, ry, sweep, theta)
        }
        return 0.0
}

// Curvature returns the curvature of the path at the given segment
// and t in [0.0,1.0] along that path. It is zero for straight lines
// and for non-existing segments.
func Curvature(p ppath.Path, seg int, t float32) float32 {
        if len(p) <= 4 {
                return 0.0
        }

        curSeg := 0
        iStart, iSeg, iEnd := 0, 0, 0
        for i := 0; i < len(p); {
                cmd := p[i]
                if cmd == ppath.MoveTo {
                        if seg < curSeg {
                                pi := p[iStart:iEnd]
                                return curvature(pi, iSeg-iStart, t)
                        }
                        iStart = i
                }
                if seg == curSeg {
                        iSeg = i
                }
                i += ppath.CmdLen(cmd)
        }
        return 0.0 // if segment doesn't exist
}

// windings counts intersections of ray with path.
// ppath.Paths that cross downwards are negative and upwards are positive.
// It returns the windings excluding the start position and the
// windings of the start position itself. If the windings of the
// start position is not zero, the start position is on a boundary.
func windings(zs []Intersection) (int, bool) {
        // There are four particular situations to be aware of. Whenever the path is horizontal it
        // will be parallel to the ray, and usually overlapping. Either we have:
        // - a starting point to the left of the overlapping section: ignore the overlapping
        //   intersections so that it appears as a regular intersection, albeit at the endpoints
        //   of two segments, which may either cancel out to zero (top or bottom edge) or add up to
        //   1 or -1 if the path goes upwards or downwards respectively before/after the overlap.
        // - a starting point on the left-hand corner of an overlapping section: ignore if either
        //   intersection of an endpoint pair (t=0,t=1) is overlapping, but count for nb upon
        //   leaving the overlap.
        // - a starting point in the middle of an overlapping section: same as above
        // - a starting point on the right-hand corner of an overlapping section: intersections are
        //   tangent and thus already ignored for n, but for nb we should ignore the intersection with
        //   a 0/180 degree direction, and count the other

        n := 0
        boundary := false
        for i := 0; i < len(zs); i++ {
                z := zs[i]
                if z.T[0] == 0.0 {
                        boundary = true
                        continue
                }

                d := 1
                if z.Into() {
                        d = -1 // downwards
                }
                if z.T[1] != 0.0 && z.T[1] != 1.0 {
                        if !z.Same {
                                n += d
                        }
                } else if i+1 < len(zs) {
                        same := z.Same || (len(zs) > i+1 && zs[i+1].Same)
                        if !same && len(zs) > i+1 {
                                if z.Into() == zs[i+1].Into() {
                                        n += d
                                }
                        }
                        i++
                }
        }
        return n, boundary
}

// Windings returns the number of windings at the given point,
// i.e. the sum of windings for each time a ray from (x,y)
// towards (∞,y) intersects the path. Counter clock-wise
// intersections count as positive, while clock-wise intersections
// count as negative. Additionally, it returns whether the point
// is on a path's boundary (which counts as being on the exterior).
func Windings(p ppath.Path, x, y float32) (int, bool) {
        n := 0
        boundary := false
        for _, pi := range p.Split() {
                zs := RayIntersections(pi, x, y)
                if ni, boundaryi := windings(zs); boundaryi {
                        boundary = true
                } else {
                        n += ni
                }
        }
        return n, boundary
}

// Crossings returns the number of crossings with the path from the
// given point outwards, i.e. the number of times a ray from (x,y)
// towards (∞,y) intersects the path. Additionally, it returns whether
// the point is on a path's boundary (which does not count towards
// the number of crossings).
func Crossings(p ppath.Path, x, y float32) (int, bool) {
        n := 0
        boundary := false
        for _, pi := range p.Split() {
                // Count intersections of ray with path. Count half an intersection on boundaries.
                ni := 0.0
                for _, z := range RayIntersections(pi, x, y) {
                        if z.T[0] == 0.0 {
                                boundary = true
                        } else if !z.Same {
                                if z.T[1] == 0.0 || z.T[1] == 1.0 {
                                        ni += 0.5
                                } else {
                                        ni += 1.0
                                }
                        } else if z.T[1] == 0.0 || z.T[1] == 1.0 {
                                ni -= 0.5
                        }
                }
                n += int(ni)
        }
        return n, boundary
}

// Contains returns whether the point (x,y) is contained/filled by the path.
// This depends on the ppath.FillRules. It uses a ray from (x,y) toward (∞,y) and
// counts the number of intersections with the path.
// When the point is on the boundary it is considered to be on the path's exterior.
func Contains(p ppath.Path, x, y float32, fillRule ppath.FillRules) bool {
        n, boundary := Windings(p, x, y)
        if boundary {
                return true
        }
        return fillRule.Fills(n)
}

// CCW returns true when the path is counter clockwise oriented at its
// bottom-right-most coordinate. It is most useful when knowing that
// the path does not self-intersect as it will tell you if the entire
// path is CCW or not. It will only return the result for the first subpath.
// It will return true for an empty path or a straight line.
// It may not return a valid value when the right-most point happens to be a
// (self-)overlapping segment.
func CCW(p ppath.Path) bool {
        if len(p) <= 4 || (p[4] == ppath.LineTo || p[4] == ppath.Close) && len(p) <= 4+ppath.CmdLen(p[4]) {
                // empty path or single straight segment
                return true
        }

        p = XMonotone(p)

        // pick bottom-right-most coordinate of subpath, as we know its left-hand side is filling
        k, kMax := 4, len(p)
        if p[kMax-1] == ppath.Close {
                kMax -= ppath.CmdLen(ppath.Close)
        }
        for i := 4; i < len(p); {
                cmd := p[i]
                if cmd == ppath.MoveTo {
                        // only handle first subpath
                        kMax = i
                        break
                }
                i += ppath.CmdLen(cmd)
                if x, y := p[i-3], p[i-2]; p[k-3] < x || ppath.Equal(p[k-3], x) && y < p[k-2] {
                        k = i
                }
        }

        // get coordinates of previous and next segments
        var kPrev int
        if k == 4 {
                kPrev = kMax
        } else {
                kPrev = k - ppath.CmdLen(p[k-1])
        }

        var angleNext float32
        anglePrev := ppath.AngleNorm(ppath.Angle(ppath.DirectionIndex(p, kPrev, 1.0)) + math32.Pi)
        if k == kMax {
                // use implicit close command
                angleNext = ppath.Angle(math32.Vec2(p[1], p[2]).Sub(math32.Vec2(p[k-3], p[k-2])))
        } else {
                angleNext = ppath.Angle(ppath.DirectionIndex(p, k, 0.0))
        }
        if ppath.Equal(anglePrev, angleNext) {
                // segments have the same direction at their right-most point
                // one or both are not straight lines, check if curvature is different
                var curvNext float32
                curvPrev := -curvature(p, kPrev, 1.0)
                if k == kMax {
                        // use implicit close command
                        curvNext = 0.0
                } else {
                        curvNext = curvature(p, k, 0.0)
                }
                if !ppath.Equal(curvPrev, curvNext) {
                        // ccw if curvNext is smaller than curvPrev
                        return curvNext < curvPrev
                }
        }
        return (angleNext - anglePrev) < 0.0
}

// Filling returns whether each subpath gets filled or not.
// Whether a path is filled depends on the ppath.FillRules and whether it
// negates another path. If a subpath is not closed, it is implicitly
// assumed to be closed.
func Filling(p ppath.Path, fillRule ppath.FillRules) []bool {
        ps := p.Split()
        filling := make([]bool, len(ps))
        for i, pi := range ps {
                // get current subpath's winding
                n := 0
                if CCW(pi) {
                        n++
                } else {
                        n--
                }

                // sum windings from other subpaths
                pos := math32.Vec2(pi[1], pi[2])
                for j, pj := range ps {
                        if i == j {
                                continue
                        }
                        zs := RayIntersections(pj, pos.X, pos.Y)
                        if ni, boundaryi := windings(zs); !boundaryi {
                                n += ni
                        } else {
                                // on the boundary, check if around the interior or exterior of pos
                        }
                }
                filling[i] = fillRule.Fills(n)
        }
        return filling
}

// Length returns the length of the path in millimeters.
// The length is approximated for cubic Béziers.
func Length(p ppath.Path) float32 {
        d := float32(0.0)
        var start, end math32.Vector2
        for i := 0; i < len(p); {
                cmd := p[i]
                switch cmd {
                case ppath.MoveTo:
                        end = math32.Vec2(p[i+1], p[i+2])
                case ppath.LineTo, ppath.Close:
                        end = math32.Vec2(p[i+1], p[i+2])
                        d += end.Sub(start).Length()
                case ppath.QuadTo:
                        cp := math32.Vec2(p[i+1], p[i+2])
                        end = math32.Vec2(p[i+3], p[i+4])
                        d += quadraticBezierLength(start, cp, end)
                case ppath.CubeTo:
                        cp1 := math32.Vec2(p[i+1], p[i+2])
                        cp2 := math32.Vec2(p[i+3], p[i+4])
                        end = math32.Vec2(p[i+5], p[i+6])
                        d += cubicBezierLength(start, cp1, cp2, end)
                case ppath.ArcTo:
                        var rx, ry, phi float32
                        var large, sweep bool
                        rx, ry, phi, large, sweep, end = p.ArcToPoints(i)
                        _, _, theta1, theta2 := ppath.EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)
                        d += ellipseLength(rx, ry, theta1, theta2)
                }
                i += ppath.CmdLen(cmd)
                start = end
        }
        return d
}

// IsFlat returns true if the path consists of solely line segments,
// that is only MoveTo, ppath.LineTo and Close commands.
func IsFlat(p ppath.Path) bool {
        for i := 0; i < len(p); {
                cmd := p[i]
                if cmd != ppath.MoveTo && cmd != ppath.LineTo && cmd != ppath.Close {
                        return false
                }
                i += ppath.CmdLen(cmd)
        }
        return true
}

// SplitAt splits the path into separate paths at the specified
// intervals (given in millimeters) along the path.
func SplitAt(p ppath.Path, ts ...float32) []ppath.Path {
        if len(ts) == 0 {
                return []ppath.Path{p}
        }

        slices.Sort(ts)
        if ts[0] == 0.0 {
                ts = ts[1:]
        }

        j := 0            // index into ts
        T := float32(0.0) // current position along curve

        qs := []ppath.Path{}
        q := ppath.Path{}
        push := func() {
                qs = append(qs, q)
                q = ppath.Path{}
        }

        if 0 < len(p) && p[0] == ppath.MoveTo {
                q.MoveTo(p[1], p[2])
        }
        for _, ps := range p.Split() {
                var start, end math32.Vector2
                for i := 0; i < len(ps); {
                        cmd := ps[i]
                        switch cmd {
                        case ppath.MoveTo:
                                end = math32.Vec2(p[i+1], p[i+2])
                        case ppath.LineTo, ppath.Close:
                                end = math32.Vec2(p[i+1], p[i+2])

                                if j == len(ts) {
                                        q.LineTo(end.X, end.Y)
                                } else {
                                        dT := end.Sub(start).Length()
                                        Tcurve := T
                                        for j < len(ts) && T < ts[j] && ts[j] <= T+dT {
                                                tpos := (ts[j] - T) / dT
                                                pos := start.Lerp(end, tpos)
                                                Tcurve = ts[j]

                                                q.LineTo(pos.X, pos.Y)
                                                push()
                                                q.MoveTo(pos.X, pos.Y)
                                                j++
                                        }
                                        if Tcurve < T+dT {
                                                q.LineTo(end.X, end.Y)
                                        }
                                        T += dT
                                }
                        case ppath.QuadTo:
                                cp := math32.Vec2(p[i+1], p[i+2])
                                end = math32.Vec2(p[i+3], p[i+4])

                                if j == len(ts) {
                                        q.QuadTo(cp.X, cp.Y, end.X, end.Y)
                                } else {
                                        speed := func(t float32) float32 {
                                                return ppath.QuadraticBezierDeriv(start, cp, end, t).Length()
                                        }
                                        invL, dT := invSpeedPolynomialChebyshevApprox(20, gaussLegendre7, speed, 0.0, 1.0)

                                        t0 := float32(0.0)
                                        r0, r1, r2 := start, cp, end
                                        for j < len(ts) && T < ts[j] && ts[j] <= T+dT {
                                                t := invL(ts[j] - T)
                                                tsub := (t - t0) / (1.0 - t0)
                                                t0 = t

                                                var q1 math32.Vector2
                                                _, q1, _, r0, r1, r2 = quadraticBezierSplit(r0, r1, r2, tsub)

                                                q.QuadTo(q1.X, q1.Y, r0.X, r0.Y)
                                                push()
                                                q.MoveTo(r0.X, r0.Y)
                                                j++
                                        }
                                        if !ppath.Equal(t0, 1.0) {
                                                q.QuadTo(r1.X, r1.Y, r2.X, r2.Y)
                                        }
                                        T += dT
                                }
                        case ppath.CubeTo:
                                cp1 := math32.Vec2(p[i+1], p[i+2])
                                cp2 := math32.Vec2(p[i+3], p[i+4])
                                end = math32.Vec2(p[i+5], p[i+6])

                                if j == len(ts) {
                                        q.CubeTo(cp1.X, cp1.Y, cp2.X, cp2.Y, end.X, end.Y)
                                } else {
                                        speed := func(t float32) float32 {
                                                // splitting on inflection points does not improve output
                                                return ppath.CubicBezierDeriv(start, cp1, cp2, end, t).Length()
                                        }
                                        N := 20 + 20*cubicBezierNumInflections(start, cp1, cp2, end) // TODO: needs better N
                                        invL, dT := invSpeedPolynomialChebyshevApprox(N, gaussLegendre7, speed, 0.0, 1.0)

                                        t0 := float32(0.0)
                                        r0, r1, r2, r3 := start, cp1, cp2, end
                                        for j < len(ts) && T < ts[j] && ts[j] <= T+dT {
                                                t := invL(ts[j] - T)
                                                tsub := (t - t0) / (1.0 - t0)
                                                t0 = t

                                                var q1, q2 math32.Vector2
                                                _, q1, q2, _, r0, r1, r2, r3 = cubicBezierSplit(r0, r1, r2, r3, tsub)

                                                q.CubeTo(q1.X, q1.Y, q2.X, q2.Y, r0.X, r0.Y)
                                                push()
                                                q.MoveTo(r0.X, r0.Y)
                                                j++
                                        }
                                        if !ppath.Equal(t0, 1.0) {
                                                q.CubeTo(r1.X, r1.Y, r2.X, r2.Y, r3.X, r3.Y)
                                        }
                                        T += dT
                                }
                        case ppath.ArcTo:
                                var rx, ry, phi float32
                                var large, sweep bool
                                rx, ry, phi, large, sweep, end = p.ArcToPoints(i)
                                cx, cy, theta1, theta2 := ppath.EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)

                                if j == len(ts) {
                                        q.ArcTo(rx, ry, phi, large, sweep, end.X, end.Y)
                                } else {
                                        speed := func(theta float32) float32 {
                                                return ppath.EllipseDeriv(rx, ry, 0.0, true, theta).Length()
                                        }
                                        invL, dT := invSpeedPolynomialChebyshevApprox(10, gaussLegendre7, speed, theta1, theta2)

                                        startTheta := theta1
                                        nextLarge := large
                                        for j < len(ts) && T < ts[j] && ts[j] <= T+dT {
                                                theta := invL(ts[j] - T)
                                                mid, large1, large2, ok := ellipseSplit(rx, ry, phi, cx, cy, startTheta, theta2, theta)
                                                if !ok {
                                                        panic("theta not in elliptic arc range for splitting")
                                                }

                                                q.ArcTo(rx, ry, phi, large1, sweep, mid.X, mid.Y)
                                                push()
                                                q.MoveTo(mid.X, mid.Y)
                                                startTheta = theta
                                                nextLarge = large2
                                                j++
                                        }
                                        if !ppath.Equal(startTheta, theta2) {
                                                q.ArcTo(rx, ry, phi*180.0/math32.Pi, nextLarge, sweep, end.X, end.Y)
                                        }
                                        T += dT
                                }
                        }
                        i += ppath.CmdLen(cmd)
                        start = end
                }
        }
        if ppath.CmdLen(ppath.MoveTo) < len(q) {
                push()
        }
        return qs
}

// XMonotone replaces all Bézier and arc segments to be x-monotone
// and returns a new path, that is each path segment is either increasing
// or decreasing with X while moving across the segment.
// This is always true for line segments.
func XMonotone(p ppath.Path) ppath.Path {
        quad := func(p0, p1, p2 math32.Vector2) ppath.Path {
                return xmonotoneQuadraticBezier(p0, p1, p2)
        }
        cube := func(p0, p1, p2, p3 math32.Vector2) ppath.Path {
                return xmonotoneCubicBezier(p0, p1, p2, p3)
        }
        arc := func(start math32.Vector2, rx, ry, phi float32, large, sweep bool, end math32.Vector2) ppath.Path {
                return xmonotoneEllipticArc(start, rx, ry, phi, large, sweep, end)
        }
        return p.Replace(nil, quad, cube, arc)
}

// Bounds returns the exact bounding box rectangle of the path.
func Bounds(p ppath.Path) math32.Box2 {
        if len(p) < 4 {
                return math32.Box2{}
        }

        // first command is MoveTo
        start, end := math32.Vec2(p[1], p[2]), math32.Vector2{}
        xmin, xmax := start.X, start.X
        ymin, ymax := start.Y, start.Y
        for i := 4; i < len(p); {
                cmd := p[i]
                switch cmd {
                case ppath.MoveTo, ppath.LineTo, ppath.Close:
                        end = math32.Vec2(p[i+1], p[i+2])
                        xmin = math32.Min(xmin, end.X)
                        xmax = math32.Max(xmax, end.X)
                        ymin = math32.Min(ymin, end.Y)
                        ymax = math32.Max(ymax, end.Y)
                case ppath.QuadTo:
                        cp := math32.Vec2(p[i+1], p[i+2])
                        end = math32.Vec2(p[i+3], p[i+4])

                        xmin = math32.Min(xmin, end.X)
                        xmax = math32.Max(xmax, end.X)
                        if tdenom := (start.X - 2*cp.X + end.X); !ppath.Equal(tdenom, 0.0) {
                                if t := (start.X - cp.X) / tdenom; inIntervalExclusive(t, 0.0, 1.0) {
                                        x := quadraticBezierPos(start, cp, end, t)
                                        xmin = math32.Min(xmin, x.X)
                                        xmax = math32.Max(xmax, x.X)
                                }
                        }

                        ymin = math32.Min(ymin, end.Y)
                        ymax = math32.Max(ymax, end.Y)
                        if tdenom := (start.Y - 2*cp.Y + end.Y); !ppath.Equal(tdenom, 0.0) {
                                if t := (start.Y - cp.Y) / tdenom; inIntervalExclusive(t, 0.0, 1.0) {
                                        y := quadraticBezierPos(start, cp, end, t)
                                        ymin = math32.Min(ymin, y.Y)
                                        ymax = math32.Max(ymax, y.Y)
                                }
                        }
                case ppath.CubeTo:
                        cp1 := math32.Vec2(p[i+1], p[i+2])
                        cp2 := math32.Vec2(p[i+3], p[i+4])
                        end = math32.Vec2(p[i+5], p[i+6])

                        a := -start.X + 3*cp1.X - 3*cp2.X + end.X
                        b := 2*start.X - 4*cp1.X + 2*cp2.X
                        c := -start.X + cp1.X
                        t1, t2 := solveQuadraticFormula(a, b, c)

                        xmin = math32.Min(xmin, end.X)
                        xmax = math32.Max(xmax, end.X)
                        if !math32.IsNaN(t1) && inIntervalExclusive(t1, 0.0, 1.0) {
                                x1 := cubicBezierPos(start, cp1, cp2, end, t1)
                                xmin = math32.Min(xmin, x1.X)
                                xmax = math32.Max(xmax, x1.X)
                        }
                        if !math32.IsNaN(t2) && inIntervalExclusive(t2, 0.0, 1.0) {
                                x2 := cubicBezierPos(start, cp1, cp2, end, t2)
                                xmin = math32.Min(xmin, x2.X)
                                xmax = math32.Max(xmax, x2.X)
                        }

                        a = -start.Y + 3*cp1.Y - 3*cp2.Y + end.Y
                        b = 2*start.Y - 4*cp1.Y + 2*cp2.Y
                        c = -start.Y + cp1.Y
                        t1, t2 = solveQuadraticFormula(a, b, c)

                        ymin = math32.Min(ymin, end.Y)
                        ymax = math32.Max(ymax, end.Y)
                        if !math32.IsNaN(t1) && inIntervalExclusive(t1, 0.0, 1.0) {
                                y1 := cubicBezierPos(start, cp1, cp2, end, t1)
                                ymin = math32.Min(ymin, y1.Y)
                                ymax = math32.Max(ymax, y1.Y)
                        }
                        if !math32.IsNaN(t2) && inIntervalExclusive(t2, 0.0, 1.0) {
                                y2 := cubicBezierPos(start, cp1, cp2, end, t2)
                                ymin = math32.Min(ymin, y2.Y)
                                ymax = math32.Max(ymax, y2.Y)
                        }
                case ppath.ArcTo:
                        var rx, ry, phi float32
                        var large, sweep bool
                        rx, ry, phi, large, sweep, end = p.ArcToPoints(i)
                        cx, cy, theta0, theta1 := ppath.EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)

                        // find the four extremes (top, bottom, left, right) and apply those who are between theta1 and theta2
                        // x(theta) = cx + rx*cos(theta)*cos(phi) - ry*sin(theta)*sin(phi)
                        // y(theta) = cy + rx*cos(theta)*sin(phi) + ry*sin(theta)*cos(phi)
                        // be aware that positive rotation appears clockwise in SVGs (non-Cartesian coordinate system)
                        // we can now find the angles of the extremes

                        sinphi, cosphi := math32.Sincos(phi)
                        thetaRight := math32.Atan2(-ry*sinphi, rx*cosphi)
                        thetaTop := math32.Atan2(rx*cosphi, ry*sinphi)
                        thetaLeft := thetaRight + math32.Pi
                        thetaBottom := thetaTop + math32.Pi

                        dx := math32.Sqrt(rx*rx*cosphi*cosphi + ry*ry*sinphi*sinphi)
                        dy := math32.Sqrt(rx*rx*sinphi*sinphi + ry*ry*cosphi*cosphi)
                        if ppath.IsAngleBetween(thetaLeft, theta0, theta1) {
                                xmin = math32.Min(xmin, cx-dx)
                        }
                        if ppath.IsAngleBetween(thetaRight, theta0, theta1) {
                                xmax = math32.Max(xmax, cx+dx)
                        }
                        if ppath.IsAngleBetween(thetaBottom, theta0, theta1) {
                                ymin = math32.Min(ymin, cy-dy)
                        }
                        if ppath.IsAngleBetween(thetaTop, theta0, theta1) {
                                ymax = math32.Max(ymax, cy+dy)
                        }
                        xmin = math32.Min(xmin, end.X)
                        xmax = math32.Max(xmax, end.X)
                        ymin = math32.Min(ymin, end.Y)
                        ymax = math32.Max(ymax, end.Y)
                }
                i += ppath.CmdLen(cmd)
                start = end
        }
        return math32.B2(xmin, ymin, xmax, ymax)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package intersect

import (
        "fmt"
        "io"
        "slices"
        "sort"
        "strings"
        "sync"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
)

// BentleyOttmannEpsilon is the snap rounding grid used by the Bentley-Ottmann algorithm.
// This prevents numerical issues. It must be larger than Epsilon since we use that to calculate
// intersections between segments. It is the number of binary digits to keep.
var BentleyOttmannEpsilon = float32(1e-8)

// RayIntersections returns the intersections of a path with a ray starting at (x,y) to (∞,y).
// An intersection is tangent only when it is at (x,y), i.e. the start of the ray. The parameter T
// along the ray is zero at the start but NaN otherwise. Intersections are sorted along the ray.
// This function runs in O(n) with n the number of path segments.
func RayIntersections(p ppath.Path, x, y float32) []Intersection {
        var start, end, cp1, cp2 math32.Vector2
        var zs []Intersection
        for i := 0; i < len(p); {
                cmd := p[i]
                switch cmd {
                case ppath.MoveTo:
                        end = p.EndPoint(i)
                case ppath.LineTo, ppath.Close:
                        end = p.EndPoint(i)
                        ymin := math32.Min(start.Y, end.Y)
                        ymax := math32.Max(start.Y, end.Y)
                        xmax := math32.Max(start.X, end.X)
                        if inInterval(y, ymin, ymax) && x <= xmax+ppath.Epsilon {
                                zs = intersectionLineLine(zs, math32.Vector2{x, y}, math32.Vector2{xmax + 1.0, y}, start, end)
                        }
                case ppath.QuadTo:
                        cp1, end = p.QuadToPoints(i)
                        ymin := math32.Min(math32.Min(start.Y, end.Y), cp1.Y)
                        ymax := math32.Max(math32.Max(start.Y, end.Y), cp1.Y)
                        xmax := math32.Max(math32.Max(start.X, end.X), cp1.X)
                        if inInterval(y, ymin, ymax) && x <= xmax+ppath.Epsilon {
                                zs = intersectionLineQuad(zs, math32.Vector2{x, y}, math32.Vector2{xmax + 1.0, y}, start, cp1, end)
                        }
                case ppath.CubeTo:
                        cp1, cp2, end = p.CubeToPoints(i)
                        ymin := math32.Min(math32.Min(start.Y, end.Y), math32.Min(cp1.Y, cp2.Y))
                        ymax := math32.Max(math32.Max(start.Y, end.Y), math32.Max(cp1.Y, cp2.Y))
                        xmax := math32.Max(math32.Max(start.X, end.X), math32.Max(cp1.X, cp2.X))
                        if inInterval(y, ymin, ymax) && x <= xmax+ppath.Epsilon {
                                zs = intersectionLineCube(zs, math32.Vector2{x, y}, math32.Vector2{xmax + 1.0, y}, start, cp1, cp2, end)
                        }
                case ppath.ArcTo:
                        var rx, ry, phi float32
                        var large, sweep bool
                        rx, ry, phi, large, sweep, end = p.ArcToPoints(i)
                        cx, cy, theta0, theta1 := ppath.EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)
                        if inInterval(y, cy-math32.Max(rx, ry), cy+math32.Max(rx, ry)) && x <= cx+math32.Max(rx, ry)+ppath.Epsilon {
                                zs = intersectionLineEllipse(zs, math32.Vector2{x, y}, math32.Vector2{cx + rx + 1.0, y}, math32.Vector2{cx, cy}, math32.Vector2{rx, ry}, phi, theta0, theta1)
                        }
                }
                i += ppath.CmdLen(cmd)
                start = end
        }
        for i := range zs {
                if zs[i].T[0] != 0.0 {
                        zs[i].T[0] = math32.NaN()
                }
        }
        sort.SliceStable(zs, func(i, j int) bool {
                if ppath.Equal(zs[i].X, zs[j].X) {
                        return false
                }
                return zs[i].X < zs[j].X
        })
        return zs
}

type pathOp int

const (
        opSettle pathOp = iota
        opAND
        opOR
        opNOT
        opXOR
        opDIV
)

func (op pathOp) String() string {
        switch op {
        case opSettle:
                return "Settle"
        case opAND:
                return "AND"
        case opOR:
                return "OR"
        case opNOT:
                return "NOT"
        case opXOR:
                return "XOR"
        case opDIV:
                return "DIV"
        }
        return fmt.Sprintf("pathOp(%d)", op)
}

var boPointPool *sync.Pool
var boNodePool *sync.Pool
var boSquarePool *sync.Pool
var boInitPoolsOnce = sync.OnceFunc(func() {
        boPointPool = &sync.Pool{New: func() any { return &SweepPoint{} }}
        boNodePool = &sync.Pool{New: func() any { return &SweepNode{} }}
        boSquarePool = &sync.Pool{New: func() any { return &toleranceSquare{} }}
})

// Settle returns the "settled" path. It removes all self-intersections, orients all filling paths
// CCW and all holes CW, and tries to split into subpaths if possible. Note that path p is
// flattened unless q is already flat. ppath.Path q is implicitly closed. It runs in O((n + k) log n),
// with n the sum of the number of segments, and k the number of intersections.
func Settle(p ppath.Path, fillRule ppath.FillRules) ppath.Path {
        return bentleyOttmann(p.Split(), nil, opSettle, fillRule)
}

// SettlePaths is the same as [Settle], but faster if paths are already split.
func SettlePaths(ps ppath.Paths, fillRule ppath.FillRules) ppath.Path {
        return bentleyOttmann(ps, nil, opSettle, fillRule)
}

// And returns the boolean path operation of path p AND q, i.e. the intersection of both. It
// removes all self-intersections, orients all filling paths CCW and all holes CW, and tries to
// split into subpaths if possible. Note that path p is flattened unless q is already flat. ppath.Path
// q is implicitly closed. It runs in O((n + k) log n), with n the sum of the number of segments,
// and k the number of intersections.
func And(p ppath.Path, q ppath.Path) ppath.Path {
        return bentleyOttmann(p.Split(), q.Split(), opAND, ppath.NonZero)
}

// AndPaths is the same as [And], but faster if paths are already split.
func AndPaths(ps ppath.Paths, qs ppath.Paths) ppath.Path {
        return bentleyOttmann(ps, qs, opAND, ppath.NonZero)
}

// Or returns the boolean path operation of path p OR q, i.e. the union of both. It
// removes all self-intersections, orients all filling paths CCW and all holes CW, and tries to
// split into subpaths if possible. Note that path p is flattened unless q is already flat. ppath.Path
// q is implicitly closed. It runs in O((n + k) log n), with n the sum of the number of segments,
// and k the number of intersections.
func Or(p ppath.Path, q ppath.Path) ppath.Path {
        return bentleyOttmann(p.Split(), q.Split(), opOR, ppath.NonZero)
}

// OrPaths is the same as ppath.Path.Or, but faster if paths are already split.
func OrPaths(ps ppath.Paths, qs ppath.Paths) ppath.Path {
        return bentleyOttmann(ps, qs, opOR, ppath.NonZero)
}

// Xor returns the boolean path operation of path p XOR q, i.e. the symmetric difference of both.
// It removes all self-intersections, orients all filling paths CCW and all holes CW, and tries to
// split into subpaths if possible. Note that path p is flattened unless q is already flat. ppath.Path
// q is implicitly closed. It runs in O((n + k) log n), with n the sum of the number of segments,
// and k the number of intersections.
func Xor(p ppath.Path, q ppath.Path) ppath.Path {
        return bentleyOttmann(p.Split(), q.Split(), opXOR, ppath.NonZero)
}

// XorPaths is the same as [Xor], but faster if paths are already split.
func XorPaths(ps ppath.Paths, qs ppath.Paths) ppath.Path {
        return bentleyOttmann(ps, qs, opXOR, ppath.NonZero)
}

// Not returns the boolean path operation of path p NOT q, i.e. the difference of both.
// It removes all self-intersections, orients all filling paths CCW and all holes CW, and tries to
// split into subpaths if possible. Note that path p is flattened unless q is already flat. ppath.Path
// q is implicitly closed. It runs in O((n + k) log n), with n the sum of the number of segments,
// and k the number of intersections.
func Not(p ppath.Path, q ppath.Path) ppath.Path {
        return bentleyOttmann(p.Split(), q.Split(), opNOT, ppath.NonZero)
}

// NotPaths is the same as ppath.Path.Not, but faster if paths are already split.
func NotPaths(ps ppath.Paths, qs ppath.Paths) ppath.Path {
        return bentleyOttmann(ps, qs, opNOT, ppath.NonZero)
}

// DivideBy returns the boolean path operation of path p DIV q, i.e. p divided by q.
// It removes all self-intersections, orients all filling paths CCW and all holes CW, and tries to
// split into subpaths if possible. Note that path p is flattened unless q is already flat. ppath.Path
// q is implicitly closed. It runs in O((n + k) log n), with n the sum of the number of segments,
// and k the number of intersections.
func DivideBy(p ppath.Path, q ppath.Path) ppath.Path {
        return bentleyOttmann(p.Split(), q.Split(), opDIV, ppath.NonZero)
}

// DivideByPaths is the same as [DivideBy] but faster if paths are already split.
func DivideByPaths(ps ppath.Paths, qs ppath.Paths) ppath.Path {
        return bentleyOttmann(ps, qs, opDIV, ppath.NonZero)
}

type SweepPoint struct {
        // initial data
        math32.Vector2             // position of this endpoint
        other          *SweepPoint // pointer to the other endpoint of the segment
        segment        int         // segment index to distinguish self-overlapping segments

        // processing the queue
        node *SweepNode // used for fast accessing btree node in O(1) (instead of Find in O(log n))

        // computing sweep fields
        windings          int         // windings of the same polygon (excluding this segment)
        otherWindings     int         // windings of the other polygon
        selfWindings      int         // positive if segment goes left-right (or bottom-top when vertical)
        otherSelfWindings int         // used when merging overlapping segments
        prev              *SweepPoint // segment below

        // building the polygon
        index          int // index into result array
        resultWindings int // windings of the resulting polygon

        // bools at the end to optimize memory layout of struct
        clipping   bool  // is clipping path (otherwise is subject path)
        open       bool  // path is not closed (only for subject paths)
        left       bool  // point is left-end of segment
        vertical   bool  // segment is vertical
        increasing bool  // original direction is left-right (or bottom-top)
        overlapped bool  // segment's overlapping was handled
        inResult   uint8 // in final result polygon (1 is once, 2 is twice for opDIV)
}

func (s *SweepPoint) InterpolateY(x float32) float32 {
        t := (x - s.X) / (s.other.X - s.X)
        return s.Lerp(s.other.Vector2, t).Y
}

// ToleranceEdgeY returns the y-value of the SweepPoint at the tolerance edges given by xLeft and
// xRight, or at the endpoints of the SweepPoint, whichever comes first.
func (s *SweepPoint) ToleranceEdgeY(xLeft, xRight float32) (float32, float32) {
        if !s.left {
                s = s.other
        }

        y0 := s.Y
        if s.X < xLeft {
                y0 = s.InterpolateY(xLeft)
        }
        y1 := s.other.Y
        if xRight <= s.other.X {
                y1 = s.InterpolateY(xRight)
        }
        return y0, y1
}

func (s *SweepPoint) SplitAt(z math32.Vector2) (*SweepPoint, *SweepPoint) {
        // split segment at point
        r := boPointPool.Get().(*SweepPoint)
        l := boPointPool.Get().(*SweepPoint)
        *r, *l = *s.other, *s
        r.Vector2, l.Vector2 = z, z

        // update references
        r.other, s.other.other = s, l
        l.other, s.other = s.other, r
        l.node = nil
        return r, l
}

func (s *SweepPoint) Reverse() {
        s.left, s.other.left = !s.left, s.left
        s.increasing, s.other.increasing = !s.increasing, !s.other.increasing
}

func (s *SweepPoint) String() string {
        path := "P"
        if s.clipping {
                path = "Q"
        }
        arrow := "→"
        if !s.left {
                arrow = "←"
        }
        return fmt.Sprintf("%s-%v(%v%v%v)", path, s.segment, s.Vector2, arrow, s.other.Vector2)
}

// SweepEvents is a heap priority queue of sweep events.
type SweepEvents []*SweepPoint

func (q SweepEvents) Less(i, j int) bool {
        return q[i].LessH(q[j])
}

func (q SweepEvents) Swap(i, j int) {
        q[i], q[j] = q[j], q[i]
}

func (q *SweepEvents) AddPathEndpoints(p ppath.Path, seg int, clipping bool) int {
        if len(p) == 0 {
                return seg
        }

        // TODO: change this if we allow non-flat paths
        // allocate all memory at once to prevent multiple allocations/memmoves below
        n := len(p) / 4
        if cap(*q) < len(*q)+n {
                q2 := make(SweepEvents, len(*q), len(*q)+n)
                copy(q2, *q)
                *q = q2
        }

        open := !p.Closed()
        start := math32.Vector2{p[1], p[2]}
        if math32.IsNaN(start.X) || math32.IsInf(start.X, 0.0) || math32.IsNaN(start.Y) || math32.IsInf(start.Y, 0.0) {
                panic("path has NaN or Inf")
        }
        for i := 4; i < len(p); {
                if p[i] != ppath.LineTo && p[i] != ppath.Close {
                        panic("non-flat paths not supported")
                }

                n := ppath.CmdLen(p[i])
                end := math32.Vector2{p[i+n-3], p[i+n-2]}
                if math32.IsNaN(end.X) || math32.IsInf(end.X, 0.0) || math32.IsNaN(end.Y) || math32.IsInf(end.Y, 0.0) {
                        panic("path has NaN or Inf")
                }
                i += n
                seg++

                if start == end {
                        // skip zero-length lineTo or close command
                        start = end
                        continue
                }

                vertical := start.X == end.X
                increasing := start.X < end.X
                if vertical {
                        increasing = start.Y < end.Y
                }
                a := boPointPool.Get().(*SweepPoint)
                b := boPointPool.Get().(*SweepPoint)
                *a = SweepPoint{
                        Vector2:    start,
                        clipping:   clipping,
                        open:       open,
                        segment:    seg,
                        left:       increasing,
                        increasing: increasing,
                        vertical:   vertical,
                }
                *b = SweepPoint{
                        Vector2:    end,
                        clipping:   clipping,
                        open:       open,
                        segment:    seg,
                        left:       !increasing,
                        increasing: increasing,
                        vertical:   vertical,
                }
                a.other = b
                b.other = a
                *q = append(*q, a, b)
                start = end
        }
        return seg
}

func (q SweepEvents) Init() {
        n := len(q)
        for i := n/2 - 1; 0 <= i; i-- {
                q.down(i, n)
        }
}

func (q *SweepEvents) Push(item *SweepPoint) {
        *q = append(*q, item)
        q.up(len(*q) - 1)
}

func (q *SweepEvents) Top() *SweepPoint {
        return (*q)[0]
}

func (q *SweepEvents) Pop() *SweepPoint {
        n := len(*q) - 1
        q.Swap(0, n)
        q.down(0, n)

        items := (*q)[n]
        *q = (*q)[:n]
        return items
}

func (q *SweepEvents) Fix(i int) {
        if !q.down(i, len(*q)) {
                q.up(i)
        }
}

// from container/heap
func (q SweepEvents) up(j int) {
        for {
                i := (j - 1) / 2 // parent
                if i == j || !q.Less(j, i) {
                        break
                }
                q.Swap(i, j)
                j = i
        }
}

func (q SweepEvents) down(i0, n int) bool {
        i := i0
        for {
                j1 := 2*i + 1
                if n <= j1 || j1 < 0 { // j1 < 0 after int overflow
                        break
                }
                j := j1 // left child
                if j2 := j1 + 1; j2 < n && q.Less(j2, j1) {
                        j = j2 // = 2*i + 2  // right child
                }
                if !q.Less(j, i) {
                        break
                }
                q.Swap(i, j)
                i = j
        }
        return i0 < i
}

func (q SweepEvents) Print(w io.Writer) {
        q2 := make(SweepEvents, len(q))
        copy(q2, q)
        q = q2

        n := len(q) - 1
        for 0 < n {
                q.Swap(0, n)
                q.down(0, n)
                n--
        }
        width := int(math32.Max(0.0, math32.Log10(float32(len(q)-1)))) + 1
        for k := len(q) - 1; 0 <= k; k-- {
                fmt.Fprintf(w, "%*d %v\n", width, len(q)-1-k, q[k])
        }
        return
}

func (q SweepEvents) String() string {
        sb := strings.Builder{}
        q.Print(&sb)
        str := sb.String()
        if 0 < len(str) {
                str = str[:len(str)-1]
        }
        return str
}

type SweepNode struct {
        parent, left, right *SweepNode
        height              int

        *SweepPoint
}

func (n *SweepNode) Prev() *SweepNode {
        // go left
        if n.left != nil {
                n = n.left
                for n.right != nil {
                        n = n.right // find the right-most of current subtree
                }
                return n
        }

        for n.parent != nil && n.parent.left == n {
                n = n.parent // find first parent for which we're right
        }
        return n.parent // can be nil
}

func (n *SweepNode) Next() *SweepNode {
        // go right
        if n.right != nil {
                n = n.right
                for n.left != nil {
                        n = n.left // find the left-most of current subtree
                }
                return n
        }

        for n.parent != nil && n.parent.right == n {
                n = n.parent // find first parent for which we're left
        }
        return n.parent // can be nil
}

func (a *SweepNode) swap(b *SweepNode) {
        a.SweepPoint, b.SweepPoint = b.SweepPoint, a.SweepPoint
        a.SweepPoint.node, b.SweepPoint.node = a, b
}

//func (n *SweepNode) fix() (*SweepNode, int) {
//        move := 0
//        if prev := n.Prev(); prev != nil && 0 < prev.CompareV(n.SweepPoint, false) {
//                // move down
//                n.swap(prev)
//                n, prev = prev, n
//                move--
//
//                for prev = prev.Prev(); prev != nil; prev = prev.Prev() {
//                        if prev.CompareV(n.SweepPoint, false) < 0 {
//                                break
//                        }
//                        n.swap(prev)
//                        n, prev = prev, n
//                        move--
//                }
//        } else if next := n.Next(); next != nil && next.CompareV(n.SweepPoint, false) < 0 {
//                // move up
//                n.swap(next)
//                n, next = next, n
//                move++
//
//                for next = next.Next(); next != nil; next = next.Next() {
//                        if 0 < next.CompareV(n.SweepPoint, false) {
//                                break
//                        }
//                        n.swap(next)
//                        n, next = next, n
//                        move++
//                }
//        }
//        return n, move
//}

func (n *SweepNode) balance() int {
        r := 0
        if n.left != nil {
                r -= n.left.height
        }
        if n.right != nil {
                r += n.right.height
        }
        return r
}

func (n *SweepNode) updateHeight() {
        n.height = 0
        if n.left != nil {
                n.height = n.left.height
        }
        if n.right != nil && n.height < n.right.height {
                n.height = n.right.height
        }
        n.height++
}

func (n *SweepNode) swapChild(a, b *SweepNode) {
        if n.right == a {
                n.right = b
        } else {
                n.left = b
        }
        if b != nil {
                b.parent = n
        }
}

func (a *SweepNode) rotateLeft() *SweepNode {
        b := a.right
        if a.parent != nil {
                a.parent.swapChild(a, b)
        } else {
                b.parent = nil
        }
        a.parent = b
        if a.right = b.left; a.right != nil {
                a.right.parent = a
        }
        b.left = a
        return b
}

func (a *SweepNode) rotateRight() *SweepNode {
        b := a.left
        if a.parent != nil {
                a.parent.swapChild(a, b)
        } else {
                b.parent = nil
        }
        a.parent = b
        if a.left = b.right; a.left != nil {
                a.left.parent = a
        }
        b.right = a
        return b
}

func (n *SweepNode) print(w io.Writer, prefix string, cmp int) {
        c := ""
        if cmp < 0 {
                c = "│ "
        } else if 0 < cmp {
                c = "  "
        }
        if n.right != nil {
                n.right.print(w, prefix+c, 1)
        } else if n.left != nil {
                fmt.Fprintf(w, "%v%v┌─nil\n", prefix, c)
        }

        c = ""
        if 0 < cmp {
                c = "┌─"
        } else if cmp < 0 {
                c = "└─"
        }
        fmt.Fprintf(w, "%v%v%v\n", prefix, c, n.SweepPoint)

        c = ""
        if 0 < cmp {
                c = "│ "
        } else if cmp < 0 {
                c = "  "
        }
        if n.left != nil {
                n.left.print(w, prefix+c, -1)
        } else if n.right != nil {
                fmt.Fprintf(w, "%v%v└─nil\n", prefix, c)
        }
}

func (n *SweepNode) Print(w io.Writer) {
        n.print(w, "", 0)
}

// TODO: test performance versus (2,4)-tree (current LEDA implementation), (2,16)-tree (as proposed by S. Naber/Näher in "Comparison of search-tree data structures in LEDA. Personal communication" apparently), RB-tree (likely a good candidate), and an AA-tree (simpler implementation may be faster). Perhaps an unbalanced (e.g. Treap) works well due to the high number of insertions/deletions.
type SweepStatus struct {
        root *SweepNode
}

func (s *SweepStatus) newNode(item *SweepPoint) *SweepNode {
        n := boNodePool.Get().(*SweepNode)
        n.parent = nil
        n.left = nil
        n.right = nil
        n.height = 1
        n.SweepPoint = item
        n.SweepPoint.node = n
        return n
}

func (s *SweepStatus) returnNode(n *SweepNode) {
        n.SweepPoint.node = nil
        n.SweepPoint = nil // help the GC
        boNodePool.Put(n)
}

func (s *SweepStatus) find(item *SweepPoint) (*SweepNode, int) {
        n := s.root
        for n != nil {
                cmp := item.CompareV(n.SweepPoint)
                if cmp < 0 {
                        if n.left == nil {
                                return n, -1
                        }
                        n = n.left
                } else if 0 < cmp {
                        if n.right == nil {
                                return n, 1
                        }
                        n = n.right
                } else {
                        break
                }
        }
        return n, 0
}

func (s *SweepStatus) rebalance(n *SweepNode) {
        for {
                oheight := n.height
                if balance := n.balance(); balance == 2 {
                        // Tree is excessively right-heavy, rotate it to the left.
                        if n.right != nil && n.right.balance() < 0 {
                                // Right tree is left-heavy, which would cause the next rotation to result in
                                // overall left-heaviness. Rotate the right tree to the right to counteract this.
                                n.right = n.right.rotateRight()
                                n.right.right.updateHeight()
                        }
                        n = n.rotateLeft()
                        n.left.updateHeight()
                } else if balance == -2 {
                        // Tree is excessively left-heavy, rotate it to the right
                        if n.left != nil && 0 < n.left.balance() {
                                // The left tree is right-heavy, which would cause the next rotation to result in
                                // overall right-heaviness. Rotate the left tree to the left to compensate.
                                n.left = n.left.rotateLeft()
                                n.left.left.updateHeight()
                        }
                        n = n.rotateRight()
                        n.right.updateHeight()
                } else if balance < -2 || 2 < balance {
                        panic("Tree too far out of shape!")
                }

                n.updateHeight()
                if n.parent == nil {
                        s.root = n
                        return
                }
                if oheight == n.height {
                        return
                }
                n = n.parent
        }
}

func (s *SweepStatus) String() string {
        if s.root == nil {
                return "nil"
        }

        sb := strings.Builder{}
        s.root.Print(&sb)
        str := sb.String()
        if 0 < len(str) {
                str = str[:len(str)-1]
        }
        return str
}

func (s *SweepStatus) First() *SweepNode {
        if s.root == nil {
                return nil
        }
        n := s.root
        for n.left != nil {
                n = n.left
        }
        return n
}

func (s *SweepStatus) Last() *SweepNode {
        if s.root == nil {
                return nil
        }
        n := s.root
        for n.right != nil {
                n = n.right
        }
        return n
}

// Find returns the node equal to item. May return nil.
func (s *SweepStatus) Find(item *SweepPoint) *SweepNode {
        n, cmp := s.find(item)
        if cmp == 0 {
                return n
        }
        return nil
}

func (s *SweepStatus) FindPrevNext(item *SweepPoint) (*SweepNode, *SweepNode) {
        if s.root == nil {
                return nil, nil
        }

        n, cmp := s.find(item)
        if cmp < 0 {
                return n.Prev(), n
        } else if 0 < cmp {
                return n, n.Next()
        } else {
                return n.Prev(), n.Next()
        }
}

func (s *SweepStatus) Insert(item *SweepPoint) *SweepNode {
        if s.root == nil {
                s.root = s.newNode(item)
                return s.root
        }

        rebalance := false
        n, cmp := s.find(item)
        if cmp < 0 {
                // lower
                n.left = s.newNode(item)
                n.left.parent = n
                rebalance = n.right == nil
        } else if 0 < cmp {
                // higher
                n.right = s.newNode(item)
                n.right.parent = n
                rebalance = n.left == nil
        } else {
                // equal, replace
                n.SweepPoint.node = nil
                n.SweepPoint = item
                n.SweepPoint.node = n
                return n
        }

        if rebalance && n.parent != nil {
                n.height++
                s.rebalance(n.parent)
        }

        if cmp < 0 {
                return n.left
        } else {
                return n.right
        }
}

func (s *SweepStatus) InsertAfter(n *SweepNode, item *SweepPoint) *SweepNode {
        var cur *SweepNode
        rebalance := false
        if n == nil {
                if s.root == nil {
                        s.root = s.newNode(item)
                        return s.root
                }

                // insert as left-most node in tree
                n = s.root
                for n.left != nil {
                        n = n.left
                }
                n.left = s.newNode(item)
                n.left.parent = n
                rebalance = n.right == nil
                cur = n.left
        } else if n.right == nil {
                // insert directly to the right of n
                n.right = s.newNode(item)
                n.right.parent = n
                rebalance = n.left == nil
                cur = n.right
        } else {
                // insert next to n at a deeper level
                n = n.right
                for n.left != nil {
                        n = n.left
                }
                n.left = s.newNode(item)
                n.left.parent = n
                rebalance = n.right == nil
                cur = n.left
        }

        if rebalance && n.parent != nil {
                n.height++
                s.rebalance(n.parent)
        }
        return cur
}

func (s *SweepStatus) Remove(n *SweepNode) {
        ancestor := n.parent
        if n.left == nil || n.right == nil {
                // no children or one child
                child := n.left
                if n.left == nil {
                        child = n.right
                }
                if n.parent != nil {
                        n.parent.swapChild(n, child)
                } else {
                        s.root = child
                }
                if child != nil {
                        child.parent = n.parent
                }
        } else {
                // two children
                succ := n.right
                for succ.left != nil {
                        succ = succ.left
                }
                ancestor = succ.parent // rebalance from here
                if succ.parent == n {
                        // succ is child of n
                        ancestor = succ
                }
                succ.parent.swapChild(succ, succ.right)

                // swap succesor with deleted node
                succ.parent, succ.left, succ.right = n.parent, n.left, n.right
                if n.parent != nil {
                        n.parent.swapChild(n, succ)
                } else {
                        s.root = succ
                }
                if n.left != nil {
                        n.left.parent = succ
                }
                if n.right != nil {
                        n.right.parent = succ
                }
        }

        // rebalance all ancestors
        for ; ancestor != nil; ancestor = ancestor.parent {
                s.rebalance(ancestor)
        }
        s.returnNode(n)
        return
}

func (s *SweepStatus) Clear() {
        n := s.First()
        for n != nil {
                cur := n
                n = n.Next()
                s.returnNode(cur)
        }
        s.root = nil
}

func (a *SweepPoint) LessH(b *SweepPoint) bool {
        // used for sweep queue
        if a.X != b.X {
                return a.X < b.X // sort left to right
        } else if a.Y != b.Y {
                return a.Y < b.Y // then bottom to top
        } else if a.left != b.left {
                return b.left // handle right-endpoints before left-endpoints
        } else if a.compareTangentsV(b) < 0 {
                return true // sort upwards, this ensures CCW orientation order of result
        }
        return false
}

func (a *SweepPoint) CompareH(b *SweepPoint) int {
        // used for sweep queue
        // sort left-to-right, then bottom-to-top, then right-endpoints before left-endpoints, and then
        // sort upwards to ensure a CCW orientation of the result
        if a.X < b.X {
                return -1
        } else if b.X < a.X {
                return 1
        } else if a.Y < b.Y {
                return -1
        } else if b.Y < a.Y {
                return 1
        } else if !a.left && b.left {
                return -1
        } else if a.left && !b.left {
                return 1
        }
        return a.compareTangentsV(b)
}

func (a *SweepPoint) compareOverlapsV(b *SweepPoint) int {
        // compare segments vertically that overlap (ie. are the same)
        if a.clipping != b.clipping {
                // for equal segments, clipping path is virtually on top (or left if vertical) of subject
                if b.clipping {
                        return -1
                } else {
                        return 1
                }
        }

        // equal segment on same path, sort by segment index
        if a.segment != b.segment {
                if a.segment < b.segment {
                        return -1
                } else {
                        return 1
                }
        }
        return 0
}

func (a *SweepPoint) compareTangentsV(b *SweepPoint) int {
        // compare segments vertically at a.X, b.X <= a.X, and a and b coincide at (a.X,a.Y)
        // note that a.left==b.left, we may be comparing right-endpoints
        sign := 1
        if !a.left {
                sign = -1
        }
        if a.vertical {
                // a is vertical
                if b.vertical {
                        // a and b are vertical
                        if a.Y == b.Y {
                                return sign * a.compareOverlapsV(b)
                        } else if a.Y < b.Y {
                                return -1
                        } else {
                                return 1
                        }
                }
                return 1
        } else if b.vertical {
                // b is vertical
                return -1
        }

        if a.other.X == b.other.X && a.other.Y == b.other.Y {
                return sign * a.compareOverlapsV(b)
        } else if a.left && a.other.X < b.other.X || !a.left && b.other.X < a.other.X {
                by := b.InterpolateY(a.other.X) // b's y at a's other
                if a.other.Y == by {
                        return sign * a.compareOverlapsV(b)
                } else if a.other.Y < by {
                        return sign * -1
                } else {
                        return sign * 1
                }
        } else {
                ay := a.InterpolateY(b.other.X) // a's y at b's other
                if ay == b.other.Y {
                        return sign * a.compareOverlapsV(b)
                } else if ay < b.other.Y {
                        return sign * -1
                } else {
                        return sign * 1
                }
        }
}

func (a *SweepPoint) compareV(b *SweepPoint) int {
        // compare segments vertically at a.X and b.X < a.X
        // note that by may be infinite/large for fully/nearly vertical segments
        by := b.InterpolateY(a.X) // b's y at a's left
        if a.Y == by {
                return a.compareTangentsV(b)
        } else if a.Y < by {
                return -1
        } else {
                return 1
        }
}

func (a *SweepPoint) CompareV(b *SweepPoint) int {
        // used for sweep status, a is the point to be inserted / found
        if a.X == b.X {
                // left-point at same X
                if a.Y == b.Y {
                        // left-point the same
                        return a.compareTangentsV(b)
                } else if a.Y < b.Y {
                        return -1
                } else {
                        return 1
                }
        } else if a.X < b.X {
                // a starts to the left of b
                return -b.compareV(a)
        } else {
                // a starts to the right of b
                return a.compareV(b)
        }
}

//type SweepPointPair [2]*SweepPoint
//
//func (pair SweepPointPair) Swapped() SweepPointPair {
//        return SweepPointPair{pair[1], pair[0]}
//}

func addIntersections(zs []math32.Vector2, queue *SweepEvents, event *SweepPoint, prev, next *SweepNode) bool {
        // a and b are always left-endpoints and a is below b
        //pair := SweepPointPair{a, b}
        //if _, ok := handled[pair]; ok {
        //        return
        //} else if _, ok := handled[pair.Swapped()]; ok {
        //        return
        //}
        //handled[pair] = struct{}{}

        var a, b *SweepPoint
        if prev == nil {
                a, b = event, next.SweepPoint
        } else if next == nil {
                a, b = prev.SweepPoint, event
        } else {
                a, b = prev.SweepPoint, next.SweepPoint
        }

        // find all intersections between segment pair
        // this returns either no intersections, or one or more secant/tangent intersections,
        // or exactly two "same" intersections which occurs when the segments overlap.
        zs = intersectionLineLineBentleyOttmann(zs[:0], a.Vector2, a.other.Vector2, b.Vector2, b.other.Vector2)

        // no (valid) intersections
        if len(zs) == 0 {
                return false
        }

        // Non-vertical but downwards-sloped segments may become vertical upon intersection due to
        // floating-point rounding and limited precision. Only the first segment of b can ever become
        // vertical, never the first segment of a:
        // - a and b may be segments in status when processing a right-endpoint. The left-endpoints of
        //   both thus must be to the left of this right-endpoint (unless vertical) and can never
        //   become vertical in their first segment.
        // - a is the segment of the currently processed left-endpoint and b is in status and above it.
        //   a's left-endpoint is to the right of b's left-endpoint and is below b, thus:
        //   - a and b go upwards: a nor b may become vertical, no reversal
        //   - a goes downwards and b upwards: no intersection
        //   - a goes upwards and b downwards: only a may become vertical but no reversal
        //   - a and b go downwards: b may pass a's left-endpoint to its left (no intersection),
        //     through it (tangential intersection, no splitting), or to its right so that a never
        //     becomes vertical and thus no reversal
        // - b is the segment of the currently processed left-endpoint and a is in status and below it.
        //   a's left-endpoint is below or to the left of b's left-endpoint and a is below b, thus:
        //   - a and b go upwards: only a may become vertical, no reversal
        //   - a goes downwards and b upwards: no intersection
        //   - a goes upwards and b downwards: both may become vertical where only b must be reversed
        //   - a and b go downwards: if b passes through a's left-endpoint, it must become vertical and
        //     be reversed, or it passed to the right of a's left-endpoint and a nor b become vertical
        // Conclusion: either may become vertical, but only b ever needs reversal of direction. And
        // note that b is the currently processed left-endpoint and thus isn't in status.
        // Note: handle overlapping segments immediately by checking up and down status for segments
        // that compare equally with weak ordering (ie. overlapping).

        if !event.left {
                // intersection may be to the left (or below) the current event due to floating-point
                // precision which would interfere with the sequence in queue, this is a problem when
                // handling right-endpoints
                for i := range zs {
                        zold := zs[i]
                        z := &zs[i]
                        if z.X < event.X {
                                z.X = event.X
                        } else if z.X == event.X && z.Y < event.Y {
                                z.Y = event.Y
                        }

                        aMaxY := math32.Max(a.Y, a.other.Y)
                        bMaxY := math32.Max(b.Y, b.other.Y)
                        if a.other.X < z.X || b.other.X < z.X || aMaxY < z.Y || bMaxY < z.Y {
                                fmt.Println("WARNING: intersection moved outside of segment:", zold, "=>", z)
                        }
                }
        }

        // split segments a and b, but first find overlapping segments above and below and split them at the same point
        // this prevents a case that causes alternating intersections between overlapping segments and thus slowdown significantly
        //if a.node != nil {
        //        splitOverlappingAtIntersections(zs, queue, a, true)
        //}
        aChanged := splitAtIntersections(zs, queue, a, true)

        //if b.node != nil {
        //        splitOverlappingAtIntersections(zs, queue, b, false)
        //}
        bChanged := splitAtIntersections(zs, queue, b, false)
        return aChanged || bChanged
}

//func splitOverlappingAtIntersections(zs []Point, queue *SweepEvents, s *SweepPoint, isA bool) bool {
//        changed := false
//        for prev := s.node.Prev(); prev != nil; prev = prev.Prev() {
//                if prev.Point == s.Point && prev.other.Point == s.other.Point {
//                        splitAtIntersections(zs, queue, prev.SweepPoint, isA)
//                        changed = true
//                }
//        }
//        if !changed {
//                for next := s.node.Next(); next != nil; next = next.Next() {
//                        if next.Point == s.Point && next.other.Point == s.other.Point {
//                                splitAtIntersections(zs, queue, next.SweepPoint, isA)
//                                changed = true
//                        }
//                }
//        }
//        return changed
//}

func splitAtIntersections(zs []math32.Vector2, queue *SweepEvents, s *SweepPoint, isA bool) bool {
        changed := false
        for i := len(zs) - 1; 0 <= i; i-- {
                z := zs[i]
                if z == s.Vector2 || z == s.other.Vector2 {
                        // ignore tangent intersections at the endpoints
                        continue
                }

                // split segment at intersection
                right, left := s.SplitAt(z)

                // reverse direction if necessary
                if left.X == left.other.X {
                        // segment after the split is vertical
                        left.vertical, left.other.vertical = true, true
                        if left.other.Y < left.Y {
                                left.Reverse()
                        }
                } else if right.X == right.other.X {
                        // segment before the split is vertical
                        right.vertical, right.other.vertical = true, true
                        if right.Y < right.other.Y {
                                // reverse first segment
                                if isA {
                                        fmt.Println("WARNING: reversing first segment of A")
                                }
                                if right.other.node != nil {
                                        // panic("impossible: first segment became vertical and needs reversal, but was already in the sweep status")
                                        continue
                                }
                                right.Reverse()

                                // Note that we swap the content of the currently processed left-endpoint of b with
                                // the new left-endpoint vertically below. The queue may not be strictly ordered
                                // with other vertical segments at the new left-endpoint, but this isn't a problem
                                // since we sort the events in each square after the Bentley-Ottmann phase.

                                // update references from handled and queue by swapping their contents
                                first := right.other
                                *right, *first = *first, *right
                                first.other, right.other = right, first
                        }
                }

                // add to handled
                //handled[SweepPointPair{a, bLeft}] = struct{}{}
                //if aPrevLeft != a {
                //        // there is only one non-tangential intersection
                //        handled[SweepPointPair{aPrevLeft, bLeft}] = struct{}{}
                //}

                // add to queue
                queue.Push(right)
                queue.Push(left)
                changed = true
        }
        return changed
}

//func reorderStatus(queue *SweepEvents, event *SweepPoint, aOld, bOld *SweepNode) {
//        var aNew, bNew *SweepNode
//        var aMove, bMove int
//        if aOld != nil {
//                // a == prev is a node in status that needs to be reordered
//                aNew, aMove = aOld.fix()
//        }
//        if bOld != nil {
//                // b == next is a node in status that needs to be reordered
//                bNew, bMove = bOld.fix()
//        }
//
//        // find new intersections after snapping and moving around, first between the (new) neighbours
//        // of a and b, and then check if any other segment became adjacent due to moving around a or b,
//        // while avoiding superfluous checking for intersections (the aMove/bMove conditions)
//        if aNew != nil {
//                if prev := aNew.Prev(); prev != nil && aMove != bMove+1 {
//                        // b is not a's previous
//                        addIntersections(queue, event, prev, aNew)
//                }
//                if next := aNew.Next(); next != nil && aMove != bMove-1 {
//                        // b is not a's next
//                        addIntersections(queue, event, aNew, next)
//                }
//        }
//        if bNew != nil {
//                if prev := bNew.Prev(); prev != nil && bMove != aMove+1 {
//                        // a is not b's previous
//                        addIntersections(queue, event, prev, bNew)
//                }
//                if next := bNew.Next(); next != nil && bMove != aMove-1 {
//                        // a is not b's next
//                        addIntersections(queue, event, bNew, next)
//                }
//        }
//        if aOld != nil && aMove != 0 && bMove != -1 {
//                // a's old position is not aNew or bNew
//                if prev := aOld.Prev(); prev != nil && aMove != -1 && bMove != -2 {
//                        // a nor b are not old a's previous
//                        addIntersections(queue, event, prev, aOld)
//                }
//                if next := aOld.Next(); next != nil && aMove != 1 && bMove != 0 {
//                        // a nor b are not old a's next
//                        addIntersections(queue, event, aOld, next)
//                }
//        }
//        if bOld != nil && aMove != 1 && bMove != 0 {
//                // b's old position is not aNew or bNew
//                if aOld == nil {
//                        if prev := bOld.Prev(); prev != nil && aMove != 0 && bMove != -1 {
//                                // a nor b are not old b's previous
//                                addIntersections(queue, event, prev, bOld)
//                        }
//                }
//                if next := bOld.Next(); next != nil && aMove != 2 && bMove != 1 {
//                        // a nor b are not old b's next
//                        addIntersections(queue, event, bOld, next)
//                }
//        }
//}

type toleranceSquare struct {
        X, Y   float32       // snapped value
        Events []*SweepPoint // all events in this square

        // reference node inside or near the square
        // after breaking up segments, this is the previous node (ie. completely below the square)
        Node *SweepNode

        // lower and upper node crossing this square
        Lower, Upper *SweepNode
}

type toleranceSquares []*toleranceSquare

func (squares *toleranceSquares) find(x, y float32) (int, bool) {
        // find returns the index of the square at or above (x,y) (or len(squares) if above all)
        // the bool indicates if the square exists, otherwise insert a new square at that index
        for i := len(*squares) - 1; 0 <= i; i-- {
                if (*squares)[i].X < x || (*squares)[i].Y < y {
                        return i + 1, false
                } else if (*squares)[i].Y == y {
                        return i, true
                }
        }
        return 0, false
}

func (squares *toleranceSquares) Add(x float32, event *SweepPoint, refNode *SweepNode) {
        // refNode is always the node itself for left-endpoints, and otherwise the previous node (ie.
        // the node below) of a right-endpoint, or the next (ie. above) node if the previous is nil.
        // It may be inside or outside the right edge of the square. If outside, it is the first such
        // segment going upwards/downwards from the square (and not just any segment).
        y := snap(event.Y, BentleyOttmannEpsilon)
        if idx, ok := squares.find(x, y); !ok {
                // create new tolerance square
                square := boSquarePool.Get().(*toleranceSquare)
                *square = toleranceSquare{
                        X:      x,
                        Y:      y,
                        Events: []*SweepPoint{event},
                        Node:   refNode,
                }
                *squares = append((*squares)[:idx], append(toleranceSquares{square}, (*squares)[idx:]...)...)
        } else {
                // insert into existing tolerance square
                (*squares)[idx].Node = refNode
                (*squares)[idx].Events = append((*squares)[idx].Events, event)
        }

        // (nearly) vertical segments may still be used as the reference segment for squares around
        // in that case, replace with the new reference node (above or below that segment)
        if !event.left {
                orig := event.other.node
                for i := len(*squares) - 1; 0 <= i && (*squares)[i].X == x; i-- {
                        if (*squares)[i].Node == orig {
                                (*squares)[i].Node = refNode
                        }
                }
        }
}

//func (event *SweepPoint) insertIntoSortedH(events *[]*SweepPoint) {
//        // O(log n)
//        lo, hi := 0, len(*events)
//        for lo < hi {
//                mid := (lo + hi) / 2
//                if (*events)[mid].LessH(event, false) {
//                        lo = mid + 1
//                } else {
//                        hi = mid
//                }
//        }
//
//        sorted := sort.IsSorted(eventSliceH(*events))
//        if !sorted {
//                fmt.Println("WARNING: H not sorted")
//                for i, event := range *events {
//                        fmt.Println(i, event, event.Angle())
//                }
//        }
//        *events = append(*events, nil)
//        copy((*events)[lo+1:], (*events)[lo:])
//        (*events)[lo] = event
//        if sorted && !sort.IsSorted(eventSliceH(*events)) {
//                fmt.Println("ERROR: not sorted after inserting into events:", *events)
//        }
//}

func (event *SweepPoint) breakupSegment(events *[]*SweepPoint, index int, x, y float32) *SweepPoint {
        // break up a segment in two parts and let the middle point be (x,y)
        if snap(event.X, BentleyOttmannEpsilon) == x && snap(event.Y, BentleyOttmannEpsilon) == y || snap(event.other.X, BentleyOttmannEpsilon) == x && snap(event.other.Y, BentleyOttmannEpsilon) == y {
                // segment starts or ends in tolerance square, don't break up
                return event
        }

        // original segment should be kept in-place to not alter the queue or status
        r, l := event.SplitAt(math32.Vector2{x, y})
        r.index, l.index = index, index

        // reverse
        //if r.other.X == r.X {
        //        if l.other.Y < r.other.Y {
        //                r.Reverse()
        //        }
        //        r.vertical, r.other.vertical = true, true
        //} else if l.other.X == l.X {
        //        if l.other.Y < r.other.Y {
        //                l.Reverse()
        //        }
        //        l.vertical, l.other.vertical = true, true
        //}

        // update node reference
        if event.node != nil {
                l.node, event.node = event.node, nil
                l.node.SweepPoint = l
        }

        *events = append(*events, r, l)
        return l
}

func (squares toleranceSquares) breakupCrossingSegments(n int, x float32) {
        // find and break up all segments that cross this tolerance square
        // note that we must move up to find all upwards-sloped segments and then move down for the
        // downwards-sloped segments, since they may need to be broken up in other squares first
        x0, x1 := x-BentleyOttmannEpsilon/2.0, x+BentleyOttmannEpsilon/2.0

        // scan squares bottom to top
        for i := n; i < len(squares); i++ {
                square := squares[i] // pointer

                // be aware that a tolerance square is inclusive of the left and bottom edge
                // and only the bottom-left corner
                yTop, yBottom := square.Y+BentleyOttmannEpsilon/2.0, square.Y-BentleyOttmannEpsilon/2.0

                // from reference node find the previous/lower/upper segments for this square
                // the reference node may be any of the segments that cross the right-edge of the square,
                // or a segment below or above the right-edge of the square
                if square.Node != nil {
                        y0, y1 := square.Node.ToleranceEdgeY(x0, x1)
                        below, above := y0 < yBottom && y1 <= yBottom, yTop <= y0 && yTop <= y1
                        if !below && !above {
                                // reference node is inside the square
                                square.Lower, square.Upper = square.Node, square.Node
                        }

                        // find upper node
                        if !above {
                                for next := square.Node.Next(); next != nil; next = next.Next() {
                                        y0, y1 := next.ToleranceEdgeY(x0, x1)
                                        if yTop <= y0 && yTop <= y1 {
                                                // above
                                                break
                                        } else if y0 < yBottom && y1 <= yBottom {
                                                // below
                                                square.Node = next
                                                continue
                                        }
                                        square.Upper = next
                                        if square.Lower == nil {
                                                // this is set if the reference node is below the square
                                                square.Lower = next
                                        }
                                }
                        }

                        // find lower node and set reference node to the node completely below the square
                        if !below {
                                prev := square.Node.Prev()
                                for ; prev != nil; prev = prev.Prev() {
                                        y0, y1 := prev.ToleranceEdgeY(x0, x1)
                                        if y0 < yBottom && y1 <= yBottom { // exclusive for bottom-right corner
                                                // below
                                                break
                                        } else if yTop <= y0 && yTop <= y1 {
                                                // above
                                                square.Node = prev
                                                continue
                                        }
                                        square.Lower = prev
                                        if square.Upper == nil {
                                                // this is set if the reference node is above the square
                                                square.Upper = prev
                                        }
                                }
                                square.Node = prev
                        }
                }

                // find all segments that cross the tolerance square
                // first find all segments that extend to the right (they are in the sweepline status)
                if square.Lower != nil {
                        for node := square.Lower; ; node = node.Next() {
                                node.breakupSegment(&squares[i].Events, i, x, square.Y)
                                if node == square.Upper {
                                        break
                                }
                        }
                }

                // then find which segments that end in this square go through other squares
                for _, event := range square.Events {
                        if !event.left {
                                y0, _ := event.ToleranceEdgeY(x0, x1)
                                s := event.other
                                if y0 < yBottom {
                                        // comes from below, find lowest square and breakup in each square
                                        j0 := i
                                        for j := i - 1; 0 <= j; j-- {
                                                if squares[j].X != x || squares[j].Y+BentleyOttmannEpsilon/2.0 <= y0 {
                                                        break
                                                }
                                                j0 = j
                                        }
                                        for j := j0; j < i; j++ {
                                                s = s.breakupSegment(&squares[j].Events, j, x, squares[j].Y)
                                        }
                                } else if yTop <= y0 {
                                        // comes from above, find highest square and breakup in each square
                                        j0 := i
                                        for j := i + 1; j < len(squares); j++ {
                                                if y0 < squares[j].Y-BentleyOttmannEpsilon/2.0 {
                                                        break
                                                }
                                                j0 = j
                                        }
                                        for j := j0; i < j; j-- {
                                                s = s.breakupSegment(&squares[j].Events, j, x, squares[j].Y)
                                        }
                                }
                        }
                }
        }
}

type eventSliceV []*SweepPoint

func (a eventSliceV) Len() int {
        return len(a)
}

func (a eventSliceV) Less(i, j int) bool {
        return a[i].CompareV(a[j]) < 0
}

func (a eventSliceV) Swap(i, j int) {
        a[i].node.SweepPoint, a[j].node.SweepPoint = a[j], a[i]
        a[i].node, a[j].node = a[j].node, a[i].node
        a[i], a[j] = a[j], a[i]
}

type eventSliceH []*SweepPoint

func (a eventSliceH) Len() int {
        return len(a)
}

func (a eventSliceH) Less(i, j int) bool {
        return a[i].LessH(a[j])
}

func (a eventSliceH) Swap(i, j int) {
        a[i], a[j] = a[j], a[i]
}

func (cur *SweepPoint) computeSweepFields(prev *SweepPoint, op pathOp, fillRule ppath.FillRules) {
        // cur is left-endpoint
        if !cur.open {
                cur.selfWindings = 1
                if !cur.increasing {
                        cur.selfWindings = -1
                }
        }

        // skip vertical segments
        cur.prev = prev
        for prev != nil && prev.vertical {
                prev = prev.prev
        }

        // compute windings
        if prev != nil {
                if cur.clipping == prev.clipping {
                        cur.windings = prev.windings + prev.selfWindings
                        cur.otherWindings = prev.otherWindings + prev.otherSelfWindings
                } else {
                        cur.windings = prev.otherWindings + prev.otherSelfWindings
                        cur.otherWindings = prev.windings + prev.selfWindings
                }
        } else {
                // may have been copied when intersected / broken up
                cur.windings, cur.otherWindings = 0, 0
        }

        cur.inResult = cur.InResult(op, fillRule)
        cur.other.inResult = cur.inResult
}

func (s *SweepPoint) InResult(op pathOp, fillRule ppath.FillRules) uint8 {
        lowerWindings, lowerOtherWindings := s.windings, s.otherWindings
        upperWindings, upperOtherWindings := s.windings+s.selfWindings, s.otherWindings+s.otherSelfWindings
        if s.clipping {
                lowerWindings, lowerOtherWindings = lowerOtherWindings, lowerWindings
                upperWindings, upperOtherWindings = upperOtherWindings, upperWindings
        }

        if s.open {
                // handle open paths on the subject
                switch op {
                case opSettle, opOR, opDIV:
                        return 1
                case opAND:
                        if fillRule.Fills(lowerOtherWindings) || fillRule.Fills(upperOtherWindings) {
                                return 1
                        }
                case opNOT, opXOR:
                        if !fillRule.Fills(lowerOtherWindings) || !fillRule.Fills(upperOtherWindings) {
                                return 1
                        }
                }
                return 0
        }

        // lower/upper windings refers to subject path, otherWindings to clipping path
        var belowFills, aboveFills bool
        switch op {
        case opSettle:
                belowFills = fillRule.Fills(lowerWindings)
                aboveFills = fillRule.Fills(upperWindings)
        case opAND:
                belowFills = fillRule.Fills(lowerWindings) && fillRule.Fills(lowerOtherWindings)
                aboveFills = fillRule.Fills(upperWindings) && fillRule.Fills(upperOtherWindings)
        case opOR:
                belowFills = fillRule.Fills(lowerWindings) || fillRule.Fills(lowerOtherWindings)
                aboveFills = fillRule.Fills(upperWindings) || fillRule.Fills(upperOtherWindings)
        case opNOT:
                belowFills = fillRule.Fills(lowerWindings) && !fillRule.Fills(lowerOtherWindings)
                aboveFills = fillRule.Fills(upperWindings) && !fillRule.Fills(upperOtherWindings)
        case opXOR:
                belowFills = fillRule.Fills(lowerWindings) != fillRule.Fills(lowerOtherWindings)
                aboveFills = fillRule.Fills(upperWindings) != fillRule.Fills(upperOtherWindings)
        case opDIV:
                belowFills = fillRule.Fills(lowerWindings)
                aboveFills = fillRule.Fills(upperWindings)
                if belowFills && aboveFills {
                        return 2
                } else if belowFills || aboveFills {
                        return 1
                }
                return 0
        }

        // only keep edge if there is a change in filling between both sides
        if belowFills != aboveFills {
                return 1
        }
        return 0
}

func (s *SweepPoint) mergeOverlapping(op pathOp, fillRule ppath.FillRules) {
        // When merging overlapping segments, the order of the right-endpoints may have changed and
        // thus be different from the order used to compute the sweep fields, here we reset the values
        // for windings and otherWindings to be taken from the segment below (prev) which was updated
        // after snapping the endpoints.
        // We use event.overlapped to handle segments once and count windings once, in whichever order
        // the events are handled. We also update prev to reflect the segment below the overlapping
        // segments.
        if s.overlapped {
                // already handled
                return
        }
        prev := s.prev
        for ; prev != nil; prev = prev.prev {
                if prev.overlapped || s.Vector2 != prev.Vector2 || s.other.Vector2 != prev.other.Vector2 {
                        break
                }

                // combine selfWindings
                if s.clipping == prev.clipping {
                        s.selfWindings += prev.selfWindings
                        s.otherSelfWindings += prev.otherSelfWindings
                } else {
                        s.selfWindings += prev.otherSelfWindings
                        s.otherSelfWindings += prev.selfWindings
                }
                prev.windings, prev.selfWindings, prev.otherWindings, prev.otherSelfWindings = 0, 0, 0, 0
                prev.inResult, prev.other.inResult = 0, 0
                prev.overlapped = true
        }
        if prev == s.prev {
                return
        }

        // compute merged windings
        if prev == nil {
                s.windings, s.otherWindings = 0, 0
        } else if s.clipping == prev.clipping {
                s.windings = prev.windings + prev.selfWindings
                s.otherWindings = prev.otherWindings + prev.otherSelfWindings
        } else {
                s.windings = prev.otherWindings + prev.otherSelfWindings
                s.otherWindings = prev.windings + prev.selfWindings
        }
        s.inResult = s.InResult(op, fillRule)
        s.other.inResult = s.inResult
        s.prev = prev
}

func bentleyOttmann(ps, qs ppath.Paths, op pathOp, fillRule ppath.FillRules) ppath.Path {
        // TODO: make public and add grid spacing argument
        // TODO: support OpDIV, keeping only subject, or both subject and clipping subpaths
        // TODO: add Intersects/Touches functions (return bool)
        // TODO: add Intersections function (return []Point)
        // TODO: support Cut to cut a path in subpaths between intersections (not polygons)
        // TODO: support elliptical arcs
        // TODO: use a red-black tree for the sweepline status?
        // TODO: use a red-black or 2-4 tree for the sweepline queue (LessH is 33% of time spent now),
        //       perhaps a red-black tree where the nodes are min-queues of the resulting squares
        // TODO: optimize path data by removing commands, set number of same command (50% less memory)
        // TODO: can we get idempotency (same result after second time) by tracing back each snapped
        //       right-endpoint for the squares it may now intersect? (Hershberger 2013)

        // Implementation of the Bentley-Ottmann algorithm by reducing the complexity of finding
        // intersections to O((n + k) log n), with n the number of segments and k the number of
        // intersections. All special cases are handled by use of:
        // - M. de Berg, et al., "Computational Geometry", Chapter 2, DOI: 10.1007/978-3-540-77974-2
        // - F. Martínez, et al., "A simple algorithm for Boolean operations on polygons", Advances in
        //   Engineering Software 64, p. 11-19, 2013, DOI: 10.1016/j.advengsoft.2013.04.004
        // - J. Hobby, "Practical segment intersection with finite precision output", Computational
        //   Geometry, 1997
        // - J. Hershberger, "Stable snap rounding", Computational Geometry: Theory and Applications,
        //   2013, DOI: 10.1016/j.comgeo.2012.02.011
        // - https://github.com/verven/contourklip

        // Bentley-Ottmann is the most popular algorithm to find path intersections, which is mainly
        // due to it's relative simplicity and the fact that it is (much) faster than the naive
        // approach. It however does not specify how special cases should be handled (overlapping
        // segments, multiple segment endpoints in one point, vertical segments), which is treated in
        // later works by other authors (e.g. Martínez from which this implementation draws
        // inspiration). I've made some small additions and adjustments to make it work in all cases
        // I encountered. Specifically, this implementation has the following properties:
        // - Subject and clipping paths may consist of any number of contours / subpaths.
        // - Any contour may be oriented clockwise (CW) or counter-clockwise (CCW).
        // - Any path or contour may self-intersect any number of times.
        // - Any point may be crossed multiple times by any path.
        // - Segments may overlap any number of times by any path.
        // - Segments may be vertical.
        // - The clipping path is implicitly closed, it makes no sense if it is an open path.
        // - The subject path is currently implicitly closed, but it is WIP to support open paths.
        // - ppath.Paths are currently flattened, but supporting Bézier or elliptical arcs is a WIP.

        // An unaddressed problem in those works is that of numerical accuracies. The main problem is
        // that calculating the intersections is not precise; the imprecision of the initial endpoints
        // of a path can be trivially fixed before the algorithm. Intersections however are calculated
        // during the algorithm and must be addressed. There are a few authors that propose a solution,
        // and Hobby's work inspired this implementation. The approach taken is somewhat different
        // though:
        // - Instead of integers (or rational numbers implemented using integers), floating points are
        //   used for their speed. It isn't even necessary that the grid points can be represented
        //   exactly in the floating point format, as long as all points in the tolerance square around
        //   the grid points snap to the same point. Now we can compare using == instead of an equality
        //   test.
        // - As in Martínez, we treat an intersection as a right- and left-endpoint combination and not
        //   as a third type of event. This avoids rearrangement of events in the sweep status as it is
        //   removed and reinserted into the right position, but at the cost of more delete/insert
        //   operations in the sweep status (potential to improve performance).
        // - As we run the Bentley-Ottmann algorithm, found endpoints must also be snapped to the grid.
        //   Since intersections are found in advance (ie. towards the right), we have no idea how the
        //   sweepline status will be yet, so we cannot snap those intersections to the grid yet. We
        //   must snap all endpoints/intersections when we reach them (ie. pop them off the queue).
        //   When we get to an endpoint, snap all endpoints in the tolerance square around the grid
        //   point to that point, and process all endpoints and intersections. Additionally, we should
        //   break-up all segments that pass through the square into two, and snap them to the grid
        //   point as well. These segments pass very close to another endpoint, and by snapping those
        //   to the grid we avoid the problem where we may or may not find that the segment intersects.
        // - Note that most (not all) intersections on the right are calculated with the left-endpoint
        //   already snapped, which may move the intersection to another grid point. These inaccuracies
        //   depend on the grid spacing and can be made small relative to the size of the input paths.
        //
        // The difference with Hobby's steps is that we advance Bentley-Ottmann for the entire column,
        // and only then do we calculate crossing segments. I'm not sure what reason Hobby has to do
        // this in two fases. Also, Hobby uses a shadow sweep line status structure which contains the
        // segments sorted after snapping. Instead of using two sweep status structures (the original
        // Bentley-Ottmann and the shadow with snapped segments), we sort the status after each column.
        // Additionally, we need to keep the sweep line queue structure ordered as well for the result
        // polygon (instead of the queue we gather the events for each sqaure, and sort those), and we
        // need to calculate the sweep fields for the result polygon.
        //
        // It is best to think of processing the tolerance squares, one at a time moving bottom-to-top,
        // for each column while moving the sweepline from left to right. Since all intersections
        // in this implementation are already converted to two right-endpoints and two left-endpoints,
        // we do all the snapping after each column and snapping the endpoints beforehand is not
        // necessary. We pop off all events from the queue that belong to the same column and process
        // them as we would with Bentley-Ottmann. This ensures that we find all original locations of
        // the intersections (except for intersections between segments in the sweep status structure
        // that are not yet adjacent, see note above) and may introduce new tolerance squares. For each
        // square, we find all segments that pass through and break them up and snap them to the grid.
        // Then snap all endpoints in the
        // square to the grid. We must sort the sweep line status and all events per square to account
        // for the new order after snapping. Some implementation observations:
        // - We must breakup segments that cross the square BEFORE we snap the square's endpoints,
        //   since we depend on the order of in the sweep status (from after processing the column
        //   using the original Bentley-Ottmann sweep line) for finding crossing segments.
        // - We find all original locations of intersections for adjacent segments during and after
        //   processing the column. However, if intersections become adjacent later on, the
        //   left-endpoint has already been snapped and the intersection has moved.
        // - We must be careful with overlapping segments. Since gridsnapping may introduce new
        //   overlapping segments (potentially vertical), we must check for that when processing the
        //   right-endpoints of each square.
        //
        // We thus proceed as follows:
        // - Process all events from left-to-right in a column using the regular Bentley-Ottmann.
        // - Identify all "hot" squares (those that contain endpoints / intersections).
        // - Find all segments that pass through each hot square, break them up and snap to the grid.
        //   These may be segments that start left of the column and end right of it, but also segments
        //   that start or end inside the column, or even start AND end inside the column (eg. vertical
        //   or almost vertical segments).
        // - Snap all endpoints and intersections to the grid.
        // - Compute sweep fields / windings for all new left-endpoints.
        // - Handle segments that are now overlapping for all right-endpoints.
        // Note that we must be careful with vertical segments.

        boInitPoolsOnce() // use pools for SweepPoint and SweepNode to amortize repeated calls to BO

        // return in case of one path is empty
        if op == opSettle {
                qs = nil
        } else if qs.Empty() {
                if op == opAND {
                        return ppath.Path{}
                }
                return SettlePaths(ps, fillRule)
        }
        if ps.Empty() {
                if qs != nil && (op == opOR || op == opXOR) {
                        return SettlePaths(qs, fillRule)
                }
                return ppath.Path{}
        }

        // ensure that X-monotone property holds for Béziers and arcs by breaking them up at their
        // extremes along X (ie. their inflection points along X)
        // TODO: handle Béziers and arc segments
        //p = p.XMonotone()
        //q = q.XMonotone()
        for i, iMax := 0, len(ps); i < iMax; i++ {
                split := ps[i].Split()
                if 1 < len(split) {
                        ps[i] = split[0]
                        ps = append(ps, split[1:]...)
                }
        }
        for i := range ps {
                ps[i] = Flatten(ps[i], ppath.Tolerance)
        }
        if qs != nil {
                for i, iMax := 0, len(qs); i < iMax; i++ {
                        split := qs[i].Split()
                        if 1 < len(split) {
                                qs[i] = split[0]
                                qs = append(qs, split[1:]...)
                        }
                }
                for i := range qs {
                        qs[i] = Flatten(qs[i], ppath.Tolerance)
                }
        }

        // check for path bounding boxes to overlap
        // TODO: cluster paths that overlap and treat non-overlapping clusters separately, this
        // makes the algorithm "more linear"
        R := ppath.Path{}
        var pOverlaps, qOverlaps []bool
        if qs != nil {
                pBounds := make([]math32.Box2, len(ps))
                qBounds := make([]math32.Box2, len(qs))
                for i := range ps {
                        pBounds[i] = ps[i].FastBounds()
                }
                for i := range qs {
                        qBounds[i] = qs[i].FastBounds()
                }
                pOverlaps = make([]bool, len(ps))
                qOverlaps = make([]bool, len(qs))
                for i := range ps {
                        for j := range qs {
                                if touches(pBounds[i], qBounds[j]) {
                                        pOverlaps[i] = true
                                        qOverlaps[j] = true
                                }
                        }
                        if !pOverlaps[i] && (op == opOR || op == opXOR || op == opNOT) {
                                // path bounding boxes do not overlap, thus no intersections
                                R = R.Append(Settle(ps[i], fillRule))
                        }
                }
                for j := range qs {
                        if !qOverlaps[j] && (op == opOR || op == opXOR) {
                                // path bounding boxes do not overlap, thus no intersections
                                R = R.Append(Settle(qs[j], fillRule))
                        }
                }
        }

        // construct the priority queue of sweep events
        pSeg, qSeg := 0, 0
        queue := &SweepEvents{}
        for i := range ps {
                if qs == nil || pOverlaps[i] {
                        pSeg = queue.AddPathEndpoints(ps[i], pSeg, false)
                }
        }
        if qs != nil {
                for i := range qs {
                        if qOverlaps[i] {
                                // implicitly close all subpaths on Q
                                if !qs[i].Closed() {
                                        qs[i].Close()
                                }
                                qSeg = queue.AddPathEndpoints(qs[i], qSeg, true)
                        }
                }
        }
        queue.Init() // sort from left to right

        // run sweep line left-to-right
        zs := make([]math32.Vector2, 0, 2) // buffer for intersections
        centre := &SweepPoint{}            // allocate here to reduce allocations
        events := []*SweepPoint{}          // buffer used for ordering status
        status := &SweepStatus{}           // contains only left events
        squares := toleranceSquares{}      // sorted vertically, squares and their events
        // TODO: use linked list for toleranceSquares?
        for 0 < len(*queue) {
                // TODO: skip or stop depending on operation if we're to the left/right of subject/clipping polygon

                // We slightly divert from the original Bentley-Ottmann and paper implementation. First
                // we find the top element in queue but do not pop it off yet. If it is a right-event, pop
                // from queue and proceed as usual, but if it's a left-event we first check (and add) all
                // surrounding intersections to the queue. This may change the order from which we should
                // pop off the queue, since intersections may create right-events, or new left-events that
                // are lower (by compareTangentV). If no intersections are found, pop off the queue and
                // proceed as usual.

                // Pass 1
                // process all events of the current column
                n := len(squares)
                x := snap(queue.Top().X, BentleyOttmannEpsilon)
        BentleyOttmannLoop:
                for 0 < len(*queue) && snap(queue.Top().X, BentleyOttmannEpsilon) == x {
                        event := queue.Top()
                        // TODO: breaking intersections into two right and two left endpoints is not the most
                        // efficient. We could keep an intersection-type event and simply swap the order of the
                        // segments in status (note there can be multiple segments crossing in one point). This
                        // would alleviate a 2*m*log(n) search in status to remove/add the segments (m number
                        // of intersections in one point, and n number of segments in status), and instead use
                        // an m/2 number of swap operations. This alleviates pressure on the CompareV method.
                        if !event.left {
                                queue.Pop()

                                n := event.other.node
                                if n == nil {
                                        // panic("right-endpoint not part of status, probably buggy intersection code")
                                        // don't put back in boPointPool, rare event
                                        continue
                                } else if n.SweepPoint == nil {
                                        // this may happen if the left-endpoint is to the right of the right-endpoint
                                        // for some reason, usually due to a bug in the segment intersection code
                                        // panic("other endpoint already removed, probably buggy intersection code")
                                        // don't put back in boPointPool, rare event
                                        continue
                                }

                                // find intersections between the now adjacent segments
                                prev := n.Prev()
                                next := n.Next()
                                if prev != nil && next != nil {
                                        addIntersections(zs, queue, event, prev, next)
                                }

                                // add event to tolerance square
                                if prev != nil {
                                        squares.Add(x, event, prev)
                                } else {
                                        // next can be nil
                                        squares.Add(x, event, next)
                                }

                                // remove event from sweep status
                                status.Remove(n)
                        } else {
                                // add intersections to queue
                                prev, next := status.FindPrevNext(event)
                                if prev != nil {
                                        addIntersections(zs, queue, event, prev, nil)
                                }
                                if next != nil {
                                        addIntersections(zs, queue, event, nil, next)
                                }
                                if queue.Top() != event {
                                        // check if the queue order was changed, this happens if the current event
                                        // is the left-endpoint of a segment that intersects with an existing segment
                                        // that goes below, or when two segments become fully overlapping, which sets
                                        // their order in status differently than when one of them extends further
                                        continue
                                }
                                queue.Pop()

                                // add event to sweep status
                                n := status.InsertAfter(prev, event)

                                // add event to tolerance square
                                squares.Add(x, event, n)
                        }
                }

                // Pass 2
                // find all crossing segments, break them up and snap to the grid
                squares.breakupCrossingSegments(n, x)

                // snap events to grid
                // note that this may make segments overlapping from the left and towards the right
                // we handle the former below, but ignore the latter which may result in overlapping
                // segments not being strictly ordered
                for j := n; j < len(squares); j++ {
                        del := 0
                        square := squares[j] // pointer
                        for i := 0; i < len(square.Events); i++ {
                                event := square.Events[i]
                                event.index = j
                                event.X, event.Y = x, square.Y

                                other := Gridsnap(event.other.Vector2, BentleyOttmannEpsilon)
                                if event.Vector2 == other {
                                        // remove collapsed segments, we aggregate them with `del` to improve performance when we have many
                                        // TODO: prevent creating these segments in the first place
                                        del++
                                } else {
                                        if 0 < del {
                                                for _, event := range square.Events[i-del : i] {
                                                        if !event.left {
                                                                boPointPool.Put(event.other)
                                                                boPointPool.Put(event)
                                                        }
                                                }
                                                square.Events = append(square.Events[:i-del], square.Events[i:]...)
                                                i -= del
                                                del = 0
                                        }
                                        if event.X == other.X {
                                                // correct for segments that have become vertical due to snap/breakup
                                                event.vertical, event.other.vertical = true, true
                                                if !event.left && event.Y < other.Y {
                                                        // downward sloped, reverse direction
                                                        event.Reverse()
                                                }
                                        }
                                }
                        }
                        if 0 < del {
                                for _, event := range square.Events[len(square.Events)-del:] {
                                        if !event.left {
                                                boPointPool.Put(event.other)
                                                boPointPool.Put(event)
                                        }
                                }
                                square.Events = square.Events[:len(square.Events)-del]
                        }
                }

                for _, square := range squares[n:] {
                        // reorder sweep status and events for result polygon
                        // note that the number of events/nodes is usually small
                        // and note that we must first snap all segments in this column before sorting
                        if square.Lower != nil {
                                events = events[:0]
                                for n := square.Lower; ; n = n.Next() {
                                        events = append(events, n.SweepPoint)
                                        if n == square.Upper {
                                                break
                                        }
                                }

                                // TODO: test this thoroughly, this below prevents long loops of moving intersections to columns on the right
                                for n := square.Lower; n != square.Upper; {
                                        next := n.Next()
                                        if 0 < n.CompareV(next.SweepPoint) {
                                                if next.other.X < n.other.X {
                                                        r, l := n.SplitAt(next.other.Vector2)
                                                        queue.Push(r)
                                                        queue.Push(l)
                                                } else if n.other.X < next.other.X {
                                                        r, l := next.SplitAt(n.other.Vector2)
                                                        queue.Push(r)
                                                        queue.Push(l)
                                                }
                                        }
                                        n = next
                                }

                                // keep unsorted events in the same slice
                                n := len(events)
                                events = append(events, events...)
                                origEvents := events[n:]
                                events = events[:n]

                                sort.Sort(eventSliceV(events))

                                // find intersections between neighbouring segments due to snapping
                                // TODO: ugly!
                                has := false
                                centre.Vector2 = math32.Vector2{square.X, square.Y}
                                if prev := square.Lower.Prev(); prev != nil {
                                        has = addIntersections(zs, queue, centre, prev, square.Lower)
                                }
                                if next := square.Upper.Next(); next != nil {
                                        has = has || addIntersections(zs, queue, centre, square.Upper, next)
                                }

                                // find intersections between new neighbours in status after sorting
                                for i, event := range events[:len(events)-1] {
                                        if event != origEvents[i] {
                                                n := event.node
                                                var j int
                                                for origEvents[j] != event {
                                                        j++
                                                }

                                                if next := n.Next(); next != nil && (j == 0 || next.SweepPoint != origEvents[j-1]) && (j+1 == len(origEvents) || next.SweepPoint != origEvents[j+1]) {
                                                        // segment changed order and the segment above was not its neighbour
                                                        has = has || addIntersections(zs, queue, centre, n, next)
                                                }
                                        }
                                }

                                if 0 < len(*queue) && snap(queue.Top().X, BentleyOttmannEpsilon) == x {
                                        //fmt.Println("WARNING: new intersections in this column!")
                                        goto BentleyOttmannLoop // TODO: is this correct? seems to work
                                        // TODO: almost parallel combined with overlapping segments may create many intersections considering order of
                                        //       of overlapping segments and snapping after each column
                                } else if has {
                                        // sort overlapping segments again
                                        // this is needed when segments get cut and now become equal to the adjacent
                                        // overlapping segments
                                        // TODO: segments should be sorted by segment ID when overlapping, even if
                                        //       one segment extends further than the other, is that due to floating
                                        //       point accuracy?
                                        sort.Sort(eventSliceV(events))
                                }
                        }

                        slices.SortFunc(square.Events, (*SweepPoint).CompareH)

                        // compute sweep fields on left-endpoints
                        for i, event := range square.Events {
                                if !event.left {
                                        event.other.mergeOverlapping(op, fillRule)
                                } else if event.node == nil {
                                        // vertical
                                        if 0 < i && square.Events[i-1].left {
                                                // against last left-endpoint in square
                                                // inside this square there are no crossing segments, they have been broken
                                                // up and have their left-endpoints sorted
                                                event.computeSweepFields(square.Events[i-1], op, fillRule)
                                        } else {
                                                // against first segment below square
                                                // square.Node may be nil
                                                var s *SweepPoint
                                                if square.Node != nil {
                                                        s = square.Node.SweepPoint
                                                }
                                                event.computeSweepFields(s, op, fillRule)
                                        }
                                } else {
                                        var s *SweepPoint
                                        if event.node.Prev() != nil {
                                                s = event.node.Prev().SweepPoint
                                        }
                                        event.computeSweepFields(s, op, fillRule)
                                }
                        }
                }
        }
        status.Clear() // release all nodes (but not SweepPoints)

        // build resulting polygons
        var Ropen ppath.Path
        for _, square := range squares {
                for _, cur := range square.Events {
                        if cur.inResult == 0 {
                                continue
                        }

                BuildPath:
                        windings := 0
                        prev := cur.prev
                        if op != opDIV && prev != nil {
                                windings = prev.resultWindings
                        }

                        first := cur
                        indexR := len(R)
                        R.MoveTo(cur.X, cur.Y)
                        cur.resultWindings = windings
                        if !first.open {
                                // we go to the right/top
                                cur.resultWindings++
                        }
                        cur.other.resultWindings = cur.resultWindings
                        for {
                                // find segments starting from other endpoint, find the other segment amongst
                                // them, the next segment should be the next going CCW
                                i0 := 0
                                nodes := squares[cur.other.index].Events
                                for i := range nodes {
                                        if nodes[i] == cur.other {
                                                i0 = i
                                                break
                                        }
                                }

                                // find the next segment in CW order, this will make smaller subpaths
                                // instead one large path when multiple segments end at the same position
                                var next *SweepPoint
                                for i := i0 - 1; ; i-- {
                                        if i < 0 {
                                                i += len(nodes)
                                        }
                                        if i == i0 {
                                                break
                                        } else if 0 < nodes[i].inResult && nodes[i].open == first.open {
                                                next = nodes[i]
                                                break
                                        }
                                }
                                if next == nil {
                                        if first.open {
                                                R.LineTo(cur.other.X, cur.other.Y)
                                        } else {
                                                // fmt.Println(ps)
                                                // fmt.Println(op)
                                                // fmt.Println(qs)
                                                // panic("next node for result polygon is nil, probably buggy intersection code")
                                        }
                                        break
                                } else if next == first {
                                        break // contour is done
                                }
                                cur = next

                                R.LineTo(cur.X, cur.Y)
                                cur.resultWindings = windings
                                if cur.left && !first.open {
                                        // we go to the right/top
                                        cur.resultWindings++
                                }
                                cur.other.resultWindings = cur.resultWindings
                                cur.other.inResult--
                                cur.inResult--
                        }
                        first.other.inResult--
                        first.inResult--

                        if first.open {
                                if Ropen != nil {
                                        start := (R[indexR:]).Reverse()
                                        R = append(R[:indexR], start...)
                                        R = append(R, Ropen...)
                                        Ropen = nil
                                } else {
                                        for _, cur2 := range square.Events {
                                                if 0 < cur2.inResult && cur2.open {
                                                        cur = cur2
                                                        Ropen = make(ppath.Path, len(R)-indexR-4)
                                                        copy(Ropen, R[indexR+4:])
                                                        R = R[:indexR]
                                                        goto BuildPath
                                                }
                                        }
                                }
                        } else {
                                R.Close()
                                if windings%2 != 0 {
                                        // orient holes clockwise
                                        hole := R[indexR:].Reverse()
                                        R = append(R[:indexR], hole...)
                                }
                        }
                }

                for _, event := range square.Events {
                        if !event.left {
                                boPointPool.Put(event.other)
                                boPointPool.Put(event)
                        }
                }
                boSquarePool.Put(square)
        }
        return R
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package intersect

import (
        "fmt"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
)

// see https://github.com/signavio/svg-intersections
// see https://github.com/w8r/bezier-intersect
// see https://cs.nyu.edu/exact/doc/subdiv1.pdf

// intersect for path segments a and b, starting at a0 and b0.
// Note that all intersection functions return up to two intersections.
func IntersectionSegment(zs Intersections, a0 math32.Vector2, a ppath.Path, b0 math32.Vector2, b ppath.Path) Intersections {
        n := len(zs)
        swapCurves := false
        if a[0] == ppath.LineTo || a[0] == ppath.Close {
                if b[0] == ppath.LineTo || b[0] == ppath.Close {
                        zs = intersectionLineLine(zs, a0, math32.Vec2(a[1], a[2]), b0, math32.Vec2(b[1], b[2]))
                } else if b[0] == ppath.QuadTo {
                        zs = intersectionLineQuad(zs, a0, math32.Vec2(a[1], a[2]), b0, math32.Vec2(b[1], b[2]), math32.Vec2(b[3], b[4]))
                } else if b[0] == ppath.CubeTo {
                        zs = intersectionLineCube(zs, a0, math32.Vec2(a[1], a[2]), b0, math32.Vec2(b[1], b[2]), math32.Vec2(b[3], b[4]), math32.Vec2(b[5], b[6]))
                } else if b[0] == ppath.ArcTo {
                        rx := b[1]
                        ry := b[2]
                        phi := b[3]
                        large, sweep := ppath.ToArcFlags(b[4])
                        cx, cy, theta0, theta1 := ppath.EllipseToCenter(b0.X, b0.Y, rx, ry, phi, large, sweep, b[5], b[6])
                        zs = intersectionLineEllipse(zs, a0, math32.Vec2(a[1], a[2]), math32.Vector2{cx, cy}, math32.Vector2{rx, ry}, phi, theta0, theta1)
                }
        } else if a[0] == ppath.QuadTo {
                if b[0] == ppath.LineTo || b[0] == ppath.Close {
                        zs = intersectionLineQuad(zs, b0, math32.Vec2(b[1], b[2]), a0, math32.Vec2(a[1], a[2]), math32.Vec2(a[3], a[4]))
                        swapCurves = true
                } else if b[0] == ppath.QuadTo {
                        panic("unsupported intersection for quad-quad")
                } else if b[0] == ppath.CubeTo {
                        panic("unsupported intersection for quad-cube")
                } else if b[0] == ppath.ArcTo {
                        panic("unsupported intersection for quad-arc")
                }
        } else if a[0] == ppath.CubeTo {
                if b[0] == ppath.LineTo || b[0] == ppath.Close {
                        zs = intersectionLineCube(zs, b0, math32.Vec2(b[1], b[2]), a0, math32.Vec2(a[1], a[2]), math32.Vec2(a[3], a[4]), math32.Vec2(a[5], a[6]))
                        swapCurves = true
                } else if b[0] == ppath.QuadTo {
                        panic("unsupported intersection for cube-quad")
                } else if b[0] == ppath.CubeTo {
                        panic("unsupported intersection for cube-cube")
                } else if b[0] == ppath.ArcTo {
                        panic("unsupported intersection for cube-arc")
                }
        } else if a[0] == ppath.ArcTo {
                rx := a[1]
                ry := a[2]
                phi := a[3]
                large, sweep := ppath.ToArcFlags(a[4])
                cx, cy, theta0, theta1 := ppath.EllipseToCenter(a0.X, a0.Y, rx, ry, phi, large, sweep, a[5], a[6])
                if b[0] == ppath.LineTo || b[0] == ppath.Close {
                        zs = intersectionLineEllipse(zs, b0, math32.Vec2(b[1], b[2]), math32.Vector2{cx, cy}, math32.Vector2{rx, ry}, phi, theta0, theta1)
                        swapCurves = true
                } else if b[0] == ppath.QuadTo {
                        panic("unsupported intersection for arc-quad")
                } else if b[0] == ppath.CubeTo {
                        panic("unsupported intersection for arc-cube")
                } else if b[0] == ppath.ArcTo {
                        rx2 := b[1]
                        ry2 := b[2]
                        phi2 := b[3]
                        large2, sweep2 := ppath.ToArcFlags(b[4])
                        cx2, cy2, theta20, theta21 := ppath.EllipseToCenter(b0.X, b0.Y, rx2, ry2, phi2, large2, sweep2, b[5], b[6])
                        zs = intersectionEllipseEllipse(zs, math32.Vector2{cx, cy}, math32.Vector2{rx, ry}, phi, theta0, theta1, math32.Vector2{cx2, cy2}, math32.Vector2{rx2, ry2}, phi2, theta20, theta21)
                }
        }

        // swap A and B in the intersection found to match segments A and B of this function
        if swapCurves {
                for i := n; i < len(zs); i++ {
                        zs[i].T[0], zs[i].T[1] = zs[i].T[1], zs[i].T[0]
                        zs[i].Dir[0], zs[i].Dir[1] = zs[i].Dir[1], zs[i].Dir[0]
                }
        }
        return zs
}

// Intersection is an intersection between two path segments, e.g. Line x Line. Note that an
// intersection is tangent also when it is at one of the endpoints, in which case it may be tangent
// for this segment but may or may not cross the path depending on the adjacent segment.
// Notabene: for quad/cube/ellipse aligned angles at the endpoint for non-overlapping curves are deviated slightly to correctly calculate the value for Into, and will thus not be aligned
type Intersection struct {
        math32.Vector2            // coordinate of intersection
        T              [2]float32 // position along segment [0,1]
        Dir            [2]float32 // direction at intersection [0,2*pi)
        Tangent        bool       // intersection is tangent (touches) instead of secant (crosses)
        Same           bool       // intersection is of two overlapping segments (tangent is also true)
}

// Into returns true if first path goes into the left-hand side of the second path,
// i.e. the second path goes to the right-hand side of the first path.
func (z Intersection) Into() bool {
        return angleBetweenExclusive(z.Dir[1]-z.Dir[0], math32.Pi, 2.0*math32.Pi)
}

func (z Intersection) Equals(o Intersection) bool {
        return ppath.EqualPoint(z.Vector2, o.Vector2) && ppath.Equal(z.T[0], o.T[0]) && ppath.Equal(z.T[1], o.T[1]) && ppath.AngleEqual(z.Dir[0], o.Dir[0]) && ppath.AngleEqual(z.Dir[1], o.Dir[1]) && z.Tangent == o.Tangent && z.Same == o.Same
}

func (z Intersection) String() string {
        var extra string
        if z.Tangent {
                extra = " Tangent"
        }
        if z.Same {
                extra = " Same"
        }
        return fmt.Sprintf("({%v,%v} t={%v,%v} dir={%v°,%v°}%v)", numEps(z.Vector2.X), numEps(z.Vector2.Y), numEps(z.T[0]), numEps(z.T[1]), numEps(math32.RadToDeg(ppath.AngleNorm(z.Dir[0]))), numEps(math32.RadToDeg(ppath.AngleNorm(z.Dir[1]))), extra)
}

type Intersections []Intersection

// Has returns true if there are secant/tangent intersections.
func (zs Intersections) Has() bool {
        return 0 < len(zs)
}

// HasSecant returns true when there are secant intersections, i.e. the curves intersect and cross (they cut).
func (zs Intersections) HasSecant() bool {
        for _, z := range zs {
                if !z.Tangent {
                        return true
                }
        }
        return false
}

// HasTangent returns true when there are tangent intersections, i.e. the curves intersect but don't cross (they touch).
func (zs Intersections) HasTangent() bool {
        for _, z := range zs {
                if z.Tangent {
                        return true
                }
        }
        return false
}

func (zs Intersections) add(pos math32.Vector2, ta, tb, dira, dirb float32, tangent, same bool) Intersections {
        // normalise T values between [0,1]
        if ta < 0.0 { // || ppath.Equal(ta, 0.0) {
                ta = 0.0
        } else if 1.0 <= ta { // || ppath.Equal(ta, 1.0) {
                ta = 1.0
        }
        if tb < 0.0 { // || ppath.Equal(tb, 0.0) {
                tb = 0.0
        } else if 1.0 < tb { // || ppath.Equal(tb, 1.0) {
                tb = 1.0
        }
        return append(zs, Intersection{pos, [2]float32{ta, tb}, [2]float32{dira, dirb}, tangent, same})
}

func correctIntersection(z, aMin, aMax, bMin, bMax math32.Vector2) math32.Vector2 {
        if z.X < aMin.X {
                //fmt.Println("CORRECT 1:", a0, a1, "--", b0, b1)
                z.X = aMin.X
        } else if aMax.X < z.X {
                //fmt.Println("CORRECT 2:", a0, a1, "--", b0, b1)
                z.X = aMax.X
        }
        if z.X < bMin.X {
                //fmt.Println("CORRECT 3:", a0, a1, "--", b0, b1)
                z.X = bMin.X
        } else if bMax.X < z.X {
                //fmt.Println("CORRECT 4:", a0, a1, "--", b0, b1)
                z.X = bMax.X
        }
        if z.Y < aMin.Y {
                //fmt.Println("CORRECT 5:", a0, a1, "--", b0, b1)
                z.Y = aMin.Y
        } else if aMax.Y < z.Y {
                //fmt.Println("CORRECT 6:", a0, a1, "--", b0, b1)
                z.Y = aMax.Y
        }
        if z.Y < bMin.Y {
                //fmt.Println("CORRECT 7:", a0, a1, "--", b0, b1)
                z.Y = bMin.Y
        } else if bMax.Y < z.Y {
                //fmt.Println("CORRECT 8:", a0, a1, "--", b0, b1)
                z.Y = bMax.Y
        }
        return z
}

// F. Antonio, "Faster Line Segment Intersection", Graphics Gems III, 1992
func intersectionLineLineBentleyOttmann(zs []math32.Vector2, a0, a1, b0, b1 math32.Vector2) []math32.Vector2 {
        // fast line-line intersection code, with additional constraints for the BentleyOttmann code:
        // - a0 is to the left and/or bottom of a1, same for b0 and b1
        // - an intersection z must keep the above property between (a0,z), (z,a1), (b0,z), and (z,b1)
        // note that an exception is made for (z,a1) and (z,b1) to allow them to become vertical, this
        // is because there isn't always "space" between a0.X and a1.X, eg. when a1.X = nextafter(a0.X)
        if a1.X < b0.X || b1.X < a0.X {
                return zs
        }

        aMin, aMax, bMin, bMax := a0, a1, b0, b1
        if a1.Y < a0.Y {
                aMin.Y, aMax.Y = aMax.Y, aMin.Y
        }
        if b1.Y < b0.Y {
                bMin.Y, bMax.Y = bMax.Y, bMin.Y
        }
        if aMax.Y < bMin.Y || bMax.Y < aMin.Y {
                return zs
        } else if (aMax.X == bMin.X || bMax.X == aMin.X) && (aMax.Y == bMin.Y || bMax.Y == aMin.Y) {
                return zs
        }

        // only the position and T values are valid for each intersection
        A := a1.Sub(a0)
        B := b0.Sub(b1)
        C := a0.Sub(b0)
        denom := B.Cross(A)
        // divide by length^2 since the perpdot between very small segments may be below Epsilon
        if denom == 0.0 {
                // colinear
                if C.Cross(B) == 0.0 {
                        // overlap, rotate to x-axis
                        a, b, c, d := a0.X, a1.X, b0.X, b1.X
                        if math32.Abs(A.X) < math32.Abs(A.Y) {
                                // mostly vertical
                                a, b, c, d = a0.Y, a1.Y, b0.Y, b1.Y
                        }
                        if c < b && a < d {
                                if a < c {
                                        zs = append(zs, b0)
                                } else if c < a {
                                        zs = append(zs, a0)
                                }
                                if d < b {
                                        zs = append(zs, b1)
                                } else if b < d {
                                        zs = append(zs, a1)
                                }
                        }
                }
                return zs
        }

        // find intersections within +-Epsilon to avoid missing near intersections
        ta := C.Cross(B) / denom
        if ta < -ppath.Epsilon || 1.0+ppath.Epsilon < ta {
                return zs
        }

        tb := A.Cross(C) / denom
        if tb < -ppath.Epsilon || 1.0+ppath.Epsilon < tb {
                return zs
        }

        // ta is snapped to 0.0 or 1.0 if very close
        if ta <= ppath.Epsilon {
                ta = 0.0
        } else if 1.0-ppath.Epsilon <= ta {
                ta = 1.0
        }

        z := a0.Lerp(a1, ta)
        z = correctIntersection(z, aMin, aMax, bMin, bMax)
        if z != a0 && z != a1 || z != b0 && z != b1 {
                // not at endpoints for both
                if a0 != b0 && z != a0 && z != b0 && b0.Sub(z).Cross(z.Sub(a0)) == 0.0 {
                        a, c, m := a0.X, b0.X, z.X
                        if math32.Abs(z.Sub(a0).X) < math32.Abs(z.Sub(a0).Y) {
                                // mostly vertical
                                a, c, m = a0.Y, b0.Y, z.Y
                        }

                        if a != c && (a < m) == (c < m) {
                                if a < m && a < c || m < a && c < a {
                                        zs = append(zs, b0)
                                } else {
                                        zs = append(zs, a0)
                                }
                        }
                        zs = append(zs, z)
                } else if a1 != b1 && z != a1 && z != b1 && z.Sub(b1).Cross(a1.Sub(z)) == 0.0 {
                        b, d, m := a1.X, b1.X, z.X
                        if math32.Abs(z.Sub(a1).X) < math32.Abs(z.Sub(a1).Y) {
                                // mostly vertical
                                b, d, m = a1.Y, b1.Y, z.Y
                        }

                        if b != d && (b < m) == (d < m) {
                                if b < m && b < d || m < b && d < b {
                                        zs = append(zs, b1)
                                } else {
                                        zs = append(zs, a1)
                                }
                        }
                } else {
                        zs = append(zs, z)
                }
        }
        return zs
}

func intersectionLineLine(zs Intersections, a0, a1, b0, b1 math32.Vector2) Intersections {
        if ppath.EqualPoint(a0, a1) || ppath.EqualPoint(b0, b1) {
                return zs // zero-length Close
        }

        da := a1.Sub(a0)
        db := b1.Sub(b0)
        anglea := ppath.Angle(da)
        angleb := ppath.Angle(db)
        div := da.Cross(db)

        // divide by length^2 since otherwise the perpdot between very small segments may be
        // below Epsilon
        if length := da.Length() * db.Length(); ppath.Equal(div/length, 0.0) {
                // parallel
                if ppath.Equal(b0.Sub(a0).Cross(db), 0.0) {
                        // overlap, rotate to x-axis
                        a := a0.Rot(-anglea, math32.Vector2{}).X
                        b := a1.Rot(-anglea, math32.Vector2{}).X
                        c := b0.Rot(-anglea, math32.Vector2{}).X
                        d := b1.Rot(-anglea, math32.Vector2{}).X
                        if inInterval(a, c, d) && inInterval(b, c, d) {
                                // a-b in c-d or a-b == c-d
                                zs = zs.add(a0, 0.0, (a-c)/(d-c), anglea, angleb, true, true)
                                zs = zs.add(a1, 1.0, (b-c)/(d-c), anglea, angleb, true, true)
                        } else if inInterval(c, a, b) && inInterval(d, a, b) {
                                // c-d in a-b
                                zs = zs.add(b0, (c-a)/(b-a), 0.0, anglea, angleb, true, true)
                                zs = zs.add(b1, (d-a)/(b-a), 1.0, anglea, angleb, true, true)
                        } else if inInterval(a, c, d) {
                                // a in c-d
                                same := a < d-ppath.Epsilon || a < c-ppath.Epsilon
                                zs = zs.add(a0, 0.0, (a-c)/(d-c), anglea, angleb, true, same)
                                if a < d-ppath.Epsilon {
                                        zs = zs.add(b1, (d-a)/(b-a), 1.0, anglea, angleb, true, true)
                                } else if a < c-ppath.Epsilon {
                                        zs = zs.add(b0, (c-a)/(b-a), 0.0, anglea, angleb, true, true)
                                }
                        } else if inInterval(b, c, d) {
                                // b in c-d
                                same := c < b-ppath.Epsilon || d < b-ppath.Epsilon
                                if c < b-ppath.Epsilon {
                                        zs = zs.add(b0, (c-a)/(b-a), 0.0, anglea, angleb, true, true)
                                } else if d < b-ppath.Epsilon {
                                        zs = zs.add(b1, (d-a)/(b-a), 1.0, anglea, angleb, true, true)
                                }
                                zs = zs.add(a1, 1.0, (b-c)/(d-c), anglea, angleb, true, same)
                        }
                }
                return zs
        } else if ppath.EqualPoint(a1, b0) {
                // handle common cases with endpoints to avoid numerical issues
                zs = zs.add(a1, 1.0, 0.0, anglea, angleb, true, false)
                return zs
        } else if ppath.EqualPoint(a0, b1) {
                // handle common cases with endpoints to avoid numerical issues
                zs = zs.add(a0, 0.0, 1.0, anglea, angleb, true, false)
                return zs
        }

        ta := db.Cross(a0.Sub(b0)) / div
        tb := da.Cross(a0.Sub(b0)) / div
        if inInterval(ta, 0.0, 1.0) && inInterval(tb, 0.0, 1.0) {
                tangent := ppath.Equal(ta, 0.0) || ppath.Equal(ta, 1.0) || ppath.Equal(tb, 0.0) || ppath.Equal(tb, 1.0)
                zs = zs.add(a0.Lerp(a1, ta), ta, tb, anglea, angleb, tangent, false)
        }
        return zs
}

// https://www.particleincell.com/2013/cubic-line-intersection/
func intersectionLineQuad(zs Intersections, l0, l1, p0, p1, p2 math32.Vector2) Intersections {
        if ppath.EqualPoint(l0, l1) {
                return zs // zero-length Close
        }

        // write line as A.X = bias
        A := math32.Vector2{l1.Y - l0.Y, l0.X - l1.X}
        bias := l0.Dot(A)

        a := A.Dot(p0.Sub(p1.MulScalar(2.0)).Add(p2))
        b := A.Dot(p1.Sub(p0).MulScalar(2.0))
        c := A.Dot(p0) - bias

        roots := []float32{}
        r0, r1 := solveQuadraticFormula(a, b, c)
        if !math32.IsNaN(r0) {
                roots = append(roots, r0)
                if !math32.IsNaN(r1) {
                        roots = append(roots, r1)
                }
        }

        dira := ppath.Angle(l1.Sub(l0))
        horizontal := math32.Abs(l1.Y-l0.Y) <= math32.Abs(l1.X-l0.X)
        for _, root := range roots {
                if inInterval(root, 0.0, 1.0) {
                        var s float32
                        pos := quadraticBezierPos(p0, p1, p2, root)
                        if horizontal {
                                s = (pos.X - l0.X) / (l1.X - l0.X)
                        } else {
                                s = (pos.Y - l0.Y) / (l1.Y - l0.Y)
                        }
                        if inInterval(s, 0.0, 1.0) {
                                deriv := ppath.QuadraticBezierDeriv(p0, p1, p2, root)
                                dirb := ppath.Angle(deriv)
                                endpoint := ppath.Equal(root, 0.0) || ppath.Equal(root, 1.0) || ppath.Equal(s, 0.0) || ppath.Equal(s, 1.0)
                                if endpoint {
                                        // deviate angle slightly at endpoint when aligned to properly set Into
                                        deriv2 := quadraticBezierDeriv2(p0, p1, p2)
                                        if (0.0 <= deriv.Cross(deriv2)) == (ppath.Equal(root, 0.0) || !ppath.Equal(root, 1.0) && ppath.Equal(s, 0.0)) {
                                                dirb += ppath.Epsilon * 2.0 // t=0 and CCW, or t=1 and CW
                                        } else {
                                                dirb -= ppath.Epsilon * 2.0 // t=0 and CW, or t=1 and CCW
                                        }
                                        dirb = ppath.AngleNorm(dirb)
                                }
                                zs = zs.add(pos, s, root, dira, dirb, endpoint || ppath.Equal(A.Dot(deriv), 0.0), false)
                        }
                }
        }
        return zs
}

// https://www.particleincell.com/2013/cubic-line-intersection/
func intersectionLineCube(zs Intersections, l0, l1, p0, p1, p2, p3 math32.Vector2) Intersections {
        if ppath.EqualPoint(l0, l1) {
                return zs // zero-length Close
        }

        // write line as A.X = bias
        A := math32.Vector2{l1.Y - l0.Y, l0.X - l1.X}
        bias := l0.Dot(A)

        a := A.Dot(p3.Sub(p0).Add(p1.MulScalar(3.0)).Sub(p2.MulScalar(3.0)))
        b := A.Dot(p0.MulScalar(3.0).Sub(p1.MulScalar(6.0)).Add(p2.MulScalar(3.0)))
        c := A.Dot(p1.MulScalar(3.0).Sub(p0.MulScalar(3.0)))
        d := A.Dot(p0) - bias

        roots := []float32{}
        r0, r1, r2 := solveCubicFormula(a, b, c, d)
        if !math32.IsNaN(r0) {
                roots = append(roots, r0)
                if !math32.IsNaN(r1) {
                        roots = append(roots, r1)
                        if !math32.IsNaN(r2) {
                                roots = append(roots, r2)
                        }
                }
        }

        dira := ppath.Angle(l1.Sub(l0))
        horizontal := math32.Abs(l1.Y-l0.Y) <= math32.Abs(l1.X-l0.X)
        for _, root := range roots {
                if inInterval(root, 0.0, 1.0) {
                        var s float32
                        pos := cubicBezierPos(p0, p1, p2, p3, root)
                        if horizontal {
                                s = (pos.X - l0.X) / (l1.X - l0.X)
                        } else {
                                s = (pos.Y - l0.Y) / (l1.Y - l0.Y)
                        }
                        if inInterval(s, 0.0, 1.0) {
                                deriv := ppath.CubicBezierDeriv(p0, p1, p2, p3, root)
                                dirb := ppath.Angle(deriv)
                                tangent := ppath.Equal(A.Dot(deriv), 0.0)
                                endpoint := ppath.Equal(root, 0.0) || ppath.Equal(root, 1.0) || ppath.Equal(s, 0.0) || ppath.Equal(s, 1.0)
                                if endpoint {
                                        // deviate angle slightly at endpoint when aligned to properly set Into
                                        deriv2 := cubicBezierDeriv2(p0, p1, p2, p3, root)
                                        if (0.0 <= deriv.Cross(deriv2)) == (ppath.Equal(root, 0.0) || !ppath.Equal(root, 1.0) && ppath.Equal(s, 0.0)) {
                                                dirb += ppath.Epsilon * 2.0 // t=0 and CCW, or t=1 and CW
                                        } else {
                                                dirb -= ppath.Epsilon * 2.0 // t=0 and CW, or t=1 and CCW
                                        }
                                } else if ppath.AngleEqual(dira, dirb) || ppath.AngleEqual(dira, dirb+math32.Pi) {
                                        // directions are parallel but the paths do cross (inflection point)
                                        // TODO: test better
                                        deriv2 := cubicBezierDeriv2(p0, p1, p2, p3, root)
                                        if ppath.Equal(deriv2.X, 0.0) && ppath.Equal(deriv2.Y, 0.0) {
                                                deriv3 := cubicBezierDeriv3(p0, p1, p2, p3, root)
                                                if 0.0 < deriv.Cross(deriv3) {
                                                        dirb += ppath.Epsilon * 2.0
                                                } else {
                                                        dirb -= ppath.Epsilon * 2.0
                                                }
                                                dirb = ppath.AngleNorm(dirb)
                                                tangent = false
                                        }
                                }
                                zs = zs.add(pos, s, root, dira, dirb, endpoint || tangent, false)
                        }
                }
        }
        return zs
}

// handle line-arc intersections and their peculiarities regarding angles
func addLineArcIntersection(zs Intersections, pos math32.Vector2, dira, dirb, t, t0, t1, angle, theta0, theta1 float32, tangent bool) Intersections {
        if theta0 <= theta1 {
                angle = theta0 - ppath.Epsilon + ppath.AngleNorm(angle-theta0+ppath.Epsilon)
        } else {
                angle = theta1 - ppath.Epsilon + ppath.AngleNorm(angle-theta1+ppath.Epsilon)
        }
        endpoint := ppath.Equal(t, t0) || ppath.Equal(t, t1) || ppath.Equal(angle, theta0) || ppath.Equal(angle, theta1)
        if endpoint {
                // deviate angle slightly at endpoint when aligned to properly set Into
                if (theta0 <= theta1) == (ppath.Equal(angle, theta0) || !ppath.Equal(angle, theta1) && ppath.Equal(t, t0)) {
                        dirb += ppath.Epsilon * 2.0 // t=0 and CCW, or t=1 and CW
                } else {
                        dirb -= ppath.Epsilon * 2.0 // t=0 and CW, or t=1 and CCW
                }
                dirb = ppath.AngleNorm(dirb)
        }

        // snap segment parameters to 0.0 and 1.0 to avoid numerical issues
        var s float32
        if ppath.Equal(t, t0) {
                t = 0.0
        } else if ppath.Equal(t, t1) {
                t = 1.0
        } else {
                t = (t - t0) / (t1 - t0)
        }
        if ppath.Equal(angle, theta0) {
                s = 0.0
        } else if ppath.Equal(angle, theta1) {
                s = 1.0
        } else {
                s = (angle - theta0) / (theta1 - theta0)
        }
        return zs.add(pos, t, s, dira, dirb, endpoint || tangent, false)
}

// https://www.geometrictools.com/GTE/Mathematics/IntrLine2Circle2.h
func intersectionLineCircle(zs Intersections, l0, l1, center math32.Vector2, radius, theta0, theta1 float32) Intersections {
        if ppath.EqualPoint(l0, l1) {
                return zs // zero-length Close
        }

        // solve l0 + t*(l1-l0) = P + t*D = X  (line equation)
        // and |X - center| = |X - C| = R = radius  (circle equation)
        // by substitution and squaring: |P + t*D - C|^2 = R^2
        // giving: D^2 t^2 + 2D(P-C) t + (P-C)^2-R^2 = 0
        dir := l1.Sub(l0)
        diff := l0.Sub(center) // P-C
        length := dir.Length()
        D := dir.DivScalar(length)

        // we normalise D to be of length 1, so that the roots are in [0,length]
        a := float32(1.0)
        b := 2.0 * D.Dot(diff)
        c := diff.Dot(diff) - radius*radius

        // find solutions for t ∈ [0,1], the parameter along the line's path
        roots := []float32{}
        r0, r1 := solveQuadraticFormula(a, b, c)
        if !math32.IsNaN(r0) {
                roots = append(roots, r0)
                if !math32.IsNaN(r1) && !ppath.Equal(r0, r1) {
                        roots = append(roots, r1)
                }
        }

        // handle common cases with endpoints to avoid numerical issues
        // snap closest root to path's start or end
        if 0 < len(roots) {
                if pos := l0.Sub(center); ppath.Equal(pos.Length(), radius) {
                        if len(roots) == 1 || math32.Abs(roots[0]) < math32.Abs(roots[1]) {
                                roots[0] = 0.0
                        } else {
                                roots[1] = 0.0
                        }
                }
                if pos := l1.Sub(center); ppath.Equal(pos.Length(), radius) {
                        if len(roots) == 1 || math32.Abs(roots[0]-length) < math32.Abs(roots[1]-length) {
                                roots[0] = length
                        } else {
                                roots[1] = length
                        }
                }
        }

        // add intersections
        dira := ppath.Angle(dir)
        tangent := len(roots) == 1
        for _, root := range roots {
                pos := diff.Add(dir.MulScalar(root / length))
                angle := math32.Atan2(pos.Y*radius, pos.X*radius)
                if inInterval(root, 0.0, length) && ppath.IsAngleBetween(angle, theta0, theta1) {
                        pos = center.Add(pos)
                        dirb := ppath.Angle(ppath.EllipseDeriv(radius, radius, 0.0, theta0 <= theta1, angle))
                        zs = addLineArcIntersection(zs, pos, dira, dirb, root, 0.0, length, angle, theta0, theta1, tangent)
                }
        }
        return zs
}

func intersectionLineEllipse(zs Intersections, l0, l1, center, radius math32.Vector2, phi, theta0, theta1 float32) Intersections {
        if ppath.Equal(radius.X, radius.Y) {
                return intersectionLineCircle(zs, l0, l1, center, radius.X, theta0, theta1)
        } else if ppath.EqualPoint(l0, l1) {
                return zs // zero-length Close
        }

        // TODO: needs more testing
        // TODO: intersection inconsistency due to numerical stability in finding tangent collisions for subsequent paht segments (line -> ellipse), or due to the endpoint of a line not touching with another arc, but the subsequent segment does touch with its starting point
        dira := ppath.Angle(l1.Sub(l0))

        // we take the ellipse center as the origin and counter-rotate by phi
        l0 = l0.Sub(center).Rot(-phi, ppath.Origin)
        l1 = l1.Sub(center).Rot(-phi, ppath.Origin)

        // line: cx + dy + e = 0
        c := l0.Y - l1.Y
        d := l1.X - l0.X
        e := l0.Cross(l1)

        // follow different code paths when line is mostly horizontal or vertical
        horizontal := math32.Abs(c) <= math32.Abs(d)

        // ellipse: x^2/a + y^2/b = 1
        a := radius.X * radius.X
        b := radius.Y * radius.Y

        // rewrite as a polynomial by substituting x or y to obtain:
        // At^2 + Bt + C = 0, with t either x (horizontal) or y (!horizontal)
        var A, B, C float32
        A = a*c*c + b*d*d
        if horizontal {
                B = 2.0 * a * c * e
                C = a*e*e - a*b*d*d
        } else {
                B = 2.0 * b * d * e
                C = b*e*e - a*b*c*c
        }

        // find solutions
        roots := []float32{}
        r0, r1 := solveQuadraticFormula(A, B, C)
        if !math32.IsNaN(r0) {
                roots = append(roots, r0)
                if !math32.IsNaN(r1) && !ppath.Equal(r0, r1) {
                        roots = append(roots, r1)
                }
        }

        for _, root := range roots {
                // get intersection position with center as origin
                var x, y, t0, t1 float32
                if horizontal {
                        x = root
                        y = -e/d - c*root/d
                        t0 = l0.X
                        t1 = l1.X
                } else {
                        x = -e/c - d*root/c
                        y = root
                        t0 = l0.Y
                        t1 = l1.Y
                }

                tangent := ppath.Equal(root, 0.0)
                angle := math32.Atan2(y*radius.X, x*radius.Y)
                if inInterval(root, t0, t1) && ppath.IsAngleBetween(angle, theta0, theta1) {
                        pos := math32.Vector2{x, y}.Rot(phi, ppath.Origin).Add(center)
                        dirb := ppath.Angle(ppath.EllipseDeriv(radius.X, radius.Y, phi, theta0 <= theta1, angle))
                        zs = addLineArcIntersection(zs, pos, dira, dirb, root, t0, t1, angle, theta0, theta1, tangent)
                }
        }
        return zs
}

func intersectionEllipseEllipse(zs Intersections, c0, r0 math32.Vector2, phi0, thetaStart0, thetaEnd0 float32, c1, r1 math32.Vector2, phi1, thetaStart1, thetaEnd1 float32) Intersections {
        // TODO: needs more testing
        if !ppath.Equal(r0.X, r0.Y) || !ppath.Equal(r1.X, r1.Y) {
                panic("not handled") // ellipses
        }

        arcAngle := func(theta float32, sweep bool) float32 {
                theta += math32.Pi / 2.0
                if !sweep {
                        theta -= math32.Pi
                }
                return ppath.AngleNorm(theta)
        }

        dtheta0 := thetaEnd0 - thetaStart0
        thetaStart0 = ppath.AngleNorm(thetaStart0 + phi0)
        thetaEnd0 = thetaStart0 + dtheta0

        dtheta1 := thetaEnd1 - thetaStart1
        thetaStart1 = ppath.AngleNorm(thetaStart1 + phi1)
        thetaEnd1 = thetaStart1 + dtheta1

        if ppath.EqualPoint(c0, c1) && ppath.EqualPoint(r0, r1) {
                // parallel
                tOffset1 := float32(0.0)
                dirOffset1 := float32(0.0)
                if (0.0 <= dtheta0) != (0.0 <= dtheta1) {
                        thetaStart1, thetaEnd1 = thetaEnd1, thetaStart1 // keep order on first arc
                        dirOffset1 = math32.Pi
                        tOffset1 = 1.0
                }

                // will add either 1 (when touching) or 2 (when overlapping) intersections
                if t := angleTime(thetaStart0, thetaStart1, thetaEnd1); inInterval(t, 0.0, 1.0) {
                        // ellipse0 starts within/on border of ellipse1
                        dir := arcAngle(thetaStart0, 0.0 <= dtheta0)
                        pos := ppath.EllipsePos(r0.X, r0.Y, 0.0, c0.X, c0.Y, thetaStart0)
                        zs = zs.add(pos, 0.0, math32.Abs(t-tOffset1), dir, ppath.AngleNorm(dir+dirOffset1), true, true)
                }
                if t := angleTime(thetaStart1, thetaStart0, thetaEnd0); inIntervalExclusive(t, 0.0, 1.0) {
                        // ellipse1 starts within ellipse0
                        dir := arcAngle(thetaStart1, 0.0 <= dtheta0)
                        pos := ppath.EllipsePos(r0.X, r0.Y, 0.0, c0.X, c0.Y, thetaStart1)
                        zs = zs.add(pos, t, tOffset1, dir, ppath.AngleNorm(dir+dirOffset1), true, true)
                }
                if t := angleTime(thetaEnd1, thetaStart0, thetaEnd0); inIntervalExclusive(t, 0.0, 1.0) {
                        // ellipse1 ends within ellipse0
                        dir := arcAngle(thetaEnd1, 0.0 <= dtheta0)
                        pos := ppath.EllipsePos(r0.X, r0.Y, 0.0, c0.X, c0.Y, thetaEnd1)
                        zs = zs.add(pos, t, 1.0-tOffset1, dir, ppath.AngleNorm(dir+dirOffset1), true, true)
                }
                if t := angleTime(thetaEnd0, thetaStart1, thetaEnd1); inInterval(t, 0.0, 1.0) {
                        // ellipse0 ends within/on border of ellipse1
                        dir := arcAngle(thetaEnd0, 0.0 <= dtheta0)
                        pos := ppath.EllipsePos(r0.X, r0.Y, 0.0, c0.X, c0.Y, thetaEnd0)
                        zs = zs.add(pos, 1.0, math32.Abs(t-tOffset1), dir, ppath.AngleNorm(dir+dirOffset1), true, true)
                }
                return zs
        }

        // https://math32.stackexchange.com/questions/256100/how-can-i-find-the-points-at-which-two-circles-intersect
        // https://gist.github.com/jupdike/bfe5eb23d1c395d8a0a1a4ddd94882ac
        R := c0.Sub(c1).Length()
        if R < math32.Abs(r0.X-r1.X) || r0.X+r1.X < R {
                return zs
        }
        R2 := R * R

        k := r0.X*r0.X - r1.X*r1.X
        a := float32(0.5)
        b := 0.5 * k / R2
        c := 0.5 * math32.Sqrt(2.0*(r0.X*r0.X+r1.X*r1.X)/R2-k*k/(R2*R2)-1.0)

        mid := c1.Sub(c0).MulScalar(a + b)
        dev := math32.Vector2{c1.Y - c0.Y, c0.X - c1.X}.MulScalar(c)

        tangent := ppath.EqualPoint(dev, math32.Vector2{})
        anglea0 := ppath.Angle(mid.Add(dev))
        anglea1 := ppath.Angle(c0.Sub(c1).Add(mid).Add(dev))
        ta0 := angleTime(anglea0, thetaStart0, thetaEnd0)
        ta1 := angleTime(anglea1, thetaStart1, thetaEnd1)
        if inInterval(ta0, 0.0, 1.0) && inInterval(ta1, 0.0, 1.0) {
                dir0 := arcAngle(anglea0, 0.0 <= dtheta0)
                dir1 := arcAngle(anglea1, 0.0 <= dtheta1)
                endpoint := ppath.Equal(ta0, 0.0) || ppath.Equal(ta0, 1.0) || ppath.Equal(ta1, 0.0) || ppath.Equal(ta1, 1.0)
                zs = zs.add(c0.Add(mid).Add(dev), ta0, ta1, dir0, dir1, tangent || endpoint, false)
        }

        if !tangent {
                angleb0 := ppath.Angle(mid.Sub(dev))
                angleb1 := ppath.Angle(c0.Sub(c1).Add(mid).Sub(dev))
                tb0 := angleTime(angleb0, thetaStart0, thetaEnd0)
                tb1 := angleTime(angleb1, thetaStart1, thetaEnd1)
                if inInterval(tb0, 0.0, 1.0) && inInterval(tb1, 0.0, 1.0) {
                        dir0 := arcAngle(angleb0, 0.0 <= dtheta0)
                        dir1 := arcAngle(angleb1, 0.0 <= dtheta1)
                        endpoint := ppath.Equal(tb0, 0.0) || ppath.Equal(tb0, 1.0) || ppath.Equal(tb1, 0.0) || ppath.Equal(tb1, 1.0)
                        zs = zs.add(c0.Add(mid).Sub(dev), tb0, tb1, dir0, dir1, endpoint, false)
                }
        }
        return zs
}

// TODO: bezier-bezier intersection
// TODO: bezier-ellipse intersection

// For Bézier-Bézier intersections:
// see T.W. Sederberg, "Computer Aided Geometric Design", 2012
// see T.W. Sederberg and T. Nishita, "Curve intersection using Bézier clipping", 1990
// see T.W. Sederberg and S.R. Parry, "Comparison of three curve intersection algorithms", 1986

func IntersectionRayLine(a0, a1, b0, b1 math32.Vector2) (math32.Vector2, bool) {
        da := a1.Sub(a0)
        db := b1.Sub(b0)
        div := da.Cross(db)
        if ppath.Equal(div, 0.0) {
                // parallel
                return math32.Vector2{}, false
        }

        tb := da.Cross(a0.Sub(b0)) / div
        if inInterval(tb, 0.0, 1.0) {
                return b0.Lerp(b1, tb), true
        }
        return math32.Vector2{}, false
}

// https://mathworld.wolfram.com/Circle-LineIntersection.html
func IntersectionRayCircle(l0, l1, c math32.Vector2, r float32) (math32.Vector2, math32.Vector2, bool) {
        d := l1.Sub(l0).Normal() // along line direction, anchored in l0, its length is 1
        D := l0.Sub(c).Cross(d)
        discriminant := r*r - D*D
        if discriminant < 0 {
                return math32.Vector2{}, math32.Vector2{}, false
        }
        discriminant = math32.Sqrt(discriminant)

        ax := D * d.Y
        bx := d.X * discriminant
        if d.Y < 0.0 {
                bx = -bx
        }
        ay := -D * d.X
        by := math32.Abs(d.Y) * discriminant
        return c.Add(math32.Vector2{ax + bx, ay + by}), c.Add(math32.Vector2{ax - bx, ay - by}), true
}

// https://math32.stackexchange.com/questions/256100/how-can-i-find-the-points-at-which-two-circles-intersect
// https://gist.github.com/jupdike/bfe5eb23d1c395d8a0a1a4ddd94882ac
func IntersectionCircleCircle(c0 math32.Vector2, r0 float32, c1 math32.Vector2, r1 float32) (math32.Vector2, math32.Vector2, bool) {
        R := c0.Sub(c1).Length()
        if R < math32.Abs(r0-r1) || r0+r1 < R || ppath.EqualPoint(c0, c1) {
                return math32.Vector2{}, math32.Vector2{}, false
        }
        R2 := R * R

        k := r0*r0 - r1*r1
        a := float32(0.5)
        b := 0.5 * k / R2
        c := 0.5 * math32.Sqrt(2.0*(r0*r0+r1*r1)/R2-k*k/(R2*R2)-1.0)

        i0 := c0.Add(c1).MulScalar(a)
        i1 := c1.Sub(c0).MulScalar(b)
        i2 := math32.Vector2{c1.Y - c0.Y, c0.X - c1.X}.MulScalar(c)
        return i0.Add(i1).Add(i2), i0.Add(i1).Sub(i2), true
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package intersect

import (
        "fmt"
        "strings"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
)

// inInterval returns true if f is in closed interval
// [lower-Epsilon,upper+Epsilon] where lower and upper can be interchanged.
func inInterval(f, lower, upper float32) bool {
        if upper < lower {
                lower, upper = upper, lower
        }
        return lower-ppath.Epsilon <= f && f <= upper+ppath.Epsilon
}

// inIntervalExclusive returns true if f is in open interval
// [lower+Epsilon,upper-Epsilon] where lower and upper can be interchanged.
func inIntervalExclusive(f, lower, upper float32) bool {
        if upper < lower {
                lower, upper = upper, lower
        }
        return lower+ppath.Epsilon < f && f < upper-ppath.Epsilon
}

// touchesPoint returns true if the rectangle touches a point (within +-Epsilon).
func touchesPoint(r math32.Box2, p math32.Vector2) bool {
        return inInterval(p.X, r.Min.X, r.Max.X) && inInterval(p.Y, r.Min.Y, r.Max.Y)
}

// touches returns true if both rectangles touch (or overlap).
func touches(r, q math32.Box2) bool {
        if q.Max.X+ppath.Epsilon < r.Min.X || r.Max.X < q.Min.X-ppath.Epsilon {
                // left or right
                return false
        } else if q.Max.Y+ppath.Epsilon < r.Min.Y || r.Max.Y < q.Min.Y-ppath.Epsilon {
                // below or above
                return false
        }
        return true
}

// angleBetweenExclusive is true when theta is in range (lower,upper)
// excluding the end points. Angles can be outside the [0,2PI) range.
func angleBetweenExclusive(theta, lower, upper float32) bool {
        if upper < lower {
                // sweep is false, ie direction is along negative angle (clockwise)
                lower, upper = upper, lower
        }
        theta = ppath.AngleNorm(theta - lower)
        upper = ppath.AngleNorm(upper - lower)
        if 0.0 < theta && theta < upper {
                return true
        }
        return false
}

// angleTime returns the time [0.0,1.0] of theta between
// [lower,upper]. When outside of [lower,upper], the result will also be outside of [0.0,1.0].
func angleTime(theta, lower, upper float32) float32 {
        sweep := true
        if upper < lower {
                // sweep is false, ie direction is along negative angle (clockwise)
                lower, upper = upper, lower
                sweep = false
        }
        theta = ppath.AngleNorm(theta - lower + ppath.Epsilon)
        upper = ppath.AngleNorm(upper - lower)

        t := (theta - ppath.Epsilon) / upper
        if !sweep {
                t = 1.0 - t
        }
        if ppath.Equal(t, 0.0) {
                return 0.0
        } else if ppath.Equal(t, 1.0) {
                return 1.0
        }
        return t
}

// Numerically stable quadratic formula, lowest root is returned first, see https://math32.stackexchange.com/a/2007723
func solveQuadraticFormula(a, b, c float32) (float32, float32) {
        if ppath.Equal(a, 0.0) {
                if ppath.Equal(b, 0.0) {
                        if ppath.Equal(c, 0.0) {
                                // all terms disappear, all x satisfy the solution
                                return 0.0, math32.NaN()
                        }
                        // linear term disappears, no solutions
                        return math32.NaN(), math32.NaN()
                }
                // quadratic term disappears, solve linear equation
                return -c / b, math32.NaN()
        }

        if ppath.Equal(c, 0.0) {
                // no constant term, one solution at zero and one from solving linearly
                if ppath.Equal(b, 0.0) {
                        return 0.0, math32.NaN()
                }
                return 0.0, -b / a
        }

        discriminant := b*b - 4.0*a*c
        if discriminant < 0.0 {
                return math32.NaN(), math32.NaN()
        } else if ppath.Equal(discriminant, 0.0) {
                return -b / (2.0 * a), math32.NaN()
        }

        // Avoid catastrophic cancellation, which occurs when we subtract two nearly equal numbers and causes a large error. This can be the case when 4*a*c is small so that sqrt(discriminant) -> b, and the sign of b and in front of the radical are the same. Instead, we calculate x where b and the radical have different signs, and then use this result in the analytical equivalent of the formula, called the Citardauq Formula.
        q := math32.Sqrt(discriminant)
        if b < 0.0 {
                // apply sign of b
                q = -q
        }
        x1 := -(b + q) / (2.0 * a)
        x2 := c / (a * x1)
        if x2 < x1 {
                x1, x2 = x2, x1
        }
        return x1, x2
}

// see https://www.geometrictools.com/Documentation/LowDegreePolynomialRoots.pdf
// see https://github.com/thelonious/kld-polynomial/blob/development/lib/Polynomial.js
func solveCubicFormula(a, b, c, d float32) (float32, float32, float32) {
        var x1, x2, x3 float32
        x2, x3 = math32.NaN(), math32.NaN() // x1 is always set to a number below
        if ppath.Equal(a, 0.0) {
                x1, x2 = solveQuadraticFormula(b, c, d)
        } else {
                // obtain monic polynomial: x^3 + f.x^2 + g.x + h = 0
                b /= a
                c /= a
                d /= a

                // obtain depressed polynomial: x^3 + c1.x + c0
                bthird := b / 3.0
                c0 := d - bthird*(c-2.0*bthird*bthird)
                c1 := c - b*bthird
                if ppath.Equal(c0, 0.0) {
                        if c1 < 0.0 {
                                tmp := math32.Sqrt(-c1)
                                x1 = -tmp - bthird
                                x2 = tmp - bthird
                                x3 = 0.0 - bthird
                        } else {
                                x1 = 0.0 - bthird
                        }
                } else if ppath.Equal(c1, 0.0) {
                        if 0.0 < c0 {
                                x1 = -math32.Cbrt(c0) - bthird
                        } else {
                                x1 = math32.Cbrt(-c0) - bthird
                        }
                } else {
                        delta := -(4.0*c1*c1*c1 + 27.0*c0*c0)
                        if ppath.Equal(delta, 0.0) {
                                delta = 0.0
                        }

                        if delta < 0.0 {
                                betaRe := -c0 / 2.0
                                betaIm := math32.Sqrt(-delta / 108.0)
                                tmp := betaRe - betaIm
                                if 0.0 <= tmp {
                                        x1 = math32.Cbrt(tmp)
                                } else {
                                        x1 = -math32.Cbrt(-tmp)
                                }
                                tmp = betaRe + betaIm
                                if 0.0 <= tmp {
                                        x1 += math32.Cbrt(tmp)
                                } else {
                                        x1 -= math32.Cbrt(-tmp)
                                }
                                x1 -= bthird
                        } else if 0.0 < delta {
                                betaRe := -c0 / 2.0
                                betaIm := math32.Sqrt(delta / 108.0)
                                theta := math32.Atan2(betaIm, betaRe) / 3.0
                                sintheta, costheta := math32.Sincos(theta)
                                distance := math32.Sqrt(-c1 / 3.0) // same as rhoPowThird
                                tmp := distance * sintheta * math32.Sqrt(3.0)
                                x1 = 2.0*distance*costheta - bthird
                                x2 = -distance*costheta - tmp - bthird
                                x3 = -distance*costheta + tmp - bthird
                        } else {
                                tmp := -3.0 * c0 / (2.0 * c1)
                                x1 = tmp - bthird
                                x2 = -2.0*tmp - bthird
                        }
                }
        }

        // sort
        if x3 < x2 || math32.IsNaN(x2) {
                x2, x3 = x3, x2
        }
        if x2 < x1 || math32.IsNaN(x1) {
                x1, x2 = x2, x1
        }
        if x3 < x2 || math32.IsNaN(x2) {
                x2, x3 = x3, x2
        }
        return x1, x2, x3
}

type gaussLegendreFunc func(func(float32) float32, float32, float32) float32

// Gauss-Legendre quadrature integration from a to b with n=3, see https://pomax.github.io/bezierinfo/legendre-gauss.html for more values
func gaussLegendre3(f func(float32) float32, a, b float32) float32 {
        c := (b - a) / 2.0
        d := (a + b) / 2.0
        Qd1 := f(-0.774596669*c + d)
        Qd2 := f(d)
        Qd3 := f(0.774596669*c + d)
        return c * ((5.0/9.0)*(Qd1+Qd3) + (8.0/9.0)*Qd2)
}

// Gauss-Legendre quadrature integration from a to b with n=5
func gaussLegendre5(f func(float32) float32, a, b float32) float32 {
        c := (b - a) / 2.0
        d := (a + b) / 2.0
        Qd1 := f(-0.90618*c + d)
        Qd2 := f(-0.538469*c + d)
        Qd3 := f(d)
        Qd4 := f(0.538469*c + d)
        Qd5 := f(0.90618*c + d)
        return c * (0.236927*(Qd1+Qd5) + 0.478629*(Qd2+Qd4) + 0.568889*Qd3)
}

// Gauss-Legendre quadrature integration from a to b with n=7
func gaussLegendre7(f func(float32) float32, a, b float32) float32 {
        c := (b - a) / 2.0
        d := (a + b) / 2.0
        Qd1 := f(-0.949108*c + d)
        Qd2 := f(-0.741531*c + d)
        Qd3 := f(-0.405845*c + d)
        Qd4 := f(d)
        Qd5 := f(0.405845*c + d)
        Qd6 := f(0.741531*c + d)
        Qd7 := f(0.949108*c + d)
        return c * (0.129485*(Qd1+Qd7) + 0.279705*(Qd2+Qd6) + 0.381830*(Qd3+Qd5) + 0.417959*Qd4)
}

func invSpeedPolynomialChebyshevApprox(N int, gaussLegendre gaussLegendreFunc, fp func(float32) float32, tmin, tmax float32) (func(float32) float32, float32) {
        // TODO: find better way to determine N. For Arc 10 seems fine, for some Quads 10 is too low, for Cube depending on inflection points is maybe not the best indicator
        // TODO: track efficiency, how many times is fp called? Does a look-up table make more sense?
        fLength := func(t float32) float32 {
                return math32.Abs(gaussLegendre(fp, tmin, t))
        }
        totalLength := fLength(tmax)
        t := func(L float32) float32 {
                return bisectionMethod(fLength, L, tmin, tmax)
        }
        return polynomialChebyshevApprox(N, t, 0.0, totalLength, tmin, tmax), totalLength
}

func polynomialChebyshevApprox(N int, f func(float32) float32, xmin, xmax, ymin, ymax float32) func(float32) float32 {
        fs := make([]float32, N)
        for k := 0; k < N; k++ {
                u := math32.Cos(math32.Pi * (float32(k+1) - 0.5) / float32(N))
                fs[k] = f(xmin + (xmax-xmin)*(u+1.0)/2.0)
        }

        c := make([]float32, N)
        for j := 0; j < N; j++ {
                a := float32(0.0)
                for k := 0; k < N; k++ {
                        a += fs[k] * math32.Cos(float32(j)*math32.Pi*(float32(k+1)-0.5)/float32(N))
                }
                c[j] = (2.0 / float32(N)) * a
        }

        if ymax < ymin {
                ymin, ymax = ymax, ymin
        }
        return func(x float32) float32 {
                x = math32.Min(xmax, math32.Max(xmin, x))
                u := (x-xmin)/(xmax-xmin)*2.0 - 1.0
                a := float32(0.0)
                for j := 0; j < N; j++ {
                        a += c[j] * math32.Cos(float32(j)*math32.Acos(u))
                }
                y := -0.5*c[0] + a
                if !math32.IsNaN(ymin) && !math32.IsNaN(ymax) {
                        y = math32.Min(ymax, math32.Max(ymin, y))
                }
                return y
        }
}

// find value x for which f(x) = y in the interval x in [xmin, xmax] using the bisection method
func bisectionMethod(f func(float32) float32, y, xmin, xmax float32) float32 {
        const MaxIterations = 100
        const Tolerance = 0.001 // 0.1%

        n := 0
        toleranceX := math32.Abs(xmax-xmin) * Tolerance
        toleranceY := math32.Abs(f(xmax)-f(xmin)) * Tolerance

        var x float32
        for {
                x = (xmin + xmax) / 2.0
                if n >= MaxIterations {
                        return x
                }

                dy := f(x) - y
                if math32.Abs(dy) < toleranceY || math32.Abs(xmax-xmin)/2.0 < toleranceX {
                        return x
                } else if dy > 0.0 {
                        xmax = x
                } else {
                        xmin = x
                }
                n++
        }
}

// snap "gridsnaps" the floating point to a grid of the given spacing
func snap(val, spacing float32) float32 {
        return math32.Round(val/spacing) * spacing
}

// Gridsnap snaps point to a grid with the given spacing.
func Gridsnap(p math32.Vector2, spacing float32) math32.Vector2 {
        return math32.Vector2{snap(p.X, spacing), snap(p.Y, spacing)}
}

type numEps float32

func (f numEps) String() string {
        s := fmt.Sprintf("%.*g", int(math32.Ceil(-math32.Log10(ppath.Epsilon))), f)
        if dot := strings.IndexByte(s, '.'); dot != -1 {
                for dot < len(s) && s[len(s)-1] == '0' {
                        s = s[:len(s)-1]
                }
                if dot < len(s) && s[len(s)-1] == '.' {
                        s = s[:len(s)-1]
                }
        }
        return s
}

//func lookupMin(f func(float64) float64, xmin, xmax float64) float64 {
//        const MaxIterations = 1000
//        min := math32.Inf(1)
//        for i := 0; i <= MaxIterations; i++ {
//                t := float64(i) / float64(MaxIterations)
//                x := xmin + t*(xmax-xmin)
//                y := f(x)
//                if y < min {
//                        min = y
//                }
//        }
//        return min
//}
//
//func gradientDescent(f func(float64) float64, xmin, xmax float64) float64 {
//        const MaxIterations = 100
//        const Delta = 0.0001
//        const Rate = 0.01
//
//        x := (xmin + xmax) / 2.0
//        for i := 0; i < MaxIterations; i++ {
//                dydx := (f(x+Delta) - f(x-Delta)) / 2.0 / Delta
//                x -= Rate * dydx
//        }
//        return x
//}

// func cohenSutherlandOutcode(rect math32.Box2, p math32.Vector2, eps float32) int {
//         code := 0b0000
//         if p.X < rect.Min.X-eps {
//                 code |= 0b0001 // left
//         } else if rect.Max.X+eps < p.X {
//                 code |= 0b0010 // right
//         }
//         if p.Y < rect.Min.Y-eps {
//                 code |= 0b0100 // bottom
//         } else if rect.Max.Y+eps < p.Y {
//                 code |= 0b1000 // top
//         }
//         return code
// }
//
// // return whether line is inside the rectangle, either entirely or partially.
// func cohenSutherlandLineClip(rect math32.Box2, a, b math32.Vector2, eps float32) (math32.Vector2, math32.Vector2, bool, bool) {
//         outcode0 := cohenSutherlandOutcode(rect, a, eps)
//         outcode1 := cohenSutherlandOutcode(rect, b, eps)
//         if outcode0 == 0 && outcode1 == 0 {
//                 return a, b, true, false
//         }
//         for {
//                 if (outcode0 | outcode1) == 0 {
//                         // both inside
//                         return a, b, true, true
//                 } else if (outcode0 & outcode1) != 0 {
//                         // both in same region outside
//                         return a, b, false, false
//                 }
//
//                 // pick point outside
//                 outcodeOut := outcode0
//                 if outcode0 < outcode1 {
//                         outcodeOut = outcode1
//                 }
//
//                 // intersect with rectangle
//                 var c math32.Vector2
//                 if (outcodeOut & 0b1000) != 0 {
//                         // above
//                         c.X = a.X + (b.X-a.X)*(rect.Max.Y-a.Y)/(b.Y-a.Y)
//                         c.Y = rect.Max.Y
//                 } else if (outcodeOut & 0b0100) != 0 {
//                         // below
//                         c.X = a.X + (b.X-a.X)*(rect.Min.Y-a.Y)/(b.Y-a.Y)
//                         c.Y = rect.Min.Y
//                 } else if (outcodeOut & 0b0010) != 0 {
//                         // right
//                         c.X = rect.Max.X
//                         c.Y = a.Y + (b.Y-a.Y)*(rect.Max.X-a.X)/(b.X-a.X)
//                 } else if (outcodeOut & 0b0001) != 0 {
//                         // left
//                         c.X = rect.Min.X
//                         c.Y = a.Y + (b.Y-a.Y)*(rect.Min.X-a.X)/(b.X-a.X)
//                 }
//
//                 // prepare next pass
//                 if outcodeOut == outcode0 {
//                         outcode0 = cohenSutherlandOutcode(rect, c, eps)
//                         a = c
//                 } else {
//                         outcode1 = cohenSutherlandOutcode(rect, c, eps)
//                         b = c
//                 }
//         }
// }

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import (
        "fmt"
        "math"
        "strings"

        "cogentcore.org/core/math32"
        "github.com/tdewolff/parse/v2/strconv"
)

type num float32

func (f num) String() string {
        s := fmt.Sprintf("%.*g", Precision, f)
        if num(math.MaxInt32) < f || f < num(math.MinInt32) {
                if i := strings.IndexAny(s, ".eE"); i == -1 {
                        s += ".0"
                }
        }
        return string(MinifyNumber([]byte(s), Precision))
}

type dec float32

func (f dec) String() string {
        s := fmt.Sprintf("%.*f", Precision, f)
        s = string(MinifyDecimal([]byte(s), Precision))
        if dec(math.MaxInt32) < f || f < dec(math.MinInt32) {
                if i := strings.IndexByte(s, '.'); i == -1 {
                        s += ".0"
                }
        }
        return s
}

func skipCommaWhitespace(path []byte) int {
        i := 0
        for i < len(path) && (path[i] == ' ' || path[i] == ',' || path[i] == '\n' || path[i] == '\r' || path[i] == '\t') {
                i++
        }
        return i
}

// MustParseSVGPath parses an SVG path data string and panics if it fails.
func MustParseSVGPath(s string) Path {
        p, err := ParseSVGPath(s)
        if err != nil {
                panic(err)
        }
        return p
}

// ParseSVGPath parses an SVG path data string.
func ParseSVGPath(s string) (Path, error) {
        if len(s) == 0 {
                return Path{}, nil
        }

        i := 0
        path := []byte(s)
        i += skipCommaWhitespace(path[i:])
        if path[0] == ',' || path[i] < 'A' {
                return nil, fmt.Errorf("bad path: path should start with command")
        }

        cmdLens := map[byte]int{
                'M': 2,
                'Z': 0,
                'L': 2,
                'H': 1,
                'V': 1,
                'C': 6,
                'S': 4,
                'Q': 4,
                'T': 2,
                'A': 7,
        }
        f := [7]float32{}

        p := Path{}
        var q, c math32.Vector2
        var p0, p1 math32.Vector2
        prevCmd := byte('z')
        for {
                i += skipCommaWhitespace(path[i:])
                if len(path) <= i {
                        break
                }

                cmd := prevCmd
                repeat := true
                if cmd == 'z' || cmd == 'Z' || !(path[i] >= '0' && path[i] <= '9' || path[i] == '.' || path[i] == '-' || path[i] == '+') {
                        cmd = path[i]
                        repeat = false
                        i++
                        i += skipCommaWhitespace(path[i:])
                }

                CMD := cmd
                if 'a' <= cmd && cmd <= 'z' {
                        CMD -= 'a' - 'A'
                }
                for j := 0; j < cmdLens[CMD]; j++ {
                        if CMD == 'A' && (j == 3 || j == 4) {
                                // parse largeArc and sweep booleans for A command
                                if i < len(path) && path[i] == '1' {
                                        f[j] = 1.0
                                } else if i < len(path) && path[i] == '0' {
                                        f[j] = 0.0
                                } else {
                                        return nil, fmt.Errorf("bad path: largeArc and sweep flags should be 0 or 1 in command '%c' at position %d", cmd, i+1)
                                }
                                i++
                        } else {
                                num, n := strconv.ParseFloat(path[i:])
                                if n == 0 {
                                        if repeat && j == 0 && i < len(path) {
                                                return nil, fmt.Errorf("bad path: unknown command '%c' at position %d", path[i], i+1)
                                        } else if 1 < cmdLens[CMD] {
                                                return nil, fmt.Errorf("bad path: sets of %d numbers should follow command '%c' at position %d", cmdLens[CMD], cmd, i+1)
                                        } else {
                                                return nil, fmt.Errorf("bad path: number should follow command '%c' at position %d", cmd, i+1)
                                        }
                                }
                                f[j] = float32(num)
                                i += n
                        }
                        i += skipCommaWhitespace(path[i:])
                }

                switch cmd {
                case 'M', 'm':
                        p1 = math32.Vector2{f[0], f[1]}
                        if cmd == 'm' {
                                p1 = p1.Add(p0)
                                cmd = 'l'
                        } else {
                                cmd = 'L'
                        }
                        p.MoveTo(p1.X, p1.Y)
                case 'Z', 'z':
                        p1 = p.StartPos()
                        p.Close()
                case 'L', 'l':
                        p1 = math32.Vector2{f[0], f[1]}
                        if cmd == 'l' {
                                p1 = p1.Add(p0)
                        }
                        p.LineTo(p1.X, p1.Y)
                case 'H', 'h':
                        p1.X = f[0]
                        if cmd == 'h' {
                                p1.X += p0.X
                        }
                        p.LineTo(p1.X, p1.Y)
                case 'V', 'v':
                        p1.Y = f[0]
                        if cmd == 'v' {
                                p1.Y += p0.Y
                        }
                        p.LineTo(p1.X, p1.Y)
                case 'C', 'c':
                        cp1 := math32.Vector2{f[0], f[1]}
                        cp2 := math32.Vector2{f[2], f[3]}
                        p1 = math32.Vector2{f[4], f[5]}
                        if cmd == 'c' {
                                cp1 = cp1.Add(p0)
                                cp2 = cp2.Add(p0)
                                p1 = p1.Add(p0)
                        }
                        p.CubeTo(cp1.X, cp1.Y, cp2.X, cp2.Y, p1.X, p1.Y)
                        c = cp2
                case 'S', 's':
                        cp1 := p0
                        cp2 := math32.Vector2{f[0], f[1]}
                        p1 = math32.Vector2{f[2], f[3]}
                        if cmd == 's' {
                                cp2 = cp2.Add(p0)
                                p1 = p1.Add(p0)
                        }
                        if prevCmd == 'C' || prevCmd == 'c' || prevCmd == 'S' || prevCmd == 's' {
                                cp1 = p0.MulScalar(2.0).Sub(c)
                        }
                        p.CubeTo(cp1.X, cp1.Y, cp2.X, cp2.Y, p1.X, p1.Y)
                        c = cp2
                case 'Q', 'q':
                        cp := math32.Vector2{f[0], f[1]}
                        p1 = math32.Vector2{f[2], f[3]}
                        if cmd == 'q' {
                                cp = cp.Add(p0)
                                p1 = p1.Add(p0)
                        }
                        p.QuadTo(cp.X, cp.Y, p1.X, p1.Y)
                        q = cp
                case 'T', 't':
                        cp := p0
                        p1 = math32.Vector2{f[0], f[1]}
                        if cmd == 't' {
                                p1 = p1.Add(p0)
                        }
                        if prevCmd == 'Q' || prevCmd == 'q' || prevCmd == 'T' || prevCmd == 't' {
                                cp = p0.MulScalar(2.0).Sub(q)
                        }
                        p.QuadTo(cp.X, cp.Y, p1.X, p1.Y)
                        q = cp
                case 'A', 'a':
                        rx := f[0]
                        ry := f[1]
                        rot := f[2]
                        large := f[3] == 1.0
                        sweep := f[4] == 1.0
                        p1 = math32.Vector2{f[5], f[6]}
                        if cmd == 'a' {
                                p1 = p1.Add(p0)
                        }
                        p.ArcToDeg(rx, ry, rot, large, sweep, p1.X, p1.Y)
                default:
                        return nil, fmt.Errorf("bad path: unknown command '%c' at position %d", cmd, i+1)
                }
                prevCmd = cmd
                p0 = p1
        }
        return p, nil
}

// String returns a string that represents the path similar to the SVG
// path data format (but not necessarily valid SVG).
func (p Path) String() string {
        sb := strings.Builder{}
        for i := 0; i < len(p); {
                cmd := p[i]
                switch cmd {
                case MoveTo:
                        fmt.Fprintf(&sb, "M%g %g", p[i+1], p[i+2])
                case LineTo:
                        fmt.Fprintf(&sb, "L%g %g", p[i+1], p[i+2])
                case QuadTo:
                        fmt.Fprintf(&sb, "Q%g %g %g %g", p[i+1], p[i+2], p[i+3], p[i+4])
                case CubeTo:
                        fmt.Fprintf(&sb, "C%g %g %g %g %g %g", p[i+1], p[i+2], p[i+3], p[i+4], p[i+5], p[i+6])
                case ArcTo:
                        rot := math32.RadToDeg(p[i+3])
                        large, sweep := ToArcFlags(p[i+4])
                        sLarge := "0"
                        if large {
                                sLarge = "1"
                        }
                        sSweep := "0"
                        if sweep {
                                sSweep = "1"
                        }
                        fmt.Fprintf(&sb, "A%g %g %g %s %s %g %g", p[i+1], p[i+2], rot, sLarge, sSweep, p[i+5], p[i+6])
                case Close:
                        fmt.Fprintf(&sb, "z")
                }
                i += CmdLen(cmd)
        }
        return sb.String()
}

// ToSVG returns a string that represents the path in the SVG path data format with minification.
func (p Path) ToSVG() string {
        if p.Empty() {
                return ""
        }

        sb := strings.Builder{}
        var x, y float32
        for i := 0; i < len(p); {
                cmd := p[i]
                switch cmd {
                case MoveTo:
                        x, y = p[i+1], p[i+2]
                        fmt.Fprintf(&sb, "M%v %v", num(x), num(y))
                case LineTo:
                        xStart, yStart := x, y
                        x, y = p[i+1], p[i+2]
                        if Equal(x, xStart) && Equal(y, yStart) {
                                // nothing
                        } else if Equal(x, xStart) {
                                fmt.Fprintf(&sb, "V%v", num(y))
                        } else if Equal(y, yStart) {
                                fmt.Fprintf(&sb, "H%v", num(x))
                        } else {
                                fmt.Fprintf(&sb, "L%v %v", num(x), num(y))
                        }
                case QuadTo:
                        x, y = p[i+3], p[i+4]
                        fmt.Fprintf(&sb, "Q%v %v %v %v", num(p[i+1]), num(p[i+2]), num(x), num(y))
                case CubeTo:
                        x, y = p[i+5], p[i+6]
                        fmt.Fprintf(&sb, "C%v %v %v %v %v %v", num(p[i+1]), num(p[i+2]), num(p[i+3]), num(p[i+4]), num(x), num(y))
                case ArcTo:
                        rx, ry := p[i+1], p[i+2]
                        rot := math32.RadToDeg(p[i+3])
                        large, sweep := ToArcFlags(p[i+4])
                        x, y = p[i+5], p[i+6]
                        sLarge := "0"
                        if large {
                                sLarge = "1"
                        }
                        sSweep := "0"
                        if sweep {
                                sSweep = "1"
                        }
                        if 90.0 <= rot {
                                rx, ry = ry, rx
                                rot -= 90.0
                        }
                        fmt.Fprintf(&sb, "A%v %v %v %s%s%v %v", num(rx), num(ry), num(rot), sLarge, sSweep, num(p[i+5]), num(p[i+6]))
                case Close:
                        x, y = p[i+1], p[i+2]
                        fmt.Fprintf(&sb, "z")
                }
                i += CmdLen(cmd)
        }
        return sb.String()
}

// ToPS returns a string that represents the path in the PostScript data format.
func (p Path) ToPS() string {
        if p.Empty() {
                return ""
        }

        sb := strings.Builder{}
        var x, y float32
        for i := 0; i < len(p); {
                cmd := p[i]
                switch cmd {
                case MoveTo:
                        x, y = p[i+1], p[i+2]
                        fmt.Fprintf(&sb, " %v %v moveto", dec(x), dec(y))
                case LineTo:
                        x, y = p[i+1], p[i+2]
                        fmt.Fprintf(&sb, " %v %v lineto", dec(x), dec(y))
                case QuadTo, CubeTo:
                        var start, cp1, cp2 math32.Vector2
                        start = math32.Vector2{x, y}
                        if cmd == QuadTo {
                                x, y = p[i+3], p[i+4]
                                cp1, cp2 = QuadraticToCubicBezier(start, math32.Vec2(p[i+1], p[i+2]), math32.Vector2{x, y})
                        } else {
                                cp1 = math32.Vec2(p[i+1], p[i+2])
                                cp2 = math32.Vec2(p[i+3], p[i+4])
                                x, y = p[i+5], p[i+6]
                        }
                        fmt.Fprintf(&sb, " %v %v %v %v %v %v curveto", dec(cp1.X), dec(cp1.Y), dec(cp2.X), dec(cp2.Y), dec(x), dec(y))
                case ArcTo:
                        x0, y0 := x, y
                        rx, ry, phi := p[i+1], p[i+2], p[i+3]
                        large, sweep := ToArcFlags(p[i+4])
                        x, y = p[i+5], p[i+6]

                        cx, cy, theta0, theta1 := EllipseToCenter(x0, y0, rx, ry, phi, large, sweep, x, y)
                        theta0 = math32.RadToDeg(theta0)
                        theta1 = math32.RadToDeg(theta1)
                        rot := math32.RadToDeg(phi)

                        fmt.Fprintf(&sb, " %v %v %v %v %v %v %v ellipse", dec(cx), dec(cy), dec(rx), dec(ry), dec(theta0), dec(theta1), dec(rot))
                        if !sweep {
                                fmt.Fprintf(&sb, "n")
                        }
                case Close:
                        x, y = p[i+1], p[i+2]
                        fmt.Fprintf(&sb, " closepath")
                }
                i += CmdLen(cmd)
        }
        return sb.String()[1:] // remove the first space
}

// ToPDF returns a string that represents the path in the PDF data format.
func (p Path) ToPDF() string {
        if p.Empty() {
                return ""
        }
        p = p.ReplaceArcs()

        sb := strings.Builder{}
        var x, y float32
        for i := 0; i < len(p); {
                cmd := p[i]
                switch cmd {
                case MoveTo:
                        x, y = p[i+1], p[i+2]
                        fmt.Fprintf(&sb, " %v %v m", dec(x), dec(y))
                case LineTo:
                        x, y = p[i+1], p[i+2]
                        fmt.Fprintf(&sb, " %v %v l", dec(x), dec(y))
                case QuadTo, CubeTo:
                        var start, cp1, cp2 math32.Vector2
                        start = math32.Vector2{x, y}
                        if cmd == QuadTo {
                                x, y = p[i+3], p[i+4]
                                cp1, cp2 = QuadraticToCubicBezier(start, math32.Vec2(p[i+1], p[i+2]), math32.Vector2{x, y})
                        } else {
                                cp1 = math32.Vec2(p[i+1], p[i+2])
                                cp2 = math32.Vec2(p[i+3], p[i+4])
                                x, y = p[i+5], p[i+6]
                        }
                        fmt.Fprintf(&sb, " %v %v %v %v %v %v c", dec(cp1.X), dec(cp1.Y), dec(cp2.X), dec(cp2.Y), dec(x), dec(y))
                case ArcTo:
                        panic("arcs should have been replaced")
                case Close:
                        x, y = p[i+1], p[i+2]
                        fmt.Fprintf(&sb, " h")
                }
                i += CmdLen(cmd)
        }
        return sb.String()[1:] // remove the first space
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import (
        "cogentcore.org/core/math32"
)

var (
        // Tolerance is the maximum deviation from the original path in millimeters
        // when e.g. flatting. Used for flattening in the renderers, font decorations,
        // and path intersections.
        Tolerance = float32(0.01)

        // PixelTolerance is the maximum deviation of the rasterized path from
        // the original for flattening purposed in pixels.
        PixelTolerance = float32(0.1)

        //        In C, FLT_EPSILON = 1.19209e-07

        // Epsilon is the smallest number below which we assume the value to be zero.
        // This is to avoid numerical floating point issues.
        Epsilon = float32(1e-7)

        // Precision is the number of significant digits at which floating point
        // value will be printed to output formats.
        Precision = 7

        // Origin is the coordinate system's origin.
        Origin = math32.Vector2{0.0, 0.0}
)

// Equal returns true if a and b are equal within an absolute
// tolerance of Epsilon.
func Equal(a, b float32) bool {
        // avoid math32.Abs
        if a < b {
                return b-a <= Epsilon
        }
        return a-b <= Epsilon
}

func EqualPoint(a, b math32.Vector2) bool {
        return Equal(a.X, b.X) && Equal(a.Y, b.Y)
}

// AngleEqual returns true if both angles are equal.
func AngleEqual(a, b float32) bool {
        return IsAngleBetween(a, b, b) // IsAngleBetween will add Epsilon to lower and upper
}

// AngleNorm returns the angle theta in the range [0,2PI).
func AngleNorm(theta float32) float32 {
        theta = math32.Mod(theta, 2.0*math32.Pi)
        if theta < 0.0 {
                theta += 2.0 * math32.Pi
        }
        return theta
}

// IsAngleBetween is true when theta is in range [lower,upper]
// including the end points. Angles can be outside the [0,2PI) range.
func IsAngleBetween(theta, lower, upper float32) bool {
        if upper < lower {
                // sweep is false, ie direction is along negative angle (clockwise)
                lower, upper = upper, lower
        }
        theta = AngleNorm(theta - lower + Epsilon)
        upper = AngleNorm(upper - lower + 2.0*Epsilon)
        return theta <= upper
}

// Slope returns the slope between OP, i.e. y/x.
func Slope(p math32.Vector2) float32 {
        return p.Y / p.X
}

// Angle returns the angle in radians [0,2PI) between the x-axis and OP.
func Angle(p math32.Vector2) float32 {
        return AngleNorm(math32.Atan2(p.Y, p.X))
}

// todo: use this for our AngleTo

// AngleBetween returns the angle between OP and OQ.
func AngleBetween(p, q math32.Vector2) float32 {
        return math32.Atan2(p.Cross(q), p.Dot(q))
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/minify
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import "github.com/tdewolff/parse/v2/strconv"

// MaxInt is the maximum value of int.
const MaxInt = int(^uint(0) >> 1)

// MinInt is the minimum value of int.
const MinInt = -MaxInt - 1

// MinifyDecimal minifies a given byte slice containing a decimal and removes superfluous characters. It differs from Number in that it does not parse exponents.
// It does not parse or output exponents. prec is the number of significant digits. When prec is zero it will keep all digits. Only digits after the dot can be removed to reach the number of significant digits. Very large number may thus have more significant digits.
func MinifyDecimal(num []byte, prec int) []byte {
        if len(num) <= 1 {
                return num
        }

        // omit first + and register mantissa start and end, whether it's negative and the exponent
        neg := false
        start := 0
        dot := -1
        end := len(num)
        if 0 < end && (num[0] == '+' || num[0] == '-') {
                if num[0] == '-' {
                        neg = true
                }
                start++
        }
        for i, c := range num[start:] {
                if c == '.' {
                        dot = start + i
                        break
                }
        }
        if dot == -1 {
                dot = end
        }

        // trim leading zeros but leave at least one digit
        for start < end-1 && num[start] == '0' {
                start++
        }
        // trim trailing zeros
        i := end - 1
        for ; dot < i; i-- {
                if num[i] != '0' {
                        end = i + 1
                        break
                }
        }
        if i == dot {
                end = dot
                if start == end {
                        num[start] = '0'
                        return num[start : start+1]
                }
        } else if start == end-1 && num[start] == '0' {
                return num[start:end]
        }

        // apply precision
        if 0 < prec && dot <= start+prec {
                precEnd := start + prec + 1 // include dot
                if dot == start {           // for numbers like .012
                        digit := start + 1
                        for digit < end && num[digit] == '0' {
                                digit++
                        }
                        precEnd = digit + prec
                }
                if precEnd < end {
                        end = precEnd

                        // process either an increase from a lesser significant decimal (>= 5)
                        // or remove trailing zeros after the dot, or both
                        i := end - 1
                        inc := '5' <= num[end]
                        for ; start < i; i-- {
                                if i == dot {
                                        // no-op
                                } else if inc && num[i] != '9' {
                                        num[i]++
                                        inc = false
                                        break
                                } else if inc && i < dot { // end inc for integer
                                        num[i] = '0'
                                } else if !inc && (i < dot || num[i] != '0') {
                                        break
                                }
                        }
                        if i < dot {
                                end = dot
                        } else {
                                end = i + 1
                        }

                        if inc {
                                if dot == start && end == start+1 {
                                        num[start] = '1'
                                } else if num[start] == '9' {
                                        num[start] = '1'
                                        num[start+1] = '0'
                                        end++
                                } else {
                                        num[start]++
                                }
                        }
                }
        }

        if neg {
                start--
                num[start] = '-'
        }
        return num[start:end]
}

// MinifyNumber minifies a given byte slice containing a number and removes superfluous characters.
func MinifyNumber(num []byte, prec int) []byte {
        if len(num) <= 1 {
                return num
        }

        // omit first + and register mantissa start and end, whether it's negative and the exponent
        neg := false
        start := 0
        dot := -1
        end := len(num)
        origExp := 0
        if num[0] == '+' || num[0] == '-' {
                if num[0] == '-' {
                        neg = true
                }
                start++
        }
        for i, c := range num[start:] {
                if c == '.' {
                        dot = start + i
                } else if c == 'e' || c == 'E' {
                        end = start + i
                        i += start + 1
                        if i < len(num) && num[i] == '+' {
                                i++
                        }
                        if tmpOrigExp, n := strconv.ParseInt(num[i:]); 0 < n && int64(MinInt) <= tmpOrigExp && tmpOrigExp <= int64(MaxInt) {
                                // range checks for when int is 32 bit
                                origExp = int(tmpOrigExp)
                        } else {
                                return num
                        }
                        break
                }
        }
        if dot == -1 {
                dot = end
        }

        // trim leading zeros but leave at least one digit
        for start < end-1 && num[start] == '0' {
                start++
        }
        // trim trailing zeros
        i := end - 1
        for ; dot < i; i-- {
                if num[i] != '0' {
                        end = i + 1
                        break
                }
        }
        if i == dot {
                end = dot
                if start == end {
                        num[start] = '0'
                        return num[start : start+1]
                }
        } else if start == end-1 && num[start] == '0' {
                return num[start:end]
        }

        // apply precision
        if 0 < prec { //&& (dot <= start+prec || start+prec+1 < dot || 0 < origExp) { // don't minify 9 to 10, but do 999 to 1e3 and 99e1 to 1e3
                precEnd := start + prec
                if dot == start { // for numbers like .012
                        digit := start + 1
                        for digit < end && num[digit] == '0' {
                                digit++
                        }
                        precEnd = digit + prec
                } else if dot < precEnd { // for numbers where precision will include the dot
                        precEnd++
                }
                if precEnd < end && (dot < end || 1 < dot-precEnd+origExp) { // do not minify 9=>10 or 99=>100 or 9e1=>1e2 (but 90), but 999=>1e3 and 99e1=>1e3
                        end = precEnd
                        inc := '5' <= num[end]
                        if dot == end {
                                inc = end+1 < len(num) && '5' <= num[end+1]
                        }
                        if precEnd < dot {
                                origExp += dot - precEnd
                                dot = precEnd
                        }
                        // process either an increase from a lesser significant decimal (>= 5)
                        // and remove trailing zeros
                        i := end - 1
                        for ; start < i; i-- {
                                if i == dot {
                                        // no-op
                                } else if inc && num[i] != '9' {
                                        num[i]++
                                        inc = false
                                        break
                                } else if !inc && num[i] != '0' {
                                        break
                                }
                        }
                        end = i + 1
                        if end < dot {
                                origExp += dot - end
                                dot = end
                        }
                        if inc { // single digit left
                                if dot == start {
                                        num[start] = '1'
                                        dot = start + 1
                                } else if num[start] == '9' {
                                        num[start] = '1'
                                        origExp++
                                } else {
                                        num[start]++
                                }
                        }
                }
        }

        // n is the number of significant digits
        // normExp would be the exponent if it were normalised (0.1 <= f < 1)
        n := 0
        normExp := 0
        if dot == start {
                for i = dot + 1; i < end; i++ {
                        if num[i] != '0' {
                                n = end - i
                                normExp = dot - i + 1
                                break
                        }
                }
        } else if dot == end {
                normExp = end - start
                for i = end - 1; start <= i; i-- {
                        if num[i] != '0' {
                                n = i + 1 - start
                                end = i + 1
                                break
                        }
                }
        } else {
                n = end - start - 1
                normExp = dot - start
        }

        if origExp < 0 && (normExp < MinInt-origExp || normExp-n < MinInt-origExp) || 0 < origExp && (MaxInt-origExp < normExp || MaxInt-origExp < normExp-n) {
                return num // exponent overflow
        }
        normExp += origExp

        // intExp would be the exponent if it were an integer
        intExp := normExp - n
        lenIntExp := strconv.LenInt(int64(intExp))
        lenNormExp := strconv.LenInt(int64(normExp))

        // there are three cases to consider when printing the number
        // case 1: without decimals and with a positive exponent (large numbers: 5e4)
        // case 2: with decimals and with a negative exponent (small numbers with many digits: .123456e-4)
        // case 3: with decimals and without an exponent (around zero: 5.6)
        // case 4: without decimals and with a negative exponent (small numbers: 123456e-9)
        if n <= normExp {
                // case 1: print number with positive exponent
                if dot < end {
                        // remove dot, either from the front or copy the smallest part
                        if dot == start {
                                start = end - n
                        } else if dot-start < end-dot-1 {
                                copy(num[start+1:], num[start:dot])
                                start++
                        } else {
                                copy(num[dot:], num[dot+1:end])
                                end--
                        }
                }
                if n+3 <= normExp {
                        num[end] = 'e'
                        end++
                        for i := end + lenIntExp - 1; end <= i; i-- {
                                num[i] = byte(intExp%10) + '0'
                                intExp /= 10
                        }
                        end += lenIntExp
                } else if n+2 == normExp {
                        num[end] = '0'
                        num[end+1] = '0'
                        end += 2
                } else if n+1 == normExp {
                        num[end] = '0'
                        end++
                }
        } else if normExp < -3 && lenNormExp < lenIntExp && dot < end {
                // case 2: print normalized number (0.1 <= f < 1)
                zeroes := -normExp + origExp
                if 0 < zeroes {
                        copy(num[start+1:], num[start+1+zeroes:end])
                        end -= zeroes
                } else if zeroes < 0 {
                        copy(num[start+1:], num[start:dot])
                        num[start] = '.'
                }
                num[end] = 'e'
                num[end+1] = '-'
                end += 2
                for i := end + lenNormExp - 1; end <= i; i-- {
                        num[i] = -byte(normExp%10) + '0'
                        normExp /= 10
                }
                end += lenNormExp
        } else if -lenIntExp-1 <= normExp {
                // case 3: print number without exponent
                zeroes := -normExp
                if 0 < zeroes {
                        // dot placed at the front and negative exponent, adding zeroes
                        newDot := end - n - zeroes - 1
                        if newDot != dot {
                                d := start - newDot
                                if 0 < d {
                                        if dot < end {
                                                // copy original digits after the dot towards the end
                                                copy(num[dot+1+d:], num[dot+1:end])
                                                if start < dot {
                                                        // copy original digits before the dot towards the end
                                                        copy(num[start+d+1:], num[start:dot])
                                                }
                                        } else if start < dot {
                                                // copy original digits before the dot towards the end
                                                copy(num[start+d:], num[start:dot])
                                        }
                                        newDot = start
                                        end += d
                                } else {
                                        start += -d
                                }
                                num[newDot] = '.'
                                for i := 0; i < zeroes; i++ {
                                        num[newDot+1+i] = '0'
                                }
                        }
                } else {
                        // dot placed in the middle of the number
                        if dot == start {
                                // when there are zeroes after the dot
                                dot = end - n - 1
                                start = dot
                        } else if end <= dot {
                                // when input has no dot in it
                                dot = end
                                end++
                        }
                        newDot := start + normExp
                        // move digits between dot and newDot towards the end
                        if dot < newDot {
                                copy(num[dot:], num[dot+1:newDot+1])
                        } else if newDot < dot {
                                copy(num[newDot+1:], num[newDot:dot])
                        }
                        num[newDot] = '.'
                }
        } else {
                // case 4: print number with negative exponent
                // find new end, considering moving numbers to the front, removing the dot and increasing the length of the exponent
                newEnd := end
                if dot == start {
                        newEnd = start + n
                } else {
                        newEnd--
                }
                newEnd += 2 + lenIntExp

                exp := intExp
                lenExp := lenIntExp
                if newEnd < len(num) {
                        // it saves space to convert the decimal to an integer and decrease the exponent
                        if dot < end {
                                if dot == start {
                                        copy(num[start:], num[end-n:end])
                                        end = start + n
                                } else {
                                        copy(num[dot:], num[dot+1:end])
                                        end--
                                }
                        }
                } else {
                        // it does not save space and will panic, so we revert to the original representation
                        exp = origExp
                        lenExp = 1
                        if origExp <= -10 || 10 <= origExp {
                                lenExp = strconv.LenInt(int64(origExp))
                        }
                }
                num[end] = 'e'
                num[end+1] = '-'
                end += 2
                for i := end + lenExp - 1; end <= i; i-- {
                        num[i] = -byte(exp%10) + '0'
                        exp /= 10
                }
                end += lenExp
        }

        if neg {
                start--
                num[start] = '-'
        }
        return num[start:end]
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import (
        "bytes"
        "encoding/gob"
        "slices"

        "cogentcore.org/core/math32"
)

// ArcToCubeImmediate causes ArcTo commands to be immediately converted into
// corresponding CubeTo commands, instead of doing this later.
// This is faster than using [Path.ReplaceArcs], but when rendering to SVG
// it might be better to turn this off in order to preserve the logical structure
// of the arcs in the SVG output.
var ArcToCubeImmediate = true

// Path is a collection of MoveTo, LineTo, QuadTo, CubeTo, ArcTo, and Close
// commands, each followed the float32 coordinate data for it.
// To enable support bidirectional processing, the command verb is also added
// to the end of the coordinate data as well.
// The last two coordinate values are the end point position of the pen after
// the action (x,y).
// QuadTo defines one control point (x,y) in between.
// CubeTo defines two control points.
// ArcTo defines (rx,ry,phi,large+sweep) i.e. the radius in x and y,
// its rotation (in radians) and the large and sweep booleans in one float32.
// While ArcTo can be converted to CubeTo, it is useful for the path intersection
// computation.
// Only valid commands are appended, so that LineTo has a non-zero length,
// QuadTo's and CubeTo's control point(s) don't (both) overlap with the start
// and end point.
type Path []float32

func New() *Path {
        return &Path{}
}

// Commands
const (
        MoveTo float32 = 0
        LineTo float32 = 1
        QuadTo float32 = 2
        CubeTo float32 = 3
        ArcTo  float32 = 4
        Close  float32 = 5
)

var cmdLens = [6]int{4, 4, 6, 8, 8, 4}

// CmdLen returns the overall length of the command, including
// the command op itself.
func CmdLen(cmd float32) int {
        return cmdLens[int(cmd)]
}

// ToArcFlags converts to the largeArc and sweep boolean flags given its value in the path.
func ToArcFlags(cmd float32) (bool, bool) {
        large := (cmd == 1.0 || cmd == 3.0)
        sweep := (cmd == 2.0 || cmd == 3.0)
        return large, sweep
}

// fromArcFlags converts the largeArc and sweep boolean flags to a value stored in the path.
func fromArcFlags(large, sweep bool) float32 {
        f := float32(0.0)
        if large {
                f += 1.0
        }
        if sweep {
                f += 2.0
        }
        return f
}

// Paths is a collection of Path elements.
type Paths []Path

// Empty returns true if the set of paths is empty.
func (ps Paths) Empty() bool {
        for _, p := range ps {
                if !p.Empty() {
                        return false
                }
        }
        return true
}

// Reset clears the path but retains the same memory.
// This can be used in loops where you append and process
// paths every iteration, and avoid new memory allocations.
func (p *Path) Reset() {
        *p = (*p)[:0]
}

// GobEncode implements the gob interface.
func (p Path) GobEncode() ([]byte, error) {
        b := bytes.Buffer{}
        enc := gob.NewEncoder(&b)
        if err := enc.Encode(p); err != nil {
                return nil, err
        }
        return b.Bytes(), nil
}

// GobDecode implements the gob interface.
func (p *Path) GobDecode(b []byte) error {
        dec := gob.NewDecoder(bytes.NewReader(b))
        return dec.Decode(p)
}

// Empty returns true if p is an empty path or consists of only MoveTos and Closes.
func (p Path) Empty() bool {
        return len(p) <= CmdLen(MoveTo)
}

// Equals returns true if p and q are equal within tolerance Epsilon.
func (p Path) Equals(q Path) bool {
        if len(p) != len(q) {
                return false
        }
        for i := 0; i < len(p); i++ {
                if !Equal(p[i], q[i]) {
                        return false
                }
        }
        return true
}

// Sane returns true if the path is sane, ie. it does not have NaN or infinity values.
func (p Path) Sane() bool {
        sane := func(x float32) bool {
                return !math32.IsNaN(x) && !math32.IsInf(x, 0.0)
        }
        for i := 0; i < len(p); {
                cmd := p[i]
                i += CmdLen(cmd)

                if !sane(p[i-3]) || !sane(p[i-2]) {
                        return false
                }
                switch cmd {
                case QuadTo:
                        if !sane(p[i-5]) || !sane(p[i-4]) {
                                return false
                        }
                case CubeTo, ArcTo:
                        if !sane(p[i-7]) || !sane(p[i-6]) || !sane(p[i-5]) || !sane(p[i-4]) {
                                return false
                        }
                }
        }
        return true
}

// Same returns true if p and q are equal shapes within tolerance Epsilon.
// Path q may start at an offset into path p or may be in the reverse direction.
func (p Path) Same(q Path) bool {
        // TODO: improve, does not handle subpaths or Close vs LineTo
        if len(p) != len(q) {
                return false
        }
        qr := q.Reverse() // TODO: can we do without?
        for j := 0; j < len(q); {
                equal := true
                for i := 0; i < len(p); i++ {
                        if !Equal(p[i], q[(j+i)%len(q)]) {
                                equal = false
                                break
                        }
                }
                if equal {
                        return true
                }

                // backwards
                equal = true
                for i := 0; i < len(p); i++ {
                        if !Equal(p[i], qr[(j+i)%len(qr)]) {
                                equal = false
                                break
                        }
                }
                if equal {
                        return true
                }
                j += CmdLen(q[j])
        }
        return false
}

// Closed returns true if the last subpath of p is a closed path.
func (p Path) Closed() bool {
        return 0 < len(p) && p[len(p)-1] == Close
}

// PointClosed returns true if the last subpath of p is a closed path
// and the close command is a point and not a line.
func (p Path) PointClosed() bool {
        return 6 < len(p) && p[len(p)-1] == Close && Equal(p[len(p)-7], p[len(p)-3]) && Equal(p[len(p)-6], p[len(p)-2])
}

// HasSubpaths returns true when path p has subpaths.
// TODO: naming right? A simple path would not self-intersect.
// Add IsXMonotone and IsFlat as well?
func (p Path) HasSubpaths() bool {
        for i := 0; i < len(p); {
                if p[i] == MoveTo && i != 0 {
                        return true
                }
                i += CmdLen(p[i])
        }
        return false
}

// Clone returns a copy of p.
func (p Path) Clone() Path {
        return slices.Clone(p)
}

// CopyTo returns a copy of p, using the memory of path q.
func (p Path) CopyTo(q Path) Path {
        if q == nil || len(q) < len(p) {
                q = make(Path, len(p))
        } else {
                q = q[:len(p)]
        }
        copy(q, p)
        return q
}

// Len returns the number of commands in the path.
func (p Path) Len() int {
        n := 0
        for i := 0; i < len(p); {
                i += CmdLen(p[i])
                n++
        }
        return n
}

// Append appends path q to p and returns the extended path p.
func (p Path) Append(qs ...Path) Path {
        if p.Empty() {
                p = Path{}
        }
        for _, q := range qs {
                if !q.Empty() {
                        p = append(p, q...)
                }
        }
        return p
}

// Join joins path q to p and returns the extended path p
// (or q if p is empty). It's like executing the commands
// in q to p in sequence, where if the first MoveTo of q
// doesn't coincide with p, or if p ends in Close,
// it will fallback to appending the paths.
func (p Path) Join(q Path) Path {
        if q.Empty() {
                return p
        } else if p.Empty() {
                return q
        }

        if p[len(p)-1] == Close || !Equal(p[len(p)-3], q[1]) || !Equal(p[len(p)-2], q[2]) {
                return append(p, q...)
        }

        d := q[CmdLen(MoveTo):]

        // add the first command through the command functions to use the optimization features
        // q is not empty, so starts with a MoveTo followed by other commands
        cmd := d[0]
        switch cmd {
        case MoveTo:
                p.MoveTo(d[1], d[2])
        case LineTo:
                p.LineTo(d[1], d[2])
        case QuadTo:
                p.QuadTo(d[1], d[2], d[3], d[4])
        case CubeTo:
                p.CubeTo(d[1], d[2], d[3], d[4], d[5], d[6])
        case ArcTo:
                large, sweep := ToArcFlags(d[4])
                p.ArcTo(d[1], d[2], d[3], large, sweep, d[5], d[6])
        case Close:
                p.Close()
        }

        i := len(p)
        end := p.StartPos()
        p = append(p, d[CmdLen(cmd):]...)

        // repair close commands
        for i < len(p) {
                cmd := p[i]
                if cmd == MoveTo {
                        break
                } else if cmd == Close {
                        p[i+1] = end.X
                        p[i+2] = end.Y
                        break
                }
                i += CmdLen(cmd)
        }
        return p

}

// Pos returns the current position of the path,
// which is the end point of the last command.
func (p Path) Pos() math32.Vector2 {
        if 0 < len(p) {
                return math32.Vec2(p[len(p)-3], p[len(p)-2])
        }
        return math32.Vector2{}
}

// StartPos returns the start point of the current subpath,
// i.e. it returns the position of the last MoveTo command.
func (p Path) StartPos() math32.Vector2 {
        for i := len(p); 0 < i; {
                cmd := p[i-1]
                if cmd == MoveTo {
                        return math32.Vec2(p[i-3], p[i-2])
                }
                i -= CmdLen(cmd)
        }
        return math32.Vector2{}
}

// Coords returns all the coordinates of the segment
// start/end points. It omits zero-length Closes.
func (p Path) Coords() []math32.Vector2 {
        coords := []math32.Vector2{}
        for i := 0; i < len(p); {
                cmd := p[i]
                i += CmdLen(cmd)
                if len(coords) == 0 || cmd != Close || !EqualPoint(coords[len(coords)-1], math32.Vec2(p[i-3], p[i-2])) {
                        coords = append(coords, math32.Vec2(p[i-3], p[i-2]))
                }
        }
        return coords
}

/////// Accessors

// EndPoint returns the end point for MoveTo, LineTo, and Close commands,
// where the command is at index i.
func (p Path) EndPoint(i int) math32.Vector2 {
        return math32.Vec2(p[i+1], p[i+2])
}

// QuadToPoints returns the control point and end for QuadTo command,
// where the command is at index i.
func (p Path) QuadToPoints(i int) (cp, end math32.Vector2) {
        return math32.Vec2(p[i+1], p[i+2]), math32.Vec2(p[i+3], p[i+4])
}

// CubeToPoints returns the cp1, cp2, and end for CubeTo command,
// where the command is at index i.
func (p Path) CubeToPoints(i int) (cp1, cp2, end math32.Vector2) {
        return math32.Vec2(p[i+1], p[i+2]), math32.Vec2(p[i+3], p[i+4]), math32.Vec2(p[i+5], p[i+6])
}

// ArcToPoints returns the rx, ry, phi, large, sweep values for ArcTo command,
// where the command is at index i.
func (p Path) ArcToPoints(i int) (rx, ry, phi float32, large, sweep bool, end math32.Vector2) {
        rx = p[i+1]
        ry = p[i+2]
        phi = p[i+3]
        large, sweep = ToArcFlags(p[i+4])
        end = math32.Vec2(p[i+5], p[i+6])
        return
}

/////// Constructors

// MoveTo moves the path to (x,y) without connecting the path.
// It starts a new independent subpath. Multiple subpaths can be useful
// when negating parts of a previous path by overlapping it with a path
// in the opposite direction. The behaviour for overlapping paths depends
// on the FillRules.
func (p *Path) MoveTo(x, y float32) {
        if 0 < len(*p) && (*p)[len(*p)-1] == MoveTo {
                (*p)[len(*p)-3] = x
                (*p)[len(*p)-2] = y
                return
        }
        *p = append(*p, MoveTo, x, y, MoveTo)
}

// LineTo adds a linear path to (x,y).
func (p *Path) LineTo(x, y float32) {
        start := p.Pos()
        end := math32.Vector2{x, y}
        if EqualPoint(start, end) {
                return
        } else if CmdLen(LineTo) <= len(*p) && (*p)[len(*p)-1] == LineTo {
                prevStart := math32.Vector2{}
                if CmdLen(LineTo) < len(*p) {
                        prevStart = math32.Vec2((*p)[len(*p)-CmdLen(LineTo)-3], (*p)[len(*p)-CmdLen(LineTo)-2])
                }

                // divide by length^2 since otherwise the perpdot between very small segments may be
                // below Epsilon
                da := start.Sub(prevStart)
                db := end.Sub(start)
                div := da.Cross(db)
                if length := da.Length() * db.Length(); Equal(div/length, 0.0) {
                        // lines are parallel
                        extends := false
                        if da.Y < da.X {
                                extends = math32.Signbit(da.X) == math32.Signbit(db.X)
                        } else {
                                extends = math32.Signbit(da.Y) == math32.Signbit(db.Y)
                        }
                        if extends {
                                //if Equal(end.Sub(start).AngleBetween(start.Sub(prevStart)), 0.0) {
                                (*p)[len(*p)-3] = x
                                (*p)[len(*p)-2] = y
                                return
                        }
                }
        }

        if len(*p) == 0 {
                p.MoveTo(0.0, 0.0)
        } else if (*p)[len(*p)-1] == Close {
                p.MoveTo((*p)[len(*p)-3], (*p)[len(*p)-2])
        }
        *p = append(*p, LineTo, end.X, end.Y, LineTo)
}

// QuadTo adds a quadratic Bézier path with control point (cpx,cpy) and end point (x,y).
func (p *Path) QuadTo(cpx, cpy, x, y float32) {
        start := p.Pos()
        cp := math32.Vector2{cpx, cpy}
        end := math32.Vector2{x, y}
        if EqualPoint(start, end) && EqualPoint(start, cp) {
                return
        } else if !EqualPoint(start, end) && (EqualPoint(start, cp) || AngleEqual(AngleBetween(end.Sub(start), cp.Sub(start)), 0.0)) && (EqualPoint(end, cp) || AngleEqual(AngleBetween(end.Sub(start), end.Sub(cp)), 0.0)) {
                p.LineTo(end.X, end.Y)
                return
        }

        if len(*p) == 0 {
                p.MoveTo(0.0, 0.0)
        } else if (*p)[len(*p)-1] == Close {
                p.MoveTo((*p)[len(*p)-3], (*p)[len(*p)-2])
        }
        *p = append(*p, QuadTo, cp.X, cp.Y, end.X, end.Y, QuadTo)
}

// CubeTo adds a cubic Bézier path with control points
// (cpx1,cpy1) and (cpx2,cpy2) and end point (x,y).
func (p *Path) CubeTo(cpx1, cpy1, cpx2, cpy2, x, y float32) {
        start := p.Pos()
        cp1 := math32.Vector2{cpx1, cpy1}
        cp2 := math32.Vector2{cpx2, cpy2}
        end := math32.Vector2{x, y}
        if EqualPoint(start, end) && EqualPoint(start, cp1) && EqualPoint(start, cp2) {
                return
        } else if !EqualPoint(start, end) && (EqualPoint(start, cp1) || EqualPoint(end, cp1) || AngleEqual(AngleBetween(end.Sub(start), cp1.Sub(start)), 0.0) && AngleEqual(AngleBetween(end.Sub(start), end.Sub(cp1)), 0.0)) && (EqualPoint(start, cp2) || EqualPoint(end, cp2) || AngleEqual(AngleBetween(end.Sub(start), cp2.Sub(start)), 0.0) && AngleEqual(AngleBetween(end.Sub(start), end.Sub(cp2)), 0.0)) {
                p.LineTo(end.X, end.Y)
                return
        }

        if len(*p) == 0 {
                p.MoveTo(0.0, 0.0)
        } else if (*p)[len(*p)-1] == Close {
                p.MoveTo((*p)[len(*p)-3], (*p)[len(*p)-2])
        }
        *p = append(*p, CubeTo, cp1.X, cp1.Y, cp2.X, cp2.Y, end.X, end.Y, CubeTo)
}

// ArcTo adds an arc with radii rx and ry, with rot the counter clockwise
// rotation with respect to the coordinate system in radians, large and sweep booleans
// (see https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Arcs),
// and (x,y) the end position of the pen. The start position of the pen was
// given by a previous command's end point.
func (p *Path) ArcTo(rx, ry, rot float32, large, sweep bool, x, y float32) {
        start := p.Pos()
        end := math32.Vector2{x, y}
        if EqualPoint(start, end) {
                return
        }
        if Equal(rx, 0.0) || math32.IsInf(rx, 0) || Equal(ry, 0.0) || math32.IsInf(ry, 0) {
                p.LineTo(end.X, end.Y)
                return
        }

        rx = math32.Abs(rx)
        ry = math32.Abs(ry)
        if Equal(rx, ry) {
                rot = 0.0 // circle
        } else if rx < ry {
                rx, ry = ry, rx
                rot += math32.Pi / 2.0
        }

        phi := AngleNorm(rot)
        if math32.Pi <= phi { // phi is canonical within 0 <= phi < 180
                phi -= math32.Pi
        }

        // scale ellipse if rx and ry are too small
        lambda := EllipseRadiiCorrection(start, rx, ry, phi, end)
        if lambda > 1.0 {
                rx *= lambda
                ry *= lambda
        }

        if len(*p) == 0 {
                p.MoveTo(0.0, 0.0)
        } else if (*p)[len(*p)-1] == Close {
                p.MoveTo((*p)[len(*p)-3], (*p)[len(*p)-2])
        }
        if ArcToCubeImmediate {
                for _, bezier := range ellipseToCubicBeziers(start, rx, ry, phi, large, sweep, end) {
                        p.CubeTo(bezier[1].X, bezier[1].Y, bezier[2].X, bezier[2].Y, bezier[3].X, bezier[3].Y)
                }
        } else {
                *p = append(*p, ArcTo, rx, ry, phi, fromArcFlags(large, sweep), end.X, end.Y, ArcTo)
        }
}

// ArcToDeg is a version of [Path.ArcTo] with the angle in degrees instead of radians.
// It adds an arc with radii rx and ry, with rot the counter clockwise
// rotation with respect to the coordinate system in degrees, large and sweep booleans
// (see https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Arcs),
// and (x,y) the end position of the pen. The start position of the pen was
// given by a previous command's end point.
func (p *Path) ArcToDeg(rx, ry, rot float32, large, sweep bool, x, y float32) {
        p.ArcTo(rx, ry, math32.DegToRad(rot), large, sweep, x, y)
}

// Arc adds an elliptical arc with radii rx and ry, with rot the
// counter clockwise rotation in radians, and theta0 and theta1
// the angles in radians of the ellipse (before rot is applies)
// between which the arc will run. If theta0 < theta1,
// the arc will run in a CCW direction. If the difference between
// theta0 and theta1 is bigger than 360 degrees, one full circle
// will be drawn and the remaining part of diff % 360,
// e.g. a difference of 810 degrees will draw one full circle
// and an arc over 90 degrees.
func (p *Path) Arc(rx, ry, phi, theta0, theta1 float32) {
        dtheta := math32.Abs(theta1 - theta0)

        sweep := theta0 < theta1
        large := math32.Mod(dtheta, 2.0*math32.Pi) > math32.Pi
        p0 := EllipsePos(rx, ry, phi, 0.0, 0.0, theta0)
        p1 := EllipsePos(rx, ry, phi, 0.0, 0.0, theta1)

        start := p.Pos()
        center := start.Sub(p0)
        if dtheta >= 2.0*math32.Pi {
                startOpposite := center.Sub(p0)
                p.ArcTo(rx, ry, phi, large, sweep, startOpposite.X, startOpposite.Y)
                p.ArcTo(rx, ry, phi, large, sweep, start.X, start.Y)
                if Equal(math32.Mod(dtheta, 2.0*math32.Pi), 0.0) {
                        return
                }
        }
        end := center.Add(p1)
        p.ArcTo(rx, ry, phi, large, sweep, end.X, end.Y)
}

// ArcDeg is a version of [Path.Arc] that uses degrees instead of radians,
// to add an elliptical arc with radii rx and ry, with rot the
// counter clockwise rotation in degrees, and theta0 and theta1
// the angles in degrees of the ellipse (before rot is applied)
// between which the arc will run.
func (p *Path) ArcDeg(rx, ry, rot, theta0, theta1 float32) {
        p.Arc(rx, ry, math32.DegToRad(rot), math32.DegToRad(theta0), math32.DegToRad(theta1))
}

// Close closes a (sub)path with a LineTo to the start of the path
// (the most recent MoveTo command). It also signals the path closes
// as opposed to being just a LineTo command, which can be significant
// for stroking purposes for example.
func (p *Path) Close() {
        if len(*p) == 0 || (*p)[len(*p)-1] == Close {
                // already closed or empty
                return
        } else if (*p)[len(*p)-1] == MoveTo {
                // remove MoveTo + Close
                *p = (*p)[:len(*p)-CmdLen(MoveTo)]
                return
        }

        end := p.StartPos()
        if (*p)[len(*p)-1] == LineTo && Equal((*p)[len(*p)-3], end.X) && Equal((*p)[len(*p)-2], end.Y) {
                // replace LineTo by Close if equal
                (*p)[len(*p)-1] = Close
                (*p)[len(*p)-CmdLen(LineTo)] = Close
                return
        } else if (*p)[len(*p)-1] == LineTo {
                // replace LineTo by Close if equidirectional extension
                start := math32.Vec2((*p)[len(*p)-3], (*p)[len(*p)-2])
                prevStart := math32.Vector2{}
                if CmdLen(LineTo) < len(*p) {
                        prevStart = math32.Vec2((*p)[len(*p)-CmdLen(LineTo)-3], (*p)[len(*p)-CmdLen(LineTo)-2])
                }
                if Equal(AngleBetween(end.Sub(start), start.Sub(prevStart)), 0.0) {
                        (*p)[len(*p)-CmdLen(LineTo)] = Close
                        (*p)[len(*p)-3] = end.X
                        (*p)[len(*p)-2] = end.Y
                        (*p)[len(*p)-1] = Close
                        return
                }
        }
        *p = append(*p, Close, end.X, end.Y, Close)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import (
        "cogentcore.org/core/math32"
)

// Scanner returns a path scanner.
func (p Path) Scanner() *Scanner {
        return &Scanner{p, -1}
}

// ReverseScanner returns a path scanner in reverse order.
func (p Path) ReverseScanner() ReverseScanner {
        return ReverseScanner{p, len(p)}
}

// Scanner scans the path.
type Scanner struct {
        p Path
        i int
}

// Scan scans a new path segment and should be called before the other methods.
func (s *Scanner) Scan() bool {
        if s.i+1 < len(s.p) {
                s.i += CmdLen(s.p[s.i+1])
                return true
        }
        return false
}

// Cmd returns the current path segment command.
func (s *Scanner) Cmd() float32 {
        return s.p[s.i]
}

// Values returns the current path segment values.
func (s *Scanner) Values() []float32 {
        return s.p[s.i-CmdLen(s.p[s.i])+2 : s.i]
}

// Start returns the current path segment start position.
func (s *Scanner) Start() math32.Vector2 {
        i := s.i - CmdLen(s.p[s.i])
        if i == -1 {
                return math32.Vector2{}
        }
        return math32.Vector2{s.p[i-2], s.p[i-1]}
}

// CP1 returns the first control point for quadratic and cubic Béziers.
func (s *Scanner) CP1() math32.Vector2 {
        if s.p[s.i] != QuadTo && s.p[s.i] != CubeTo {
                panic("must be quadratic or cubic Bézier")
        }
        i := s.i - CmdLen(s.p[s.i]) + 1
        return math32.Vector2{s.p[i+1], s.p[i+2]}
}

// CP2 returns the second control point for cubic Béziers.
func (s *Scanner) CP2() math32.Vector2 {
        if s.p[s.i] != CubeTo {
                panic("must be cubic Bézier")
        }
        i := s.i - CmdLen(s.p[s.i]) + 1
        return math32.Vector2{s.p[i+3], s.p[i+4]}
}

// Arc returns the arguments for arcs (rx,ry,rot,large,sweep).
func (s *Scanner) Arc() (float32, float32, float32, bool, bool) {
        if s.p[s.i] != ArcTo {
                panic("must be arc")
        }
        i := s.i - CmdLen(s.p[s.i]) + 1
        large, sweep := ToArcFlags(s.p[i+4])
        return s.p[i+1], s.p[i+2], s.p[i+3], large, sweep
}

// End returns the current path segment end position.
func (s *Scanner) End() math32.Vector2 {
        return math32.Vector2{s.p[s.i-2], s.p[s.i-1]}
}

// Path returns the current path segment.
func (s *Scanner) Path() Path {
        p := Path{}
        p.MoveTo(s.Start().X, s.Start().Y)
        switch s.Cmd() {
        case LineTo:
                p.LineTo(s.End().X, s.End().Y)
        case QuadTo:
                p.QuadTo(s.CP1().X, s.CP1().Y, s.End().X, s.End().Y)
        case CubeTo:
                p.CubeTo(s.CP1().X, s.CP1().Y, s.CP2().X, s.CP2().Y, s.End().X, s.End().Y)
        case ArcTo:
                rx, ry, rot, large, sweep := s.Arc()
                p.ArcTo(rx, ry, rot, large, sweep, s.End().X, s.End().Y)
        }
        return p
}

// ReverseScanner scans the path in reverse order.
type ReverseScanner struct {
        p Path
        i int
}

// Scan scans a new path segment and should be called before the other methods.
func (s *ReverseScanner) Scan() bool {
        if 0 < s.i {
                s.i -= CmdLen(s.p[s.i-1])
                return true
        }
        return false
}

// Cmd returns the current path segment command.
func (s *ReverseScanner) Cmd() float32 {
        return s.p[s.i]
}

// Values returns the current path segment values.
func (s *ReverseScanner) Values() []float32 {
        return s.p[s.i+1 : s.i+CmdLen(s.p[s.i])-1]
}

// Start returns the current path segment start position.
func (s *ReverseScanner) Start() math32.Vector2 {
        if s.i == 0 {
                return math32.Vector2{}
        }
        return math32.Vector2{s.p[s.i-3], s.p[s.i-2]}
}

// CP1 returns the first control point for quadratic and cubic Béziers.
func (s *ReverseScanner) CP1() math32.Vector2 {
        if s.p[s.i] != QuadTo && s.p[s.i] != CubeTo {
                panic("must be quadratic or cubic Bézier")
        }
        return math32.Vector2{s.p[s.i+1], s.p[s.i+2]}
}

// CP2 returns the second control point for cubic Béziers.
func (s *ReverseScanner) CP2() math32.Vector2 {
        if s.p[s.i] != CubeTo {
                panic("must be cubic Bézier")
        }
        return math32.Vector2{s.p[s.i+3], s.p[s.i+4]}
}

// Arc returns the arguments for arcs (rx,ry,rot,large,sweep).
func (s *ReverseScanner) Arc() (float32, float32, float32, bool, bool) {
        if s.p[s.i] != ArcTo {
                panic("must be arc")
        }
        large, sweep := ToArcFlags(s.p[s.i+4])
        return s.p[s.i+1], s.p[s.i+2], s.p[s.i+3], large, sweep
}

// End returns the current path segment end position.
func (s *ReverseScanner) End() math32.Vector2 {
        i := s.i + CmdLen(s.p[s.i])
        return math32.Vector2{s.p[i-3], s.p[i-2]}
}

// Path returns the current path segment.
func (s *ReverseScanner) Path() Path {
        p := Path{}
        p.MoveTo(s.Start().X, s.Start().Y)
        switch s.Cmd() {
        case LineTo:
                p.LineTo(s.End().X, s.End().Y)
        case QuadTo:
                p.QuadTo(s.CP1().X, s.CP1().Y, s.End().X, s.End().Y)
        case CubeTo:
                p.CubeTo(s.CP1().X, s.CP1().Y, s.CP2().X, s.CP2().Y, s.End().X, s.End().Y)
        case ArcTo:
                rx, ry, rot, large, sweep := s.Arc()
                p.ArcTo(rx, ry, rot, large, sweep, s.End().X, s.End().Y)
        }
        return p
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/sides"
)

// Line adds a line segment of from (x1,y1) to (x2,y2).
func (p *Path) Line(x1, y1, x2, y2 float32) *Path {
        if Equal(x1, x2) && Equal(y1, y2) {
                return p
        }
        p.MoveTo(x1, y1)
        p.LineTo(x2, y2)
        return p
}

// Polyline adds multiple connected lines, with no final Close.
func (p *Path) Polyline(points ...math32.Vector2) *Path {
        sz := len(points)
        if sz < 2 {
                return p
        }
        p.MoveTo(points[0].X, points[0].Y)
        for i := 1; i < sz; i++ {
                p.LineTo(points[i].X, points[i].Y)
        }
        return p
}

// Polygon adds multiple connected lines with a final Close.
func (p *Path) Polygon(points ...math32.Vector2) *Path {
        p.Polyline(points...)
        p.Close()
        return p
}

// Rectangle adds a rectangle of width w and height h.
func (p *Path) Rectangle(x, y, w, h float32) *Path {
        if Equal(w, 0.0) || Equal(h, 0.0) {
                return p
        }
        p.MoveTo(x, y)
        p.LineTo(x+w, y)
        p.LineTo(x+w, y+h)
        p.LineTo(x, y+h)
        p.Close()
        return p
}

// RoundedRectangle adds a rectangle of width w and height h
// with rounded corners of radius r. A negative radius will cast
// the corners inwards (i.e. concave).
func (p *Path) RoundedRectangle(x, y, w, h, r float32) *Path {
        if Equal(w, 0.0) || Equal(h, 0.0) {
                return p
        } else if Equal(r, 0.0) {
                return p.Rectangle(x, y, w, h)
        }

        sweep := true
        if r < 0.0 {
                sweep = false
                r = -r
        }
        r = math32.Min(r, w/2.0)
        r = math32.Min(r, h/2.0)

        p.MoveTo(x, y+r)
        p.ArcTo(r, r, 0.0, false, sweep, x+r, y)
        p.LineTo(x+w-r, y)
        p.ArcTo(r, r, 0.0, false, sweep, x+w, y+r)
        p.LineTo(x+w, y+h-r)
        p.ArcTo(r, r, 0.0, false, sweep, x+w-r, y+h)
        p.LineTo(x+r, y+h)
        p.ArcTo(r, r, 0.0, false, sweep, x, y+h-r)
        p.Close()
        return p
}

// RoundedRectangleSides draws a standard rounded rectangle
// with a consistent border and with the given x and y position,
// width and height, and border radius for each corner.
// This version uses the Arc elliptical arc function.
func (p *Path) RoundedRectangleSides(x, y, w, h float32, r sides.Floats) *Path {
        // clamp border radius values
        min := math32.Min(w/2, h/2)
        r.Top = math32.Clamp(r.Top, 0, min)
        r.Right = math32.Clamp(r.Right, 0, min)
        r.Bottom = math32.Clamp(r.Bottom, 0, min)
        r.Left = math32.Clamp(r.Left, 0, min)

        // position values; some variables are missing because they are unused
        var (
                xtl, ytl   = x, y                 // top left
                xtli, ytli = x + r.Top, y + r.Top // top left inset

                ytr        = y                            // top right
                xtri, ytri = x + w - r.Right, y + r.Right // top right inset

                xbr        = x + w                              // bottom right
                xbri, ybri = x + w - r.Bottom, y + h - r.Bottom // bottom right inset

                ybl        = y + h                      // bottom left
                xbli, ybli = x + r.Left, y + h - r.Left // bottom left inset
        )

        p.MoveTo(xtl, ytli)
        if r.Top != 0 {
                p.ArcTo(r.Top, r.Top, 0, false, true, xtli, ytl)
        }
        p.LineTo(xtri, ytr)
        if r.Right != 0 {
                p.ArcTo(r.Right, r.Right, 0, false, true, xbr, ytri)
        }
        p.LineTo(xbr, ybri)
        if r.Bottom != 0 {
                p.ArcTo(r.Bottom, r.Bottom, 0, false, true, xbri, ybl)
        }
        p.LineTo(xbli, ybl)
        if r.Left != 0 {
                p.ArcTo(r.Left, r.Left, 0, false, true, xtl, ybli)
        }
        p.Close()
        return p
}

// BeveledRectangle adds a rectangle of width w and height h
// with beveled corners at distance r from the corner.
func (p *Path) BeveledRectangle(x, y, w, h, r float32) *Path {
        if Equal(w, 0.0) || Equal(h, 0.0) {
                return p
        } else if Equal(r, 0.0) {
                return p.Rectangle(x, y, w, h)
        }

        r = math32.Abs(r)
        r = math32.Min(r, w/2.0)
        r = math32.Min(r, h/2.0)

        p.MoveTo(x, y+r)
        p.LineTo(x+r, y)
        p.LineTo(x+w-r, y)
        p.LineTo(x+w, y+r)
        p.LineTo(x+w, y+h-r)
        p.LineTo(x+w-r, y+h)
        p.LineTo(x+r, y+h)
        p.LineTo(x, y+h-r)
        p.Close()
        return p
}

// Circle adds a circle at given center coordinates of radius r.
func (p *Path) Circle(cx, cy, r float32) *Path {
        return p.Ellipse(cx, cy, r, r)
}

// Ellipse adds an ellipse at given center coordinates of radii rx and ry.
func (p *Path) Ellipse(cx, cy, rx, ry float32) *Path {
        if Equal(rx, 0.0) || Equal(ry, 0.0) {
                return p
        }

        p.MoveTo(cx+rx, cy+(ry*0.001))
        p.ArcTo(rx, ry, 0.0, false, true, cx-rx, cy)
        p.ArcTo(rx, ry, 0.0, false, true, cx+rx, cy)
        p.Close()
        return p
}

// CircularArc adds a circular arc centered at given coordinates with radius r
// and theta0 and theta1 as the angles in degrees of the ellipse
// (before rot is applied) between which the arc will run.
// If theta0 < theta1, the arc will run in a CCW direction.
// If the difference between theta0 and theta1 is bigger than 360 degrees,
// one full circle will be drawn and the remaining part of diff % 360,
// e.g. a difference of 810 degrees will draw one full circle and an arc
// over 90 degrees.
func (p *Path) CircularArc(x, y, r, theta0, theta1 float32) *Path {
        return p.EllipticalArc(x, y, r, r, 0, theta0, theta1)
}

// EllipticalArc adds an elliptical arc centered at given coordinates with
// radii rx and ry, with rot the counter clockwise rotation in radians,
// and theta0 and theta1 the angles in radians of the ellipse
// (before rot is applied) between which the arc will run.
// If theta0 < theta1, the arc will run in a CCW direction.
// If the difference between theta0 and theta1 is bigger than 360 degrees,
// one full circle will be drawn and the remaining part of diff % 360,
// e.g. a difference of 810 degrees will draw one full circle and an arc
// over 90 degrees.
func (p *Path) EllipticalArc(x, y, rx, ry, rot, theta0, theta1 float32) *Path {
        sins, coss := math32.Sincos(theta0)
        sx := rx * coss
        sy := ry * sins
        p.MoveTo(x+sx, y+sy)
        p.Arc(rx, ry, rot, theta0, theta1)
        return p
}

// Triangle adds a triangle of radius r pointing upwards.
func (p *Path) Triangle(r float32) *Path {
        return p.RegularPolygon(3, r, true)
}

// RegularPolygon adds a regular polygon with radius r.
// It uses n vertices/edges, so when n approaches infinity
// this will return a path that approximates a circle.
// n must be 3 or more. The up boolean defines whether
// the first point will point upwards or downwards.
func (p *Path) RegularPolygon(n int, r float32, up bool) *Path {
        return p.RegularStarPolygon(n, 1, r, up)
}

// RegularStarPolygon adds a regular star polygon with radius r.
// It uses n vertices of density d. This will result in a
// self-intersection star in counter clockwise direction.
// If n/2 < d the star will be clockwise and if n and d are not coprime
// a regular polygon will be obtained, possible with multiple windings.
// n must be 3 or more and d 2 or more. The up boolean defines whether
// the first point will point upwards or downwards.
func (p *Path) RegularStarPolygon(n, d int, r float32, up bool) *Path {
        if n < 3 || d < 1 || n == d*2 || Equal(r, 0.0) {
                return p
        }

        dtheta := 2.0 * math32.Pi / float32(n)
        theta0 := float32(0.5 * math32.Pi)
        if !up {
                theta0 += dtheta / 2.0
        }

        for i := 0; i == 0 || i%n != 0; i += d {
                theta := theta0 + float32(i)*dtheta
                sintheta, costheta := math32.Sincos(theta)
                if i == 0 {
                        p.MoveTo(r*costheta, r*sintheta)
                } else {
                        p.LineTo(r*costheta, r*sintheta)
                }
        }
        p.Close()
        return p
}

// StarPolygon adds a star polygon of n points with alternating
// radius R and r. The up boolean defines whether the first point
// will be point upwards or downwards.
func (p *Path) StarPolygon(n int, R, r float32, up bool) *Path {
        if n < 3 || Equal(R, 0.0) || Equal(r, 0.0) {
                return p
        }

        n *= 2
        dtheta := 2.0 * math32.Pi / float32(n)
        theta0 := float32(0.5 * math32.Pi)
        if !up {
                theta0 += dtheta
        }

        for i := 0; i < n; i++ {
                theta := theta0 + float32(i)*dtheta
                sintheta, costheta := math32.Sincos(theta)
                if i == 0 {
                        p.MoveTo(R*costheta, R*sintheta)
                } else if i%2 == 0 {
                        p.LineTo(R*costheta, R*sintheta)
                } else {
                        p.LineTo(r*costheta, r*sintheta)
                }
        }
        p.Close()
        return p
}

// Grid adds a stroked grid of width w and height h,
// with grid line thickness r, and the number of cells horizontally
// and vertically as nx and ny respectively.
func (p *Path) Grid(w, h float32, nx, ny int, r float32) *Path {
        if nx < 1 || ny < 1 || w <= float32(nx+1)*r || h <= float32(ny+1)*r {
                return p
        }

        p.Rectangle(0, 0, w, h)
        dx, dy := (w-float32(nx+1)*r)/float32(nx), (h-float32(ny+1)*r)/float32(ny)
        cell := New().Rectangle(0, 0, dx, dy).Reverse()
        for j := 0; j < ny; j++ {
                for i := 0; i < nx; i++ {
                        x := r + float32(i)*(r+dx)
                        y := r + float32(j)*(r+dy)
                        *p = p.Append(cell.Translate(x, y))
                }
        }
        return p
}

func ArcToQuad(start math32.Vector2, rx, ry, phi float32, large, sweep bool, end math32.Vector2) Path {
        p := Path{}
        p.MoveTo(start.X, start.Y)
        for _, bezier := range ellipseToQuadraticBeziers(start, rx, ry, phi, large, sweep, end) {
                p.QuadTo(bezier[1].X, bezier[1].Y, bezier[2].X, bezier[2].Y)
        }
        return p
}

func ArcToCube(start math32.Vector2, rx, ry, phi float32, large, sweep bool, end math32.Vector2) Path {
        p := Path{}
        p.MoveTo(start.X, start.Y)
        for _, bezier := range ellipseToCubicBeziers(start, rx, ry, phi, large, sweep, end) {
                p.CubeTo(bezier[1].X, bezier[1].Y, bezier[2].X, bezier[2].Y, bezier[3].X, bezier[3].Y)
        }
        return p
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import "cogentcore.org/core/math32"

//go:generate core generate

// FillRules specifies the algorithm for which area is to be filled and which not,
// in particular when multiple subpaths overlap. The NonZero rule is the default
// and will fill any point that is being enclosed by an unequal number of paths
// winding clock-wise and counter clock-wise, otherwise it will not be filled.
// The EvenOdd rule will fill any point that is being enclosed by an uneven number
// of paths, whichever their direction. Positive fills only counter clock-wise
// oriented paths, while Negative fills only clock-wise oriented paths.
type FillRules int32 //enums:enum -transform lower

const (
        NonZero FillRules = iota
        EvenOdd
        Positive
        Negative
)

func (fr FillRules) Fills(windings int) bool {
        switch fr {
        case NonZero:
                return windings != 0
        case EvenOdd:
                return windings%2 != 0
        case Positive:
                return 0 < windings
        case Negative:
                return windings < 0
        }
        return false
}

// todo: these need serious work:

// VectorEffects contains special effects for rendering
type VectorEffects int32 //enums:enum -trim-prefix VectorEffect -transform kebab

const (
        VectorEffectNone VectorEffects = iota

        // VectorEffectNonScalingStroke means that the stroke width is not affected by
        // transform properties
        VectorEffectNonScalingStroke
)

// Caps specifies the end-cap of a stroked line: stroke-linecap property in SVG
type Caps int32 //enums:enum -trim-prefix Cap -transform kebab

const (
        // CapButt indicates to draw no line caps; it draws a
        // line with the length of the specified length.
        CapButt Caps = iota

        // CapRound indicates to draw a semicircle on each line
        // end with a diameter of the stroke width.
        CapRound

        // CapSquare indicates to draw a rectangle on each line end
        // with a height of the stroke width and a width of half of the
        // stroke width.
        CapSquare
)

// Joins specifies the way stroked lines are joined together:
// stroke-linejoin property in SVG
type Joins int32 //enums:enum -trim-prefix Join -transform kebab

const (
        JoinMiter Joins = iota
        JoinMiterClip
        JoinRound
        JoinBevel
        JoinArcs
        JoinArcsClip
)

// Dash patterns
var (
        Solid              = []float32{}
        Dotted             = []float32{1.0, 2.0}
        DenselyDotted      = []float32{1.0, 1.0}
        SparselyDotted     = []float32{1.0, 4.0}
        Dashed             = []float32{3.0, 3.0}
        DenselyDashed      = []float32{3.0, 1.0}
        SparselyDashed     = []float32{3.0, 6.0}
        Dashdotted         = []float32{3.0, 2.0, 1.0, 2.0}
        DenselyDashdotted  = []float32{3.0, 1.0, 1.0, 1.0}
        SparselyDashdotted = []float32{3.0, 4.0, 1.0, 4.0}
)

func ScaleDash(scale float32, offset float32, d []float32) (float32, []float32) {
        d2 := make([]float32, len(d))
        for i := range d {
                d2[i] = d[i] * scale
        }
        return offset * scale, d2
}

// DirectionIndex returns the direction of the path at the given index
// into Path and t in [0.0,1.0]. Path must not contain subpaths,
// and will return the path's starting direction when i points
// to a MoveTo, or the path's final direction when i points to
// a Close of zero-length.
func DirectionIndex(p Path, i int, t float32) math32.Vector2 {
        last := len(p)
        if p[last-1] == Close && EqualPoint(math32.Vec2(p[last-CmdLen(Close)-3], p[last-CmdLen(Close)-2]), math32.Vec2(p[last-3], p[last-2])) {
                // point-closed
                last -= CmdLen(Close)
        }

        if i == 0 {
                // get path's starting direction when i points to MoveTo
                i = 4
                t = 0.0
        } else if i < len(p) && i == last {
                // get path's final direction when i points to zero-length Close
                i -= CmdLen(p[i-1])
                t = 1.0
        }
        if i < 0 || len(p) <= i || last < i+CmdLen(p[i]) {
                return math32.Vector2{}
        }

        cmd := p[i]
        var start math32.Vector2
        if i == 0 {
                start = math32.Vec2(p[last-3], p[last-2])
        } else {
                start = math32.Vec2(p[i-3], p[i-2])
        }

        i += CmdLen(cmd)
        end := math32.Vec2(p[i-3], p[i-2])
        switch cmd {
        case LineTo, Close:
                return end.Sub(start).Normal()
        case QuadTo:
                cp := math32.Vec2(p[i-5], p[i-4])
                return QuadraticBezierDeriv(start, cp, end, t).Normal()
        case CubeTo:
                cp1 := math32.Vec2(p[i-7], p[i-6])
                cp2 := math32.Vec2(p[i-5], p[i-4])
                return CubicBezierDeriv(start, cp1, cp2, end, t).Normal()
        case ArcTo:
                rx, ry, phi := p[i-7], p[i-6], p[i-5]
                large, sweep := ToArcFlags(p[i-4])
                _, _, theta0, theta1 := EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)
                theta := theta0 + t*(theta1-theta0)
                return EllipseDeriv(rx, ry, phi, sweep, theta).Normal()
        }
        return math32.Vector2{}
}

// Direction returns the direction of the path at the given
// segment and t in [0.0,1.0] along that path.
// The direction is a vector of unit length.
func (p Path) Direction(seg int, t float32) math32.Vector2 {
        if len(p) <= 4 {
                return math32.Vector2{}
        }

        curSeg := 0
        iStart, iSeg, iEnd := 0, 0, 0
        for i := 0; i < len(p); {
                cmd := p[i]
                if cmd == MoveTo {
                        if seg < curSeg {
                                pi := p[iStart:iEnd]
                                return DirectionIndex(pi, iSeg-iStart, t)
                        }
                        iStart = i
                }
                if seg == curSeg {
                        iSeg = i
                }
                i += CmdLen(cmd)
        }
        return math32.Vector2{} // if segment doesn't exist
}

// CoordDirections returns the direction of the segment start/end points.
// It will return the average direction at the intersection of two
// end points, and for an open path it will simply return the direction
// of the start and end points of the path.
func (p Path) CoordDirections() []math32.Vector2 {
        if len(p) <= 4 {
                return []math32.Vector2{{}}
        }
        last := len(p)
        if p[last-1] == Close && EqualPoint(math32.Vec2(p[last-CmdLen(Close)-3], p[last-CmdLen(Close)-2]), math32.Vec2(p[last-3], p[last-2])) {
                // point-closed
                last -= CmdLen(Close)
        }

        dirs := []math32.Vector2{}
        var closed bool
        var dirPrev math32.Vector2
        for i := 4; i < last; {
                cmd := p[i]
                dir := DirectionIndex(p, i, 0.0)
                if i == 0 {
                        dirs = append(dirs, dir)
                } else {
                        dirs = append(dirs, dirPrev.Add(dir).Normal())
                }
                dirPrev = DirectionIndex(p, i, 1.0)
                closed = cmd == Close
                i += CmdLen(cmd)
        }
        if closed {
                dirs[0] = dirs[0].Add(dirPrev).Normal()
                dirs = append(dirs, dirs[0])
        } else {
                dirs = append(dirs, dirPrev)
        }
        return dirs
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package stroke

import (
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/paint/ppath/intersect"
)

// Dash returns a new path that consists of dashes.
// The elements in d specify the width of the dashes and gaps.
// It will alternate between dashes and gaps when picking widths.
// If d is an array of odd length, it is equivalent of passing d
// twice in sequence. The offset specifies the offset used into d
// (or negative offset into the path).
// Dash will be applied to each subpath independently.
func Dash(p ppath.Path, offset float32, d ...float32) ppath.Path {
        offset, d = dashCanonical(offset, d)
        if len(d) == 0 {
                return p
        } else if len(d) == 1 && d[0] == 0.0 {
                return ppath.Path{}
        }

        if len(d)%2 == 1 {
                // if d is uneven length, dash and space lengths alternate. Duplicate d so that uneven indices are always spaces
                d = append(d, d...)
        }

        i0, pos0 := dashStart(offset, d)

        q := ppath.Path{}
        for _, ps := range p.Split() {
                i := i0
                pos := pos0

                t := []float32{}
                length := intersect.Length(ps)
                for pos+d[i]+ppath.Epsilon < length {
                        pos += d[i]
                        if 0.0 < pos {
                                t = append(t, pos)
                        }
                        i++
                        if i == len(d) {
                                i = 0
                        }
                }

                j0 := 0
                endsInDash := i%2 == 0
                if len(t)%2 == 1 && endsInDash || len(t)%2 == 0 && !endsInDash {
                        j0 = 1
                }

                qd := ppath.Path{}
                pd := intersect.SplitAt(ps, t...)
                for j := j0; j < len(pd)-1; j += 2 {
                        qd = qd.Append(pd[j])
                }
                if endsInDash {
                        if ps.Closed() {
                                qd = pd[len(pd)-1].Join(qd)
                        } else {
                                qd = qd.Append(pd[len(pd)-1])
                        }
                }
                q = q.Append(qd)
        }
        return q
}

func dashStart(offset float32, d []float32) (int, float32) {
        i0 := 0 // index in d
        for d[i0] <= offset {
                offset -= d[i0]
                i0++
                if i0 == len(d) {
                        i0 = 0
                }
        }
        pos0 := -offset // negative if offset is halfway into dash
        if offset < 0.0 {
                dTotal := float32(0.0)
                for _, dd := range d {
                        dTotal += dd
                }
                pos0 = -(dTotal + offset) // handle negative offsets
        }
        return i0, pos0
}

// dashCanonical returns an optimized dash array.
func dashCanonical(offset float32, d []float32) (float32, []float32) {
        if len(d) == 0 {
                return 0.0, []float32{}
        }

        // remove zeros except first and last
        for i := 1; i < len(d)-1; i++ {
                if ppath.Equal(d[i], 0.0) {
                        d[i-1] += d[i+1]
                        d = append(d[:i], d[i+2:]...)
                        i--
                }
        }

        // remove first zero, collapse with second and last
        if ppath.Equal(d[0], 0.0) {
                if len(d) < 3 {
                        return 0.0, []float32{0.0}
                }
                offset -= d[1]
                d[len(d)-1] += d[1]
                d = d[2:]
        }

        // remove last zero, collapse with fist and second to last
        if ppath.Equal(d[len(d)-1], 0.0) {
                if len(d) < 3 {
                        return 0.0, []float32{}
                }
                offset += d[len(d)-2]
                d[0] += d[len(d)-2]
                d = d[:len(d)-2]
        }

        // if there are zeros or negatives, don't draw any dashes
        for i := 0; i < len(d); i++ {
                if d[i] < 0.0 || ppath.Equal(d[i], 0.0) {
                        return 0.0, []float32{0.0}
                }
        }

        // remove repeated patterns
REPEAT:
        for len(d)%2 == 0 {
                mid := len(d) / 2
                for i := 0; i < mid; i++ {
                        if !ppath.Equal(d[i], d[mid+i]) {
                                break REPEAT
                        }
                }
                d = d[:mid]
        }
        return offset, d
}

func checkDash(p ppath.Path, offset float32, d []float32) ([]float32, bool) {
        offset, d = dashCanonical(offset, d)
        if len(d) == 0 {
                return d, true // stroke without dashes
        } else if len(d) == 1 && d[0] == 0.0 {
                return d[:0], false // no dashes, no stroke
        }

        length := intersect.Length(p)
        i, pos := dashStart(offset, d)
        if length <= d[i]-pos {
                if i%2 == 0 {
                        return d[:0], true // first dash covers whole path, stroke without dashes
                }
                return d[:0], false // first space covers whole path, no stroke
        }
        return d, true
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package stroke

//go:generate core generate

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/paint/ppath/intersect"
)

// ellipseNormal returns the normal to the right at angle theta of the ellipse, given rotation phi.
func ellipseNormal(rx, ry, phi float32, sweep bool, theta, d float32) math32.Vector2 {
        return ppath.EllipseDeriv(rx, ry, phi, sweep, theta).Rot90CW().Normal().MulScalar(d)
}

// NOTE: implementation inspired from github.com/golang/freetype/raster/stroke.go

// Stroke converts a path into a stroke of width w and returns a new path.
// It uses cr to cap the start and end of the path, and jr to join all path elements.
// If the path closes itself, it will use a join between the start and end instead
// of capping them. The tolerance is the maximum deviation from the original path
// when flattening Béziers and optimizing the stroke.
func Stroke(p ppath.Path, w float32, cr Capper, jr Joiner, tolerance float32) ppath.Path {
        if cr == nil {
                cr = ButtCap
        }
        if jr == nil {
                jr = MiterJoin
        }
        q := ppath.Path{}
        halfWidth := math32.Abs(w) / 2.0
        for _, pi := range p.Split() {
                rhs, lhs := offset(pi, halfWidth, cr, jr, true, tolerance)
                if rhs == nil {
                        continue
                } else if lhs == nil {
                        // open path
                        q = q.Append(intersect.Settle(rhs, ppath.Positive))
                } else {
                        // closed path
                        // inner path should go opposite direction to cancel the outer path
                        if intersect.CCW(pi) {
                                q = q.Append(intersect.Settle(rhs, ppath.Positive))
                                q = q.Append(intersect.Settle(lhs, ppath.Positive).Reverse())
                        } else {
                                // outer first, then inner
                                q = q.Append(intersect.Settle(lhs, ppath.Negative))
                                q = q.Append(intersect.Settle(rhs, ppath.Negative).Reverse())
                        }
                }
        }
        return q
}

func CapFromStyle(st ppath.Caps) Capper {
        switch st {
        case ppath.CapButt:
                return ButtCap
        case ppath.CapRound:
                return RoundCap
        case ppath.CapSquare:
                return SquareCap
        }
        return ButtCap
}

func JoinFromStyle(st ppath.Joins) Joiner {
        switch st {
        case ppath.JoinMiter:
                return MiterJoin
        case ppath.JoinMiterClip:
                return MiterClipJoin
        case ppath.JoinRound:
                return RoundJoin
        case ppath.JoinBevel:
                return BevelJoin
        case ppath.JoinArcs:
                return ArcsJoin
        case ppath.JoinArcsClip:
                return ArcsClipJoin
        }
        return MiterJoin
}

// Capper implements Cap, with rhs the path to append to,
// halfWidth the half width of the stroke, pivot the pivot point around
// which to construct a cap, and n0 the normal at the start of the path.
// The length of n0 is equal to the halfWidth.
type Capper interface {
        Cap(*ppath.Path, float32, math32.Vector2, math32.Vector2)
}

// RoundCap caps the start or end of a path by a round cap.
var RoundCap Capper = RoundCapper{}

// RoundCapper is a round capper.
type RoundCapper struct{}

// Cap adds a cap to path p of width 2*halfWidth,
// at a pivot point and initial normal direction of n0.
func (RoundCapper) Cap(p *ppath.Path, halfWidth float32, pivot, n0 math32.Vector2) {
        end := pivot.Sub(n0)
        p.ArcTo(halfWidth, halfWidth, 0, false, true, end.X, end.Y)
}

func (RoundCapper) String() string {
        return "Round"
}

// ButtCap caps the start or end of a path by a butt cap.
var ButtCap Capper = ButtCapper{}

// ButtCapper is a butt capper.
type ButtCapper struct{}

// Cap adds a cap to path p of width 2*halfWidth,
// at a pivot point and initial normal direction of n0.
func (ButtCapper) Cap(p *ppath.Path, halfWidth float32, pivot, n0 math32.Vector2) {
        end := pivot.Sub(n0)
        p.LineTo(end.X, end.Y)
}

func (ButtCapper) String() string {
        return "Butt"
}

// SquareCap caps the start or end of a path by a square cap.
var SquareCap Capper = SquareCapper{}

// SquareCapper is a square capper.
type SquareCapper struct{}

// Cap adds a cap to path p of width 2*halfWidth,
// at a pivot point and initial normal direction of n0.
func (SquareCapper) Cap(p *ppath.Path, halfWidth float32, pivot, n0 math32.Vector2) {
        e := n0.Rot90CCW()
        corner1 := pivot.Add(e).Add(n0)
        corner2 := pivot.Add(e).Sub(n0)
        end := pivot.Sub(n0)
        p.LineTo(corner1.X, corner1.Y)
        p.LineTo(corner2.X, corner2.Y)
        p.LineTo(end.X, end.Y)
}

func (SquareCapper) String() string {
        return "Square"
}

////////

// Joiner implements Join, with rhs the right path and lhs the left path
// to append to, pivot the intersection of both path elements, n0 and n1
// the normals at the start and end of the path respectively.
// The length of n0 and n1 are equal to the halfWidth.
type Joiner interface {
        Join(*ppath.Path, *ppath.Path, float32, math32.Vector2, math32.Vector2, math32.Vector2, float32, float32)
}

// BevelJoin connects two path elements by a linear join.
var BevelJoin Joiner = BevelJoiner{}

// BevelJoiner is a bevel joiner.
type BevelJoiner struct{}

// Join adds a join to a right-hand-side and left-hand-side path,
// of width 2*halfWidth, around a pivot point with starting and
// ending normals of n0 and n1, and radius of curvatures of the
// previous and next segments.
func (BevelJoiner) Join(rhs, lhs *ppath.Path, halfWidth float32, pivot, n0, n1 math32.Vector2, r0, r1 float32) {
        rEnd := pivot.Add(n1)
        lEnd := pivot.Sub(n1)
        rhs.LineTo(rEnd.X, rEnd.Y)
        lhs.LineTo(lEnd.X, lEnd.Y)
}

func (BevelJoiner) String() string {
        return "Bevel"
}

// RoundJoin connects two path elements by a round join.
var RoundJoin Joiner = RoundJoiner{}

// RoundJoiner is a round joiner.
type RoundJoiner struct{}

func (RoundJoiner) Join(rhs, lhs *ppath.Path, halfWidth float32, pivot, n0, n1 math32.Vector2, r0, r1 float32) {
        rEnd := pivot.Add(n1)
        lEnd := pivot.Sub(n1)
        cw := 0.0 <= n0.Rot90CW().Dot(n1)
        if cw { // bend to the right, ie. CW (or 180 degree turn)
                rhs.LineTo(rEnd.X, rEnd.Y)
                lhs.ArcTo(halfWidth, halfWidth, 0.0, false, false, lEnd.X, lEnd.Y)
        } else { // bend to the left, ie. CCW
                rhs.ArcTo(halfWidth, halfWidth, 0.0, false, true, rEnd.X, rEnd.Y)
                lhs.LineTo(lEnd.X, lEnd.Y)
        }
}

func (RoundJoiner) String() string {
        return "Round"
}

// MiterJoin connects two path elements by extending the ends
// of the paths as lines until they meet.
// If this point is further than the limit, this will result in a bevel
// join (MiterJoin) or they will meet at the limit (MiterClipJoin).
var MiterJoin Joiner = MiterJoiner{BevelJoin, 4.0}
var MiterClipJoin Joiner = MiterJoiner{nil, 4.0} // TODO: should extend limit*halfwidth before bevel

// MiterJoiner is a miter joiner.
type MiterJoiner struct {
        GapJoiner Joiner
        Limit     float32
}

func (j MiterJoiner) Join(rhs, lhs *ppath.Path, halfWidth float32, pivot, n0, n1 math32.Vector2, r0, r1 float32) {
        if ppath.EqualPoint(n0, n1.Negate()) {
                BevelJoin.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                return
        }

        cw := 0.0 <= n0.Rot90CW().Dot(n1)
        hw := halfWidth
        if cw {
                hw = -hw // used to calculate |R|, when running CW then n0 and n1 point the other way, so the sign of r0 and r1 is negated
        }

        // note that cos(theta) below refers to sin(theta/2) in the documentation of stroke-miterlimit
        // in https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit
        theta := ppath.AngleBetween(n0, n1) / 2.0 // half the angle between normals
        d := hw / math32.Cos(theta)               // half the miter length
        limit := math32.Max(j.Limit, 1.001)       // otherwise nearly linear joins will also get clipped
        clip := !math32.IsNaN(limit) && limit*halfWidth < math32.Abs(d)
        if clip && j.GapJoiner != nil {
                j.GapJoiner.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                return
        }

        rEnd := pivot.Add(n1)
        lEnd := pivot.Sub(n1)
        mid := pivot.Add(n0.Add(n1).Normal().MulScalar(d))
        if clip {
                // miter-clip
                t := math32.Abs(limit * halfWidth / d)
                if cw { // bend to the right, ie. CW
                        mid0 := lhs.Pos().Lerp(mid, t)
                        mid1 := lEnd.Lerp(mid, t)
                        lhs.LineTo(mid0.X, mid0.Y)
                        lhs.LineTo(mid1.X, mid1.Y)
                } else {
                        mid0 := rhs.Pos().Lerp(mid, t)
                        mid1 := rEnd.Lerp(mid, t)
                        rhs.LineTo(mid0.X, mid0.Y)
                        rhs.LineTo(mid1.X, mid1.Y)
                }
        } else {
                if cw { // bend to the right, ie. CW
                        lhs.LineTo(mid.X, mid.Y)
                } else {
                        rhs.LineTo(mid.X, mid.Y)
                }
        }
        rhs.LineTo(rEnd.X, rEnd.Y)
        lhs.LineTo(lEnd.X, lEnd.Y)
}

func (j MiterJoiner) String() string {
        if j.GapJoiner == nil {
                return "MiterClip"
        }
        return "Miter"
}

// ArcsJoin connects two path elements by extending the ends
// of the paths as circle arcs until they meet.
// If this point is further than the limit, this will result
// in a bevel join (ArcsJoin) or they will meet at the limit (ArcsClipJoin).
var ArcsJoin Joiner = ArcsJoiner{BevelJoin, 4.0}
var ArcsClipJoin Joiner = ArcsJoiner{nil, 4.0}

// ArcsJoiner is an arcs joiner.
type ArcsJoiner struct {
        GapJoiner Joiner
        Limit     float32
}

func closestArcIntersection(c math32.Vector2, cw bool, pivot, i0, i1 math32.Vector2) math32.Vector2 {
        thetaPivot := ppath.Angle(pivot.Sub(c))
        dtheta0 := ppath.Angle(i0.Sub(c)) - thetaPivot
        dtheta1 := ppath.Angle(i1.Sub(c)) - thetaPivot
        if cw { // arc runs clockwise, so look the other way around
                dtheta0 = -dtheta0
                dtheta1 = -dtheta1
        }
        if ppath.AngleNorm(dtheta1) < ppath.AngleNorm(dtheta0) {
                return i1
        }
        return i0
}

func (j ArcsJoiner) Join(rhs, lhs *ppath.Path, halfWidth float32, pivot, n0, n1 math32.Vector2, r0, r1 float32) {
        if ppath.EqualPoint(n0, n1.Negate()) {
                BevelJoin.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                return
        } else if math32.IsNaN(r0) && math32.IsNaN(r1) {
                MiterJoiner(j).Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                return
        }
        limit := math32.Max(j.Limit, 1.001) // 1.001 so that nearly linear joins will not get clipped

        cw := 0.0 <= n0.Rot90CW().Dot(n1)
        hw := halfWidth
        if cw {
                hw = -hw // used to calculate |R|, when running CW then n0 and n1 point the other way, so the sign of r0 and r1 is negated
        }

        // r is the radius of the original curve, R the radius of the stroke curve, c are the centers of the circles
        c0 := pivot.Add(n0.Normal().MulScalar(-r0))
        c1 := pivot.Add(n1.Normal().MulScalar(-r1))
        R0, R1 := math32.Abs(r0+hw), math32.Abs(r1+hw)

        // TODO: can simplify if intersection returns angles too?
        var i0, i1 math32.Vector2
        var ok bool
        if math32.IsNaN(r0) {
                line := pivot.Add(n0)
                if cw {
                        line = pivot.Sub(n0)
                }
                i0, i1, ok = intersect.IntersectionRayCircle(line, line.Add(n0.Rot90CCW()), c1, R1)
        } else if math32.IsNaN(r1) {
                line := pivot.Add(n1)
                if cw {
                        line = pivot.Sub(n1)
                }
                i0, i1, ok = intersect.IntersectionRayCircle(line, line.Add(n1.Rot90CCW()), c0, R0)
        } else {
                i0, i1, ok = intersect.IntersectionCircleCircle(c0, R0, c1, R1)
        }
        if !ok {
                // no intersection
                BevelJoin.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                return
        }

        // find the closest intersection when following the arc (using either arc r0 or r1 with center c0 or c1 respectively)
        var mid math32.Vector2
        if !math32.IsNaN(r0) {
                mid = closestArcIntersection(c0, r0 < 0.0, pivot, i0, i1)
        } else {
                mid = closestArcIntersection(c1, 0.0 <= r1, pivot, i0, i1)
        }

        // check arc limit
        d := mid.Sub(pivot).Length()
        clip := !math32.IsNaN(limit) && limit*halfWidth < d
        if clip && j.GapJoiner != nil {
                j.GapJoiner.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                return
        }

        mid2 := mid
        if clip {
                // arcs-clip
                start, end := pivot.Add(n0), pivot.Add(n1)
                if cw {
                        start, end = pivot.Sub(n0), pivot.Sub(n1)
                }

                var clipMid, clipNormal math32.Vector2
                if !math32.IsNaN(r0) && !math32.IsNaN(r1) && (0.0 < r0) == (0.0 < r1) {
                        // circle have opposite direction/sweep
                        // NOTE: this may cause the bevel to be imperfectly oriented
                        clipMid = mid.Sub(pivot).Normal().MulScalar(limit * halfWidth)
                        clipNormal = clipMid.Rot90CCW()
                } else {
                        // circle in between both stroke edges
                        rMid := (r0 - r1) / 2.0
                        if math32.IsNaN(r0) {
                                rMid = -(r1 + hw) * 2.0
                        } else if math32.IsNaN(r1) {
                                rMid = (r0 + hw) * 2.0
                        }

                        sweep := 0.0 < rMid
                        RMid := math32.Abs(rMid)
                        cx, cy, a0, _ := ppath.EllipseToCenter(pivot.X, pivot.Y, RMid, RMid, 0.0, false, sweep, mid.X, mid.Y)
                        cMid := math32.Vector2{cx, cy}
                        dtheta := limit * halfWidth / rMid

                        clipMid = ppath.EllipsePos(RMid, RMid, 0.0, cMid.X, cMid.Y, a0+dtheta)
                        clipNormal = ellipseNormal(RMid, RMid, 0.0, sweep, a0+dtheta, 1.0)
                }

                if math32.IsNaN(r1) {
                        i0, ok = intersect.IntersectionRayLine(clipMid, clipMid.Add(clipNormal), mid, end)
                        if !ok {
                                // not sure when this occurs
                                BevelJoin.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                                return
                        }
                        mid2 = i0
                } else {
                        i0, i1, ok = intersect.IntersectionRayCircle(clipMid, clipMid.Add(clipNormal), c1, R1)
                        if !ok {
                                // not sure when this occurs
                                BevelJoin.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                                return
                        }
                        mid2 = closestArcIntersection(c1, 0.0 <= r1, pivot, i0, i1)
                }

                if math32.IsNaN(r0) {
                        i0, ok = intersect.IntersectionRayLine(clipMid, clipMid.Add(clipNormal), start, mid)
                        if !ok {
                                // not sure when this occurs
                                BevelJoin.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                                return
                        }
                        mid = i0
                } else {
                        i0, i1, ok = intersect.IntersectionRayCircle(clipMid, clipMid.Add(clipNormal), c0, R0)
                        if !ok {
                                // not sure when this occurs
                                BevelJoin.Join(rhs, lhs, halfWidth, pivot, n0, n1, r0, r1)
                                return
                        }
                        mid = closestArcIntersection(c0, r0 < 0.0, pivot, i0, i1)
                }
        }

        rEnd := pivot.Add(n1)
        lEnd := pivot.Sub(n1)
        if cw { // bend to the right, ie. CW
                rhs.LineTo(rEnd.X, rEnd.Y)
                if math32.IsNaN(r0) {
                        lhs.LineTo(mid.X, mid.Y)
                } else {
                        lhs.ArcTo(R0, R0, 0.0, false, 0.0 < r0, mid.X, mid.Y)
                }
                if clip {
                        lhs.LineTo(mid2.X, mid2.Y)
                }
                if math32.IsNaN(r1) {
                        lhs.LineTo(lEnd.X, lEnd.Y)
                } else {
                        lhs.ArcTo(R1, R1, 0.0, false, 0.0 < r1, lEnd.X, lEnd.Y)
                }
        } else { // bend to the left, ie. CCW
                if math32.IsNaN(r0) {
                        rhs.LineTo(mid.X, mid.Y)
                } else {
                        rhs.ArcTo(R0, R0, 0.0, false, 0.0 < r0, mid.X, mid.Y)
                }
                if clip {
                        rhs.LineTo(mid2.X, mid2.Y)
                }
                if math32.IsNaN(r1) {
                        rhs.LineTo(rEnd.X, rEnd.Y)
                } else {
                        rhs.ArcTo(R1, R1, 0.0, false, 0.0 < r1, rEnd.X, rEnd.Y)
                }
                lhs.LineTo(lEnd.X, lEnd.Y)
        }
}

func (j ArcsJoiner) String() string {
        if j.GapJoiner == nil {
                return "ArcsClip"
        }
        return "Arcs"
}

// optimizeClose removes a superfluous first line segment in-place
// of a subpath. If both the first and last segment are line segments
// and are colinear, move the start of the path forward one segment
func optimizeClose(p *ppath.Path) {
        if len(*p) == 0 || (*p)[len(*p)-1] != ppath.Close {
                return
        }

        // find last MoveTo
        end := math32.Vector2{}
        iMoveTo := len(*p)
        for 0 < iMoveTo {
                cmd := (*p)[iMoveTo-1]
                iMoveTo -= ppath.CmdLen(cmd)
                if cmd == ppath.MoveTo {
                        end = math32.Vec2((*p)[iMoveTo+1], (*p)[iMoveTo+2])
                        break
                }
        }

        if (*p)[iMoveTo] == ppath.MoveTo && (*p)[iMoveTo+ppath.CmdLen(ppath.MoveTo)] == ppath.LineTo && iMoveTo+ppath.CmdLen(ppath.MoveTo)+ppath.CmdLen(ppath.LineTo) < len(*p)-ppath.CmdLen(ppath.Close) {
                // replace Close + MoveTo + LineTo by Close + MoveTo if equidirectional
                // move Close and MoveTo forward along the path
                start := math32.Vec2((*p)[len(*p)-ppath.CmdLen(ppath.Close)-3], (*p)[len(*p)-ppath.CmdLen(ppath.Close)-2])
                nextEnd := math32.Vec2((*p)[iMoveTo+ppath.CmdLen(ppath.MoveTo)+ppath.CmdLen(ppath.LineTo)-3], (*p)[iMoveTo+ppath.CmdLen(ppath.MoveTo)+ppath.CmdLen(ppath.LineTo)-2])
                if ppath.Equal(ppath.AngleBetween(end.Sub(start), nextEnd.Sub(end)), 0.0) {
                        // update Close
                        (*p)[len(*p)-3] = nextEnd.X
                        (*p)[len(*p)-2] = nextEnd.Y

                        // update MoveTo
                        (*p)[iMoveTo+1] = nextEnd.X
                        (*p)[iMoveTo+2] = nextEnd.Y

                        // remove LineTo
                        *p = append((*p)[:iMoveTo+ppath.CmdLen(ppath.MoveTo)], (*p)[iMoveTo+ppath.CmdLen(ppath.MoveTo)+ppath.CmdLen(ppath.LineTo):]...)
                }
        }
}

func optimizeInnerBend(p ppath.Path, i int) {
        // i is the index of the line segment in the inner bend connecting both edges
        ai := i - ppath.CmdLen(p[i-1])
        if ai == 0 {
                return
        }
        if i >= len(p) {
                return
        }
        bi := i + ppath.CmdLen(p[i])

        a0 := math32.Vector2{p[ai-3], p[ai-2]}
        b0 := math32.Vector2{p[bi-3], p[bi-2]}
        if bi == len(p) {
                // inner bend is at the path's start
                bi = 4
        }

        // TODO: implement other segment combinations
        zs_ := [2]intersect.Intersection{}
        zs := zs_[:]
        if (p[ai] == ppath.LineTo || p[ai] == ppath.Close) && (p[bi] == ppath.LineTo || p[bi] == ppath.Close) {
                zs = intersect.IntersectionSegment(zs[:0], a0, p[ai:ai+4], b0, p[bi:bi+4])
                // TODO: check conditions for pathological cases
                if len(zs) == 1 && zs[0].T[0] != 0.0 && zs[0].T[0] != 1.0 && zs[0].T[1] != 0.0 && zs[0].T[1] != 1.0 {
                        p[ai+1] = zs[0].X
                        p[ai+2] = zs[0].Y
                        if bi == 4 {
                                // inner bend is at the path's start
                                if p[i] == ppath.Close {
                                        if p[ai] == ppath.LineTo {
                                                p[ai] = ppath.Close
                                                p[ai+3] = ppath.Close
                                        } else {
                                                p = append(p, ppath.Close, zs[0].X, zs[1].Y, ppath.Close)
                                        }
                                }
                                p = p[:i]
                                p[1] = zs[0].X
                                p[2] = zs[0].Y
                        } else {
                                p = append(p[:i], p[bi:]...)
                        }
                }
        }
}

type pathStrokeState struct {
        cmd    float32
        p0, p1 math32.Vector2 // position of start and end
        n0, n1 math32.Vector2 // normal of start and end (points right when walking the path)
        r0, r1 float32        // radius of start and end

        cp1, cp2                    math32.Vector2 // Béziers
        rx, ry, rot, theta0, theta1 float32        // arcs
        large, sweep                bool           // arcs
}

// offset returns the rhs and lhs paths from offsetting a path
// (must not have subpaths). It closes rhs and lhs when p is closed as well.
func offset(p ppath.Path, halfWidth float32, cr Capper, jr Joiner, strokeOpen bool, tolerance float32) (ppath.Path, ppath.Path) {
        // only non-empty paths are evaluated
        closed := false
        states := []pathStrokeState{}
        var start, end math32.Vector2
        for i := 0; i < len(p); {
                cmd := p[i]
                switch cmd {
                case ppath.MoveTo:
                        end = math32.Vector2{p[i+1], p[i+2]}
                case ppath.LineTo:
                        end = math32.Vector2{p[i+1], p[i+2]}
                        n := end.Sub(start).Rot90CW().Normal().MulScalar(halfWidth)
                        states = append(states, pathStrokeState{
                                cmd: ppath.LineTo,
                                p0:  start,
                                p1:  end,
                                n0:  n,
                                n1:  n,
                                r0:  math32.NaN(),
                                r1:  math32.NaN(),
                        })
                case ppath.QuadTo, ppath.CubeTo:
                        var cp1, cp2 math32.Vector2
                        if cmd == ppath.QuadTo {
                                cp := math32.Vector2{p[i+1], p[i+2]}
                                end = math32.Vector2{p[i+3], p[i+4]}
                                cp1, cp2 = ppath.QuadraticToCubicBezier(start, cp, end)
                        } else {
                                cp1 = math32.Vector2{p[i+1], p[i+2]}
                                cp2 = math32.Vector2{p[i+3], p[i+4]}
                                end = math32.Vector2{p[i+5], p[i+6]}
                        }
                        n0 := intersect.CubicBezierNormal(start, cp1, cp2, end, 0.0, halfWidth)
                        n1 := intersect.CubicBezierNormal(start, cp1, cp2, end, 1.0, halfWidth)
                        r0 := intersect.CubicBezierCurvatureRadius(start, cp1, cp2, end, 0.0)
                        r1 := intersect.CubicBezierCurvatureRadius(start, cp1, cp2, end, 1.0)
                        states = append(states, pathStrokeState{
                                cmd: ppath.CubeTo,
                                p0:  start,
                                p1:  end,
                                n0:  n0,
                                n1:  n1,
                                r0:  r0,
                                r1:  r1,
                                cp1: cp1,
                                cp2: cp2,
                        })
                case ppath.ArcTo:
                        rx, ry, phi := p[i+1], p[i+2], p[i+3]
                        large, sweep := ppath.ToArcFlags(p[i+4])
                        end = math32.Vector2{p[i+5], p[i+6]}
                        _, _, theta0, theta1 := ppath.EllipseToCenter(start.X, start.Y, rx, ry, phi, large, sweep, end.X, end.Y)
                        n0 := ellipseNormal(rx, ry, phi, sweep, theta0, halfWidth)
                        n1 := ellipseNormal(rx, ry, phi, sweep, theta1, halfWidth)
                        r0 := intersect.EllipseCurvatureRadius(rx, ry, sweep, theta0)
                        r1 := intersect.EllipseCurvatureRadius(rx, ry, sweep, theta1)
                        states = append(states, pathStrokeState{
                                cmd:    ppath.ArcTo,
                                p0:     start,
                                p1:     end,
                                n0:     n0,
                                n1:     n1,
                                r0:     r0,
                                r1:     r1,
                                rx:     rx,
                                ry:     ry,
                                rot:    phi * 180.0 / math32.Pi,
                                theta0: theta0,
                                theta1: theta1,
                                large:  large,
                                sweep:  sweep,
                        })
                case ppath.Close:
                        end = math32.Vector2{p[i+1], p[i+2]}
                        if !ppath.Equal(start.X, end.X) || !ppath.Equal(start.Y, end.Y) {
                                n := end.Sub(start).Rot90CW().Normal().MulScalar(halfWidth)
                                states = append(states, pathStrokeState{
                                        cmd: ppath.LineTo,
                                        p0:  start,
                                        p1:  end,
                                        n0:  n,
                                        n1:  n,
                                        r0:  math32.NaN(),
                                        r1:  math32.NaN(),
                                })
                        }
                        closed = true
                }
                start = end
                i += ppath.CmdLen(cmd)
        }
        if len(states) == 0 {
                return nil, nil
        }

        rhs, lhs := ppath.Path{}, ppath.Path{}
        rStart := states[0].p0.Add(states[0].n0)
        lStart := states[0].p0.Sub(states[0].n0)
        rhs.MoveTo(rStart.X, rStart.Y)
        lhs.MoveTo(lStart.X, lStart.Y)
        rhsJoinIndex, lhsJoinIndex := -1, -1
        for i, cur := range states {
                switch cur.cmd {
                case ppath.LineTo:
                        rEnd := cur.p1.Add(cur.n1)
                        lEnd := cur.p1.Sub(cur.n1)
                        rhs.LineTo(rEnd.X, rEnd.Y)
                        lhs.LineTo(lEnd.X, lEnd.Y)
                case ppath.CubeTo:
                        rhs = rhs.Join(intersect.FlattenCubicBezier(cur.p0, cur.cp1, cur.cp2, cur.p1, halfWidth, tolerance))
                        lhs = lhs.Join(intersect.FlattenCubicBezier(cur.p0, cur.cp1, cur.cp2, cur.p1, -halfWidth, tolerance))
                case ppath.ArcTo:
                        rStart := cur.p0.Add(cur.n0)
                        lStart := cur.p0.Sub(cur.n0)
                        rEnd := cur.p1.Add(cur.n1)
                        lEnd := cur.p1.Sub(cur.n1)
                        dr := halfWidth
                        if !cur.sweep { // bend to the right, ie. CW
                                dr = -dr
                        }

                        rLambda := ppath.EllipseRadiiCorrection(rStart, cur.rx+dr, cur.ry+dr, cur.rot*math32.Pi/180.0, rEnd)
                        lLambda := ppath.EllipseRadiiCorrection(lStart, cur.rx-dr, cur.ry-dr, cur.rot*math32.Pi/180.0, lEnd)
                        if rLambda <= 1.0 && lLambda <= 1.0 {
                                rLambda, lLambda = 1.0, 1.0
                        }
                        rhs.ArcTo(rLambda*(cur.rx+dr), rLambda*(cur.ry+dr), cur.rot, cur.large, cur.sweep, rEnd.X, rEnd.Y)
                        lhs.ArcTo(lLambda*(cur.rx-dr), lLambda*(cur.ry-dr), cur.rot, cur.large, cur.sweep, lEnd.X, lEnd.Y)
                }

                // optimize inner bend
                if 0 < i {
                        prev := states[i-1]
                        cw := 0.0 <= prev.n1.Rot90CW().Dot(cur.n0)
                        if cw && rhsJoinIndex != -1 {
                                optimizeInnerBend(rhs, rhsJoinIndex)
                        } else if !cw && lhsJoinIndex != -1 {
                                optimizeInnerBend(lhs, lhsJoinIndex)
                        }
                }
                rhsJoinIndex = -1
                lhsJoinIndex = -1

                // join the cur and next path segments
                if i+1 < len(states) || closed {
                        next := states[0]
                        if i+1 < len(states) {
                                next = states[i+1]
                        }
                        if !ppath.EqualPoint(cur.n1, next.n0) {
                                rhsJoinIndex = len(rhs)
                                lhsJoinIndex = len(lhs)
                                jr.Join(&rhs, &lhs, halfWidth, cur.p1, cur.n1, next.n0, cur.r1, next.r0)
                        }
                }
        }

        if closed {
                rhs.Close()
                lhs.Close()

                // optimize inner bend
                if 1 < len(states) {
                        cw := 0.0 <= states[len(states)-1].n1.Rot90CW().Dot(states[0].n0)
                        if cw && rhsJoinIndex != -1 {
                                optimizeInnerBend(rhs, rhsJoinIndex)
                        } else if !cw && lhsJoinIndex != -1 {
                                optimizeInnerBend(lhs, lhsJoinIndex)
                        }
                }

                optimizeClose(&rhs)
                optimizeClose(&lhs)
        } else if strokeOpen {
                lhs = lhs.Reverse()
                cr.Cap(&rhs, halfWidth, states[len(states)-1].p1, states[len(states)-1].n1)
                rhs = rhs.Join(lhs)
                cr.Cap(&rhs, halfWidth, states[0].p0, states[0].n0.Negate())
                lhs = nil

                rhs.Close()
                optimizeClose(&rhs)
        }
        return rhs, lhs
}

// Offset offsets the path by w and returns a new path.
// A positive w will offset the path to the right-hand side, that is,
// it expands CCW oriented contours and contracts CW oriented contours.
// If you don't know the orientation you can use `Path.CCW` to find out,
// but if there may be self-intersection you should use `Path.Settle`
// to remove them and orient all filling contours CCW.
// The tolerance is the maximum deviation from the actual offset when
// flattening Béziers and optimizing the path.
func Offset(p ppath.Path, w float32, tolerance float32) ppath.Path {
        if ppath.Equal(w, 0.0) {
                return p
        }

        positive := 0.0 < w
        w = math32.Abs(w)

        q := ppath.Path{}
        for _, pi := range p.Split() {
                r := ppath.Path{}
                rhs, lhs := offset(pi, w, ButtCap, RoundJoin, false, tolerance)
                if rhs == nil {
                        continue
                } else if positive {
                        r = rhs
                } else {
                        r = lhs
                }
                if pi.Closed() {
                        if intersect.CCW(pi) {
                                r = intersect.Settle(r, ppath.Positive)
                        } else {
                                r = intersect.Settle(r, ppath.Negative).Reverse()
                        }
                }
                q = q.Append(r)
        }
        return q
}

// Markers returns an array of start, mid and end marker paths along
// the path at the coordinates between commands.
// Align will align the markers with the path direction so that
// the markers orient towards the path's left.
func Markers(p ppath.Path, first, mid, last ppath.Path, align bool) []ppath.Path {
        markers := []ppath.Path{}
        coordPos := p.Coords()
        coordDir := p.CoordDirections()
        for i := range coordPos {
                q := mid
                if i == 0 {
                        q = first
                } else if i == len(coordPos)-1 {
                        q = last
                }

                if q != nil {
                        pos, dir := coordPos[i], coordDir[i]
                        m := math32.Identity2().Translate(pos.X, pos.Y)
                        if align {
                                m = m.Rotate(ppath.Angle(dir))
                        }
                        markers = append(markers, q.Clone().Transform(m))
                }
        }
        return markers
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is adapted from https://github.com/tdewolff/canvas
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package ppath

import (
        "cogentcore.org/core/math32"
)

// Transform transforms the path by the given transformation matrix
// and returns a new path. It modifies the path in-place.
func (p Path) Transform(m math32.Matrix2) Path {
        xscale, yscale := m.ExtractScale()
        for i := 0; i < len(p); {
                cmd := p[i]
                switch cmd {
                case MoveTo, LineTo, Close:
                        end := m.MulVector2AsPoint(math32.Vec2(p[i+1], p[i+2]))
                        p[i+1] = end.X
                        p[i+2] = end.Y
                case QuadTo:
                        cp := m.MulVector2AsPoint(math32.Vec2(p[i+1], p[i+2]))
                        end := m.MulVector2AsPoint(math32.Vec2(p[i+3], p[i+4]))
                        p[i+1] = cp.X
                        p[i+2] = cp.Y
                        p[i+3] = end.X
                        p[i+4] = end.Y
                case CubeTo:
                        cp1 := m.MulVector2AsPoint(math32.Vec2(p[i+1], p[i+2]))
                        cp2 := m.MulVector2AsPoint(math32.Vec2(p[i+3], p[i+4]))
                        end := m.MulVector2AsPoint(math32.Vec2(p[i+5], p[i+6]))
                        p[i+1] = cp1.X
                        p[i+2] = cp1.Y
                        p[i+3] = cp2.X
                        p[i+4] = cp2.Y
                        p[i+5] = end.X
                        p[i+6] = end.Y
                case ArcTo:
                        rx, ry, phi, large, sweep, end := p.ArcToPoints(i)

                        // For ellipses written as the conic section equation in matrix form, we have:
                        // [x, y] E [x; y] = 0, with E = [1/rx^2, 0; 0, 1/ry^2]
                        // For our transformed ellipse we have [x', y'] = T [x, y], with T the affine
                        // transformation matrix so that
                        // (T^-1 [x'; y'])^T E (T^-1 [x'; y'] = 0  =>  [x', y'] T^(-T) E T^(-1) [x'; y'] = 0
                        // We define Q = T^(-1,T) E T^(-1) the new ellipse equation which is typically rotated
                        // from the x-axis. That's why we find the eigenvalues and eigenvectors (the new
                        // direction and length of the major and minor axes).
                        T := m.Rotate(phi)
                        invT := T.Inverse()
                        Q := math32.Identity2().Scale(1.0/rx/rx, 1.0/ry/ry)
                        Q = invT.Transpose().Mul(Q).Mul(invT)

                        lambda1, lambda2, v1, v2 := Q.Eigen()
                        rx = 1 / math32.Sqrt(lambda1)
                        ry = 1 / math32.Sqrt(lambda2)
                        phi = Angle(v1)
                        if rx < ry {
                                rx, ry = ry, rx
                                phi = Angle(v2)
                        }
                        phi = AngleNorm(phi)
                        if math32.Pi <= phi { // phi is canonical within 0 <= phi < 180
                                phi -= math32.Pi
                        }

                        if xscale*yscale < 0.0 { // flip x or y axis needs flipping of the sweep
                                sweep = !sweep
                        }
                        end = m.MulVector2AsPoint(end)

                        p[i+1] = rx
                        p[i+2] = ry
                        p[i+3] = phi
                        p[i+4] = fromArcFlags(large, sweep)
                        p[i+5] = end.X
                        p[i+6] = end.Y
                }
                i += CmdLen(cmd)
        }
        return p
}

// Translate translates the path by (x,y) and returns a new path.
func (p Path) Translate(x, y float32) Path {
        return p.Transform(math32.Identity2().Translate(x, y))
}

// Scale scales the path by (x,y) and returns a new path.
func (p Path) Scale(x, y float32) Path {
        return p.Transform(math32.Identity2().Scale(x, y))
}

// ReplaceArcs replaces ArcTo commands by CubeTo commands and returns a new path.
func (p *Path) ReplaceArcs() Path {
        return p.Replace(nil, nil, nil, ArcToCube)
}

// Replace replaces path segments by their respective functions,
// each returning the path that will replace the segment or nil
// if no replacement is to be performed. The line function will
// take the start and end points. The bezier function will take
// the start point, control point 1 and 2, and the end point
// (i.e. a cubic Bézier, quadratic Béziers will be implicitly
// converted to cubic ones). The arc function will take a start point,
// the major and minor radii, the radial rotaton counter clockwise,
// the large and sweep booleans, and the end point.
// The replacing path will replace the path segment without any checks,
// you need to make sure the be moved so that its start point connects
// with the last end point of the base path before the replacement.
// If the end point of the replacing path is different that the end point
// of what is replaced, the path that follows will be displaced.
func (p Path) Replace(
        line func(math32.Vector2, math32.Vector2) Path,
        quad func(math32.Vector2, math32.Vector2, math32.Vector2) Path,
        cube func(math32.Vector2, math32.Vector2, math32.Vector2, math32.Vector2) Path,
        arc func(math32.Vector2, float32, float32, float32, bool, bool, math32.Vector2) Path,
) Path {
        copied := false
        var start, end, cp1, cp2 math32.Vector2
        for i := 0; i < len(p); {
                var q Path
                cmd := p[i]
                switch cmd {
                case LineTo, Close:
                        if line != nil {
                                end = p.EndPoint(i)
                                q = line(start, end)
                                if cmd == Close {
                                        q.Close()
                                }
                        }
                case QuadTo:
                        if quad != nil {
                                cp1, end = p.QuadToPoints(i)
                                q = quad(start, cp1, end)
                        }
                case CubeTo:
                        if cube != nil {
                                cp1, cp2, end = p.CubeToPoints(i)
                                q = cube(start, cp1, cp2, end)
                        }
                case ArcTo:
                        if arc != nil {
                                var rx, ry, phi float32
                                var large, sweep bool
                                rx, ry, phi, large, sweep, end = p.ArcToPoints(i)
                                q = arc(start, rx, ry, phi, large, sweep, end)
                        }
                }

                if q != nil {
                        if !copied {
                                p = p.Clone()
                                copied = true
                        }

                        r := append(Path{MoveTo, end.X, end.Y, MoveTo}, p[i+CmdLen(cmd):]...)

                        p = p[: i : i+CmdLen(cmd)] // make sure not to overwrite the rest of the path
                        p = p.Join(q)
                        if cmd != Close {
                                p.LineTo(end.X, end.Y)
                        }

                        i = len(p)
                        p = p.Join(r) // join the rest of the base path
                } else {
                        i += CmdLen(cmd)
                }
                start = math32.Vec2(p[i-3], p[i-2])
        }
        return p
}

// Split splits the path into its independent subpaths.
// The path is split before each MoveTo command.
func (p Path) Split() []Path {
        if p == nil {
                return nil
        }
        var i, j int
        ps := []Path{}
        for j < len(p) {
                cmd := p[j]
                if i < j && cmd == MoveTo {
                        ps = append(ps, p[i:j:j])
                        i = j
                }
                j += CmdLen(cmd)
        }
        if i+CmdLen(MoveTo) < j {
                ps = append(ps, p[i:j:j])
        }
        return ps
}

// Reverse returns a new path that is the same path as p but in the reverse direction.
func (p Path) Reverse() Path {
        if len(p) == 0 {
                return p
        }

        end := math32.Vector2{p[len(p)-3], p[len(p)-2]}
        q := make(Path, 0, len(p))
        q = append(q, MoveTo, end.X, end.Y, MoveTo)

        closed := false
        first, start := end, end
        for i := len(p); 0 < i; {
                cmd := p[i-1]
                i -= CmdLen(cmd)

                end = math32.Vector2{}
                if 0 < i {
                        end = math32.Vector2{p[i-3], p[i-2]}
                }

                switch cmd {
                case MoveTo:
                        if closed {
                                q = append(q, Close, first.X, first.Y, Close)
                                closed = false
                        }
                        if i != 0 {
                                q = append(q, MoveTo, end.X, end.Y, MoveTo)
                                first = end
                        }
                case Close:
                        if !EqualPoint(start, end) {
                                q = append(q, LineTo, end.X, end.Y, LineTo)
                        }
                        closed = true
                case LineTo:
                        if closed && (i == 0 || p[i-1] == MoveTo) {
                                q = append(q, Close, first.X, first.Y, Close)
                                closed = false
                        } else {
                                q = append(q, LineTo, end.X, end.Y, LineTo)
                        }
                case QuadTo:
                        cx, cy := p[i+1], p[i+2]
                        q = append(q, QuadTo, cx, cy, end.X, end.Y, QuadTo)
                case CubeTo:
                        cx1, cy1 := p[i+1], p[i+2]
                        cx2, cy2 := p[i+3], p[i+4]
                        q = append(q, CubeTo, cx2, cy2, cx1, cy1, end.X, end.Y, CubeTo)
                case ArcTo:
                        rx, ry, phi, large, sweep, _ := p.ArcToPoints(i)
                        q = append(q, ArcTo, rx, ry, phi, fromArcFlags(large, !sweep), end.X, end.Y, ArcTo)
                }
                start = end
        }
        if closed {
                q = append(q, Close, first.X, first.Y, Close)
        }
        return q
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package render

import (
        "image"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/sides"
)

// Bounds represents an optimized rounded rectangle form of clipping,
// which is critical for GUI rendering.
type Bounds struct {
        // Rect is a rectangular bounding box.
        Rect math32.Box2

        // Radius is the border radius for rounded rectangles, can be per corner
        // or one value for all.
        Radius sides.Floats

        // Path is the computed clipping path for the Rect and Radius.
        Path ppath.Path
}

func NewBounds(x, y, w, h float32, radius sides.Floats) *Bounds {
        return &Bounds{Rect: math32.B2(x, y, x+w, y+h), Radius: radius}
}

func NewBoundsRect(rect image.Rectangle, radius sides.Floats) *Bounds {
        sz := rect.Size()
        return NewBounds(float32(rect.Min.X), float32(rect.Min.Y), float32(sz.X), float32(sz.Y), radius)
}

// Context contains all of the rendering constraints / filters / masks
// that are applied to elements being rendered.
// For SVG compliant rendering, we need a stack of these Context elements
// that apply to all elements in the group.
// Each level always represents the compounded effects of any parent groups,
// with the compounding being performed when a new Context is pushed on the stack.
// https://www.w3.org/TR/SVG2/render.html#Grouping
type Context struct {

        // Style has the accumulated style values.
        // Individual elements inherit from this style.
        Style styles.Paint

        // Transform is the accumulated transformation matrix.
        Transform math32.Matrix2

        // Bounds is the rounded rectangle clip boundary.
        // This is applied to the effective Path prior to adding to Render.
        Bounds Bounds

        // ClipPath is the current shape-based clipping path,
        // in addition to the Bounds, which is applied to the effective Path
        // prior to adding to Render.
        ClipPath ppath.Path

        // Mask is the current masking element, as rendered to a separate image.
        // This is composited with the rendering output to produce the final result.
        Mask image.Image

        // Filter // todo add filtering effects here
}

// NewContext returns a new Context using given paint style, bounds, and
// parent Context. See [Context.Init] for details.
func NewContext(sty *styles.Paint, bounds *Bounds, parent *Context) *Context {
        ctx := &Context{}
        ctx.Init(sty, bounds, parent)
        if sty == nil && parent != nil {
                ctx.Style.UnitContext = parent.Style.UnitContext
        }
        return ctx
}

// Init initializes context based on given style, bounds and parent Context.
// If parent is present, then bounds can be nil, in which
// case it gets the bounds from the parent.
// All the values from the style are used to update the Context,
// accumulating anything from the parent.
func (ctx *Context) Init(sty *styles.Paint, bounds *Bounds, parent *Context) {
        if sty != nil {
                ctx.Style = *sty
        } else {
                ctx.Style.Defaults()
        }
        if parent == nil {
                ctx.Transform = sty.Transform
                ctx.SetBounds(bounds)
                ctx.ClipPath = sty.ClipPath
                ctx.Mask = sty.Mask
                return
        }
        ctx.Transform = parent.Transform.Mul(ctx.Style.Transform)
        ctx.Style.InheritFields(&parent.Style)
        if bounds == nil {
                bounds = &parent.Bounds
        }
        ctx.SetBounds(bounds)
        // todo: not clear if following are needed:
        // ctx.Bounds.Path = ctx.Bounds.Path.And(parent.Bounds.Path) // intersect
        // ctx.ClipPath = ctx.Style.ClipPath.And(parent.ClipPath)
        ctx.Mask = parent.Mask // todo: intersect with our own mask
}

// SetBounds sets the context bounds, and updates the Bounds.Path
func (ctx *Context) SetBounds(bounds *Bounds) {
        ctx.Bounds = *bounds
        // bsz := bounds.Rect.Size()
        // ctx.Bounds.Path = *ppath.New().RoundedRectangleSides(bounds.Rect.Min.X, bounds.Rect.Min.Y, bsz.X, bsz.Y, bounds.Radius)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package render

// Item is a union interface for render items:
// [Path], [Text], [Image], and [ContextPush].
type Item interface {
        IsRenderItem()
}

// ContextPush is a [Context] push render item, which can be used by renderers
// that track group structure (e.g., SVG).
type ContextPush struct {
        Context Context
}

// interface assertion.
func (p *ContextPush) IsRenderItem() {
}

// ContextPop is a [Context] pop render item, which can be used by renderers
// that track group structure (e.g., SVG).
type ContextPop struct {
}

// interface assertion.
func (p *ContextPop) IsRenderItem() {
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package render

import (
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/styles"
)

// Path is a path drawing render [Item]: responsible for all vector graphics
// drawing functionality.
type Path struct {
        // Path specifies the shape(s) to be drawn, using commands:
        // MoveTo, LineTo, QuadTo, CubeTo, ArcTo, and Close.
        // Each command has the applicable coordinates appended after it,
        // like the SVG path element. The coordinates are in the original
        // units as specified in the Paint drawing commands, without any
        // transforms applied. See [Path.Transform].
        Path ppath.Path

        // Context has the full accumulated style, transform, etc parameters
        // for rendering the path, combining the current state context (e.g.,
        // from any higher-level groups) with the current element's style parameters.
        Context Context
}

func NewPath(pt ppath.Path, sty *styles.Paint, ctx *Context) *Path {
        pe := &Path{Path: pt}
        pe.Context.Init(sty, nil, ctx)
        return pe
}

// interface assertion.
func (p *Path) IsRenderItem() {}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package render

import (
        "reflect"
        "slices"

        "cogentcore.org/core/base/reflectx"
)

// Render is the sequence of painting [Item]s recorded
// from a [paint.Painter]
type Render []Item

// Clone returns a copy of this Render,
// with shallow clones of the Items and Renderers lists.
func (pr *Render) Clone() Render {
        return slices.Clone(*pr)
}

// Add adds item(s) to render. Filters any nil items.
func (pr *Render) Add(item ...Item) *Render {
        for _, it := range item {
                if reflectx.IsNil(reflect.ValueOf(it)) {
                        continue
                }
                *pr = append(*pr, it)
        }
        return pr
}

// Reset resets back to an empty Render state.
// It preserves the existing slice memory for re-use.
func (pr *Render) Reset() {
        *pr = (*pr)[:0]
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package render

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/text/shaped"
)

// Text is a text rendering render item.
type Text struct {
        // Text contains shaped Lines of text to be rendered, as produced by a
        // [shaped.Shaper]. Typically this text is  configured so that the
        // Postion is at the upper left corner of the resulting text rendering.
        Text *shaped.Lines

        // Position to render, which typically specifies the upper left corner of
        // the Text. This is added directly to the offsets and is transformed by the
        // active transform matrix. See also PositionAbs
        Position math32.Vector2

        // Context has the full accumulated style, transform, etc parameters
        // for rendering, combining the current state context (e.g.,
        // from any higher-level groups) with the current element's style parameters.
        Context Context
}

func NewText(txt *shaped.Lines, sty *styles.Paint, ctx *Context, pos math32.Vector2) *Text {
        nt := &Text{Text: txt, Position: pos}
        nt.Context.Init(sty, nil, ctx)
        return nt
}

// interface assertion.
func (tx *Text) IsRenderItem() {}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/rasterx:
// Copyright 2018 by the rasterx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

package rasterx

import (
        "golang.org/x/image/math/fixed"
)

// Dasher struct extends the Stroker and can draw
// dashed lines with end capping
type Dasher struct {
        Stroker
        Dashes         []fixed.Int26_6
        DashPlace      int
        FirstDashIsGap bool
        DashIsGap      bool
        DeltaDash      fixed.Int26_6
        DashOffset     fixed.Int26_6

        // Sgm allows us to switch between dashing
        // and non-dashing rasterizers in the SetStroke function.
        Sgm Raster
}

// NewDasher returns a Dasher ptr with default values.
// A Dasher has all of the capabilities of a Stroker, Filler, and Scanner, plus the ability
// to stroke curves with solid lines. Use SetStroke to configure with non-default
// values.
func NewDasher(width, height int, scanner Scanner) *Dasher {
        r := new(Dasher)
        r.Scanner = scanner
        r.SetBounds(width, height)
        r.SetWinding(true)
        r.SetStroke(1*64, 4*64, ButtCap, nil, FlatGap, MiterClip, nil, 0)
        r.Sgm = &r.Stroker
        return r
}

// JoinF overides stroker JoinF during dashed stroking, because we need to slightly modify
// the the call as below to handle the case of the join being in a dash gap.
func (r *Dasher) JoinF() {
        if len(r.Dashes) == 0 || !r.InStroke || !r.DashIsGap {
                r.Stroker.JoinF()
        }
}

// Start starts a dashed line
func (r *Dasher) Start(a fixed.Point26_6) {
        // Advance dashPlace to the dashOffset start point and set deltaDash
        if len(r.Dashes) > 0 {
                r.DeltaDash = r.DashOffset
                r.DashIsGap = false
                r.DashPlace = 0
                for r.DeltaDash > r.Dashes[r.DashPlace] {
                        r.DeltaDash -= r.Dashes[r.DashPlace]
                        r.DashIsGap = !r.DashIsGap
                        r.DashPlace++
                        if r.DashPlace == len(r.Dashes) {
                                r.DashPlace = 0
                        }
                }
                r.FirstDashIsGap = r.DashIsGap
        }
        r.Stroker.Start(a)
}

// LineF overides stroker LineF to modify the the call as below
// while performing the join in a dashed stroke.
func (r *Dasher) LineF(b fixed.Point26_6) {
        var bnorm fixed.Point26_6
        a := r.A // Copy local a since r.a is going to change during stroke operation
        ba := b.Sub(a)
        segLen := Length(ba)
        var nlt fixed.Int26_6
        if b == r.LeadPoint.P { // End of segment
                bnorm = r.LeadPoint.TNorm // Use more accurate leadPoint tangent
        } else {
                bnorm = TurnPort90(ToLength(b.Sub(a), r.U)) // Intra segment normal
        }
        for segLen+r.DeltaDash > r.Dashes[r.DashPlace] {
                nl := r.Dashes[r.DashPlace] - r.DeltaDash
                nlt += nl
                r.DashLineStrokeBit(a.Add(ToLength(ba, nlt)), bnorm, false)
                r.DashIsGap = !r.DashIsGap
                segLen -= nl
                r.DeltaDash = 0
                r.DashPlace++
                if r.DashPlace == len(r.Dashes) {
                        r.DashPlace = 0
                }
        }
        r.DeltaDash += segLen
        r.DashLineStrokeBit(b, bnorm, true)
}

// SetStroke set the parameters for stroking a line. width is the width of the line, miterlimit is the miter cutoff
// value for miter, arc, miterclip and arcClip joinModes. CapL and CapT are the capping functions for leading and trailing
// line ends. If one is nil, the other function is used at both ends. gp is the gap function that determines how a
// gap on the convex side of two lines joining is filled. jm is the JoinMode for curve segments. Dashes is the values for
// the dash pattern. Pass in nil or an empty slice for no dashes. dashoffset is the starting offset into the dash array.
func (r *Dasher) SetStroke(width, miterLimit fixed.Int26_6, capL, capT CapFunc, gp GapFunc, jm JoinMode, dashes []float32, dashOffset float32) {
        r.Stroker.SetStroke(width, miterLimit, capL, capT, gp, jm)

        r.Dashes = r.Dashes[:0] // clear the dash array
        if len(dashes) == 0 {
                r.Sgm = &r.Stroker // This is just plain stroking
                return
        }
        // Dashed Stroke
        // Convert the float dash array and offset to fixed point and attach to the Filler
        oneIsPos := false // Check to see if at least one dash is > 0
        for _, v := range dashes {
                fv := fixed.Int26_6(v * 64)
                if fv <= 0 { // Negatives are considered 0s.
                        fv = 0
                } else {
                        oneIsPos = true
                }
                r.Dashes = append(r.Dashes, fv)
        }
        if !oneIsPos {
                r.Dashes = r.Dashes[:0]
                r.Sgm = &r.Stroker // This is just plain stroking
                return
        }
        r.DashOffset = fixed.Int26_6(dashOffset * 64)
        r.Sgm = r // Use the full dasher
}

// Stop terminates a dashed line
func (r *Dasher) Stop(isClosed bool) {
        if len(r.Dashes) == 0 {
                r.Stroker.Stop(isClosed)
                return
        }
        if !r.InStroke {
                return
        }
        if isClosed && r.A != r.FirstP.P {
                r.LineSeg(r.Sgm, r.FirstP.P)
        }
        ra := &r.Filler
        if isClosed && !r.FirstDashIsGap && !r.DashIsGap { // closed connect w/o caps
                a := r.A
                r.FirstP.TNorm = r.LeadPoint.TNorm
                r.FirstP.RT = r.LeadPoint.RT
                r.FirstP.TTan = r.LeadPoint.TTan
                ra.Start(r.FirstP.P.Sub(r.FirstP.TNorm))
                ra.Line(a.Sub(r.Ln))
                ra.Start(a.Add(r.Ln))
                ra.Line(r.FirstP.P.Add(r.FirstP.TNorm))
                r.Joiner(r.FirstP)
                r.FirstP.BlackWidowMark(ra)
        } else { // Cap open ends
                if !r.DashIsGap {
                        r.CapL(ra, r.LeadPoint.P, r.LeadPoint.TNorm)
                }
                if !r.FirstDashIsGap {
                        r.CapT(ra, r.FirstP.P, Invert(r.FirstP.LNorm))
                }
        }
        r.InStroke = false
}

// DashLineStrokeBit is a helper function that reduces code redundancy in the
// LineF function.
func (r *Dasher) DashLineStrokeBit(b, bnorm fixed.Point26_6, dontClose bool) {
        if !r.DashIsGap { // Moving from dash to gap
                a := r.A
                ra := &r.Filler
                ra.Start(b.Sub(bnorm))
                ra.Line(a.Sub(r.Ln))
                ra.Start(a.Add(r.Ln))
                ra.Line(b.Add(bnorm))
                if !dontClose {
                        r.CapL(ra, b, bnorm)
                }
        } else { // Moving from gap to dash
                if !dontClose {
                        ra := &r.Filler
                        r.CapT(ra, b, Invert(bnorm))
                }
        }
        r.A = b
        r.Ln = bnorm
}

// Line for Dasher is here to pass the dasher sgm to LineP
func (r *Dasher) Line(b fixed.Point26_6) {
        r.LineSeg(r.Sgm, b)
}

// QuadBezier for dashing
func (r *Dasher) QuadBezier(b, c fixed.Point26_6) {
        r.QuadBezierf(r.Sgm, b, c)
}

// CubeBezier starts a stroked cubic bezier.
// It is a low level function exposed for the purposes of callbacks
// and debugging.
func (r *Dasher) CubeBezier(b, c, d fixed.Point26_6) {
        r.CubeBezierf(r.Sgm, b, c, d)
}

// Code generated by "core generate"; DO NOT EDIT.

package rasterx

import (
        "cogentcore.org/core/enums"
)

var _PathCommandValues = []PathCommand{0, 1, 2, 3, 4}

// PathCommandN is the highest valid value for type PathCommand, plus one.
const PathCommandN PathCommand = 5

var _PathCommandValueMap = map[string]PathCommand{`PathMoveTo`: 0, `PathLineTo`: 1, `PathQuadTo`: 2, `PathCubicTo`: 3, `PathClose`: 4}

var _PathCommandDescMap = map[PathCommand]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``}

var _PathCommandMap = map[PathCommand]string{0: `PathMoveTo`, 1: `PathLineTo`, 2: `PathQuadTo`, 3: `PathCubicTo`, 4: `PathClose`}

// String returns the string representation of this PathCommand value.
func (i PathCommand) String() string { return enums.String(i, _PathCommandMap) }

// SetString sets the PathCommand value from its string representation,
// and returns an error if the string is invalid.
func (i *PathCommand) SetString(s string) error {
        return enums.SetString(i, s, _PathCommandValueMap, "PathCommand")
}

// Int64 returns the PathCommand value as an int64.
func (i PathCommand) Int64() int64 { return int64(i) }

// SetInt64 sets the PathCommand value from an int64.
func (i *PathCommand) SetInt64(in int64) { *i = PathCommand(in) }

// Desc returns the description of the PathCommand value.
func (i PathCommand) Desc() string { return enums.Desc(i, _PathCommandDescMap) }

// PathCommandValues returns all possible values for the type PathCommand.
func PathCommandValues() []PathCommand { return _PathCommandValues }

// Values returns all possible values for the type PathCommand.
func (i PathCommand) Values() []enums.Enum { return enums.Values(_PathCommandValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i PathCommand) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *PathCommand) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "PathCommand")
}

var _JoinModeValues = []JoinMode{0, 1, 2, 3, 4, 5}

// JoinModeN is the highest valid value for type JoinMode, plus one.
const JoinModeN JoinMode = 6

var _JoinModeValueMap = map[string]JoinMode{`Arc`: 0, `ArcClip`: 1, `Miter`: 2, `MiterClip`: 3, `Bevel`: 4, `Round`: 5}

var _JoinModeDescMap = map[JoinMode]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``, 5: ``}

var _JoinModeMap = map[JoinMode]string{0: `Arc`, 1: `ArcClip`, 2: `Miter`, 3: `MiterClip`, 4: `Bevel`, 5: `Round`}

// String returns the string representation of this JoinMode value.
func (i JoinMode) String() string { return enums.String(i, _JoinModeMap) }

// SetString sets the JoinMode value from its string representation,
// and returns an error if the string is invalid.
func (i *JoinMode) SetString(s string) error {
        return enums.SetString(i, s, _JoinModeValueMap, "JoinMode")
}

// Int64 returns the JoinMode value as an int64.
func (i JoinMode) Int64() int64 { return int64(i) }

// SetInt64 sets the JoinMode value from an int64.
func (i *JoinMode) SetInt64(in int64) { *i = JoinMode(in) }

// Desc returns the description of the JoinMode value.
func (i JoinMode) Desc() string { return enums.Desc(i, _JoinModeDescMap) }

// JoinModeValues returns all possible values for the type JoinMode.
func JoinModeValues() []JoinMode { return _JoinModeValues }

// Values returns all possible values for the type JoinMode.
func (i JoinMode) Values() []enums.Enum { return enums.Values(_JoinModeValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i JoinMode) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *JoinMode) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "JoinMode") }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/rasterx:
// Copyright 2018 by the rasterx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

package rasterx

import (
        "cogentcore.org/core/math32"
        "golang.org/x/image/math/fixed"
)

// Filler is a filler that implements [Raster].
type Filler struct {
        Scanner
        A     fixed.Point26_6
        First fixed.Point26_6
}

// NewFiller returns a Filler ptr with default values.
// A Filler in addition to rasterizing lines like a Scann,
// can also rasterize quadratic and cubic bezier curves.
// If Scanner is nil default scanner ScannerGV is used
func NewFiller(width, height int, scanner Scanner) *Filler {
        r := new(Filler)
        r.Scanner = scanner
        r.SetBounds(width, height)
        r.SetWinding(true)
        return r
}

// Start starts a new path at the given point.
func (r *Filler) Start(a fixed.Point26_6) {
        r.A = a
        r.First = a
        r.Scanner.Start(a)
}

// Stop sends a path at the given point.
func (r *Filler) Stop(isClosed bool) {
        if r.First != r.A {
                r.Line(r.First)
        }
}

// QuadBezier adds a quadratic segment to the current curve.
func (r *Filler) QuadBezier(b, c fixed.Point26_6) {
        r.QuadBezierF(r, b, c)
}

// QuadTo flattens the quadratic Bezier curve into lines through the LineTo func
// This functions is adapted from the version found in
// golang.org/x/image/vector
func QuadTo(ax, ay, bx, by, cx, cy float32, LineTo func(dx, dy float32)) {
        devsq := DevSquared(ax, ay, bx, by, cx, cy)
        if devsq >= 0.333 {
                const tol = 3
                n := 1 + int(math32.Sqrt(math32.Sqrt(tol*float32(devsq))))
                t, nInv := float32(0), 1/float32(n)
                for i := 0; i < n-1; i++ {
                        t += nInv

                        mt := 1 - t
                        t1 := mt * mt
                        t2 := mt * t * 2
                        t3 := t * t
                        LineTo(
                                ax*t1+bx*t2+cx*t3,
                                ay*t1+by*t2+cy*t3)
                }
        }
        LineTo(cx, cy)
}

// CubeTo flattens the cubic Bezier curve into lines through the LineTo func
// This functions is adapted from the version found in
// golang.org/x/image/vector
func CubeTo(ax, ay, bx, by, cx, cy, dx, dy float32, LineTo func(ex, ey float32)) {
        devsq := DevSquared(ax, ay, bx, by, dx, dy)
        if devsqAlt := DevSquared(ax, ay, cx, cy, dx, dy); devsq < devsqAlt {
                devsq = devsqAlt
        }
        if devsq >= 0.333 {
                const tol = 3
                n := 1 + int(math32.Sqrt(math32.Sqrt(tol*float32(devsq))))
                t, nInv := float32(0), 1/float32(n)
                for i := 0; i < n-1; i++ {
                        t += nInv

                        tsq := t * t
                        mt := 1 - t
                        mtsq := mt * mt
                        t1 := mtsq * mt
                        t2 := mtsq * t * 3
                        t3 := mt * tsq * 3
                        t4 := tsq * t
                        LineTo(
                                ax*t1+bx*t2+cx*t3+dx*t4,
                                ay*t1+by*t2+cy*t3+dy*t4)
                }
        }
        LineTo(dx, dy)
}

// DevSquared returns a measure of how curvy the sequence (ax, ay) to (bx, by)
// to (cx, cy) is. It determines how many line segments will approximate a
// Bézier curve segment. This functions is copied from the version found in
// golang.org/x/image/vector as are the below comments.
//
// http://lists.nongnu.org/archive/html/freetype-devel/2016-08/msg00080.html
// gives the rationale for this evenly spaced heuristic instead of a recursive
// de Casteljau approach:
//
// The reason for the subdivision by n is that I expect the "flatness"
// computation to be semi-expensive (it's done once rather than on each
// potential subdivision) and also because you'll often get fewer subdivisions.
// Taking a circular arc as a simplifying assumption (ie a spherical cow),
// where I get n, a recursive approach would get 2^⌈lg n⌉, which, if I haven't
// made any horrible mistakes, is expected to be 33% more in the limit.
func DevSquared(ax, ay, bx, by, cx, cy float32) float32 {
        devx := ax - 2*bx + cx
        devy := ay - 2*by + cy
        return devx*devx + devy*devy
}

// QuadBezierF adds a quadratic segment to the sgm Rasterizer.
func (r *Filler) QuadBezierF(sgm Raster, b, c fixed.Point26_6) {
        // check for degenerate bezier
        if r.A == b || b == c {
                sgm.Line(c)
                return
        }
        sgm.JoinF()
        QuadTo(float32(r.A.X), float32(r.A.Y), // Pts are x64, but does not matter.
                float32(b.X), float32(b.Y),
                float32(c.X), float32(c.Y),
                func(dx, dy float32) {
                        sgm.LineF(fixed.Point26_6{X: fixed.Int26_6(dx), Y: fixed.Int26_6(dy)})
                })

}

// CubeBezier adds a cubic bezier to the curve
func (r *Filler) CubeBezier(b, c, d fixed.Point26_6) {
        r.CubeBezierF(r, b, c, d)
}

// JoinF is a no-op for a filling rasterizer. This is used in stroking and dashed
// stroking
func (r *Filler) JoinF() {

}

// Line for a filling rasterizer is just the line call in scan
func (r *Filler) Line(b fixed.Point26_6) {
        r.LineF(b)
}

// LineF for a filling rasterizer is just the line call in scan
func (r *Filler) LineF(b fixed.Point26_6) {
        r.Scanner.Line(b)
        r.A = b
}

// CubeBezierF adds a cubic bezier to the curve. sending the line calls the the
// sgm Rasterizer
func (r *Filler) CubeBezierF(sgm Raster, b, c, d fixed.Point26_6) {
        if (r.A == b && c == d) || (r.A == b && b == c) || (c == b && d == c) {
                sgm.Line(d)
                return
        }
        sgm.JoinF()
        CubeTo(float32(r.A.X), float32(r.A.Y),
                float32(b.X), float32(b.Y),
                float32(c.X), float32(c.Y),
                float32(d.X), float32(d.Y),
                func(ex, ey float32) {
                        sgm.LineF(fixed.Point26_6{X: fixed.Int26_6(ex), Y: fixed.Int26_6(ey)})
                })
}

// Clear resets the filler
func (r *Filler) Clear() {
        r.A = fixed.Point26_6{}
        r.First = r.A
        r.Scanner.Clear()
}

// SetBounds sets the maximum width and height of the rasterized image and
// calls Clear. The width and height are in pixels, not fixed.Int26_6 units.
func (r *Filler) SetBounds(width, height int) {
        if width < 0 {
                width = 0
        }
        if height < 0 {
                height = 0
        }
        r.Scanner.SetBounds(width, height)
        r.Clear()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/rasterx:
// Copyright 2018 by the rasterx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

package rasterx

import (
        "fmt"

        "cogentcore.org/core/math32"
        "golang.org/x/image/math/fixed"
)

// Invert returns the point inverted around the origin
func Invert(v fixed.Point26_6) fixed.Point26_6 {
        return fixed.Point26_6{X: -v.X, Y: -v.Y}
}

// TurnStarboard90 returns the vector 90 degrees starboard (right in direction heading)
func TurnStarboard90(v fixed.Point26_6) fixed.Point26_6 {
        return fixed.Point26_6{X: -v.Y, Y: v.X}
}

// TurnPort90 returns the vector 90 degrees port (left in direction heading)
func TurnPort90(v fixed.Point26_6) fixed.Point26_6 {
        return fixed.Point26_6{X: v.Y, Y: -v.X}
}

// DotProd returns the inner product of p and q
func DotProd(p fixed.Point26_6, q fixed.Point26_6) fixed.Int52_12 {
        return fixed.Int52_12(int64(p.X)*int64(q.X) + int64(p.Y)*int64(q.Y))
}

// Length is the distance from the origin of the point
func Length(v fixed.Point26_6) fixed.Int26_6 {
        vx, vy := float32(v.X), float32(v.Y)
        return fixed.Int26_6(math32.Sqrt(vx*vx + vy*vy))
}

// PathCommand is the type for the path command token
type PathCommand fixed.Int26_6 //enums:enum -no-extend

// Human readable path command constants
const (
        PathMoveTo PathCommand = iota
        PathLineTo
        PathQuadTo
        PathCubicTo
        PathClose
)

// A Path starts with a PathCommand value followed by zero to three fixed
// int points.
type Path []fixed.Int26_6

// ToSVGPath returns a string representation of the path
func (p Path) ToSVGPath() string {
        s := ""
        for i := 0; i < len(p); {
                if i != 0 {
                        s += " "
                }
                switch PathCommand(p[i]) {
                case PathMoveTo:
                        s += fmt.Sprintf("M%4.3f,%4.3f", float32(p[i+1])/64, float32(p[i+2])/64)
                        i += 3
                case PathLineTo:
                        s += fmt.Sprintf("L%4.3f,%4.3f", float32(p[i+1])/64, float32(p[i+2])/64)
                        i += 3
                case PathQuadTo:
                        s += fmt.Sprintf("Q%4.3f,%4.3f,%4.3f,%4.3f", float32(p[i+1])/64, float32(p[i+2])/64,
                                float32(p[i+3])/64, float32(p[i+4])/64)
                        i += 5
                case PathCubicTo:
                        s += "C" + fmt.Sprintf("C%4.3f,%4.3f,%4.3f,%4.3f,%4.3f,%4.3f", float32(p[i+1])/64, float32(p[i+2])/64,
                                float32(p[i+3])/64, float32(p[i+4])/64, float32(p[i+5])/64, float32(p[i+6])/64)
                        i += 7
                case PathClose:
                        s += "Z"
                        i++
                default:
                        panic("freetype/rasterx: bad pather")
                }
        }
        return s
}

// String returns a readable representation of a Path.
func (p Path) String() string {
        return p.ToSVGPath()
}

// Clear zeros the path slice
func (p *Path) Clear() {
        *p = (*p)[:0]
}

// Start starts a new curve at the given point.
func (p *Path) Start(a fixed.Point26_6) {
        *p = append(*p, fixed.Int26_6(PathMoveTo), a.X, a.Y)
}

// Line adds a linear segment to the current curve.
func (p *Path) Line(b fixed.Point26_6) {
        *p = append(*p, fixed.Int26_6(PathLineTo), b.X, b.Y)
}

// QuadBezier adds a quadratic segment to the current curve.
func (p *Path) QuadBezier(b, c fixed.Point26_6) {
        *p = append(*p, fixed.Int26_6(PathQuadTo), b.X, b.Y, c.X, c.Y)
}

// CubeBezier adds a cubic segment to the current curve.
func (p *Path) CubeBezier(b, c, d fixed.Point26_6) {
        *p = append(*p, fixed.Int26_6(PathCubicTo), b.X, b.Y, c.X, c.Y, d.X, d.Y)
}

// Stop joins the ends of the path
func (p *Path) Stop(closeLoop bool) {
        if closeLoop {
                *p = append(*p, fixed.Int26_6(PathClose))
        }
}

// AddTo adds the Path p to q.
func (p Path) AddTo(q Adder) {
        for i := 0; i < len(p); {
                switch PathCommand(p[i]) {
                case PathMoveTo:
                        q.Stop(false) // Fixes issues #1 by described by Djadala; implicit close if currently in path.
                        q.Start(fixed.Point26_6{X: p[i+1], Y: p[i+2]})
                        i += 3
                case PathLineTo:
                        q.Line(fixed.Point26_6{X: p[i+1], Y: p[i+2]})
                        i += 3
                case PathQuadTo:
                        q.QuadBezier(fixed.Point26_6{X: p[i+1], Y: p[i+2]}, fixed.Point26_6{X: p[i+3], Y: p[i+4]})
                        i += 5
                case PathCubicTo:
                        q.CubeBezier(fixed.Point26_6{X: p[i+1], Y: p[i+2]},
                                fixed.Point26_6{X: p[i+3], Y: p[i+4]}, fixed.Point26_6{X: p[i+5], Y: p[i+6]})
                        i += 7
                case PathClose:
                        q.Stop(true)
                        i++
                default:
                        panic("AddTo: bad path")
                }
        }
        q.Stop(false)
}

// ToLength scales the point to the length indicated by ln
func ToLength(p fixed.Point26_6, ln fixed.Int26_6) (q fixed.Point26_6) {
        if ln == 0 || (p.X == 0 && p.Y == 0) {
                return
        }

        pX, pY := float32(p.X), float32(p.Y)
        lnF := float32(ln)
        pLen := math32.Sqrt(pX*pX + pY*pY)

        qX, qY := pX*lnF/pLen, pY*lnF/pLen
        q.X, q.Y = fixed.Int26_6(qX), fixed.Int26_6(qY)
        return
}

// ClosestPortside returns the closest of p1 or p2 on the port side of the
// line from the bow to the stern. (port means left side of the direction you are heading)
// isIntersecting is just convienice to reduce code, and if false returns false, because p1 and p2 are not valid
func ClosestPortside(bow, stern, p1, p2 fixed.Point26_6, isIntersecting bool) (xt fixed.Point26_6, intersects bool) {
        if !isIntersecting {
                return
        }
        dir := bow.Sub(stern)
        dp1 := p1.Sub(stern)
        dp2 := p2.Sub(stern)
        cp1 := dir.X*dp1.Y - dp1.X*dir.Y
        cp2 := dir.X*dp2.Y - dp2.X*dir.Y
        switch {
        case cp1 < 0 && cp2 < 0:
                return
        case cp1 < 0 && cp2 >= 0:
                return p2, true
        case cp1 >= 0 && cp2 < 0:
                return p1, true
        default: // both points on port side
                dirdot := DotProd(dir, dir)
                // calculate vector rejections of dp1 and dp2 onto dir
                h1 := dp1.Sub(dir.Mul(fixed.Int26_6((DotProd(dp1, dir) << 6) / dirdot)))
                h2 := dp2.Sub(dir.Mul(fixed.Int26_6((DotProd(dp2, dir) << 6) / dirdot)))
                // return point with smallest vector rejection; i.e. closest to dir line
                if (h1.X*h1.X + h1.Y*h1.Y) > (h2.X*h2.X + h2.Y*h2.Y) {
                        return p2, true
                }
                return p1, true
        }
}

// RadCurvature returns the curvature of a Bezier curve end point,
// given an end point, the two adjacent control points and the degree.
// The sign of the value indicates if the center of the osculating circle
// is left or right (port or starboard) of the curve in the forward direction.
func RadCurvature(p0, p1, p2 fixed.Point26_6, dm fixed.Int52_12) fixed.Int26_6 {
        a, b := p2.Sub(p1), p1.Sub(p0)
        abdot, bbdot := DotProd(a, b), DotProd(b, b)
        h := a.Sub(b.Mul(fixed.Int26_6((abdot << 6) / bbdot))) // h is the vector rejection of a onto b
        if h.X == 0 && h.Y == 0 {                              // points are co-linear
                return 0
        }
        radCurve := fixed.Int26_6((fixed.Int52_12(a.X*a.X+a.Y*a.Y) * dm / fixed.Int52_12(Length(h)<<6)) >> 6)
        if a.X*b.Y > b.X*a.Y { // xprod sign
                return radCurve
        }
        return -radCurve
}

// CircleCircleIntersection calculates the points of intersection of
// two circles or returns with intersects == false if no such points exist.
func CircleCircleIntersection(ct, cl fixed.Point26_6, rt, rl fixed.Int26_6) (xt1, xt2 fixed.Point26_6, intersects bool) {
        dc := cl.Sub(ct)
        d := Length(dc)

        // Check for solvability.
        if d > (rt + rl) {
                return // No solution. Circles do not intersect.
        }
        // check if  d < abs(rt-rl)
        if da := rt - rl; (da > 0 && d < da) || (da < 0 && d < -da) {
                return // No solution. One circle is contained by the other.
        }

        rlf, rtf, df := float32(rl), float32(rt), float32(d)
        af := (rtf*rtf - rlf*rlf + df*df) / df / 2.0
        hfd := math32.Sqrt(rtf*rtf-af*af) / df
        afd := af / df

        rOffx, rOffy := float32(-dc.Y)*hfd, float32(dc.X)*hfd
        p2x := float32(ct.X) + float32(dc.X)*afd
        p2y := float32(ct.Y) + float32(dc.Y)*afd
        xt1x, xt1y := p2x+rOffx, p2y+rOffy
        xt2x, xt2y := p2x-rOffx, p2y-rOffy
        return fixed.Point26_6{X: fixed.Int26_6(xt1x), Y: fixed.Int26_6(xt1y)},
                fixed.Point26_6{X: fixed.Int26_6(xt2x), Y: fixed.Int26_6(xt2y)}, true
}

// CalcIntersect calculates the points of intersection of two fixed point lines
// and panics if the determinate is zero. You have been warned.
func CalcIntersect(a1, a2, b1, b2 fixed.Point26_6) (x fixed.Point26_6) {
        da, db, ds := a2.Sub(a1), b2.Sub(b1), a1.Sub(b1)
        det := float32(da.X*db.Y - db.X*da.Y) // Determinate
        t := float32(ds.Y*db.X-ds.X*db.Y) / det
        x = a1.Add(fixed.Point26_6{X: fixed.Int26_6(float32(da.X) * t), Y: fixed.Int26_6(float32(da.Y) * t)})
        return
}

// RayCircleIntersection calculates the points of intersection of
// a ray starting at s2 passing through s1 and a circle in fixed point.
// Returns intersects == false if no solution is possible. If two
// solutions are possible, the point closest to s2 is returned
func RayCircleIntersection(s1, s2, c fixed.Point26_6, r fixed.Int26_6) (x fixed.Point26_6, intersects bool) {
        fx, fy, intersects := RayCircleIntersectionF(float32(s1.X), float32(s1.Y),
                float32(s2.X), float32(s2.Y), float32(c.X), float32(c.Y), float32(r))
        return fixed.Point26_6{X: fixed.Int26_6(fx),
                Y: fixed.Int26_6(fy)}, intersects

}

// RayCircleIntersectionF calculates in floating point the points of intersection of
// a ray starting at s2 passing through s1 and a circle in fixed point.
// Returns intersects == false if no solution is possible. If two
// solutions are possible, the point closest to s2 is returned
func RayCircleIntersectionF(s1X, s1Y, s2X, s2Y, cX, cY, r float32) (x, y float32, intersects bool) {
        n := s2X - cX // Calculating using 64* rather than divide
        m := s2Y - cY

        e := s2X - s1X
        d := s2Y - s1Y

        // Quadratic normal form coefficients
        A, B, C := e*e+d*d, -2*(e*n+m*d), n*n+m*m-r*r

        D := B*B - 4*A*C

        if D <= 0 {
                return // No intersection or is tangent
        }

        D = math32.Sqrt(D)
        t1, t2 := (-B+D)/(2*A), (-B-D)/(2*A)
        p1OnSide := t1 > 0
        p2OnSide := t2 > 0

        switch {
        case p1OnSide && p2OnSide:
                if t2 < t1 { // both on ray, use closest to s2
                        t1 = t2
                }
        case p2OnSide: // Only p2 on ray
                t1 = t2
        case p1OnSide: // only p1 on ray
        default: // Neither solution is on the ray
                return
        }
        return (n - e*t1) + cX, (m - d*t1) + cY, true
}

// MatrixAdder is an adder that applies matrix M to all points
type MatrixAdder struct {
        Adder
        M math32.Matrix2
}

// Reset sets the matrix M to identity
func (t *MatrixAdder) Reset() {
        t.M = math32.Identity2()
}

// Start starts a new path
func (t *MatrixAdder) Start(a fixed.Point26_6) {
        t.Adder.Start(t.M.MulFixedAsPoint(a))
}

// Line adds a linear segment to the current curve.
func (t *MatrixAdder) Line(b fixed.Point26_6) {
        t.Adder.Line(t.M.MulFixedAsPoint(b))
}

// QuadBezier adds a quadratic segment to the current curve.
func (t *MatrixAdder) QuadBezier(b, c fixed.Point26_6) {
        t.Adder.QuadBezier(t.M.MulFixedAsPoint(b), t.M.MulFixedAsPoint(c))
}

// CubeBezier adds a cubic segment to the current curve.
func (t *MatrixAdder) CubeBezier(b, c, d fixed.Point26_6) {
        t.Adder.CubeBezier(t.M.MulFixedAsPoint(b), t.M.MulFixedAsPoint(c), t.M.MulFixedAsPoint(d))
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rasterx

import (
        "image"
        "image/color"
        "image/draw"
        "sync"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/renderers/rasterx/scan"
        "github.com/go-text/typesetting/font"
        "github.com/go-text/typesetting/font/opentype"
        "github.com/go-text/typesetting/shaping"
)

var (
        // TheGlyphCache is the shared font glyph bitmap render cache.
        theGlyphCache glyphCache

        // UseGlyphCache determines if the glyph cache is used.
        UseGlyphCache = true
)

const (
        // glyphMaxSize is the max size in either dim for the render mask.
        glyphMaxSize = 128

        // glyphMaskBorder is the extra amount on each side to include around the glyph bounds.
        glyphMaskBorder = 2

        // glyphMaskOffsets is the number of different subpixel offsets to render, in each axis.
        // The memory usage goes as the square of this number, and 4 produces very good results,
        // while 2 is acceptable, and is significantly better than 1. 8 is overkill.
        glyphMaskOffsets = 4
)

func init() {
        theGlyphCache.init()
}

// GlyphCache holds cached rendered font glyphs.
type glyphCache struct {
        glyphs     map[*font.Face]map[glyphKey]*image.Alpha
        maxSize    image.Point
        image      *image.RGBA
        scanner    *scan.Scanner
        imgSpanner *scan.ImgSpanner
        filler     *Filler
        sync.Mutex
}

// glyphKey is the key for encoding a mask render.
type glyphKey struct {
        gid font.GID // uint32
        sx  uint8    // size
        sy  uint8
        ox  uint8 // offset
        oy  uint8
}

func (fc *glyphCache) init() {
        fc.glyphs = make(map[*font.Face]map[glyphKey]*image.Alpha)
        fc.maxSize = image.Point{glyphMaxSize, glyphMaxSize}
        sz := fc.maxSize
        fc.image = image.NewRGBA(image.Rectangle{Max: sz})
        fc.imgSpanner = scan.NewImgSpanner(fc.image)
        fc.scanner = scan.NewScanner(fc.imgSpanner, sz.X, sz.Y)
        fc.filler = NewFiller(sz.X, sz.Y, fc.scanner)
        fc.filler.SetWinding(true)
        fc.filler.SetColor(colors.Uniform(color.Black))
        fc.scanner.SetClip(fc.image.Bounds())
}

// Glyph returns an existing cached glyph or a newly rendered one,
// and the top-left rendering position to use, based on pos arg.
// fractional offsets are supported to improve quality.
func (gc *glyphCache) Glyph(face *font.Face, g *shaping.Glyph, outline font.GlyphOutline, scale float32, pos math32.Vector2) (*image.Alpha, image.Point) {
        gc.Lock()
        defer gc.Unlock()

        fsize := image.Point{X: int(g.Width.Ceil()), Y: -int(g.Height.Ceil())}
        size := fsize.Add(image.Point{2 * glyphMaskBorder, 2 * glyphMaskBorder})
        if size.X <= 0 || size.X > glyphMaxSize || size.Y <= 0 || size.Y > glyphMaxSize {
                return nil, image.Point{}
        }
        // fmt.Println(face.Describe().Family, g.GlyphID, "wd, ht:", math32.FromFixed(g.Width), -math32.FromFixed(g.Height), "size:", size)
        // fmt.Printf("g: %#v\n", g)

        pf := pos.Floor()
        pi := pf.ToPoint().Sub(image.Point{glyphMaskBorder, glyphMaskBorder})
        pi.X += g.XBearing.Round()
        pi.Y -= g.YBearing.Round()
        off := pos.Sub(pf)
        oi := off.MulScalar(glyphMaskOffsets).Floor().ToPoint()
        // fmt.Println("pos:", pos, "oi:", oi, "pi:", pi)

        key := glyphKey{gid: g.GlyphID, sx: uint8(fsize.X), sy: uint8(fsize.Y), ox: uint8(oi.X), oy: uint8(oi.Y)}

        fc, hasfc := gc.glyphs[face]
        if hasfc {
                mask := fc[key]
                if mask != nil {
                        return mask, pi
                }
        } else {
                fc = make(map[glyphKey]*image.Alpha)
        }

        mask := gc.renderGlyph(face, g.GlyphID, g, outline, size, scale, oi.X, oi.Y)
        fc[key] = mask
        gc.glyphs[face] = fc
        // fmt.Println(gc.CacheSize())
        return mask, pi
}

// renderGlyph renders the given glyph and caches the result.
func (gc *glyphCache) renderGlyph(face *font.Face, gid font.GID, g *shaping.Glyph, outline font.GlyphOutline, size image.Point, scale float32, xo, yo int) *image.Alpha {
        // clear target:
        draw.Draw(gc.image, gc.image.Bounds(), colors.Uniform(color.Transparent), image.Point{0, 0}, draw.Src)

        od := float32(1) / glyphMaskOffsets
        x := -float32(g.XBearing.Round()) + float32(xo)*od + glyphMaskBorder
        y := float32(g.YBearing.Round()) + float32(yo)*od + glyphMaskBorder
        rs := gc.filler
        rs.Clear()
        for _, s := range outline.Segments {
                p0 := math32.Vec2(s.Args[0].X*scale+x, -s.Args[0].Y*scale+y)
                switch s.Op {
                case opentype.SegmentOpMoveTo:
                        rs.Start(p0.ToFixed())
                case opentype.SegmentOpLineTo:
                        rs.Line(p0.ToFixed())
                case opentype.SegmentOpQuadTo:
                        p1 := math32.Vec2(s.Args[1].X*scale+x, -s.Args[1].Y*scale+y)
                        rs.QuadBezier(p0.ToFixed(), p1.ToFixed())
                case opentype.SegmentOpCubeTo:
                        p1 := math32.Vec2(s.Args[1].X*scale+x, -s.Args[1].Y*scale+y)
                        p2 := math32.Vec2(s.Args[2].X*scale+x, -s.Args[2].Y*scale+y)
                        rs.CubeBezier(p0.ToFixed(), p1.ToFixed(), p2.ToFixed())
                }
        }
        rs.Stop(true)
        rs.Draw()
        rs.Clear()
        bb := image.Rectangle{Max: size}

        mask := image.NewAlpha(bb)
        draw.Draw(mask, bb, gc.image, image.Point{}, draw.Src)
        // fmt.Println("size:", size, *mask)
        // fmt.Println("render:", gid, size)
        return mask
}

// CacheSize reports the total number of bytes used for image masks.
// For example, the cogent core docs took about 3.5mb using 4
func (gc *glyphCache) CacheSize() int {
        gc.Lock()
        defer gc.Unlock()
        total := 0
        for _, fc := range gc.glyphs {
                for _, mask := range fc {
                        sz := mask.Bounds().Size()
                        total += sz.X * sz.Y
                }
        }
        return total
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rasterx

import (
        "image"
        "slices"

        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/pimage"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/paint/renderers/rasterx/scan"
        "cogentcore.org/core/styles/units"
)

// Renderer is the rasterx renderer.
type Renderer struct {
        size  math32.Vector2
        image *image.RGBA

        // Path is the current path.
        Path Path

        // rasterizer -- stroke / fill rendering engine from raster
        Raster *Dasher

        // scan scanner
        Scanner *scan.Scanner

        // scan spanner
        ImgSpanner *scan.ImgSpanner
}

func New(size math32.Vector2) render.Renderer {
        rs := &Renderer{}
        rs.SetSize(units.UnitDot, size)
        return rs
}

func (rs *Renderer) Image() image.Image { return rs.image }
func (rs *Renderer) Source() []byte     { return nil }

func (rs *Renderer) Size() (units.Units, math32.Vector2) {
        return units.UnitDot, rs.size
}

func (rs *Renderer) SetSize(un units.Units, size math32.Vector2) {
        if rs.size == size {
                return
        }
        rs.size = size
        psz := size.ToPointCeil()
        rs.image = image.NewRGBA(image.Rectangle{Max: psz})
        rs.ImgSpanner = scan.NewImgSpanner(rs.image)
        rs.Scanner = scan.NewScanner(rs.ImgSpanner, psz.X, psz.Y)
        rs.Raster = NewDasher(psz.X, psz.Y, rs.Scanner)
}

// Render is the main rendering function.
func (rs *Renderer) Render(r render.Render) render.Renderer {
        for _, ri := range r {
                switch x := ri.(type) {
                case *render.Path:
                        rs.RenderPath(x)
                case *pimage.Params:
                        x.Render(rs.image)
                case *render.Text:
                        rs.RenderText(x)
                }
        }
        return rs
}

func (rs *Renderer) RenderPath(pt *render.Path) {
        p := pt.Path
        if !ppath.ArcToCubeImmediate {
                p = p.ReplaceArcs()
        }
        pc := &pt.Context
        rs.Scanner.SetClip(pc.Bounds.Rect.ToRect())
        PathToRasterx(&rs.Path, p, pt.Context.Transform, math32.Vector2{})
        rs.Fill(pt)
        rs.Stroke(pt)
        rs.Path.Clear()
        rs.Raster.Clear()
}

func PathToRasterx(rs Adder, p ppath.Path, m math32.Matrix2, off math32.Vector2) {
        for s := p.Scanner(); s.Scan(); {
                cmd := s.Cmd()
                end := m.MulVector2AsPoint(s.End()).Add(off)
                switch cmd {
                case ppath.MoveTo:
                        rs.Start(end.ToFixed())
                case ppath.LineTo:
                        rs.Line(end.ToFixed())
                case ppath.QuadTo:
                        cp1 := m.MulVector2AsPoint(s.CP1()).Add(off)
                        rs.QuadBezier(cp1.ToFixed(), end.ToFixed())
                case ppath.CubeTo:
                        cp1 := m.MulVector2AsPoint(s.CP1()).Add(off)
                        cp2 := m.MulVector2AsPoint(s.CP2()).Add(off)
                        rs.CubeBezier(cp1.ToFixed(), cp2.ToFixed(), end.ToFixed())
                case ppath.Close:
                        rs.Stop(true)
                }
        }
}

func (rs *Renderer) Stroke(pt *render.Path) {
        pc := &pt.Context
        sty := &pc.Style
        if !sty.HasStroke() {
                return
        }

        dash := slices.Clone(sty.Stroke.Dashes)
        if dash != nil {
                scx, scy := pc.Transform.ExtractScale()
                sc := 0.5 * (math32.Abs(scx) + math32.Abs(scy))
                for i := range dash {
                        dash[i] *= sc
                }
        }

        sw := rs.StrokeWidth(pt)
        rs.Raster.SetStroke(
                math32.ToFixed(sw),
                math32.ToFixed(sty.Stroke.MiterLimit),
                capfunc(sty.Stroke.Cap), nil, nil, joinmode(sty.Stroke.Join),
                dash, 0)
        rs.Path.AddTo(rs.Raster)
        rs.SetColor(rs.Raster, pc, sty.Stroke.Color, sty.Stroke.Opacity)
        rs.Raster.Draw()
}

func (rs *Renderer) SetColor(sc Scanner, pc *render.Context, clr image.Image, opacity float32) {
        if g, ok := clr.(gradient.Gradient); ok {
                fbox := sc.GetPathExtent()
                lastRenderBBox := image.Rectangle{Min: image.Point{fbox.Min.X.Floor(), fbox.Min.Y.Floor()},
                        Max: image.Point{fbox.Max.X.Ceil(), fbox.Max.Y.Ceil()}}
                g.Update(opacity, math32.B2FromRect(lastRenderBBox), pc.Transform)
                sc.SetColor(clr)
        } else {
                if opacity < 1 {
                        sc.SetColor(gradient.ApplyOpacity(clr, opacity))
                } else {
                        sc.SetColor(clr)
                }
        }
}

// Fill fills the current path with the current color. Open subpaths
// are implicitly closed. The path is preserved after this operation.
func (rs *Renderer) Fill(pt *render.Path) {
        pc := &pt.Context
        sty := &pc.Style
        if !sty.HasFill() {
                return
        }
        rf := &rs.Raster.Filler
        rf.SetWinding(sty.Fill.Rule == ppath.NonZero)
        rs.Path.AddTo(rf)
        rs.SetColor(rf, pc, sty.Fill.Color, sty.Fill.Opacity)
        rf.Draw()
        rf.Clear()
}

func MeanScale(m math32.Matrix2) float32 {
        scx, scy := m.ExtractScale()
        return 0.5 * (math32.Abs(scx) + math32.Abs(scy))
}

// StrokeWidth obtains the current stoke width subject to transform (or not
// depending on VecEffNonScalingStroke)
func (rs *Renderer) StrokeWidth(pt *render.Path) float32 {
        pc := &pt.Context
        sty := &pc.Style
        dw := sty.Stroke.Width.Dots
        if dw == 0 {
                return dw
        }
        if sty.VectorEffect == ppath.VectorEffectNonScalingStroke {
                return dw
        }
        sc := MeanScale(pt.Context.Transform)
        lw := math32.Max(sc*dw, sty.Stroke.MinWidth.Dots)
        return lw
}

func capfunc(st ppath.Caps) CapFunc {
        switch st {
        case ppath.CapButt:
                return ButtCap
        case ppath.CapRound:
                return RoundCap
        case ppath.CapSquare:
                return SquareCap
        }
        return nil
}

func joinmode(st ppath.Joins) JoinMode {
        switch st {
        case ppath.JoinMiter:
                return Miter
        case ppath.JoinMiterClip:
                return MiterClip
        case ppath.JoinRound:
                return Round
        case ppath.JoinBevel:
                return Bevel
        case ppath.JoinArcs:
                return Arc
        case ppath.JoinArcsClip:
                return ArcClip
        }
        return Arc
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/scanx:
// Copyright 2018 by the scanx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

// This is the anti-aliasing algorithm from the golang
// translation of FreeType. It has been adapted for use by the scan package
// which replaces the painter interface with the spanner interface.

// Copyright 2010 The Freetype-Go Authors. All rights reserved.
// Use of this source code is governed by your choice of either the
// FreeType License or the GNU General Public License version 2 (or
// any later version), both of which can be found in the LICENSE file.

// Package scan provides an anti-aliasing 2-D rasterizer, which is
// based on the larger Freetype suite of font-related packages, but the
// raster package is not specific to font rasterization, and can be used
// standalone without any other Freetype package.
// Rasterization is done by the same area/coverage accumulation algorithm as
// the Freetype "smooth" module, and the Anti-Grain Geometry library. A
// description of the area/coverage algorithm is at
// http://projects.tuxee.net/cl-vectors/section-the-cl-aa-algorithm
package scan

import (
        "image"
        "math"

        "golang.org/x/image/math/fixed"
)

// Scanner is a refactored version of the freetype scanner
type Scanner struct {
        // If false, the behavior is to use the even-odd winding fill
        // rule during Rasterize.
        UseNonZeroWinding bool

        // The Width of the Rasterizer. The height is implicit in len(cellIndex).
        Width int

        // The current pen position.
        A fixed.Point26_6

        // The current cell and its area/coverage being accumulated.
        Xi, Yi int
        Area   int
        Cover  int

        // The clip bounds of the scanner
        Clip image.Rectangle

        // The saved cells.
        Cell []Cell

        // Linked list of cells, one per row.
        CellIndex []int

        // The spanner that we use.
        Spanner Spanner

        // The bounds.
        MinX, MinY, MaxX, MaxY fixed.Int26_6
}

// SpanFunc is the type of a span function
type SpanFunc func(yi, xi0, xi1 int, alpha uint32)

// A Spanner consumes spans as they are created by the Scanner Draw function
type Spanner interface {
        // SetColor sets the color used for rendering.
        SetColor(color image.Image)

        // This returns a function that is efficient given the Spanner parameters.
        GetSpanFunc() SpanFunc
}

// Cell is part of a linked list (for a given yi co-ordinate) of accumulated
// area/coverage for the pixel at (xi, yi).
type Cell struct {
        Xi    int
        Area  int
        Cover int
        Next  int
}

func (s *Scanner) Set(a fixed.Point26_6) {
        if s.MaxX < a.X {
                s.MaxX = a.X
        }
        if s.MaxY < a.Y {
                s.MaxY = a.Y
        }
        if s.MinX > a.X {
                s.MinX = a.X
        }
        if s.MinY > a.Y {
                s.MinY = a.Y
        }
}

// SetWinding set the winding rule for the polygons
func (s *Scanner) SetWinding(useNonZeroWinding bool) {
        s.UseNonZeroWinding = useNonZeroWinding
}

// SetColor sets the color used for rendering.
func (s *Scanner) SetColor(clr image.Image) {
        s.Spanner.SetColor(clr)
}

// FindCell returns the index in [Scanner.Cell] for the cell corresponding to
// (r.xi, r.yi). The cell is created if necessary.
func (s *Scanner) FindCell() int {
        yi := s.Yi
        if yi < 0 || yi >= len(s.CellIndex) {
                return -1
        }
        xi := s.Xi
        if xi < 0 {
                xi = -1
        } else if xi > s.Width {
                xi = s.Width
        }
        i, prev := s.CellIndex[yi], -1
        for i != -1 && s.Cell[i].Xi <= xi {
                if s.Cell[i].Xi == xi {
                        return i
                }
                i, prev = s.Cell[i].Next, i
        }
        c := len(s.Cell)
        s.Cell = append(s.Cell, Cell{xi, 0, 0, i})
        if prev == -1 {
                s.CellIndex[yi] = c
        } else {
                s.Cell[prev].Next = c
        }
        return c
}

// SaveCell saves any accumulated [Scanner.Area] or [Scanner.Cover] for ([Scanner.Xi], [Scanner.Yi]).
func (s *Scanner) SaveCell() {
        if s.Area != 0 || s.Cover != 0 {
                i := s.FindCell()
                if i != -1 {
                        s.Cell[i].Area += s.Area
                        s.Cell[i].Cover += s.Cover
                }
                s.Area = 0
                s.Cover = 0
        }
}

// SetCell sets the (xi, yi) cell that r is accumulating area/coverage for.
func (s *Scanner) SetCell(xi, yi int) {
        if s.Xi != xi || s.Yi != yi {
                s.SaveCell()
                s.Xi, s.Yi = xi, yi
        }
}

// Scan accumulates area/coverage for the yi'th scanline, going from
// x0 to x1 in the horizontal direction (in 26.6 fixed point co-ordinates)
// and from y0f to y1f fractional vertical units within that scanline.
func (s *Scanner) Scan(yi int, x0, y0f, x1, y1f fixed.Int26_6) {
        // Break the 26.6 fixed point X co-ordinates into integral and fractional parts.
        x0i := int(x0) / 64
        x0f := x0 - fixed.Int26_6(64*x0i)
        x1i := int(x1) / 64
        x1f := x1 - fixed.Int26_6(64*x1i)

        // A perfectly horizontal scan.
        if y0f == y1f {
                s.SetCell(x1i, yi)
                return
        }
        dx, dy := x1-x0, y1f-y0f
        // A single cell scan.
        if x0i == x1i {
                s.Area += int((x0f + x1f) * dy)
                s.Cover += int(dy)
                return
        }
        // There are at least two cells. Apart from the first and last cells,
        // all intermediate cells go through the full width of the cell,
        // or 64 units in 26.6 fixed point format.
        var (
                p, q, edge0, edge1 fixed.Int26_6
                xiDelta            int
        )
        if dx > 0 {
                p, q = (64-x0f)*dy, dx
                edge0, edge1, xiDelta = 0, 64, 1
        } else {
                p, q = x0f*dy, -dx
                edge0, edge1, xiDelta = 64, 0, -1
        }
        yDelta, yRem := p/q, p%q
        if yRem < 0 {
                yDelta--
                yRem += q
        }
        // Do the first cell.
        xi, y := x0i, y0f
        s.Area += int((x0f + edge1) * yDelta)
        s.Cover += int(yDelta)
        xi, y = xi+xiDelta, y+yDelta
        s.SetCell(xi, yi)
        if xi != x1i {
                // Do all the intermediate cells.
                p = 64 * (y1f - y + yDelta)
                fullDelta, fullRem := p/q, p%q
                if fullRem < 0 {
                        fullDelta--
                        fullRem += q
                }
                yRem -= q
                for xi != x1i {
                        yDelta = fullDelta
                        yRem += fullRem
                        if yRem >= 0 {
                                yDelta++
                                yRem -= q
                        }
                        s.Area += int(64 * yDelta)
                        s.Cover += int(yDelta)
                        xi, y = xi+xiDelta, y+yDelta
                        s.SetCell(xi, yi)
                }
        }
        // Do the last cell.
        yDelta = y1f - y
        s.Area += int((edge0 + x1f) * yDelta)
        s.Cover += int(yDelta)
}

// Start starts a new path at the given point.
func (s *Scanner) Start(a fixed.Point26_6) {
        s.Set(a)
        s.SetCell(int(a.X/64), int(a.Y/64))
        s.A = a
}

// Line adds a linear segment to the current curve.
func (s *Scanner) Line(b fixed.Point26_6) {
        s.Set(b)
        x0, y0 := s.A.X, s.A.Y
        x1, y1 := b.X, b.Y
        dx, dy := x1-x0, y1-y0
        // Break the 26.6 fixed point Y co-ordinates into integral and fractional
        // parts.
        y0i := int(y0) / 64
        y0f := y0 - fixed.Int26_6(64*y0i)
        y1i := int(y1) / 64
        y1f := y1 - fixed.Int26_6(64*y1i)

        if y0i == y1i {
                // There is only one scanline.
                s.Scan(y0i, x0, y0f, x1, y1f)

        } else if dx == 0 {
                // This is a vertical line segment. We avoid calling r.scan and instead
                // manipulate r.area and r.cover directly.
                var (
                        edge0, edge1 fixed.Int26_6
                        yiDelta      int
                )
                if dy > 0 {
                        edge0, edge1, yiDelta = 0, 64, 1
                } else {
                        edge0, edge1, yiDelta = 64, 0, -1
                }
                x0i, yi := int(x0)/64, y0i
                x0fTimes2 := (int(x0) - (64 * x0i)) * 2
                // Do the first pixel.
                dcover := int(edge1 - y0f)
                darea := int(x0fTimes2 * dcover)
                s.Area += darea
                s.Cover += dcover
                yi += yiDelta
                s.SetCell(x0i, yi)
                // Do all the intermediate pixels.
                dcover = int(edge1 - edge0)
                darea = int(x0fTimes2 * dcover)
                for yi != y1i {
                        s.Area += darea
                        s.Cover += dcover
                        yi += yiDelta
                        s.SetCell(x0i, yi)
                }
                // Do the last pixel.
                dcover = int(y1f - edge0)
                darea = int(x0fTimes2 * dcover)
                s.Area += darea
                s.Cover += dcover

        } else {
                // There are at least two scanlines. Apart from the first and last
                // scanlines, all intermediate scanlines go through the full height of
                // the row, or 64 units in 26.6 fixed point format.
                var (
                        p, q, edge0, edge1 fixed.Int26_6
                        yiDelta            int
                )
                if dy > 0 {
                        p, q = (64-y0f)*dx, dy
                        edge0, edge1, yiDelta = 0, 64, 1
                } else {
                        p, q = y0f*dx, -dy
                        edge0, edge1, yiDelta = 64, 0, -1
                }
                xDelta, xRem := p/q, p%q
                if xRem < 0 {
                        xDelta--
                        xRem += q
                }
                // Do the first scanline.
                x, yi := x0, y0i
                s.Scan(yi, x, y0f, x+xDelta, edge1)
                x, yi = x+xDelta, yi+yiDelta
                s.SetCell(int(x)/64, yi)
                if yi != y1i {
                        // Do all the intermediate scanlines.
                        p = 64 * dx
                        fullDelta, fullRem := p/q, p%q
                        if fullRem < 0 {
                                fullDelta--
                                fullRem += q
                        }
                        xRem -= q
                        for yi != y1i {
                                xDelta = fullDelta
                                xRem += fullRem
                                if xRem >= 0 {
                                        xDelta++
                                        xRem -= q
                                }
                                s.Scan(yi, x, edge0, x+xDelta, edge1)
                                x, yi = x+xDelta, yi+yiDelta
                                s.SetCell(int(x)/64, yi)
                        }
                }
                // Do the last scanline.
                s.Scan(yi, x, edge0, x1, y1f)
        }
        // The next lineTo starts from b.
        s.A = b
}

// AreaToAlpha converts an area value to a uint32 alpha value. A completely
// filled pixel corresponds to an area of 64*64*2, and an alpha of 0xffff. The
// conversion of area values greater than this depends on the winding rule:
// even-odd or non-zero.
func (s *Scanner) AreaToAlpha(area int) uint32 {
        // The C Freetype implementation (version 2.3.12) does "alpha := area>>1"
        // without the +1. Round-to-nearest gives a more symmetric result than
        // round-down. The C implementation also returns 8-bit alpha, not 16-bit
        // alpha.
        a := (area + 1) >> 1
        if a < 0 {
                a = -a
        }
        alpha := uint32(a)
        if s.UseNonZeroWinding {
                if alpha > 0x0fff {
                        alpha = 0x0fff
                }
        } else {
                alpha &= 0x1fff
                if alpha > 0x1000 {
                        alpha = 0x2000 - alpha
                } else if alpha == 0x1000 {
                        alpha = 0x0fff
                }
        }
        // alpha is now in the range [0x0000, 0x0fff]. Convert that 12-bit alpha to
        // 16-bit alpha.
        return alpha<<4 | alpha>>8
}

// Draw converts r's accumulated curves into Spans for p. The Spans passed
// to the spanner are non-overlapping, and sorted by Y and then X. They all have non-zero
// width (and 0 <= X0 < X1 <= r.width) and non-zero A, except for the final
// Span, which has Y, X0, X1 and A all equal to zero.
func (s *Scanner) Draw() {
        b := image.Rect(0, 0, s.Width, len(s.CellIndex))
        if s.Clip.Dx() != 0 && s.Clip.Dy() != 0 {
                b = b.Intersect(s.Clip)
        }
        s.SaveCell()
        span := s.Spanner.GetSpanFunc()
        for yi := b.Min.Y; yi < b.Max.Y; yi++ {
                xi, cover := 0, 0
                for c := s.CellIndex[yi]; c != -1; c = s.Cell[c].Next {
                        if cover != 0 && s.Cell[c].Xi > xi {
                                alpha := s.AreaToAlpha(cover * 64 * 2)
                                if alpha != 0 {
                                        xi0, xi1 := xi, s.Cell[c].Xi
                                        if xi0 < b.Min.X {
                                                xi0 = b.Min.X
                                        }
                                        if xi1 > b.Max.X {
                                                xi1 = b.Max.X
                                        }
                                        if xi0 < xi1 {
                                                span(yi, xi0, xi1, alpha)
                                        }
                                }
                        }
                        cover += s.Cell[c].Cover
                        alpha := s.AreaToAlpha(cover*64*2 - s.Cell[c].Area)
                        xi = s.Cell[c].Xi + 1
                        if alpha != 0 {
                                xi0, xi1 := s.Cell[c].Xi, xi
                                if xi0 < b.Min.X {
                                        xi0 = b.Min.X
                                }
                                if xi1 > b.Max.X {
                                        xi1 = b.Max.X
                                }
                                if xi0 < xi1 {
                                        span(yi, xi0, xi1, alpha)
                                }
                        }
                }
        }
}

// GetPathExtent returns the bounds of the accumulated path extent
func (s *Scanner) GetPathExtent() fixed.Rectangle26_6 {
        return fixed.Rectangle26_6{
                Min: fixed.Point26_6{X: s.MinX, Y: s.MinY},
                Max: fixed.Point26_6{X: s.MaxX, Y: s.MaxY}}
}

// Clear cancels any previous accumulated scans
func (s *Scanner) Clear() {
        s.A = fixed.Point26_6{}
        s.Xi = 0
        s.Yi = 0
        s.Area = 0
        s.Cover = 0
        s.Cell = s.Cell[:0]
        for i := 0; i < len(s.CellIndex); i++ {
                s.CellIndex[i] = -1
        }
        const mxfi = fixed.Int26_6(math.MaxInt32)
        s.MinX, s.MinY, s.MaxX, s.MaxY = mxfi, mxfi, -mxfi, -mxfi
}

// SetBounds sets the maximum width and height of the rasterized image and
// calls Clear. The width and height are in pixels, not fixed.Int26_6 units.
func (s *Scanner) SetBounds(width, height int) {
        if width < 0 {
                width = 0
        }
        if height < 0 {
                height = 0
        }
        s.Width = width
        s.Cell = s.Cell[:0]
        if height > cap(s.CellIndex) {
                s.CellIndex = make([]int, height)
        }
        // Make sure length of cellIndex = height
        s.CellIndex = s.CellIndex[0:height]
        s.Width = width
        s.Clear()
}

// NewScanner creates a new Scanner with the given bounds.
func NewScanner(xs Spanner, width, height int) (sc *Scanner) {
        sc = &Scanner{Spanner: xs, UseNonZeroWinding: true}
        sc.SetBounds(width, height)
        return
}

// SetClip will not affect accumulation of scans, but it will
// clip drawing of the spans int the Draw func by the clip rectangle.
func (s *Scanner) SetClip(r image.Rectangle) {
        s.Clip = r
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/scanx:
// Copyright 2018 by the scanx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

package scan

import (
        "image"
        "image/color"
        "image/draw"

        "cogentcore.org/core/colors"
)

const (
        m         = 1<<16 - 1
        mp        = 0x100 * m
        pa uint32 = 0x101
        q  uint32 = 0xFF00
)

// ImgSpanner is a Spanner that draws Spans onto an [*image.RGBA] image.
// It uses either a color function as a the color source, or a fgColor
// if colFunc is nil.
type ImgSpanner struct {
        BaseSpanner
        Pix        []uint8
        Stride     int
        ColorImage image.Image
}

// LinkListSpanner is a Spanner that draws Spans onto a draw.Image
// interface satisfying struct but it is optimized for [*image.RGBA].
// It uses a solid Color only for fg and bg and does not support a color function
// used by gradients. Spans are accumulated into a set of linked lists, one for
// every horizontal line in the image. After the spans for the image are accumulated,
// use the DrawToImage function to write the spans to an image.
type LinkListSpanner struct {
        BaseSpanner
        Spans   []SpanCell
        BgColor color.RGBA
        LastY   int
        LastP   int
}

// SpanCell represents a span cell.
type SpanCell struct {
        X0   int
        X1   int
        Next int
        Clr  color.RGBA
}

// BaseSpanner contains base spanner information extended by [ImgSpanner] and [LinkListSpanner].
type BaseSpanner struct {
        // drawing is done with Bounds.Min as the origin
        Bounds image.Rectangle

        // Op is how pixels are overlayed
        Op      draw.Op
        FgColor color.RGBA
}

// Clear clears the current spans
func (x *LinkListSpanner) Clear() {
        x.LastY, x.LastP = 0, 0
        x.Spans = x.Spans[0:0]
        width := x.Bounds.Dy()
        for i := 0; i < width; i++ {
                // The first cells are indexed according to the y values
                // to create y separate linked lists corresponding to the
                // image y length. Since index 0 is used by the first of these sentinel cells
                // 0 can and is used for the end of list value by the spanner linked list.
                x.Spans = append(x.Spans, SpanCell{})
        }
}

func (x *LinkListSpanner) SpansToImage(img draw.Image) {
        for y := 0; y < x.Bounds.Dy(); y++ {
                p := x.Spans[y].Next
                for p != 0 {
                        spCell := x.Spans[p]
                        clr := spCell.Clr
                        x0, x1 := spCell.X0, spCell.X1
                        for x := x0; x < x1; x++ {
                                img.Set(y, x, clr)
                        }
                        p = spCell.Next
                }
        }
}

func (x *LinkListSpanner) SpansToPix(pix []uint8, stride int) {
        for y := 0; y < x.Bounds.Dy(); y++ {
                yo := y * stride
                p := x.Spans[y].Next
                for p != 0 {
                        spCell := x.Spans[p]
                        i0 := yo + spCell.X0*4
                        i1 := i0 + (spCell.X1-spCell.X0)*4
                        r, g, b, a := spCell.Clr.R, spCell.Clr.G, spCell.Clr.B, spCell.Clr.A
                        for i := i0; i < i1; i += 4 {
                                pix[i+0] = r
                                pix[i+1] = g
                                pix[i+2] = b
                                pix[i+3] = a
                        }
                        p = spCell.Next
                }
        }
}

// DrawToImage draws the accumulated y spans onto the img
func (x *LinkListSpanner) DrawToImage(img image.Image) {
        switch img := img.(type) {
        case *image.RGBA:
                x.SpansToPix(img.Pix, img.Stride)
        case draw.Image:
                x.SpansToImage(img)
        }
}

// SetBounds sets the spanner boundaries
func (x *LinkListSpanner) SetBounds(bounds image.Rectangle) {
        x.Bounds = bounds
        x.Clear()
}

func (x *LinkListSpanner) BlendColor(under color.RGBA, ma uint32) color.RGBA {
        if ma == 0 {
                return under
        }
        rma := uint32(x.FgColor.R) * ma
        gma := uint32(x.FgColor.G) * ma
        bma := uint32(x.FgColor.B) * ma
        ama := uint32(x.FgColor.A) * ma
        if x.Op != draw.Over || under.A == 0 || ama == m*0xFF {
                return color.RGBA{
                        uint8(rma / q),
                        uint8(gma / q),
                        uint8(bma / q),
                        uint8(ama / q)}
        }
        a := m - (ama / (m >> 8))
        cc := color.RGBA{
                uint8((uint32(under.R)*a + rma) / q),
                uint8((uint32(under.G)*a + gma) / q),
                uint8((uint32(under.B)*a + bma) / q),
                uint8((uint32(under.A)*a + ama) / q)}
        return cc
}

func (x *LinkListSpanner) AddLink(x0, x1, next, pp int, underColor color.RGBA, alpha uint32) (p int) {
        clr := x.BlendColor(underColor, alpha)
        if pp >= x.Bounds.Dy() && x.Spans[pp].X1 >= x0 && ((clr.A == 0 && x.Spans[pp].Clr.A == 0) || clr == x.Spans[pp].Clr) {
                // Just extend the prev span; a new one is not required
                x.Spans[pp].X1 = x1
                return pp
        }
        x.Spans = append(x.Spans, SpanCell{X0: x0, X1: x1, Next: next, Clr: clr})
        p = len(x.Spans) - 1
        x.Spans[pp].Next = p
        return
}

// GetSpanFunc returns the function that consumes a span described by the parameters.
func (x *LinkListSpanner) GetSpanFunc() SpanFunc {
        x.LastY = -1 // x within a y list may no longer be ordered, so this ensures a reset.
        return x.SpanOver
}

// SpanOver adds the span into an array of linked lists of spans using the fgColor and Porter-Duff composition
// ma is the accumulated alpha coverage. This function also assumes usage sorted x inputs for each y and so if
// inputs for x in y are not monotonically increasing, then lastY should be set to -1.
func (x *LinkListSpanner) SpanOver(yi, xi0, xi1 int, ma uint32) {
        if yi != x.LastY { // If the y place has changed, start at the list beginning
                x.LastP = yi
                x.LastY = yi
        }
        // since spans are sorted, we can start from x.lastP
        pp := x.LastP
        p := x.Spans[pp].Next
        for p != 0 && xi0 < xi1 {
                sp := x.Spans[p]
                if sp.X1 <= xi0 { //sp is before new span
                        pp = p
                        p = sp.Next
                        continue
                }
                if sp.X0 >= xi1 { //new span is before sp
                        x.LastP = x.AddLink(xi0, xi1, p, pp, x.BgColor, ma)
                        return
                }
                // left span
                if xi0 < sp.X0 {
                        pp = x.AddLink(xi0, sp.X0, p, pp, x.BgColor, ma)
                        xi0 = sp.X0
                } else if xi0 > sp.X0 {
                        pp = x.AddLink(sp.X0, xi0, p, pp, sp.Clr, 0)
                }

                clr := x.BlendColor(sp.Clr, ma)
                sameClrs := pp >= x.Bounds.Dy() && ((clr.A == 0 && x.Spans[pp].Clr.A == 0) || clr == x.Spans[pp].Clr)
                if xi1 < sp.X1 { // span does not go beyond sp
                        // merge with left span
                        if x.Spans[pp].X1 >= xi0 && sameClrs {
                                x.Spans[pp].X1 = xi1
                                x.Spans[pp].Next = sp.Next
                                // Suffices not to advance lastP ?!? Testing says NO!
                                x.LastP = yi // We need to go back, so let's just go to start of the list next time
                                p = pp
                        } else {
                                // middle span; replaces sp
                                x.Spans[p] = SpanCell{X0: xi0, X1: xi1, Next: sp.Next, Clr: clr}
                                x.LastP = pp
                        }
                        x.AddLink(xi1, sp.X1, sp.Next, p, sp.Clr, 0)
                        return
                }
                if x.Spans[pp].X1 >= xi0 && sameClrs { // Extend and merge with previous
                        x.Spans[pp].X1 = sp.X1
                        x.Spans[pp].Next = sp.Next
                        p = sp.Next // clip out the current span from the list
                        xi0 = sp.X1 // set remaining to start for next loop
                        continue
                }
                // Set current span to start of new span and combined color
                x.Spans[p] = SpanCell{X0: xi0, X1: sp.X1, Next: sp.Next, Clr: clr}
                xi0 = sp.X1 // any remaining span starts at sp.x1
                pp = p
                p = sp.Next
        }
        x.LastP = pp
        if xi0 < xi1 { // add any remaining span to the end of the chain
                x.AddLink(xi0, xi1, 0, pp, x.BgColor, ma)
        }
}

// SetBgColor sets the background color for blending to the first pixel of the given color
func (x *LinkListSpanner) SetBgColor(c image.Image) {
        x.BgColor = colors.AsRGBA(colors.ToUniform(c))
}

// SetColor sets the color of x to the first pixel of the given color
func (x *LinkListSpanner) SetColor(c image.Image) {
        x.FgColor = colors.AsRGBA(colors.ToUniform(c))
}

// NewImgSpanner returns an ImgSpanner set to draw to the given [*image.RGBA].
func NewImgSpanner(img *image.RGBA) (x *ImgSpanner) {
        x = &ImgSpanner{}
        x.SetImage(img)
        return
}

// SetImage set the [*image.RGBA] that the ImgSpanner will draw onto.
func (x *ImgSpanner) SetImage(img *image.RGBA) {
        x.Pix = img.Pix
        x.Stride = img.Stride
        x.Bounds = img.Bounds()
}

// SetColor sets the color of x to the given color image
func (x *ImgSpanner) SetColor(c image.Image) {
        if u, ok := c.(*image.Uniform); ok {
                x.FgColor = colors.AsRGBA(u.C)
                x.ColorImage = nil
                return
        }
        x.FgColor = color.RGBA{}
        x.ColorImage = c
}

// GetSpanFunc returns the function that consumes a span described by the parameters.
// The next four func declarations are all slightly different
// but in order to reduce code redundancy, this method is used
// to dispatch the function in the draw method.
func (x *ImgSpanner) GetSpanFunc() SpanFunc {
        var (
                useColorFunc = x.ColorImage != nil
                drawOver     = x.Op == draw.Over
        )
        switch {
        case useColorFunc && drawOver:
                return x.SpanColorFunc
        case useColorFunc && !drawOver:
                return x.SpanColorFuncR
        case !useColorFunc && !drawOver:
                return x.SpanFgColorR
        default:
                return x.SpanFgColor
        }
}

// SpanColorFuncR draw the span using a colorFunc and replaces the previous values.
func (x *ImgSpanner) SpanColorFuncR(yi, xi0, xi1 int, ma uint32) {
        i0 := (yi)*x.Stride + (xi0)*4
        i1 := i0 + (xi1-xi0)*4
        cx := xi0
        for i := i0; i < i1; i += 4 {
                rcr, rcg, rcb, rca := x.ColorImage.At(cx, yi).RGBA()
                cx++
                x.Pix[i+0] = uint8(rcr * ma / mp)
                x.Pix[i+1] = uint8(rcg * ma / mp)
                x.Pix[i+2] = uint8(rcb * ma / mp)
                x.Pix[i+3] = uint8(rca * ma / mp)
        }
}

// SpanFgColorR draws the span with the fore ground color and replaces the previous values.
func (x *ImgSpanner) SpanFgColorR(yi, xi0, xi1 int, ma uint32) {
        i0 := (yi)*x.Stride + (xi0)*4
        i1 := i0 + (xi1-xi0)*4
        cr, cg, cb, ca := x.FgColor.RGBA()
        rma := uint8(cr * ma / mp)
        gma := uint8(cg * ma / mp)
        bma := uint8(cb * ma / mp)
        ama := uint8(ca * ma / mp)
        for i := i0; i < i1; i += 4 {
                x.Pix[i+0] = rma
                x.Pix[i+1] = gma
                x.Pix[i+2] = bma
                x.Pix[i+3] = ama
        }
}

// SpanColorFunc draws the span using a colorFunc and the  Porter-Duff composition operator.
func (x *ImgSpanner) SpanColorFunc(yi, xi0, xi1 int, ma uint32) {
        i0 := (yi)*x.Stride + (xi0)*4
        i1 := i0 + (xi1-xi0)*4
        cx := xi0

        for i := i0; i < i1; i += 4 {
                // uses the Porter-Duff composition operator.
                rcr, rcg, rcb, rca := x.ColorImage.At(cx, yi).RGBA()
                cx++
                a := (m - (rca * ma / m)) * pa
                dr := uint32(x.Pix[i+0])
                dg := uint32(x.Pix[i+1])
                db := uint32(x.Pix[i+2])
                da := uint32(x.Pix[i+3])
                x.Pix[i+0] = uint8((dr*a + rcr*ma) / mp)
                x.Pix[i+1] = uint8((dg*a + rcg*ma) / mp)
                x.Pix[i+2] = uint8((db*a + rcb*ma) / mp)
                x.Pix[i+3] = uint8((da*a + rca*ma) / mp)
        }
}

// SpanFgColor draw the span using the fore ground color and the Porter-Duff composition operator.
func (x *ImgSpanner) SpanFgColor(yi, xi0, xi1 int, ma uint32) {
        i0 := (yi)*x.Stride + (xi0)*4
        i1 := i0 + (xi1-xi0)*4
        // uses the Porter-Duff composition operator.
        cr, cg, cb, ca := x.FgColor.RGBA()
        ama := ca * ma
        if ama == 0xFFFF*0xFFFF { // undercolor is ignored
                rmb := uint8(cr * ma / mp)
                gmb := uint8(cg * ma / mp)
                bmb := uint8(cb * ma / mp)
                amb := uint8(ama / mp)
                for i := i0; i < i1; i += 4 {
                        x.Pix[i+0] = rmb
                        x.Pix[i+1] = gmb
                        x.Pix[i+2] = bmb
                        x.Pix[i+3] = amb
                }
                return
        }
        rma := cr * ma
        gma := cg * ma
        bma := cb * ma
        a := (m - (ama / m)) * pa
        for i := i0; i < i1; i += 4 {
                x.Pix[i+0] = uint8((uint32(x.Pix[i+0])*a + rma) / mp)
                x.Pix[i+1] = uint8((uint32(x.Pix[i+1])*a + gma) / mp)
                x.Pix[i+2] = uint8((uint32(x.Pix[i+2])*a + bma) / mp)
                x.Pix[i+3] = uint8((uint32(x.Pix[i+3])*a + ama) / mp)
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/rasterx:
// Copyright 2018 by the rasterx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

package rasterx

import (
        "cogentcore.org/core/math32"
        "golang.org/x/image/math/fixed"
)

// MaxDx is the Maximum radians a cubic splice is allowed to span
// in ellipse parametric when approximating an off-axis ellipse.
const MaxDx float32 = math32.Pi / 8

// ToFixedP converts two floats to a fixed point.
func ToFixedP(x, y float32) (p fixed.Point26_6) {
        p.X = fixed.Int26_6(x * 64)
        p.Y = fixed.Int26_6(y * 64)
        return
}

// AddCircle adds a circle to the Adder p
func AddCircle(cx, cy, r float32, p Adder) {
        AddEllipse(cx, cy, r, r, 0, p)
}

// AddEllipse adds an elipse with center at cx,cy, with the indicated
// x and y radius, (rx, ry), rotated around the center by rot degrees.
func AddEllipse(cx, cy, rx, ry, rot float32, p Adder) {
        rotRads := rot * math32.Pi / 180
        pt := math32.Identity2().Translate(cx, cy).Rotate(rotRads).Translate(-cx, -cy).MulVector2AsPoint(math32.Vec2(cx+rx, cy))
        points := []float32{rx, ry, rot, 1.0, 0.0, pt.X, pt.Y}
        p.Start(pt.ToFixed())
        AddArc(points, cx, cy, pt.X, pt.Y, p)
        p.Stop(true)
}

// AddRect adds a rectangle of the indicated size, rotated
// around the center by rot degrees.
func AddRect(minX, minY, maxX, maxY, rot float32, p Adder) {
        rot *= math32.Pi / 180
        cx, cy := (minX+maxX)/2, (minY+maxY)/2
        m := math32.Identity2().Translate(cx, cy).Rotate(rot).Translate(-cx, -cy)
        q := &MatrixAdder{M: m, Adder: p}
        q.Start(ToFixedP(minX, minY))
        q.Line(ToFixedP(maxX, minY))
        q.Line(ToFixedP(maxX, maxY))
        q.Line(ToFixedP(minX, maxY))
        q.Stop(true)
}

// AddRoundRect adds a rectangle of the indicated size, rotated
// around the center by rot degrees with rounded corners of radius
// rx in the x axis and ry in the y axis. gf specifes the shape of the
// filleting function. Valid values are RoundGap, QuadraticGap, CubicGap,
// FlatGap, or nil which defaults to a flat gap.
func AddRoundRect(minX, minY, maxX, maxY, rx, ry, rot float32, gf GapFunc, p Adder) {
        if rx <= 0 || ry <= 0 {
                AddRect(minX, minY, maxX, maxY, rot, p)
                return
        }
        rot *= math32.Pi / 180
        if gf == nil {
                gf = FlatGap
        }
        w := maxX - minX
        if w < rx*2 {
                rx = w / 2
        }
        h := maxY - minY
        if h < ry*2 {
                ry = h / 2
        }
        stretch := rx / ry
        midY := minY + h/2
        m := math32.Identity2().Translate(minX+w/2, midY).Rotate(rot).Scale(1, 1/stretch).Translate(-minX-w/2, -minY-h/2)
        maxY = midY + h/2*stretch
        minY = midY - h/2*stretch

        q := &MatrixAdder{M: m, Adder: p}

        q.Start(ToFixedP(minX+rx, minY))
        q.Line(ToFixedP(maxX-rx, minY))
        gf(q, ToFixedP(maxX-rx, minY+rx), ToFixedP(0, -rx), ToFixedP(rx, 0))
        q.Line(ToFixedP(maxX, maxY-rx))
        gf(q, ToFixedP(maxX-rx, maxY-rx), ToFixedP(rx, 0), ToFixedP(0, rx))
        q.Line(ToFixedP(minX+rx, maxY))
        gf(q, ToFixedP(minX+rx, maxY-rx), ToFixedP(0, rx), ToFixedP(-rx, 0))
        q.Line(ToFixedP(minX, minY+rx))
        gf(q, ToFixedP(minX+rx, minY+rx), ToFixedP(-rx, 0), ToFixedP(0, -rx))
        q.Stop(true)
}

// AddArc adds an arc to the adder p
func AddArc(points []float32, cx, cy, px, py float32, p Adder) (lx, ly float32) {
        rotX := points[2] * math32.Pi / 180 // Convert degress to radians
        largeArc := points[3] != 0
        sweep := points[4] != 0
        startAngle := math32.Atan2(py-cy, px-cx) - rotX
        endAngle := math32.Atan2(points[6]-cy, points[5]-cx) - rotX
        deltaTheta := endAngle - startAngle
        arcBig := math32.Abs(deltaTheta) > math32.Pi

        // Approximate ellipse using cubic bezeir splines
        etaStart := math32.Atan2(math32.Sin(startAngle)/points[1], math32.Cos(startAngle)/points[0])
        etaEnd := math32.Atan2(math32.Sin(endAngle)/points[1], math32.Cos(endAngle)/points[0])
        deltaEta := etaEnd - etaStart
        if (arcBig && !largeArc) || (!arcBig && largeArc) { // Go has no boolean XOR
                if deltaEta < 0 {
                        deltaEta += math32.Pi * 2
                } else {
                        deltaEta -= math32.Pi * 2
                }
        }
        // This check might be needed if the center point of the ellipse is
        // at the midpoint of the start and end lines.
        if deltaEta < 0 && sweep {
                deltaEta += math32.Pi * 2
        } else if deltaEta >= 0 && !sweep {
                deltaEta -= math32.Pi * 2
        }

        // Round up to determine number of cubic splines to approximate bezier curve
        segs := int(math32.Abs(deltaEta)/MaxDx) + 1
        dEta := deltaEta / float32(segs) // span of each segment
        // Approximate the ellipse using a set of cubic bezier curves by the method of
        // L. Maisonobe, "Drawing an elliptical arc using polylines, quadratic
        // or cubic Bezier curves", 2003
        // https://www.spaceroots.org/documents/elllipse/elliptical-arc.pdf
        tde := math32.Tan(dEta / 2)
        alpha := math32.Sin(dEta) * (math32.Sqrt(4+3*tde*tde) - 1) / 3 // math32 is fun!
        lx, ly = px, py
        sinTheta, cosTheta := math32.Sin(rotX), math32.Cos(rotX)
        ldx, ldy := EllipsePrime(points[0], points[1], sinTheta, cosTheta, etaStart, cx, cy)
        for i := 1; i <= segs; i++ {
                eta := etaStart + dEta*float32(i)
                var px, py float32
                if i == segs {
                        px, py = points[5], points[6] // Just makes the end point exact; no roundoff error
                } else {
                        px, py = EllipsePointAt(points[0], points[1], sinTheta, cosTheta, eta, cx, cy)
                }
                dx, dy := EllipsePrime(points[0], points[1], sinTheta, cosTheta, eta, cx, cy)
                p.CubeBezier(ToFixedP(lx+alpha*ldx, ly+alpha*ldy),
                        ToFixedP(px-alpha*dx, py-alpha*dy), ToFixedP(px, py))
                lx, ly, ldx, ldy = px, py, dx, dy
        }
        return lx, ly
}

// EllipsePrime gives tangent vectors for parameterized ellipse; a, b, radii, eta parameter, center cx, cy
func EllipsePrime(a, b, sinTheta, cosTheta, eta, cx, cy float32) (px, py float32) {
        bCosEta := b * math32.Cos(eta)
        aSinEta := a * math32.Sin(eta)
        px = -aSinEta*cosTheta - bCosEta*sinTheta
        py = -aSinEta*sinTheta + bCosEta*cosTheta
        return
}

// EllipsePointAt gives points for parameterized ellipse; a, b, radii, eta parameter, center cx, cy
func EllipsePointAt(a, b, sinTheta, cosTheta, eta, cx, cy float32) (px, py float32) {
        aCosEta := a * math32.Cos(eta)
        bSinEta := b * math32.Sin(eta)
        px = cx + aCosEta*cosTheta - bSinEta*sinTheta
        py = cy + aCosEta*sinTheta + bSinEta*cosTheta
        return
}

// FindEllipseCenter locates the center of the Ellipse if it exists. If it does not exist,
// the radius values will be increased minimally for a solution to be possible
// while preserving the ra to rb ratio.  ra and rb arguments are pointers that can be
// checked after the call to see if the values changed. This method uses coordinate transformations
// to reduce the problem to finding the center of a circle that includes the origin
// and an arbitrary point. The center of the circle is then transformed
// back to the original coordinates and returned.
func FindEllipseCenter(ra, rb *float32, rotX, startX, startY, endX, endY float32, sweep, smallArc bool) (cx, cy float32) {
        cos, sin := math32.Cos(rotX), math32.Sin(rotX)

        // Move origin to start point
        nx, ny := endX-startX, endY-startY

        // Rotate ellipse x-axis to coordinate x-axis
        nx, ny = nx*cos+ny*sin, -nx*sin+ny*cos
        // Scale X dimension so that ra = rb
        nx *= *rb / *ra // Now the ellipse is a circle radius rb; therefore foci and center coincide

        midX, midY := nx/2, ny/2
        midlenSq := midX*midX + midY*midY

        var hr float32
        if *rb**rb < midlenSq {
                // Requested ellipse does not exist; scale ra, rb to fit. Length of
                // span is greater than max width of ellipse, must scale *ra, *rb
                nrb := math32.Sqrt(midlenSq)
                if *ra == *rb {
                        *ra = nrb // prevents roundoff
                } else {
                        *ra = *ra * nrb / *rb
                }
                *rb = nrb
        } else {
                hr = math32.Sqrt(*rb**rb-midlenSq) / math32.Sqrt(midlenSq)
        }
        // Notice that if hr is zero, both answers are the same.
        if (sweep && smallArc) || (!sweep && !smallArc) {
                cx = midX + midY*hr
                cy = midY - midX*hr
        } else {
                cx = midX - midY*hr
                cy = midY + midX*hr
        }

        // reverse scale
        cx *= *ra / *rb
        //Reverse rotate and translate back to original coordinates
        return cx*cos - cy*sin + startX, cx*sin + cy*cos + startY
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Based on https://github.com/srwiley/rasterx:
// Copyright 2018 by the rasterx Authors. All rights reserved.
// Created 2018 by S.R.Wiley

package rasterx

import (
        "cogentcore.org/core/math32"
        "golang.org/x/image/math/fixed"
)

// Stroker does everything a [Filler] does, but
// also allows for stroking and dashed stroking in addition to
// filling
type Stroker struct {
        Filler

        // Trailing cap function
        CapT CapFunc

        // Leading cpa function
        CapL CapFunc

        // When gap appears between segments, this function is called
        JoinGap GapFunc

        // Tracks progress of the stroke
        FirstP C2Point

        // Tracks progress of the stroke
        TrailPoint C2Point

        // Tracks progress of the stroke
        LeadPoint C2Point

        // last normal of intra-seg connection.
        Ln fixed.Point26_6

        // U is the half-width of the stroke.
        U fixed.Int26_6

        MLimit fixed.Int26_6

        JoinMode JoinMode

        InStroke bool
}

// NewStroker returns a ptr to a Stroker with default values.
// A Stroker has all of the capabilities of a Filler and Scanner, plus the ability
// to stroke curves with solid lines. Use SetStroke to configure with non-default
// values.
func NewStroker(width, height int, scanner Scanner) *Stroker {
        r := new(Stroker)
        r.Scanner = scanner
        r.SetBounds(width, height)
        //Defaults for stroking
        r.SetWinding(true)
        r.U = 2 << 6
        r.MLimit = 4 << 6
        r.JoinMode = MiterClip
        r.JoinGap = RoundGap
        r.CapL = RoundCap
        r.CapT = RoundCap
        r.SetStroke(1<<6, 4<<6, ButtCap, nil, FlatGap, MiterClip)
        return r
}

// CapFunc defines a function that draws caps on the ends of lines
type CapFunc func(p Adder, a, eNorm fixed.Point26_6)

// GapFunc defines a function to bridge gaps when the miter limit is
// exceeded
type GapFunc func(p Adder, a, tNorm, lNorm fixed.Point26_6)

// C2Point represents a point that connects two stroke segments
// and holds the tangent, normal and radius of curvature
// of the trailing and leading segments in fixed point values.
type C2Point struct {
        P, TTan, LTan, TNorm, LNorm fixed.Point26_6
        RT, RL                      fixed.Int26_6
}

// JoinMode type to specify how segments join.
type JoinMode int32 //enums:enum

// JoinMode constants determine how stroke segments bridge the gap at a join
// ArcClip mode is like MiterClip applied to arcs, and is not part of the SVG2.0
// standard.
const (
        Arc JoinMode = iota
        ArcClip
        Miter
        MiterClip
        Bevel
        Round
)

const (
        // Number of cubic beziers to approx half a circle
        CubicsPerHalfCircle = 8

        // 1/4 in fixed point
        EpsilonFixed = fixed.Int26_6(16)

        // fixed point t parameterization shift factor;
        // (2^this)/64 is the max length of t for fixed.Int26_6
        TStrokeShift = 14
)

// SetStroke set the parameters for stroking a line. width is the width of the line, miterlimit is the miter cutoff
// value for miter, arc, miterclip and arcClip joinModes. CapL and CapT are the capping functions for leading and trailing
// line ends. If one is nil, the other function is used at both ends. If both are nil, both ends are ButtCapped.
// gp is the gap function that determines how a gap on the convex side of two joining lines is filled. jm is the JoinMode
// for curve segments.
func (r *Stroker) SetStroke(width, miterLimit fixed.Int26_6, capL, capT CapFunc, gp GapFunc, jm JoinMode) {
        r.U = width / 2
        r.CapL = capL
        r.CapT = capT
        r.JoinMode = jm
        r.JoinGap = gp
        r.MLimit = (r.U * miterLimit) >> 6

        if r.CapT == nil {
                if r.CapL == nil {
                        r.CapT = ButtCap
                } else {
                        r.CapT = r.CapL
                }
        }
        if r.CapL == nil {
                r.CapL = r.CapT
        }
        if gp == nil {
                if r.JoinMode == Round {
                        r.JoinGap = RoundGap
                } else {
                        r.JoinGap = FlatGap
                }
        }

}

// GapToCap is a utility that converts a CapFunc to GapFunc
func GapToCap(p Adder, a, eNorm fixed.Point26_6, gf GapFunc) {
        p.Start(a.Add(eNorm))
        gf(p, a, eNorm, Invert(eNorm))
        p.Line(a.Sub(eNorm))
}

var (
        // ButtCap caps lines with a straight line
        ButtCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
                p.Start(a.Add(eNorm))
                p.Line(a.Sub(eNorm))
        }

        // SquareCap caps lines with a square which is slightly longer than ButtCap
        SquareCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
                tpt := a.Add(TurnStarboard90(eNorm))
                p.Start(a.Add(eNorm))
                p.Line(tpt.Add(eNorm))
                p.Line(tpt.Sub(eNorm))
                p.Line(a.Sub(eNorm))
        }

        // RoundCap caps lines with a half-circle
        RoundCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
                GapToCap(p, a, eNorm, RoundGap)
        }

        // CubicCap caps lines with a cubic bezier
        CubicCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
                GapToCap(p, a, eNorm, CubicGap)
        }

        // QuadraticCap caps lines with a quadratic bezier
        QuadraticCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
                GapToCap(p, a, eNorm, QuadraticGap)
        }

        // Gap functions

        // FlatGap bridges miter-limit gaps with a straight line
        FlatGap GapFunc = func(p Adder, a, tNorm, lNorm fixed.Point26_6) {
                p.Line(a.Add(lNorm))
        }

        // RoundGap bridges miter-limit gaps with a circular arc
        RoundGap GapFunc = func(p Adder, a, tNorm, lNorm fixed.Point26_6) {
                StrokeArc(p, a, a.Add(tNorm), a.Add(lNorm), true, 0, 0, p.Line)
                p.Line(a.Add(lNorm)) // just to be sure line joins cleanly,
                // last pt in stoke arc may not be precisely s2
        }

        // CubicGap bridges miter-limit gaps with a cubic bezier
        CubicGap GapFunc = func(p Adder, a, tNorm, lNorm fixed.Point26_6) {
                p.CubeBezier(a.Add(tNorm).Add(TurnStarboard90(tNorm)), a.Add(lNorm).Add(TurnPort90(lNorm)), a.Add(lNorm))
        }

        // QuadraticGap bridges miter-limit gaps with a quadratic bezier
        QuadraticGap GapFunc = func(p Adder, a, tNorm, lNorm fixed.Point26_6) {
                c1, c2 := a.Add(tNorm).Add(TurnStarboard90(tNorm)), a.Add(lNorm).Add(TurnPort90(lNorm))
                cm := c1.Add(c2).Mul(fixed.Int26_6(1 << 5))
                p.QuadBezier(cm, a.Add(lNorm))
        }
)

// StrokeArc strokes a circular arc by approximation with bezier curves
func StrokeArc(p Adder, a, s1, s2 fixed.Point26_6, clockwise bool, trimStart,
        trimEnd fixed.Int26_6, firstPoint func(p fixed.Point26_6)) (ps1, ds1, ps2, ds2 fixed.Point26_6) {
        // Approximate the circular arc using a set of cubic bezier curves by the method of
        // L. Maisonobe, "Drawing an elliptical arc using polylines, quadratic
        // or cubic Bezier curves", 2003
        // https://www.spaceroots.org/documents/elllipse/elliptical-arc.pdf
        // The method was simplified for circles.
        theta1 := math32.Atan2(float32(s1.Y-a.Y), float32(s1.X-a.X))
        theta2 := math32.Atan2(float32(s2.Y-a.Y), float32(s2.X-a.X))
        if !clockwise {
                for theta1 < theta2 {
                        theta1 += math32.Pi * 2
                }
        } else {
                for theta2 < theta1 {
                        theta2 += math32.Pi * 2
                }
        }
        deltaTheta := theta2 - theta1
        if trimStart > 0 {
                ds := (deltaTheta * float32(trimStart)) / float32(1<<TStrokeShift)
                deltaTheta -= ds
                theta1 += ds
        }
        if trimEnd > 0 {
                ds := (deltaTheta * float32(trimEnd)) / float32(1<<TStrokeShift)
                deltaTheta -= ds
        }

        segs := int(math32.Abs(deltaTheta)/(math32.Pi/CubicsPerHalfCircle)) + 1
        dTheta := deltaTheta / float32(segs)
        tde := math32.Tan(dTheta / 2)
        alpha := fixed.Int26_6(math32.Sin(dTheta) * (math32.Sqrt(4+3*tde*tde) - 1) * (64.0 / 3.0)) // math32 is fun!
        r := float32(Length(s1.Sub(a)))                                                            // Note r is *64
        ldp := fixed.Point26_6{X: -fixed.Int26_6(r * math32.Sin(theta1)), Y: fixed.Int26_6(r * math32.Cos(theta1))}
        ds1 = ldp
        ps1 = fixed.Point26_6{X: a.X + ldp.Y, Y: a.Y - ldp.X}
        firstPoint(ps1)
        s1 = ps1
        for i := 1; i <= segs; i++ {
                eta := theta1 + dTheta*float32(i)
                ds2 = fixed.Point26_6{X: -fixed.Int26_6(r * math32.Sin(eta)), Y: fixed.Int26_6(r * math32.Cos(eta))}
                ps2 = fixed.Point26_6{X: a.X + ds2.Y, Y: a.Y - ds2.X} // Using deriviative to calc new pt, because circle
                p1 := s1.Add(ldp.Mul(alpha))
                p2 := ps2.Sub(ds2.Mul(alpha))
                p.CubeBezier(p1, p2, ps2)
                s1, ldp = ps2, ds2
        }
        return
}

// Joiner is called when two segments of a stroke are joined. it is exposed
// so that if can be wrapped to generate callbacks for the join points.
func (r *Stroker) Joiner(p C2Point) {
        crossProd := p.LNorm.X*p.TNorm.Y - p.TNorm.X*p.LNorm.Y
        // stroke bottom edge, with the reverse of p
        r.StrokeEdge(C2Point{P: p.P, TNorm: Invert(p.LNorm), LNorm: Invert(p.TNorm),
                TTan: Invert(p.LTan), LTan: Invert(p.TTan), RT: -p.RL, RL: -p.RT}, -crossProd)
        // stroke top edge
        r.StrokeEdge(p, crossProd)
}

// StrokeEdge reduces code redundancy in the Joiner function by 2x since it handles
// the top and bottom edges. This function encodes most of the logic of how to
// handle joins between the given C2Point point p, and the end of the line.
func (r *Stroker) StrokeEdge(p C2Point, crossProd fixed.Int26_6) {
        ra := &r.Filler
        s1, s2 := p.P.Add(p.TNorm), p.P.Add(p.LNorm) // Bevel points for top leading and trailing
        ra.Start(s1)
        if crossProd > -EpsilonFixed*EpsilonFixed { // Almost co-linear or convex
                ra.Line(s2)
                return // No need to fill any gaps
        }

        var ct, cl fixed.Point26_6 // Center of curvature trailing, leading
        var rt, rl fixed.Int26_6   // Radius of curvature trailing, leading

        // Adjust radiuses for stroke width
        if r.JoinMode == Arc || r.JoinMode == ArcClip {
                // Find centers of radius of curvature and adjust the radius to be drawn
                // by half the stroke width.
                if p.RT != 0 {
                        if p.RT > 0 {
                                ct = p.P.Add(ToLength(TurnPort90(p.TTan), p.RT))
                                rt = p.RT - r.U
                        } else {
                                ct = p.P.Sub(ToLength(TurnPort90(p.TTan), -p.RT))
                                rt = -p.RT + r.U
                        }
                        if rt < 0 {
                                rt = 0
                        }
                }
                if p.RL != 0 {
                        if p.RL > 0 {
                                cl = p.P.Add(ToLength(TurnPort90(p.LTan), p.RL))
                                rl = p.RL - r.U
                        } else {
                                cl = p.P.Sub(ToLength(TurnPort90(p.LTan), -p.RL))
                                rl = -p.RL + r.U
                        }
                        if rl < 0 {
                                rl = 0
                        }
                }
        }

        if r.JoinMode == MiterClip || r.JoinMode == Miter ||
                // Arc or ArcClip with 0 tRadCurve and 0 lRadCurve is treated the same as a
                // Miter or MiterClip join, resp.
                ((r.JoinMode == Arc || r.JoinMode == ArcClip) && (rt == 0 && rl == 0)) {
                xt := CalcIntersect(s1.Sub(p.TTan), s1, s2, s2.Sub(p.LTan))
                xa := xt.Sub(p.P)
                if Length(xa) < r.MLimit { // within miter limit
                        ra.Line(xt)
                        ra.Line(s2)
                        return
                }
                if r.JoinMode == MiterClip || (r.JoinMode == ArcClip) {
                        //Projection of tNorm onto xa
                        tProjP := xa.Mul(fixed.Int26_6((DotProd(xa, p.TNorm) << 6) / DotProd(xa, xa)))
                        projLen := Length(tProjP)
                        if r.MLimit > projLen { // the miter limit line is past the bevel point
                                // t is the fraction shifted by tStrokeShift to scale the vectors from the bevel point
                                // to the line intersection, so that they abbut the miter limit line.
                                tiLength := Length(xa)
                                sx1, sx2 := xt.Sub(s1), xt.Sub(s2)
                                t := (r.MLimit - projLen) << TStrokeShift / (tiLength - projLen)
                                tx := ToLength(sx1, t*Length(sx1)>>TStrokeShift)
                                lx := ToLength(sx2, t*Length(sx2)>>TStrokeShift)
                                vx := ToLength(xa, t*Length(xa)>>TStrokeShift)
                                s1p, _, ap := s1.Add(tx), s2.Add(lx), p.P.Add(vx)
                                gLen := Length(ap.Sub(s1p))
                                ra.Line(s1p)
                                r.JoinGap(ra, ap, ToLength(TurnPort90(p.TTan), gLen), ToLength(TurnPort90(p.LTan), gLen))
                                ra.Line(s2)
                                return
                        }
                } // Fallthrough
        } else if r.JoinMode == Arc || r.JoinMode == ArcClip {
                // Test for cases of a bezier meeting line, an line meeting a bezier,
                // or a bezier meeting a bezier. (Line meeting line is handled above.)
                switch {
                case rt == 0: // rl != 0, because one must be non-zero as checked above
                        xt, intersect := RayCircleIntersection(s1.Add(p.TTan), s1, cl, rl)
                        if intersect {
                                ray1, ray2 := xt.Sub(cl), s2.Sub(cl)
                                clockwise := (ray1.X*ray2.Y > ray1.Y*ray2.X) // Sign of xprod
                                if Length(p.P.Sub(xt)) < r.MLimit {          // within miter limit
                                        StrokeArc(ra, cl, xt, s2, clockwise, 0, 0, ra.Line)
                                        ra.Line(s2)
                                        return
                                }
                                // Not within miter limit line
                                if r.JoinMode == ArcClip { // Scale bevel points towards xt, and call gap func
                                        xa := xt.Sub(p.P)
                                        //Projection of tNorm onto xa
                                        tProjP := xa.Mul(fixed.Int26_6((DotProd(xa, p.TNorm) << 6) / DotProd(xa, xa)))
                                        projLen := Length(tProjP)
                                        if r.MLimit > projLen { // the miter limit line is past the bevel point
                                                // t is the fraction shifted by tStrokeShift to scale the line or arc from the bevel point
                                                // to the line intersection, so that they abbut the miter limit line.
                                                sx1 := xt.Sub(s1) //, xt.Sub(s2)
                                                t := fixed.Int26_6(1<<TStrokeShift) - ((r.MLimit - projLen) << TStrokeShift / (Length(xa) - projLen))
                                                tx := ToLength(sx1, t*Length(sx1)>>TStrokeShift)
                                                s1p := xt.Sub(tx)
                                                ra.Line(s1p)
                                                sp1, ds1, ps2, _ := StrokeArc(ra, cl, xt, s2, clockwise, t, 0, ra.Start)
                                                ra.Start(s1p)
                                                // calc gap center as pt where -tnorm and line perp to midcoord
                                                midP := sp1.Add(s1p).Mul(fixed.Int26_6(1 << 5)) // midpoint
                                                midLine := TurnPort90(midP.Sub(sp1))
                                                if midLine.X*midLine.X+midLine.Y*midLine.Y > EpsilonFixed { // if midline is zero, CalcIntersect is invalid
                                                        ap := CalcIntersect(s1p, s1p.Sub(p.TNorm), midLine.Add(midP), midP)
                                                        gLen := Length(ap.Sub(s1p))
                                                        if clockwise {
                                                                ds1 = Invert(ds1)
                                                        }
                                                        r.JoinGap(ra, ap, ToLength(TurnPort90(p.TTan), gLen), ToLength(TurnStarboard90(ds1), gLen))
                                                }
                                                ra.Line(sp1)
                                                ra.Start(ps2)
                                                ra.Line(s2)
                                                return
                                        }
                                        //Bevel points not past miter limit: fallthrough
                                }
                        }
                case rl == 0: // rt != 0, because one must be non-zero as checked above
                        xt, intersect := RayCircleIntersection(s2.Sub(p.LTan), s2, ct, rt)
                        if intersect {
                                ray1, ray2 := s1.Sub(ct), xt.Sub(ct)
                                clockwise := ray1.X*ray2.Y > ray1.Y*ray2.X
                                if Length(p.P.Sub(xt)) < r.MLimit { // within miter limit
                                        StrokeArc(ra, ct, s1, xt, clockwise, 0, 0, ra.Line)
                                        ra.Line(s2)
                                        return
                                }
                                // Not within miter limit line
                                if r.JoinMode == ArcClip { // Scale bevel points towards xt, and call gap func
                                        xa := xt.Sub(p.P)
                                        //Projection of lNorm onto xa
                                        lProjP := xa.Mul(fixed.Int26_6((DotProd(xa, p.LNorm) << 6) / DotProd(xa, xa)))
                                        projLen := Length(lProjP)
                                        if r.MLimit > projLen { // The miter limit line is past the bevel point,
                                                // t is the fraction to scale the line or arc from the bevel point
                                                // to the line intersection, so that they abbut the miter limit line.
                                                sx2 := xt.Sub(s2)
                                                t := fixed.Int26_6(1<<TStrokeShift) - ((r.MLimit - projLen) << TStrokeShift / (Length(xa) - projLen))
                                                lx := ToLength(sx2, t*Length(sx2)>>TStrokeShift)
                                                s2p := xt.Sub(lx)
                                                _, _, ps2, ds2 := StrokeArc(ra, ct, s1, xt, clockwise, 0, t, ra.Line)
                                                // calc gap center as pt where -lnorm and line perp to midcoord
                                                midP := s2p.Add(ps2).Mul(fixed.Int26_6(1 << 5)) // midpoint
                                                midLine := TurnStarboard90(midP.Sub(ps2))
                                                if midLine.X*midLine.X+midLine.Y*midLine.Y > EpsilonFixed { // if midline is zero, CalcIntersect is invalid
                                                        ap := CalcIntersect(midP, midLine.Add(midP), s2p, s2p.Sub(p.LNorm))
                                                        gLen := Length(ap.Sub(ps2))
                                                        if clockwise {
                                                                ds2 = Invert(ds2)
                                                        }
                                                        r.JoinGap(ra, ap, ToLength(TurnStarboard90(ds2), gLen), ToLength(TurnPort90(p.LTan), gLen))
                                                }
                                                ra.Line(s2)
                                                return
                                        }
                                        //Bevel points not past miter limit: fallthrough
                                }
                        }
                default: // Both rl != 0 and rt != 0 as checked above
                        xt1, xt2, gIntersect := CircleCircleIntersection(ct, cl, rt, rl)
                        xt, intersect := ClosestPortside(s1, s2, xt1, xt2, gIntersect)
                        if intersect {
                                ray1, ray2 := s1.Sub(ct), xt.Sub(ct)
                                clockwiseT := (ray1.X*ray2.Y > ray1.Y*ray2.X)
                                ray1, ray2 = xt.Sub(cl), s2.Sub(cl)
                                clockwiseL := ray1.X*ray2.Y > ray1.Y*ray2.X

                                if Length(p.P.Sub(xt)) < r.MLimit { // within miter limit
                                        StrokeArc(ra, ct, s1, xt, clockwiseT, 0, 0, ra.Line)
                                        StrokeArc(ra, cl, xt, s2, clockwiseL, 0, 0, ra.Line)
                                        ra.Line(s2)
                                        return
                                }

                                if r.JoinMode == ArcClip { // Scale bevel points towards xt, and call gap func
                                        xa := xt.Sub(p.P)
                                        //Projection of lNorm onto xa
                                        lProjP := xa.Mul(fixed.Int26_6((DotProd(xa, p.LNorm) << 6) / DotProd(xa, xa)))
                                        projLen := Length(lProjP)
                                        if r.MLimit > projLen { // The miter limit line is past the bevel point,
                                                // t is the fraction to scale the line or arc from the bevel point
                                                // to the line intersection, so that they abbut the miter limit line.
                                                t := fixed.Int26_6(1<<TStrokeShift) - ((r.MLimit - projLen) << TStrokeShift / (Length(xa) - projLen))
                                                _, _, ps1, ds1 := StrokeArc(ra, ct, s1, xt, clockwiseT, 0, t, r.Filler.Line)
                                                ps2, ds2, fs2, _ := StrokeArc(ra, cl, xt, s2, clockwiseL, t, 0, ra.Start)
                                                midP := ps1.Add(ps2).Mul(fixed.Int26_6(1 << 5)) // midpoint
                                                midLine := TurnStarboard90(midP.Sub(ps1))
                                                ra.Start(ps1)
                                                if midLine.X*midLine.X+midLine.Y*midLine.Y > EpsilonFixed { // if midline is zero, CalcIntersect is invalid
                                                        if clockwiseT {
                                                                ds1 = Invert(ds1)
                                                        }
                                                        if clockwiseL {
                                                                ds2 = Invert(ds2)
                                                        }
                                                        ap := CalcIntersect(midP, midLine.Add(midP), ps2, ps2.Sub(TurnStarboard90(ds2)))
                                                        gLen := Length(ap.Sub(ps2))
                                                        r.JoinGap(ra, ap, ToLength(TurnStarboard90(ds1), gLen), ToLength(TurnStarboard90(ds2), gLen))
                                                }
                                                ra.Line(ps2)
                                                ra.Start(fs2)
                                                ra.Line(s2)
                                                return
                                        }
                                }
                        }
                        // fallthrough to final JoinGap
                }
        }
        r.JoinGap(ra, p.P, p.TNorm, p.LNorm)
        ra.Line(s2)
}

// Stop a stroked line. The line will close
// is isClosed is true. Otherwise end caps will
// be drawn at both ends.
func (r *Stroker) Stop(isClosed bool) {
        if !r.InStroke {
                return
        }
        rf := &r.Filler
        if isClosed {
                if r.FirstP.P != rf.A {
                        r.Line(r.FirstP.P)
                }
                a := rf.A
                r.FirstP.TNorm = r.LeadPoint.TNorm
                r.FirstP.RT = r.LeadPoint.RT
                r.FirstP.TTan = r.LeadPoint.TTan

                rf.Start(r.FirstP.P.Sub(r.FirstP.TNorm))
                rf.Line(a.Sub(r.Ln))
                rf.Start(a.Add(r.Ln))
                rf.Line(r.FirstP.P.Add(r.FirstP.TNorm))
                r.Joiner(r.FirstP)
                r.FirstP.BlackWidowMark(rf)
        } else {
                a := rf.A
                rf.Start(r.LeadPoint.P.Sub(r.LeadPoint.TNorm))
                rf.Line(a.Sub(r.Ln))
                rf.Start(a.Add(r.Ln))
                rf.Line(r.LeadPoint.P.Add(r.LeadPoint.TNorm))
                r.CapL(rf, r.LeadPoint.P, r.LeadPoint.TNorm)
                r.CapT(rf, r.FirstP.P, Invert(r.FirstP.LNorm))
        }
        r.InStroke = false
}

// QuadBezier starts a stroked quadratic bezier.
func (r *Stroker) QuadBezier(b, c fixed.Point26_6) {
        r.QuadBezierf(r, b, c)
}

// CubeBezier starts a stroked quadratic bezier.
func (r *Stroker) CubeBezier(b, c, d fixed.Point26_6) {
        r.CubeBezierf(r, b, c, d)
}

// QuadBezierf calcs end curvature of beziers
func (r *Stroker) QuadBezierf(s Raster, b, c fixed.Point26_6) {
        r.TrailPoint = r.LeadPoint
        r.CalcEndCurvature(r.A, b, c, c, b, r.A, fixed.Int52_12(2<<12), DoCalcCurvature(s))
        r.QuadBezierF(s, b, c)
        r.A = c
}

// DoCalcCurvature determines if calculation of the end curvature is required
// depending on the raster type and JoinMode
func DoCalcCurvature(r Raster) bool {
        switch q := r.(type) {
        case *Filler:
                return false // never for filler
        case *Stroker:
                return (q.JoinMode == Arc || q.JoinMode == ArcClip)
        case *Dasher:
                return (q.JoinMode == Arc || q.JoinMode == ArcClip)
        default:
                return true // Better safe than sorry if another raster type is used
        }
}

func (r *Stroker) CubeBezierf(sgm Raster, b, c, d fixed.Point26_6) {
        if (r.A == b && c == d) || (r.A == b && b == c) || (c == b && d == c) {
                sgm.Line(d)
                return
        }
        r.TrailPoint = r.LeadPoint
        // Only calculate curvature if stroking or and using arc or arc-clip
        doCalcCurve := DoCalcCurvature(sgm)
        const dm = fixed.Int52_12((3 << 12) / 2)
        switch {
        // b != c, and c != d see above
        case r.A == b:
                r.CalcEndCurvature(b, c, d, d, c, b, dm, doCalcCurve)
        // b != a,  and b != c, see above
        case c == d:
                r.CalcEndCurvature(r.A, b, c, c, b, r.A, dm, doCalcCurve)
        default:
                r.CalcEndCurvature(r.A, b, c, d, c, b, dm, doCalcCurve)
        }
        r.CubeBezierF(sgm, b, c, d)
        r.A = d
}

// Line adds a line segment to the rasterizer
func (r *Stroker) Line(b fixed.Point26_6) {
        r.LineSeg(r, b)
}

// LineSeg is called by both the Stroker and Dasher
func (r *Stroker) LineSeg(sgm Raster, b fixed.Point26_6) {
        r.TrailPoint = r.LeadPoint
        ba := b.Sub(r.A)
        if ba.X == 0 && ba.Y == 0 { // a == b, line is degenerate
                if r.TrailPoint.TTan.X != 0 || r.TrailPoint.TTan.Y != 0 {
                        ba = r.TrailPoint.TTan // Use last tangent for seg tangent
                } else { // Must be on top of last moveto; set ba to X axis unit vector
                        ba = fixed.Point26_6{X: 1 << 6, Y: 0}
                }
        }
        bnorm := TurnPort90(ToLength(ba, r.U))
        r.TrailPoint.LTan = ba
        r.LeadPoint.TTan = ba
        r.TrailPoint.LNorm = bnorm
        r.LeadPoint.TNorm = bnorm
        r.TrailPoint.RL = 0.0
        r.LeadPoint.RT = 0.0
        r.TrailPoint.P = r.A
        r.LeadPoint.P = b

        sgm.JoinF()
        sgm.LineF(b)
        r.A = b
}

// LineF is for intra-curve lines. It is required for the Rasterizer interface
// so that if the line is being stroked or dash stroked, different actions can be
// taken.
func (r *Stroker) LineF(b fixed.Point26_6) {
        // b is either an intra-segment value, or
        // the end of the segment.
        var bnorm fixed.Point26_6
        a := r.A                // Hold a since r.a is going to change during stroke operation
        if b == r.LeadPoint.P { // End of segment
                bnorm = r.LeadPoint.TNorm // Use more accurate leadPoint tangent
        } else {
                bnorm = TurnPort90(ToLength(b.Sub(a), r.U)) // Intra segment normal
        }
        ra := &r.Filler
        ra.Start(b.Sub(bnorm))
        ra.Line(a.Sub(r.Ln))
        ra.Start(a.Add(r.Ln))
        ra.Line(b.Add(bnorm))
        r.A = b
        r.Ln = bnorm
}

// Start iniitates a stroked path
func (r *Stroker) Start(a fixed.Point26_6) {
        r.InStroke = false
        r.Filler.Start(a)
}

// CalcEndCurvature calculates the radius of curvature given the control points
// of a bezier curve.
// It is a low level function exposed for the purposes of callbacks
// and debugging.
func (r *Stroker) CalcEndCurvature(p0, p1, p2, q0, q1, q2 fixed.Point26_6,
        dm fixed.Int52_12, calcRadCuve bool) {
        r.TrailPoint.P = p0
        r.LeadPoint.P = q0
        r.TrailPoint.LTan = p1.Sub(p0)
        r.LeadPoint.TTan = q0.Sub(q1)
        r.TrailPoint.LNorm = TurnPort90(ToLength(r.TrailPoint.LTan, r.U))
        r.LeadPoint.TNorm = TurnPort90(ToLength(r.LeadPoint.TTan, r.U))
        if calcRadCuve {
                r.TrailPoint.RL = RadCurvature(p0, p1, p2, dm)
                r.LeadPoint.RT = -RadCurvature(q0, q1, q2, dm)
        } else {
                r.TrailPoint.RL = 0
                r.LeadPoint.RT = 0
        }
}

func (r *Stroker) JoinF() {
        if !r.InStroke {
                r.InStroke = true
                r.FirstP = r.TrailPoint
        } else {
                ra := &r.Filler
                tl := r.TrailPoint.P.Sub(r.TrailPoint.TNorm)
                th := r.TrailPoint.P.Add(r.TrailPoint.TNorm)
                if r.A != r.TrailPoint.P || r.Ln != r.TrailPoint.TNorm {
                        a := r.A
                        ra.Start(tl)
                        ra.Line(a.Sub(r.Ln))
                        ra.Start(a.Add(r.Ln))
                        ra.Line(th)
                }
                r.Joiner(r.TrailPoint)
                r.TrailPoint.BlackWidowMark(ra)
        }
        r.Ln = r.TrailPoint.LNorm
        r.A = r.TrailPoint.P
}

// BlackWidowMark handles a gap in a stroke that can occur when a line end is too close
// to a segment to segment join point. Although it is only required in those cases,
// at this point, no code has been written to properly detect when it is needed,
// so for now it just draws by default.
func (jp *C2Point) BlackWidowMark(ra Adder) {
        xprod := jp.TNorm.X*jp.LNorm.Y - jp.TNorm.Y*jp.LNorm.X
        if xprod > EpsilonFixed*EpsilonFixed {
                tl := jp.P.Sub(jp.TNorm)
                ll := jp.P.Sub(jp.LNorm)
                ra.Start(jp.P)
                ra.Line(tl)
                ra.Line(ll)
                ra.Line(jp.P)
        } else if xprod < -EpsilonFixed*EpsilonFixed {
                th := jp.P.Add(jp.TNorm)
                lh := jp.P.Add(jp.LNorm)
                ra.Start(jp.P)
                ra.Line(lh)
                ra.Line(th)
                ra.Line(jp.P)
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rasterx

import (
        "image"
        "image/color"
        "image/draw"
        _ "image/jpeg" // load image formats for users of the API
        _ "image/png"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/shaped/shapers/shapedgt"
        "cogentcore.org/core/text/textpos"
        "github.com/go-text/typesetting/font"
        "github.com/go-text/typesetting/font/opentype"
        "github.com/go-text/typesetting/shaping"
        _ "golang.org/x/image/tiff" // load image formats for users of the API
)

// RenderText rasterizes the given Text
func (rs *Renderer) RenderText(txt *render.Text) {
        // pr := profile.Start("RenderText")
        rs.TextLines(&txt.Context, txt.Text, txt.Position)
        // pr.End()
}

// TextLines rasterizes the given shaped.Lines.
// The text will be drawn starting at the start pixel position, which specifies the
// left baseline location of the first text item..
func (rs *Renderer) TextLines(ctx *render.Context, lns *shaped.Lines, pos math32.Vector2) {
        m := ctx.Transform
        identity := m == math32.Identity2()
        off := pos.Add(lns.Offset)
        rs.Scanner.SetClip(ctx.Bounds.Rect.ToRect())
        // tbb := lns.Bounds.Translate(off)
        // rs.StrokeBounds(ctx, tbb, colors.Red)
        clr := colors.Uniform(lns.Color)
        for li := range lns.Lines {
                ln := &lns.Lines[li]
                rs.TextLine(ctx, ln, lns, clr, off, identity)
        }
}

// TextLine rasterizes the given shaped.Line.
func (rs *Renderer) TextLine(ctx *render.Context, ln *shaped.Line, lns *shaped.Lines, clr image.Image, off math32.Vector2, identity bool) {
        start := off.Add(ln.Offset)
        off = start
        // tbb := ln.Bounds.Translate(off)
        // rs.StrokeBounds(ctx, tbb, colors.Blue)
        for ri := range ln.Runs {
                run := ln.Runs[ri].(*shapedgt.Run)
                rs.TextRunRegions(ctx, run, ln, lns, off)
                if run.Direction.IsVertical() {
                        off.Y += run.Advance()
                } else {
                        off.X += run.Advance()
                }
        }
        off = start
        for ri := range ln.Runs {
                run := ln.Runs[ri].(*shapedgt.Run)
                rs.TextRun(ctx, run, ln, lns, clr, off, identity)
                if run.Direction.IsVertical() {
                        off.Y += run.Advance()
                } else {
                        off.X += run.Advance()
                }
        }
}

// TextRegionFill fills given regions within run with given fill color.
func (rs *Renderer) TextRegionFill(ctx *render.Context, run *shapedgt.Run, off math32.Vector2, fill image.Image, ranges []textpos.Range) {
        if fill == nil {
                return
        }
        for _, sel := range ranges {
                rsel := sel.Intersect(run.Runes())
                if rsel.Len() == 0 {
                        continue
                }
                fi := run.FirstGlyphAt(rsel.Start)
                li := run.LastGlyphAt(rsel.End - 1)
                if fi >= 0 && li >= fi {
                        sbb := run.GlyphRegionBounds(fi, li).Canon()
                        rs.FillBounds(ctx, sbb.Translate(off), fill)
                }
        }
}

// TextRunRegions draws region fills for given run.
func (rs *Renderer) TextRunRegions(ctx *render.Context, run *shapedgt.Run, ln *shaped.Line, lns *shaped.Lines, off math32.Vector2) {
        // dir := run.Direction
        rbb := run.MaxBounds.Translate(off)
        if run.Background != nil {
                rs.FillBounds(ctx, rbb, run.Background)
        }
        rs.TextRegionFill(ctx, run, off, lns.SelectionColor, ln.Selections)
        rs.TextRegionFill(ctx, run, off, lns.HighlightColor, ln.Highlights)
}

// TextRun rasterizes the given text run into the output image using the
// font face set in the shaping.
// The text will be drawn starting at the start pixel position.
func (rs *Renderer) TextRun(ctx *render.Context, run *shapedgt.Run, ln *shaped.Line, lns *shaped.Lines, clr image.Image, off math32.Vector2, identity bool) {
        // dir := run.Direction
        rbb := run.MaxBounds.Translate(off)
        fill := clr
        if run.FillColor != nil {
                fill = run.FillColor
        }
        stroke := run.StrokeColor
        fsz := math32.FromFixed(run.Size)
        lineW := max(fsz/16, 1) // 1 at 16, bigger if biggerr
        if run.Math.Path != nil {
                rs.Path.Clear()
                PathToRasterx(&rs.Path, *run.Math.Path, ctx.Transform, off)
                rf := &rs.Raster.Filler
                rf.SetWinding(true)
                rf.SetColor(fill)
                rs.Path.AddTo(rf)
                rf.Draw()
                rf.Clear()
                return
        }

        if run.Decoration.HasFlag(rich.Underline) || run.Decoration.HasFlag(rich.DottedUnderline) {
                dash := []float32{2, 2}
                if run.Decoration.HasFlag(rich.Underline) {
                        dash = nil
                }
                if run.Direction.IsVertical() {

                } else {
                        dec := off.Y + 3
                        rs.StrokeTextLine(ctx, math32.Vec2(rbb.Min.X, dec), math32.Vec2(rbb.Max.X, dec), lineW, fill, dash)
                }
        }
        if run.Decoration.HasFlag(rich.Overline) {
                if run.Direction.IsVertical() {
                } else {
                        dec := off.Y - 0.7*rbb.Size().Y
                        rs.StrokeTextLine(ctx, math32.Vec2(rbb.Min.X, dec), math32.Vec2(rbb.Max.X, dec), lineW, fill, nil)
                }
        }

        for gi := range run.Glyphs {
                g := &run.Glyphs[gi]
                pos := off.Add(math32.Vec2(math32.FromFixed(g.XOffset), -math32.FromFixed(g.YOffset)))
                bb := run.GlyphBoundsBox(g).Translate(off)
                // rs.StrokeBounds(ctx, bb, colors.Yellow)

                data := run.Face.GlyphData(g.GlyphID)
                switch format := data.(type) {
                case font.GlyphOutline:
                        rs.GlyphOutline(ctx, run, g, format, fill, stroke, bb, pos, identity)
                case font.GlyphBitmap:
                        rs.GlyphBitmap(ctx, run, g, format, fill, stroke, bb, pos, identity)
                case font.GlyphSVG:
                        rs.GlyphSVG(ctx, run, g, format.Source, bb, pos, identity)
                }
                off.X += math32.FromFixed(g.XAdvance)
                off.Y -= math32.FromFixed(g.YAdvance)
        }

        if run.Decoration.HasFlag(rich.LineThrough) {
                if run.Direction.IsVertical() {
                } else {
                        dec := off.Y - 0.2*rbb.Size().Y
                        rs.StrokeTextLine(ctx, math32.Vec2(rbb.Min.X, dec), math32.Vec2(rbb.Max.X, dec), lineW, fill, nil)
                }
        }
}

func (rs *Renderer) GlyphOutline(ctx *render.Context, run *shapedgt.Run, g *shaping.Glyph, outline font.GlyphOutline, fill, stroke image.Image, bb math32.Box2, pos math32.Vector2, identity bool) {
        scale := math32.FromFixed(run.Size) / float32(run.Face.Upem())
        x := pos.X // note: has offsets already added
        y := pos.Y
        if len(outline.Segments) == 0 {
                // fmt.Println("nil path:", g.GlyphID)
                return
        }

        wd := math32.FromFixed(g.Width)
        xadv := math32.Abs(math32.FromFixed(g.XAdvance))
        if wd > xadv {
                if run.Font.Style(&ctx.Style.Text).Family == rich.Monospace {
                        scale *= 0.95 * xadv / wd
                }
        }

        if UseGlyphCache && identity && stroke == nil {
                mask, pi := theGlyphCache.Glyph(run.Face, g, outline, scale, pos)
                if mask != nil {
                        rs.GlyphMask(ctx, run, g, fill, stroke, bb, pi, mask)
                        return
                }
        }

        rs.Path.Clear()
        m := ctx.Transform
        for _, s := range outline.Segments {
                p0 := m.MulVector2AsPoint(math32.Vec2(s.Args[0].X*scale+x, -s.Args[0].Y*scale+y))
                switch s.Op {
                case opentype.SegmentOpMoveTo:
                        rs.Path.Start(p0.ToFixed())
                case opentype.SegmentOpLineTo:
                        rs.Path.Line(p0.ToFixed())
                case opentype.SegmentOpQuadTo:
                        p1 := m.MulVector2AsPoint(math32.Vec2(s.Args[1].X*scale+x, -s.Args[1].Y*scale+y))
                        rs.Path.QuadBezier(p0.ToFixed(), p1.ToFixed())
                case opentype.SegmentOpCubeTo:
                        p1 := m.MulVector2AsPoint(math32.Vec2(s.Args[1].X*scale+x, -s.Args[1].Y*scale+y))
                        p2 := m.MulVector2AsPoint(math32.Vec2(s.Args[2].X*scale+x, -s.Args[2].Y*scale+y))
                        rs.Path.CubeBezier(p0.ToFixed(), p1.ToFixed(), p2.ToFixed())
                }
        }
        rs.Path.Stop(true)
        if fill != nil {
                rf := &rs.Raster.Filler
                rf.SetWinding(true)
                rf.SetColor(fill)
                rs.Path.AddTo(rf)
                rf.Draw()
                rf.Clear()
        }

        if stroke != nil {
                sw := math32.FromFixed(run.Size) / 32.0 // scale with font size
                rs.Raster.SetStroke(
                        math32.ToFixed(sw),
                        math32.ToFixed(10),
                        ButtCap, nil, nil, Miter, nil, 0)
                rs.Path.AddTo(rs.Raster)
                rs.Raster.SetColor(stroke)
                rs.Raster.Draw()
                rs.Raster.Clear()
        }
        rs.Path.Clear()
}

func (rs *Renderer) GlyphMask(ctx *render.Context, run *shapedgt.Run, g *shaping.Glyph, fill, stroke image.Image, bb math32.Box2, pos image.Point, mask *image.Alpha) error {
        mbb := mask.Bounds()
        dbb := mbb.Add(pos)
        ibb := dbb.Intersect(ctx.Bounds.Rect.ToRect())
        if ibb == (image.Rectangle{}) {
                return nil
        }
        mp := ibb.Min.Sub(dbb.Min)
        draw.DrawMask(rs.image, ibb, fill, image.Point{}, mask, mp, draw.Over)
        return nil
}

// StrokeBounds strokes a bounding box in the given color. Useful for debugging.
func (rs *Renderer) StrokeBounds(ctx *render.Context, bb math32.Box2, clr color.Color) {
        rs.Raster.SetStroke(
                math32.ToFixed(1),
                math32.ToFixed(10),
                ButtCap, nil, nil, Miter,
                nil, 0)
        rs.Raster.SetColor(colors.Uniform(clr))
        m := ctx.Transform
        rs.Raster.Start(m.MulVector2AsPoint(math32.Vec2(bb.Min.X, bb.Min.Y)).ToFixed())
        rs.Raster.Line(m.MulVector2AsPoint(math32.Vec2(bb.Max.X, bb.Min.Y)).ToFixed())
        rs.Raster.Line(m.MulVector2AsPoint(math32.Vec2(bb.Max.X, bb.Max.Y)).ToFixed())
        rs.Raster.Line(m.MulVector2AsPoint(math32.Vec2(bb.Min.X, bb.Max.Y)).ToFixed())
        rs.Raster.Stop(true)
        rs.Raster.Draw()
        rs.Raster.Clear()
}

// StrokeTextLine strokes a line for text decoration.
func (rs *Renderer) StrokeTextLine(ctx *render.Context, sp, ep math32.Vector2, width float32, clr image.Image, dash []float32) {
        m := ctx.Transform
        sp = m.MulVector2AsPoint(sp)
        ep = m.MulVector2AsPoint(ep)
        width *= MeanScale(m)
        rs.Raster.SetStroke(
                math32.ToFixed(width),
                math32.ToFixed(10),
                ButtCap, nil, nil, Miter,
                dash, 0)
        rs.Raster.SetColor(clr)
        rs.Raster.Start(sp.ToFixed())
        rs.Raster.Line(ep.ToFixed())
        rs.Raster.Stop(false)
        rs.Raster.Draw()
        rs.Raster.Clear()
}

// FillBounds fills a bounding box in the given color.
func (rs *Renderer) FillBounds(ctx *render.Context, bb math32.Box2, clr image.Image) {
        rf := &rs.Raster.Filler
        rf.SetColor(clr)
        m := ctx.Transform
        rf.Start(m.MulVector2AsPoint(math32.Vec2(bb.Min.X, bb.Min.Y)).ToFixed())
        rf.Line(m.MulVector2AsPoint(math32.Vec2(bb.Max.X, bb.Min.Y)).ToFixed())
        rf.Line(m.MulVector2AsPoint(math32.Vec2(bb.Max.X, bb.Max.Y)).ToFixed())
        rf.Line(m.MulVector2AsPoint(math32.Vec2(bb.Min.X, bb.Max.Y)).ToFixed())
        rf.Stop(true)
        rf.Draw()
        rf.Clear()
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rasterx

import (
        "bytes"
        "image"
        "image/color"
        "image/draw"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/text/shaped/shapers/shapedgt"
        "github.com/go-text/typesetting/font"
        "github.com/go-text/typesetting/shaping"
        scale "golang.org/x/image/draw"
)

var bitmapGlyphCache map[glyphKey]*image.RGBA

func (rs *Renderer) GlyphBitmap(ctx *render.Context, run *shapedgt.Run, g *shaping.Glyph, bitmap font.GlyphBitmap, fill, stroke image.Image, bb math32.Box2, pos math32.Vector2, identity bool) error {
        if bitmapGlyphCache == nil {
                bitmapGlyphCache = make(map[glyphKey]*image.RGBA)
        }
        // todo: this needs serious work to function with transforms
        x := pos.X
        y := pos.Y
        top := y - math32.FromFixed(g.YBearing)
        bottom := top - math32.FromFixed(g.Height)
        right := x + math32.FromFixed(g.Width)
        dbb := image.Rect(int(x), int(top), int(right), int(bottom))
        ibb := dbb.Intersect(ctx.Bounds.Rect.ToRect())
        if ibb == (image.Rectangle{}) {
                return nil
        }

        fam := run.Font.Style(&ctx.Style.Text).Family
        size := dbb.Size()

        gk := glyphKey{gid: g.GlyphID, sx: uint8(size.Y / 256), sy: uint8(size.Y % 256), ox: uint8(fam)}
        img, ok := bitmapGlyphCache[gk]
        if !ok {
                img = image.NewRGBA(image.Rectangle{Max: size})
                switch bitmap.Format {
                case font.BlackAndWhite:
                        rec := image.Rect(0, 0, bitmap.Width, bitmap.Height)
                        sub := image.NewPaletted(rec, color.Palette{color.Transparent, colors.ToUniform(fill)})

                        for i := range sub.Pix {
                                sub.Pix[i] = bitAt(bitmap.Data, i)
                        }
                        // note: NearestNeighbor is better than bilinear
                        scale.NearestNeighbor.Scale(img, img.Bounds(), sub, sub.Bounds(), draw.Src, nil)
                case font.JPG, font.PNG, font.TIFF:
                        pix, _, err := image.Decode(bytes.NewReader(bitmap.Data))
                        if err != nil {
                                return err
                        }
                        scale.NearestNeighbor.Scale(img, img.Bounds(), pix, pix.Bounds(), draw.Src, nil)
                }
                bitmapGlyphCache[gk] = img
        }

        sp := ibb.Min.Sub(dbb.Min)
        draw.Draw(rs.image, ibb, img, sp, draw.Over)

        if bitmap.Outline != nil {
                rs.GlyphOutline(ctx, run, g, *bitmap.Outline, fill, stroke, bb, pos, identity)
        }
        return nil
}

// bitAt returns the bit at the given index in the byte slice.
func bitAt(b []byte, i int) byte {
        return (b[i/8] >> (7 - i%8)) & 1
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rasterx

import (
        "bytes"
        "fmt"
        "image"
        "image/draw"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/svg"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped/shapers/shapedgt"
        "github.com/go-text/typesetting/shaping"
)

var svgGlyphCache map[glyphKey]image.Image

func (rs *Renderer) GlyphSVG(ctx *render.Context, run *shapedgt.Run, g *shaping.Glyph, svgCmds []byte, bb math32.Box2, pos math32.Vector2, identity bool) {
        if svgGlyphCache == nil {
                svgGlyphCache = make(map[glyphKey]image.Image)
        }
        size := run.Size.Floor()
        fsize := image.Point{X: size, Y: size}
        scale := 82.0 / float32(run.Face.Upem())
        fam := run.Font.Style(&ctx.Style.Text).Family
        if fam == rich.Monospace {
                scale *= 0.8
        }
        gk := glyphKey{gid: g.GlyphID, sx: uint8(size / 256), sy: uint8(size % 256), ox: uint8(fam)}
        img, ok := svgGlyphCache[gk]
        if !ok {
                sv := svg.NewSVG(math32.FromPoint(fsize))
                sv.GroupFilter = fmt.Sprintf("glyph%d", g.GlyphID) // critical: for filtering items with many glyphs
                b := bytes.NewBuffer(svgCmds)
                err := sv.ReadXML(b)
                errors.Log(err)
                sv.Translate.Y = float32(run.Face.Upem())
                sv.Scale = scale
                img = sv.RenderImage()
                svgGlyphCache[gk] = img
        }
        left := int(math32.Round(pos.X + math32.FromFixed(g.XBearing)))
        desc := run.Output.LineBounds.Descent
        top := int(math32.Round(pos.Y - math32.FromFixed(g.YBearing+desc) - float32(fsize.Y)))
        dbb := img.Bounds().Add(image.Point{left, top})
        ibb := dbb.Intersect(ctx.Bounds.Rect.ToRect())
        if ibb == (image.Rectangle{}) {
                return
        }
        sp := ibb.Min.Sub(dbb.Min)
        draw.Draw(rs.image, ibb, img, sp, draw.Over)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package renderers

import (
        "cogentcore.org/core/paint"
        "cogentcore.org/core/paint/renderers/svgrender"
        _ "cogentcore.org/core/text/shaped/shapers"
)

func init() {
        paint.NewSVGRenderer = svgrender.New
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !js

package renderers

import (
        "cogentcore.org/core/paint"
        "cogentcore.org/core/paint/renderers/rasterx"
        _ "cogentcore.org/core/text/shaped/shapers"
)

func init() {
        paint.NewSourceRenderer = rasterx.New
        paint.NewImageRenderer = rasterx.New
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svgrender

import (
        "bytes"
        "image"
        "maps"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/stack"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/paint/pimage"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/svg"
        "cogentcore.org/core/text/shaped/shapers/shapedgt"
)

// Renderer is the SVG renderer.
type Renderer struct {
        size math32.Vector2

        SVG *svg.SVG

        // gpStack is a stack of groups used while building the svg
        gpStack stack.Stack[*svg.Group]
}

func New(size math32.Vector2) render.Renderer {
        rs := &Renderer{}
        rs.SetSize(units.UnitDot, size)
        return rs
}

func (rs *Renderer) Image() image.Image {
        if rs.SVG == nil {
                return nil
        }
        pc := rs.SVG.Render(nil)
        ir := paint.NewImageRenderer(rs.size)
        ir.Render(pc.RenderDone())
        return ir.Image()
}

func (rs *Renderer) Source() []byte {
        if rs.SVG == nil {
                return nil
        }
        var b bytes.Buffer
        rs.SVG.WriteXML(&b, true)
        return b.Bytes()
}

func (rs *Renderer) Size() (units.Units, math32.Vector2) {
        return units.UnitDot, rs.size
}

func (rs *Renderer) SetSize(un units.Units, size math32.Vector2) {
        if rs.size == size {
                return
        }
        rs.size = size
}

// Render is the main rendering function.
func (rs *Renderer) Render(r render.Render) render.Renderer {
        rs.SVG = svg.NewSVG(rs.size)
        rs.gpStack = nil
        bg := svg.NewGroup(rs.SVG.Root)
        rs.gpStack.Push(bg)
        for _, ri := range r {
                switch x := ri.(type) {
                case *render.Path:
                        rs.RenderPath(x)
                case *pimage.Params:
                        rs.RenderImage(x)
                case *render.Text:
                        rs.RenderText(x)
                case *render.ContextPush:
                        rs.PushContext(x)
                case *render.ContextPop:
                        rs.PopContext(x)
                }
        }
        // pc := paint.NewPainter(rs.size)
        // rs.SVG.Render(pc)
        // rs.rend = pc.RenderDone()
        return rs
}

func (rs *Renderer) PushGroup() *svg.Group {
        cg := rs.gpStack.Peek()
        g := svg.NewGroup(cg)
        rs.gpStack.Push(g)
        return g
}

func (rs *Renderer) RenderPath(pt *render.Path) {
        p := pt.Path
        pc := &pt.Context
        cg := rs.gpStack.Peek()
        sp := svg.NewPath(cg)
        sp.Data = p.Clone()
        props := map[string]any{}
        pt.Context.Style.GetProperties(props)
        if !pc.Transform.IsIdentity() {
                props["transform"] = pc.Transform.String()
        }
        sp.Properties = props
        // rs.Scanner.SetClip(pc.Bounds.Rect.ToRect())
}

func (rs *Renderer) PushContext(pt *render.ContextPush) {
        pc := &pt.Context
        g := rs.PushGroup()
        g.Paint.Transform = pc.Transform
}

func (rs *Renderer) PopContext(pt *render.ContextPop) {
        rs.gpStack.Pop()
}

func (rs *Renderer) RenderText(pt *render.Text) {
        pc := &pt.Context
        cg := rs.gpStack.Peek()
        tg := svg.NewGroup(cg)
        props := map[string]any{}
        pt.Context.Style.GetProperties(props)
        if !pc.Transform.IsIdentity() {
                props["transform"] = pc.Transform.String()
        }
        pos := pt.Position
        tx := pt.Text.Source
        txt := tx.Join()
        for li := range pt.Text.Lines {
                ln := &pt.Text.Lines[li]
                lpos := pos.Add(ln.Offset)
                rpos := lpos
                for ri := range ln.Runs {
                        run := ln.Runs[ri].(*shapedgt.Run)
                        rs := run.Runes().Start
                        re := run.Runes().End
                        si, _, _ := tx.Index(rs)
                        sty, _ := tx.Span(si)
                        rtxt := txt[rs:re]

                        st := svg.NewText(tg)
                        st.Text = string(rtxt)
                        rprops := maps.Clone(props)
                        if pc.Style.UnitContext.DPI != 160 {
                                sty.Size *= pc.Style.UnitContext.DPI / 160
                        }
                        pt.Context.Style.Text.ToProperties(sty, rprops)
                        rprops["x"] = reflectx.ToString(rpos.X)
                        rprops["y"] = reflectx.ToString(rpos.Y)
                        st.Pos = rpos
                        st.Properties = rprops

                        rpos.X += run.Advance()
                }
        }
}

func (rs *Renderer) RenderImage(pr *pimage.Params) {
        usrc := imagex.Unwrap(pr.Source)
        umask := imagex.Unwrap(pr.Mask)
        cg := rs.gpStack.Peek()

        nilSrc := usrc == nil
        if r, ok := usrc.(*image.RGBA); ok && r == nil {
                nilSrc = true
        }
        if pr.Rect == (image.Rectangle{}) {
                pr.Rect = image.Rectangle{Max: rs.size.ToPoint()}
        }

        // todo: handle masks!

        // Fast path for [image.Uniform]
        if u, ok := usrc.(*image.Uniform); nilSrc || ok && umask == nil {
                _ = u
                return
        }

        if gr, ok := usrc.(gradient.Gradient); ok {
                _ = gr
                // todo: handle:
                return
        }

        sz := pr.Rect.Size()

        simg := svg.NewImage(cg)
        simg.SetImage(usrc, float32(sz.X), float32(sz.Y))
        simg.Pos = math32.FromPoint(pr.Rect.Min)
        // todo: ViewBox?
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package paint

import (
        "image"
        "log/slog"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/sides"
)

var (
        // NewSourceRenderer returns the [composer.Source] renderer
        // for [Painter] rendering, for the current platform.
        NewSourceRenderer func(size math32.Vector2) render.Renderer

        // NewImageRenderer returns a painter renderer for generating
        // images locally in Go regardless of platform.
        NewImageRenderer func(size math32.Vector2) render.Renderer

        // NewSVGRenderer returns a structured SVG renderer that can
        // generate an SVG vector graphics document from painter content.
        NewSVGRenderer func(size math32.Vector2) render.Renderer
)

// RenderToImage is a convenience function that renders the current
// accumulated painter actions to an image using a [NewImageRenderer],
// and returns the Image() call from that renderer.
// The image is wrapped by [imagex.WrapJS] so that it is ready to be
// used efficiently for subsequent rendering actions on the JS (web) platform.
func RenderToImage(pc *Painter) image.Image {
        rd := NewImageRenderer(pc.Size)
        return imagex.WrapJS(rd.Render(pc.RenderDone()).Image())
}

// RenderToSVG is a convenience function that renders the current
// accumulated painter actions to an SVG document using a
// [NewSVGRenderer].n
func RenderToSVG(pc *Painter) []byte {
        rd := NewSVGRenderer(pc.Size)
        return rd.Render(pc.RenderDone()).Source()
}

// The State holds all the current rendering state information used
// while painting. The [Paint] embeds a pointer to this.
type State struct {
        // Size in dots (true pixels) as specified during Init.
        Size math32.Vector2

        // Stack provides the SVG "stacking context" as a stack of [Context]s.
        // There is always an initial base-level Context element for the overall
        // rendering context.
        Stack []*render.Context

        // Render holds the current [render.PaintRender] state that we are building.
        // and has the list of [render.Renderer]s that we render to.
        Render render.Render

        // Path is the current path state we are adding to.
        Path ppath.Path
}

// Init initializes the rendering state, creating a new Stack
// with an initial baseline context using given size and styles.
// Size is used to set the bounds for clipping rendering, assuming
// units are image dots (true pixels), which is typical.
// This should be called whenever the size changes.
func (rs *State) Init(sty *styles.Paint, size math32.Vector2) {
        rs.Size = size
        bounds := render.NewBounds(0, 0, size.X, size.Y, sides.Floats{})
        rs.Stack = []*render.Context{render.NewContext(sty, bounds, nil)}
        rs.Render = nil
        rs.Path = nil
}

// RenderDone should be called when the full set of rendering
// for this painter is done. It returns a self-contained
// [render.Render] representing the entire rendering state,
// suitable for rendering by passing to a [render.Renderer].
// It resets the current painter state so that it is ready for
// new rendering.
func (rs *State) RenderDone() render.Render {
        npr := rs.Render.Clone()
        rs.Render.Reset()
        rs.Path.Reset()
        if len(rs.Stack) > 1 { // ensure back to baseline stack
                rs.Stack = rs.Stack[:1]
        }
        return npr
}

// Context() returns the currently active [render.Context] state (top of Stack).
func (rs *State) Context() *render.Context {
        return rs.Stack[len(rs.Stack)-1]
}

// PushContext pushes a new [render.Context] onto the stack using given styles and bounds.
// The transform from the style will be applied to all elements rendered
// within this group, along with the other group properties.
// This adds the Context to the current Render state as well, so renderers
// that track grouping will track this.
// Must protect within render mutex lock (see Lock version).
func (rs *State) PushContext(sty *styles.Paint, bounds *render.Bounds) *render.Context {
        parent := rs.Context()
        g := render.NewContext(sty, bounds, parent)
        rs.Stack = append(rs.Stack, g)
        rs.Render.Add(&render.ContextPush{Context: *g})
        return g
}

// PopContext pops the current Context off of the Stack.
func (rs *State) PopContext() {
        n := len(rs.Stack)
        if n == 1 {
                slog.Error("programmer error: paint.State.PopContext: stack is at base starting point")
                return
        }
        rs.Stack = rs.Stack[:n-1]
        rs.Render.Add(&render.ContextPop{})
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package abilities

//go:generate core generate

import "cogentcore.org/core/enums"

// Abilities represent abilities of GUI elements to take on different States,
// and are aligned with the States flags.  All elements can be disabled.
// These correspond to some of the global attributes in CSS:
// https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes
type Abilities int64 //enums:bitflag

const (
        // Selectable means it can be Selected
        Selectable Abilities = iota

        // Activatable means it can be made Active by pressing down on it,
        // which gives it a visible state layer color change.
        // This also implies Clickable, receiving Click events when
        // the user executes a mouse down and up event on the same element.
        Activatable

        // Clickable means it can be Clicked, receiving Click events when
        // the user executes a mouse down and up event on the same element,
        // but otherwise does not change its rendering when pressed
        // (as Activatable does).  Use this for items that are more passively
        // clickable, such as frames or tables, whereas e.g., a Button is
        // Activatable.
        Clickable

        // DoubleClickable indicates that an element does something different
        // when it is clicked on twice in a row.
        DoubleClickable

        // TripleClickable indicates that an element does something different
        // when it is clicked on three times in a row.
        TripleClickable

        // RepeatClickable indicates that an element should receive repeated
        // click events when the pointer is held down on it.
        RepeatClickable

        // LongPressable indicates that an element can be LongPressed.
        LongPressable

        // Draggable means it can be Dragged
        Draggable

        // Droppable means it can receive DragEnter, DragLeave, and Drop events
        // (not specific to current Drag item, just generally).
        Droppable

        // Slideable means it has a slider element that can be dragged
        // to change value.  Cannot be both Draggable and Slideable.
        Slideable

        // Checkable means it can be Checked.
        Checkable

        // Scrollable means it can be Scrolled.
        Scrollable

        // Focusable means it can be Focused: capable of receiving and
        // processing key events directly and typically changing the
        // style when focused to indicate this property to the user.
        Focusable

        // Hoverable means it can be Hovered.
        Hoverable

        // LongHoverable means it can be LongHovered.
        LongHoverable

        // ScrollableUnattended means it can be Scrolled and Slided without
        // Focused or Attended state. This is true by default only for Frames.
        ScrollableUnattended
)

var (
        // Pressable is the list of abilities that makes something Pressable
        Pressable = []Abilities{Selectable, Activatable, DoubleClickable, TripleClickable, Draggable, Slideable, Checkable, Clickable}

        pressableBits = []enums.BitFlag{Selectable, Activatable, DoubleClickable, TripleClickable, Draggable, Slideable, Checkable, Clickable}
)

// Is is a shortcut for HasFlag for Abilities
func (ab *Abilities) Is(flag enums.BitFlag) bool {
        return ab.HasFlag(flag)
}

// IsPressable returns true when an element is Selectable, Activatable,
// DoubleClickable, Draggable, Slideable, or Checkable
func (ab *Abilities) IsPressable() bool {
        return enums.HasAnyFlags((*int64)(ab), pressableBits...)
}

// IsHoverable is true for both Hoverable and LongHoverable
func (ab *Abilities) IsHoverable() bool {
        return ab.HasFlag(Hoverable) || ab.HasFlag(LongHoverable)
}

// Code generated by "core generate"; DO NOT EDIT.

package abilities

import (
        "cogentcore.org/core/enums"
)

var _AbilitiesValues = []Abilities{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}

// AbilitiesN is the highest valid value for type Abilities, plus one.
const AbilitiesN Abilities = 16

var _AbilitiesValueMap = map[string]Abilities{`Selectable`: 0, `Activatable`: 1, `Clickable`: 2, `DoubleClickable`: 3, `TripleClickable`: 4, `RepeatClickable`: 5, `LongPressable`: 6, `Draggable`: 7, `Droppable`: 8, `Slideable`: 9, `Checkable`: 10, `Scrollable`: 11, `Focusable`: 12, `Hoverable`: 13, `LongHoverable`: 14, `ScrollableUnattended`: 15}

var _AbilitiesDescMap = map[Abilities]string{0: `Selectable means it can be Selected`, 1: `Activatable means it can be made Active by pressing down on it, which gives it a visible state layer color change. This also implies Clickable, receiving Click events when the user executes a mouse down and up event on the same element.`, 2: `Clickable means it can be Clicked, receiving Click events when the user executes a mouse down and up event on the same element, but otherwise does not change its rendering when pressed (as Activatable does). Use this for items that are more passively clickable, such as frames or tables, whereas e.g., a Button is Activatable.`, 3: `DoubleClickable indicates that an element does something different when it is clicked on twice in a row.`, 4: `TripleClickable indicates that an element does something different when it is clicked on three times in a row.`, 5: `RepeatClickable indicates that an element should receive repeated click events when the pointer is held down on it.`, 6: `LongPressable indicates that an element can be LongPressed.`, 7: `Draggable means it can be Dragged`, 8: `Droppable means it can receive DragEnter, DragLeave, and Drop events (not specific to current Drag item, just generally).`, 9: `Slideable means it has a slider element that can be dragged to change value. Cannot be both Draggable and Slideable.`, 10: `Checkable means it can be Checked.`, 11: `Scrollable means it can be Scrolled.`, 12: `Focusable means it can be Focused: capable of receiving and processing key events directly and typically changing the style when focused to indicate this property to the user.`, 13: `Hoverable means it can be Hovered.`, 14: `LongHoverable means it can be LongHovered.`, 15: `ScrollableUnattended means it can be Scrolled and Slided without Focused or Attended state. This is true by default only for Frames.`}

var _AbilitiesMap = map[Abilities]string{0: `Selectable`, 1: `Activatable`, 2: `Clickable`, 3: `DoubleClickable`, 4: `TripleClickable`, 5: `RepeatClickable`, 6: `LongPressable`, 7: `Draggable`, 8: `Droppable`, 9: `Slideable`, 10: `Checkable`, 11: `Scrollable`, 12: `Focusable`, 13: `Hoverable`, 14: `LongHoverable`, 15: `ScrollableUnattended`}

// String returns the string representation of this Abilities value.
func (i Abilities) String() string { return enums.BitFlagString(i, _AbilitiesValues) }

// BitIndexString returns the string representation of this Abilities value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i Abilities) BitIndexString() string { return enums.String(i, _AbilitiesMap) }

// SetString sets the Abilities value from its string representation,
// and returns an error if the string is invalid.
func (i *Abilities) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the Abilities value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *Abilities) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _AbilitiesValueMap, "Abilities")
}

// Int64 returns the Abilities value as an int64.
func (i Abilities) Int64() int64 { return int64(i) }

// SetInt64 sets the Abilities value from an int64.
func (i *Abilities) SetInt64(in int64) { *i = Abilities(in) }

// Desc returns the description of the Abilities value.
func (i Abilities) Desc() string { return enums.Desc(i, _AbilitiesDescMap) }

// AbilitiesValues returns all possible values for the type Abilities.
func AbilitiesValues() []Abilities { return _AbilitiesValues }

// Values returns all possible values for the type Abilities.
func (i Abilities) Values() []enums.Enum { return enums.Values(_AbilitiesValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *Abilities) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *Abilities) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Abilities) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Abilities) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Abilities")
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "image"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/sides"
        "cogentcore.org/core/styles/units"
)

// note: background-color is in FontStyle as it is needed to make that the
// only style needed for text render styling

// // Background has style parameters for backgrounds
// type Background struct {
//         // todo: all the properties not yet implemented -- mostly about images
//         // Image is like a PaintServer -- includes gradients etc
//         // Attachment -- how the image moves
//         // Clip -- how to clip the image
//         // Origin
//         // Position
//         // Repeat
//         // Size
// }

// func (b *Background) Defaults() {
//         b.Color.SetColor(White)
// }

// BorderStyles determines how to draw the border
type BorderStyles int32 //enums:enum -trim-prefix Border -transform kebab

const (
        // BorderSolid indicates to render a solid border.
        BorderSolid BorderStyles = iota

        // BorderDotted indicates to render a dotted border.
        BorderDotted

        // BorderDashed indicates to render a dashed border.
        BorderDashed

        // TODO(kai): maybe implement these at some point if there
        // is ever an actual use case for them

        // BorderDouble is not currently supported.
        BorderDouble

        // BorderGroove is not currently supported.
        BorderGroove

        // BorderRidge is not currently supported.
        BorderRidge

        // BorderInset is not currently supported.
        BorderInset

        // BorderOutset is not currently supported.
        BorderOutset

        // BorderNone indicates to render no border.
        BorderNone
)

// IMPORTANT: any changes here must be updated in style_properties.go StyleBorderFuncs

// Border contains style parameters for borders
type Border struct { //types:add

        // Style specifies how to draw the border
        Style sides.Sides[BorderStyles]

        // Width specifies the width of the border
        Width sides.Values `display:"inline"`

        // Radius specifies the radius (rounding) of the corners
        Radius sides.Values `display:"inline"`

        // Offset specifies how much, if any, the border is offset
        // from its element. It is only applicable in the standard
        // box model, which is used by [paint.Painter.DrawStdBox] and
        // all standard GUI elements.
        Offset sides.Values `display:"inline"`

        // Color specifies the color of the border
        Color sides.Sides[image.Image] `display:"inline"`
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (bs *Border) ToDots(uc *units.Context) {
        bs.Width.ToDots(uc)
        bs.Radius.ToDots(uc)
        bs.Offset.ToDots(uc)
}

// Pre-configured border radius values, based on
// https://m3.material.io/styles/shape/shape-scale-tokens
var (
        // BorderRadiusExtraSmall indicates to use extra small
        // 4dp rounded corners
        BorderRadiusExtraSmall = sides.NewValues(units.Dp(4))

        // BorderRadiusExtraSmallTop indicates to use extra small
        // 4dp rounded corners on the top of the element and no
        // border radius on the bottom of the element
        BorderRadiusExtraSmallTop = sides.NewValues(units.Dp(4), units.Dp(4), units.Zero(), units.Zero())

        // BorderRadiusSmall indicates to use small
        // 8dp rounded corners
        BorderRadiusSmall = sides.NewValues(units.Dp(8))

        // BorderRadiusMedium indicates to use medium
        // 12dp rounded corners
        BorderRadiusMedium = sides.NewValues(units.Dp(12))

        // BorderRadiusLarge indicates to use large
        // 16dp rounded corners
        BorderRadiusLarge = sides.NewValues(units.Dp(16))

        // BorderRadiusLargeEnd indicates to use large
        // 16dp rounded corners on the end (right side)
        // of the element and no border radius elsewhere
        BorderRadiusLargeEnd = sides.NewValues(units.Zero(), units.Dp(16), units.Dp(16), units.Zero())

        // BorderRadiusLargeTop indicates to use large
        // 16dp rounded corners on the top of the element
        // and no border radius on the bottom of the element
        BorderRadiusLargeTop = sides.NewValues(units.Dp(16), units.Dp(16), units.Zero(), units.Zero())

        // BorderRadiusExtraLarge indicates to use extra large
        // 28dp rounded corners
        BorderRadiusExtraLarge = sides.NewValues(units.Dp(28))

        // BorderRadiusExtraLargeTop indicates to use extra large
        // 28dp rounded corners on the top of the element
        // and no border radius on the bottom of the element
        BorderRadiusExtraLargeTop = sides.NewValues(units.Dp(28), units.Dp(28), units.Zero(), units.Zero())

        // BorderRadiusFull indicates to use a full border radius,
        // which creates a circular/pill-shaped object.
        // It is defined to be a value that the width/height of an object
        // will never exceed.
        BorderRadiusFull = sides.NewValues(units.Dp(1_000_000_000))
)

// IMPORTANT: any changes here must be updated in style_properties.go StyleShadowFuncs

// style parameters for shadows
type Shadow struct { //types:add

        // OffsetX is th horizontal offset of the shadow.
        // Positive moves it right, negative moves it left.
        OffsetX units.Value

        // OffsetY is the vertical offset of the shadow.
        // Positive moves it down, negative moves it up.
        OffsetY units.Value

        // Blur specifies the blur radius of the shadow.
        // Higher numbers make it more blurry.
        Blur units.Value

        // Spread specifies the spread radius of the shadow.
        // Positive numbers increase the size of the shadow,
        // and negative numbers decrease the size.
        Spread units.Value

        // Color specifies the color of the shadow.
        Color image.Image

        // Inset specifies whether the shadow is inset within the
        // box instead of outset outside of the box.
        // TODO: implement.
        Inset bool
}

func (s *Shadow) HasShadow() bool {
        return s.OffsetX.Dots != 0 || s.OffsetY.Dots != 0 || s.Blur.Dots != 0 || s.Spread.Dots != 0
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (s *Shadow) ToDots(uc *units.Context) {
        s.OffsetX.ToDots(uc)
        s.OffsetY.ToDots(uc)
        s.Blur.ToDots(uc)
        s.Spread.ToDots(uc)
}

// BasePos returns the position at which the base box shadow
// (the actual solid, unblurred box part) should be rendered
// if the shadow is on an element with the given starting position.
func (s *Shadow) BasePos(startPos math32.Vector2) math32.Vector2 {
        // Offset directly affects position.
        // We need to subtract spread
        // to compensate for size changes and stay centered.
        return startPos.Add(math32.Vec2(s.OffsetX.Dots, s.OffsetY.Dots)).SubScalar(s.Spread.Dots)
}

// BaseSize returns the total size the base box shadow
// (the actual solid, unblurred part) should be if
// the shadow is on an element with the given starting size.
func (s *Shadow) BaseSize(startSize math32.Vector2) math32.Vector2 {
        // Spread goes on all sides, so need to count twice per dimension.
        return startSize.AddScalar(2 * s.Spread.Dots)
}

// Pos returns the position at which the blurred box shadow
// should start if the shadow is on an element
// with the given starting position.
func (s *Shadow) Pos(startPos math32.Vector2) math32.Vector2 {
        // We need to subtract half of blur
        // to compensate for size changes and stay centered.
        return s.BasePos(startPos).SubScalar(s.Blur.Dots / 2)
}

// Size returns the total size occupied by the blurred box shadow
// if the shadow is on an element with the given starting size.
func (s *Shadow) Size(startSize math32.Vector2) math32.Vector2 {
        // Blur goes on all sides, but it is rendered as half of actual
        // because CSS does the same, so we only count it once.
        return s.BaseSize(startSize).AddScalar(s.Blur.Dots)
}

// Margin returns the effective margin created by the
// shadow on each side in terms of raw display dots.
// It should be added to margin for sizing considerations.
func (s *Shadow) Margin() sides.Floats {
        // Spread benefits every side.
        // Offset goes either way, depending on side.
        // Every side must be positive.

        // note: we are using EdgeBlurFactors with radiusFactor = 1
        // (sigma == radius), so we divide Blur / 2 relative to the
        // CSS standard of sigma = blur / 2 (i.e., our sigma = blur,
        // so we divide Blur / 2 to achieve the same effect).
        // This works fine for low-opacity blur factors (the edges are
        // so transparent that you can't really see beyond 1 sigma if
        // you used radiusFactor = 2).
        // If a higher-contrast shadow is used, it would look better
        // with radiusFactor = 2, and you'd have to remove this /2 factor.

        sdots := float32(0)
        if s.Blur.Dots > 0 {
                sdots = math32.Ceil(0.5 * s.Blur.Dots)
                if sdots < 2 { // for tight dp = 1 case, the render antialiasing requires a min width..
                        sdots = 2
                }
        }

        return sides.NewFloats(
                math32.Max(s.Spread.Dots-s.OffsetY.Dots+sdots, 0),
                math32.Max(s.Spread.Dots+s.OffsetX.Dots+sdots, 0),
                math32.Max(s.Spread.Dots+s.OffsetY.Dots+sdots, 0),
                math32.Max(s.Spread.Dots-s.OffsetX.Dots+sdots, 0),
        )
}

// AddBoxShadow adds the given box shadows to the style
func (s *Style) AddBoxShadow(shadow ...Shadow) {
        if s.BoxShadow == nil {
                s.BoxShadow = []Shadow{}
        }
        s.BoxShadow = append(s.BoxShadow, shadow...)
}

// BoxShadowMargin returns the effective box
// shadow margin of the style, calculated through [Shadow.Margin]
func (s *Style) BoxShadowMargin() sides.Floats {
        return BoxShadowMargin(s.BoxShadow)
}

// MaxBoxShadowMargin returns the maximum effective box
// shadow margin of the style, calculated through [Shadow.Margin]
func (s *Style) MaxBoxShadowMargin() sides.Floats {
        return BoxShadowMargin(s.MaxBoxShadow)
}

// BoxShadowMargin returns the maximum effective box shadow margin
// of the given box shadows, calculated through [Shadow.Margin].
func BoxShadowMargin(shadows []Shadow) sides.Floats {
        max := sides.Floats{}
        for _, sh := range shadows {
                max = max.Max(sh.Margin())
        }
        return max
}

// BoxShadowToDots runs ToDots on all box shadow
// unit values to compile down to raw pixels
func (s *Style) BoxShadowToDots(uc *units.Context) {
        for i := range s.BoxShadow {
                s.BoxShadow[i].ToDots(uc)
        }
        for i := range s.MaxBoxShadow {
                s.MaxBoxShadow[i].ToDots(uc)
        }
}

// HasBoxShadow returns whether the style has
// any box shadows
func (s *Style) HasBoxShadow() bool {
        for _, sh := range s.BoxShadow {
                if sh.HasShadow() {
                        return true
                }
        }
        return false
}

// Pre-configured box shadow values, based on
// those in Material 3.

// BoxShadow0 returns the shadows
// to be used on Elevation 0 elements.
// There are no shadows part of BoxShadow0,
// so applying it is purely semantic.
func BoxShadow0() []Shadow {
        return []Shadow{}
}

// BoxShadow1 contains the shadows
// to be used on Elevation 1 elements.
func BoxShadow1() []Shadow {
        return []Shadow{
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(3),
                        Blur:    units.Dp(1),
                        Spread:  units.Dp(-2),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.2),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(2),
                        Blur:    units.Dp(2),
                        Spread:  units.Zero(),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.14),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(1),
                        Blur:    units.Dp(5),
                        Spread:  units.Zero(),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.12),
                },
        }
}

// BoxShadow2 returns the shadows
// to be used on Elevation 2 elements.
func BoxShadow2() []Shadow {
        return []Shadow{
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(2),
                        Blur:    units.Dp(4),
                        Spread:  units.Dp(-1),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.2),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(4),
                        Blur:    units.Dp(5),
                        Spread:  units.Zero(),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.14),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(1),
                        Blur:    units.Dp(10),
                        Spread:  units.Zero(),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.12),
                },
        }
}

// TODO: figure out why 3 and 4 are the same

// BoxShadow3 returns the shadows
// to be used on Elevation 3 elements.
func BoxShadow3() []Shadow {
        return []Shadow{
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(5),
                        Blur:    units.Dp(5),
                        Spread:  units.Dp(-3),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.2),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(8),
                        Blur:    units.Dp(10),
                        Spread:  units.Dp(1),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.14),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(3),
                        Blur:    units.Dp(14),
                        Spread:  units.Dp(2),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.12),
                },
        }
}

// BoxShadow4 returns the shadows
// to be used on Elevation 4 elements.
func BoxShadow4() []Shadow {
        return []Shadow{
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(5),
                        Blur:    units.Dp(5),
                        Spread:  units.Dp(-3),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.2),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(8),
                        Blur:    units.Dp(10),
                        Spread:  units.Dp(1),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.14),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(3),
                        Blur:    units.Dp(14),
                        Spread:  units.Dp(2),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.12),
                },
        }
}

// BoxShadow5 returns the shadows
// to be used on Elevation 5 elements.
func BoxShadow5() []Shadow {
        return []Shadow{
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(8),
                        Blur:    units.Dp(10),
                        Spread:  units.Dp(-6),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.2),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(16),
                        Blur:    units.Dp(24),
                        Spread:  units.Dp(2),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.14),
                },
                {
                        OffsetX: units.Zero(),
                        OffsetY: units.Dp(6),
                        Blur:    units.Dp(30),
                        Spread:  units.Dp(5),
                        Color:   gradient.ApplyOpacity(colors.Scheme.Shadow, 0.12),
                },
        }
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import "cogentcore.org/core/math32"

// ClampMax returns given value, not greater than given max _only if_ max > 0
func ClampMax(v, mx float32) float32 {
        if mx <= 0 {
                return v
        }
        return min(v, mx)
}

// ClampMin returns given value, not less than given min _only if_ min > 0
func ClampMin(v, mn float32) float32 {
        if mn <= 0 {
                return v
        }
        return max(v, mn)
}

// SetClampMax ensures the given value is not greater than given max _only if_ max > 0
func SetClampMax(v *float32, mx float32) {
        if mx <= 0 {
                return
        }
        *v = min(*v, mx)
}

// SetClampMin ensures the given value is not less than given min _only if_ min > 0
func SetClampMin(v *float32, mn float32) {
        if mn <= 0 {
                return
        }
        *v = max(*v, mn)
}

// ClampMaxVector returns given Vector2 values, not greater than given max _only if_ max > 0
func ClampMaxVector(v, mx math32.Vector2) math32.Vector2 {
        var nv math32.Vector2
        nv.X = ClampMax(v.X, mx.X)
        nv.Y = ClampMax(v.Y, mx.Y)
        return nv
}

// ClampMinVector returns given Vector2 values, not less than given min _only if_ min > 0
func ClampMinVector(v, mn math32.Vector2) math32.Vector2 {
        var nv math32.Vector2
        nv.X = ClampMin(v.X, mn.X)
        nv.Y = ClampMin(v.Y, mn.Y)
        return nv
}

// SetClampMaxVector ensures the given Vector2 values are not greater than given max _only if_ max > 0
func SetClampMaxVector(v *math32.Vector2, mx math32.Vector2) {
        SetClampMax(&v.X, mx.X)
        SetClampMax(&v.Y, mx.Y)
}

// SetClampMinVector ensures the given Vector2 values are not less than given min _only if_ min > 0
func SetClampMinVector(v *math32.Vector2, mn math32.Vector2) {
        SetClampMin(&v.X, mn.X)
        SetClampMin(&v.Y, mn.Y)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "fmt"
        "image"
        "strconv"
        "strings"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
)

// ToCSS converts the given [Style] object to a semicolon-separated CSS string.
// It is not guaranteed to be fully complete or accurate. It also takes the kebab-case
// ID name of the associated widget and the resultant html element name for context.
func ToCSS(s *Style, idName, htmlName string) string {
        parts := []string{}
        add := func(key, value string) {
                if value == "" || value == "0" || value == "0px" || value == "0dot" {
                        return
                }
                parts = append(parts, key+":"+value)
        }

        add("color", colorToCSS(s.Color))
        add("background", colorToCSS(s.Background))
        if htmlName == "svg" {
                add("stroke", colorToCSS(s.Color))
                add("fill", colorToCSS(s.Color))
        }
        if idName != "text" { // text does not have these layout properties
                if s.Is(states.Invisible) {
                        add("display", "none")
                } else {
                        add("display", s.Display.String())
                }
                add("flex-direction", s.Direction.String())
                add("flex-grow", fmt.Sprintf("%g", s.Grow.Y))
                add("justify-content", s.Justify.Content.String())
                add("align-items", s.Align.Items.String())
                add("columns", strconv.Itoa(s.Columns))
                add("gap", s.Gap.X.StringCSS())
        }
        add("min-width", s.Min.X.StringCSS())
        add("min-height", s.Min.Y.StringCSS())
        add("max-width", s.Max.X.StringCSS())
        add("max-height", s.Max.Y.StringCSS())
        if s.Grow == (math32.Vector2{}) {
                add("width", s.Min.X.StringCSS())
                add("height", s.Min.Y.StringCSS())
        }
        add("padding-top", s.Padding.Top.StringCSS())
        add("padding-right", s.Padding.Right.StringCSS())
        add("padding-bottom", s.Padding.Bottom.StringCSS())
        add("padding-left", s.Padding.Left.StringCSS())
        add("margin", s.Margin.Top.StringCSS())
        if s.Font.Size.Value != 16 || s.Font.Size.Unit != units.UnitDp {
                add("font-size", s.Font.Size.StringCSS())
        }
        // todo:
        // if s.Font.Family != "" && s.Font.Family != "Roboto" {
        //         ff := s.Font.Family
        //         if strings.HasSuffix(ff, "Mono") {
        //                 ff += ", monospace"
        //         } else {
        //                 ff += ", sans-serif"
        //         }
        //         add("font-family", ff)
        // }
        if s.Font.Weight == rich.Medium {
                add("font-weight", "500")
        } else {
                add("font-weight", s.Font.Weight.String())
        }
        add("line-height", fmt.Sprintf("%g", s.Text.LineHeight))
        add("text-align", s.Text.Align.String())
        if s.Border.Width.Top.Value > 0 {
                add("border-style", s.Border.Style.Top.String())
                add("border-width", s.Border.Width.Top.StringCSS())
                add("border-color", colorToCSS(s.Border.Color.Top))
        }
        add("border-radius", s.Border.Radius.Top.StringCSS())

        return strings.Join(parts, ";")
}

func colorToCSS(c image.Image) string {
        switch c {
        case nil:
                return ""
        case colors.Scheme.Primary.Base:
                return "var(--primary-color)"
        case colors.Scheme.Primary.On:
                return "var(--primary-on-color)"
        case colors.Scheme.Secondary.Container:
                return "var(--secondary-container-color)"
        case colors.Scheme.Secondary.OnContainer:
                return "var(--secondary-on-container-color)"
        case colors.Scheme.Surface, colors.Scheme.OnSurface, colors.Scheme.Background, colors.Scheme.OnBackground:
                return "" // already default
        case colors.Scheme.SurfaceContainer, colors.Scheme.SurfaceContainerLowest, colors.Scheme.SurfaceContainerLow, colors.Scheme.SurfaceContainerHigh, colors.Scheme.SurfaceContainerHighest:
                return "var(--surface-container-color)" // all of them are close enough for this
        default:
                return colors.AsHex(colors.ToUniform(c))
        }
}

// Code generated by "core generate"; DO NOT EDIT.

package styles

import (
        "cogentcore.org/core/enums"
)

var _BorderStylesValues = []BorderStyles{0, 1, 2, 3, 4, 5, 6, 7, 8}

// BorderStylesN is the highest valid value for type BorderStyles, plus one.
const BorderStylesN BorderStyles = 9

var _BorderStylesValueMap = map[string]BorderStyles{`solid`: 0, `dotted`: 1, `dashed`: 2, `double`: 3, `groove`: 4, `ridge`: 5, `inset`: 6, `outset`: 7, `none`: 8}

var _BorderStylesDescMap = map[BorderStyles]string{0: `BorderSolid indicates to render a solid border.`, 1: `BorderDotted indicates to render a dotted border.`, 2: `BorderDashed indicates to render a dashed border.`, 3: `BorderDouble is not currently supported.`, 4: `BorderGroove is not currently supported.`, 5: `BorderRidge is not currently supported.`, 6: `BorderInset is not currently supported.`, 7: `BorderOutset is not currently supported.`, 8: `BorderNone indicates to render no border.`}

var _BorderStylesMap = map[BorderStyles]string{0: `solid`, 1: `dotted`, 2: `dashed`, 3: `double`, 4: `groove`, 5: `ridge`, 6: `inset`, 7: `outset`, 8: `none`}

// String returns the string representation of this BorderStyles value.
func (i BorderStyles) String() string { return enums.String(i, _BorderStylesMap) }

// SetString sets the BorderStyles value from its string representation,
// and returns an error if the string is invalid.
func (i *BorderStyles) SetString(s string) error {
        return enums.SetString(i, s, _BorderStylesValueMap, "BorderStyles")
}

// Int64 returns the BorderStyles value as an int64.
func (i BorderStyles) Int64() int64 { return int64(i) }

// SetInt64 sets the BorderStyles value from an int64.
func (i *BorderStyles) SetInt64(in int64) { *i = BorderStyles(in) }

// Desc returns the description of the BorderStyles value.
func (i BorderStyles) Desc() string { return enums.Desc(i, _BorderStylesDescMap) }

// BorderStylesValues returns all possible values for the type BorderStyles.
func BorderStylesValues() []BorderStyles { return _BorderStylesValues }

// Values returns all possible values for the type BorderStyles.
func (i BorderStyles) Values() []enums.Enum { return enums.Values(_BorderStylesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i BorderStyles) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *BorderStyles) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "BorderStyles")
}

var _DirectionsValues = []Directions{0, 1}

// DirectionsN is the highest valid value for type Directions, plus one.
const DirectionsN Directions = 2

var _DirectionsValueMap = map[string]Directions{`row`: 0, `column`: 1}

var _DirectionsDescMap = map[Directions]string{0: `Row indicates that elements are laid out in a row or that an element is longer / travels in the x dimension.`, 1: `Column indicates that elements are laid out in a column or that an element is longer / travels in the y dimension.`}

var _DirectionsMap = map[Directions]string{0: `row`, 1: `column`}

// String returns the string representation of this Directions value.
func (i Directions) String() string { return enums.String(i, _DirectionsMap) }

// SetString sets the Directions value from its string representation,
// and returns an error if the string is invalid.
func (i *Directions) SetString(s string) error {
        return enums.SetString(i, s, _DirectionsValueMap, "Directions")
}

// Int64 returns the Directions value as an int64.
func (i Directions) Int64() int64 { return int64(i) }

// SetInt64 sets the Directions value from an int64.
func (i *Directions) SetInt64(in int64) { *i = Directions(in) }

// Desc returns the description of the Directions value.
func (i Directions) Desc() string { return enums.Desc(i, _DirectionsDescMap) }

// DirectionsValues returns all possible values for the type Directions.
func DirectionsValues() []Directions { return _DirectionsValues }

// Values returns all possible values for the type Directions.
func (i Directions) Values() []enums.Enum { return enums.Values(_DirectionsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Directions) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Directions) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Directions")
}

var _DisplaysValues = []Displays{0, 1, 2, 3, 4}

// DisplaysN is the highest valid value for type Displays, plus one.
const DisplaysN Displays = 5

var _DisplaysValueMap = map[string]Displays{`flex`: 0, `stacked`: 1, `grid`: 2, `custom`: 3, `none`: 4}

var _DisplaysDescMap = map[Displays]string{0: `Flex is the default layout model, based on a simplified version of the CSS flex layout: uses MainAxis to specify the direction, Wrap for wrapping of elements, and Min, Max, and Grow values on elements to determine sizing.`, 1: `Stacked is a stack of elements, with one on top that is visible`, 2: `Grid is the X, Y grid layout, with Columns specifying the number of elements in the X axis.`, 3: `Custom means that no automatic layout will be applied to elements, which can then be managed via custom code by setting the [Style.Pos] position.`, 4: `None means the item is not displayed: sets the Invisible state`}

var _DisplaysMap = map[Displays]string{0: `flex`, 1: `stacked`, 2: `grid`, 3: `custom`, 4: `none`}

// String returns the string representation of this Displays value.
func (i Displays) String() string { return enums.String(i, _DisplaysMap) }

// SetString sets the Displays value from its string representation,
// and returns an error if the string is invalid.
func (i *Displays) SetString(s string) error {
        return enums.SetString(i, s, _DisplaysValueMap, "Displays")
}

// Int64 returns the Displays value as an int64.
func (i Displays) Int64() int64 { return int64(i) }

// SetInt64 sets the Displays value from an int64.
func (i *Displays) SetInt64(in int64) { *i = Displays(in) }

// Desc returns the description of the Displays value.
func (i Displays) Desc() string { return enums.Desc(i, _DisplaysDescMap) }

// DisplaysValues returns all possible values for the type Displays.
func DisplaysValues() []Displays { return _DisplaysValues }

// Values returns all possible values for the type Displays.
func (i Displays) Values() []enums.Enum { return enums.Values(_DisplaysValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Displays) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Displays) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Displays") }

var _AlignsValues = []Aligns{0, 1, 2, 3, 4, 5, 6, 7}

// AlignsN is the highest valid value for type Aligns, plus one.
const AlignsN Aligns = 8

var _AlignsValueMap = map[string]Aligns{`auto`: 0, `start`: 1, `end`: 2, `center`: 3, `baseline`: 4, `space-between`: 5, `space-around`: 6, `space-evenly`: 7}

var _AlignsDescMap = map[Aligns]string{0: `Auto means the item uses the container's AlignItems value`, 1: `Align items to the start (top, left) of layout`, 2: `Align items to the end (bottom, right) of layout`, 3: `Align items centered`, 4: `Align to text baselines`, 5: `First and last are flush, equal space between remaining items`, 6: `First and last have 1/2 space at edges, full space between remaining items`, 7: `Equal space at start, end, and between all items`}

var _AlignsMap = map[Aligns]string{0: `auto`, 1: `start`, 2: `end`, 3: `center`, 4: `baseline`, 5: `space-between`, 6: `space-around`, 7: `space-evenly`}

// String returns the string representation of this Aligns value.
func (i Aligns) String() string { return enums.String(i, _AlignsMap) }

// SetString sets the Aligns value from its string representation,
// and returns an error if the string is invalid.
func (i *Aligns) SetString(s string) error { return enums.SetString(i, s, _AlignsValueMap, "Aligns") }

// Int64 returns the Aligns value as an int64.
func (i Aligns) Int64() int64 { return int64(i) }

// SetInt64 sets the Aligns value from an int64.
func (i *Aligns) SetInt64(in int64) { *i = Aligns(in) }

// Desc returns the description of the Aligns value.
func (i Aligns) Desc() string { return enums.Desc(i, _AlignsDescMap) }

// AlignsValues returns all possible values for the type Aligns.
func AlignsValues() []Aligns { return _AlignsValues }

// Values returns all possible values for the type Aligns.
func (i Aligns) Values() []enums.Enum { return enums.Values(_AlignsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Aligns) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Aligns) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Aligns") }

var _OverflowsValues = []Overflows{0, 1, 2, 3}

// OverflowsN is the highest valid value for type Overflows, plus one.
const OverflowsN Overflows = 4

var _OverflowsValueMap = map[string]Overflows{`visible`: 0, `hidden`: 1, `auto`: 2, `scroll`: 3}

var _OverflowsDescMap = map[Overflows]string{0: `OverflowVisible makes the overflow visible, meaning that the size of the container is always at least the Min size of its contents. No scrollbars are shown.`, 1: `OverflowHidden hides the overflow and doesn't present scrollbars.`, 2: `OverflowAuto automatically determines if scrollbars should be added to show the overflow. Scrollbars are added only if the actual content size is greater than the currently available size.`, 3: `OverflowScroll means that scrollbars are always visible, and is otherwise identical to Auto. However, only during Viewport PrefSize call, the actual content size is used -- otherwise it behaves just like Auto.`}

var _OverflowsMap = map[Overflows]string{0: `visible`, 1: `hidden`, 2: `auto`, 3: `scroll`}

// String returns the string representation of this Overflows value.
func (i Overflows) String() string { return enums.String(i, _OverflowsMap) }

// SetString sets the Overflows value from its string representation,
// and returns an error if the string is invalid.
func (i *Overflows) SetString(s string) error {
        return enums.SetString(i, s, _OverflowsValueMap, "Overflows")
}

// Int64 returns the Overflows value as an int64.
func (i Overflows) Int64() int64 { return int64(i) }

// SetInt64 sets the Overflows value from an int64.
func (i *Overflows) SetInt64(in int64) { *i = Overflows(in) }

// Desc returns the description of the Overflows value.
func (i Overflows) Desc() string { return enums.Desc(i, _OverflowsDescMap) }

// OverflowsValues returns all possible values for the type Overflows.
func OverflowsValues() []Overflows { return _OverflowsValues }

// Values returns all possible values for the type Overflows.
func (i Overflows) Values() []enums.Enum { return enums.Values(_OverflowsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Overflows) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Overflows) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Overflows")
}

var _ObjectFitsValues = []ObjectFits{0, 1, 2, 3, 4}

// ObjectFitsN is the highest valid value for type ObjectFits, plus one.
const ObjectFitsN ObjectFits = 5

var _ObjectFitsValueMap = map[string]ObjectFits{`fill`: 0, `contain`: 1, `cover`: 2, `none`: 3, `scale-down`: 4}

var _ObjectFitsDescMap = map[ObjectFits]string{0: `FitFill indicates that the replaced object will fill the element's entire content box, stretching if necessary.`, 1: `FitContain indicates that the replaced object will resize as large as possible while fully fitting within the element's content box and maintaining its aspect ratio. Therefore, it may not fill the entire element.`, 2: `FitCover indicates that the replaced object will fill the element's entire content box, clipping if necessary.`, 3: `FitNone indicates that the replaced object will not resize.`, 4: `FitScaleDown indicates that the replaced object will size as if [FitNone] or [FitContain] was specified, using whichever will result in a smaller final size.`}

var _ObjectFitsMap = map[ObjectFits]string{0: `fill`, 1: `contain`, 2: `cover`, 3: `none`, 4: `scale-down`}

// String returns the string representation of this ObjectFits value.
func (i ObjectFits) String() string { return enums.String(i, _ObjectFitsMap) }

// SetString sets the ObjectFits value from its string representation,
// and returns an error if the string is invalid.
func (i *ObjectFits) SetString(s string) error {
        return enums.SetString(i, s, _ObjectFitsValueMap, "ObjectFits")
}

// Int64 returns the ObjectFits value as an int64.
func (i ObjectFits) Int64() int64 { return int64(i) }

// SetInt64 sets the ObjectFits value from an int64.
func (i *ObjectFits) SetInt64(in int64) { *i = ObjectFits(in) }

// Desc returns the description of the ObjectFits value.
func (i ObjectFits) Desc() string { return enums.Desc(i, _ObjectFitsDescMap) }

// ObjectFitsValues returns all possible values for the type ObjectFits.
func ObjectFitsValues() []ObjectFits { return _ObjectFitsValues }

// Values returns all possible values for the type ObjectFits.
func (i ObjectFits) Values() []enums.Enum { return enums.Values(_ObjectFitsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i ObjectFits) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *ObjectFits) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "ObjectFits")
}

var _VirtualKeyboardsValues = []VirtualKeyboards{0, 1, 2, 3, 4, 5, 6, 7}

// VirtualKeyboardsN is the highest valid value for type VirtualKeyboards, plus one.
const VirtualKeyboardsN VirtualKeyboards = 8

var _VirtualKeyboardsValueMap = map[string]VirtualKeyboards{`none`: 0, `single-line`: 1, `multi-line`: 2, `number`: 3, `password`: 4, `email`: 5, `phone`: 6, `url`: 7}

var _VirtualKeyboardsDescMap = map[VirtualKeyboards]string{0: `KeyboardNone indicates to display no virtual keyboard.`, 1: `KeyboardSingleLine indicates to display a virtual keyboard with a default input style and a "Done" return key.`, 2: `KeyboardMultiLine indicates to display a virtual keyboard with a default input style and a "Return" return key.`, 3: `KeyboardNumber indicates to display a virtual keyboard for inputting a number.`, 4: `KeyboardPassword indicates to display a virtual keyboard for inputting a password.`, 5: `KeyboardEmail indicates to display a virtual keyboard for inputting an email address.`, 6: `KeyboardPhone indicates to display a virtual keyboard for inputting a phone number.`, 7: `KeyboardURL indicates to display a virtual keyboard for inputting a URL / URI / web address.`}

var _VirtualKeyboardsMap = map[VirtualKeyboards]string{0: `none`, 1: `single-line`, 2: `multi-line`, 3: `number`, 4: `password`, 5: `email`, 6: `phone`, 7: `url`}

// String returns the string representation of this VirtualKeyboards value.
func (i VirtualKeyboards) String() string { return enums.String(i, _VirtualKeyboardsMap) }

// SetString sets the VirtualKeyboards value from its string representation,
// and returns an error if the string is invalid.
func (i *VirtualKeyboards) SetString(s string) error {
        return enums.SetString(i, s, _VirtualKeyboardsValueMap, "VirtualKeyboards")
}

// Int64 returns the VirtualKeyboards value as an int64.
func (i VirtualKeyboards) Int64() int64 { return int64(i) }

// SetInt64 sets the VirtualKeyboards value from an int64.
func (i *VirtualKeyboards) SetInt64(in int64) { *i = VirtualKeyboards(in) }

// Desc returns the description of the VirtualKeyboards value.
func (i VirtualKeyboards) Desc() string { return enums.Desc(i, _VirtualKeyboardsDescMap) }

// VirtualKeyboardsValues returns all possible values for the type VirtualKeyboards.
func VirtualKeyboardsValues() []VirtualKeyboards { return _VirtualKeyboardsValues }

// Values returns all possible values for the type VirtualKeyboards.
func (i VirtualKeyboards) Values() []enums.Enum { return enums.Values(_VirtualKeyboardsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i VirtualKeyboards) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *VirtualKeyboards) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "VirtualKeyboards")
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "log/slog"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
)

// IMPORTANT: any changes here must be updated in style_properties.go StyleFontFuncs

// Font contains all font styling information.
// Most of font information is inherited.
type Font struct { //types:add

        // Size of font to render (inherited).
        // Converted to points when getting font to use.
        Size units.Value

        // Family indicates the generic family of typeface to use, where the
        // specific named values to use for each are provided in the [Settings],
        // or [CustomFont] for [Custom].
        Family rich.Family

        // CustomFont specifies the Custom font name for Family = Custom.
        CustomFont rich.FontName

        // Slant allows italic or oblique faces to be selected.
        Slant rich.Slants

        // Weights are the degree of blackness or stroke thickness of a font.
        // This value ranges from 100.0 to 900.0, with 400.0 as normal.
        Weight rich.Weights

        // Stretch is the width of a font as an approximate fraction of the normal width.
        // Widths range from 0.5 to 2.0 inclusive, with 1.0 as the normal width.
        Stretch rich.Stretch

        // Decorations are underline, line-through, etc, as bit flags
        // that must be set using [Decorations.SetFlag].
        Decoration rich.Decorations
}

func (fs *Font) Defaults() {
        fs.Size.Dp(16)
        fs.Weight = rich.Normal
        fs.Stretch = rich.StretchNormal
}

// InheritFields from parent
func (fs *Font) InheritFields(parent *Font) {
        if parent.Size.Value != 0 {
                fs.Size = parent.Size
        }
        fs.Family = parent.Family
        fs.CustomFont = parent.CustomFont
        fs.Slant = parent.Slant
        fs.Weight = parent.Weight
        fs.Stretch = parent.Stretch
        fs.Decoration = parent.Decoration
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (fs *Font) ToDots(uc *units.Context) {
        if fs.Size.Unit == units.UnitEm || fs.Size.Unit == units.UnitEx || fs.Size.Unit == units.UnitCh {
                slog.Error("girl/styles.Font.Size was set to Em, Ex, or Ch; that is recursive and unstable!", "unit", fs.Size.Unit)
                fs.Size.Dp(16)
        }
        fs.Size.ToDots(uc)
}

// SetUnitContext sets the font-specific information in the given
// units.Context, based on the given styles. Just uses standardized
// fractions of the font size for the other less common units such as ex, ch.
func (fs *Font) SetUnitContext(uc *units.Context) {
        fsz := math32.Round(fs.Size.Dots)
        if fsz == 0 {
                fsz = 16
        }
        uc.SetFont(fsz)
}

// SetDecoration sets text decoration (underline, etc),
// which uses bitflags to allow multiple combinations.
func (fs *Font) SetDecoration(deco ...rich.Decorations) *Font {
        for _, d := range deco {
                fs.Decoration.SetFlag(true, d)
        }
        return fs
}

// FontHeight returns the font height in dots (actual pixels).
// Only valid after ToDots has been called, as final step of styling.
func (fs *Font) FontHeight() float32 {
        return math32.Round(fs.Size.Dots)
}

// SetRich sets the rich.Style from font style.
func (fs *Font) SetRich(sty *rich.Style) {
        sty.Family = fs.Family
        sty.Slant = fs.Slant
        sty.Weight = fs.Weight
        sty.Stretch = fs.Stretch
        sty.Decoration = fs.Decoration
}

// SetRichText sets the rich.Style and text.Style properties from the style props.
func (s *Style) SetRichText(sty *rich.Style, tsty *text.Style) {
        s.Font.SetRich(sty)
        s.Text.SetText(tsty)
        tsty.FontSize = s.Font.Size
        tsty.CustomFont = s.Font.CustomFont
        if s.Color != nil {
                clr := colors.ApplyOpacity(colors.ToUniform(s.Color), s.Opacity)
                tsty.Color = clr
        }
        // note: no default background color here
}

// NewRichText sets the rich.Style and text.Style properties from the style props.
func (s *Style) NewRichText() (sty *rich.Style, tsty *text.Style) {
        sty = rich.NewStyle()
        tsty = text.NewStyle()
        s.SetRichText(sty, tsty)
        return
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/units"
)

// todo: for style
// Resize: user-resizability
// z-index

// CSS vs. Layout alignment
//
// CSS has align-self, align-items (for a container, provides a default for
// items) and align-content which only applies to lines in a flex layout (akin
// to a flow layout) -- there is a presumed horizontal aspect to these, except
// align-content, so they are subsumed in the AlignH parameter in this style.
// Vertical-align works as expected, and Text.Align uses left/center/right

// IMPORTANT: any changes here must be updated in style_properties.go StyleLayoutFuncs

// DefaultScrollbarWidth is the default [Style.ScrollbarWidth].
var DefaultScrollbarWidth = units.Dp(10)

func (s *Style) LayoutDefaults() {
        s.Justify.Defaults()
        s.Align.Defaults()
        s.Gap.Set(units.Em(0.5))
        s.ScrollbarWidth = DefaultScrollbarWidth
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (s *Style) LayoutToDots(uc *units.Context) {
        s.Pos.ToDots(uc)
        s.Min.ToDots(uc)
        s.Max.ToDots(uc)
        s.Padding.ToDots(uc)
        s.Margin.ToDots(uc)
        s.Gap.ToDots(uc)
        s.ScrollbarWidth.ToDots(uc)

        // max must be at least as much as min
        if s.Max.X.Dots > 0 {
                s.Max.X.Dots = max(s.Max.X.Dots, s.Min.X.Dots)
        }
        if s.Max.Y.Dots > 0 {
                s.Max.Y.Dots = max(s.Max.Y.Dots, s.Min.Y.Dots)
        }
}

// AlignPos returns the position offset based on Align.X,Y settings
// for given inner-sized box within given outer-sized container box.
func AlignPos(align Aligns, inner, outer float32) float32 {
        extra := outer - inner
        var pos float32
        if extra > 0 {
                pos += AlignFactor(align) * extra
        }
        return math32.Floor(pos)
}

/////////////////////////////////////////////////////////////////

// Direction specifies the way in which elements are laid out, or
// the dimension on which an element is longer / travels in.
type Directions int32 //enums:enum -transform kebab

const (
        // Row indicates that elements are laid out in a row
        // or that an element is longer / travels in the x dimension.
        Row Directions = iota

        // Column indicates that elements are laid out in a column
        // or that an element is longer / travels in the y dimension.
        Column
)

// Dim returns the corresponding dimension for the direction.
func (d Directions) Dim() math32.Dims {
        return math32.Dims(d)
}

// Other returns the opposite (other) direction.
func (d Directions) Other() Directions {
        if d == Row {
                return Column
        }
        return Row
}

// Displays determines how items are displayed.
type Displays int32 //enums:enum -trim-prefix Display -transform kebab

const (
        // Flex is the default layout model, based on a simplified version of the
        // CSS flex layout: uses MainAxis to specify the direction, Wrap for
        // wrapping of elements, and Min, Max, and Grow values on elements to
        // determine sizing.
        Flex Displays = iota

        // Stacked is a stack of elements, with one on top that is visible
        Stacked

        // Grid is the X, Y grid layout, with Columns specifying the number
        // of elements in the X axis.
        Grid

        // Custom means that no automatic layout will be applied to elements,
        // which can then be managed via custom code by setting the [Style.Pos] position.
        Custom

        // None means the item is not displayed: sets the Invisible state
        DisplayNone
)

// Aligns has all different types of alignment and justification.
type Aligns int32 //enums:enum -transform kebab

const (
        // Auto means the item uses the container's AlignItems value
        Auto Aligns = iota

        // Align items to the start (top, left) of layout
        Start

        // Align items to the end (bottom, right) of layout
        End

        // Align items centered
        Center

        // Align to text baselines
        Baseline

        // First and last are flush, equal space between remaining items
        SpaceBetween

        // First and last have 1/2 space at edges, full space between remaining items
        SpaceAround

        // Equal space at start, end, and between all items
        SpaceEvenly
)

func AlignFactor(al Aligns) float32 {
        switch al {
        case Start:
                return 0
        case End:
                return 1
        case Center:
                return 0.5
        }
        return 0
}

// AlignSet specifies the 3 levels of Justify or Align: Content, Items, and Self
type AlignSet struct { //types:add
        // Content specifies the distribution of the entire collection of items within
        // any larger amount of space allocated to the container.  By contrast, Items
        // and Self specify distribution within the individual element's allocated space.
        Content Aligns

        // Items specifies the distribution within the individual element's allocated space,
        // as a default for all items within a collection.
        Items Aligns

        // Self specifies the distribution within the individual element's allocated space,
        // for this specific item.  Auto defaults to containers Items setting.
        Self Aligns
}

func (as *AlignSet) Defaults() {
        as.Content = Start
        as.Items = Start
        as.Self = Auto
}

// ItemAlign returns the effective Aligns value between parent Items and Self
func ItemAlign(parItems, self Aligns) Aligns {
        if self == Auto {
                return parItems
        }
        return self
}

// overflow type -- determines what happens when there is too much stuff in a layout
type Overflows int32 //enums:enum -trim-prefix Overflow -transform kebab

const (
        // OverflowVisible makes the overflow visible, meaning that the size
        // of the container is always at least the Min size of its contents.
        // No scrollbars are shown.
        OverflowVisible Overflows = iota

        // OverflowHidden hides the overflow and doesn't present scrollbars.
        OverflowHidden

        // OverflowAuto automatically determines if scrollbars should be added to show
        // the overflow.  Scrollbars are added only if the actual content size is greater
        // than the currently available size.
        OverflowAuto

        // OverflowScroll means that scrollbars are always visible,
        // and is otherwise identical to Auto.  However, only during Viewport PrefSize call,
        // the actual content size is used -- otherwise it behaves just like Auto.
        OverflowScroll
)

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "image"
        "image/draw"

        "cogentcore.org/core/math32"
        "github.com/anthonynsimon/bild/transform"
)

// ObjectFits are the different ways in which a replaced element
// (image, video, etc) can be fit into its containing box.
type ObjectFits int32 //enums:enum -trim-prefix Fit -transform kebab

const (
        // FitFill indicates that the replaced object will fill
        // the element's entire content box, stretching if necessary.
        FitFill ObjectFits = iota

        // FitContain indicates that the replaced object will resize
        // as large as possible while fully fitting within the element's
        // content box and maintaining its aspect ratio. Therefore,
        // it may not fill the entire element.
        FitContain

        // FitCover indicates that the replaced object will fill
        // the element's entire content box, clipping if necessary.
        FitCover

        // FitNone indicates that the replaced object will not resize.
        FitNone

        // FitScaleDown indicates that the replaced object will size
        // as if [FitNone] or [FitContain] was specified, using
        // whichever will result in a smaller final size.
        FitScaleDown
)

// ObjectSizeFromFit returns the target object size based on the given
// ObjectFits setting, original object size, and target box size
// for the object to fit into.
func ObjectSizeFromFit(fit ObjectFits, obj, box math32.Vector2) math32.Vector2 {
        oar := obj.X / obj.Y
        bar := box.X / box.Y
        var sz math32.Vector2
        switch fit {
        case FitFill:
                return box
        case FitContain, FitScaleDown:
                if oar >= bar {
                        // if we have a higher x:y than them, x is our limiting size
                        sz.X = box.X
                        // and we make our y in proportion to that
                        sz.Y = obj.Y * (box.X / obj.X)
                } else {
                        // if we have a lower x:y than them, y is our limiting size
                        sz.Y = box.Y
                        // and we make our x in proportion to that
                        sz.X = obj.X * (box.Y / obj.Y)
                }
        case FitCover:
                if oar < bar {
                        // if we have a lower x:y than them, x is our limiting size
                        sz.X = box.X
                        // and we make our y in proportion to that
                        sz.Y = obj.Y * (box.X / obj.X)
                } else {
                        // if we have a lower x:y than them, y is our limiting size
                        sz.Y = box.Y
                        // and we make our x in proportion to that
                        sz.X = obj.X * (box.Y / obj.Y)
                }
        }
        return sz
}

// ResizeImage resizes the given image according to [Style.ObjectFit]
// in an object of the given box size.
func (s *Style) ResizeImage(img image.Image, box math32.Vector2) image.Image {
        obj := math32.FromPoint(img.Bounds().Size())
        sz := ObjectSizeFromFit(s.ObjectFit, obj, box)

        if s.ObjectFit == FitScaleDown && sz.X >= obj.X {
                return img
        }
        rimg := transform.Resize(img, int(sz.X), int(sz.Y), transform.Linear)
        if s.ObjectFit != FitCover {
                return rimg
        }
        // but we cap the destination size to the size of the containing object
        drect := image.Rect(0, 0, int(min(sz.X, box.X)), int(min(sz.Y, box.Y)))
        dst := image.NewRGBA(drect)
        draw.Draw(dst, drect, rimg, image.Point{}, draw.Src)
        return dst
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "image"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
)

// Paint provides the styling parameters for SVG-style rendering,
// including the Path stroke and fill properties, and font and text
// properties.
type Paint struct { //types:add
        Path

        // Font selects font properties.
        Font rich.Style

        // Text has the text styling settings.
        Text text.Style

        // ClipPath is a clipping path for this item.
        ClipPath ppath.Path

        // Mask is a rendered image of the mask for this item.
        Mask image.Image
}

func NewPaint() *Paint {
        pc := &Paint{}
        pc.Defaults()
        return pc
}

// NewPaintWithContext returns a new Paint style with [units.Context]
// initialized from given. Pass the Styles context for example.
func NewPaintWithContext(uc *units.Context) *Paint {
        pc := NewPaint()
        pc.UnitContext = *uc
        return pc
}

func (pc *Paint) Defaults() {
        pc.Path.Defaults()
        pc.Font.Defaults()
        pc.Text.Defaults()
}

// CopyStyleFrom copies styles from another paint
func (pc *Paint) CopyStyleFrom(cp *Paint) {
        pc.Path.CopyStyleFrom(&cp.Path)
        pc.Font = cp.Font
        pc.Text = cp.Text
}

// InheritFields from parent
func (pc *Paint) InheritFields(parent *Paint) {
        pc.Font.InheritFields(&parent.Font)
        pc.Text.InheritFields(&parent.Text)
}

// SetProperties sets paint values based on given property map (name: value
// pairs), inheriting elements as appropriate from parent, and also having a
// default style for the "initial" setting
func (pc *Paint) SetProperties(parent *Paint, properties map[string]any, ctxt colors.Context) {
        if !pc.StyleSet && parent != nil { // first time
                pc.InheritFields(parent)
        }
        pc.fromProperties(parent, properties, ctxt)

        pc.PropertiesNil = (len(properties) == 0)
        pc.StyleSet = true
}

// GetProperties gets properties values from current style settings,
// for any non-default settings, setting name-value pairs in given map,
// which must be non-nil.
func (pc *Paint) GetProperties(properties map[string]any) {
        pc.toProperties(properties)
}

func (pc *Paint) FromStyle(st *Style) {
        pc.UnitContext = st.UnitContext
        st.SetRichText(&pc.Font, &pc.Text)
}

// ToDotsImpl runs ToDots on unit values, to compile down to raw pixels
func (pc *Paint) ToDotsImpl(uc *units.Context) {
        pc.Path.ToDotsImpl(uc)
        // pc.Font.ToDots(uc)
        pc.Text.ToDots(uc)
}

// SetUnitContextExt sets the unit context for external usage of paint
// outside of Core Scene context, based on overall size of painting canvas.
// caches everything out in terms of raw pixel dots for rendering
// call at start of render.
func (pc *Paint) SetUnitContextExt(size image.Point) {
        if pc.UnitContext.DPI == 0 {
                pc.UnitContext.Defaults()
        }
        // TODO: maybe should have different values for these sizes?
        pc.UnitContext.SetSizes(float32(size.X), float32(size.Y), float32(size.X), float32(size.Y), float32(size.X), float32(size.Y))
        // todo: need a shaper here to get SetUnitContext call
        // pc.Font.SetUnitContext(&pc.UnitContext)
        pc.ToDotsImpl(&pc.UnitContext)
        pc.dotsSet = true
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (pc *Paint) ToDots() {
        if !(pc.dotsSet && pc.UnitContext == pc.lastUnCtxt && pc.PropertiesNil) {
                pc.ToDotsImpl(&pc.UnitContext)
                pc.dotsSet = true
                pc.lastUnCtxt = pc.UnitContext
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "log"
        "strconv"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/styles/styleprops"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
)

/////// see style_props.go for master version

// fromProperties sets style field values based on map[string]any properties
func (pc *Path) fromProperties(parent *Path, properties map[string]any, cc colors.Context) {
        for key, val := range properties {
                if len(key) == 0 {
                        continue
                }
                if key[0] == '#' || key[0] == '.' || key[0] == ':' || key[0] == '_' {
                        continue
                }
                if key == "display" {
                        if inh, init := styleprops.InhInit(val, parent); inh || init {
                                if inh {
                                        pc.Display = parent.Display
                                } else if init {
                                        pc.Display = true
                                }
                                return
                        }
                        sval := reflectx.ToString(val)
                        switch sval {
                        case "none":
                                pc.Display = false
                        case "inline":
                                pc.Display = true
                        default:
                                pc.Display = true
                        }
                        continue
                }
                if sfunc, ok := styleStrokeFuncs[key]; ok {
                        if parent != nil {
                                sfunc(&pc.Stroke, key, val, &parent.Stroke, cc)
                        } else {
                                sfunc(&pc.Stroke, key, val, nil, cc)
                        }
                        continue
                }
                if sfunc, ok := styleFillFuncs[key]; ok {
                        if parent != nil {
                                sfunc(&pc.Fill, key, val, &parent.Fill, cc)
                        } else {
                                sfunc(&pc.Fill, key, val, nil, cc)
                        }
                        continue
                }
                if sfunc, ok := stylePathFuncs[key]; ok {
                        sfunc(pc, key, val, parent, cc)
                        continue
                }
        }
}

// fromProperties sets style field values based on map[string]any properties
func (pc *Paint) fromProperties(parent *Paint, properties map[string]any, cc colors.Context) {
        var ppath *Path
        var pfont *rich.Style
        var ptext *text.Style
        if parent != nil {
                ppath = &parent.Path
                pfont = &parent.Font
                ptext = &parent.Text
        }
        pc.Path.fromProperties(ppath, properties, cc)
        pc.Font.FromProperties(pfont, properties, cc)
        pc.Text.FromProperties(ptext, properties, cc)
        for key, val := range properties {
                _ = val
                if len(key) == 0 {
                        continue
                }
                if key[0] == '#' || key[0] == '.' || key[0] == ':' || key[0] == '_' {
                        continue
                }
                // todo: add others here
        }
}

////////  Stroke

// styleStrokeFuncs are functions for styling the Stroke object
var styleStrokeFuncs = map[string]styleprops.Func{
        "stroke": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Stroke)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Color = parent.(*Stroke).Color
                        } else if init {
                                fs.Color = colors.Uniform(colors.Black)
                        }
                        return
                }
                fs.Color = errors.Log1(gradient.FromAny(val, cc))
        },
        "stroke-opacity": styleprops.Float(float32(1),
                func(obj *Stroke) *float32 { return &(obj.Opacity) }),
        "stroke-width": styleprops.Units(units.Dp(1),
                func(obj *Stroke) *units.Value { return &(obj.Width) }),
        "stroke-min-width": styleprops.Units(units.Dp(1),
                func(obj *Stroke) *units.Value { return &(obj.MinWidth) }),
        "stroke-dasharray": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Stroke)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Dashes = parent.(*Stroke).Dashes
                        } else if init {
                                fs.Dashes = nil
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        fs.Dashes = parseDashesString(vt)
                case []float32:
                        math32.CopyFloat32s(&fs.Dashes, vt)
                case *[]float32:
                        math32.CopyFloat32s(&fs.Dashes, *vt)
                }
        },
        "stroke-linecap": styleprops.Enum(ppath.CapButt,
                func(obj *Stroke) enums.EnumSetter { return &(obj.Cap) }),
        "stroke-linejoin": styleprops.Enum(ppath.JoinMiter,
                func(obj *Stroke) enums.EnumSetter { return &(obj.Join) }),
        "stroke-miterlimit": styleprops.Float(float32(1),
                func(obj *Stroke) *float32 { return &(obj.MiterLimit) }),
}

////////  Fill

// styleFillFuncs are functions for styling the Fill object
var styleFillFuncs = map[string]styleprops.Func{
        "fill": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Fill)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Color = parent.(*Fill).Color
                        } else if init {
                                fs.Color = colors.Uniform(colors.Black)
                        }
                        return
                }
                fs.Color = errors.Log1(gradient.FromAny(val, cc))
        },
        "fill-opacity": styleprops.Float(float32(1),
                func(obj *Fill) *float32 { return &(obj.Opacity) }),
        "fill-rule": styleprops.Enum(ppath.NonZero,
                func(obj *Fill) enums.EnumSetter { return &(obj.Rule) }),
}

////////  Paint

// stylePathFuncs are functions for styling the Stroke object
var stylePathFuncs = map[string]styleprops.Func{
        "vector-effect": styleprops.Enum(ppath.VectorEffectNone,
                func(obj *Path) enums.EnumSetter { return &(obj.VectorEffect) }),
        "opacity": styleprops.Float(float32(1),
                func(obj *Path) *float32 { return &(obj.Opacity) }),
        "transform": func(obj any, key string, val any, parent any, cc colors.Context) {
                pc := obj.(*Path)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                pc.Transform = parent.(*Path).Transform
                        } else if init {
                                pc.Transform = math32.Identity2()
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        pc.Transform.SetString(vt)
                case *math32.Matrix2:
                        pc.Transform = *vt
                case math32.Matrix2:
                        pc.Transform = vt
                }
        },
}

// parseDashesString gets a dash slice from given string
func parseDashesString(str string) []float32 {
        if len(str) == 0 || str == "none" {
                return nil
        }
        ds := strings.Split(str, ",")
        dl := make([]float32, len(ds))
        for i, dstr := range ds {
                d, err := strconv.ParseFloat(strings.TrimSpace(dstr), 32)
                if err != nil {
                        log.Printf("core.ParseDashesString parsing error: %v\n", err)
                        return nil
                }
                dl[i] = float32(d)
        }
        return dl
}

////////  ToProperties

// toProperties sets map[string]any properties based on non-default style values.
// properties map must be non-nil.
func (pc *Path) toProperties(p map[string]any) {
        if !pc.Display {
                p["display"] = "none"
                return
        }
        pc.Stroke.toProperties(p)
        pc.Fill.toProperties(p)
}

// toProperties sets map[string]any properties based on non-default style values.
// properties map must be non-nil.
func (pc *Paint) toProperties(p map[string]any) {
        pc.Path.toProperties(p)
        if !pc.Display {
                return
        }
}

// toProperties sets map[string]any properties based on non-default style values.
// properties map must be non-nil.
func (pc *Stroke) toProperties(p map[string]any) {
        if pc.Color == nil {
                p["stroke"] = "none"
                return
        }
        // todo: gradients!
        p["stroke"] = colors.AsHex(colors.ToUniform(pc.Color))
        if pc.Opacity != 1 {
                p["stroke-opacity"] = reflectx.ToString(pc.Opacity)
        }
        if pc.Width.Unit != units.UnitDp || pc.Width.Value != 1 {
                p["stroke-width"] = pc.Width.StringCSS()
        }
        if pc.MinWidth.Unit != units.UnitDp || pc.MinWidth.Value != 1 {
                p["stroke-min-width"] = pc.MinWidth.StringCSS()
        }
        // todo: dashes
        if pc.Cap != ppath.CapButt {
                p["stroke-linecap"] = pc.Cap.String()
        }
        if pc.Join != ppath.JoinMiter {
                p["stroke-linecap"] = pc.Cap.String()
        }
}

// toProperties sets map[string]any properties based on non-default style values.
// properties map must be non-nil.
func (pc *Fill) toProperties(p map[string]any) {
        if pc.Color == nil {
                p["fill"] = "none"
                return
        }
        p["fill"] = colors.AsHex(colors.ToUniform(pc.Color))
        if pc.Opacity != 1 {
                p["fill-opacity"] = reflectx.ToString(pc.Opacity)
        }
        if pc.Rule != ppath.NonZero {
                p["fill-rule"] = pc.Rule.String()
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "image"
        "image/color"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/styles/units"
)

// Path provides the styling parameters for path-level rendering:
// Stroke and Fill.
type Path struct { //types:add
        // Off indicates that node and everything below it are off, non-rendering.
        // This is auto-updated based on other settings.
        Off bool

        // Display is the user-settable flag that determines if this item
        // should be displayed.
        Display bool

        // Stroke (line drawing) parameters.
        Stroke Stroke

        // Fill (region filling) parameters.
        Fill Fill

        // Opacity is a global transparency alpha factor that applies to stroke and fill.
        Opacity float32

        // Transform has our additions to the transform stack.
        Transform math32.Matrix2

        // VectorEffect has various rendering special effects settings.
        VectorEffect ppath.VectorEffects

        // UnitContext has parameters necessary for determining unit sizes.
        UnitContext units.Context `display:"-"`

        // StyleSet indicates if the styles already been set.
        StyleSet bool `display:"-"`

        PropertiesNil bool `display:"-"`
        dotsSet       bool
        lastUnCtxt    units.Context
}

func (pc *Path) Defaults() {
        pc.Off = false
        pc.Display = true
        pc.Stroke.Defaults()
        pc.Fill.Defaults()
        pc.Opacity = 1
        pc.Transform = math32.Identity2()
        pc.StyleSet = false
}

// CopyStyleFrom copies styles from another paint
func (pc *Path) CopyStyleFrom(cp *Path) {
        pc.Off = cp.Off
        pc.UnitContext = cp.UnitContext
        pc.Stroke = cp.Stroke
        pc.Fill = cp.Fill
        pc.VectorEffect = cp.VectorEffect
}

// SetProperties sets path values based on given property map (name: value
// pairs), inheriting elements as appropriate from parent, and also having a
// default style for the "initial" setting
func (pc *Path) SetProperties(parent *Path, properties map[string]any, ctxt colors.Context) {
        pc.fromProperties(parent, properties, ctxt)
        pc.PropertiesNil = (len(properties) == 0)
        pc.StyleSet = true
}

// GetProperties gets properties values from current style settings,
// for any non-default settings, setting name-value pairs in given map,
// which must be non-nil.
func (pc *Path) GetProperties(properties map[string]any) {
        pc.toProperties(properties)
}

func (pc *Path) FromStyle(st *Style) {
        pc.UnitContext = st.UnitContext
}

// ToDotsImpl runs ToDots on unit values, to compile down to raw pixels
func (pc *Path) ToDotsImpl(uc *units.Context) {
        pc.Stroke.ToDots(uc)
        pc.Fill.ToDots(uc)
}

func (pc *Path) HasFill() bool {
        return !pc.Off && pc.Fill.Color != nil && pc.Fill.Opacity > 0
}

func (pc *Path) HasStroke() bool {
        return !pc.Off && pc.Stroke.Color != nil && pc.Stroke.Width.Dots > 0 && pc.Stroke.Opacity > 0
}

//////// Stroke and Fill Styles

// IMPORTANT: any changes here must be updated in StyleFillFuncs

// Fill contains all the properties for filling a region.
type Fill struct {

        // Color to use in filling; filling is off if nil.
        Color image.Image

        // Fill alpha opacity / transparency factor between 0 and 1.
        // This applies in addition to any alpha specified in the Color.
        Opacity float32

        // Rule for how to fill more complex shapes with crossing lines.
        Rule ppath.FillRules
}

// Defaults initializes default values for paint fill
func (pf *Fill) Defaults() {
        pf.Color = colors.Uniform(color.Black)
        pf.Rule = ppath.NonZero
        pf.Opacity = 1.0
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (fs *Fill) ToDots(uc *units.Context) {
}

//////// Stroke

// IMPORTANT: any changes here must be updated below in StyleStrokeFuncs

// Stroke contains all the properties for painting a line.
type Stroke struct {

        // stroke color image specification; stroking is off if nil
        Color image.Image

        // global alpha opacity / transparency factor between 0 and 1
        Opacity float32

        // line width
        Width units.Value

        // MinWidth is the minimum line width used for rendering.
        // If width is > 0, then this is the smallest line width.
        // This value is NOT subject to transforms so is in absolute
        // dot values, and is ignored if vector-effects, non-scaling-stroke
        // is used. This is an extension of the SVG / CSS standard
        MinWidth units.Value

        // Dashes are the dashes of the stroke. Each pair of values specifies
        // the amount to paint and then the amount to skip.
        Dashes []float32

        // DashOffset is the starting offset for the dashes.
        DashOffset float32

        // Cap specifies how to draw the end cap of stroked lines.
        Cap ppath.Caps

        // Join specifies how to join line segments.
        Join ppath.Joins

        // MiterLimit is the limit of how far to miter: must be 1 or larger.
        MiterLimit float32 `min:"1"`
}

// Defaults initializes default values for paint stroke
func (ss *Stroke) Defaults() {
        // stroking is off by default in svg
        ss.Color = nil
        ss.Width.Dp(1)
        ss.MinWidth.Dot(.5)
        ss.Cap = ppath.CapButt
        ss.Join = ppath.JoinMiter
        ss.MiterLimit = 10.0
        ss.Opacity = 1.0
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (ss *Stroke) ToDots(uc *units.Context) {
        ss.Width.ToDots(uc)
        ss.MinWidth.ToDots(uc)
}

// ApplyBorderStyle applies the given border style to the stroke style.
func (ss *Stroke) ApplyBorderStyle(bs BorderStyles) {
        switch bs {
        case BorderNone:
                ss.Color = nil
        case BorderDotted:
                ss.Dashes = []float32{0, 12}
                ss.Cap = ppath.CapRound
        case BorderDashed:
                ss.Dashes = []float32{8, 6}
        }
}

// Code generated by "core generate"; DO NOT EDIT.

package sides

import (
        "cogentcore.org/core/enums"
)

var _IndexesValues = []Indexes{0, 1, 2, 3}

// IndexesN is the highest valid value for type Indexes, plus one.
const IndexesN Indexes = 4

var _IndexesValueMap = map[string]Indexes{`Top`: 0, `Right`: 1, `Bottom`: 2, `Left`: 3}

var _IndexesDescMap = map[Indexes]string{0: ``, 1: ``, 2: ``, 3: ``}

var _IndexesMap = map[Indexes]string{0: `Top`, 1: `Right`, 2: `Bottom`, 3: `Left`}

// String returns the string representation of this Indexes value.
func (i Indexes) String() string { return enums.String(i, _IndexesMap) }

// SetString sets the Indexes value from its string representation,
// and returns an error if the string is invalid.
func (i *Indexes) SetString(s string) error {
        return enums.SetString(i, s, _IndexesValueMap, "Indexes")
}

// Int64 returns the Indexes value as an int64.
func (i Indexes) Int64() int64 { return int64(i) }

// SetInt64 sets the Indexes value from an int64.
func (i *Indexes) SetInt64(in int64) { *i = Indexes(in) }

// Desc returns the description of the Indexes value.
func (i Indexes) Desc() string { return enums.Desc(i, _IndexesDescMap) }

// IndexesValues returns all possible values for the type Indexes.
func IndexesValues() []Indexes { return _IndexesValues }

// Values returns all possible values for the type Indexes.
func (i Indexes) Values() []enums.Enum { return enums.Values(_IndexesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Indexes) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Indexes) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Indexes") }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package sides provides flexible representation of box sides
// or corners, with either a single value for all, or different values
// for subsets.
package sides

//go:generate core generate

import (
        "fmt"
        "image/color"
        "strings"

        "log/slog"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/units"
)

// Indexes provides names for the Sides in order defined
type Indexes int32 //enums:enum

const (
        Top Indexes = iota
        Right
        Bottom
        Left
)

// Sides contains values for each side or corner of a box.
// If Sides contains sides, the struct field names correspond
// directly to the side values (ie: Top = top side value).
// If Sides contains corners, the struct field names correspond
// to the corners as follows: Top = top left, Right = top right,
// Bottom = bottom right, Left = bottom left.
type Sides[T any] struct { //types:add

        // top/top-left value
        Top T

        // right/top-right value
        Right T

        // bottom/bottom-right value
        Bottom T

        // left/bottom-left value
        Left T
}

// NewSides is a helper that creates new sides/corners of the given type
// and calls Set on them with the given values.
func NewSides[T any](vals ...T) *Sides[T] {
        return (&Sides[T]{}).Set(vals...)
}

// Set sets the values of the sides/corners from the given list of 0 to 4 values.
// If 0 values are provided, all sides/corners are set to the zero value of the type.
// If 1 value is provided, all sides/corners are set to that value.
// If 2 values are provided, the top/top-left and bottom/bottom-right are set to the first value
// and the right/top-right and left/bottom-left are set to the second value.
// If 3 values are provided, the top/top-left is set to the first value,
// the right/top-right and left/bottom-left are set to the second value,
// and the bottom/bottom-right is set to the third value.
// If 4 values are provided, the top/top-left is set to the first value,
// the right/top-right is set to the second value, the bottom/bottom-right is set
// to the third value, and the left/bottom-left is set to the fourth value.
// If more than 4 values are provided, the behavior is the same
// as with 4 values, but Set also logs a programmer error.
// This behavior is based on the CSS multi-side/corner setting syntax,
// like that with padding and border-radius (see https://www.w3schools.com/css/css_padding.asp
// and https://www.w3schools.com/cssref/css3_pr_border-radius.php)
func (s *Sides[T]) Set(vals ...T) *Sides[T] {
        switch len(vals) {
        case 0:
                var zval T
                s.SetAll(zval)
        case 1:
                s.SetAll(vals[0])
        case 2:
                s.SetVertical(vals[0])
                s.SetHorizontal(vals[1])
        case 3:
                s.Top = vals[0]
                s.SetHorizontal(vals[1])
                s.Bottom = vals[2]
        case 4:
                s.Top = vals[0]
                s.Right = vals[1]
                s.Bottom = vals[2]
                s.Left = vals[3]
        default:
                s.Top = vals[0]
                s.Right = vals[1]
                s.Bottom = vals[2]
                s.Left = vals[3]
                slog.Error("programmer error: sides.Set: expected 0 to 4 values, but got", "numValues", len(vals))
        }
        return s
}

// Zero sets the values of all of the sides to zero.
func (s *Sides[T]) Zero() *Sides[T] {
        s.Set()
        return s
}

// SetVertical sets the values for the sides/corners in the
// vertical/diagonally descending direction
// (top/top-left and bottom/bottom-right) to the given value
func (s *Sides[T]) SetVertical(val T) *Sides[T] {
        s.Top = val
        s.Bottom = val
        return s
}

// SetHorizontal sets the values for the sides/corners in the
// horizontal/diagonally ascending direction
// (right/top-right and left/bottom-left) to the given value
func (s *Sides[T]) SetHorizontal(val T) *Sides[T] {
        s.Right = val
        s.Left = val
        return s
}

// SetAll sets the values for all of the sides/corners
// to the given value
func (s *Sides[T]) SetAll(val T) *Sides[T] {
        s.Top = val
        s.Right = val
        s.Bottom = val
        s.Left = val
        return s
}

// SetTop sets the top side to the given value
func (s *Sides[T]) SetTop(top T) *Sides[T] {
        s.Top = top
        return s
}

// SetRight sets the right side to the given value
func (s *Sides[T]) SetRight(right T) *Sides[T] {
        s.Right = right
        return s
}

// SetBottom sets the bottom side to the given value
func (s *Sides[T]) SetBottom(bottom T) *Sides[T] {
        s.Bottom = bottom
        return s
}

// SetLeft sets the left side to the given value
func (s *Sides[T]) SetLeft(left T) *Sides[T] {
        s.Left = left
        return s
}

// SetAny sets the sides/corners from the given value of any type
func (s *Sides[T]) SetAny(a any) error {
        switch val := a.(type) {
        case Sides[T]:
                *s = val
        case *Sides[T]:
                *s = *val
        case T:
                s.SetAll(val)
        case *T:
                s.SetAll(*val)
        case []T:
                s.Set(val...)
        case *[]T:
                s.Set(*val...)
        case string:
                return s.SetString(val)
        default:
                return s.SetString(fmt.Sprint(val))
        }
        return nil
}

// SetString sets the sides/corners from the given string value
func (s *Sides[T]) SetString(str string) error {
        fields := strings.Fields(str)
        vals := make([]T, len(fields))
        for i, field := range fields {
                ss, ok := any(&vals[i]).(reflectx.SetStringer)
                if !ok {
                        err := fmt.Errorf("(Sides).SetString('%s'): to set from a string, the sides type (%T) must implement reflectx.SetStringer (needs SetString(str string) error function)", str, s)
                        slog.Error(err.Error())
                        return err
                }
                err := ss.SetString(field)
                if err != nil {
                        nerr := fmt.Errorf("(Sides).SetString('%s'): error setting sides of type %T from string: %w", str, s, err)
                        slog.Error(nerr.Error())
                        return nerr
                }
        }
        s.Set(vals...)
        return nil
}

// AreSame returns whether all of the sides/corners are the same
func AreSame[T comparable](s Sides[T]) bool {
        return s.Right == s.Top && s.Bottom == s.Top && s.Left == s.Top
}

// AreZero returns whether all of the sides/corners are equal to zero
func AreZero[T comparable](s Sides[T]) bool {
        var zv T
        return s.Top == zv && s.Right == zv && s.Bottom == zv && s.Left == zv
}

// Values contains units.Value values for each side/corner of a box
type Values struct { //types:add
        Sides[units.Value]
}

// NewValues is a helper that creates new side/corner values
// and calls Set on them with the given values.
func NewValues(vals ...units.Value) Values {
        sides := Sides[units.Value]{}
        sides.Set(vals...)
        return Values{sides}
}

// ToDots converts the values for each of the sides/corners
// to raw display pixels (dots) and sets the Dots field for each
// of the values. It returns the dot values as a Floats.
func (sv *Values) ToDots(uc *units.Context) Floats {
        return NewFloats(
                sv.Top.ToDots(uc),
                sv.Right.ToDots(uc),
                sv.Bottom.ToDots(uc),
                sv.Left.ToDots(uc),
        )
}

// Dots returns the dot values of the sides/corners as a Floats.
// It does not compute them; see ToDots for that.
func (sv Values) Dots() Floats {
        return NewFloats(
                sv.Top.Dots,
                sv.Right.Dots,
                sv.Bottom.Dots,
                sv.Left.Dots,
        )
}

// Floats contains float32 values for each side/corner of a box
type Floats struct { //types:add
        Sides[float32]
}

// NewFloats is a helper that creates new side/corner floats
// and calls Set on them with the given values.
func NewFloats(vals ...float32) Floats {
        sides := Sides[float32]{}
        sides.Set(vals...)
        return Floats{sides}
}

// Add adds the side floats to the
// other side floats and returns the result
func (sf Floats) Add(other Floats) Floats {
        return NewFloats(
                sf.Top+other.Top,
                sf.Right+other.Right,
                sf.Bottom+other.Bottom,
                sf.Left+other.Left,
        )
}

// Sub subtracts the other side floats from
// the side floats and returns the result
func (sf Floats) Sub(other Floats) Floats {
        return NewFloats(
                sf.Top-other.Top,
                sf.Right-other.Right,
                sf.Bottom-other.Bottom,
                sf.Left-other.Left,
        )
}

// MulScalar multiplies each side by the given scalar value
// and returns the result.
func (sf Floats) MulScalar(s float32) Floats {
        return NewFloats(
                sf.Top*s,
                sf.Right*s,
                sf.Bottom*s,
                sf.Left*s,
        )
}

// Min returns a new side floats containing the
// minimum values of the two side floats
func (sf Floats) Min(other Floats) Floats {
        return NewFloats(
                math32.Min(sf.Top, other.Top),
                math32.Min(sf.Right, other.Right),
                math32.Min(sf.Bottom, other.Bottom),
                math32.Min(sf.Left, other.Left),
        )
}

// Max returns a new side floats containing the
// maximum values of the two side floats
func (sf Floats) Max(other Floats) Floats {
        return NewFloats(
                math32.Max(sf.Top, other.Top),
                math32.Max(sf.Right, other.Right),
                math32.Max(sf.Bottom, other.Bottom),
                math32.Max(sf.Left, other.Left),
        )
}

// Round returns a new side floats with each side value
// rounded to the nearest whole number.
func (sf Floats) Round() Floats {
        return NewFloats(
                math32.Round(sf.Top),
                math32.Round(sf.Right),
                math32.Round(sf.Bottom),
                math32.Round(sf.Left),
        )
}

// Pos returns the position offset casued by the side/corner values (Left, Top)
func (sf Floats) Pos() math32.Vector2 {
        return math32.Vec2(sf.Left, sf.Top)
}

// Size returns the toal size the side/corner values take up (Left + Right, Top + Bottom)
func (sf Floats) Size() math32.Vector2 {
        return math32.Vec2(sf.Left+sf.Right, sf.Top+sf.Bottom)
}

// ToValues returns the side floats a
// Values composed of [units.UnitDot] values
func (sf Floats) ToValues() Values {
        return NewValues(
                units.Dot(sf.Top),
                units.Dot(sf.Right),
                units.Dot(sf.Bottom),
                units.Dot(sf.Left),
        )
}

// Colors contains color values for each side/corner of a box
type Colors struct { //types:add
        Sides[color.RGBA]
}

// NewColors is a helper that creates new side/corner colors
// and calls Set on them with the given values.
// It does not return any error values and just logs them.
func NewColors(vals ...color.RGBA) Colors {
        sides := Sides[color.RGBA]{}
        sides.Set(vals...)
        return Colors{sides}
}

// SetAny sets the sides/corners from the given value of any type
func (s *Colors) SetAny(a any, base color.Color) error {
        switch val := a.(type) {
        case Sides[color.RGBA]:
                s.Sides = val
        case *Sides[color.RGBA]:
                s.Sides = *val
        case color.RGBA:
                s.SetAll(val)
        case *color.RGBA:
                s.SetAll(*val)
        case []color.RGBA:
                s.Set(val...)
        case *[]color.RGBA:
                s.Set(*val...)
        case string:
                return s.SetString(val, base)
        default:
                return s.SetString(fmt.Sprint(val), base)
        }
        return nil
}

// SetString sets the sides/corners from the given string value
func (s *Colors) SetString(str string, base color.Color) error {
        fields := strings.Fields(str)
        vals := make([]color.RGBA, len(fields))
        for i, field := range fields {
                clr, err := colors.FromString(field, base)
                if err != nil {
                        nerr := fmt.Errorf("(Colors).SetString('%s'): error setting sides of type %T from string: %w", str, s, err)
                        slog.Error(nerr.Error())
                        return nerr
                }
                vals[i] = clr
        }
        s.Set(vals...)
        return nil
}

// Code generated by "core generate"; DO NOT EDIT.

package states

import (
        "cogentcore.org/core/enums"
)

var _StatesValues = []States{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}

// StatesN is the highest valid value for type States, plus one.
const StatesN States = 15

var _StatesValueMap = map[string]States{`Invisible`: 0, `Disabled`: 1, `ReadOnly`: 2, `Selected`: 3, `Active`: 4, `Dragging`: 5, `Sliding`: 6, `Focused`: 7, `Attended`: 8, `Checked`: 9, `Indeterminate`: 10, `Hovered`: 11, `LongHovered`: 12, `LongPressed`: 13, `DragHovered`: 14}

var _StatesDescMap = map[States]string{0: `Invisible elements are not displayable, and thus do not present a target for GUI events. It is identical to CSS display:none. It is often used for elements such as tabs to hide elements in tabs that are not open. Elements can be made visible by toggling this flag and thus in general should be constructed and styled, but a new layout step must generally be taken after visibility status has changed. See also [cogentcore.org/core/core.WidgetBase.IsDisplayable].`, 1: `Disabled elements cannot be interacted with or selected, but do display.`, 2: `ReadOnly elements cannot be changed, but can be selected. A text input must not be ReadOnly for entering text. A button can be pressed while ReadOnly -- if not ReadOnly then the label on the button can be edited, for example.`, 3: `Selected elements have been marked for clipboard or other such actions.`, 4: `Active elements are currently being interacted with, usually involving a mouse button being pressed in the element. A text field will be active while being clicked on, and this can also result in a [Focused] state. If further movement happens, an element can also end up being Dragged or Sliding.`, 5: `Dragging means this element is currently being dragged by the mouse (i.e., a MouseDown event followed by MouseMove), as part of a drag-n-drop sequence.`, 6: `Sliding means this element is currently being manipulated via mouse to change the slider state, which will continue until the mouse is released, even if it goes off the element. It should also still be [Active].`, 7: `Focused elements receive keyboard input. Only one element can be Focused at a time.`, 8: `Attended elements are the last Activatable elements to be clicked on. Only one element can be Attended at a time. The main effect of Attended is on scrolling events: see [abilities.ScrollableUnattended]`, 9: `Checked is for check boxes or radio buttons or other similar state.`, 10: `Indeterminate indicates that the true state of an item is unknown. For example, [Checked] state items may be in an uncertain state if they represent other checked items, some of which are checked and some of which are not.`, 11: `Hovered indicates that a mouse pointer has entered the space over an element, but it is not [Active] (nor [DragHovered]).`, 12: `LongHovered indicates a Hover event that persists without significant movement for a minimum period of time (e.g., 500 msec), which typically triggers a tooltip popup.`, 13: `LongPressed indicates a MouseDown event that persists without significant movement for a minimum period of time (e.g., 500 msec), which typically triggers a tooltip and/or context menu popup.`, 14: `DragHovered indicates that a mouse pointer has entered the space over an element during a drag-n-drop sequence. This makes it a candidate for a potential drop target.`}

var _StatesMap = map[States]string{0: `Invisible`, 1: `Disabled`, 2: `ReadOnly`, 3: `Selected`, 4: `Active`, 5: `Dragging`, 6: `Sliding`, 7: `Focused`, 8: `Attended`, 9: `Checked`, 10: `Indeterminate`, 11: `Hovered`, 12: `LongHovered`, 13: `LongPressed`, 14: `DragHovered`}

// String returns the string representation of this States value.
func (i States) String() string { return enums.BitFlagString(i, _StatesValues) }

// BitIndexString returns the string representation of this States value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i States) BitIndexString() string { return enums.String(i, _StatesMap) }

// SetString sets the States value from its string representation,
// and returns an error if the string is invalid.
func (i *States) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the States value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *States) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _StatesValueMap, "States")
}

// Int64 returns the States value as an int64.
func (i States) Int64() int64 { return int64(i) }

// SetInt64 sets the States value from an int64.
func (i *States) SetInt64(in int64) { *i = States(in) }

// Desc returns the description of the States value.
func (i States) Desc() string { return enums.Desc(i, _StatesDescMap) }

// StatesValues returns all possible values for the type States.
func StatesValues() []States { return _StatesValues }

// Values returns all possible values for the type States.
func (i States) Values() []enums.Enum { return enums.Values(_StatesValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *States) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *States) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i States) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *States) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "States") }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package states

//go:generate core generate

import "cogentcore.org/core/enums"

// States are GUI states of elements that are relevant for styling based on
// CSS pseudo-classes (https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes).
type States int64 //enums:bitflag

const (
        // Invisible elements are not displayable, and thus do not present
        // a target for GUI events. It is identical to CSS display:none.
        // It is often used for elements such as tabs to hide elements in
        // tabs that are not open. Elements can be made visible by toggling
        // this flag and thus in general should be constructed and styled,
        // but a new layout step must generally be taken after visibility
        // status has changed. See also [cogentcore.org/core/core.WidgetBase.IsDisplayable].
        Invisible States = iota

        // Disabled elements cannot be interacted with or selected,
        // but do display.
        Disabled

        // ReadOnly elements cannot be changed, but can be selected.
        // A text input must not be ReadOnly for entering text.
        // A button can be pressed while ReadOnly -- if not ReadOnly then
        // the label on the button can be edited, for example.
        ReadOnly

        // Selected elements have been marked for clipboard or other such actions.
        Selected

        // Active elements are currently being interacted with,
        // usually involving a mouse button being pressed in the element.
        // A text field will be active while being clicked on, and this
        // can also result in a [Focused] state.
        // If further movement happens, an element can also end up being
        // Dragged or Sliding.
        Active

        // Dragging means this element is currently being dragged
        // by the mouse (i.e., a MouseDown event followed by MouseMove),
        // as part of a drag-n-drop sequence.
        Dragging

        // Sliding means this element is currently being manipulated
        // via mouse to change the slider state, which will continue
        // until the mouse is released, even if it goes off the element.
        // It should also still be [Active].
        Sliding

        // The current Focused element receives keyboard input.
        // Only one element can be Focused at a time.
        Focused

        // Attended is the last Pressable element to be clicked on.
        // Only one element can be Attended at a time.
        // The main effect of Attended is on scrolling events:
        // see [abilities.ScrollableUnattended]
        Attended

        // Checked is for check boxes or radio buttons or other similar state.
        Checked

        // Indeterminate indicates that the true state of an item is unknown.
        // For example, [Checked] state items may be in an uncertain state
        // if they represent other checked items, some of which are checked
        // and some of which are not.
        Indeterminate

        // Hovered indicates that a mouse pointer has entered the space over
        // an element, but it is not [Active] (nor [DragHovered]).
        Hovered

        // LongHovered indicates a Hover event that persists without significant
        // movement for a minimum period of time (e.g., 500 msec),
        // which typically triggers a tooltip popup.
        LongHovered

        // LongPressed indicates a MouseDown event that persists without significant
        // movement for a minimum period of time (e.g., 500 msec),
        // which typically triggers a tooltip and/or context menu popup.
        LongPressed

        // DragHovered indicates that a mouse pointer has entered the space over
        // an element during a drag-n-drop sequence.  This makes it a candidate
        // for a potential drop target.
        DragHovered
)

// Is is a shortcut for HasFlag for States
func (st States) Is(flag enums.BitFlag) bool {
        return st.HasFlag(flag)
}

// StateLayer returns the state layer opacity for the state, appropriate for use
// as the value of [cogentcore.org/core/styles.Style.StateLayer]
func (st States) StateLayer() float32 {
        switch {
        case st.Is(Disabled):
                return 0
        case st.Is(Dragging), st.Is(LongPressed):
                return 0.12
        case st.Is(Active), st.Is(Focused):
                return 0.10
        case st.Is(Hovered), st.Is(DragHovered):
                return 0.08
        default:
                return 0
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package styles provides style objects containing style properties
// used for GUI widgets and other rendering contexts.
package styles

//go:generate core generate

import (
        "image"
        "image/color"
        "log/slog"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/sides"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/text"
)

// IMPORTANT: any changes here must be updated in style_properties.go StyleStyleFuncs
// and likewise for all sub-styles as fields here.

// Style contains all of the style properties used for GUI widgets.
type Style struct { //types:add

        // State holds style-relevant state flags, for convenient styling access,
        // given that styles typically depend on element states.
        State states.States

        // Abilities specifies the abilities of this element, which determine
        // which kinds of states the element can express.
        // This is used by the system/events system.  Putting this info next
        // to the State info makes it easy to configure and manage.
        Abilities abilities.Abilities

        // the cursor to switch to upon hovering over the element (inherited)
        Cursor cursors.Cursor

        // Padding is the transparent space around central content of box,
        // which is _included_ in the size of the standard box rendering.
        Padding sides.Values `display:"inline"`

        // Margin is the outer-most transparent space around box element,
        // which is _excluded_ from standard box rendering.
        Margin sides.Values `display:"inline"`

        // Display controls how items are displayed, in terms of layout
        Display Displays

        // Direction specifies the way in which elements are laid out, or
        // the dimension on which an element is longer / travels in.
        Direction Directions

        // Wrap causes elements to wrap around in the CrossAxis dimension
        // to fit within sizing constraints.
        Wrap bool

        // Justify specifies the distribution of elements along the main axis,
        // i.e., the same as Direction, for Flex Display.  For Grid, the main axis is
        // given by the writing direction (e.g., Row-wise for latin based languages).
        Justify AlignSet `display:"inline"`

        // Align specifies the cross-axis alignment of elements, orthogonal to the
        // main Direction axis. For Grid, the cross-axis is orthogonal to the
        // writing direction (e.g., Column-wise for latin based languages).
        Align AlignSet `display:"inline"`

        // Min is the minimum size of the actual content, exclusive of additional space
        // from padding, border, margin; 0 = default is sum of Min for all content
        // (which _includes_ space for all sub-elements).
        // This is equivalent to the Basis for the CSS flex styling model.
        Min units.XY `display:"inline"`

        // Max is the maximum size of the actual content, exclusive of additional space
        // from padding, border, margin; 0 = default provides no Max size constraint
        Max units.XY `display:"inline"`

        // Grow is the proportional amount that the element can grow (stretch)
        // if there is more space available.  0 = default = no growth.
        // Extra available space is allocated as: Grow / sum (all Grow).
        // Important: grow elements absorb available space and thus are not
        // subject to alignment (Center, End).
        Grow math32.Vector2

        // GrowWrap is a special case for Text elements where it grows initially
        // in the horizontal axis to allow for longer, word wrapped text to fill
        // the available space, but then it does not grow thereafter, so that alignment
        // operations still work (Grow elements do not align because they absorb all
        // available space). Do NOT set this for non-Text elements.
        GrowWrap bool

        // RenderBox determines whether to render the standard box model for the element.
        // This is typically necessary for most elements and helps prevent text, border,
        // and box shadow from rendering over themselves. Therefore, it should be kept at
        // its default value of true in most circumstances, but it can be set to false
        // when the element is fully managed by something that is guaranteed to render the
        // appropriate background color and/or border for the element.
        RenderBox bool

        // FillMargin determines is whether to fill the margin with
        // the surrounding background color before rendering the element itself.
        // This is typically necessary to prevent text, border, and box shadow from
        // rendering over themselves. Therefore, it should be kept at its default value
        // of true in most circumstances, but it can be set to false when the element
        // is fully managed by something that is guaranteed to render the
        // appropriate background color for the element. It is irrelevant if RenderBox
        // is false.
        FillMargin bool

        // Overflow determines how to handle overflowing content in a layout.
        // Default is OverflowVisible.  Set to OverflowAuto to enable scrollbars.
        Overflow XY[Overflows]

        // For layouts, extra space added between elements in the layout.
        Gap units.XY `display:"inline"`

        // For grid layouts, the number of columns to use.
        // If > 0, number of rows is computed as N elements / Columns.
        // Used as a constraint in layout if individual elements
        // do not specify their row, column positions
        Columns int

        // If this object is a replaced object (image, video, etc)
        // or has a background image, ObjectFit specifies the way
        // in which the replaced object should be fit into the element.
        ObjectFit ObjectFits

        // If this object is a replaced object (image, video, etc)
        // or has a background image, ObjectPosition specifies the
        // X,Y position of the object within the space allocated for
        // the object (see ObjectFit).
        ObjectPosition units.XY

        // Border is a rendered border around the element.
        Border Border

        // MaxBorder is the largest border that will ever be rendered
        // around the element, the size of which is used for computing
        // the effective margin to allocate for the element.
        MaxBorder Border

        // BoxShadow is the box shadows to render around box (can have multiple)
        BoxShadow []Shadow

        // MaxBoxShadow contains the largest shadows that will ever be rendered
        // around the element, the size of which are used for computing the
        // effective margin to allocate for the element.
        MaxBoxShadow []Shadow

        // Color specifies the text / content color, and it is inherited.
        Color image.Image

        // Background specifies the background of the element. It is not inherited,
        // and it is nil (transparent) by default.
        Background image.Image

        // alpha value between 0 and 1 to apply to the foreground and background
        // of this element and all of its children.
        Opacity float32

        // StateLayer, if above zero, indicates to create a state layer over
        // the element with this much opacity (on a scale of 0-1) and the
        // color Color (or StateColor if it defined). It is automatically
        // set based on State, but can be overridden in stylers.
        StateLayer float32

        // StateColor, if not nil, is the color to use for the StateLayer
        // instead of Color. If you want to disable state layers
        // for an element, do not use this; instead, set StateLayer to 0.
        StateColor image.Image

        // ActualBackground is the computed actual background rendered for the element,
        // taking into account its Background, Opacity, StateLayer, and parent
        // ActualBackground. It is automatically computed and should not be set manually.
        ActualBackground image.Image

        // VirtualKeyboard is the virtual keyboard to display, if any,
        // on mobile platforms when this element is focused. It is not
        // used if the element is read only.
        VirtualKeyboard VirtualKeyboards

        // Pos is used for the position of the widget if the parent frame
        // has [Style.Display] = [Custom].
        Pos units.XY `display:"inline"`

        // ordering factor for rendering depth -- lower numbers rendered first.
        // Sort children according to this factor
        ZIndex int

        // specifies the row that this element should appear within a grid layout
        Row int

        // specifies the column that this element should appear within a grid layout
        Col int

        // specifies the number of sequential rows that this element should occupy
        // within a grid layout (todo: not currently supported)
        RowSpan int

        // specifies the number of sequential columns that this element should occupy
        // within a grid layout
        ColSpan int

        // ScrollbarWidth is the width of layout scrollbars. It defaults
        // to [DefaultScrollbarWidth], and it is inherited.
        ScrollbarWidth units.Value

        // Font styling parameters applicable to individual spans of text.
        Font Font

        // Text styling parameters applicable to a paragraph of text.
        Text Text

        // unit context: parameters necessary for anchoring relative units
        UnitContext units.Context
}

func (s *Style) Defaults() {
        // mostly all the defaults are 0 initial values, except these..
        s.UnitContext.Defaults()
        s.LayoutDefaults()
        s.Color = colors.Scheme.OnSurface
        s.Border.Color.Set(colors.Scheme.Outline)
        s.Opacity = 1
        s.RenderBox = true
        s.FillMargin = true
        s.Font.Defaults()
        s.Text.Defaults()
}

// VirtualKeyboards are all of the supported virtual keyboard types
// to display on mobile platforms.
type VirtualKeyboards int32 //enums:enum -trim-prefix Keyboard -transform kebab

const (
        // KeyboardNone indicates to display no virtual keyboard.
        KeyboardNone VirtualKeyboards = iota

        // KeyboardSingleLine indicates to display a virtual keyboard
        // with a default input style and a "Done" return key.
        KeyboardSingleLine

        // KeyboardMultiLine indicates to display a virtual keyboard
        // with a default input style and a "Return" return key.
        KeyboardMultiLine

        // KeyboardNumber indicates to display a virtual keyboard
        // for inputting a number.
        KeyboardNumber

        // KeyboardPassword indicates to display a virtual keyboard
        // for inputting a password.
        KeyboardPassword

        // KeyboardEmail indicates to display a virtual keyboard
        // for inputting an email address.
        KeyboardEmail

        // KeyboardPhone indicates to display a virtual keyboard
        // for inputting a phone number.
        KeyboardPhone

        // KeyboardURL indicates to display a virtual keyboard for
        // inputting a URL / URI / web address.
        KeyboardURL
)

// todo: Animation

// Clear -- no floating elements

// Clip -- clip images

// column- settings -- lots of those

// List-style for lists

// Object-fit for videos

// visibility -- support more than just hidden

// transition -- animation of hover, etc

// NewStyle returns a new [Style] object with default values.
func NewStyle() *Style {
        s := &Style{}
        s.Defaults()
        return s
}

// Is returns whether the given [states.States] flag is set
func (s *Style) Is(st states.States) bool {
        return s.State.HasFlag(st)
}

// AbilityIs returns whether the given [abilities.Abilities] flag is set
func (s *Style) AbilityIs(able abilities.Abilities) bool {
        return s.Abilities.HasFlag(able)
}

// SetState sets the given [states.States] flags to the given value
func (s *Style) SetState(on bool, state ...states.States) *Style {
        bfs := make([]enums.BitFlag, len(state))
        for i, st := range state {
                bfs[i] = st
        }
        s.State.SetFlag(on, bfs...)
        return s
}

// SetEnabled sets the Disabled State flag according to given bool
func (s *Style) SetEnabled(on bool) *Style {
        s.State.SetFlag(!on, states.Disabled)
        return s
}

// IsReadOnly returns whether this style object is flagged as either [states.ReadOnly] or [states.Disabled].
func (s *Style) IsReadOnly() bool {
        return s.Is(states.ReadOnly) || s.Is(states.Disabled)
}

// SetAbilities sets the given [states.State] flags to the given value
func (s *Style) SetAbilities(on bool, able ...abilities.Abilities) {
        bfs := make([]enums.BitFlag, len(able))
        for i, st := range able {
                bfs[i] = st
        }
        s.Abilities.SetFlag(on, bfs...)
}

// InheritFields from parent
func (s *Style) InheritFields(parent *Style) {
        s.Color = parent.Color
        s.Opacity = parent.Opacity
        s.ScrollbarWidth = parent.ScrollbarWidth
        s.Font.InheritFields(&parent.Font)
        s.Text.InheritFields(&parent.Text)
}

// ToDotsImpl runs ToDots on unit values, to compile down to raw pixels
func (s *Style) ToDotsImpl(uc *units.Context) {
        s.LayoutToDots(uc)
        s.Font.ToDots(uc)
        s.Text.ToDots(uc)
        s.Border.ToDots(uc)
        s.MaxBorder.ToDots(uc)
        s.BoxShadowToDots(uc)
}

// ToDots caches all style elements in terms of raw pixel
// dots for rendering.
func (s *Style) ToDots() {
        if s.Min.X.Unit == units.UnitEw || s.Min.X.Unit == units.UnitEh ||
                s.Min.Y.Unit == units.UnitEw || s.Min.Y.Unit == units.UnitEh ||
                s.Max.X.Unit == units.UnitEw || s.Max.X.Unit == units.UnitEh ||
                s.Max.Y.Unit == units.UnitEw || s.Max.Y.Unit == units.UnitEh {
                slog.Error("styling error: cannot use Ew or Eh for Min size -- that is self-referential!")
        }
        s.ToDotsImpl(&s.UnitContext)
}

// BoxSpace returns the extra space around the central content in the box model in dots.
// It rounds all of the sides first.
func (s *Style) BoxSpace() sides.Floats {
        return s.TotalMargin().Add(s.Padding.Dots()).Round()
}

// TotalMargin returns the total effective margin of the element
// holding the style, using the sum of the actual margin, the max
// border width, and the max box shadow effective margin. If the
// values for the max border width / box shadow are unset, the
// current values are used instead, which allows for the omission
// of the max properties when the values do not change.
func (s *Style) TotalMargin() sides.Floats {
        mbw := s.MaxBorder.Width.Dots()
        if sides.AreZero(mbw.Sides) {
                mbw = s.Border.Width.Dots()
        }
        mbo := s.MaxBorder.Offset.Dots()
        if sides.AreZero(mbo.Sides) {
                mbo = s.Border.Offset.Dots()
        }
        mbw = mbw.Add(mbo)

        if s.Border.Style.Top == BorderNone {
                mbw.Top = 0
        }
        if s.Border.Style.Right == BorderNone {
                mbw.Right = 0
        }
        if s.Border.Style.Bottom == BorderNone {
                mbw.Bottom = 0
        }
        if s.Border.Style.Left == BorderNone {
                mbw.Left = 0
        }

        mbsm := s.MaxBoxShadowMargin()
        if sides.AreZero(mbsm.Sides) {
                mbsm = s.BoxShadowMargin()
        }
        return s.Margin.Dots().Add(mbw).Add(mbsm)
}

// SubProperties returns a sub-property map from given prop map for a given styling
// selector (property name) -- e.g., :normal :active :hover etc -- returns
// false if not found
func SubProperties(prp map[string]any, selector string) (map[string]any, bool) {
        sp, ok := prp[selector]
        if !ok {
                return nil, false
        }
        spm, ok := sp.(map[string]any)
        if ok {
                return spm, true
        }
        return nil, false
}

// StyleDefault is default style can be used when property specifies "default"
var StyleDefault Style

// ComputeActualBackground sets [Style.ActualBackground] based on the
// given parent actual background and the properties of the style object.
func (s *Style) ComputeActualBackground(pabg image.Image) {
        s.ActualBackground = s.ComputeActualBackgroundFor(s.Background, pabg)
}

// ComputeActualBackgroundFor returns the actual background for
// the given background based on the given parent actual background
// and the properties of the style object.
func (s *Style) ComputeActualBackgroundFor(bg, pabg image.Image) image.Image {
        if bg == nil {
                bg = pabg
        } else if u, ok := bg.(*image.Uniform); ok && colors.IsNil(u.C) {
                bg = pabg
        }

        if s.Opacity >= 1 && s.StateLayer <= 0 {
                // we have no transformations to apply
                return bg
        }

        // TODO(kai): maybe improve this function to handle all
        // use cases correctly (image parents, image state colors, etc)

        upabg := colors.ToUniform(pabg)

        if s.Opacity < 1 {
                bg = gradient.Apply(bg, func(c color.Color) color.Color {
                        // we take our opacity-applied background color and then overlay it onto our surrounding color
                        obg := colors.ApplyOpacity(c, s.Opacity)
                        return colors.AlphaBlend(upabg, obg)
                })
        }
        if s.StateLayer > 0 {
                sc := s.Color
                if s.StateColor != nil {
                        sc = s.StateColor
                }
                // we take our state-layer-applied state color and then overlay it onto our background color
                sclr := colors.WithAF32(colors.ToUniform(sc), s.StateLayer)
                bg = gradient.Apply(bg, func(c color.Color) color.Color {
                        return colors.AlphaBlend(c, sclr)
                })
        }
        return bg
}

// IsFlexWrap returns whether the style is both [Style.Wrap] and [Flex].
func (s *Style) IsFlexWrap() bool {
        return s.Wrap && s.Display == Flex
}

// SetReadOnly sets the [states.ReadOnly] flag to the given value.
func (s *Style) SetReadOnly(ro bool) {
        s.SetState(ro, states.ReadOnly)
}

// CenterAll sets all of the alignment properties to [Center]
// such that all children are fully centered.
func (s *Style) CenterAll() {
        s.Justify.Content = Center
        s.Justify.Items = Center
        s.Align.Content = Center
        s.Align.Items = Center
        s.Text.Align = text.Center
        s.Text.AlignV = text.Center
}

// SetTextWrap sets the Text.WhiteSpace and GrowWrap properties in
// a coordinated manner.  If wrap == true, then WhiteSpaceNormal
// and GrowWrap = true; else WhiteSpaceNowrap and GrowWrap = false, which
// are typically the two desired stylings.
func (s *Style) SetTextWrap(wrap bool) {
        if wrap {
                s.Text.WhiteSpace = text.WrapAsNeeded
                s.GrowWrap = true
        } else {
                s.Text.WhiteSpace = text.WrapNever
                s.GrowWrap = false
        }
}

// SetNonSelectable turns off the Selectable and DoubleClickable
// abilities and sets the Cursor to None.
func (s *Style) SetNonSelectable() {
        s.SetAbilities(false, abilities.Selectable, abilities.DoubleClickable, abilities.TripleClickable, abilities.Slideable)
        s.Cursor = cursors.None
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/styles/styleprops"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
)

// These functions set styles from map[string]any which are used for styling

// FromProperty sets style field values based on the given property key and value
func (s *Style) FromProperty(parent *Style, key string, val any, cc colors.Context) {
        var pfont *Font
        var ptext *Text
        if parent != nil {
                pfont = &parent.Font
                ptext = &parent.Text
        }
        s.Font.FromProperty(pfont, key, val, cc)
        s.Text.FromProperty(ptext, key, val, cc)
        if sfunc, ok := styleLayoutFuncs[key]; ok {
                if parent != nil {
                        sfunc(s, key, val, parent, cc)
                } else {
                        sfunc(s, key, val, nil, cc)
                }
                return
        }
        if sfunc, ok := styleBorderFuncs[key]; ok {
                if parent != nil {
                        sfunc(&s.Border, key, val, &parent.Border, cc)
                } else {
                        sfunc(&s.Border, key, val, nil, cc)
                }
                return
        }
        if sfunc, ok := styleStyleFuncs[key]; ok {
                sfunc(s, key, val, parent, cc)
                return
        }
        // doesn't work with multiple shadows
        // if sfunc, ok := StyleShadowFuncs[key]; ok {
        //         if parent != nil {
        //                 sfunc(&s.BoxShadow, key, val, &par.BoxShadow, cc)
        //         } else {
        //                 sfunc(&s.BoxShadow, key, val, nil, cc)
        //         }
        //         return
        // }
}

////////  Style

// styleStyleFuncs are functions for styling the Style object itself
var styleStyleFuncs = map[string]styleprops.Func{
        "color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Color = parent.(*Style).Color
                        } else if init {
                                fs.Color = colors.Scheme.OnSurface
                        }
                        return
                }
                fs.Color = errors.Log1(gradient.FromAny(val, cc))
        },
        "background-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Background = parent.(*Style).Background
                        } else if init {
                                fs.Background = nil
                        }
                        return
                }
                fs.Background = errors.Log1(gradient.FromAny(val, cc))
        },
        "opacity": styleprops.Float(float32(1),
                func(obj *Style) *float32 { return &obj.Opacity }),
}

////////  Layout

// styleLayoutFuncs are functions for styling the layout
// style properties; they are still stored on the main style object,
// but they are done separately to improve clarity
var styleLayoutFuncs = map[string]styleprops.Func{
        "display": styleprops.Enum(Flex,
                func(obj *Style) enums.EnumSetter { return &obj.Display }),
        "flex-direction": func(obj any, key string, val, parent any, cc colors.Context) {
                s := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                s.Direction = parent.(*Style).Direction
                        } else if init {
                                s.Direction = Row
                        }
                        return
                }
                str := reflectx.ToString(val)
                if str == "row" || str == "row-reverse" {
                        s.Direction = Row
                } else {
                        s.Direction = Column
                }
        },
        // TODO(kai/styproperties): multi-dim flex-grow
        "flex-grow": styleprops.Float(0, func(obj *Style) *float32 { return &obj.Grow.Y }),
        "wrap": styleprops.Bool(false,
                func(obj *Style) *bool { return &obj.Wrap }),
        "justify-content": styleprops.Enum(Start,
                func(obj *Style) enums.EnumSetter { return &obj.Justify.Content }),
        "justify-items": styleprops.Enum(Start,
                func(obj *Style) enums.EnumSetter { return &obj.Justify.Items }),
        "justify-self": styleprops.Enum(Auto,
                func(obj *Style) enums.EnumSetter { return &obj.Justify.Self }),
        "align-content": styleprops.Enum(Start,
                func(obj *Style) enums.EnumSetter { return &obj.Align.Content }),
        "align-items": styleprops.Enum(Start,
                func(obj *Style) enums.EnumSetter { return &obj.Align.Items }),
        "align-self": styleprops.Enum(Auto,
                func(obj *Style) enums.EnumSetter { return &obj.Align.Self }),
        "x": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.Pos.X }),
        "y": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.Pos.Y }),
        "width": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.Min.X }),
        "height": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.Min.Y }),
        "max-width": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.Max.X }),
        "max-height": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.Max.Y }),
        "min-width": styleprops.Units(units.Dp(2),
                func(obj *Style) *units.Value { return &obj.Min.X }),
        "min-height": styleprops.Units(units.Dp(2),
                func(obj *Style) *units.Value { return &obj.Min.Y }),
        "margin": func(obj any, key string, val any, parent any, cc colors.Context) {
                s := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                s.Margin = parent.(*Style).Margin
                        } else if init {
                                s.Margin.Zero()
                        }
                        return
                }
                s.Margin.SetAny(val)
        },
        "padding": func(obj any, key string, val any, parent any, cc colors.Context) {
                s := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                s.Padding = parent.(*Style).Padding
                        } else if init {
                                s.Padding.Zero()
                        }
                        return
                }
                s.Padding.SetAny(val)
        },
        // TODO(kai/styproperties): multi-dim overflow
        "overflow": styleprops.Enum(OverflowAuto,
                func(obj *Style) enums.EnumSetter { return &obj.Overflow.Y }),
        "columns": styleprops.Int(int(0),
                func(obj *Style) *int { return &obj.Columns }),
        "row": styleprops.Int(int(0),
                func(obj *Style) *int { return &obj.Row }),
        "col": styleprops.Int(int(0),
                func(obj *Style) *int { return &obj.Col }),
        "row-span": styleprops.Int(int(0),
                func(obj *Style) *int { return &obj.RowSpan }),
        "col-span": styleprops.Int(int(0),
                func(obj *Style) *int { return &obj.ColSpan }),
        "z-index": styleprops.Int(int(0),
                func(obj *Style) *int { return &obj.ZIndex }),
        "scrollbar-width": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.ScrollbarWidth }),
}

////////  Border

// styleBorderFuncs are functions for styling the Border object
var styleBorderFuncs = map[string]styleprops.Func{
        // SidesTODO: need to figure out how to get key and context information for side SetAny calls
        // with padding, margin, border, etc
        "border-style": func(obj any, key string, val any, parent any, cc colors.Context) {
                bs := obj.(*Border)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                bs.Style = parent.(*Border).Style
                        } else if init {
                                bs.Style.Set(BorderSolid)
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        bs.Style.SetString(vt)
                case BorderStyles:
                        bs.Style.Set(vt)
                case []BorderStyles:
                        bs.Style.Set(vt...)
                default:
                        iv, err := reflectx.ToInt(val)
                        if err == nil {
                                bs.Style.Set(BorderStyles(iv))
                        } else {
                                styleprops.SetError(key, val, err)
                        }
                }
        },
        "border-width": func(obj any, key string, val any, parent any, cc colors.Context) {
                bs := obj.(*Border)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                bs.Width = parent.(*Border).Width
                        } else if init {
                                bs.Width.Zero()
                        }
                        return
                }
                bs.Width.SetAny(val)
        },
        "border-radius": func(obj any, key string, val any, parent any, cc colors.Context) {
                bs := obj.(*Border)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                bs.Radius = parent.(*Border).Radius
                        } else if init {
                                bs.Radius.Zero()
                        }
                        return
                }
                bs.Radius.SetAny(val)
        },
        "border-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                bs := obj.(*Border)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                bs.Color = parent.(*Border).Color
                        } else if init {
                                bs.Color.Set(colors.Scheme.Outline)
                        }
                        return
                }
                // TODO(kai): support side-specific border colors
                bs.Color.Set(errors.Log1(gradient.FromAny(val, cc)))
        },
}

////////  Outline

// styleOutlineFuncs are functions for styling the OutlineStyle object
var styleOutlineFuncs = map[string]styleprops.Func{
        "outline-style": func(obj any, key string, val any, parent any, cc colors.Context) {
                bs := obj.(*Border)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                bs.Style = parent.(*Border).Style
                        } else if init {
                                bs.Style.Set(BorderSolid)
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        bs.Style.SetString(vt)
                case BorderStyles:
                        bs.Style.Set(vt)
                case []BorderStyles:
                        bs.Style.Set(vt...)
                default:
                        iv, err := reflectx.ToInt(val)
                        if err == nil {
                                bs.Style.Set(BorderStyles(iv))
                        } else {
                                styleprops.SetError(key, val, err)
                        }
                }
        },
        "outline-width": func(obj any, key string, val any, parent any, cc colors.Context) {
                bs := obj.(*Border)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                bs.Width = parent.(*Border).Width
                        } else if init {
                                bs.Width.Zero()
                        }
                        return
                }
                bs.Width.SetAny(val)
        },
        "outline-radius": func(obj any, key string, val any, parent any, cc colors.Context) {
                bs := obj.(*Border)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                bs.Radius = parent.(*Border).Radius
                        } else if init {
                                bs.Radius.Zero()
                        }
                        return
                }
                bs.Radius.SetAny(val)
        },
        "outline-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                bs := obj.(*Border)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                bs.Color = parent.(*Border).Color
                        } else if init {
                                bs.Color.Set(colors.Scheme.Outline)
                        }
                        return
                }
                // TODO(kai): support side-specific border colors
                bs.Color.Set(errors.Log1(gradient.FromAny(val, cc)))
        },
}

////////  Shadow

// styleShadowFuncs are functions for styling the Shadow object
var styleShadowFuncs = map[string]styleprops.Func{
        "box-shadow.offset-x": styleprops.Units(units.Value{},
                func(obj *Shadow) *units.Value { return &obj.OffsetX }),
        "box-shadow.offset-y": styleprops.Units(units.Value{},
                func(obj *Shadow) *units.Value { return &obj.OffsetY }),
        "box-shadow.blur": styleprops.Units(units.Value{},
                func(obj *Shadow) *units.Value { return &obj.Blur }),
        "box-shadow.spread": styleprops.Units(units.Value{},
                func(obj *Shadow) *units.Value { return &obj.Spread }),
        "box-shadow.color": func(obj any, key string, val any, parent any, cc colors.Context) {
                ss := obj.(*Shadow)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                ss.Color = parent.(*Shadow).Color
                        } else if init {
                                ss.Color = colors.Scheme.Shadow
                        }
                        return
                }
                ss.Color = errors.Log1(gradient.FromAny(val, cc))
        },
        "box-shadow.inset": styleprops.Bool(false,
                func(obj *Shadow) *bool { return &obj.Inset }),
}

//////// Font

// FromProperties sets style field values based on the given property list.
func (s *Font) FromProperties(parent *Font, properties map[string]any, ctxt colors.Context) {
        for key, val := range properties {
                if len(key) == 0 {
                        continue
                }
                if key[0] == '#' || key[0] == '.' || key[0] == ':' || key[0] == '_' {
                        continue
                }
                s.FromProperty(parent, key, val, ctxt)
        }
}

// FromProperty sets style field values based on the given property key and value.
func (s *Font) FromProperty(parent *Font, key string, val any, cc colors.Context) {
        if sfunc, ok := styleFontFuncs[key]; ok {
                if parent != nil {
                        sfunc(s, key, val, parent, cc)
                } else {
                        sfunc(s, key, val, nil, cc)
                }
                return
        }
}

// FontSizePoints maps standard font names to standard point sizes -- we use
// dpi zoom scaling instead of rescaling "medium" font size, so generally use
// these values as-is.  smaller and larger relative scaling can move in 2pt increments
var FontSizePoints = map[string]float32{
        "xx-small": 7,
        "x-small":  7.5,
        "small":    10, // small is also "smaller"
        "smallf":   10, // smallf = small font size..
        "medium":   12,
        "large":    14,
        "x-large":  18,
        "xx-large": 24,
}

// styleFontFuncs are functions for styling the Font object.
var styleFontFuncs = map[string]styleprops.Func{
        // note: text.Style handles the standard units-based font-size settings
        "font-size": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Font)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Size = parent.(*Font).Size
                        } else if init {
                                fs.Size.Set(16, units.UnitDp)
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        if psz, ok := FontSizePoints[vt]; ok {
                                fs.Size = units.Pt(psz)
                        } else {
                                fs.Size.SetAny(val, key) // also processes string
                        }
                }
        },
        "font-family": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Font)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Family = parent.(*Font).Family
                        } else if init {
                                fs.Family = rich.SansSerif // font has defaults
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        fs.CustomFont = rich.FontName(vt)
                        fs.Family = rich.Custom
                default:
                        // todo: process enum
                }
        },
        "font-style": styleprops.Enum(rich.SlantNormal,
                func(obj *Font) enums.EnumSetter { return &obj.Slant }),
        "font-weight": styleprops.Enum(rich.Normal,
                func(obj *Font) enums.EnumSetter { return &obj.Weight }),
        "font-stretch": styleprops.Enum(rich.StretchNormal,
                func(obj *Font) enums.EnumSetter { return &obj.Stretch }),
        "text-decoration": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Font)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Decoration = parent.(*Font).Decoration
                        } else if init {
                                fs.Decoration = 0
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        if vt == "none" {
                                fs.Decoration = 0
                        } else {
                                fs.Decoration.SetString(vt)
                        }
                case rich.Decorations:
                        fs.Decoration.SetFlag(true, vt)
                default:
                        iv, err := reflectx.ToInt(val)
                        if err == nil {
                                fs.Decoration.SetFlag(true, rich.Decorations(iv))
                        } else {
                                styleprops.SetError(key, val, err)
                        }
                }
        },
}

// FromProperties sets style field values based on the given property list.
func (s *Text) FromProperties(parent *Text, properties map[string]any, ctxt colors.Context) {
        for key, val := range properties {
                if len(key) == 0 {
                        continue
                }
                if key[0] == '#' || key[0] == '.' || key[0] == ':' || key[0] == '_' {
                        continue
                }
                s.FromProperty(parent, key, val, ctxt)
        }
}

// FromProperty sets style field values based on the given property key and value.
func (s *Text) FromProperty(parent *Text, key string, val any, cc colors.Context) {
        if sfunc, ok := styleFuncs[key]; ok {
                if parent != nil {
                        sfunc(s, key, val, parent, cc)
                } else {
                        sfunc(s, key, val, nil, cc)
                }
                return
        }
}

// styleFuncs are functions for styling the Text object.
var styleFuncs = map[string]styleprops.Func{
        "text-align": styleprops.Enum(Start,
                func(obj *Text) enums.EnumSetter { return &obj.Align }),
        "text-vertical-align": styleprops.Enum(Start,
                func(obj *Text) enums.EnumSetter { return &obj.AlignV }),
        "line-height": styleprops.FloatProportion(float32(1.2),
                func(obj *Text) *float32 { return &obj.LineHeight }),
        "line-spacing": styleprops.FloatProportion(float32(1.2),
                func(obj *Text) *float32 { return &obj.LineHeight }),
        "white-space": styleprops.Enum(text.WrapAsNeeded,
                func(obj *Text) enums.EnumSetter { return &obj.WhiteSpace }),
        "direction": styleprops.Enum(rich.LTR,
                func(obj *Text) enums.EnumSetter { return &obj.Direction }),
        "tab-size": styleprops.Int(int(4),
                func(obj *Text) *int { return &obj.TabSize }),
        "select-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Text)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.SelectColor = parent.(*Text).SelectColor
                        } else if init {
                                fs.SelectColor = colors.Scheme.Select.Container
                        }
                        return
                }
                fs.SelectColor = errors.Log1(gradient.FromAny(val, cc))
        },
        "highlight-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Text)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.HighlightColor = parent.(*Text).HighlightColor
                        } else if init {
                                fs.HighlightColor = colors.Scheme.Warn.Container
                        }
                        return
                }
                fs.HighlightColor = errors.Log1(gradient.FromAny(val, cc))
        },
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package styleprops provides infrastructure for property-list-based setting
// of style values, where a property list is a map[string]any collection of
// key, value pairs.
package styleprops

import (
        "log/slog"
        "reflect"
        "strings"

        "cogentcore.org/core/base/num"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/styles/units"
)

// Func is the signature for styleprops functions
type Func func(obj any, key string, val any, parent any, cc colors.Context)

// InhInit detects the style values of "inherit" and "initial",
// setting the corresponding bool return values
func InhInit(val, parent any) (inh, init bool) {
        if str, ok := val.(string); ok {
                switch str {
                case "inherit":
                        return !reflectx.IsNil(reflect.ValueOf(parent)), false
                case "initial":
                        return false, true
                default:
                        return false, false
                }
        }
        return false, false
}

// FuncInt returns a style function for any numerical value
func Int[T any, F num.Integer](initVal F, getField func(obj *T) *F) Func {
        return func(obj any, key string, val any, parent any, cc colors.Context) {
                fp := getField(obj.(*T))
                if inh, init := InhInit(val, parent); inh || init {
                        if inh {
                                *fp = *getField(parent.(*T))
                        } else if init {
                                *fp = initVal
                        }
                        return
                }
                fv, _ := reflectx.ToInt(val)
                *fp = F(fv)
        }
}

// Float returns a style function for any numerical value.
// Automatically removes a trailing % -- see FloatProportion.
func Float[T any, F num.Float](initVal F, getField func(obj *T) *F) Func {
        return func(obj any, key string, val any, parent any, cc colors.Context) {
                fp := getField(obj.(*T))
                if inh, init := InhInit(val, parent); inh || init {
                        if inh {
                                *fp = *getField(parent.(*T))
                        } else if init {
                                *fp = initVal
                        }
                        return
                }
                if vstr, ok := val.(string); ok {
                        val = strings.TrimSuffix(vstr, "%")
                }
                fv, _ := reflectx.ToFloat(val) // can represent any number, ToFloat is fast type switch
                *fp = F(fv)
        }
}

// FloatProportion returns a style function for a proportion that can be
// represented as a percentage (divides value by 100).
func FloatProportion[T any, F num.Float](initVal F, getField func(obj *T) *F) Func {
        return func(obj any, key string, val any, parent any, cc colors.Context) {
                fp := getField(obj.(*T))
                if inh, init := InhInit(val, parent); inh || init {
                        if inh {
                                *fp = *getField(parent.(*T))
                        } else if init {
                                *fp = initVal
                        }
                        return
                }
                isPct := false
                if vstr, ok := val.(string); ok {
                        val = strings.TrimSuffix(vstr, "%")
                        isPct = true
                }
                fv, _ := reflectx.ToFloat(val) // can represent any number, ToFloat is fast type switch
                if isPct {
                        fv /= 100
                }
                *fp = F(fv)
        }
}

// Bool returns a style function for a bool value
func Bool[T any](initVal bool, getField func(obj *T) *bool) Func {
        return func(obj any, key string, val any, parent any, cc colors.Context) {
                fp := getField(obj.(*T))
                if inh, init := InhInit(val, parent); inh || init {
                        if inh {
                                *fp = *getField(parent.(*T))
                        } else if init {
                                *fp = initVal
                        }
                        return
                }
                fv, _ := reflectx.ToBool(val)
                *fp = fv
        }
}

// Units returns a style function for units.Value
func Units[T any](initVal units.Value, getField func(obj *T) *units.Value) Func {
        return func(obj any, key string, val any, parent any, cc colors.Context) {
                fp := getField(obj.(*T))
                if inh, init := InhInit(val, parent); inh || init {
                        if inh {
                                *fp = *getField(parent.(*T))
                        } else if init {
                                *fp = initVal
                        }
                        return
                }
                fp.SetAny(val, key)
        }
}

// Enum returns a style function for any enum value
func Enum[T any](initVal enums.Enum, getField func(obj *T) enums.EnumSetter) Func {
        return func(obj any, key string, val any, parent any, cc colors.Context) {
                fp := getField(obj.(*T))
                if inh, init := InhInit(val, parent); inh || init {
                        if inh {
                                fp.SetInt64(getField(parent.(*T)).Int64())
                        } else if init {
                                fp.SetInt64(initVal.Int64())
                        }
                        return
                }
                if st, ok := val.(string); ok {
                        fp.SetString(st)
                        return
                }
                if en, ok := val.(enums.Enum); ok {
                        fp.SetInt64(en.Int64())
                        return
                }
                iv, _ := reflectx.ToInt(val)
                fp.SetInt64(int64(iv))
        }
}

// SetError reports that cannot set property of given key with given value due to given error
func SetError(key string, val any, err error) {
        slog.Error("styleprops: error setting value", "key", key, "value", val, "err", err)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styleprops

import (
        "fmt"
        "strings"

        "cogentcore.org/core/base/reflectx"
)

// FromXMLString sets style properties from XML style string, which contains ';'
// separated name: value pairs
func FromXMLString(style string, properties map[string]any) {
        st := strings.Split(style, ";")
        for _, s := range st {
                kv := strings.Split(s, ":")
                if len(kv) >= 2 {
                        k := strings.TrimSpace(strings.ToLower(kv[0]))
                        v := strings.TrimSpace(kv[1])
                        properties[k] = v
                }
        }
}

// ToXMLString returns an XML style string from given style properties map
// using ';' separated name: value pairs.
func ToXMLString(properties map[string]any) string {
        var sb strings.Builder
        for k, v := range properties {
                if k == "transform" {
                        continue
                }
                sb.WriteString(fmt.Sprintf("%s:%s;", k, reflectx.ToString(v)))
        }
        return sb.String()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "image"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
)

// Text has styles for text layout styling.
// Most of these are inherited
type Text struct { //types:add

        // Align specifies how to align text along the default direction (inherited).
        // This *only* applies to the text within its containing element,
        // and is relevant only for multi-line text.
        Align text.Aligns

        // AlignV specifies "vertical" (orthogonal to default direction)
        // alignment of text (inherited).
        // This *only* applies to the text within its containing element:
        // if that element does not have a specified size
        // that is different from the text size, then this has *no effect*.
        AlignV text.Aligns

        // LineHeight is a multiplier on the default font size for spacing between lines.
        // If there are larger font elements within a line, they will be accommodated, with
        // the same amount of total spacing added above that maximum size as if it was all
        // the same height. The default of 1.3 represents standard "single spaced" text.
        LineHeight float32 `default:"1.3"`

        // WhiteSpace (not inherited) specifies how white space is processed,
        // and how lines are wrapped.  If set to WhiteSpaceNormal (default) lines are wrapped.
        // See info about interactions with Grow.X setting for this and the NoWrap case.
        WhiteSpace text.WhiteSpaces

        // Direction specifies the default text direction, which can be overridden if the
        // unicode text is typically written in a different direction.
        Direction rich.Directions

        // TabSize specifies the tab size, in number of characters (inherited).
        TabSize int

        // SelectColor is the color to use for the background region of selected text (inherited).
        SelectColor image.Image

        // HighlightColor is the color to use for the background region of highlighted text (inherited).
        HighlightColor image.Image
}

func (ts *Text) Defaults() {
        ts.Align = text.Start
        ts.AlignV = text.Start
        ts.LineHeight = 1.3
        ts.Direction = rich.LTR
        ts.TabSize = 4
        ts.SelectColor = colors.Scheme.Select.Container
        ts.HighlightColor = colors.Scheme.Warn.Container
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (ts *Text) ToDots(uc *units.Context) {
}

// InheritFields from parent
func (ts *Text) InheritFields(parent *Text) {
        ts.Align = parent.Align
        ts.AlignV = parent.AlignV
        ts.LineHeight = parent.LineHeight
        // ts.WhiteSpace = par.WhiteSpace // note: we can't inherit this b/c label base default then gets overwritten
        ts.Direction = parent.Direction
        ts.TabSize = parent.TabSize
        ts.SelectColor = parent.SelectColor
        ts.HighlightColor = parent.HighlightColor
}

// SetText sets the text.Style from this style.
func (ts *Text) SetText(tsty *text.Style) {
        tsty.Align = ts.Align
        tsty.AlignV = ts.AlignV
        tsty.LineHeight = ts.LineHeight
        tsty.WhiteSpace = ts.WhiteSpace
        tsty.Direction = ts.Direction
        tsty.TabSize = ts.TabSize
        tsty.SelectColor = ts.SelectColor
        tsty.HighlightColor = ts.HighlightColor
}

// LineHeightDots returns the effective line height in dots (actual pixels)
// as FontHeight * LineHeight
func (s *Style) LineHeightDots() float32 {
        return math32.Ceil(s.Font.FontHeight() * s.Text.LineHeight)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package units

import (
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/math32"
)

// Context specifies everything about the current context necessary for converting the number
// into specific display-dependent pixels
type Context struct {

        // DPI is dots-per-inch of the display
        DPI float32

        // FontEm is the size of the font of the element in raw dots (not points)
        FontEm float32

        // FontEx is the height x-height of font in points (size of 'x' glyph)
        FontEx float32

        // FontCh is the ch-size character size of font in points (width of '0' glyph)
        FontCh float32

        // FontRem is the size of the font of the root element in raw dots (not points)
        FontRem float32

        // Vpw is viewport width in dots
        Vpw float32

        // Vph is viewport height in dots
        Vph float32

        // Elw is width of element in dots
        Elw float32

        // Elh is height of element in dots
        Elh float32

        // Paw is width of parent in dots
        Paw float32

        // Pah is height of parent in dots
        Pah float32
}

// Defaults are generic defaults
func (uc *Context) Defaults() {
        uc.DPI = DpPerInch
        uc.FontEm = 16
        uc.FontEx = 8
        uc.FontCh = 8
        uc.FontRem = 16
        uc.Vpw = 800
        uc.Vph = 600
        uc.Elw = uc.Vpw
        uc.Elh = uc.Vph
        uc.Paw = uc.Vpw
        uc.Pah = uc.Vph
}

func (uc *Context) String() string {
        return reflectx.StringJSON(uc)
}

// SetSizes sets the context values for the non-font sizes
// to the given values; the values are ignored if they are zero.
// returns true if any are different.
func (uc *Context) SetSizes(vw, vh, ew, eh, pw, ph float32) bool {
        diff := false
        if vw != 0 {
                if uc.Vpw != vw {
                        diff = true
                }
                uc.Vpw = vw
        }
        if vh != 0 {
                if uc.Vph != vh {
                        diff = true
                }
                uc.Vph = vh
        }
        if ew != 0 {
                if uc.Elw != ew {
                        diff = true
                }
                uc.Elw = ew
        }
        if eh != 0 {
                if uc.Elh != eh {
                        diff = true
                }
                uc.Elh = eh
        }
        if pw != 0 {
                if uc.Paw != pw {
                        diff = true
                }
                uc.Paw = pw
        }
        if ph != 0 {
                if uc.Pah != ph {
                        diff = true
                }
                uc.Pah = ph
        }
        return diff
}

// SetFont sets the context values for font based on the em size,
// which is the nominal font height, in DPI dots.
// This uses standard conversion factors from em. It is too unreliable
// and complicated to get these values from the actual font itself.
func (uc *Context) SetFont(em float32) {
        if em == 0 {
                em = 16
        }
        uc.FontEm = em
        uc.FontEx = math32.Round(0.53 * em)
        uc.FontCh = math32.Round(0.45 * em)
        uc.FontRem = math32.Round(uc.Dp(16))
}

// ToDotsFact returns factor needed to convert given unit into raw pixels (dots in DPI)
func (uc *Context) Dots(un Units) float32 {
        if uc.DPI == 0 {
                // log.Printf("gi/units Context was not initialized -- falling back on defaults\n")
                uc.Defaults()
        }
        switch un {
        case UnitEw:
                return 0.01 * uc.Elw
        case UnitEh:
                return 0.01 * uc.Elh
        case UnitPw:
                return 0.01 * uc.Paw
        case UnitPh:
                return 0.01 * uc.Pah
        case UnitEm:
                return uc.FontEm
        case UnitEx:
                return uc.FontEx
        case UnitCh:
                return uc.FontCh
        case UnitRem:
                return uc.FontRem
        case UnitVw:
                return 0.01 * uc.Vpw
        case UnitVh:
                return 0.01 * uc.Vph
        case UnitVmin:
                return 0.01 * min(uc.Vpw, uc.Vph)
        case UnitVmax:
                return 0.01 * max(uc.Vpw, uc.Vph)
        case UnitCm:
                return uc.DPI / CmPerInch
        case UnitMm:
                return uc.DPI / MmPerInch
        case UnitQ:
                return uc.DPI / (4.0 * MmPerInch)
        case UnitIn:
                return uc.DPI
        case UnitPc:
                return uc.DPI / PcPerInch
        case UnitPt:
                return uc.DPI / PtPerInch
        case UnitPx:
                return uc.DPI / PxPerInch
        case UnitDp:
                return uc.DPI / DpPerInch
        case UnitDot:
                return 1.0
        }
        return uc.DPI
}

// ToDots converts value in given units into raw display pixels (dots in DPI)
func (uc *Context) ToDots(val float32, un Units) float32 {
        return val * uc.Dots(un)
}

// PxToDots just converts a value from pixels to dots
func (uc *Context) PxToDots(val float32) float32 {
        return val * uc.Dots(UnitPx)
}

// DotsToPx just converts a value from dots to pixels
func (uc *Context) DotsToPx(val float32) float32 {
        return val / uc.Dots(UnitPx)
}

// Code generated by "core generate"; DO NOT EDIT.

package units

import (
        "cogentcore.org/core/enums"
)

var _UnitsValues = []Units{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}

// UnitsN is the highest valid value for type Units, plus one.
const UnitsN Units = 21

var _UnitsValueMap = map[string]Units{`dp`: 0, `px`: 1, `ew`: 2, `eh`: 3, `pw`: 4, `ph`: 5, `rem`: 6, `em`: 7, `ex`: 8, `ch`: 9, `vw`: 10, `vh`: 11, `vmin`: 12, `vmax`: 13, `cm`: 14, `mm`: 15, `q`: 16, `in`: 17, `pc`: 18, `pt`: 19, `dot`: 20}

var _UnitsDescMap = map[Units]string{0: `UnitDp represents density-independent pixels. 1dp is 1/160 in. Inches are not necessarily the same as actual physical inches, as they depend on the DPI, so dp values may correspond to different physical sizes on different displays, but they will look correct.`, 1: `UnitPx represents logical pixels. 1px is 1/96 in. These are not raw display pixels, for which you should use dots. Dp is a more common unit for general use.`, 2: `UnitEw represents percentage of element width, which is equivalent to CSS % in some contexts.`, 3: `UnitEh represents percentage of element height, which is equivalent to CSS % in some contexts.`, 4: `UnitPw represents percentage of parent width, which is equivalent to CSS % in some contexts.`, 5: `UnitPh represents percentage of parent height, which is equivalent to CSS % in some contexts.`, 6: `UnitRem represents the font size of the root element, which is always 16dp.`, 7: `UnitEm represents the font size of the element.`, 8: `UnitEx represents x-height of the element's font (size of 'x' glyph). It falls back to a default of 0.5em.`, 9: `UnitCh represents width of the '0' glyph in the element's font. It falls back to a default of 0.5em.`, 10: `UnitVw represents percentage of viewport (Scene) width.`, 11: `UnitVh represents percentage of viewport (Scene) height.`, 12: `UnitVmin represents percentage of the smaller dimension of the viewport (Scene).`, 13: `UnitVmax represents percentage of the larger dimension of the viewport (Scene).`, 14: `UnitCm represents logical centimeters. 1cm is 1/2.54 in.`, 15: `UnitMm represents logical millimeters. 1mm is 1/10 cm.`, 16: `UnitQ represents logical quarter-millimeters. 1q is 1/40 cm.`, 17: `UnitIn represents logical inches. 1in is 2.54cm or 96px. This is similar to CSS inches in that it is not necessarily the same as an actual physical inch; it is dependent on the DPI of the display.`, 18: `UnitPc represents logical picas. 1pc is 1/6 in.`, 19: `UnitPt represents points. 1pt is 1/72 in.`, 20: `UnitDot represents real display pixels. They are generally only used internally.`}

var _UnitsMap = map[Units]string{0: `dp`, 1: `px`, 2: `ew`, 3: `eh`, 4: `pw`, 5: `ph`, 6: `rem`, 7: `em`, 8: `ex`, 9: `ch`, 10: `vw`, 11: `vh`, 12: `vmin`, 13: `vmax`, 14: `cm`, 15: `mm`, 16: `q`, 17: `in`, 18: `pc`, 19: `pt`, 20: `dot`}

// String returns the string representation of this Units value.
func (i Units) String() string { return enums.String(i, _UnitsMap) }

// SetString sets the Units value from its string representation,
// and returns an error if the string is invalid.
func (i *Units) SetString(s string) error { return enums.SetString(i, s, _UnitsValueMap, "Units") }

// Int64 returns the Units value as an int64.
func (i Units) Int64() int64 { return int64(i) }

// SetInt64 sets the Units value from an int64.
func (i *Units) SetInt64(in int64) { *i = Units(in) }

// Desc returns the description of the Units value.
func (i Units) Desc() string { return enums.Desc(i, _UnitsDescMap) }

// UnitsValues returns all possible values for the type Units.
func UnitsValues() []Units { return _UnitsValues }

// Values returns all possible values for the type Units.
func (i Units) Values() []enums.Enum { return enums.Values(_UnitsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Units) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Units) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Units") }

// Code generated by "go run gen.go"; DO NOT EDIT.

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package units
        
// Dp returns a new dp value.
// Dp is density-independent pixels. 1dp is 1/160 in. Inches are not necessarily the same as actual physical inches, as they depend on the DPI, so dp values may correspond to different physical sizes on different displays, but they will look correct.
func Dp(value float32) Value {
        return Value{Value: value, Unit: UnitDp}
}

// Dp sets the value in terms of dp.
// Dp is density-independent pixels. 1dp is 1/160 in. Inches are not necessarily the same as actual physical inches, as they depend on the DPI, so dp values may correspond to different physical sizes on different displays, but they will look correct.
func (v *Value) Dp(value float32) {
        v.Value = value
        v.Unit = UnitDp
}

// Dp converts the given dp value to dots.
// Dp is density-independent pixels. 1dp is 1/160 in. Inches are not necessarily the same as actual physical inches, as they depend on the DPI, so dp values may correspond to different physical sizes on different displays, but they will look correct.
func (uc *Context) Dp(value float32) float32 {
        return uc.ToDots(value, UnitDp)
}

// Px returns a new px value.
// Px is logical pixels. 1px is 1/96 in. These are not raw display pixels, for which you should use dots. Dp is a more common unit for general use.
func Px(value float32) Value {
        return Value{Value: value, Unit: UnitPx}
}

// Px sets the value in terms of px.
// Px is logical pixels. 1px is 1/96 in. These are not raw display pixels, for which you should use dots. Dp is a more common unit for general use.
func (v *Value) Px(value float32) {
        v.Value = value
        v.Unit = UnitPx
}

// Px converts the given px value to dots.
// Px is logical pixels. 1px is 1/96 in. These are not raw display pixels, for which you should use dots. Dp is a more common unit for general use.
func (uc *Context) Px(value float32) float32 {
        return uc.ToDots(value, UnitPx)
}

// Ew returns a new ew value.
// Ew is percentage of element width, which is equivalent to CSS % in some contexts.
func Ew(value float32) Value {
        return Value{Value: value, Unit: UnitEw}
}

// Ew sets the value in terms of ew.
// Ew is percentage of element width, which is equivalent to CSS % in some contexts.
func (v *Value) Ew(value float32) {
        v.Value = value
        v.Unit = UnitEw
}

// Ew converts the given ew value to dots.
// Ew is percentage of element width, which is equivalent to CSS % in some contexts.
func (uc *Context) Ew(value float32) float32 {
        return uc.ToDots(value, UnitEw)
}

// Eh returns a new eh value.
// Eh is percentage of element height, which is equivalent to CSS % in some contexts.
func Eh(value float32) Value {
        return Value{Value: value, Unit: UnitEh}
}

// Eh sets the value in terms of eh.
// Eh is percentage of element height, which is equivalent to CSS % in some contexts.
func (v *Value) Eh(value float32) {
        v.Value = value
        v.Unit = UnitEh
}

// Eh converts the given eh value to dots.
// Eh is percentage of element height, which is equivalent to CSS % in some contexts.
func (uc *Context) Eh(value float32) float32 {
        return uc.ToDots(value, UnitEh)
}

// Pw returns a new pw value.
// Pw is percentage of parent width, which is equivalent to CSS % in some contexts.
func Pw(value float32) Value {
        return Value{Value: value, Unit: UnitPw}
}

// Pw sets the value in terms of pw.
// Pw is percentage of parent width, which is equivalent to CSS % in some contexts.
func (v *Value) Pw(value float32) {
        v.Value = value
        v.Unit = UnitPw
}

// Pw converts the given pw value to dots.
// Pw is percentage of parent width, which is equivalent to CSS % in some contexts.
func (uc *Context) Pw(value float32) float32 {
        return uc.ToDots(value, UnitPw)
}

// Ph returns a new ph value.
// Ph is percentage of parent height, which is equivalent to CSS % in some contexts.
func Ph(value float32) Value {
        return Value{Value: value, Unit: UnitPh}
}

// Ph sets the value in terms of ph.
// Ph is percentage of parent height, which is equivalent to CSS % in some contexts.
func (v *Value) Ph(value float32) {
        v.Value = value
        v.Unit = UnitPh
}

// Ph converts the given ph value to dots.
// Ph is percentage of parent height, which is equivalent to CSS % in some contexts.
func (uc *Context) Ph(value float32) float32 {
        return uc.ToDots(value, UnitPh)
}

// Rem returns a new rem value.
// Rem is the font size of the root element, which is always 16dp.
func Rem(value float32) Value {
        return Value{Value: value, Unit: UnitRem}
}

// Rem sets the value in terms of rem.
// Rem is the font size of the root element, which is always 16dp.
func (v *Value) Rem(value float32) {
        v.Value = value
        v.Unit = UnitRem
}

// Rem converts the given rem value to dots.
// Rem is the font size of the root element, which is always 16dp.
func (uc *Context) Rem(value float32) float32 {
        return uc.ToDots(value, UnitRem)
}

// Em returns a new em value.
// Em is the font size of the element.
func Em(value float32) Value {
        return Value{Value: value, Unit: UnitEm}
}

// Em sets the value in terms of em.
// Em is the font size of the element.
func (v *Value) Em(value float32) {
        v.Value = value
        v.Unit = UnitEm
}

// Em converts the given em value to dots.
// Em is the font size of the element.
func (uc *Context) Em(value float32) float32 {
        return uc.ToDots(value, UnitEm)
}

// Ex returns a new ex value.
// Ex is x-height of the element's font (size of 'x' glyph). It falls back to a default of 0.5em.
func Ex(value float32) Value {
        return Value{Value: value, Unit: UnitEx}
}

// Ex sets the value in terms of ex.
// Ex is x-height of the element's font (size of 'x' glyph). It falls back to a default of 0.5em.
func (v *Value) Ex(value float32) {
        v.Value = value
        v.Unit = UnitEx
}

// Ex converts the given ex value to dots.
// Ex is x-height of the element's font (size of 'x' glyph). It falls back to a default of 0.5em.
func (uc *Context) Ex(value float32) float32 {
        return uc.ToDots(value, UnitEx)
}

// Ch returns a new ch value.
// Ch is width of the '0' glyph in the element's font. It falls back to a default of 0.5em.
func Ch(value float32) Value {
        return Value{Value: value, Unit: UnitCh}
}

// Ch sets the value in terms of ch.
// Ch is width of the '0' glyph in the element's font. It falls back to a default of 0.5em.
func (v *Value) Ch(value float32) {
        v.Value = value
        v.Unit = UnitCh
}

// Ch converts the given ch value to dots.
// Ch is width of the '0' glyph in the element's font. It falls back to a default of 0.5em.
func (uc *Context) Ch(value float32) float32 {
        return uc.ToDots(value, UnitCh)
}

// Vw returns a new vw value.
// Vw is percentage of viewport (Scene) width.
func Vw(value float32) Value {
        return Value{Value: value, Unit: UnitVw}
}

// Vw sets the value in terms of vw.
// Vw is percentage of viewport (Scene) width.
func (v *Value) Vw(value float32) {
        v.Value = value
        v.Unit = UnitVw
}

// Vw converts the given vw value to dots.
// Vw is percentage of viewport (Scene) width.
func (uc *Context) Vw(value float32) float32 {
        return uc.ToDots(value, UnitVw)
}

// Vh returns a new vh value.
// Vh is percentage of viewport (Scene) height.
func Vh(value float32) Value {
        return Value{Value: value, Unit: UnitVh}
}

// Vh sets the value in terms of vh.
// Vh is percentage of viewport (Scene) height.
func (v *Value) Vh(value float32) {
        v.Value = value
        v.Unit = UnitVh
}

// Vh converts the given vh value to dots.
// Vh is percentage of viewport (Scene) height.
func (uc *Context) Vh(value float32) float32 {
        return uc.ToDots(value, UnitVh)
}

// Vmin returns a new vmin value.
// Vmin is percentage of the smaller dimension of the viewport (Scene).
func Vmin(value float32) Value {
        return Value{Value: value, Unit: UnitVmin}
}

// Vmin sets the value in terms of vmin.
// Vmin is percentage of the smaller dimension of the viewport (Scene).
func (v *Value) Vmin(value float32) {
        v.Value = value
        v.Unit = UnitVmin
}

// Vmin converts the given vmin value to dots.
// Vmin is percentage of the smaller dimension of the viewport (Scene).
func (uc *Context) Vmin(value float32) float32 {
        return uc.ToDots(value, UnitVmin)
}

// Vmax returns a new vmax value.
// Vmax is percentage of the larger dimension of the viewport (Scene).
func Vmax(value float32) Value {
        return Value{Value: value, Unit: UnitVmax}
}

// Vmax sets the value in terms of vmax.
// Vmax is percentage of the larger dimension of the viewport (Scene).
func (v *Value) Vmax(value float32) {
        v.Value = value
        v.Unit = UnitVmax
}

// Vmax converts the given vmax value to dots.
// Vmax is percentage of the larger dimension of the viewport (Scene).
func (uc *Context) Vmax(value float32) float32 {
        return uc.ToDots(value, UnitVmax)
}

// Cm returns a new cm value.
// Cm is logical centimeters. 1cm is 1/2.54 in.
func Cm(value float32) Value {
        return Value{Value: value, Unit: UnitCm}
}

// Cm sets the value in terms of cm.
// Cm is logical centimeters. 1cm is 1/2.54 in.
func (v *Value) Cm(value float32) {
        v.Value = value
        v.Unit = UnitCm
}

// Cm converts the given cm value to dots.
// Cm is logical centimeters. 1cm is 1/2.54 in.
func (uc *Context) Cm(value float32) float32 {
        return uc.ToDots(value, UnitCm)
}

// Mm returns a new mm value.
// Mm is logical millimeters. 1mm is 1/10 cm.
func Mm(value float32) Value {
        return Value{Value: value, Unit: UnitMm}
}

// Mm sets the value in terms of mm.
// Mm is logical millimeters. 1mm is 1/10 cm.
func (v *Value) Mm(value float32) {
        v.Value = value
        v.Unit = UnitMm
}

// Mm converts the given mm value to dots.
// Mm is logical millimeters. 1mm is 1/10 cm.
func (uc *Context) Mm(value float32) float32 {
        return uc.ToDots(value, UnitMm)
}

// Q returns a new q value.
// Q is logical quarter-millimeters. 1q is 1/40 cm.
func Q(value float32) Value {
        return Value{Value: value, Unit: UnitQ}
}

// Q sets the value in terms of q.
// Q is logical quarter-millimeters. 1q is 1/40 cm.
func (v *Value) Q(value float32) {
        v.Value = value
        v.Unit = UnitQ
}

// Q converts the given q value to dots.
// Q is logical quarter-millimeters. 1q is 1/40 cm.
func (uc *Context) Q(value float32) float32 {
        return uc.ToDots(value, UnitQ)
}

// In returns a new in value.
// In is logical inches. 1in is 2.54cm or 96px. This is similar to CSS inches in that it is not necessarily the same as an actual physical inch; it is dependent on the DPI of the display.
func In(value float32) Value {
        return Value{Value: value, Unit: UnitIn}
}

// In sets the value in terms of in.
// In is logical inches. 1in is 2.54cm or 96px. This is similar to CSS inches in that it is not necessarily the same as an actual physical inch; it is dependent on the DPI of the display.
func (v *Value) In(value float32) {
        v.Value = value
        v.Unit = UnitIn
}

// In converts the given in value to dots.
// In is logical inches. 1in is 2.54cm or 96px. This is similar to CSS inches in that it is not necessarily the same as an actual physical inch; it is dependent on the DPI of the display.
func (uc *Context) In(value float32) float32 {
        return uc.ToDots(value, UnitIn)
}

// Pc returns a new pc value.
// Pc is logical picas. 1pc is 1/6 in.
func Pc(value float32) Value {
        return Value{Value: value, Unit: UnitPc}
}

// Pc sets the value in terms of pc.
// Pc is logical picas. 1pc is 1/6 in.
func (v *Value) Pc(value float32) {
        v.Value = value
        v.Unit = UnitPc
}

// Pc converts the given pc value to dots.
// Pc is logical picas. 1pc is 1/6 in.
func (uc *Context) Pc(value float32) float32 {
        return uc.ToDots(value, UnitPc)
}

// Pt returns a new pt value.
// Pt is points. 1pt is 1/72 in.
func Pt(value float32) Value {
        return Value{Value: value, Unit: UnitPt}
}

// Pt sets the value in terms of pt.
// Pt is points. 1pt is 1/72 in.
func (v *Value) Pt(value float32) {
        v.Value = value
        v.Unit = UnitPt
}

// Pt converts the given pt value to dots.
// Pt is points. 1pt is 1/72 in.
func (uc *Context) Pt(value float32) float32 {
        return uc.ToDots(value, UnitPt)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package units

import (
        "fmt"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
        "golang.org/x/image/math/fixed"
)

// NOTE: we have empty labels for value fields, because there is a natural
// flow of the unit values without it. "{{Value}} {{Unit}}" without labels
// makes sense and provides a nicer end-user experience.

// Value and units, and converted value into raw pixels (dots in DPI)
type Value struct { //types:add

        // Value is the value in terms of the specified unit
        Value float32 `label:""`

        // Unit is the unit used for the value
        Unit Units `label:""`

        // Dots is the computed value in raw pixels (dots in DPI)
        Dots float32 `display:"-"`

        // Custom is a custom function that returns the dots of the value.
        // If it is non-nil, it overrides all other fields.
        // Otherwise, the standard ToDots with the other fields is used.
        Custom func(uc *Context) float32 `display:"-" json:"-" xml:"-" toml:"-" save:"-"`
}

// New creates a new value with the given unit type
func New(val float32, un Units) Value {
        return Value{Value: val, Unit: un}
}

// Set sets the value and units of an existing value
func (v *Value) Set(val float32, un Units) {
        v.Value = val
        v.Unit = un
}

// Zero returns a new zero (0) value.
func Zero() Value {
        return Value{Unit: UnitDot}
}

// Zero sets the value to zero (0).
func (v *Value) Zero() {
        v.Value = 0
        v.Unit = UnitDot
        v.Dots = 0
}

// Dot returns a new dots value.
// Dots are actual real display pixels, which are generally only used internally.
func Dot(val float32) Value {
        return Value{Value: val, Unit: UnitDot, Dots: val}
}

// Dot sets the value directly in terms of dots.
// Dots are actual real display pixels, which are generally only used internally.
func (v *Value) Dot(val float32) {
        v.Value = val
        v.Unit = UnitDot
        v.Dots = val
}

// Custom returns a new custom value that has the dots
// of the value returned by the given function.
func Custom(fun func(uc *Context) float32) Value {
        return Value{Custom: fun}
}

// SetCustom sets the value to be a custom value that has
// the dots of the value returned by the given function.
func (v *Value) SetCustom(fun func(uc *Context) float32) {
        v.Custom = fun
}

// ToDots converts value to raw display pixels (dots as in DPI), setting also
// the Dots field
func (v *Value) ToDots(uc *Context) float32 {
        if v.Custom != nil {
                v.Dots = v.Custom(uc)
        } else {
                v.Dots = uc.ToDots(v.Value, v.Unit)
        }
        return v.Dots
}

// ToDotsFixed converts value to raw display pixels (dots in DPI) in
// fixed-point 26.6 format for rendering
func (v *Value) ToDotsFixed(uc *Context) fixed.Int26_6 {
        return fixed.Int26_6(v.ToDots(uc))
}

// Convert converts value to the given units, given unit context
func (v *Value) Convert(to Units, uc *Context) Value {
        dots := v.ToDots(uc)
        return Value{Value: dots / uc.Dots(to), Unit: to, Dots: dots}
}

// String implements the [fmt.Stringer] interface.
func (v *Value) String() string {
        return fmt.Sprintf("%g%s", v.Value, v.Unit.String())
}

// StringCSS returns the value as a string suitable for CSS
// by changing dp to px and using % if applicable.
func (v Value) StringCSS() string {
        if v.Unit == UnitDp {
                v.Unit = UnitPx // non-pointer so can change directly
        }
        s := v.String()
        if v.Unit == UnitPw || v.Unit == UnitPh || v.Unit == UnitEw || v.Unit == UnitEh {
                s = s[:len(s)-2] + "%"
        }
        return s
}

// SetString sets value from a string
func (v *Value) SetString(str string) error {
        trstr := strings.TrimSpace(strings.Replace(str, "%", "pct", -1))
        sz := len(trstr)
        if sz < 2 {
                vc, err := reflectx.ToFloat(str)
                if err != nil {
                        return fmt.Errorf("(units.Value).SetString: unable to convert string value %q into a number: %w", trstr, err)
                }
                v.Value = float32(vc)
                v.Unit = UnitPx
                return nil
        }
        var ends [4]string
        ends[0] = strings.ToLower(trstr[sz-1:])
        ends[1] = strings.ToLower(trstr[sz-2:])
        if sz > 3 {
                ends[2] = strings.ToLower(trstr[sz-3:])
        }
        if sz > 4 {
                ends[3] = strings.ToLower(trstr[sz-4:])
        }

        var numstr string
        un := UnitPx // default to pixels
        for _, u := range UnitsValues() {
                nm := u.String()
                unsz := len(nm)
                if ends[unsz-1] == nm {
                        numstr = trstr[:sz-unsz]
                        un = u
                        break
                }
        }
        if len(numstr) == 0 { // no units
                numstr = trstr
        }
        var val float32
        trspc := strings.TrimSpace(numstr)
        n, err := fmt.Sscanf(trspc, "%g", &val)
        if err != nil {
                return fmt.Errorf("(units.Value).SetString: error scanning string '%s': %w", trspc, err)
        }
        if n == 0 {
                return fmt.Errorf("(units.Value).SetString: no arguments parsed from string '%s'", trspc)
        }
        v.Set(val, un)
        return nil
}

// StringToValue converts a string to a value representation.
func StringToValue(str string) Value {
        var v Value
        v.SetString(str)
        return v
}

// SetAny sets value from an interface value representation as from map[string]any
// key is optional property key for error message -- always logs the error
func (v *Value) SetAny(iface any, key string) error {
        switch val := iface.(type) {
        case string:
                v.SetString(val)
        case Value:
                *v = val
        case *Value:
                *v = *val
        default: // assume Dp as an implicit default
                valflt, err := reflectx.ToFloat(iface)
                if err == nil {
                        v.Dp(float32(valflt))
                } else {
                        err := fmt.Errorf("units.Value: could not set property %q from value: %v of type: %T: %w", key, val, val, err)
                        return errors.Log(err)
                }
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package units

import (
        "cogentcore.org/core/math32"
)

// XY represents unit Value for X and Y dimensions
type XY struct { //types:add
        // X is the horizontal axis value
        X Value

        // Y is the vertical axis value
        Y Value
}

// ToDots converts value to raw display pixels (dots as in DPI),
// setting also the Dots field
func (xy *XY) ToDots(uc *Context) {
        xy.X.ToDots(uc)
        xy.Y.ToDots(uc)
}

// String implements the fmt.Stringer interface.
func (xy *XY) String() string {
        return "(" + xy.X.String() + ", " + xy.Y.String() + ")"
}

// Zero sets values to 0
func (xy *XY) Zero() {
        xy.X.Zero()
        xy.Y.Zero()
}

// Set sets the x and y values according to the given values.
// No values: set both to 0.
// One value: set both to that value.
// Two values: set x to the first value and y to the second value.
func (xy *XY) Set(v ...Value) {
        switch len(v) {
        case 0:
                var zv Value
                xy.X = zv
                xy.Y = zv
        case 1:
                xy.X = v[0]
                xy.Y = v[0]
        default:
                xy.X = v[0]
                xy.Y = v[1]
        }
}

// Dim returns the value for given dimension
func (xy *XY) Dim(d math32.Dims) Value {
        switch d {
        case math32.X:
                return xy.X
        case math32.Y:
                return xy.Y
        default:
                panic("units.XY dimension invalid")
        }
}

// SetDim sets the value for given dimension
func (xy *XY) SetDim(d math32.Dims, val Value) {
        switch d {
        case math32.X:
                xy.X = val
        case math32.Y:
                xy.Y = val
        default:
                panic("units.XY dimension invalid")
        }
}

// Dots returns the dots values as a math32.Vector2 vector
func (xy *XY) Dots() math32.Vector2 {
        return math32.Vec2(xy.X.Dots, xy.Y.Dots)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package styles

import (
        "fmt"

        "cogentcore.org/core/math32"
)

// XY represents X,Y values
type XY[T any] struct { //types:add
        // X is the horizontal axis value
        X T

        // Y is the vertical axis value
        Y T
}

// String implements the fmt.Stringer interface.
func (xy *XY[T]) String() string {
        return fmt.Sprintf("(%v, %v)", xy.X, xy.Y)
}

// Set sets the X, Y values according to the given values.
// no values: set to 0.
// 1 value: set both to that value.
// 2 values, set X, Y to the two values respectively.
func (xy *XY[T]) Set(v ...T) {
        switch len(v) {
        case 0:
                var zv T
                xy.X = zv
                xy.Y = zv
        case 1:
                xy.X = v[0]
                xy.Y = v[0]
        default:
                xy.X = v[0]
                xy.Y = v[1]
        }
}

// return the value for given dimension
func (xy *XY[T]) Dim(d math32.Dims) T {
        switch d {
        case math32.X:
                return xy.X
        case math32.Y:
                return xy.Y
        default:
                panic("styles.XY dimension invalid")
        }
}

// set the value for given dimension
func (xy *XY[T]) SetDim(d math32.Dims, val T) {
        switch d {
        case math32.X:
                xy.X = val
        case math32.Y:
                xy.Y = val
        default:
                panic("styles.XY dimension invalid")
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/math32"
)

// Circle is a SVG circle
type Circle struct {
        NodeBase

        // position of the center of the circle
        Pos math32.Vector2 `xml:"{cx,cy}"`

        // radius of the circle
        Radius float32 `xml:"r"`
}

func (g *Circle) SVGName() string { return "circle" }

func (g *Circle) Init() {
        g.Radius = 1
}

func (g *Circle) SetNodePos(pos math32.Vector2) {
        g.Pos = pos.SubScalar(g.Radius)
}

func (g *Circle) SetNodeSize(sz math32.Vector2) {
        g.Radius = 0.25 * (sz.X + sz.Y)
}

func (g *Circle) LocalBBox(sv *SVG) math32.Box2 {
        bb := math32.Box2{}
        hlw := 0.5 * g.LocalLineWidth()
        bb.Min = g.Pos.SubScalar(g.Radius + hlw)
        bb.Max = g.Pos.AddScalar(g.Radius + hlw)
        return bb
}

func (g *Circle) Render(sv *SVG) {
        if !g.IsVisible(sv) {
                return
        }
        pc := g.Painter(sv)
        pc.Circle(g.Pos.X, g.Pos.Y, g.Radius)
        pc.Draw()
        g.RenderChildren(sv)
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Circle) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        rot := xf.ExtractRot()
        if rot != 0 || !g.Paint.Transform.IsIdentity() {
                g.Paint.Transform.SetMul(xf) // todo: could be backward
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                g.Pos = xf.MulVector2AsPoint(g.Pos)
                scx, scy := xf.ExtractScale()
                g.Radius *= 0.5 * (scx + scy)
                g.GradientApplyTransform(sv, xf)
        }
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Circle) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        crot := g.Paint.Transform.ExtractRot()
        if rot != 0 || crot != 0 {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // exclude self
                g.Paint.Transform.SetMulCenter(xf, lpt)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, true) // include self
                g.Pos = xf.MulVector2AsPointCenter(g.Pos, lpt)
                scx, scy := xf.ExtractScale()
                g.Radius *= 0.5 * (scx + scy)
                g.GradientApplyTransformPt(sv, xf, lpt)
        }
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Circle) WriteGeom(sv *SVG, dat *[]float32) {
        *dat = slicesx.SetLength(*dat, 3+6)
        (*dat)[0] = g.Pos.X
        (*dat)[1] = g.Pos.Y
        (*dat)[2] = g.Radius
        g.WriteTransform(*dat, 3)
        g.GradientWritePts(sv, dat)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Circle) ReadGeom(sv *SVG, dat []float32) {
        g.Pos.X = dat[0]
        g.Pos.Y = dat[1]
        g.Radius = dat[2]
        g.ReadTransform(dat, 3)
        g.GradientReadPts(sv, dat)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

// todo: needs to be impl

// ClipPath is used for holding a path that renders as a clip path
type ClipPath struct {
        NodeBase
}

func (g *ClipPath) SVGName() string { return "clippath" }

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

//go:generate core generate -add-types -add-funcs

import (
        "path/filepath"
        "strings"

        "cogentcore.org/core/cli"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/svg"
)

func main() { //types:skip
        opts := cli.DefaultOptions("svg", "Command line tools for rendering and creating svg files")
        cli.Run(opts, &Config{}, Render, EmbedImage)
}

type Config struct {

        // Input is the filename of the input file
        Input string `posarg:"0"`

        // Output is the filename of the output file.
        // Defaults to input with the extension changed to the output format.
        Output string `flag:"o,output"`

        // Fill, if specified, indicates to fill the background of
        // the svg with the specified color in CSS format.
        Fill string

        Render RenderConfig `cmd:"render"`
}

type RenderConfig struct {

        // Width is the width of the rendered image
        Width int `posarg:"1"`

        // Height is the height of the rendered image.
        // Defaults to width.
        Height int `posarg:"2" required:"-"`
}

// Render renders the input svg file to the output image file.
//
//cli:cmd -root
func Render(c *Config) error {
        if c.Render.Height == 0 {
                c.Render.Height = c.Render.Width
        }
        sv := svg.NewSVG(math32.Vec2(float32(c.Render.Width), float32(c.Render.Height)))
        err := ApplyFill(c, sv)
        if err != nil {
                return err
        }
        err = sv.OpenXML(c.Input)
        if err != nil {
                return err
        }
        if c.Output == "" {
                c.Output = strings.TrimSuffix(c.Input, filepath.Ext(c.Input)) + ".png"
        }
        return sv.SaveImage(c.Output)
}

// EmbedImage embeds the input image file into the output svg file.
func EmbedImage(c *Config) error {
        sv := svg.NewSVG(math32.Vec2(0, 0))
        err := ApplyFill(c, sv)
        if err != nil {
                return err
        }
        img := svg.NewImage(sv.Root)
        err = img.OpenImage(c.Input, 0, 0)
        if err != nil {
                return err
        }
        sz := img.Pixels.Bounds().Size()
        sv.Root.ViewBox.Size.SetPoint(sz)
        if c.Output == "" {
                c.Output = strings.TrimSuffix(c.Input, filepath.Ext(c.Input)) + ".svg"
        }
        return sv.SaveXML(c.Output)
}

// ApplyFill applies [Config.Fill] to the given [svg.SVG].
func ApplyFill(c *Config, sv *svg.SVG) error { //types:skip
        if c.Fill == "" {
                return nil
        }
        bg, err := gradient.FromString(c.Fill)
        if err != nil {
                return err
        }
        sv.Background = bg
        return nil
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "log"

        "github.com/aymerick/douceur/css"
        "github.com/aymerick/douceur/parser"
)

// StyleSheet is a Node2D node that contains a stylesheet -- property values
// contained in this sheet can be transformed into tree.Properties and set in CSS
// field of appropriate node
type StyleSheet struct {
        NodeBase
        Sheet *css.Stylesheet `copier:"-"`
}

// ParseString parses the string into a StyleSheet of rules, which can then be
// used for extracting properties
func (ss *StyleSheet) ParseString(str string) error {
        pss, err := parser.Parse(str)
        if err != nil {
                log.Printf("styles.StyleSheet ParseString parser error: %v\n", err)
                return err
        }
        ss.Sheet = pss
        return nil
}

// CSSProperties returns the properties for each of the rules in this style sheet,
// suitable for setting the CSS value of a node -- returns nil if empty sheet
func (ss *StyleSheet) CSSProperties() map[string]any {
        if ss.Sheet == nil {
                return nil
        }
        sz := len(ss.Sheet.Rules)
        if sz == 0 {
                return nil
        }
        pr := map[string]any{}
        for _, r := range ss.Sheet.Rules {
                if r.Kind == css.AtRule {
                        continue // not supported
                }
                nd := len(r.Declarations)
                if nd == 0 {
                        continue
                }
                for _, sel := range r.Selectors {
                        sp := map[string]any{}
                        for _, de := range r.Declarations {
                                sp[de.Property] = de.Value
                        }
                        pr[sel] = sp
                }
        }
        return pr
}

////////////////////////////////////////////////////////////////////////////////////////
// MetaData

// MetaData is used for holding meta data info
type MetaData struct {
        NodeBase
        MetaData string
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/math32"
)

// Ellipse is a SVG ellipse
type Ellipse struct {
        NodeBase

        // position of the center of the ellipse
        Pos math32.Vector2 `xml:"{cx,cy}"`

        // radii of the ellipse in the horizontal, vertical axes
        Radii math32.Vector2 `xml:"{rx,ry}"`
}

func (g *Ellipse) SVGName() string { return "ellipse" }

func (g *Ellipse) Init() {
        g.NodeBase.Init()
        g.Radii.Set(1, 1)
}

func (g *Ellipse) SetNodePos(pos math32.Vector2) {
        g.Pos = pos.Sub(g.Radii)
}

func (g *Ellipse) SetNodeSize(sz math32.Vector2) {
        g.Radii = sz.MulScalar(0.5)
}

func (g *Ellipse) LocalBBox(sv *SVG) math32.Box2 {
        bb := math32.Box2{}
        hlw := 0.5 * g.LocalLineWidth()
        bb.Min = g.Pos.Sub(g.Radii.AddScalar(hlw))
        bb.Max = g.Pos.Add(g.Radii.AddScalar(hlw))
        return bb
}

func (g *Ellipse) Render(sv *SVG) {
        if !g.IsVisible(sv) {
                return
        }
        pc := g.Painter(sv)
        pc.Ellipse(g.Pos.X, g.Pos.Y, g.Radii.X, g.Radii.Y)
        pc.Draw()
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Ellipse) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        rot := xf.ExtractRot()
        if rot != 0 || !g.Paint.Transform.IsIdentity() {
                g.Paint.Transform.SetMul(xf)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                g.Pos = xf.MulVector2AsPoint(g.Pos)
                g.Radii = xf.MulVector2AsVector(g.Radii)
                g.GradientApplyTransform(sv, xf)
        }
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Ellipse) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        crot := g.Paint.Transform.ExtractRot()
        if rot != 0 || crot != 0 {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // exclude self
                g.Paint.Transform.SetMulCenter(xf, lpt)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, true) // include self
                g.Pos = xf.MulVector2AsPointCenter(g.Pos, lpt)
                g.Radii = xf.MulVector2AsVector(g.Radii)
                g.GradientApplyTransformPt(sv, xf, lpt)
        }
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Ellipse) WriteGeom(sv *SVG, dat *[]float32) {
        *dat = slicesx.SetLength(*dat, 4+6)
        (*dat)[0] = g.Pos.X
        (*dat)[1] = g.Pos.Y
        (*dat)[2] = g.Radii.X
        (*dat)[3] = g.Radii.Y
        g.WriteTransform(*dat, 4)
        g.GradientWritePts(sv, dat)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Ellipse) ReadGeom(sv *SVG, dat []float32) {
        g.Pos.X = dat[0]
        g.Pos.Y = dat[1]
        g.Radii.X = dat[2]
        g.Radii.Y = dat[3]
        g.ReadTransform(dat, 4)
        g.GradientReadPts(sv, dat)
}

// Code generated by "core generate"; DO NOT EDIT.

package svg

import (
        "cogentcore.org/core/enums"
)

var _ViewBoxAlignsValues = []ViewBoxAligns{0, 1, 2, 3}

// ViewBoxAlignsN is the highest valid value for type ViewBoxAligns, plus one.
const ViewBoxAlignsN ViewBoxAligns = 4

var _ViewBoxAlignsValueMap = map[string]ViewBoxAligns{`mid`: 0, `none`: 1, `min`: 2, `max`: 3}

var _ViewBoxAlignsDescMap = map[ViewBoxAligns]string{0: `align ViewBox.Min with midpoint of Viewport (default)`, 1: `do not preserve uniform scaling (if either X or Y is None, both are treated as such). In this case, the Meet / Slice value is ignored. This is the same as FitFill from styles.ObjectFits`, 2: `align ViewBox.Min with top / left of Viewport`, 3: `align ViewBox.Min+Size with bottom / right of Viewport`}

var _ViewBoxAlignsMap = map[ViewBoxAligns]string{0: `mid`, 1: `none`, 2: `min`, 3: `max`}

// String returns the string representation of this ViewBoxAligns value.
func (i ViewBoxAligns) String() string { return enums.String(i, _ViewBoxAlignsMap) }

// SetString sets the ViewBoxAligns value from its string representation,
// and returns an error if the string is invalid.
func (i *ViewBoxAligns) SetString(s string) error {
        return enums.SetString(i, s, _ViewBoxAlignsValueMap, "ViewBoxAligns")
}

// Int64 returns the ViewBoxAligns value as an int64.
func (i ViewBoxAligns) Int64() int64 { return int64(i) }

// SetInt64 sets the ViewBoxAligns value from an int64.
func (i *ViewBoxAligns) SetInt64(in int64) { *i = ViewBoxAligns(in) }

// Desc returns the description of the ViewBoxAligns value.
func (i ViewBoxAligns) Desc() string { return enums.Desc(i, _ViewBoxAlignsDescMap) }

// ViewBoxAlignsValues returns all possible values for the type ViewBoxAligns.
func ViewBoxAlignsValues() []ViewBoxAligns { return _ViewBoxAlignsValues }

// Values returns all possible values for the type ViewBoxAligns.
func (i ViewBoxAligns) Values() []enums.Enum { return enums.Values(_ViewBoxAlignsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i ViewBoxAligns) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *ViewBoxAligns) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "ViewBoxAligns")
}

var _ViewBoxMeetOrSliceValues = []ViewBoxMeetOrSlice{0, 1}

// ViewBoxMeetOrSliceN is the highest valid value for type ViewBoxMeetOrSlice, plus one.
const ViewBoxMeetOrSliceN ViewBoxMeetOrSlice = 2

var _ViewBoxMeetOrSliceValueMap = map[string]ViewBoxMeetOrSlice{`meet`: 0, `slice`: 1}

var _ViewBoxMeetOrSliceDescMap = map[ViewBoxMeetOrSlice]string{0: `Meet only applies if Align != None (i.e., only for uniform scaling), and means the entire ViewBox is visible within Viewport, and it is scaled up as much as possible to meet the align constraints. This is the same as FitContain from styles.ObjectFits`, 1: `Slice only applies if Align != None (i.e., only for uniform scaling), and means the entire ViewBox is covered by the ViewBox, and the ViewBox is scaled down as much as possible, while still meeting the align constraints. This is the same as FitCover from styles.ObjectFits`}

var _ViewBoxMeetOrSliceMap = map[ViewBoxMeetOrSlice]string{0: `meet`, 1: `slice`}

// String returns the string representation of this ViewBoxMeetOrSlice value.
func (i ViewBoxMeetOrSlice) String() string { return enums.String(i, _ViewBoxMeetOrSliceMap) }

// SetString sets the ViewBoxMeetOrSlice value from its string representation,
// and returns an error if the string is invalid.
func (i *ViewBoxMeetOrSlice) SetString(s string) error {
        return enums.SetString(i, s, _ViewBoxMeetOrSliceValueMap, "ViewBoxMeetOrSlice")
}

// Int64 returns the ViewBoxMeetOrSlice value as an int64.
func (i ViewBoxMeetOrSlice) Int64() int64 { return int64(i) }

// SetInt64 sets the ViewBoxMeetOrSlice value from an int64.
func (i *ViewBoxMeetOrSlice) SetInt64(in int64) { *i = ViewBoxMeetOrSlice(in) }

// Desc returns the description of the ViewBoxMeetOrSlice value.
func (i ViewBoxMeetOrSlice) Desc() string { return enums.Desc(i, _ViewBoxMeetOrSliceDescMap) }

// ViewBoxMeetOrSliceValues returns all possible values for the type ViewBoxMeetOrSlice.
func ViewBoxMeetOrSliceValues() []ViewBoxMeetOrSlice { return _ViewBoxMeetOrSliceValues }

// Values returns all possible values for the type ViewBoxMeetOrSlice.
func (i ViewBoxMeetOrSlice) Values() []enums.Enum { return enums.Values(_ViewBoxMeetOrSliceValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i ViewBoxMeetOrSlice) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *ViewBoxMeetOrSlice) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "ViewBoxMeetOrSlice")
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

// Filter represents SVG filter* elements
type Filter struct {
        NodeBase
        FilterType string
}

func (g *Filter) SVGName() string { return "filter" }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

// Flow represents SVG flow* elements
type Flow struct {
        NodeBase
        FlowType string
}

func (g *Flow) SVGName() string { return "flow" }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "log"
        "strings"

        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
)

/////////////////////////////////////////////////////////////////////////////
//  Gradient

// Gradient is used for holding a specified color gradient.
// The name is the id for lookup in url
type Gradient struct {
        NodeBase

        // the color gradient
        Grad gradient.Gradient

        // name of another gradient to get stops from
        StopsName string
}

// GradientTypeName returns the SVG-style type name of gradient: linearGradient or radialGradient
func (gr *Gradient) GradientTypeName() string {
        if _, ok := gr.Grad.(*gradient.Radial); ok {
                return "radialGradient"
        }
        return "linearGradient"
}

//////////////////////////////////////////////////////////////////////////////
//                SVG gradient management

// GradientByName returns the gradient of given name, stored on SVG node
func (sv *SVG) GradientByName(n Node, grnm string) *Gradient {
        gri := sv.NodeFindURL(n, grnm)
        if gri == nil {
                return nil
        }
        gr, ok := gri.(*Gradient)
        if !ok {
                log.Printf("SVG Found element named: %v but isn't a Gradient type, instead is: %T", grnm, gri)
                return nil
        }
        return gr
}

// GradientApplyTransform applies the given transform to any gradients for this node,
// that are using specific coordinates (not bounding box which is automatic)
func (g *NodeBase) GradientApplyTransform(sv *SVG, xf math32.Matrix2) {
        gi := g.This.(Node)
        gnm := NodePropURL(gi, "fill")
        if gnm != "" {
                gr := sv.GradientByName(gi, gnm)
                if gr != nil {
                        gr.Grad.AsBase().Transform.SetMul(xf) // todo: do the Ctr, unscale version?
                }
        }
        gnm = NodePropURL(gi, "stroke")
        if gnm != "" {
                gr := sv.GradientByName(gi, gnm)
                if gr != nil {
                        gr.Grad.AsBase().Transform.SetMul(xf)
                }
        }
}

// GradientApplyTransformPt applies the given transform with ctr point
// to any gradients for this node, that are using specific coordinates
// (not bounding box which is automatic)
func (g *NodeBase) GradientApplyTransformPt(sv *SVG, xf math32.Matrix2, pt math32.Vector2) {
        gi := g.This.(Node)
        gnm := NodePropURL(gi, "fill")
        if gnm != "" {
                gr := sv.GradientByName(gi, gnm)
                if gr != nil {
                        gr.Grad.AsBase().Transform.SetMulCenter(xf, pt) // todo: ctr off?
                }
        }
        gnm = NodePropURL(gi, "stroke")
        if gnm != "" {
                gr := sv.GradientByName(gi, gnm)
                if gr != nil {
                        gr.Grad.AsBase().Transform.SetMulCenter(xf, pt)
                }
        }
}

// GradientWritePoints writes the gradient points to
// a slice of floating point numbers, appending to end of slice.
func GradientWritePts(gr gradient.Gradient, dat *[]float32) {
        // TODO: do we want this, and is this the right way to structure it?
        if gr == nil {
                return
        }
        gb := gr.AsBase()
        *dat = append(*dat, gb.Transform.XX)
        *dat = append(*dat, gb.Transform.YX)
        *dat = append(*dat, gb.Transform.XY)
        *dat = append(*dat, gb.Transform.YY)
        *dat = append(*dat, gb.Transform.X0)
        *dat = append(*dat, gb.Transform.Y0)

        *dat = append(*dat, gb.Box.Min.X)
        *dat = append(*dat, gb.Box.Min.Y)
        *dat = append(*dat, gb.Box.Max.X)
        *dat = append(*dat, gb.Box.Max.Y)
}

// GradientWritePts writes the geometry of the gradients for this node
// to a slice of floating point numbers, appending to end of slice.
func (g *NodeBase) GradientWritePts(sv *SVG, dat *[]float32) {
        gnm := NodePropURL(g, "fill")
        if gnm != "" {
                gr := sv.GradientByName(g, gnm)
                if gr != nil {
                        GradientWritePts(gr.Grad, dat)
                }
        }
        gnm = NodePropURL(g, "stroke")
        if gnm != "" {
                gr := sv.GradientByName(g, gnm)
                if gr != nil {
                        GradientWritePts(gr.Grad, dat)
                }
        }
}

// GradientReadPoints reads the gradient points from
// a slice of floating point numbers, reading from the end.
func GradientReadPts(gr gradient.Gradient, dat []float32) {
        if gr == nil {
                return
        }
        gb := gr.AsBase()
        sz := len(dat)
        gb.Box.Min.X = dat[sz-4]
        gb.Box.Min.Y = dat[sz-3]
        gb.Box.Max.X = dat[sz-2]
        gb.Box.Max.Y = dat[sz-1]

        gb.Transform.XX = dat[sz-10]
        gb.Transform.YX = dat[sz-9]
        gb.Transform.XY = dat[sz-8]
        gb.Transform.YY = dat[sz-7]
        gb.Transform.X0 = dat[sz-6]
        gb.Transform.Y0 = dat[sz-5]
}

// GradientReadPts reads the geometry of the gradients for this node
// from a slice of floating point numbers, reading from the end.
func (g *NodeBase) GradientReadPts(sv *SVG, dat []float32) {
        gnm := NodePropURL(g, "fill")
        if gnm != "" {
                gr := sv.GradientByName(g, gnm)
                if gr != nil {
                        GradientReadPts(gr.Grad, dat)
                }
        }
        gnm = NodePropURL(g, "stroke")
        if gnm != "" {
                gr := sv.GradientByName(g, gnm)
                if gr != nil {
                        GradientReadPts(gr.Grad, dat)
                }
        }
}

//////////////////////////////////////////////////////////////////////////////
//  Gradient management utilities for creating element-specific grads

// GradientUpdateStops copies stops from StopsName gradient if it is set
func (sv *SVG) GradientUpdateStops(gr *Gradient) {
        if gr.StopsName == "" {
                return
        }
        sgr := sv.GradientByName(gr, gr.StopsName)
        if sgr != nil {
                gr.Grad.AsBase().CopyStopsFrom(sgr.Grad.AsBase())
        }
}

// GradientDeleteForNode deletes the node-specific gradient on given node
// of given name, which can be a full url(# name or just the bare name.
// Returns true if deleted.
func (sv *SVG) GradientDeleteForNode(n Node, grnm string) bool {
        gr := sv.GradientByName(n, grnm)
        if gr == nil || gr.StopsName == "" {
                return false
        }
        unm := NameFromURL(grnm)
        sv.Defs.DeleteChildByName(unm)
        return true
}

// GradientNewForNode adds a new gradient specific to given node
// that points to given stops name.  returns the new gradient
// and the url that points to it (nil if parent svg cannot be found).
// Initializes gradient to use bounding box of object, but using userSpaceOnUse setting
func (sv *SVG) GradientNewForNode(n Node, radial bool, stops string) (*Gradient, string) {
        gr, url := sv.GradientNew(radial)
        gr.StopsName = stops
        gr.Grad.AsBase().SetBox(n.LocalBBox(sv))
        sv.GradientUpdateStops(gr)
        return gr, url
}

// GradientNew adds a new gradient, either linear or radial,
// with a new unique id
func (sv *SVG) GradientNew(radial bool) (*Gradient, string) {
        gnm := ""
        if radial {
                gnm = "radialGradient"
        } else {
                gnm = "linearGradient"
        }
        gr := NewGradient(sv.Defs)
        id := sv.NewUniqueID()
        gr.SetName(NameID(gnm, id))
        url := NameToURL(gnm)
        if radial {
                gr.Grad = gradient.NewRadial()
        } else {
                gr.Grad = gradient.NewLinear()
        }
        return gr, url
}

// GradientUpdateNodeProp ensures that node has a gradient property of given type
func (sv *SVG) GradientUpdateNodeProp(n Node, prop string, radial bool, stops string) (*Gradient, string) {
        ps := n.AsTree().Property(prop)
        if ps == nil {
                gr, url := sv.GradientNewForNode(n, radial, stops)
                n.AsTree().SetProperty(prop, url)
                return gr, url
        }
        pstr := ps.(string)
        trgst := ""
        if radial {
                trgst = "radialGradient"
        } else {
                trgst = "linearGradient"
        }
        url := "url(#" + trgst
        if strings.HasPrefix(pstr, url) {
                gr := sv.GradientByName(n, pstr)
                gr.StopsName = stops
                sv.GradientUpdateStops(gr)
                return gr, NameToURL(gr.Name)
        }
        if strings.HasPrefix(pstr, "url(#") { // wrong kind
                sv.GradientDeleteForNode(n, pstr)
        }
        gr, url := sv.GradientNewForNode(n, radial, stops)
        n.AsTree().SetProperty(prop, url)
        return gr, url
}

// GradientUpdateNodePoints updates the points for node based on current bbox
func (sv *SVG) GradientUpdateNodePoints(n Node, prop string) {
        ps := n.AsTree().Property(prop)
        if ps == nil {
                return
        }
        pstr := ps.(string)
        url := "url(#"
        if !strings.HasPrefix(pstr, url) {
                return
        }
        gr := sv.GradientByName(n, pstr)
        if gr == nil {
                return
        }
        gb := gr.Grad.AsBase()
        gb.SetBox(n.LocalBBox(sv))
        gb.SetTransform(math32.Identity2())
}

// GradientCloneNodeProp creates a new clone of the existing gradient for node
// if set for given property key ("fill" or "stroke").
// returns new gradient.
func (sv *SVG) GradientCloneNodeProp(n Node, prop string) *Gradient {
        ps := n.AsTree().Property(prop)
        if ps == nil {
                return nil
        }
        pstr := ps.(string)
        radial := false
        if strings.HasPrefix(pstr, "url(#radialGradient") {
                radial = true
        } else if !strings.HasPrefix(pstr, "url(#linearGradient") {
                return nil
        }
        gr := sv.GradientByName(n, pstr)
        if gr == nil {
                return nil
        }
        ngr, url := sv.GradientNewForNode(n, radial, gr.StopsName)
        n.AsTree().SetProperty(prop, url)
        gradient.CopyFrom(ngr.Grad, gr.Grad)
        // TODO(kai): should this return ngr or gr? (used to return gr but ngr seems correct)
        return ngr
}

// GradientDeleteNodeProp deletes any existing gradient for node
// if set for given property key ("fill" or "stroke").
// Returns true if deleted.
func (sv *SVG) GradientDeleteNodeProp(n Node, prop string) bool {
        ps := n.AsTree().Property(prop)
        if ps == nil {
                return false
        }
        pstr := ps.(string)
        if !strings.HasPrefix(pstr, "url(#radialGradient") && !strings.HasPrefix(pstr, "url(#linearGradient") {
                return false
        }
        return sv.GradientDeleteForNode(n, pstr)
}

// GradientUpdateAllStops removes any items from Defs that are not actually referred to
// by anything in the current SVG tree.  Returns true if items were removed.
// Does not remove gradients with StopsName = "" with extant stops -- these
// should be removed manually, as they are not automatically generated.
func (sv *SVG) GradientUpdateAllStops() {
        for _, k := range sv.Defs.Children {
                gr, ok := k.(*Gradient)
                if ok {
                        sv.GradientUpdateStops(gr)
                }
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/math32"
)

// Group groups together SVG elements.
// Provides a common transform for all group elements
// and shared style properties.
type Group struct {
        NodeBase
}

func (g *Group) SVGName() string { return "g" }

func (g *Group) EnforceSVGName() bool { return false }

func (g *Group) BBoxes(sv *SVG, parTransform math32.Matrix2) {
        g.BBoxesFromChildren(sv, parTransform)
}

func (g *Group) Render(sv *SVG) {
        if !g.PushContext(sv) {
                return
        }
        pc := g.Painter(sv)
        g.RenderChildren(sv)
        pc.PopContext()
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Group) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        g.Paint.Transform.SetMul(xf)
        g.SetProperty("transform", g.Paint.Transform.String())
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Group) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // group does NOT include self
        g.Paint.Transform.SetMulCenter(xf, lpt)
        g.SetProperty("transform", g.Paint.Transform.String())
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Group) WriteGeom(sv *SVG, dat *[]float32) {
        *dat = slicesx.SetLength(*dat, 6)
        g.WriteTransform(*dat, 0)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Group) ReadGeom(sv *SVG, dat []float32) {
        g.ReadTransform(dat, 0)
}

// Copyright (c) 2021, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "errors"
        "image"
        "log"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/math32"
        "golang.org/x/image/draw"
        "golang.org/x/image/math/f64"
)

// Image is an SVG image (bitmap)
type Image struct {
        NodeBase

        // position of the top-left of the image
        Pos math32.Vector2 `xml:"{x,y}"`

        // rendered size of the image (imposes a scaling on image when it is rendered)
        Size math32.Vector2 `xml:"{width,height}"`

        // file name of image loaded -- set by OpenImage
        Filename string

        // how to scale and align the image
        ViewBox ViewBox `xml:"viewbox"`

        // Pixels are the image pixels, which has imagex.WrapJS already applied.
        Pixels image.Image `xml:"-" json:"-" display:"-"`
}

func (g *Image) SVGName() string { return "image" }

func (g *Image) SetNodePos(pos math32.Vector2) {
        g.Pos = pos
}

func (g *Image) SetNodeSize(sz math32.Vector2) {
        g.Size = sz
}

// pixelsOfSize returns the Pixels as an imagex.Image of given size.
// makes a new one if not already the correct size.
func (g *Image) pixelsOfSize(nwsz image.Point) image.Image {
        if nwsz.X == 0 || nwsz.Y == 0 {
                return nil
        }
        if g.Pixels != nil && g.Pixels.Bounds().Size() == nwsz {
                return g.Pixels
        }
        g.Pixels = imagex.WrapJS(image.NewRGBA(image.Rectangle{Max: nwsz}))
        return g.Pixels
}

// SetImage sets an image for the bitmap, and resizes to the size of the image
// or the specified size. Pass 0 for width and/or height to use the actual image size
// for that dimension. Copies from given image into internal image for this bitmap.
func (g *Image) SetImage(img image.Image, width, height float32) {
        if img == nil {
                return
        }
        img = imagex.Unwrap(img)
        sz := img.Bounds().Size()
        if width <= 0 && height <= 0 {
                cp := imagex.CloneAsRGBA(img)
                g.Pixels = imagex.WrapJS(cp)
                if g.Size.X == 0 && g.Size.Y == 0 {
                        g.Size = math32.FromPoint(sz)
                }
        } else {
                tsz := sz
                transformer := draw.BiLinear
                scx := float32(1)
                scy := float32(1)
                if width > 0 {
                        scx = width / float32(sz.X)
                        tsz.X = int(width)
                }
                if height > 0 {
                        scy = height / float32(sz.Y)
                        tsz.Y = int(height)
                }
                pxi := g.pixelsOfSize(tsz)
                px := imagex.Unwrap(pxi).(*image.RGBA)
                m := math32.Scale2D(scx, scy)
                s2d := f64.Aff3{float64(m.XX), float64(m.XY), float64(m.X0), float64(m.YX), float64(m.YY), float64(m.Y0)}
                transformer.Transform(px, s2d, img, img.Bounds(), draw.Over, nil)
                if g.Size.X == 0 && g.Size.Y == 0 {
                        g.Size = math32.FromPoint(tsz)
                }
        }
}

func (g *Image) DrawImage(sv *SVG) {
        if g.Pixels == nil {
                return
        }
        pc := g.Painter(sv)
        pc.DrawImageScaled(g.Pixels, g.Pos.X, g.Pos.Y, g.Size.X, g.Size.Y)
}

func (g *Image) LocalBBox(sv *SVG) math32.Box2 {
        bb := math32.Box2{}
        bb.Min = g.Pos
        bb.Max = g.Pos.Add(g.Size)
        return bb.Canon()
}

func (g *Image) Render(sv *SVG) {
        vis := g.IsVisible(sv)
        if !vis {
                return
        }
        g.DrawImage(sv)
        g.RenderChildren(sv)
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Image) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        rot := xf.ExtractRot()
        if rot != 0 || !g.Paint.Transform.IsIdentity() {
                g.Paint.Transform.SetMul(xf)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                g.Pos = xf.MulVector2AsPoint(g.Pos)
                g.Size = xf.MulVector2AsVector(g.Size)
        }
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Image) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        crot := g.Paint.Transform.ExtractRot()
        if rot != 0 || crot != 0 {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // exclude self
                g.Paint.Transform.SetMulCenter(xf, lpt)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, true) // include self
                g.Pos = xf.MulVector2AsPointCenter(g.Pos, lpt)
                g.Size = xf.MulVector2AsVector(g.Size)
        }
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Image) WriteGeom(sv *SVG, dat *[]float32) {
        *dat = slicesx.SetLength(*dat, 4+6)
        (*dat)[0] = g.Pos.X
        (*dat)[1] = g.Pos.Y
        (*dat)[2] = g.Size.X
        (*dat)[3] = g.Size.Y
        g.WriteTransform(*dat, 4)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Image) ReadGeom(sv *SVG, dat []float32) {
        g.Pos.X = dat[0]
        g.Pos.Y = dat[1]
        g.Size.X = dat[2]
        g.Size.Y = dat[3]
        g.ReadTransform(dat, 4)
}

// OpenImage opens an image for the bitmap, and resizes to the size of the image
// or the specified size -- pass 0 for width and/or height to use the actual image size
// for that dimension
func (g *Image) OpenImage(filename string, width, height float32) error {
        img, _, err := imagex.Open(filename)
        if err != nil {
                log.Printf("svg.OpenImage -- could not open file: %v, err: %v\n", filename, err)
                return err
        }
        g.Filename = filename
        g.SetImage(img, width, height)
        return nil
}

// SaveImage saves current image to a file
func (g *Image) SaveImage(filename string) error {
        if g.Pixels == nil {
                return errors.New("svg.SaveImage Pixels is nil")
        }
        return imagex.Save(g.Pixels, filename)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// svg parsing is adapted from github.com/srwiley/oksvg:
//
// Copyright 2017 The oksvg Authors. All rights reserved.
//
// created: 2/12/2017 by S.R.Wiley

package svg

import (
        "bufio"
        "encoding/xml"
        "errors"
        "fmt"
        "io"
        "io/fs"
        "log"
        "os"
        "strings"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/base/stack"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/styleprops"
        "cogentcore.org/core/tree"
        "golang.org/x/net/html/charset"
)

// this file contains all the IO-related parsing etc routines

// see https://cogentcore.org/core/ki/wiki/Naming for IO naming conventions
// using standard XML marshal / unmarshal

var (
        errParamMismatch  = errors.New("SVG Parse: Param mismatch")
        errCommandUnknown = errors.New("SVG Parse: Unknown command")
        errZeroLengthID   = errors.New("SVG Parse: zero length id")
        errMissingID      = errors.New("SVG Parse: cannot find id")
)

// OpenXML Opens XML-formatted SVG input from given file
func (sv *SVG) OpenXML(fname string) error {
        filename := fname
        fi, err := os.Stat(filename)
        if err != nil {
                log.Println(err)
                return err
        }
        if fi.IsDir() {
                err := fmt.Errorf("svg.OpenXML: file is a directory: %v", filename)
                log.Println(err)
                return err
        }
        fp, err := os.Open(filename)
        if err != nil {
                log.Println(err)
                return err
        }
        defer fp.Close()
        return sv.ReadXML(bufio.NewReader(fp))
}

// OpenFS Opens XML-formatted SVG input from given file, filesystem FS
func (sv *SVG) OpenFS(fsys fs.FS, fname string) error {
        fp, err := fsys.Open(fname)
        if err != nil {
                return err
        }
        defer fp.Close()
        return sv.ReadXML(bufio.NewReader(fp))
}

// ReadXML reads XML-formatted SVG input from io.Reader, and uses
// xml.Decoder to create the SVG scenegraph for corresponding SVG drawing.
// Removes any existing content in SVG first. To process a byte slice, pass:
// bytes.NewReader([]byte(str)) -- all errors are logged and also returned.
func (sv *SVG) ReadXML(reader io.Reader) error {
        decoder := xml.NewDecoder(reader)
        decoder.Strict = false
        decoder.AutoClose = xml.HTMLAutoClose
        decoder.Entity = xml.HTMLEntity
        decoder.CharsetReader = charset.NewReaderLabel
        var err error
outer:
        for {
                var t xml.Token
                t, err = decoder.Token()
                if err != nil {
                        if err == io.EOF {
                                break
                        }
                        log.Printf("SVG parsing error: %v\n", err)
                        break
                }
                switch se := t.(type) {
                case xml.StartElement:
                        err = sv.UnmarshalXML(decoder, se)
                        break outer
                        // todo: ignore rest?
                }
        }
        if err == io.EOF {
                return nil
        }
        return err
}

// UnmarshalXML unmarshals the svg using xml.Decoder
func (sv *SVG) UnmarshalXML(decoder *xml.Decoder, se xml.StartElement) error {
        start := &se

        sv.DeleteAll()

        curPar := sv.Root.This.(Node) // current parent node into which elements are created
        curSvg := sv.Root
        inTitle := false
        inDesc := false
        inDef := false
        inCSS := false
        var curCSS *StyleSheet
        inTxt := false
        var curTxt *Text
        inTspn := false
        var curTspn *Text
        var defPrevPar Node // previous parent before a def encountered
        var groupStack stack.Stack[string]

        for {
                var t xml.Token
                var err error
                if start != nil {
                        t = *start
                        start = nil
                } else {
                        t, err = decoder.Token()
                }
                if err != nil {
                        if err == io.EOF {
                                break
                        }
                        log.Printf("SVG parsing error: %v\n", err)
                        return err
                }
                switch se := t.(type) {
                case xml.StartElement:
                        nm := se.Name.Local
                        if nm == "g" {
                                name := ""
                                if sv.GroupFilter != "" {
                                        for _, attr := range se.Attr {
                                                if attr.Name.Local != "id" {
                                                        continue
                                                }
                                                name = attr.Value
                                                if name != sv.GroupFilter {
                                                        sv.groupFilterSkip = true
                                                        sv.groupFilterSkipName = name
                                                        // fmt.Println("skipping:", attr.Value, sv.GroupFilter)
                                                        break
                                                        // } else {
                                                        //         fmt.Println("including:", attr.Value, sv.GroupFilter)
                                                }
                                        }
                                }
                                if name == "" {
                                        name = fmt.Sprintf("tmp%d", len(groupStack)+1)
                                }
                                groupStack.Push(name)
                                if sv.groupFilterSkip {
                                        break
                                }
                                curPar = NewGroup(curPar)
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(curPar.AsNodeBase(), attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        default:
                                                curPar.AsTree().SetProperty(attr.Name.Local, attr.Value)
                                        }
                                }
                                break
                        }
                        if sv.groupFilterSkip {
                                break
                        }

                        switch {
                        case nm == "svg":
                                // if curPar != sv.This {
                                //         curPar = curPar.NewChild(TypeSVG, "svg").(Node)
                                // }
                                for _, attr := range se.Attr {
                                        // if SetStdXMLAttr(curSvg, attr.Name.Local, attr.Value) {
                                        //         continue
                                        // }
                                        switch attr.Name.Local {
                                        case "viewBox":
                                                pts := math32.ReadPoints(attr.Value)
                                                if len(pts) != 4 {
                                                        return errParamMismatch
                                                }
                                                curSvg.ViewBox.Min.X = pts[0]
                                                curSvg.ViewBox.Min.Y = pts[1]
                                                curSvg.ViewBox.Size.X = pts[2]
                                                curSvg.ViewBox.Size.Y = pts[3]
                                        case "width":
                                                sv.PhysicalWidth.SetString(attr.Value)
                                                sv.PhysicalWidth.ToDots(&curSvg.Paint.UnitContext)
                                        case "height":
                                                sv.PhysicalHeight.SetString(attr.Value)
                                                sv.PhysicalHeight.ToDots(&curSvg.Paint.UnitContext)
                                        case "preserveAspectRatio":
                                                curSvg.ViewBox.PreserveAspectRatio.SetString(attr.Value)
                                        default:
                                                curPar.AsTree().SetProperty(attr.Name.Local, attr.Value)
                                        }
                                }
                        case nm == "desc":
                                inDesc = true
                        case nm == "title":
                                inTitle = true
                        case nm == "defs":
                                inDef = true
                                defPrevPar = curPar
                                curPar = sv.Defs
                        case nm == "rect":
                                rect := NewRect(curPar)
                                var x, y, w, h, rx, ry float32
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(rect, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "x":
                                                x, err = math32.ParseFloat32(attr.Value)
                                        case "y":
                                                y, err = math32.ParseFloat32(attr.Value)
                                        case "width":
                                                w, err = math32.ParseFloat32(attr.Value)
                                        case "height":
                                                h, err = math32.ParseFloat32(attr.Value)
                                        case "rx":
                                                rx, err = math32.ParseFloat32(attr.Value)
                                        case "ry":
                                                ry, err = math32.ParseFloat32(attr.Value)
                                        default:
                                                rect.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                                rect.Pos.Set(x, y)
                                rect.Size.Set(w, h)
                                rect.Radius.Set(rx, ry)
                        case nm == "circle":
                                circle := NewCircle(curPar)
                                var cx, cy, r float32
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(circle, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "cx":
                                                cx, err = math32.ParseFloat32(attr.Value)
                                        case "cy":
                                                cy, err = math32.ParseFloat32(attr.Value)
                                        case "r":
                                                r, err = math32.ParseFloat32(attr.Value)
                                        default:
                                                circle.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                                circle.Pos.Set(cx, cy)
                                circle.Radius = r
                        case nm == "ellipse":
                                ellipse := NewEllipse(curPar)
                                var cx, cy, rx, ry float32
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(ellipse, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "cx":
                                                cx, err = math32.ParseFloat32(attr.Value)
                                        case "cy":
                                                cy, err = math32.ParseFloat32(attr.Value)
                                        case "rx":
                                                rx, err = math32.ParseFloat32(attr.Value)
                                        case "ry":
                                                ry, err = math32.ParseFloat32(attr.Value)
                                        default:
                                                ellipse.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                                ellipse.Pos.Set(cx, cy)
                                ellipse.Radii.Set(rx, ry)
                        case nm == "line":
                                line := NewLine(curPar)
                                var x1, x2, y1, y2 float32
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(line, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "x1":
                                                x1, err = math32.ParseFloat32(attr.Value)
                                        case "y1":
                                                y1, err = math32.ParseFloat32(attr.Value)
                                        case "x2":
                                                x2, err = math32.ParseFloat32(attr.Value)
                                        case "y2":
                                                y2, err = math32.ParseFloat32(attr.Value)
                                        default:
                                                line.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                                line.Start.Set(x1, y1)
                                line.End.Set(x2, y2)
                        case nm == "polygon":
                                polygon := NewPolygon(curPar)
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(polygon, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "points":
                                                pts := math32.ReadPoints(attr.Value)
                                                if pts != nil {
                                                        sz := len(pts)
                                                        if sz%2 != 0 {
                                                                err = fmt.Errorf("SVG polygon has an odd number of points: %v str: %v", sz, attr.Value)
                                                                log.Println(err)
                                                                return err
                                                        }
                                                        pvec := make([]math32.Vector2, sz/2)
                                                        for ci := 0; ci < sz/2; ci++ {
                                                                pvec[ci].Set(pts[ci*2], pts[ci*2+1])
                                                        }
                                                        polygon.Points = pvec
                                                }
                                        default:
                                                polygon.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                        case nm == "polyline":
                                polyline := NewPolyline(curPar)
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(polyline, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "points":
                                                pts := math32.ReadPoints(attr.Value)
                                                if pts != nil {
                                                        sz := len(pts)
                                                        if sz%2 != 0 {
                                                                err = fmt.Errorf("SVG polyline has an odd number of points: %v str: %v", sz, attr.Value)
                                                                log.Println(err)
                                                                return err
                                                        }
                                                        pvec := make([]math32.Vector2, sz/2)
                                                        for ci := 0; ci < sz/2; ci++ {
                                                                pvec[ci].Set(pts[ci*2], pts[ci*2+1])
                                                        }
                                                        polyline.Points = pvec
                                                }
                                        default:
                                                polyline.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                        case nm == "path":
                                path := NewPath(curPar)
                                for _, attr := range se.Attr {
                                        if attr.Name.Local == "original-d" {
                                                continue
                                        }
                                        if SetStandardXMLAttr(path, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "d":
                                                if sv.GroupFilter != "" && inDef { // font optimization
                                                        path.DataStr = attr.Value
                                                } else {
                                                        path.SetData(attr.Value)
                                                }
                                        default:
                                                path.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                        case nm == "image":
                                img := NewImage(curPar)
                                var x, y, w, h float32
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(img, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "x":
                                                x, err = math32.ParseFloat32(attr.Value)
                                        case "y":
                                                y, err = math32.ParseFloat32(attr.Value)
                                        case "width":
                                                w, err = math32.ParseFloat32(attr.Value)
                                        case "height":
                                                h, err = math32.ParseFloat32(attr.Value)
                                        case "preserveAspectRatio":
                                                img.ViewBox.PreserveAspectRatio.SetString(attr.Value)
                                        case "href":
                                                if len(attr.Value) > 11 && attr.Value[:11] == "data:image/" {
                                                        es := attr.Value[11:]
                                                        fmti := strings.Index(es, ";")
                                                        fm := es[:fmti]
                                                        bs64 := es[fmti+1 : fmti+8]
                                                        if bs64 != "base64," {
                                                                log.Printf("image base64 encoding string not properly formatted: %s\n", bs64)
                                                        }
                                                        eb := []byte(es[fmti+8:])
                                                        im, err := imagex.FromBase64(fm, eb)
                                                        if err != nil {
                                                                log.Println(err)
                                                        } else {
                                                                img.SetImage(im, 0, 0)
                                                        }
                                                } else { // url

                                                }
                                        default:
                                                img.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                                img.Pos.Set(x, y)
                                img.Size.Set(w, h)
                        case nm == "tspan":
                                fallthrough
                        case nm == "text":
                                var txt *Text
                                if se.Name.Local == "text" {
                                        txt = NewText(curPar)
                                        inTxt = true
                                        curTxt = txt
                                } else {
                                        if (inTxt && curTxt != nil) || curPar == nil {
                                                txt = NewText(curTxt)
                                                tree.SetUniqueName(txt)
                                                txt.Pos = curTxt.Pos
                                        } else if curTxt != nil {
                                                txt = NewText(curPar)
                                                tree.SetUniqueName(txt)
                                        }
                                        inTspn = true
                                        curTspn = txt
                                }
                                if txt == nil {
                                        break
                                }
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(txt, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "x":
                                                pts := math32.ReadPoints(attr.Value)
                                                if len(pts) > 1 {
                                                        txt.CharPosX = pts
                                                } else if len(pts) == 1 {
                                                        txt.Pos.X = pts[0]
                                                }
                                        case "y":
                                                pts := math32.ReadPoints(attr.Value)
                                                if len(pts) > 1 {
                                                        txt.CharPosY = pts
                                                } else if len(pts) == 1 {
                                                        txt.Pos.Y = pts[0]
                                                }
                                        case "dx":
                                                pts := math32.ReadPoints(attr.Value)
                                                if len(pts) > 0 {
                                                        txt.CharPosDX = pts
                                                }
                                        case "dy":
                                                pts := math32.ReadPoints(attr.Value)
                                                if len(pts) > 0 {
                                                        txt.CharPosDY = pts
                                                }
                                        case "rotate":
                                                pts := math32.ReadPoints(attr.Value)
                                                if len(pts) > 0 {
                                                        txt.CharRots = pts
                                                }
                                        case "textLength":
                                                tl, err := math32.ParseFloat32(attr.Value)
                                                if err != nil {
                                                        txt.TextLength = tl
                                                }
                                        case "lengthAdjust":
                                                if attr.Value == "spacingAndGlyphs" {
                                                        txt.AdjustGlyphs = true
                                                } else {
                                                        txt.AdjustGlyphs = false
                                                }
                                        default:
                                                txt.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                        case nm == "linearGradient":
                                grad := NewGradient(curPar)
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(grad, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "href":
                                                nm := attr.Value
                                                nm = strings.TrimPrefix(nm, "#")
                                                hr := curPar.AsTree().ChildByName(nm, 0)
                                                if hr != nil {
                                                        if hrg, ok := hr.(*Gradient); ok {
                                                                grad.StopsName = nm
                                                                grad.Grad = gradient.CopyOf(hrg.Grad)
                                                                if _, ok := grad.Grad.(*gradient.Linear); !ok {
                                                                        cp := grad.Grad
                                                                        grad.Grad = gradient.NewLinear()
                                                                        *grad.Grad.AsBase() = *cp.AsBase()
                                                                }
                                                        }
                                                }
                                        }
                                }
                                err = gradient.UnmarshalXML(&grad.Grad, decoder, se)
                                if err != nil {
                                        return err
                                }
                        case nm == "radialGradient":
                                grad := NewGradient(curPar)
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(grad, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "href":
                                                nm := attr.Value
                                                nm = strings.TrimPrefix(nm, "#")
                                                hr := curPar.AsTree().ChildByName(nm, 0)
                                                if hr != nil {
                                                        if hrg, ok := hr.(*Gradient); ok {
                                                                grad.StopsName = nm
                                                                grad.Grad = gradient.CopyOf(hrg.Grad)
                                                                if _, ok := grad.Grad.(*gradient.Radial); !ok {
                                                                        cp := grad.Grad
                                                                        grad.Grad = gradient.NewRadial()
                                                                        *grad.Grad.AsBase() = *cp.AsBase()
                                                                }
                                                        }
                                                }
                                        }
                                }
                                err = gradient.UnmarshalXML(&grad.Grad, decoder, se)
                                if err != nil {
                                        return err
                                }
                        case nm == "style":
                                sty := NewStyleSheet(curPar)
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(sty, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                }
                                inCSS = true
                                curCSS = sty
                                // style code shows up in CharData below
                        case nm == "clipPath":
                                curPar = NewClipPath(curPar)
                                cp := curPar.(*ClipPath)
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(cp, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        default:
                                                cp.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                }
                        case nm == "marker":
                                curPar = NewMarker(curPar)
                                mrk := curPar.(*Marker)
                                var rx, ry float32
                                szx := float32(3)
                                szy := float32(3)
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(mrk, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "refX":
                                                rx, err = math32.ParseFloat32(attr.Value)
                                        case "refY":
                                                ry, err = math32.ParseFloat32(attr.Value)
                                        case "markerWidth":
                                                szx, err = math32.ParseFloat32(attr.Value)
                                        case "markerHeight":
                                                szy, err = math32.ParseFloat32(attr.Value)
                                        case "matrixUnits":
                                                if attr.Value == "strokeWidth" {
                                                        mrk.Units = StrokeWidth
                                                } else {
                                                        mrk.Units = UserSpaceOnUse
                                                }
                                        case "viewBox":
                                                pts := math32.ReadPoints(attr.Value)
                                                if len(pts) != 4 {
                                                        return errParamMismatch
                                                }
                                                mrk.ViewBox.Min.X = pts[0]
                                                mrk.ViewBox.Min.Y = pts[1]
                                                mrk.ViewBox.Size.X = pts[2]
                                                mrk.ViewBox.Size.Y = pts[3]
                                        case "orient":
                                                mrk.Orient = attr.Value
                                        default:
                                                mrk.SetProperty(attr.Name.Local, attr.Value)
                                        }
                                        if err != nil {
                                                return err
                                        }
                                }
                                mrk.RefPos.Set(rx, ry)
                                mrk.Size.Set(szx, szy)
                        case nm == "use":
                                link := gradient.XMLAttr("href", se.Attr)
                                itm := sv.FindNamedElement(link)
                                if itm == nil {
                                        fmt.Println("can't find use:", link)
                                        break
                                }
                                cln := itm.AsTree().Clone().(Node)
                                if cln == nil {
                                        break
                                }
                                curPar.AsTree().AddChild(cln)
                                var xo, yo float64
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(cln.AsNodeBase(), attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        case "x":
                                                xo, _ = reflectx.ToFloat(attr.Value)
                                        case "y":
                                                yo, _ = reflectx.ToFloat(attr.Value)
                                        default:
                                                cln.AsTree().SetProperty(attr.Name.Local, attr.Value)
                                        }
                                }
                                if xo != 0 || yo != 0 {
                                        xf := math32.Translate2D(float32(xo), float32(yo))
                                        if txp, has := cln.AsTree().Properties["transform"]; has {
                                                exf := math32.Identity2()
                                                exf.SetString(txp.(string))
                                                exf = exf.Translate(float32(xo), float32(yo))
                                                cln.AsTree().SetProperty("transform", exf.String())
                                        } else {
                                                cln.AsTree().SetProperty("transform", xf.String())
                                        }
                                }
                                if p, ok := cln.(*Path); ok {
                                        p.SetData(p.DataStr) // defs don't apply paths
                                }
                        case nm == "Work":
                                fallthrough
                        case nm == "RDF":
                                fallthrough
                        case nm == "format":
                                fallthrough
                        case nm == "type":
                                fallthrough
                        case nm == "namedview":
                                fallthrough
                        case nm == "perspective":
                                fallthrough
                        case nm == "grid":
                                fallthrough
                        case nm == "guide":
                                fallthrough
                        case nm == "metadata":
                                curPar = NewMetaData(curPar)
                                md := curPar.(*MetaData)
                                md.Class = nm
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(md, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        default:
                                                curPar.AsTree().SetProperty(attr.Name.Local, attr.Value)
                                        }
                                }
                        case strings.HasPrefix(nm, "flow"):
                                curPar = NewFlow(curPar)
                                md := curPar.(*Flow)
                                md.Class = nm
                                md.FlowType = nm
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(md, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        default:
                                                curPar.AsTree().SetProperty(attr.Name.Local, attr.Value)
                                        }
                                }
                        case strings.HasPrefix(nm, "fe"):
                                fallthrough
                        case strings.HasPrefix(nm, "path-effect"):
                                fallthrough
                        case strings.HasPrefix(nm, "filter"):
                                curPar = NewFilter(curPar)
                                md := curPar.(*Filter)
                                md.Class = nm
                                md.FilterType = nm
                                for _, attr := range se.Attr {
                                        if SetStandardXMLAttr(md, attr.Name.Local, attr.Value) {
                                                continue
                                        }
                                        switch attr.Name.Local {
                                        default:
                                                curPar.AsTree().SetProperty(attr.Name.Local, attr.Value)
                                        }
                                }
                        default:
                                errStr := "SVG Cannot process svg element " + se.Name.Local
                                log.Println(errStr)
                                // IconAutoOpen = false
                        }
                case xml.EndElement:
                        nm := se.Name.Local
                        if nm == "g" {
                                cg := groupStack.Pop()
                                if sv.groupFilterSkip {
                                        if sv.groupFilterSkipName == cg {
                                                // fmt.Println("unskip:", cg)
                                                sv.groupFilterSkip = false
                                        }
                                        break
                                }
                                if curPar == sv.Root.This {
                                        break
                                }
                                if curPar.AsTree().Parent == nil {
                                        break
                                }
                                curPar = curPar.AsTree().Parent.(Node)
                                if curPar == sv.Root.This {
                                        break
                                }
                                r := tree.ParentByType[*Root](curPar)
                                if r != nil {
                                        curSvg = r
                                }
                                break
                        }
                        if sv.groupFilterSkip {
                                break
                        }
                        switch nm {
                        case "title":
                                inTitle = false
                        case "desc":
                                inDesc = false
                        case "style":
                                inCSS = false
                                curCSS = nil
                        case "text":
                                inTxt = false
                                curTxt = nil
                        case "tspan":
                                inTspn = false
                                curTspn = nil
                        case "defs":
                                if inDef {
                                        inDef = false
                                        curPar = defPrevPar
                                }
                        case "rect":
                        case "circle":
                        case "ellipse":
                        case "line":
                        case "polygon":
                        case "polyline":
                        case "path":
                        case "use":
                        case "linearGradient":
                        case "radialGradient":
                        default:
                                if curPar == sv.Root.This {
                                        break
                                }
                                if curPar.AsTree().Parent == nil {
                                        break
                                }
                                curPar = curPar.AsTree().Parent.(Node)
                                if curPar == sv.Root.This {
                                        break
                                }
                                r := tree.ParentByType[*Root](curPar)
                                if r != nil {
                                        curSvg = r
                                }
                        }
                case xml.CharData:
                        // (ok, md := curPar.(*MetaData); ok)
                        trspc := strings.TrimSpace(string(se))
                        switch {
                        // case :
                        //         md.MetaData = string(se)
                        case inTitle:
                                sv.Title += trspc
                        case inDesc:
                                sv.Desc += trspc
                        case inTspn && curTspn != nil:
                                curTspn.Text = trspc
                        case inTxt && curTxt != nil:
                                curTxt.Text = trspc
                        case inCSS && curCSS != nil:
                                curCSS.ParseString(trspc)
                                cp := curCSS.CSSProperties()
                                if cp != nil {
                                        if inDef && defPrevPar != nil {
                                                defPrevPar.AsNodeBase().CSS = cp
                                        } else {
                                                curPar.AsNodeBase().CSS = cp
                                        }
                                }
                        }
                }
        }
        return nil
}

////////////////////////////////////////////////////////////////////////////////////
//   Writing

// SaveXML saves the svg to a XML-encoded file, using WriteXML
func (sv *SVG) SaveXML(fname string) error {
        filename := string(fname)
        fp, err := os.Create(filename)
        if err != nil {
                log.Println(err)
                return err
        }
        defer fp.Close()
        bw := bufio.NewWriter(fp)
        err = sv.WriteXML(bw, true)
        if err != nil {
                log.Println(err)
                return err
        }
        err = bw.Flush()
        if err != nil {
                log.Println(err)
        }
        return err
}

// WriteXML writes XML-formatted SVG output to io.Writer, and uses
// XMLEncoder
func (sv *SVG) WriteXML(wr io.Writer, indent bool) error {
        enc := NewXMLEncoder(wr)
        if indent {
                enc.Indent("", "  ")
        }
        sv.MarshalXMLx(enc, xml.StartElement{})
        enc.Flush()
        return nil
}

func XMLAddAttr(attr *[]xml.Attr, name, val string) {
        at := xml.Attr{}
        at.Name.Local = name
        at.Value = val
        *attr = append(*attr, at)
}

// InkscapeProperties are property keys that should be prefixed with "inkscape:"
var InkscapeProperties = map[string]bool{
        "isstock": true,
        "stockid": true,
}

// MarshalXML encodes just the given node under SVG to XML.
// It returns the name of node, for end tag; if empty, then children will not be
// output.
func MarshalXML(n tree.Node, enc *XMLEncoder, setName string) string {
        if n == nil || n.AsTree().This == nil {
                return ""
        }
        se := xml.StartElement{}
        properties := n.AsTree().Properties
        if n.AsTree().Name != "" {
                XMLAddAttr(&se.Attr, "id", n.AsTree().Name)
        }
        text := "" // if non-empty, contains text to render
        _, issvg := n.(Node)
        _, isgp := n.(*Group)
        _, ismark := n.(*Marker)
        if !isgp {
                if issvg && !ismark {
                        sp := styleprops.ToXMLString(properties)
                        if sp != "" {
                                XMLAddAttr(&se.Attr, "style", sp)
                        }
                        if txp, has := properties["transform"]; has {
                                XMLAddAttr(&se.Attr, "transform", reflectx.ToString(txp))
                        }
                } else {
                        for k, v := range properties {
                                sv := reflectx.ToString(v)
                                if _, has := InkscapeProperties[k]; has {
                                        k = "inkscape:" + k
                                } else if k == "overflow" {
                                        k = "style"
                                        sv = "overflow:" + sv
                                }
                                XMLAddAttr(&se.Attr, k, sv)
                        }
                }
        }
        var sb strings.Builder
        nm := ""
        switch nd := n.(type) {
        case *Path:
                nm = "path"
                nd.DataStr = nd.Data.ToSVG()
                XMLAddAttr(&se.Attr, "d", nd.DataStr)
        case *Group:
                nm = "g"
                if strings.HasPrefix(strings.ToLower(n.AsTree().Name), "layer") {
                }
                for k, v := range properties {
                        sv := reflectx.ToString(v)
                        switch k {
                        case "opacity", "transform":
                                XMLAddAttr(&se.Attr, k, sv)
                        case "groupmode":
                                XMLAddAttr(&se.Attr, "inkscape:groupmode", sv)
                                if st, has := properties["style"]; has {
                                        XMLAddAttr(&se.Attr, "style", reflectx.ToString(st))
                                } else {
                                        XMLAddAttr(&se.Attr, "style", "display:inline")
                                }
                        case "insensitive":
                                if sv == "true" {
                                        XMLAddAttr(&se.Attr, "sodipodi:"+k, sv)
                                }
                        }
                }
        case *Rect:
                nm = "rect"
                XMLAddAttr(&se.Attr, "x", fmt.Sprintf("%g", nd.Pos.X))
                XMLAddAttr(&se.Attr, "y", fmt.Sprintf("%g", nd.Pos.Y))
                XMLAddAttr(&se.Attr, "width", fmt.Sprintf("%g", nd.Size.X))
                XMLAddAttr(&se.Attr, "height", fmt.Sprintf("%g", nd.Size.Y))
        case *Circle:
                nm = "circle"
                XMLAddAttr(&se.Attr, "cx", fmt.Sprintf("%g", nd.Pos.X))
                XMLAddAttr(&se.Attr, "cy", fmt.Sprintf("%g", nd.Pos.Y))
                XMLAddAttr(&se.Attr, "r", fmt.Sprintf("%g", nd.Radius))
        case *Ellipse:
                nm = "ellipse"
                XMLAddAttr(&se.Attr, "cx", fmt.Sprintf("%g", nd.Pos.X))
                XMLAddAttr(&se.Attr, "cy", fmt.Sprintf("%g", nd.Pos.Y))
                XMLAddAttr(&se.Attr, "rx", fmt.Sprintf("%g", nd.Radii.X))
                XMLAddAttr(&se.Attr, "ry", fmt.Sprintf("%g", nd.Radii.Y))
        case *Line:
                nm = "line"
                XMLAddAttr(&se.Attr, "x1", fmt.Sprintf("%g", nd.Start.X))
                XMLAddAttr(&se.Attr, "y1", fmt.Sprintf("%g", nd.Start.Y))
                XMLAddAttr(&se.Attr, "x2", fmt.Sprintf("%g", nd.End.X))
                XMLAddAttr(&se.Attr, "y2", fmt.Sprintf("%g", nd.End.Y))
        case *Polygon:
                nm = "polygon"
                for _, p := range nd.Points {
                        sb.WriteString(fmt.Sprintf("%g,%g ", p.X, p.Y))
                }
                XMLAddAttr(&se.Attr, "points", sb.String())
        case *Polyline:
                nm = "polyline"
                for _, p := range nd.Points {
                        sb.WriteString(fmt.Sprintf("%g,%g ", p.X, p.Y))
                }
                XMLAddAttr(&se.Attr, "points", sb.String())
        case *Text:
                if nd.Text == "" {
                        nm = "text"
                } else {
                        nm = "tspan"
                }
                XMLAddAttr(&se.Attr, "x", fmt.Sprintf("%g", nd.Pos.X))
                XMLAddAttr(&se.Attr, "y", fmt.Sprintf("%g", nd.Pos.Y))
                text = nd.Text
        case *Image:
                if nd.Pixels == nil {
                        return ""
                }
                nm = "image"
                XMLAddAttr(&se.Attr, "x", fmt.Sprintf("%g", nd.Pos.X))
                XMLAddAttr(&se.Attr, "y", fmt.Sprintf("%g", nd.Pos.Y))
                XMLAddAttr(&se.Attr, "width", fmt.Sprintf("%g", nd.Size.X))
                XMLAddAttr(&se.Attr, "height", fmt.Sprintf("%g", nd.Size.Y))
                XMLAddAttr(&se.Attr, "preserveAspectRatio", nd.ViewBox.PreserveAspectRatio.String())
                ib, fmt := imagex.ToBase64PNG(nd.Pixels)
                XMLAddAttr(&se.Attr, "href", "data:"+fmt+";base64,"+string(imagex.Base64SplitLines(ib)))
        case *MetaData:
                if strings.HasPrefix(nd.Name, "namedview") {
                        nm = "sodipodi:namedview"
                } else if strings.HasPrefix(nd.Name, "grid") {
                        nm = "inkscape:grid"
                }
        case *Gradient:
                MarshalXMLGradient(nd, nd.Name, enc)
                return "" // exclude -- already written
        case *Marker:
                nm = "marker"
                XMLAddAttr(&se.Attr, "refX", fmt.Sprintf("%g", nd.RefPos.X))
                XMLAddAttr(&se.Attr, "refY", fmt.Sprintf("%g", nd.RefPos.Y))
                XMLAddAttr(&se.Attr, "orient", nd.Orient)
        case *Filter:
                return "" // not yet supported
        case *StyleSheet:
                nm = "style"
        default:
                nm = n.AsTree().NodeType().Name
        }
        se.Name.Local = nm
        if setName != "" {
                se.Name.Local = setName
        }
        enc.EncodeToken(se)
        if text != "" {
                cd := xml.CharData([]byte(text))
                enc.EncodeToken(cd)
        }
        return se.Name.Local
}

// MarshalXMLGradient adds the XML for the given gradient to the given encoder.
// This is not in [cogentcore.org/core/colors/gradient] because it uses a lot of SVG
// and XML infrastructure defined here.
func MarshalXMLGradient(n *Gradient, name string, enc *XMLEncoder) {
        gr := n.Grad
        if gr == nil {
                return
        }
        gb := gr.AsBase()
        me := xml.StartElement{}
        XMLAddAttr(&me.Attr, "id", name)

        linear := true
        if _, ok := gr.(*gradient.Radial); ok {
                linear = false
                me.Name.Local = "radialGradient"
        } else {
                me.Name.Local = "linearGradient"
        }

        if linear {
                // must be non-zero to add
                if gb.Box != (math32.Box2{}) {
                        XMLAddAttr(&me.Attr, "x1", fmt.Sprintf("%g", gb.Box.Min.X))
                        XMLAddAttr(&me.Attr, "y1", fmt.Sprintf("%g", gb.Box.Min.Y))
                        XMLAddAttr(&me.Attr, "x2", fmt.Sprintf("%g", gb.Box.Max.X))
                        XMLAddAttr(&me.Attr, "y2", fmt.Sprintf("%g", gb.Box.Max.Y))
                }
        } else {
                r := gr.(*gradient.Radial)
                // must be non-zero to add
                if r.Center != (math32.Vector2{}) {
                        XMLAddAttr(&me.Attr, "cx", fmt.Sprintf("%g", r.Center.X))
                        XMLAddAttr(&me.Attr, "cy", fmt.Sprintf("%g", r.Center.Y))
                }
                if r.Focal != (math32.Vector2{}) {
                        XMLAddAttr(&me.Attr, "fx", fmt.Sprintf("%g", r.Focal.X))
                        XMLAddAttr(&me.Attr, "fy", fmt.Sprintf("%g", r.Focal.Y))
                }
                if r.Radius != (math32.Vector2{}) {
                        XMLAddAttr(&me.Attr, "r", fmt.Sprintf("%g", max(r.Radius.X, r.Radius.Y)))
                }
        }
        XMLAddAttr(&me.Attr, "gradientUnits", gb.Units.String())
        // pad is default
        if gb.Spread != gradient.Pad {
                XMLAddAttr(&me.Attr, "spreadMethod", gb.Spread.String())
        }

        if gb.Transform != math32.Identity2() {
                XMLAddAttr(&me.Attr, "gradientTransform", fmt.Sprintf("matrix(%g,%g,%g,%g,%g,%g)", gb.Transform.XX, gb.Transform.YX, gb.Transform.XY, gb.Transform.YY, gb.Transform.X0, gb.Transform.Y0))
        }

        if n.StopsName != "" {
                XMLAddAttr(&me.Attr, "href", "#"+n.StopsName)
        }

        enc.EncodeToken(me)
        if n.StopsName == "" {
                for _, gs := range gb.Stops {
                        se := xml.StartElement{}
                        se.Name.Local = "stop"
                        clr := gs.Color
                        hs := colors.AsHex(clr)[:7] // get rid of transparency
                        XMLAddAttr(&se.Attr, "style", fmt.Sprintf("stop-color:%s;stop-opacity:%g;", hs, float32(colors.AsRGBA(clr).A)/255))
                        XMLAddAttr(&se.Attr, "offset", fmt.Sprintf("%g", gs.Pos))
                        enc.EncodeToken(se)
                        enc.WriteEnd(se.Name.Local)
                }
        }
        enc.WriteEnd(me.Name.Local)
}

// MarshalXMLTree encodes the given node and any children to XML.
// It returns any error, and name of element that enc.WriteEnd() should be
// called with; allows for extra elements to be added at end of list.
func MarshalXMLTree(n Node, enc *XMLEncoder, setName string) (string, error) {
        name := MarshalXML(n, enc, setName)
        if name == "" {
                return "", nil
        }
        for _, k := range n.AsTree().Children {
                kn := k.(Node)
                if setName == "defs" {
                        if _, ok := kn.(*Path); ok { // skip paths in defs b/c just for use and copied
                                continue
                        }
                }
                knm, err := MarshalXMLTree(kn, enc, "")
                if knm != "" {
                        enc.WriteEnd(knm)
                }
                if err != nil {
                        return name, err
                }
        }
        return name, nil
}

// MarshalXMLx marshals the svg using XMLEncoder
func (sv *SVG) MarshalXMLx(enc *XMLEncoder, se xml.StartElement) error {
        me := xml.StartElement{}
        me.Name.Local = "svg"
        // TODO: what makes sense for PhysicalWidth and PhysicalHeight here?
        if sv.PhysicalWidth.Value > 0 {
                XMLAddAttr(&me.Attr, "width", fmt.Sprintf("%g", sv.PhysicalWidth.Value))
        }
        if sv.PhysicalHeight.Value > 0 {
                XMLAddAttr(&me.Attr, "height", fmt.Sprintf("%g", sv.PhysicalHeight.Value))
        }
        XMLAddAttr(&me.Attr, "viewBox", fmt.Sprintf("%g %g %g %g", sv.Root.ViewBox.Min.X, sv.Root.ViewBox.Min.Y, sv.Root.ViewBox.Size.X, sv.Root.ViewBox.Size.Y))
        XMLAddAttr(&me.Attr, "xmlns:inkscape", "http://www.inkscape.org/namespaces/inkscape")
        XMLAddAttr(&me.Attr, "xmlns:sodipodi", "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd")
        XMLAddAttr(&me.Attr, "xmlns", "http://www.w3.org/2000/svg")
        enc.EncodeToken(me)

        dnm, err := MarshalXMLTree(sv.Defs, enc, "defs")
        enc.WriteEnd(dnm)

        for _, k := range sv.Root.Children {
                var knm string
                knm, err = MarshalXMLTree(k.(Node), enc, "")
                if knm != "" {
                        enc.WriteEnd(knm)
                }
                if err != nil {
                        break
                }
        }

        ed := xml.EndElement{}
        ed.Name = me.Name
        enc.EncodeToken(ed)
        return err
}

// SetStandardXMLAttr sets standard attributes of node given XML-style name /
// attribute values (e.g., from parsing XML / SVG files); returns true if handled.
func SetStandardXMLAttr(ni Node, name, val string) bool {
        nb := ni.AsNodeBase()
        switch name {
        case "id":
                nb.SetName(val)
                return true
        case "class":
                nb.Class = val
                return true
        case "style":
                if nb.Properties == nil {
                        nb.Properties = make(map[string]any)
                }
                styleprops.FromXMLString(val, nb.Properties)
                return true
        }
        return false
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/math32"
)

// Line is a SVG line
type Line struct {
        NodeBase

        // position of the start of the line
        Start math32.Vector2 `xml:"{x1,y1}"`

        // position of the end of the line
        End math32.Vector2 `xml:"{x2,y2}"`
}

func (g *Line) SVGName() string { return "line" }

func (g *Line) Init() {
        g.NodeBase.Init()
        g.End.Set(1, 1)
}

func (g *Line) SetPos(pos math32.Vector2) {
        g.Start = pos
}

func (g *Line) SetSize(sz math32.Vector2) {
        g.End = g.Start.Add(sz)
}

func (g *Line) LocalBBox(sv *SVG) math32.Box2 {
        bb := math32.B2Empty()
        bb.ExpandByPoint(g.Start)
        bb.ExpandByPoint(g.End)
        hlw := 0.5 * g.LocalLineWidth()
        bb.Min.SetSubScalar(hlw)
        bb.Max.SetAddScalar(hlw)
        return bb
}

func (g *Line) Render(sv *SVG) {
        if !g.IsVisible(sv) {
                return
        }
        pc := g.Painter(sv)
        pc.Line(g.Start.X, g.Start.Y, g.End.X, g.End.Y)
        pc.Draw()

        g.PushContext(sv)
        if mrk := sv.MarkerByName(g, "marker-start"); mrk != nil {
                ang := math32.Atan2(g.End.Y-g.Start.Y, g.End.X-g.Start.X)
                mrk.RenderMarker(sv, g.Start, ang, g.Paint.Stroke.Width.Dots)
        }
        if mrk := sv.MarkerByName(g, "marker-end"); mrk != nil {
                ang := math32.Atan2(g.End.Y-g.Start.Y, g.End.X-g.Start.X)
                mrk.RenderMarker(sv, g.End, ang, g.Paint.Stroke.Width.Dots)
        }
        pc.PopContext()
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Line) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        rot := xf.ExtractRot()
        if rot != 0 || !g.Paint.Transform.IsIdentity() {
                g.Paint.Transform.SetMul(xf)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                g.Start = xf.MulVector2AsPoint(g.Start)
                g.End = xf.MulVector2AsPoint(g.End)
                g.GradientApplyTransform(sv, xf)
        }
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Line) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        crot := g.Paint.Transform.ExtractRot()
        if rot != 0 || crot != 0 {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // exclude self
                g.Paint.Transform.SetMulCenter(xf, lpt)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, true) // include self
                g.Start = xf.MulVector2AsPointCenter(g.Start, lpt)
                g.End = xf.MulVector2AsPointCenter(g.End, lpt)
                g.GradientApplyTransformPt(sv, xf, lpt)
        }
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Line) WriteGeom(sv *SVG, dat *[]float32) {
        *dat = slicesx.SetLength(*dat, 4+6)
        (*dat)[0] = g.Start.X
        (*dat)[1] = g.Start.Y
        (*dat)[2] = g.End.X
        (*dat)[3] = g.End.Y
        g.WriteTransform(*dat, 4)
        g.GradientWritePts(sv, dat)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Line) ReadGeom(sv *SVG, dat []float32) {
        g.Start.X = dat[0]
        g.Start.Y = dat[1]
        g.End.X = dat[2]
        g.End.Y = dat[3]
        g.ReadTransform(dat, 4)
        g.GradientReadPts(sv, dat)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "log"

        "cogentcore.org/core/math32"
)

// Marker represents marker elements that can be drawn along paths (arrow heads, etc)
type Marker struct {
        NodeBase

        // reference position to align the vertex position with, specified in ViewBox coordinates
        RefPos math32.Vector2 `xml:"{refX,refY}"`

        // size of marker to render, in Units units
        Size math32.Vector2 `xml:"{markerWidth,markerHeight}"`

        // units to use
        Units MarkerUnits `xml:"markerUnits"`

        // viewbox defines the internal coordinate system for the drawing elements within the marker
        ViewBox ViewBox

        // orientation of the marker -- either 'auto' or an angle
        Orient string `xml:"orient"`

        // current vertex position
        VertexPos math32.Vector2

        // current vertex angle in radians
        VertexAngle float32

        // current stroke width
        StrokeWidth float32

        // net transform computed from settings and current values -- applied prior to rendering
        Transform math32.Matrix2

        // effective size for actual rendering
        EffSize math32.Vector2
}

func (g *Marker) SVGName() string { return "marker" }

func (g *Marker) EnforceSVGName() bool { return false }

// MarkerUnits specifies units to use for svg marker elements
type MarkerUnits int32 //enum: enum

const (
        StrokeWidth MarkerUnits = iota
        UserSpaceOnUse
        MarkerUnitsN
)

// RenderMarker renders the marker using given vertex position, angle (in
// radians), and stroke width
func (mrk *Marker) RenderMarker(sv *SVG, vertexPos math32.Vector2, vertexAng, strokeWidth float32) {
        mrk.VertexPos = vertexPos
        mrk.VertexAngle = vertexAng
        mrk.StrokeWidth = strokeWidth
        if mrk.Units == StrokeWidth {
                mrk.EffSize = mrk.Size.MulScalar(strokeWidth)
        } else {
                mrk.EffSize = mrk.Size
        }

        ang := vertexAng
        if mrk.Orient != "auto" {
                ang, _ = math32.ParseAngle32(mrk.Orient)
        }
        if mrk.ViewBox.Size == (math32.Vector2{}) {
                mrk.ViewBox.Size = math32.Vec2(3, 3)
        }
        mrk.Transform = math32.Rotate2D(ang).Scale(mrk.EffSize.X/mrk.ViewBox.Size.X, mrk.EffSize.Y/mrk.ViewBox.Size.Y).Translate(-mrk.RefPos.X, -mrk.RefPos.Y)
        mrk.Transform.X0 += vertexPos.X
        mrk.Transform.Y0 += vertexPos.Y

        mrk.Paint.Transform = mrk.Transform

        // fmt.Println("render marker:", mrk.Name, strokeWidth, mrk.EffSize, mrk.Transform)
        mrk.Render(sv)
}

func (g *Marker) BBoxes(sv *SVG, parTransform math32.Matrix2) {
        g.BBoxesFromChildren(sv, parTransform)
}

func (g *Marker) Render(sv *SVG) {
        pc := g.Painter(sv)
        pc.PushContext(&g.Paint, nil)
        g.RenderChildren(sv)
        pc.PopContext()
}

////////  SVG marker management

// MarkerByName finds marker property of given name, or generic "marker"
// type, and if set, attempts to find that marker and return it
func (sv *SVG) MarkerByName(n Node, marker string) *Marker {
        url := NodePropURL(n, marker)
        if url == "" {
                url = NodePropURL(n, "marker")
        }
        if url == "" {
                return nil
        }
        mrkn := sv.NodeFindURL(n, url)
        if mrkn == nil {
                return nil
        }
        mrk, ok := mrkn.(*Marker)
        if !ok {
                log.Printf("SVG Found element named: %v but isn't a Marker type, instead is: %T", url, mrkn)
                return nil
        }
        return mrk
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "fmt"
        "image"
        "maps"
        "reflect"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/tree"
)

// Node is the interface for all SVG nodes.
type Node interface {
        tree.Node

        // AsNodeBase returns the [NodeBase] for our node, which gives
        // access to all the base-level data structures and methods
        // without requiring interface methods.
        AsNodeBase() *NodeBase

        // BBoxes computes BBox and VisBBox, prior to render.
        BBoxes(sv *SVG, parTransform math32.Matrix2)

        // Render draws the node to the svg image.
        Render(sv *SVG)

        // LocalBBox returns the bounding box of node in local dimensions.
        LocalBBox(sv *SVG) math32.Box2

        // SetNodePos sets the upper left effective position of this element, in local dimensions.
        SetNodePos(pos math32.Vector2)

        // SetNodeSize sets the overall effective size of this element, in local dimensions.
        SetNodeSize(sz math32.Vector2)

        // ApplyTransform applies the given 2D transform to the geometry of this node
        // this just does a direct transform multiplication on coordinates.
        ApplyTransform(sv *SVG, xf math32.Matrix2)

        // ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
        // relative to given point.  Trans translation and point are in top-level coordinates,
        // so must be transformed into local coords first.
        // Point is upper left corner of selection box that anchors the translation and scaling,
        // and for rotation it is the center point around which to rotate.
        ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2)

        // WriteGeom writes the geometry of the node to a slice of floating point numbers
        // the length and ordering of which is specific to each node type.
        // Slice must be passed and will be resized if not the correct length.
        WriteGeom(sv *SVG, dat *[]float32)

        // ReadGeom reads the geometry of the node from a slice of floating point numbers
        // the length and ordering of which is specific to each node type.
        ReadGeom(sv *SVG, dat []float32)

        // SVGName returns the SVG element name (e.g., "rect", "path" etc).
        SVGName() string

        // EnforceSVGName returns true if in general this element should
        // be named with its SVGName plus a unique id.
        // Groups and Markers are false.
        EnforceSVGName() bool
}

// NodeBase is the base type for all elements within an SVG tree.
// It implements the [Node] interface and contains the core functionality.
type NodeBase struct {
        tree.NodeBase

        // Class contains user-defined class name(s) used primarily for attaching
        // CSS styles to different display elements.
        // Multiple class names can be used to combine properties;
        // use spaces to separate per css standard.
        Class string

        // CSS is the cascading style sheet at this level.
        // These styles apply here and to everything below, until superceded.
        // Use .class and #name Properties elements to apply entire styles
        // to given elements, and type for element type.
        CSS map[string]any `xml:"css" set:"-"`

        // CSSAgg is the aggregated css properties from all higher nodes down to this node.
        CSSAgg map[string]any `copier:"-" json:"-" xml:"-" set:"-" display:"no-inline"`

        // BBox is the bounding box for the node within the SVG Pixels image.
        // This one can be outside the visible range of the SVG image.
        // VisBBox is intersected and only shows visible portion.
        BBox image.Rectangle `copier:"-" json:"-" xml:"-" set:"-"`

        // VisBBox is the visible bounding box for the node intersected with the SVG image geometry.
        VisBBox image.Rectangle `copier:"-" json:"-" xml:"-" set:"-"`

        // Paint is the paint style information for this node.
        Paint styles.Paint `json:"-" xml:"-" set:"-"`

        // isDef is whether this is in [SVG.Defs].
        isDef bool
}

func (g *NodeBase) AsNodeBase() *NodeBase {
        return g
}

func (g *NodeBase) SVGName() string {
        return "base"
}

func (g *NodeBase) EnforceSVGName() bool {
        return true
}

func (g *NodeBase) SetPos(pos math32.Vector2) {
}

func (g *NodeBase) SetSize(sz math32.Vector2) {
}

func (g *NodeBase) LocalBBox(sv *SVG) math32.Box2 {
        bb := math32.Box2{}
        return bb
}

func (n *NodeBase) BaseInterface() reflect.Type {
        return reflect.TypeOf((*NodeBase)(nil)).Elem()
}

func (g *NodeBase) PaintStyle() *styles.Paint {
        return &g.Paint
}

func (g *NodeBase) Init() {
        g.Paint.Defaults()
}

// SetColorProperties sets color property from a string representation.
// It breaks color alpha out as opacity.  prop is either "stroke" or "fill"
func (g *NodeBase) SetColorProperties(prop, color string) {
        clr := errors.Log1(colors.FromString(color))
        g.SetProperty(prop+"-opacity", fmt.Sprintf("%g", float32(clr.A)/255))
        // we have consumed the A via opacity, so we reset it to 255
        clr.A = 255
        g.SetProperty(prop, colors.AsHex(clr))
}

// ParentTransform returns the full compounded 2D transform matrix for all
// of the parents of this node. If self is true, then include our
// own transform too.
func (g *NodeBase) ParentTransform(self bool) math32.Matrix2 {
        pars := []Node{}
        xf := math32.Identity2()
        n := g.This.(Node)
        for {
                if n.AsTree().Parent == nil {
                        break
                }
                n = n.AsTree().Parent.(Node)
                pars = append(pars, n)
        }
        np := len(pars)
        if np > 0 {
                xf = pars[np-1].AsNodeBase().PaintStyle().Transform
        }
        for i := np - 2; i >= 0; i-- {
                n := pars[i]
                xf.SetMul(n.AsNodeBase().PaintStyle().Transform)
        }
        if self {
                xf.SetMul(g.Paint.Transform)
        }
        return xf
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// this just does a direct transform multiplication on coordinates.
func (g *NodeBase) ApplyTransform(sv *SVG, xf math32.Matrix2) {
}

// DeltaTransform computes the net transform matrix for given delta transform parameters
// and the transformed version of the reference point. If self is true, then
// include the current node self transform, otherwise don't. Groups do not
// but regular rendering nodes do.
func (g *NodeBase) DeltaTransform(trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2, self bool) (math32.Matrix2, math32.Vector2) {
        mxi := g.ParentTransform(self)
        mxi = mxi.Inverse()
        lpt := mxi.MulVector2AsPoint(pt)
        ldel := mxi.MulVector2AsVector(trans)
        xf := math32.Scale2D(scale.X, scale.Y).Rotate(rot)
        xf.X0 = ldel.X
        xf.Y0 = ldel.Y
        return xf, lpt
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *NodeBase) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
}

// WriteTransform writes the node transform to slice at starting index.
// slice must already be allocated sufficiently.
func (g *NodeBase) WriteTransform(dat []float32, idx int) {
        dat[idx+0] = g.Paint.Transform.XX
        dat[idx+1] = g.Paint.Transform.YX
        dat[idx+2] = g.Paint.Transform.XY
        dat[idx+3] = g.Paint.Transform.YY
        dat[idx+4] = g.Paint.Transform.X0
        dat[idx+5] = g.Paint.Transform.Y0
}

// ReadTransform reads the node transform from slice at starting index.
func (g *NodeBase) ReadTransform(dat []float32, idx int) {
        g.Paint.Transform.XX = dat[idx+0]
        g.Paint.Transform.YX = dat[idx+1]
        g.Paint.Transform.XY = dat[idx+2]
        g.Paint.Transform.YY = dat[idx+3]
        g.Paint.Transform.X0 = dat[idx+4]
        g.Paint.Transform.Y0 = dat[idx+5]
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *NodeBase) WriteGeom(sv *SVG, dat *[]float32) {
        *dat = slicesx.SetLength(*dat, 6)
        g.WriteTransform(*dat, 0)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *NodeBase) ReadGeom(sv *SVG, dat []float32) {
        g.ReadTransform(dat, 0)
}

// SVGWalkDown does [tree.NodeBase.WalkDown] on given node using given walk function
// with SVG Node parameters.
func SVGWalkDown(n Node, fun func(sn Node, snb *NodeBase) bool) {
        n.AsTree().WalkDown(func(n tree.Node) bool {
                sn := n.(Node)
                return fun(sn, sn.AsNodeBase())
        })
}

// SVGWalkDownNoDefs does [tree.Node.WalkDown] on given node using given walk function
// with SVG Node parameters.  Automatically filters Defs nodes (IsDef) and MetaData,
// i.e., it only processes concrete graphical nodes.
func SVGWalkDownNoDefs(n Node, fun func(sn Node, snb *NodeBase) bool) {
        n.AsTree().WalkDown(func(cn tree.Node) bool {
                sn := cn.(Node)
                snb := sn.AsNodeBase()
                _, md := sn.(*MetaData)
                if snb.isDef || md {
                        return tree.Break
                }
                return fun(sn, snb)
        })
}

// FirstNonGroupNode returns the first item that is not a group
// recursing into groups until a non-group item is found.
func FirstNonGroupNode(n Node) Node {
        var ngn Node
        SVGWalkDownNoDefs(n, func(sn Node, snb *NodeBase) bool {
                if _, isgp := sn.(*Group); isgp {
                        return tree.Continue
                }
                ngn = sn
                return tree.Break
        })
        return ngn
}

// NodesContainingPoint returns all Nodes with Bounding Box that contains
// given point, optionally only those that are terminal nodes (no leaves).
// Excludes the starting node.
func NodesContainingPoint(n Node, pt image.Point, leavesOnly bool) []Node {
        var cn []Node
        SVGWalkDown(n, func(sn Node, snb *NodeBase) bool {
                if sn == n {
                        return tree.Continue
                }
                if leavesOnly && snb.HasChildren() {
                        return tree.Continue
                }
                if snb.Paint.Off {
                        return tree.Break
                }
                if pt.In(snb.BBox) {
                        cn = append(cn, sn)
                }
                return tree.Continue
        })
        return cn
}

//////// Standard Node infrastructure

// Style styles the Paint values directly from node properties
func (g *NodeBase) Style(sv *SVG) {
        pc := &g.Paint
        pc.Defaults()
        ctxt := colors.Context(sv)
        pc.StyleSet = false // this is always first call, restart

        var parCSSAgg map[string]any
        if g.Parent != nil { // && g.Par != sv.Root.This
                pn := g.Parent.(Node)
                parCSSAgg = pn.AsNodeBase().CSSAgg
                pp := pn.AsNodeBase().PaintStyle()
                pc.CopyStyleFrom(pp)
                pc.SetProperties(pp, g.Properties, ctxt)
        } else {
                pc.SetProperties(nil, g.Properties, ctxt)
        }
        pc.ToDotsImpl(&pc.UnitContext) // we always inherit parent's unit context -- SVG sets it once-and-for-all

        if parCSSAgg != nil {
                AggCSS(&g.CSSAgg, parCSSAgg)
        } else {
                g.CSSAgg = nil
        }
        AggCSS(&g.CSSAgg, g.CSS)
        g.StyleCSS(sv, g.CSSAgg)
        pc.Stroke.Opacity *= pc.Opacity // applies to all
        pc.Fill.Opacity *= pc.Opacity
        pc.Off = (pc.Stroke.Color == nil && pc.Fill.Color == nil)
}

// AggCSS aggregates css properties
func AggCSS(agg *map[string]any, css map[string]any) {
        if *agg == nil {
                *agg = make(map[string]any)
        }
        maps.Copy(*agg, css)
}

// ApplyCSS applies css styles to given node,
// using key to select sub-properties from overall properties list
func (g *NodeBase) ApplyCSS(sv *SVG, key string, css map[string]any) bool {
        pp, got := css[key]
        if !got {
                return false
        }
        pmap, ok := pp.(map[string]any) // must be a properties map
        if !ok {
                return false
        }
        pc := &g.Paint
        ctxt := colors.Context(sv)
        if g.Parent != sv.Root.This {
                pp := g.Parent.(Node).AsNodeBase().PaintStyle()
                pc.SetProperties(pp, pmap, ctxt)
        } else {
                pc.SetProperties(nil, pmap, ctxt)
        }
        return true
}

// StyleCSS applies css style properties to given SVG node
// parsing out type, .class, and #name selectors
func (g *NodeBase) StyleCSS(sv *SVG, css map[string]any) {
        tyn := strings.ToLower(g.NodeType().Name) // type is most general, first
        g.ApplyCSS(sv, tyn, css)
        cln := "." + strings.ToLower(g.Class) // then class
        g.ApplyCSS(sv, cln, css)
        idnm := "#" + strings.ToLower(g.Name) // then name
        g.ApplyCSS(sv, idnm, css)
}

func (g *NodeBase) SetNodePos(pos math32.Vector2) {
        // no-op by default
}

func (g *NodeBase) SetNodeSize(sz math32.Vector2) {
        // no-op by default
}

// LocalLineWidth returns the line width in local coordinates
func (g *NodeBase) LocalLineWidth() float32 {
        pc := &g.Paint
        if pc.Stroke.Color == nil {
                return 0
        }
        return pc.Stroke.Width.Dots
}

func (g *NodeBase) BBoxes(sv *SVG, parTransform math32.Matrix2) {
        xf := parTransform.Mul(g.Paint.Transform)
        ni := g.This.(Node)
        lbb := ni.LocalBBox(sv)
        g.BBox = lbb.MulMatrix2(xf).ToRect()
        g.VisBBox = sv.Geom.SizeRect().Intersect(g.BBox)
}

// IsVisible checks our bounding box and visibility, returning false if
// out of bounds. Must be called as first step in Render.
func (g *NodeBase) IsVisible(sv *SVG) bool {
        if g.Paint.Off || g == nil || g.This == nil {
                return false
        }
        nvis := g.VisBBox == image.Rectangle{}
        if nvis && !g.isDef {
                // fmt.Println("invisible:", g.Name, g.BBox, g.VisBBox)
                return false
        }
        return true
}

// Painter returns a new Painter using my styles.
func (g *NodeBase) Painter(sv *SVG) *paint.Painter {
        return &paint.Painter{sv.painter.State, &g.Paint}
}

// PushContext checks our bounding box and visibility, returning false if
// out of bounds. If visible, pushes us as Context.
// Must be called as first step in Render.
func (g *NodeBase) PushContext(sv *SVG) bool {
        if !g.IsVisible(sv) {
                return false
        }
        pc := g.Painter(sv)
        pc.PushContext(&g.Paint, nil)
        return true
}

func (g *NodeBase) BBoxesFromChildren(sv *SVG, parTransform math32.Matrix2) {
        xf := parTransform.Mul(g.Paint.Transform)
        var bb image.Rectangle
        for i, kid := range g.Children {
                ni := kid.(Node)
                ni.BBoxes(sv, xf)
                nb := ni.AsNodeBase()
                if i == 0 {
                        bb = nb.BBox
                } else {
                        bb = bb.Union(nb.BBox)
                }
        }
        g.BBox = bb
        g.VisBBox = sv.Geom.SizeRect().Intersect(g.BBox)
}

func (g *NodeBase) RenderChildren(sv *SVG) {
        for _, kid := range g.Children {
                ni := kid.(Node)
                ni.Render(sv)
        }
}

func (g *NodeBase) Render(sv *SVG) {
        if !g.IsVisible(sv) {
                return
        }
        g.RenderChildren(sv)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
)

// Path renders SVG data sequences that can render just about anything
type Path struct {
        NodeBase

        // Path data using paint/ppath representation.
        Data ppath.Path `xml:"-" set:"-"`

        // string version of the path data
        DataStr string `xml:"d"`
}

func (g *Path) SVGName() string { return "path" }

func (g *Path) SetPos(pos math32.Vector2) {
        // todo: set first point
}

func (g *Path) SetSize(sz math32.Vector2) {
        // todo: scale bbox
}

// SetData sets the path data to given string, parsing it into an optimized
// form used for rendering
func (g *Path) SetData(data string) error {
        g.DataStr = data
        var err error
        g.Data, err = ppath.ParseSVGPath(data)
        if err != nil {
                return err
        }
        return err
}

func (g *Path) LocalBBox(sv *SVG) math32.Box2 {
        bb := g.Data.FastBounds()
        hlw := 0.5 * g.LocalLineWidth()
        bb.Min.SetSubScalar(hlw)
        bb.Max.SetAddScalar(hlw)
        return bb
}

func (g *Path) Render(sv *SVG) {
        sz := len(g.Data)
        if sz < 2 || !g.IsVisible(sv) {
                return
        }
        pc := g.Painter(sv)
        pc.State.Path = g.Data.Clone() // note: yes this Clone() is absolutely necessary.
        pc.Draw()

        g.PushContext(sv)
        mrk_start := sv.MarkerByName(g, "marker-start")
        mrk_end := sv.MarkerByName(g, "marker-end")
        mrk_mid := sv.MarkerByName(g, "marker-mid")

        if mrk_start != nil || mrk_end != nil || mrk_mid != nil {
                pos := g.Data.Coords()
                dir := g.Data.CoordDirections()
                np := len(pos)
                if mrk_start != nil && np > 0 {
                        ang := ppath.Angle(dir[0])
                        mrk_start.RenderMarker(sv, pos[0], ang, g.Paint.Stroke.Width.Dots)
                }
                if mrk_end != nil && np > 1 {
                        ang := ppath.Angle(dir[np-1])
                        mrk_end.RenderMarker(sv, pos[np-1], ang, g.Paint.Stroke.Width.Dots)
                }
                if mrk_mid != nil && np > 2 {
                        for i := 1; i < np-2; i++ {
                                ang := ppath.Angle(dir[i])
                                mrk_mid.RenderMarker(sv, pos[i], ang, g.Paint.Stroke.Width.Dots)
                        }
                }
        }
        pc.PopContext()
}

// UpdatePathString sets the path string from the Data
func (g *Path) UpdatePathString() {
        g.DataStr = g.Data.ToSVG()
}

////////  Transforms

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Path) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        // path may have horiz, vert elements -- only gen soln is to transform
        g.Paint.Transform.SetMul(xf)
        g.SetProperty("transform", g.Paint.Transform.String())
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Path) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        crot := g.Paint.Transform.ExtractRot()
        if rot != 0 || crot != 0 {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // exclude self
                g.Paint.Transform.SetMulCenter(xf, lpt)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, true) // include self
                g.ApplyTransformImpl(xf, lpt)
                g.GradientApplyTransformPt(sv, xf, lpt)
        }
}

// ApplyTransformImpl does the implementation of applying a transform to all points
func (g *Path) ApplyTransformImpl(xf math32.Matrix2, lpt math32.Vector2) {
        g.Data.Transform(xf)
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Path) WriteGeom(sv *SVG, dat *[]float32) {
        sz := len(g.Data)
        *dat = slicesx.SetLength(*dat, sz+6)
        for i := range g.Data {
                (*dat)[i] = float32(g.Data[i])
        }
        g.WriteTransform(*dat, sz)
        g.GradientWritePts(sv, dat)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Path) ReadGeom(sv *SVG, dat []float32) {
        sz := len(g.Data)
        g.Data = ppath.Path(dat)
        g.ReadTransform(dat, sz)
        g.GradientReadPts(sv, dat)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/math32"
)

// Polygon is a SVG polygon
type Polygon struct {
        Polyline
}

func (g *Polygon) SVGName() string { return "polygon" }

func (g *Polygon) Render(sv *SVG) {
        sz := len(g.Points)
        if sz < 2 || !g.IsVisible(sv) {
                return
        }
        pc := g.Painter(sv)
        pc.Polygon(g.Points...)
        pc.Draw()

        g.PushContext(sv)
        if mrk := sv.MarkerByName(g, "marker-start"); mrk != nil {
                pt := g.Points[0]
                ptn := g.Points[1]
                ang := math32.Atan2(ptn.Y-pt.Y, ptn.X-pt.X)
                mrk.RenderMarker(sv, pt, ang, g.Paint.Stroke.Width.Dots)
        }
        if mrk := sv.MarkerByName(g, "marker-end"); mrk != nil {
                pt := g.Points[sz-1]
                ptp := g.Points[sz-2]
                ang := math32.Atan2(pt.Y-ptp.Y, pt.X-ptp.X)
                mrk.RenderMarker(sv, pt, ang, g.Paint.Stroke.Width.Dots)
        }
        if mrk := sv.MarkerByName(g, "marker-mid"); mrk != nil {
                for i := 1; i < sz-1; i++ {
                        pt := g.Points[i]
                        ptp := g.Points[i-1]
                        ptn := g.Points[i+1]
                        ang := 0.5 * (math32.Atan2(pt.Y-ptp.Y, pt.X-ptp.X) + math32.Atan2(ptn.Y-pt.Y, ptn.X-pt.X))
                        mrk.RenderMarker(sv, pt, ang, g.Paint.Stroke.Width.Dots)
                }
        }
        pc.PopContext()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/math32"
)

// Polyline is a SVG multi-line shape
type Polyline struct {
        NodeBase

        // the coordinates to draw -- does a moveto on the first, then lineto for all the rest
        Points []math32.Vector2 `xml:"points"`
}

func (g *Polyline) SVGName() string { return "polyline" }

func (g *Polyline) SetPos(pos math32.Vector2) {
        // todo: set offset relative to bbox
}

func (g *Polyline) SetSize(sz math32.Vector2) {
        // todo: scale bbox
}

func (g *Polyline) LocalBBox(sv *SVG) math32.Box2 {
        bb := math32.B2Empty()
        for _, pt := range g.Points {
                bb.ExpandByPoint(pt)
        }
        hlw := 0.5 * g.LocalLineWidth()
        bb.Min.SetSubScalar(hlw)
        bb.Max.SetAddScalar(hlw)
        return bb
}

func (g *Polyline) Render(sv *SVG) {
        sz := len(g.Points)
        if sz < 2 || !g.IsVisible(sv) {
                return
        }
        pc := g.Painter(sv)
        pc.Polyline(g.Points...)
        pc.Draw()

        g.PushContext(sv)
        if mrk := sv.MarkerByName(g, "marker-start"); mrk != nil {
                pt := g.Points[0]
                ptn := g.Points[1]
                ang := math32.Atan2(ptn.Y-pt.Y, ptn.X-pt.X)
                mrk.RenderMarker(sv, pt, ang, g.Paint.Stroke.Width.Dots)
        }
        if mrk := sv.MarkerByName(g, "marker-end"); mrk != nil {
                pt := g.Points[sz-1]
                ptp := g.Points[sz-2]
                ang := math32.Atan2(pt.Y-ptp.Y, pt.X-ptp.X)
                mrk.RenderMarker(sv, pt, ang, g.Paint.Stroke.Width.Dots)
        }
        if mrk := sv.MarkerByName(g, "marker-mid"); mrk != nil {
                for i := 1; i < sz-1; i++ {
                        pt := g.Points[i]
                        ptp := g.Points[i-1]
                        ptn := g.Points[i+1]
                        ang := 0.5 * (math32.Atan2(pt.Y-ptp.Y, pt.X-ptp.X) + math32.Atan2(ptn.Y-pt.Y, ptn.X-pt.X))
                        mrk.RenderMarker(sv, pt, ang, g.Paint.Stroke.Width.Dots)
                }
        }
        pc.PopContext()
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Polyline) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        rot := xf.ExtractRot()
        if rot != 0 || !g.Paint.Transform.IsIdentity() {
                g.Paint.Transform.SetMul(xf)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                for i, p := range g.Points {
                        p = xf.MulVector2AsPoint(p)
                        g.Points[i] = p
                }
                g.GradientApplyTransform(sv, xf)
        }
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Polyline) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        crot := g.Paint.Transform.ExtractRot()
        if rot != 0 || crot != 0 {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // exclude self
                g.Paint.Transform.SetMulCenter(xf, lpt)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, true) // include self
                for i, p := range g.Points {
                        p = xf.MulVector2AsPointCenter(p, lpt)
                        g.Points[i] = p
                }
                g.GradientApplyTransformPt(sv, xf, lpt)
        }
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Polyline) WriteGeom(sv *SVG, dat *[]float32) {
        sz := len(g.Points) * 2
        *dat = slicesx.SetLength(*dat, sz+6)
        for i, p := range g.Points {
                (*dat)[i*2] = p.X
                (*dat)[i*2+1] = p.Y
        }
        g.WriteTransform(*dat, sz)
        g.GradientWritePts(sv, dat)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Polyline) ReadGeom(sv *SVG, dat []float32) {
        sz := len(g.Points) * 2
        for i, p := range g.Points {
                p.X = dat[i*2]
                p.Y = dat[i*2+1]
                g.Points[i] = p
        }
        g.ReadTransform(dat, sz)
        g.GradientReadPts(sv, dat)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/sides"
)

// Rect is a SVG rectangle, optionally with rounded corners
type Rect struct {
        NodeBase

        // position of the top-left of the rectangle
        Pos math32.Vector2 `xml:"{x,y}"`

        // size of the rectangle
        Size math32.Vector2 `xml:"{width,height}"`

        // radii for curved corners. only rx is used for now.
        Radius math32.Vector2 `xml:"{rx,ry}"`
}

func (g *Rect) SVGName() string { return "rect" }

func (g *Rect) Init() {
        g.NodeBase.Init()
        g.Size.Set(1, 1)
}

func (g *Rect) SetNodePos(pos math32.Vector2) {
        g.Pos = pos
}

func (g *Rect) SetNodeSize(sz math32.Vector2) {
        g.Size = sz
}

func (g *Rect) LocalBBox(sv *SVG) math32.Box2 {
        bb := math32.Box2{}
        hlw := 0.5 * g.LocalLineWidth()
        bb.Min = g.Pos.SubScalar(hlw)
        bb.Max = g.Pos.Add(g.Size).AddScalar(hlw)
        return bb
}

func (g *Rect) Render(sv *SVG) {
        if !g.IsVisible(sv) {
                return
        }
        pc := g.Painter(sv)
        if g.Radius.X == 0 && g.Radius.Y == 0 {
                pc.Rectangle(g.Pos.X, g.Pos.Y, g.Size.X, g.Size.Y)
        } else {
                // todo: only supports 1 radius right now -- easy to add another
                // the Painter also support different radii for each corner but not rx, ry at this point,
                // although that would be easy to add TODO:
                pc.RoundedRectangleSides(g.Pos.X, g.Pos.Y, g.Size.X, g.Size.Y, sides.NewFloats(g.Radius.X))
        }
        pc.Draw()
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Rect) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        rot := xf.ExtractRot()
        if rot != 0 || !g.Paint.Transform.IsIdentity() {
                g.Paint.Transform.SetMul(xf)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                g.Pos = xf.MulVector2AsPoint(g.Pos)
                g.Size = xf.MulVector2AsVector(g.Size)
                g.GradientApplyTransform(sv, xf)
        }
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Rect) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        crot := g.Paint.Transform.ExtractRot()
        if rot != 0 || crot != 0 {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // exclude self
                g.Paint.Transform.SetMulCenter(xf, lpt)                   // todo: this might be backwards for everything
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                // fmt.Println("adt", trans, scale, rot, pt)
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, true) // include self
                // opos := g.Pos
                g.Pos = xf.MulVector2AsPointCenter(g.Pos, lpt)
                // fmt.Println("apply delta trans:", opos, g.Pos, xf)
                g.Size = xf.MulVector2AsVector(g.Size)
                g.GradientApplyTransformPt(sv, xf, lpt)
        }
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Rect) WriteGeom(sv *SVG, dat *[]float32) {
        *dat = slicesx.SetLength(*dat, 4+6)
        (*dat)[0] = g.Pos.X
        (*dat)[1] = g.Pos.Y
        (*dat)[2] = g.Size.X
        (*dat)[3] = g.Size.Y
        g.WriteTransform(*dat, 4)
        g.GradientWritePts(sv, dat)
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Rect) ReadGeom(sv *SVG, dat []float32) {
        g.Pos.X = dat[0]
        g.Pos.Y = dat[1]
        g.Size.X = dat[2]
        g.Size.Y = dat[3]
        g.ReadTransform(dat, 4)
        g.GradientReadPts(sv, dat)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

//go:generate core generate

import (
        "bytes"
        "image"
        "image/color"
        "strings"
        "sync"

        "cogentcore.org/core/base/iox/imagex"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/sides"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/tree"
)

var (
        // svgShaper is a shared text shaper.
        svgShaper shaped.Shaper

        // mutex for initializing the svgShaper.
        shaperMu sync.Mutex
)

// SVGToImage generates an image from given svg source,
// with given width and height size.
func SVGToImage(svg []byte, size math32.Vector2) (image.Image, error) {
        sv := NewSVG(size)
        err := sv.ReadXML(bytes.NewBuffer(svg))
        return sv.RenderImage(), err
}

// SVG represents a structured SVG vector graphics drawing,
// with nodes allocated for each element.
// It renders to a [paint.Painter] via the Render method.
// Any supported representation can then be rendered from that.
type SVG struct {
        // Name is the name of the SVG -- e.g., the filename if loaded
        Name string

        // the title of the svg
        Title string `xml:"title"`

        // the description of the svg
        Desc string `xml:"desc"`

        // Background is the image/color to fill the background with,
        // if any.
        Background image.Image

        // Color can be set to provide a default Fill and Stroke Color value
        Color image.Image

        // Size is size of image, Pos is offset within any parent viewport.
        // Node bounding boxes are based on 0 Pos offset within RenderImage
        Geom math32.Geom2DInt

        // physical width of the drawing, e.g., when printed.
        // Does not affect rendering, metadata.
        PhysicalWidth units.Value

        // physical height of the drawing, e.g., when printed.
        // Does not affect rendering, metadata.
        PhysicalHeight units.Value

        // InvertY, when applying the ViewBox transform, also flip the Y axis so that
        // the smallest Y value is at the bottom of the SVG box,
        // instead of being at the top as it is by default.
        InvertY bool

        // Translate specifies a translation to apply beyond what is specified in the SVG,
        // and its ViewBox transform.
        Translate math32.Vector2

        // Scale specifies a zoom scale factor to apply beyond what is specified in the SVG,
        // and its ViewBox transform.
        Scale float32

        // painter is the current painter being used, which is only valid during rendering.
        painter *paint.Painter

        // TextShaper for shaping text. Can set to a shared external one,
        // or else the shared svgShaper is used.
        TextShaper shaped.Shaper

        // all defs defined elements go here (gradients, symbols, etc)
        Defs *Group

        // Root is the root of the svg tree, which has the top-level viewbox and styles.
        Root *Root

        // GroupFilter is used to filter group names, skipping any that don't contain
        // this string, if non-empty. This is needed e.g., for reading SVG font files
        // which pack many elements into the same file.
        GroupFilter string

        // groupFilterSkip is whether to skip the current group based on GroupFilter.
        groupFilterSkip bool

        // groupFilterSkipName is name of group currently skipping.
        groupFilterSkipName string

        // map of def names to index. uses starting index to find element.
        // always updated after each search.
        DefIndexes map[string]int `display:"-" json:"-" xml:"-"`

        // map of unique numeric ids for all elements.
        // Used for allocating new unique id numbers, appended to end of elements.
        // See NewUniqueID, GatherIDs
        UniqueIDs map[int]struct{} `display:"-" json:"-" xml:"-"`

        // mutex for protecting rendering
        sync.Mutex
}

// NewSVG creates a SVG with the given viewport size,
// which is typically in pixel dots.
func NewSVG(size math32.Vector2) *SVG {
        sv := &SVG{}
        sv.Init(size)
        return sv
}

// Init initializes the SVG with given viewport size,
// which is typically in pixel dots.
func (sv *SVG) Init(size math32.Vector2) {
        sv.Geom.Size = size.ToPointCeil()
        sv.Scale = 1
        sv.Root = NewRoot()
        sv.Root.SetName("svg")
        sv.Defs = NewGroup()
        sv.Defs.SetName("defs")
        sv.SetUnitContext(&sv.Root.Paint)
}

// SetSize updates the viewport size.
func (sv *SVG) SetSize(size math32.Vector2) {
        sv.Geom.Size = size.ToPointCeil()
        sv.SetUnitContext(&sv.Root.Paint)
}

// DeleteAll deletes any existing elements in this svg
func (sv *SVG) DeleteAll() {
        if sv.Root == nil || sv.Root.This == nil {
                return
        }
        sv.Root.Paint.Defaults()
        sv.Root.DeleteChildren()
        sv.Defs.DeleteChildren()
}

// Base returns the current Color activated in the context.
// Color has support for special color names that are relative to
// this current color.
func (sv *SVG) Base() color.RGBA {
        return colors.AsRGBA(colors.ToUniform(sv.Background))
}

// ImageByURL finds a Node by an element name (URL-like path), and
// attempts to convert it to an [image.Image].
// Used for color styling based on url() value.
func (sv *SVG) ImageByURL(url string) image.Image {
        // TODO(kai): support taking snapshot of element as image in SVG.ImageByURL
        if sv == nil {
                return nil
        }
        val := url[4:]
        val = strings.TrimPrefix(strings.TrimSuffix(val, ")"), "#")
        def := sv.FindDefByName(val)
        if def != nil {
                if grad, ok := def.(*Gradient); ok {
                        return grad.Grad
                }
        }
        ne := sv.FindNamedElement(val)
        if grad, ok := ne.(*Gradient); ok {
                return grad.Grad
        }
        return nil
}

func (sv *SVG) Style() {
        // set isDef
        sv.Defs.WalkDown(func(n tree.Node) bool {
                sn := n.(Node)
                sn.AsNodeBase().isDef = true
                sn.AsNodeBase().Style(sv)
                return tree.Continue
        })

        sv.Root.Paint.Defaults()
        if sv.Color != nil {
                // TODO(kai): consider handling non-uniform colors here
                c := colors.ToUniform(sv.Color)
                sv.Root.SetColorProperties("stroke", colors.AsHex(c))
                sv.Root.SetColorProperties("fill", colors.AsHex(c))
        }
        sv.SetUnitContext(&sv.Root.Paint)

        sv.Root.WalkDown(func(k tree.Node) bool {
                sn := k.(Node)
                sn.AsNodeBase().Style(sv)
                return tree.Continue
        })
}

// Render renders the SVG to given Painter, which can be nil
// to have a new one created. Returns the painter used.
// Set the TextShaper prior to calling to use an existing one,
// otherwise it will use shared svgShaper.
func (sv *SVG) Render(pc *paint.Painter) *paint.Painter {
        sv.Lock()
        defer sv.Unlock()

        if pc != nil {
                sv.painter = pc
        } else {
                sv.painter = paint.NewPainter(math32.FromPoint(sv.Geom.Size))
                pc = sv.painter
        }
        if sv.TextShaper == nil {
                shaperMu.Lock()
                if svgShaper == nil {
                        svgShaper = shaped.NewShaper()
                }
                sv.TextShaper = svgShaper
                shaperMu.Unlock()
                defer func() {
                        sv.TextShaper = nil
                }()
        }

        sv.Style()
        sv.SetRootTransform()
        sv.Root.BBoxes(sv, math32.Identity2())

        if sv.Background != nil {
                sv.FillViewport()
        }
        sv.Root.Render(sv)

        sv.painter = nil
        return pc
}

// RenderImage renders the SVG to an image and returns it.
func (sv *SVG) RenderImage() image.Image {
        return paint.RenderToImage(sv.Render(nil))
}

// SaveImage renders the SVG to an image and saves it to given filename,
// using the filename extension to determine the file type.
func (sv *SVG) SaveImage(fname string) error {
        return imagex.Save(sv.RenderImage(), fname)
}

func (sv *SVG) FillViewport() {
        sty := styles.NewPaint() // has no transform
        pc := &paint.Painter{sv.painter.State, sty}
        pc.FillBox(math32.Vector2{}, math32.FromPoint(sv.Geom.Size), sv.Background)
}

// SetRootTransform sets the Root node transform based on ViewBox, Translate, Scale
// parameters set on the SVG object.
func (sv *SVG) SetRootTransform() {
        vb := &sv.Root.ViewBox
        box := math32.FromPoint(sv.Geom.Size)
        if vb.Size.X == 0 {
                vb.Size.X = sv.PhysicalWidth.Dots
        }
        if vb.Size.Y == 0 {
                vb.Size.Y = sv.PhysicalHeight.Dots
        }
        _, trans, scale := vb.Transform(box)
        if sv.InvertY {
                scale.Y *= -1
        }
        trans.SetSub(vb.Min)
        trans.SetAdd(sv.Translate)
        scale.SetMulScalar(sv.Scale)
        pc := &sv.Root.Paint
        pc.Transform = pc.Transform.Scale(scale.X, scale.Y).Translate(trans.X, trans.Y)
        if sv.InvertY {
                pc.Transform.Y0 = -pc.Transform.Y0
        }
}

// SetDPITransform sets a scaling transform to compensate for
// a given LogicalDPI factor.
// svg rendering is done within a 96 DPI context.
func (sv *SVG) SetDPITransform(logicalDPI float32) {
        pc := &sv.Root.Paint
        dpisc := logicalDPI / 96.0
        pc.Transform = math32.Scale2D(dpisc, dpisc)
}

// Root represents the root of an SVG tree.
type Root struct {
        Group

        // ViewBox defines the coordinate system for the drawing.
        // These units are mapped into the screen space allocated
        // for the SVG during rendering.
        ViewBox ViewBox
}

func (g *Root) SVGName() string { return "svg" }

func (g *Root) EnforceSVGName() bool { return false }

// SetUnitContext sets the unit context based on size of viewport, element,
// and parent element (from bbox) and then caches everything out in terms of raw pixel
// dots for rendering -- call at start of render
func (sv *SVG) SetUnitContext(pc *styles.Paint) {
        pc.UnitContext.Defaults()
        pc.UnitContext.DPI = 96 // paint (SVG) context is always 96 = 1to1
        wd := float32(sv.Geom.Size.X)
        ht := float32(sv.Geom.Size.Y)
        pc.UnitContext.SetSizes(wd, ht, wd, ht, wd, ht) // self, element, parent -- all same
        pc.ToDots()
        sv.ToDots(&pc.UnitContext)
}

func (sv *SVG) ToDots(uc *units.Context) {
        sv.PhysicalWidth.ToDots(uc)
        sv.PhysicalHeight.ToDots(uc)
}

func (g *Root) Render(sv *SVG) {
        pc := g.Painter(sv)
        pc.PushContext(&g.Paint, render.NewBoundsRect(sv.Geom.Bounds(), sides.NewFloats()))
        g.RenderChildren(sv)
        pc.PopContext()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/text/htmltext"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/text"
)

// Text renders SVG text, handling both text and tspan elements.
// tspan is nested under a parent text, where text has empty Text string.
type Text struct {
        NodeBase

        // position of the left, baseline of the text
        Pos math32.Vector2 `xml:"{x,y}"`

        // width of text to render if using word-wrapping
        Width float32 `xml:"width"`

        // text string to render
        Text string `xml:"text"`

        // render version of text
        TextShaped *shaped.Lines `xml:"-" json:"-" copier:"-"`

        // character positions along X axis, if specified
        CharPosX []float32

        // character positions along Y axis, if specified
        CharPosY []float32

        // character delta-positions along X axis, if specified
        CharPosDX []float32

        // character delta-positions along Y axis, if specified
        CharPosDY []float32

        // character rotations, if specified
        CharRots []float32

        // author's computed text length, if specified -- we attempt to match
        TextLength float32

        // in attempting to match TextLength, should we adjust glyphs in addition to spacing?
        AdjustGlyphs bool
}

func (g *Text) SVGName() string {
        if len(g.Text) == 0 {
                return "text"
        }
        return "tspan"
}

// IsParText returns true if this element serves as a parent text element
// to tspan elements within it.  This is true if NumChildren() > 0 and
// Text == ""
func (g *Text) IsParText() bool {
        return g.NumChildren() > 0 && g.Text == ""
}

func (g *Text) SetNodePos(pos math32.Vector2) {
        g.Pos = pos
        for _, kii := range g.Children {
                kt := kii.(*Text)
                kt.Pos = g.Paint.Transform.MulVector2AsPoint(pos)
        }
}

func (g *Text) SetNodeSize(sz math32.Vector2) {
        g.Width = sz.X
        scx, _ := g.Paint.Transform.ExtractScale()
        for _, kii := range g.Children {
                kt := kii.(*Text)
                kt.Width = g.Width * scx
        }
}

// LocalBBox does full text layout, but no transforms
func (g *Text) LocalBBox(sv *SVG) math32.Box2 {
        if g.Text == "" {
                return math32.Box2{}
        }
        pc := &g.Paint
        fs := pc.Font
        if pc.Fill.Color != nil {
                fs.SetFillColor(colors.ToUniform(pc.Fill.Color))
        }
        tx, _ := htmltext.HTMLToRich([]byte(g.Text), &fs, nil)
        // fmt.Println(tx)
        sz := math32.Vec2(10000, 10000)
        g.TextShaped = sv.TextShaper.WrapLines(tx, &fs, &pc.Text, &rich.DefaultSettings, sz)
        // baseOff := g.TextShaped.Lines[0].Offset
        g.TextShaped.StartAtBaseline() // remove top-left offset
        // fmt.Println("baseoff:", baseOff)
        // fmt.Println(pc.Text.FontSize, pc.Text.FontSize.Dots)

        // todo: align styling only affects multi-line text and is about how tspan is arranged within
        // the overall text block.

        /*
                if len(g.CharPosX) > 0 {
                        mx := min(len(g.CharPosX), len(sr.Render))
                        for i := 0; i < mx; i++ {
                                sr.Render[i].RelPos.X = g.CharPosX[i]
                        }
                }
                if len(g.CharPosY) > 0 {
                        mx := min(len(g.CharPosY), len(sr.Render))
                        for i := 0; i < mx; i++ {
                                sr.Render[i].RelPos.Y = g.CharPosY[i]
                        }
                }
                if len(g.CharPosDX) > 0 {
                        mx := min(len(g.CharPosDX), len(sr.Render))
                        for i := 0; i < mx; i++ {
                                if i > 0 {
                                        sr.Render[i].RelPos.X = sr.Render[i-1].RelPos.X + g.CharPosDX[i]
                                } else {
                                        sr.Render[i].RelPos.X = g.CharPosDX[i] // todo: not sure this is right
                                }
                        }
                }
                if len(g.CharPosDY) > 0 {
                        mx := min(len(g.CharPosDY), len(sr.Render))
                        for i := 0; i < mx; i++ {
                                if i > 0 {
                                        sr.Render[i].RelPos.Y = sr.Render[i-1].RelPos.Y + g.CharPosDY[i]
                                } else {
                                        sr.Render[i].RelPos.Y = g.CharPosDY[i] // todo: not sure this is right
                                }
                        }
                }
        */
        // todo: TextLength, AdjustGlyphs -- also svg2 at least supports word wrapping!
        // g.TextShaped.UpdateBBox()
        return g.TextShaped.Bounds.Translate(g.Pos)
}

func (g *Text) BBoxes(sv *SVG, parTransform math32.Matrix2) {
        if g.IsParText() {
                g.BBoxesFromChildren(sv, parTransform)
                return
        }
        xf := parTransform.Mul(g.Paint.Transform)
        ni := g.This.(Node)
        lbb := ni.LocalBBox(sv)
        g.BBox = lbb.MulMatrix2(xf).ToRect()
        g.VisBBox = sv.Geom.SizeRect().Intersect(g.BBox)
}

func (g *Text) Render(sv *SVG) {
        if g.IsParText() {
                if !g.PushContext(sv) {
                        return
                }
                pc := g.Painter(sv)
                g.RenderChildren(sv)
                pc.PopContext()
                return
        }
        if !g.IsVisible(sv) {
                return
        }
        if len(g.Text) > 0 {
                g.RenderText(sv)
        }
}

func (g *Text) RenderText(sv *SVG) {
        // note: transform is managed entirely in the render side function!
        pc := g.Painter(sv)
        pos := g.Pos
        bsz := g.TextShaped.Bounds.Size()
        if pc.Text.Align == text.Center {
                pos.X -= bsz.X * .5
        } else if pc.Text.Align == text.End {
                pos.X -= bsz.X
        }
        pc.DrawText(g.TextShaped, pos)
}

// ApplyTransform applies the given 2D transform to the geometry of this node
// each node must define this for itself
func (g *Text) ApplyTransform(sv *SVG, xf math32.Matrix2) {
        rot := xf.ExtractRot()
        if rot != 0 || !g.Paint.Transform.IsIdentity() {
                g.Paint.Transform.SetMul(xf)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                if g.IsParText() {
                        for _, kii := range g.Children {
                                kt := kii.(*Text)
                                kt.ApplyTransform(sv, xf)
                        }
                } else {
                        g.Pos = xf.MulVector2AsPoint(g.Pos)
                        scx, _ := xf.ExtractScale()
                        g.Width *= scx
                        g.GradientApplyTransform(sv, xf)
                }
        }
}

// ApplyDeltaTransform applies the given 2D delta transforms to the geometry of this node
// relative to given point.  Trans translation and point are in top-level coordinates,
// so must be transformed into local coords first.
// Point is upper left corner of selection box that anchors the translation and scaling,
// and for rotation it is the center point around which to rotate
func (g *Text) ApplyDeltaTransform(sv *SVG, trans math32.Vector2, scale math32.Vector2, rot float32, pt math32.Vector2) {
        crot := g.Paint.Transform.ExtractRot()
        if rot != 0 || crot != 0 {
                xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false) // exclude self
                g.Paint.Transform.SetMulCenter(xf, lpt)
                g.SetProperty("transform", g.Paint.Transform.String())
        } else {
                if g.IsParText() {
                        // translation transform
                        xft, lptt := g.DeltaTransform(trans, scale, rot, pt, true) // include self when not a parent
                        // transform transform
                        xf, lpt := g.DeltaTransform(trans, scale, rot, pt, false)
                        xf.X0 = 0 // negate translation effects
                        xf.Y0 = 0
                        g.Paint.Transform.SetMulCenter(xf, lpt)
                        g.SetProperty("transform", g.Paint.Transform.String())

                        g.Pos = xft.MulVector2AsPointCenter(g.Pos, lptt)
                        scx, _ := xft.ExtractScale()
                        g.Width *= scx
                        for _, kii := range g.Children {
                                kt := kii.(*Text)
                                kt.Pos = xft.MulVector2AsPointCenter(kt.Pos, lptt)
                                kt.Width *= scx
                        }
                } else {
                        xf, lpt := g.DeltaTransform(trans, scale, rot, pt, true) // include self when not a parent
                        g.Pos = xf.MulVector2AsPointCenter(g.Pos, lpt)
                        scx, _ := xf.ExtractScale()
                        g.Width *= scx
                }
        }
}

// WriteGeom writes the geometry of the node to a slice of floating point numbers
// the length and ordering of which is specific to each node type.
// Slice must be passed and will be resized if not the correct length.
func (g *Text) WriteGeom(sv *SVG, dat *[]float32) {
        if g.IsParText() {
                npt := 9 + g.NumChildren()*3
                *dat = slicesx.SetLength(*dat, npt)
                (*dat)[0] = g.Pos.X
                (*dat)[1] = g.Pos.Y
                (*dat)[2] = g.Width
                g.WriteTransform(*dat, 3)
                for i, kii := range g.Children {
                        kt := kii.(*Text)
                        off := 9 + i*3
                        (*dat)[off+0] = kt.Pos.X
                        (*dat)[off+1] = kt.Pos.Y
                        (*dat)[off+2] = kt.Width
                }
        } else {
                *dat = slicesx.SetLength(*dat, 3+6)
                (*dat)[0] = g.Pos.X
                (*dat)[1] = g.Pos.Y
                (*dat)[2] = g.Width
                g.WriteTransform(*dat, 3)
        }
}

// ReadGeom reads the geometry of the node from a slice of floating point numbers
// the length and ordering of which is specific to each node type.
func (g *Text) ReadGeom(sv *SVG, dat []float32) {
        g.Pos.X = dat[0]
        g.Pos.Y = dat[1]
        g.Width = dat[2]
        g.ReadTransform(dat, 3)
        if g.IsParText() {
                for i, kii := range g.Children {
                        kt := kii.(*Text)
                        off := 9 + i*3
                        kt.Pos.X = dat[off+0]
                        kt.Pos.Y = dat[off+1]
                        kt.Width = dat[off+2]
                }
        }
}

// Code generated by "core generate"; DO NOT EDIT.

package svg

import (
        "image"

        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
        "github.com/aymerick/douceur/css"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Circle", IDName: "circle", Doc: "Circle is a SVG circle", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Pos", Doc: "position of the center of the circle"}, {Name: "Radius", Doc: "radius of the circle"}}})

// NewCircle returns a new [Circle] with the given optional parent:
// Circle is a SVG circle
func NewCircle(parent ...tree.Node) *Circle { return tree.New[Circle](parent...) }

// SetPos sets the [Circle.Pos]:
// position of the center of the circle
func (t *Circle) SetPos(v math32.Vector2) *Circle { t.Pos = v; return t }

// SetRadius sets the [Circle.Radius]:
// radius of the circle
func (t *Circle) SetRadius(v float32) *Circle { t.Radius = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.ClipPath", IDName: "clip-path", Doc: "ClipPath is used for holding a path that renders as a clip path", Embeds: []types.Field{{Name: "NodeBase"}}})

// NewClipPath returns a new [ClipPath] with the given optional parent:
// ClipPath is used for holding a path that renders as a clip path
func NewClipPath(parent ...tree.Node) *ClipPath { return tree.New[ClipPath](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.StyleSheet", IDName: "style-sheet", Doc: "StyleSheet is a Node2D node that contains a stylesheet -- property values\ncontained in this sheet can be transformed into tree.Properties and set in CSS\nfield of appropriate node", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Sheet"}}})

// NewStyleSheet returns a new [StyleSheet] with the given optional parent:
// StyleSheet is a Node2D node that contains a stylesheet -- property values
// contained in this sheet can be transformed into tree.Properties and set in CSS
// field of appropriate node
func NewStyleSheet(parent ...tree.Node) *StyleSheet { return tree.New[StyleSheet](parent...) }

// SetSheet sets the [StyleSheet.Sheet]
func (t *StyleSheet) SetSheet(v *css.Stylesheet) *StyleSheet { t.Sheet = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.MetaData", IDName: "meta-data", Doc: "MetaData is used for holding meta data info", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "MetaData"}}})

// NewMetaData returns a new [MetaData] with the given optional parent:
// MetaData is used for holding meta data info
func NewMetaData(parent ...tree.Node) *MetaData { return tree.New[MetaData](parent...) }

// SetMetaData sets the [MetaData.MetaData]
func (t *MetaData) SetMetaData(v string) *MetaData { t.MetaData = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Ellipse", IDName: "ellipse", Doc: "Ellipse is a SVG ellipse", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Pos", Doc: "position of the center of the ellipse"}, {Name: "Radii", Doc: "radii of the ellipse in the horizontal, vertical axes"}}})

// NewEllipse returns a new [Ellipse] with the given optional parent:
// Ellipse is a SVG ellipse
func NewEllipse(parent ...tree.Node) *Ellipse { return tree.New[Ellipse](parent...) }

// SetPos sets the [Ellipse.Pos]:
// position of the center of the ellipse
func (t *Ellipse) SetPos(v math32.Vector2) *Ellipse { t.Pos = v; return t }

// SetRadii sets the [Ellipse.Radii]:
// radii of the ellipse in the horizontal, vertical axes
func (t *Ellipse) SetRadii(v math32.Vector2) *Ellipse { t.Radii = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Filter", IDName: "filter", Doc: "Filter represents SVG filter* elements", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "FilterType"}}})

// NewFilter returns a new [Filter] with the given optional parent:
// Filter represents SVG filter* elements
func NewFilter(parent ...tree.Node) *Filter { return tree.New[Filter](parent...) }

// SetFilterType sets the [Filter.FilterType]
func (t *Filter) SetFilterType(v string) *Filter { t.FilterType = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Flow", IDName: "flow", Doc: "Flow represents SVG flow* elements", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "FlowType"}}})

// NewFlow returns a new [Flow] with the given optional parent:
// Flow represents SVG flow* elements
func NewFlow(parent ...tree.Node) *Flow { return tree.New[Flow](parent...) }

// SetFlowType sets the [Flow.FlowType]
func (t *Flow) SetFlowType(v string) *Flow { t.FlowType = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Gradient", IDName: "gradient", Doc: "Gradient is used for holding a specified color gradient.\nThe name is the id for lookup in url", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Grad", Doc: "the color gradient"}, {Name: "StopsName", Doc: "name of another gradient to get stops from"}}})

// NewGradient returns a new [Gradient] with the given optional parent:
// Gradient is used for holding a specified color gradient.
// The name is the id for lookup in url
func NewGradient(parent ...tree.Node) *Gradient { return tree.New[Gradient](parent...) }

// SetGrad sets the [Gradient.Grad]:
// the color gradient
func (t *Gradient) SetGrad(v gradient.Gradient) *Gradient { t.Grad = v; return t }

// SetStopsName sets the [Gradient.StopsName]:
// name of another gradient to get stops from
func (t *Gradient) SetStopsName(v string) *Gradient { t.StopsName = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Group", IDName: "group", Doc: "Group groups together SVG elements.\nProvides a common transform for all group elements\nand shared style properties.", Embeds: []types.Field{{Name: "NodeBase"}}})

// NewGroup returns a new [Group] with the given optional parent:
// Group groups together SVG elements.
// Provides a common transform for all group elements
// and shared style properties.
func NewGroup(parent ...tree.Node) *Group { return tree.New[Group](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Image", IDName: "image", Doc: "Image is an SVG image (bitmap)", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Pos", Doc: "position of the top-left of the image"}, {Name: "Size", Doc: "rendered size of the image (imposes a scaling on image when it is rendered)"}, {Name: "Filename", Doc: "file name of image loaded -- set by OpenImage"}, {Name: "ViewBox", Doc: "how to scale and align the image"}, {Name: "Pixels", Doc: "Pixels are the image pixels, which has imagex.WrapJS already applied."}}})

// NewImage returns a new [Image] with the given optional parent:
// Image is an SVG image (bitmap)
func NewImage(parent ...tree.Node) *Image { return tree.New[Image](parent...) }

// SetPos sets the [Image.Pos]:
// position of the top-left of the image
func (t *Image) SetPos(v math32.Vector2) *Image { t.Pos = v; return t }

// SetSize sets the [Image.Size]:
// rendered size of the image (imposes a scaling on image when it is rendered)
func (t *Image) SetSize(v math32.Vector2) *Image { t.Size = v; return t }

// SetFilename sets the [Image.Filename]:
// file name of image loaded -- set by OpenImage
func (t *Image) SetFilename(v string) *Image { t.Filename = v; return t }

// SetViewBox sets the [Image.ViewBox]:
// how to scale and align the image
func (t *Image) SetViewBox(v ViewBox) *Image { t.ViewBox = v; return t }

// SetPixels sets the [Image.Pixels]:
// Pixels are the image pixels, which has imagex.WrapJS already applied.
func (t *Image) SetPixels(v image.Image) *Image { t.Pixels = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Line", IDName: "line", Doc: "Line is a SVG line", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Start", Doc: "position of the start of the line"}, {Name: "End", Doc: "position of the end of the line"}}})

// NewLine returns a new [Line] with the given optional parent:
// Line is a SVG line
func NewLine(parent ...tree.Node) *Line { return tree.New[Line](parent...) }

// SetStart sets the [Line.Start]:
// position of the start of the line
func (t *Line) SetStart(v math32.Vector2) *Line { t.Start = v; return t }

// SetEnd sets the [Line.End]:
// position of the end of the line
func (t *Line) SetEnd(v math32.Vector2) *Line { t.End = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Marker", IDName: "marker", Doc: "Marker represents marker elements that can be drawn along paths (arrow heads, etc)", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "RefPos", Doc: "reference position to align the vertex position with, specified in ViewBox coordinates"}, {Name: "Size", Doc: "size of marker to render, in Units units"}, {Name: "Units", Doc: "units to use"}, {Name: "ViewBox", Doc: "viewbox defines the internal coordinate system for the drawing elements within the marker"}, {Name: "Orient", Doc: "orientation of the marker -- either 'auto' or an angle"}, {Name: "VertexPos", Doc: "current vertex position"}, {Name: "VertexAngle", Doc: "current vertex angle in radians"}, {Name: "StrokeWidth", Doc: "current stroke width"}, {Name: "Transform", Doc: "net transform computed from settings and current values -- applied prior to rendering"}, {Name: "EffSize", Doc: "effective size for actual rendering"}}})

// NewMarker returns a new [Marker] with the given optional parent:
// Marker represents marker elements that can be drawn along paths (arrow heads, etc)
func NewMarker(parent ...tree.Node) *Marker { return tree.New[Marker](parent...) }

// SetRefPos sets the [Marker.RefPos]:
// reference position to align the vertex position with, specified in ViewBox coordinates
func (t *Marker) SetRefPos(v math32.Vector2) *Marker { t.RefPos = v; return t }

// SetSize sets the [Marker.Size]:
// size of marker to render, in Units units
func (t *Marker) SetSize(v math32.Vector2) *Marker { t.Size = v; return t }

// SetUnits sets the [Marker.Units]:
// units to use
func (t *Marker) SetUnits(v MarkerUnits) *Marker { t.Units = v; return t }

// SetViewBox sets the [Marker.ViewBox]:
// viewbox defines the internal coordinate system for the drawing elements within the marker
func (t *Marker) SetViewBox(v ViewBox) *Marker { t.ViewBox = v; return t }

// SetOrient sets the [Marker.Orient]:
// orientation of the marker -- either 'auto' or an angle
func (t *Marker) SetOrient(v string) *Marker { t.Orient = v; return t }

// SetVertexPos sets the [Marker.VertexPos]:
// current vertex position
func (t *Marker) SetVertexPos(v math32.Vector2) *Marker { t.VertexPos = v; return t }

// SetVertexAngle sets the [Marker.VertexAngle]:
// current vertex angle in radians
func (t *Marker) SetVertexAngle(v float32) *Marker { t.VertexAngle = v; return t }

// SetStrokeWidth sets the [Marker.StrokeWidth]:
// current stroke width
func (t *Marker) SetStrokeWidth(v float32) *Marker { t.StrokeWidth = v; return t }

// SetTransform sets the [Marker.Transform]:
// net transform computed from settings and current values -- applied prior to rendering
func (t *Marker) SetTransform(v math32.Matrix2) *Marker { t.Transform = v; return t }

// SetEffSize sets the [Marker.EffSize]:
// effective size for actual rendering
func (t *Marker) SetEffSize(v math32.Vector2) *Marker { t.EffSize = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.NodeBase", IDName: "node-base", Doc: "NodeBase is the base type for all elements within an SVG tree.\nIt implements the [Node] interface and contains the core functionality.", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Class", Doc: "Class contains user-defined class name(s) used primarily for attaching\nCSS styles to different display elements.\nMultiple class names can be used to combine properties;\nuse spaces to separate per css standard."}, {Name: "CSS", Doc: "CSS is the cascading style sheet at this level.\nThese styles apply here and to everything below, until superceded.\nUse .class and #name Properties elements to apply entire styles\nto given elements, and type for element type."}, {Name: "CSSAgg", Doc: "CSSAgg is the aggregated css properties from all higher nodes down to this node."}, {Name: "BBox", Doc: "BBox is the bounding box for the node within the SVG Pixels image.\nThis one can be outside the visible range of the SVG image.\nVisBBox is intersected and only shows visible portion."}, {Name: "VisBBox", Doc: "VisBBox is the visible bounding box for the node intersected with the SVG image geometry."}, {Name: "Paint", Doc: "Paint is the paint style information for this node."}, {Name: "isDef", Doc: "isDef is whether this is in [SVG.Defs]."}}})

// NewNodeBase returns a new [NodeBase] with the given optional parent:
// NodeBase is the base type for all elements within an SVG tree.
// It implements the [Node] interface and contains the core functionality.
func NewNodeBase(parent ...tree.Node) *NodeBase { return tree.New[NodeBase](parent...) }

// SetClass sets the [NodeBase.Class]:
// Class contains user-defined class name(s) used primarily for attaching
// CSS styles to different display elements.
// Multiple class names can be used to combine properties;
// use spaces to separate per css standard.
func (t *NodeBase) SetClass(v string) *NodeBase { t.Class = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Path", IDName: "path", Doc: "Path renders SVG data sequences that can render just about anything", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Data", Doc: "Path data using paint/ppath representation."}, {Name: "DataStr", Doc: "string version of the path data"}}})

// NewPath returns a new [Path] with the given optional parent:
// Path renders SVG data sequences that can render just about anything
func NewPath(parent ...tree.Node) *Path { return tree.New[Path](parent...) }

// SetDataStr sets the [Path.DataStr]:
// string version of the path data
func (t *Path) SetDataStr(v string) *Path { t.DataStr = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Polygon", IDName: "polygon", Doc: "Polygon is a SVG polygon", Embeds: []types.Field{{Name: "Polyline"}}})

// NewPolygon returns a new [Polygon] with the given optional parent:
// Polygon is a SVG polygon
func NewPolygon(parent ...tree.Node) *Polygon { return tree.New[Polygon](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Polyline", IDName: "polyline", Doc: "Polyline is a SVG multi-line shape", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Points", Doc: "the coordinates to draw -- does a moveto on the first, then lineto for all the rest"}}})

// NewPolyline returns a new [Polyline] with the given optional parent:
// Polyline is a SVG multi-line shape
func NewPolyline(parent ...tree.Node) *Polyline { return tree.New[Polyline](parent...) }

// SetPoints sets the [Polyline.Points]:
// the coordinates to draw -- does a moveto on the first, then lineto for all the rest
func (t *Polyline) SetPoints(v ...math32.Vector2) *Polyline { t.Points = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Rect", IDName: "rect", Doc: "Rect is a SVG rectangle, optionally with rounded corners", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Pos", Doc: "position of the top-left of the rectangle"}, {Name: "Size", Doc: "size of the rectangle"}, {Name: "Radius", Doc: "radii for curved corners. only rx is used for now."}}})

// NewRect returns a new [Rect] with the given optional parent:
// Rect is a SVG rectangle, optionally with rounded corners
func NewRect(parent ...tree.Node) *Rect { return tree.New[Rect](parent...) }

// SetPos sets the [Rect.Pos]:
// position of the top-left of the rectangle
func (t *Rect) SetPos(v math32.Vector2) *Rect { t.Pos = v; return t }

// SetSize sets the [Rect.Size]:
// size of the rectangle
func (t *Rect) SetSize(v math32.Vector2) *Rect { t.Size = v; return t }

// SetRadius sets the [Rect.Radius]:
// radii for curved corners. only rx is used for now.
func (t *Rect) SetRadius(v math32.Vector2) *Rect { t.Radius = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Root", IDName: "root", Doc: "Root represents the root of an SVG tree.", Embeds: []types.Field{{Name: "Group"}}, Fields: []types.Field{{Name: "ViewBox", Doc: "ViewBox defines the coordinate system for the drawing.\nThese units are mapped into the screen space allocated\nfor the SVG during rendering."}}})

// NewRoot returns a new [Root] with the given optional parent:
// Root represents the root of an SVG tree.
func NewRoot(parent ...tree.Node) *Root { return tree.New[Root](parent...) }

// SetViewBox sets the [Root.ViewBox]:
// ViewBox defines the coordinate system for the drawing.
// These units are mapped into the screen space allocated
// for the SVG during rendering.
func (t *Root) SetViewBox(v ViewBox) *Root { t.ViewBox = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/svg.Text", IDName: "text", Doc: "Text renders SVG text, handling both text and tspan elements.\ntspan is nested under a parent text, where text has empty Text string.", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Pos", Doc: "position of the left, baseline of the text"}, {Name: "Width", Doc: "width of text to render if using word-wrapping"}, {Name: "Text", Doc: "text string to render"}, {Name: "TextShaped", Doc: "render version of text"}, {Name: "CharPosX", Doc: "character positions along X axis, if specified"}, {Name: "CharPosY", Doc: "character positions along Y axis, if specified"}, {Name: "CharPosDX", Doc: "character delta-positions along X axis, if specified"}, {Name: "CharPosDY", Doc: "character delta-positions along Y axis, if specified"}, {Name: "CharRots", Doc: "character rotations, if specified"}, {Name: "TextLength", Doc: "author's computed text length, if specified -- we attempt to match"}, {Name: "AdjustGlyphs", Doc: "in attempting to match TextLength, should we adjust glyphs in addition to spacing?"}}})

// NewText returns a new [Text] with the given optional parent:
// Text renders SVG text, handling both text and tspan elements.
// tspan is nested under a parent text, where text has empty Text string.
func NewText(parent ...tree.Node) *Text { return tree.New[Text](parent...) }

// SetPos sets the [Text.Pos]:
// position of the left, baseline of the text
func (t *Text) SetPos(v math32.Vector2) *Text { t.Pos = v; return t }

// SetWidth sets the [Text.Width]:
// width of text to render if using word-wrapping
func (t *Text) SetWidth(v float32) *Text { t.Width = v; return t }

// SetText sets the [Text.Text]:
// text string to render
func (t *Text) SetText(v string) *Text { t.Text = v; return t }

// SetTextShaped sets the [Text.TextShaped]:
// render version of text
func (t *Text) SetTextShaped(v *shaped.Lines) *Text { t.TextShaped = v; return t }

// SetCharPosX sets the [Text.CharPosX]:
// character positions along X axis, if specified
func (t *Text) SetCharPosX(v ...float32) *Text { t.CharPosX = v; return t }

// SetCharPosY sets the [Text.CharPosY]:
// character positions along Y axis, if specified
func (t *Text) SetCharPosY(v ...float32) *Text { t.CharPosY = v; return t }

// SetCharPosDX sets the [Text.CharPosDX]:
// character delta-positions along X axis, if specified
func (t *Text) SetCharPosDX(v ...float32) *Text { t.CharPosDX = v; return t }

// SetCharPosDY sets the [Text.CharPosDY]:
// character delta-positions along Y axis, if specified
func (t *Text) SetCharPosDY(v ...float32) *Text { t.CharPosDY = v; return t }

// SetCharRots sets the [Text.CharRots]:
// character rotations, if specified
func (t *Text) SetCharRots(v ...float32) *Text { t.CharRots = v; return t }

// SetTextLength sets the [Text.TextLength]:
// author's computed text length, if specified -- we attempt to match
func (t *Text) SetTextLength(v float32) *Text { t.TextLength = v; return t }

// SetAdjustGlyphs sets the [Text.AdjustGlyphs]:
// in attempting to match TextLength, should we adjust glyphs in addition to spacing?
func (t *Text) SetAdjustGlyphs(v bool) *Text { t.AdjustGlyphs = v; return t }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "fmt"
        "log"
        "math/rand"
        "slices"
        "strconv"
        "strings"
        "unicode"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/tree"
)

/////////////////////////////////////////////////////////////////////////////
//   Naming elements with unique id's

// SplitNameIDDig splits name into numerical end part and preceding name,
// based on string of digits from end of name.
// If Id == 0 then it was not specified or didn't parse.
// SVG object names are element names + numerical id
func SplitNameIDDig(nm string) (string, int) {
        sz := len(nm)

        for i := sz - 1; i >= 0; i-- {
                c := rune(nm[i])
                if !unicode.IsDigit(c) {
                        if i == sz-1 {
                                return nm, 0
                        }
                        n := nm[:i+1]
                        id, _ := strconv.Atoi(nm[i+1:])
                        return n, id
                }
        }
        return nm, 0
}

// SplitNameID splits name after the element name (e.g., 'rect')
// returning true if it starts with element name,
// and numerical id part after that element.
// if numerical id part is 0, then it didn't parse.
// SVG object names are element names + numerical id
func SplitNameID(elnm, nm string) (bool, int) {
        if !strings.HasPrefix(nm, elnm) {
                // fmt.Printf("not elnm: %s  %s\n", nm, elnm)
                return false, 0
        }
        idstr := nm[len(elnm):]
        id, _ := strconv.Atoi(idstr)
        return true, id
}

// NameID returns the name with given unique id.
// returns plain name if id == 0
func NameID(nm string, id int) string {
        if id == 0 {
                return nm
        }
        return fmt.Sprintf("%s%d", nm, id)
}

// GatherIDs gathers all the numeric id suffixes currently in use.
// It automatically renames any that are not unique or empty.
func (sv *SVG) GatherIDs() {
        sv.UniqueIDs = make(map[int]struct{})
        sv.Root.WalkDown(func(n tree.Node) bool {
                sv.NodeEnsureUniqueID(n.(Node))
                return tree.Continue
        })
}

// NodeEnsureUniqueID ensures that the given node has a unique ID.
// Call this on any newly created nodes.
func (sv *SVG) NodeEnsureUniqueID(n Node) {
        elnm := n.SVGName()
        if elnm == "" {
                return
        }
        nb := n.AsNodeBase()
        elpfx, id := SplitNameID(elnm, nb.Name)
        if !elpfx {
                if !n.EnforceSVGName() { // if we end in a number, just register it anyway
                        _, id = SplitNameIDDig(nb.Name)
                        if id > 0 {
                                sv.UniqueIDs[id] = struct{}{}
                        }
                        return
                }
                _, id = SplitNameIDDig(nb.Name)
                if id > 0 {
                        nb.SetName(NameID(elnm, id))
                }
        }
        _, exists := sv.UniqueIDs[id]
        if id <= 0 || exists {
                id = sv.NewUniqueID() // automatically registers it
                nb.SetName(NameID(elnm, id))
        } else {
                sv.UniqueIDs[id] = struct{}{}
        }
}

// NewUniqueID returns a new unique numerical id number, for naming an object
func (sv *SVG) NewUniqueID() int {
        if sv.UniqueIDs == nil {
                sv.GatherIDs()
        }
        sz := len(sv.UniqueIDs)
        var nid int
        for {
                switch {
                case sz >= 10000:
                        nid = rand.Intn(sz * 100)
                case sz >= 1000:
                        nid = rand.Intn(10000)
                default:
                        nid = rand.Intn(1000)
                }
                if _, has := sv.UniqueIDs[nid]; has {
                        continue
                }
                break
        }
        sv.UniqueIDs[nid] = struct{}{}
        return nid
}

// FindDefByName finds Defs item by name, using cached indexes for speed
func (sv *SVG) FindDefByName(defnm string) Node {
        if sv.DefIndexes == nil {
                sv.DefIndexes = make(map[string]int)
        }
        idx, has := sv.DefIndexes[defnm]
        if !has {
                idx = len(sv.Defs.Children) / 2
        }
        dn := sv.Defs.ChildByName(defnm, idx)
        if dn != nil {
                sv.DefIndexes[defnm] = dn.AsTree().IndexInParent()
                return dn.(Node)
        }
        delete(sv.DefIndexes, defnm) // not found, so delete from map
        return nil
}

func (sv *SVG) FindNamedElement(name string) Node {
        name = strings.TrimPrefix(name, "#")
        def := sv.FindDefByName(name)
        if def != nil {
                return def
        }
        sv.Root.WalkDown(func(n tree.Node) bool {
                if n.AsTree().Name == name {
                        def = n.(Node)
                        return tree.Break
                }
                return tree.Continue
        })
        if def != nil {
                return def
        }
        log.Printf("SVG FindNamedElement: could not find name: %v\n", name)
        return nil
}

// NameFromURL returns just the name referred to in a url(#name)
// if it is not a url(#) format then returns empty string.
func NameFromURL(url string) string {
        if len(url) < 7 {
                return ""
        }
        if url[:5] != "url(#" {
                return ""
        }
        ref := url[5:]
        sz := len(ref)
        if ref[sz-1] == ')' {
                ref = ref[:sz-1]
        }
        return ref
}

// NameToURL returns url as: url(#name)
func NameToURL(nm string) string {
        return "url(#" + nm + ")"
}

// NodeFindURL finds a url element in the parent SVG of given node.
// Returns nil if not found.
// Works with full 'url(#Name)' string or plain name or "none"
func (sv *SVG) NodeFindURL(n Node, url string) Node {
        if url == "none" {
                return nil
        }
        ref := NameFromURL(url)
        if ref == "" {
                ref = url
        }
        if ref == "" {
                return nil
        }
        rv := sv.FindNamedElement(ref)
        if rv == nil {
                log.Printf("svg.NodeFindURL could not find element named: %s for element: %s\n", url, n.AsTree().Path())
        }
        return rv
}

// NodePropURL returns a url(#name) url from given prop name on node,
// or empty string if none.  Returned value is just the 'name' part
// of the url, not the full string.
func NodePropURL(n Node, prop string) string {
        fp := n.AsTree().Property(prop)
        fs, iss := fp.(string)
        if !iss {
                return ""
        }
        return NameFromURL(fs)
}

const SVGRefCountKey = "SVGRefCount"

func IncRefCount(k tree.Node) {
        rc := k.AsTree().Property(SVGRefCountKey).(int)
        rc++
        k.AsTree().SetProperty(SVGRefCountKey, rc)
}

// RemoveOrphanedDefs removes any items from Defs that are not actually referred to
// by anything in the current SVG tree.  Returns true if items were removed.
// Does not remove gradients with StopsName = "" with extant stops -- these
// should be removed manually, as they are not automatically generated.
func (sv *SVG) RemoveOrphanedDefs() bool {
        refkey := SVGRefCountKey
        for _, k := range sv.Defs.Children {
                k.AsTree().SetProperty(refkey, 0)
        }
        sv.Root.WalkDown(func(k tree.Node) bool {
                pr := k.AsTree().Properties
                for _, v := range pr {
                        ps := reflectx.ToString(v)
                        if !strings.HasPrefix(ps, "url(#") {
                                continue
                        }
                        nm := NameFromURL(ps)
                        el := sv.FindDefByName(nm)
                        if el != nil {
                                IncRefCount(el)
                        }
                }
                if gr, isgr := k.(*Gradient); isgr {
                        if gr.StopsName != "" {
                                el := sv.FindDefByName(gr.StopsName)
                                if el != nil {
                                        IncRefCount(el)
                                }
                        } else {
                                if gr.Grad != nil && len(gr.Grad.AsBase().Stops) > 0 {
                                        IncRefCount(k) // keep us around
                                }
                        }
                }
                return tree.Continue
        })
        sz := len(sv.Defs.Children)
        del := false
        for i := sz - 1; i >= 0; i-- {
                n := sv.Defs.Children[i]
                rc := n.AsTree().Property(refkey).(int)
                if rc == 0 {
                        fmt.Printf("Deleting unused item: %s\n", n.AsTree().Name)
                        sv.Defs.Children = slices.Delete(sv.Defs.Children, i, i+1)
                        del = true
                } else {
                        n.AsTree().DeleteProperty(refkey)
                }
        }
        return del
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "errors"
        "fmt"
        "strings"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
)

////////////////////////////////////////////////////////////////////////////////////////
// ViewBox defines the SVG viewbox

// ViewBox is used in SVG to define the coordinate system
type ViewBox struct {

        // offset or starting point in parent Viewport2D
        Min math32.Vector2

        // size of viewbox within parent Viewport2D
        Size math32.Vector2

        // how to scale the view box within parent
        PreserveAspectRatio ViewBoxPreserveAspectRatio
}

// Defaults returns viewbox to defaults
func (vb *ViewBox) Defaults() {
        vb.Min = math32.Vector2{}
        vb.Size = math32.Vec2(100, 100)
        vb.PreserveAspectRatio.Align.Set(AlignMid)
        vb.PreserveAspectRatio.MeetOrSlice = Meet
}

// BoxString returns the string representation of just the viewbox:
// "min.X min.Y size.X size.Y"
func (vb *ViewBox) BoxString() string {
        return fmt.Sprintf(`viewbox="%g %g %g %g"`, vb.Min.X, vb.Min.Y, vb.Size.X, vb.Size.Y)
}

func (vb *ViewBox) String() string {
        return vb.BoxString() + ` preserveAspectRatio="` + vb.PreserveAspectRatio.String() + `"`
}

// Transform returns the transform based on viewbox size relative to given box
// (viewport) size that it will be rendered into
func (vb *ViewBox) Transform(box math32.Vector2) (size, trans, scale math32.Vector2) {
        of := styles.FitFill
        switch {
        case vb.PreserveAspectRatio.Align.X == AlignNone:
                of = styles.FitFill
        case vb.PreserveAspectRatio.MeetOrSlice == Meet:
                of = styles.FitContain
        case vb.PreserveAspectRatio.MeetOrSlice == Slice:
                of = styles.FitCover
        }
        if vb.Size.X == 0 || vb.Size.Y == 0 {
                vb.Size = math32.Vec2(100, 100)
        }
        size = styles.ObjectSizeFromFit(of, vb.Size, box)
        scale = size.Div(vb.Size)
        extra := box.Sub(size)
        if extra.X > 0 {
                trans.X = extra.X * vb.PreserveAspectRatio.Align.X.AlignFactor()
        }
        if extra.Y > 0 {
                trans.Y = extra.Y * vb.PreserveAspectRatio.Align.Y.AlignFactor()
        }
        trans.SetDiv(scale)
        return
}

// ViewBoxAlign defines values for the PreserveAspectRatio alignment factor
type ViewBoxAligns int32 //enums:enum -trim-prefix Align -transform lower

const (
        // align ViewBox.Min with midpoint of Viewport (default)
        AlignMid ViewBoxAligns = iota

        // do not preserve uniform scaling (if either X or Y is None, both are treated as such).
        // In this case, the Meet / Slice value is ignored.
        // This is the same as FitFill from styles.ObjectFits
        AlignNone

        // align ViewBox.Min with top / left of Viewport
        AlignMin

        // align ViewBox.Min+Size with bottom / right of Viewport
        AlignMax
)

// Aligns returns the styles.Aligns version of ViewBoxAligns
func (va ViewBoxAligns) Aligns() styles.Aligns {
        switch va {
        case AlignNone:
                return styles.Start
        case AlignMin:
                return styles.Start
        case AlignMax:
                return styles.End
        default:
                return styles.Center
        }
}

// SetFromAligns sets alignment from the styles.Aligns version of ViewBoxAligns
func (va *ViewBoxAligns) SetFromAligns(a styles.Aligns) {
        switch a {
        case styles.Start:
                *va = AlignMin
        case styles.End:
                *va = AlignMax
        case styles.Center:
                *va = AlignMid
        }
}

// AlignFactor returns the alignment factor for proportion offset
func (va ViewBoxAligns) AlignFactor() float32 {
        return styles.AlignFactor(va.Aligns())
}

// ViewBoxMeetOrSlice defines values for the PreserveAspectRatio meet or slice factor
type ViewBoxMeetOrSlice int32 //enums:enum -transform lower

const (
        // Meet only applies if Align != None (i.e., only for uniform scaling),
        // and means the entire ViewBox is visible within Viewport,
        // and it is scaled up as much as possible to meet the align constraints.
        // This is the same as FitContain from styles.ObjectFits
        Meet ViewBoxMeetOrSlice = iota

        // Slice only applies if Align != None (i.e., only for uniform scaling),
        // and means the entire ViewBox is covered by the ViewBox, and the
        // ViewBox is scaled down as much as possible, while still meeting the
        // align constraints.
        // This is the same as FitCover from styles.ObjectFits
        Slice
)

// ViewBoxPreserveAspectRatio determines how to scale the view box within parent Viewport2D
type ViewBoxPreserveAspectRatio struct {

        // how to align X, Y coordinates within viewbox
        Align styles.XY[ViewBoxAligns] `xml:"align"`

        // how to scale the view box relative to the viewport
        MeetOrSlice ViewBoxMeetOrSlice `xml:"meetOrSlice"`
}

func (pa *ViewBoxPreserveAspectRatio) String() string {
        if pa.Align.X == AlignNone {
                return "none"
        }
        xs := "xM" + pa.Align.X.String()[1:]
        ys := "YM" + pa.Align.Y.String()[1:]
        s := xs + ys
        if pa.MeetOrSlice != Meet {
                s += " slice"
        }
        return s
}

// SetString sets from a standard svg-formatted string,
// consisting of:
// none | x[Min, Mid, Max]Y[Min, Mid, Max] [ meet | slice]
// e.g., "xMidYMid meet" (default)
// It does not make sense to specify "meet | slice" for "none"
// as they do not apply in that case.
func (pa *ViewBoxPreserveAspectRatio) SetString(s string) error {
        s = strings.TrimSpace(s)
        if len(s) == 0 {
                pa.Align.Set(AlignMid, AlignMid)
                pa.MeetOrSlice = Meet
                return nil
        }
        sl := strings.ToLower(s)
        f := strings.Fields(sl)
        if strings.HasPrefix(f[0], "none") {
                pa.Align.Set(AlignNone)
                pa.MeetOrSlice = Meet
                return nil
        }
        var errs []error
        if len(f) > 1 {
                switch f[1] {
                case "slice":
                        pa.MeetOrSlice = Slice
                case "meet":
                        pa.MeetOrSlice = Meet
                default:
                        errs = append(errs, fmt.Errorf("ViewBoxPreserveAspectRatio: 2nd value must be meet or slice, not %q", f[1]))
                }
        }

        yi := strings.Index(f[0], "y")
        if yi < 0 {
                return fmt.Errorf("ViewBoxPreserveAspectRatio: string %q must contain a 'y'", s)
        }
        xs := f[0][1:yi]
        ys := f[0][yi+1:]

        err := pa.Align.X.SetString(xs)
        if err != nil {
                errs = append(errs, fmt.Errorf("ViewBoxPreserveAspectRatio: X align be min, mid, or max, not %q", xs))
        }

        err = pa.Align.Y.SetString(ys)
        if err != nil {
                errs = append(errs, fmt.Errorf("ViewBoxPreserveAspectRatio: Y align be min, mid, or max, not %q", ys))
        }
        if len(errs) == 0 {
                return nil
        }
        return errors.Join(errs...)
}

// SetFromStyle sets from ObjectFit and Justify (X) and Align (Y) Content
// in given style.
func (pa *ViewBoxPreserveAspectRatio) SetFromStyle(s *styles.Style) {
        pa.Align.X.SetFromAligns(s.Justify.Content)
        pa.Align.Y.SetFromAligns(s.Align.Content)

        // todo: could override with ObjectPosition but maybe not worth it?

        switch s.ObjectFit {
        case styles.FitFill:
                pa.Align.Set(AlignNone)
        case styles.FitContain:
                pa.MeetOrSlice = Meet
        case styles.FitCover, styles.FitScaleDown: // note: FitScaleDown not handled
                pa.MeetOrSlice = Slice
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package svg

import (
        "bufio"
        "bytes"
        "encoding/xml"
        "errors"
        "io"
        "unicode/utf8"
)

// XMLEncoder is a minimal XML encoder that formats output with Attr
// each on a new line, using same API as xml.Encoder
type XMLEncoder struct {
        Writer      io.Writer
        DoIndent    bool
        IndBytes    []byte
        PreBytes    []byte
        CurIndent   int
        CurStart    string
        NoEndIndent bool
}

func NewXMLEncoder(wr io.Writer) *XMLEncoder {
        return &XMLEncoder{Writer: wr}
}

func (xe *XMLEncoder) Indent(prefix, indent string) {
        if len(indent) > 0 {
                xe.DoIndent = true
        }
        xe.IndBytes = []byte(indent)
        xe.PreBytes = []byte(prefix)
}

func (xe *XMLEncoder) EncodeToken(t xml.Token) error {
        switch t := t.(type) {
        case xml.StartElement:
                if err := xe.WriteStart(&t); err != nil {
                        return err
                }
        case xml.EndElement:
                if err := xe.WriteEnd(t.Name.Local); err != nil {
                        return err
                }
        case xml.CharData:
                if xe.CurStart != "" {
                        xe.WriteString(">")
                        xe.CurStart = ""
                        xe.NoEndIndent = true // don't indent the end now
                }
                EscapeText(xe.Writer, t, false)
        }
        return nil
}

func (xe *XMLEncoder) WriteString(str string) {
        xe.Writer.Write([]byte(str))
}

func (xe *XMLEncoder) WriteIndent() {
        xe.Writer.Write(xe.PreBytes)
        xe.Writer.Write(bytes.Repeat(xe.IndBytes, xe.CurIndent))
}

func (xe *XMLEncoder) WriteEOL() {
        xe.Writer.Write([]byte("\n"))
}

// Decide whether the given rune is in the XML Character Range, per
// the Char production of https://www.xml.com/axml/testaxml.htm,
// Section 2.2 Characters.
func isInCharacterRange(r rune) (inrange bool) {
        return r == 0x09 ||
                r == 0x0A ||
                r == 0x0D ||
                r >= 0x20 && r <= 0xD7FF ||
                r >= 0xE000 && r <= 0xFFFD ||
                r >= 0x10000 && r <= 0x10FFFF
}

var (
        escQuot = []byte("&#34;") // shorter than "&quot;"
        escApos = []byte("&#39;") // shorter than "&apos;"
        escAmp  = []byte("&amp;")
        escLT   = []byte("&lt;")
        escGT   = []byte("&gt;")
        escTab  = []byte("&#x9;")
        escNL   = []byte("&#xA;")
        escCR   = []byte("&#xD;")
        escFFFD = []byte("\uFFFD") // Unicode replacement character
)

// XMLEscapeText writes to w the properly escaped XML equivalent
// of the plain text data s. If escapeNewline is true, newline
// XMLcharacters will be escaped.
func EscapeText(w io.Writer, s []byte, escapeNewline bool) error {
        var esc []byte
        last := 0
        for i := 0; i < len(s); {
                r, width := utf8.DecodeRune(s[i:])
                i += width
                switch r {
                case '"':
                        esc = escQuot
                case '\'':
                        esc = escApos
                case '&':
                        esc = escAmp
                case '<':
                        esc = escLT
                case '>':
                        esc = escGT
                case '\t':
                        esc = escTab
                case '\n':
                        if !escapeNewline {
                                continue
                        }
                        esc = escNL
                case '\r':
                        esc = escCR
                default:
                        if !isInCharacterRange(r) || (r == 0xFFFD && width == 1) {
                                esc = escFFFD
                                break
                        }
                        continue
                }
                if _, err := w.Write(s[last : i-width]); err != nil {
                        return err
                }
                if _, err := w.Write(esc); err != nil {
                        return err
                }
                last = i
        }
        _, err := w.Write(s[last:])
        return err
}

// EscapeString writes to p the properly escaped XML equivalent
// of the plain text data s.
func (xe *XMLEncoder) EscapeString(s string, escapeNewline bool) {
        var esc []byte
        last := 0
        for i := 0; i < len(s); {
                r, width := utf8.DecodeRuneInString(s[i:])
                i += width
                switch r {
                case '"':
                        esc = escQuot
                case '\'':
                        esc = escApos
                case '&':
                        esc = escAmp
                case '<':
                        esc = escLT
                case '>':
                        esc = escGT
                case '\t':
                        esc = escTab
                case '\n':
                        if !escapeNewline {
                                continue
                        }
                        esc = escNL
                case '\r':
                        esc = escCR
                default:
                        if !isInCharacterRange(r) || (r == 0xFFFD && width == 1) {
                                esc = escFFFD
                                break
                        }
                        continue
                }
                xe.WriteString(s[last : i-width])
                xe.Writer.Write(esc)
                last = i
        }
        xe.WriteString(s[last:])
}

func (xe *XMLEncoder) WriteStart(start *xml.StartElement) error {
        if start.Name.Local == "" {
                return errors.New("xml: start tag with no name")
        }
        if xe.CurStart != "" {
                xe.WriteString(">")
                xe.WriteEOL()
        }
        xe.WriteIndent()
        xe.WriteString("<")
        xe.WriteString(start.Name.Local)
        xe.CurIndent++

        xe.CurStart = start.Name.Local

        // Attributes
        for _, attr := range start.Attr {
                name := attr.Name
                if name.Local == "" {
                        continue
                }
                xe.WriteEOL()
                xe.WriteIndent()
                xe.WriteString(name.Local)
                xe.WriteString(`="`)
                xe.EscapeString(attr.Value, false)
                xe.WriteString(`"`)
        }
        return nil
}

func (xe *XMLEncoder) WriteEnd(name string) error {
        xe.CurIndent--
        if name == "" {
                return errors.New("xml: end tag with no name")
        }
        if xe.CurStart == name {
                xe.WriteString(" />")
                xe.WriteEOL()
        } else {
                if !xe.NoEndIndent {
                        xe.WriteIndent()
                }
                xe.NoEndIndent = false
                xe.WriteString("</")
                xe.WriteString(name)
                xe.WriteString(">")
                xe.WriteEOL()
        }
        xe.CurStart = ""
        xe.Flush()
        return nil
}

func (xe *XMLEncoder) Flush() {
        if bw, isb := xe.Writer.(*bufio.Writer); isb {
                bw.Flush()
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package csl

import (
        "unicode"

        "cogentcore.org/core/text/rich"
)

// definitive reference:
// https://apastyle.apa.org/style-grammar-guidelines/references/examples

// CiteAPA generates a APA-style citation, as Last[ & Last|et al.] Year
// with a , before Year in Parenthetical style, and Parens around the Year
// in Narrative style.
func CiteAPA(cs CiteStyles, it *Item) string {
        c := ""
        if len(it.Author) > 0 {
                c = NamesCiteEtAl(it.Author)
        } else {
                c = NamesCiteEtAl(it.Editor)
        }
        switch cs {
        case Parenthetical:
                c += ", " + it.Issued.Year()
        case Narrative:
                c += " (" + it.Issued.Year() + ")"
        }
        return c
}

// RefAPA generates an APA-style reference entry from the given item,
// with rich.Text formatting of italics around the source, volume,
// and spans for each separate chunk.
// Use Join method to get full raw text.
func RefAPA(it *Item) rich.Text {
        switch it.Type {
        case Book, Collection:
                return RefAPABook(it)
        case Chapter, PaperConference:
                return RefAPAChapter(it)
        case Thesis:
                return RefAPAThesis(it)
        case Article, ArticleJournal, ArticleMagazine, ArticleNewspaper:
                return RefAPAArticle(it)
        default:
                return RefAPAMisc(it)
        }
}

// RefsAPA generates a list of APA-style reference entries
// and correspondingly ordered items for given keylist.
// APA uses alpha sort order.
func RefsAPA(kl *KeyList) ([]rich.Text, []*Item) {
        refs := make([]rich.Text, kl.Len())
        items := make([]*Item, kl.Len())
        ks := kl.AlphaKeys()
        for i, k := range ks {
                it := kl.At(k)
                refs[i] = RefAPA(it)
                items[i] = it
        }
        return refs, items
}

func RefLinks(it *Item, tx *rich.Text) {
        link := rich.NewStyle().SetLinkStyle()
        if it.URL != "" {
                tx.AddLink(link, it.URL, it.URL)
        }
        if it.DOI != "" {
                url := " http://doi.org/" + it.DOI
                tx.AddLink(link, url, url)
        }
}

// EnsurePeriod returns a string that ends with a . if it doesn't
// already end in some form of punctuation.
func EnsurePeriod(s string) string {
        if !unicode.IsPunct(rune(s[len(s)-1])) {
                s += "."
        }
        return s
}

func RefAPABook(it *Item) rich.Text {
        sty := rich.NewStyle()
        ital := sty.Clone().SetSlant(rich.Italic)
        auths := ""
        if len(it.Author) > 0 {
                auths = NamesLastFirstInitialCommaAmpersand(it.Author)
        } else if len(it.Editor) > 0 {
                auths = NamesLastFirstInitialCommaAmpersand(it.Editor) + " (Ed"
                if len(it.Editor) == 1 {
                        auths += ".)"
                } else {
                        auths += "s.)"
                }
        }
        tx := rich.NewText(sty, []rune(auths+" "))
        tx.AddSpanString(sty, "("+it.Issued.Year()+"). ")
        if it.Title != "" {
                ttl := it.Title
                end := rune(ttl[len(ttl)-1])
                if it.Edition != "" {
                        if unicode.IsPunct(end) {
                                ttl = ttl[:len(ttl)-1]
                        } else {
                                end = '.'
                        }
                        tx.AddSpanString(ital, ttl)
                        tx.AddSpanString(sty, " ("+it.Edition+" ed)"+string(end)+" ")
                } else {
                        tx.AddSpanString(ital, EnsurePeriod(ttl)+" ")
                }
        }
        if it.Publisher != "" {
                tx.AddSpanString(sty, EnsurePeriod(it.Publisher)+" ")
        }
        RefLinks(it, &tx)
        return tx
}

func RefAPAChapter(it *Item) rich.Text {
        sty := rich.NewStyle()
        ital := sty.Clone().SetSlant(rich.Italic)
        tx := rich.NewText(sty, []rune(NamesLastFirstInitialCommaAmpersand(it.Author)+" "))
        tx.AddSpanString(sty, "("+it.Issued.Year()+"). ")
        contStyle := ital
        if it.Title != "" {
                if len(it.Editor) == 0 || it.ContainerTitle == "" {
                        contStyle = sty
                        tx.AddSpanString(ital, EnsurePeriod(it.Title)+" ")
                } else {
                        tx.AddSpanString(sty, EnsurePeriod(it.Title)+" ")
                }
        }
        if len(it.Editor) > 0 {
                eds := "In " + NamesFirstInitialLastCommaAmpersand(it.Editor)
                if len(it.Editor) == 1 {
                        eds += " (Ed.), "
                } else {
                        eds += " (Eds.), "
                }
                tx.AddSpanString(sty, eds)
        } else {
                tx.AddSpanString(sty, "In ")
        }
        if it.ContainerTitle != "" {
                ttl := it.ContainerTitle
                end := rune(ttl[len(ttl)-1])
                pp := ""
                if it.Edition != "" {
                        pp = "(" + it.Edition + " ed."
                }
                if it.Page != "" {
                        if pp != "" {
                                pp += ", "
                        } else {
                                pp = "("
                        }
                        pp += "pp. " + it.Page
                }
                if pp != "" {
                        pp = " " + pp + ")"
                        if unicode.IsPunct(end) {
                                ttl = ttl[:len(ttl)-1]
                                pp += string(end)
                        } else {
                                pp += "."
                        }
                        tx.AddSpanString(contStyle, ttl)
                        tx.AddSpanString(sty, pp+" ")
                } else {
                        tx.AddSpanString(contStyle, EnsurePeriod(it.ContainerTitle)+" ")
                }
        }
        if it.Publisher != "" {
                tx.AddSpanString(sty, EnsurePeriod(it.Publisher)+" ")
        }
        RefLinks(it, &tx)
        return tx
}

func RefAPAArticle(it *Item) rich.Text {
        sty := rich.NewStyle()
        ital := sty.Clone().SetSlant(rich.Italic)
        tx := rich.NewText(sty, []rune(NamesLastFirstInitialCommaAmpersand(it.Author)+" "))
        tx.AddSpanString(sty, "("+it.Issued.Year()+"). ")
        if it.Title != "" {
                tx.AddSpanString(sty, EnsurePeriod(it.Title)+" ")
        }
        jt := ""
        if it.ContainerTitle != "" {
                jt = it.ContainerTitle + ", "
        }
        if it.Volume != "" {
                jt += it.Volume
        }
        if jt != "" {
                tx.AddSpanString(ital, jt)
        }
        if it.Volume != "" {
                if it.Number != "" {
                        tx.AddSpanString(sty, "("+it.Number+"), ")
                } else {
                        tx.AddSpanString(sty, ", ")
                }
        }
        if it.Page != "" {
                tx.AddSpanString(sty, it.Page+". ")
        }
        RefLinks(it, &tx)
        return tx
}

func RefAPAThesis(it *Item) rich.Text {
        sty := rich.NewStyle()
        ital := sty.Clone().SetSlant(rich.Italic)
        tx := rich.NewText(sty, []rune(NamesLastFirstInitialCommaAmpersand(it.Author)+" "))
        tx.AddSpanString(sty, "("+it.Issued.Year()+"). ")
        if it.Title != "" {
                tx.AddSpanString(ital, EnsurePeriod(it.Title)+" ")
        }
        tt := "["
        if it.Source == "" {
                tt += "unpublished "
        }
        if it.Genre == "" {
                tt += "thesis"
        } else {
                tt += it.Genre
        }
        if it.Publisher != "" {
                tt += ", " + it.Publisher
        }
        tt += "]. "
        tx.AddSpanString(sty, tt)
        if it.Source != "" {
                tx.AddSpanString(sty, EnsurePeriod(it.Source)+" ")
        }
        RefLinks(it, &tx)
        return tx
}

func RefAPAMisc(it *Item) rich.Text {
        sty := rich.NewStyle()
        ital := sty.Clone().SetSlant(rich.Italic)
        tx := rich.NewText(sty, []rune(NamesLastFirstInitialCommaAmpersand(it.Author)+" "))
        tx.AddSpanString(sty, "("+it.Issued.Year()+"). ")
        if it.Title != "" {
                tx.AddSpanString(ital, EnsurePeriod(it.Title)+" ")
        }
        jt := ""
        if it.ContainerTitle != "" {
                jt = it.ContainerTitle + ", "
        }
        if it.Volume != "" {
                jt += it.Volume
        }
        if jt != "" {
                tx.AddSpanString(sty, jt)
        }
        if it.Volume != "" {
                if it.Number != "" {
                        tx.AddSpanString(sty, "("+it.Number+"), ")
                } else {
                        tx.AddSpanString(sty, ", ")
                }
        }
        if it.Page != "" {
                tx.AddSpanString(sty, it.Page+". ")
        }
        if it.Genre != "" {
                tx.AddSpanString(sty, EnsurePeriod(it.Genre)+" ")
        } else {
                tx.AddSpanString(sty, it.Type.String()+". ")
        }
        if it.Source != "" {
                tx.AddSpanString(sty, EnsurePeriod(it.Source)+" ")
        }
        if it.Publisher != "" {
                tx.AddSpanString(sty, EnsurePeriod(it.Publisher)+" ")
        }
        RefLinks(it, &tx)
        return tx
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package csl

import "strings"

// The CSL input model supports two different date representations:
// an EDTF string (preferred), and a more structured alternative.
type Date struct {
        DateParts [][]any `json:"date-parts,omitempty"`
        Season    any     `json:"season,omitempty"`
        Circa     string  `json:"circa,omitempty"`
        Literal   string  `json:"literal,omitempty"`
        Raw       string  `json:"raw,omitempty"`
}

func (dt *Date) Year() string {
        if len(dt.DateParts) > 0 {
                if len(dt.DateParts[0]) > 0 {
                        return dt.DateParts[0][0].(string) // this is normally it
                }
        }
        str := dt.Literal
        if str == "" {
                str = dt.Raw
        }
        if str == "" {
                str = dt.Circa
        }
        if str == "" {
                return "undated"
        }
        fs := strings.Fields(str)
        for _, s := range fs {
                if len(s) == 4 {
                        return s
                }
        }
        return str
}

// Code generated by "core generate"; DO NOT EDIT.

package csl

import (
        "cogentcore.org/core/enums"
)

var _StylesValues = []Styles{0}

// StylesN is the highest valid value for type Styles, plus one.
const StylesN Styles = 1

var _StylesValueMap = map[string]Styles{`APA`: 0}

var _StylesDescMap = map[Styles]string{0: ``}

var _StylesMap = map[Styles]string{0: `APA`}

// String returns the string representation of this Styles value.
func (i Styles) String() string { return enums.String(i, _StylesMap) }

// SetString sets the Styles value from its string representation,
// and returns an error if the string is invalid.
func (i *Styles) SetString(s string) error { return enums.SetString(i, s, _StylesValueMap, "Styles") }

// Int64 returns the Styles value as an int64.
func (i Styles) Int64() int64 { return int64(i) }

// SetInt64 sets the Styles value from an int64.
func (i *Styles) SetInt64(in int64) { *i = Styles(in) }

// Desc returns the description of the Styles value.
func (i Styles) Desc() string { return enums.Desc(i, _StylesDescMap) }

// StylesValues returns all possible values for the type Styles.
func StylesValues() []Styles { return _StylesValues }

// Values returns all possible values for the type Styles.
func (i Styles) Values() []enums.Enum { return enums.Values(_StylesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Styles) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Styles) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Styles") }

var _CiteStylesValues = []CiteStyles{0, 1}

// CiteStylesN is the highest valid value for type CiteStyles, plus one.
const CiteStylesN CiteStyles = 2

var _CiteStylesValueMap = map[string]CiteStyles{`Parenthetical`: 0, `Narrative`: 1}

var _CiteStylesDescMap = map[CiteStyles]string{0: `Parenthetical means that the citation is placed within parentheses. This is default for most styles. In the APA style for example, it adds a comma before the year, e.g., "(Smith, 1989)". Note that the parentheses or other outer bracket syntax are NOT generated directly, because often multiple are included together in the same group.`, 1: `Narrative is an active, "inline" form of citation where the cited content is used as the subject of a sentence. In the APA style this puts the year in parentheses, e.g., "Smith (1989) invented the..." In this case the parentheses are generated.`}

var _CiteStylesMap = map[CiteStyles]string{0: `Parenthetical`, 1: `Narrative`}

// String returns the string representation of this CiteStyles value.
func (i CiteStyles) String() string { return enums.String(i, _CiteStylesMap) }

// SetString sets the CiteStyles value from its string representation,
// and returns an error if the string is invalid.
func (i *CiteStyles) SetString(s string) error {
        return enums.SetString(i, s, _CiteStylesValueMap, "CiteStyles")
}

// Int64 returns the CiteStyles value as an int64.
func (i CiteStyles) Int64() int64 { return int64(i) }

// SetInt64 sets the CiteStyles value from an int64.
func (i *CiteStyles) SetInt64(in int64) { *i = CiteStyles(in) }

// Desc returns the description of the CiteStyles value.
func (i CiteStyles) Desc() string { return enums.Desc(i, _CiteStylesDescMap) }

// CiteStylesValues returns all possible values for the type CiteStyles.
func CiteStylesValues() []CiteStyles { return _CiteStylesValues }

// Values returns all possible values for the type CiteStyles.
func (i CiteStyles) Values() []enums.Enum { return enums.Values(_CiteStylesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i CiteStyles) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *CiteStyles) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "CiteStyles")
}

var _TypesValues = []Types{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44}

// TypesN is the highest valid value for type Types, plus one.
const TypesN Types = 45

var _TypesValueMap = map[string]Types{`article`: 0, `article-journal`: 1, `article-magazine`: 2, `article-newspaper`: 3, `bill`: 4, `book`: 5, `broadcast`: 6, `chapter`: 7, `classic`: 8, `collection`: 9, `dataset`: 10, `document`: 11, `entry`: 12, `entry-dictionary`: 13, `entry-encyclopedia`: 14, `event`: 15, `figure`: 16, `graphic`: 17, `hearing`: 18, `interview`: 19, `legal-case`: 20, `legislation`: 21, `manuscript`: 22, `map`: 23, `motion-picture`: 24, `musical-score`: 25, `pamphlet`: 26, `paper-conference`: 27, `patent`: 28, `performance`: 29, `periodical`: 30, `personal-communication`: 31, `post`: 32, `post-weblog`: 33, `regulation`: 34, `report`: 35, `review`: 36, `review-book`: 37, `software`: 38, `song`: 39, `speech`: 40, `standard`: 41, `thesis`: 42, `treaty`: 43, `webpage`: 44}

var _TypesDescMap = map[Types]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``, 5: ``, 6: ``, 7: ``, 8: ``, 9: ``, 10: ``, 11: ``, 12: ``, 13: ``, 14: ``, 15: ``, 16: ``, 17: ``, 18: ``, 19: ``, 20: ``, 21: ``, 22: ``, 23: ``, 24: ``, 25: ``, 26: ``, 27: ``, 28: ``, 29: ``, 30: ``, 31: ``, 32: ``, 33: ``, 34: ``, 35: ``, 36: ``, 37: ``, 38: ``, 39: ``, 40: ``, 41: ``, 42: ``, 43: ``, 44: ``}

var _TypesMap = map[Types]string{0: `article`, 1: `article-journal`, 2: `article-magazine`, 3: `article-newspaper`, 4: `bill`, 5: `book`, 6: `broadcast`, 7: `chapter`, 8: `classic`, 9: `collection`, 10: `dataset`, 11: `document`, 12: `entry`, 13: `entry-dictionary`, 14: `entry-encyclopedia`, 15: `event`, 16: `figure`, 17: `graphic`, 18: `hearing`, 19: `interview`, 20: `legal-case`, 21: `legislation`, 22: `manuscript`, 23: `map`, 24: `motion-picture`, 25: `musical-score`, 26: `pamphlet`, 27: `paper-conference`, 28: `patent`, 29: `performance`, 30: `periodical`, 31: `personal-communication`, 32: `post`, 33: `post-weblog`, 34: `regulation`, 35: `report`, 36: `review`, 37: `review-book`, 38: `software`, 39: `song`, 40: `speech`, 41: `standard`, 42: `thesis`, 43: `treaty`, 44: `webpage`}

// String returns the string representation of this Types value.
func (i Types) String() string { return enums.String(i, _TypesMap) }

// SetString sets the Types value from its string representation,
// and returns an error if the string is invalid.
func (i *Types) SetString(s string) error { return enums.SetString(i, s, _TypesValueMap, "Types") }

// Int64 returns the Types value as an int64.
func (i Types) Int64() int64 { return int64(i) }

// SetInt64 sets the Types value from an int64.
func (i *Types) SetInt64(in int64) { *i = Types(in) }

// Desc returns the description of the Types value.
func (i Types) Desc() string { return enums.Desc(i, _TypesDescMap) }

// TypesValues returns all possible values for the type Types.
func TypesValues() []Types { return _TypesValues }

// Values returns all possible values for the type Types.
func (i Types) Values() []enums.Enum { return enums.Values(_TypesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Types) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Types) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Types") }

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package csl

import (
        "io/fs"
        "os"
        "time"

        "cogentcore.org/core/base/iox/jsonx"
        "cogentcore.org/core/text/parse/languages/bibtex"
)

// Open opens CSL data items from a .json formatted CSL file.
func Open(filename string) ([]Item, error) {
        var its []Item
        err := jsonx.Open(&its, filename)
        return its, err
}

// OpenFS opens CSL data items from a .json formatted CSL file from given
// filesystem.
func OpenFS(fsys fs.FS, filename string) ([]Item, error) {
        var its []Item
        err := jsonx.OpenFS(&its, fsys, filename)
        return its, err
}

// SaveItems saves items to given filename.
func SaveItems(items []Item, filename string) error {
        return jsonx.Save(items, filename)
}

// SaveKeyList saves items to given filename.
func SaveKeyList(kl *KeyList, filename string) error {
        return jsonx.Save(kl.Values, filename)
}

////////  File

// File maintains a record for a CSL file.
type File struct {

        // File name, full path.
        File string

        // Items from the file, as a KeyList for easy citation lookup.
        Items *KeyList

        // mod time for loaded file, to detect updates.
        Mod time.Time
}

// Open [re]opens the given filename, looking on standard BIBINPUTS or TEXINPUTS
// env var paths if not found locally. If Mod >= mod timestamp on the file,
// and is already loaded, then nothing happens (already have it), but
// otherwise it parses the file and puts contents in Items.
func (fl *File) Open(fname string) error {
        path := fname
        var err error
        if fl.File == "" {
                path, err = bibtex.FullPath(fname)
                if err != nil {
                        return err
                }
                fl.File = path
                fl.Items = nil
                fl.Mod = time.Time{}
                // fmt.Printf("first open file: %s path: %s\n", fname, fl.File)
        }
        st, err := os.Stat(fl.File)
        if err != nil {
                return err
        }
        if fl.Items != nil && !fl.Mod.Before(st.ModTime()) {
                // fmt.Printf("existing file: %v is fine: file mod: %v  last mod: %v\n", fl.File, st.ModTime(), fl.Mod)
                return nil
        }
        its, err := Open(fl.File)
        if err != nil {
                return err
        }
        fl.Items = NewKeyList(its)
        fl.Mod = st.ModTime()
        // fmt.Printf("(re)loaded bibtex bibliography: %s\n", fl.File)
        return nil
}

//////// Files

// Files is a map of CSL items keyed by file name.
type Files map[string]*File

// Open [re]opens the given filename, looking on standard BIBINPUTS or TEXINPUTS
// env var paths if not found locally.  If Mod >= mod timestamp on the file,
// and Items is already loaded, then nothing happens (already have it), but
// otherwise it parses the file and puts contents in Items field.
func (fl *Files) Open(fname string) (*File, error) {
        if *fl == nil {
                *fl = make(Files)
        }
        fr, has := (*fl)[fname]
        if has {
                err := fr.Open(fname)
                return fr, err
        }
        fr = &File{}
        err := fr.Open(fname)
        if err != nil {
                return nil, err
        }
        (*fl)[fname] = fr
        return fr, nil
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package csl

import (
        "fmt"
        "slices"
        "strings"

        "cogentcore.org/core/base/keylist"
)

// KeyList is an ordered list of citation [Item]s,
// which should be used to collect items by unique citation keys.
type KeyList struct {
        keylist.List[string, *Item]
}

// NewKeyList returns a KeyList from given list of [Item]s.
func NewKeyList(items []Item) *KeyList {
        kl := &KeyList{}
        for i := range items {
                it := &items[i]
                kl.Add(it.CitationKey, it)
        }
        return kl
}

// AlphaKeys returns an alphabetically sorted list of keys.
func (kl *KeyList) AlphaKeys() []string {
        ks := slices.Clone(kl.Keys)
        slices.Sort(ks)
        return ks
}

// PrettyString pretty prints the items using default style.
func (kl *KeyList) PrettyString() string {
        var w strings.Builder
        for _, it := range kl.Values {
                w.WriteString(fmt.Sprintf("%s [%s]:\n", it.CitationKey, it.Type))
                w.WriteString(string(Ref(DefaultStyle, it).Join()) + "\n\n")
        }
        return w.String()
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package csl

import (
        "bufio"
        "io"
        "os"
        "path/filepath"
        "regexp"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fsx"
)

// GenerateMarkdown extracts markdown citations in the format [@Ref; @Ref]
// from .md markdown files in given directory, looking up in given source [KeyList],
// and writing the results in given style to given .md file (references.md default).
// Heading is written first: must include the appropriate markdown heading level
// (## typically). Returns the [KeyList] of references that were cited.
func GenerateMarkdown(dir, refFile, heading string, kl *KeyList, sty Styles) (*KeyList, error) {
        cited := &KeyList{}
        if dir == "" {
                dir = "./"
        }
        mds := fsx.Filenames(dir, ".md")
        if len(mds) == 0 {
                return cited, errors.New("No .md files found in: " + dir)
        }
        var errs []error
        for i := range mds {
                mds[i] = filepath.Join(dir, mds[i])
        }
        err := ExtractMarkdownCites(mds, kl, cited)
        if err != nil {
                errs = append(errs, err)
        }
        if refFile == "" {
                refFile = filepath.Join(dir, "references.md")
        }
        of, err := os.Create(refFile)
        if err != nil {
                errs = append(errs, err)
                return cited, errors.Join(errs...)
        }
        defer of.Close()
        if heading != "" {
                of.WriteString(heading + "\n\n")
        }
        err = WriteRefsMarkdown(of, cited, sty)
        if err != nil {
                errs = append(errs, err)
        }
        return cited, errors.Join(errs...)
}

// ExtractMarkdownCites extracts markdown citations in the format [@Ref; @Ref]
// from given list of .md files, looking up in given source [KeyList], adding to cited.
func ExtractMarkdownCites(files []string, src, cited *KeyList) error {
        exp := regexp.MustCompile(`\[(@\^?([[:alnum:]]+-?)+(;[[:blank:]]+)?)+\]`)
        var errs []error
        for _, fn := range files {
                f, err := os.Open(fn)
                if err != nil {
                        errs = append(errs, err)
                        continue
                }
                scan := bufio.NewScanner(f)
                for scan.Scan() {
                        cs := exp.FindAllString(string(scan.Bytes()), -1)
                        for _, c := range cs {
                                tc := c[1 : len(c)-1]
                                sp := strings.Split(tc, "@")
                                for _, ac := range sp {
                                        a := strings.TrimSpace(ac)
                                        a = strings.TrimSuffix(a, ";")
                                        if a == "" {
                                                continue
                                        }
                                        if a[0] == '^' {
                                                a = a[1:]
                                        }
                                        it, has := src.AtTry(a)
                                        if !has {
                                                err = errors.New("citation not found: " + a)
                                                errs = append(errs, err)
                                                continue
                                        }
                                        cited.Add(a, it)
                                }
                        }
                }
                f.Close()
        }
        return errors.Join(errs...)
}

// WriteRefsMarkdown writes references from given [KeyList] to a
// markdown file.
func WriteRefsMarkdown(w io.Writer, kl *KeyList, sty Styles) error {
        refs, items := Refs(sty, kl)
        for i, ref := range refs {
                it := items[i]
                _, err := w.Write([]byte(`<p id="` + it.CitationKey + `">`))
                if err != nil {
                        return err
                }
                _, err = w.Write([]byte(string(ref.Join()) + "</p>\n\n")) // todo: ref to markdown!!
                if err != nil {
                        return err
                }
        }
        return nil
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "cogentcore.org/core/cli"
        "cogentcore.org/core/text/csl"
)

//go:generate core generate -add-types -add-funcs

type Config struct {

        // CSL JSON formatted file with the library of references to lookup citations in.
        Refs string `flag:"r,refs" posarg:"0"`

        // Directory with markdown files to extract citations from.
        // Defaults to current directory if empty.
        Dir string `flag:"d,dir"`

        // File name to write the formatted references to.
        // Defaults to references.md if empty.
        Output string `flag:"o,output"`

        // File name to write the subset of cited reference data to.
        // Defaults to citedrefs.json if empty.
        CitedData string `flag:"c,cited"`

        // heading to add to the top of the references file.
        // Include markdown heading syntax, e.g., ##
        // Defaults to ## References if empty.
        Heading string `flag:"h,heading"`

        // style is the citation style to generate.
        // Defaults to APA if empty.
        Style csl.Styles `flag:"s,style"`
}

// Generate extracts citations and generates resulting references file.
func Generate(c *Config) error {
        refs, err := csl.Open(c.Refs)
        if err != nil {
                return err
        }
        kl := csl.NewKeyList(refs)
        cited, err := csl.GenerateMarkdown(c.Dir, c.Output, c.Heading, kl, c.Style)
        cf := c.CitedData
        if cf == "" {
                cf = "citedrefs.json"
        }
        csl.SaveKeyList(cited, cf)
        return err
}

func main() { //types:skip
        opts := cli.DefaultOptions("mdcite", "mdcites extracts markdown citations from .md files in a directory, and writes a references file with the resulting citations, using the default APA style or the specified one.")
        cli.Run(opts, &Config{}, Generate)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package csl

import (
        "fmt"
        "strings"
)

// Name represents a persons name.
type Name struct {
        Family              string `json:"family,omitempty"`
        Given               string `json:"given,omitempty"`
        DroppingParticle    string `json:"dropping-particle,omitempty"`
        NonDroppingParticle string `json:"non-dropping-particle,omitempty"`
        Suffix              string `json:"suffix,omitempty"`
        CommaSuffix         any    `json:"comma-suffix,omitempty"`
        StaticOrdering      any    `json:"static-ordering,omitempty"`
        Literal             string `json:"literal,omitempty"`
        ParseNames          any    `json:"parse-names,omitempty"`
}

// NameFamilyGiven returns the family and given names from given name record,
// parsing what is available if not already parsed.
// todo: add suffix stuff!
func NameFamilyGiven(nm *Name) (family, given string) {
        if nm.Family != "" && nm.Given != "" {
                return nm.Family, nm.Given
        }
        pnm := ""
        switch {
        case nm.Family != "":
                pnm = nm.Family
        case nm.Given != "":
                pnm = nm.Given
        case nm.Literal != "":
                pnm = nm.Literal
        }
        if pnm == "" {
                fmt.Printf("csl.NameFamilyGiven name format error: no valid name: %#v\n", nm)
                return
        }
        ci := strings.Index(pnm, ",")
        if ci > 0 {
                return pnm[:ci], strings.TrimSpace(pnm[ci+1:])
        }
        fs := strings.Fields(pnm)
        nfs := len(fs)
        if nfs > 1 {
                return fs[nfs-1], strings.Join(fs[:nfs-1], " ")
        }
        return pnm, ""
}

// NamesLastFirstInitialCommaAmpersand returns a list of names
// formatted as a string, in the format: Last, F., Last, F., & Last., F.
func NamesLastFirstInitialCommaAmpersand(nms []Name) string {
        var w strings.Builder
        n := len(nms)
        for i := range nms {
                nm := &nms[i]
                fam, giv := NameFamilyGiven(nm)
                w.WriteString(fam)
                if giv != "" {
                        w.WriteString(", ")
                        nf := strings.Fields(giv)
                        for _, fn := range nf {
                                w.WriteString(fn[0:1] + ".")
                        }
                }
                if i == n-1 {
                        break
                }
                if i == n-2 {
                        w.WriteString(", & ")
                } else {
                        w.WriteString(", ")
                }
        }
        return w.String()
}

// NamesFirstInitialLastCommaAmpersand returns a list of names
// formatted as a string, in the format: A.B. Last, C.D., Last & L.M. Last
func NamesFirstInitialLastCommaAmpersand(nms []Name) string {
        var w strings.Builder
        n := len(nms)
        for i := range nms {
                nm := &nms[i]
                fam, giv := NameFamilyGiven(nm)
                if giv != "" {
                        nf := strings.Fields(giv)
                        for _, fn := range nf {
                                w.WriteString(fn[0:1] + ".")
                        }
                        w.WriteString(" ")
                }
                w.WriteString(fam)
                if i == n-1 {
                        break
                }
                if i == n-2 {
                        w.WriteString(", & ")
                } else {
                        w.WriteString(", ")
                }
        }
        return w.String()
}

// NamesCiteEtAl returns a list of names formatted for a
// citation within a document, as Last [et al..] or
// Last & Last if exactly two authors.
func NamesCiteEtAl(nms []Name) string {
        var w strings.Builder
        n := len(nms)
        switch {
        case n == 0:
                return "(None)"
        case n == 1:
                fam, _ := NameFamilyGiven(&nms[0])
                w.WriteString(fam)
        case n == 2:
                fam, _ := NameFamilyGiven(&nms[0])
                w.WriteString(fam)
                w.WriteString(" & ")
                fam, _ = NameFamilyGiven(&nms[1])
                w.WriteString(fam)
        default:
                fam, _ := NameFamilyGiven(&nms[0])
                w.WriteString(fam)
                w.WriteString(" et al.")
        }
        return w.String()
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package csl

import "cogentcore.org/core/text/rich"

// DefaultStyle is the default citation and reference formatting style.
var DefaultStyle = APA

// Styles are CSL citation and reference formatting styles.
type Styles int32 //enums:enum

const (
        APA Styles = iota
)

// CiteStyles are different types of citation styles that are supported by
// some formatting [Styles].
type CiteStyles int32 //enums:enum

const (
        // Parenthetical means that the citation is placed within parentheses.
        // This is default for most styles. In the APA style for example, it
        // adds a comma before the year, e.g., "(Smith, 1989)".
        // Note that the parentheses or other outer bracket syntax are NOT
        // generated directly, because often multiple are included together
        // in the same group.
        Parenthetical CiteStyles = iota

        // Narrative is an active, "inline" form of citation where the cited
        // content is used as the subject of a sentence. In the APA style this
        // puts the year in parentheses, e.g., "Smith (1989) invented the..."
        // In this case the parentheses are generated.
        Narrative
)

// Ref generates the reference text for given item,
// according to the given style.
func Ref(s Styles, it *Item) rich.Text {
        switch s {
        case APA:
                return RefAPA(it)
        }
        return nil
}

// Refs returns a list of references and matching items
// according to the given [Styles] style.
func Refs(s Styles, kl *KeyList) ([]rich.Text, []*Item) {
        switch s {
        case APA:
                return RefsAPA(kl)
        }
        return nil, nil
}

// RefsDefault returns a list of references and matching items
// according to the [DefaultStyle].
func RefsDefault(kl *KeyList) ([]rich.Text, []*Item) {
        return Refs(DefaultStyle, kl)
}

// Cite generates the citation text for given item,
// according to the given overall style an citation style.
func Cite(s Styles, cs CiteStyles, it *Item) string {
        switch s {
        case APA:
                return CiteAPA(cs, it)
        }
        return ""
}

// CiteDefault generates the citation text for given item,
// according to the [DefaultStyle] overall style, and given [CiteStyles].
func CiteDefault(cs CiteStyles, it *Item) string {
        return Cite(DefaultStyle, cs, it)
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package diffbrowser

//go:generate core generate

import (
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/stringsx"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/text/textcore"
        "cogentcore.org/core/tree"
)

// Browser is a diff browser, for browsing a set of paired files
// for viewing differences between them, organized into a tree
// structure, e.g., reflecting their source in a filesystem.
type Browser struct {
        core.Frame

        // starting paths for the files being compared
        PathA, PathB string
}

func (br *Browser) Init() {
        br.Frame.Init()
        br.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 1)
        })
        br.OnShow(func(e events.Event) {
                br.OpenFiles()
        })

        tree.AddChildAt(br, "splits", func(w *core.Splits) {
                w.SetSplits(.15, .85)
                tree.AddChildAt(w, "treeframe", func(w *core.Frame) {
                        w.Styler(func(s *styles.Style) {
                                s.Direction = styles.Column
                                s.Overflow.Set(styles.OverflowAuto)
                                s.Grow.Set(1, 1)
                        })
                        tree.AddChildAt(w, "tree", func(w *Node) {})
                })
                tree.AddChildAt(w, "tabs", func(w *core.Tabs) {
                        w.Type = core.FunctionalTabs
                })
        })
}

// NewBrowserWindow opens a new diff Browser in a new window
func NewBrowserWindow() (*Browser, *core.Body) {
        b := core.NewBody("Diff browser")
        br := NewBrowser(b)
        br.UpdateTree() // must have tree
        b.AddTopBar(func(bar *core.Frame) {
                core.NewToolbar(bar).Maker(br.MakeToolbar)
        })
        return br, b
}

func (br *Browser) Splits() *core.Splits {
        return br.FindPath("splits").(*core.Splits)
}

func (br *Browser) Tree() *Node {
        sp := br.Splits()
        return sp.Child(0).AsTree().Child(0).(*Node)
}

func (br *Browser) Tabs() *core.Tabs {
        return br.FindPath("splits/tabs").(*core.Tabs)
}

// OpenFiles Updates the tree based on files
func (br *Browser) OpenFiles() { //types:add
        tv := br.Tree()
        if tv == nil {
                return
        }
        tv.Open()
}

func (br *Browser) MakeToolbar(p *tree.Plan) {
        // tree.Add(p, func(w *core.FuncButton) {
        //         w.SetFunc(br.OpenFiles).SetText("").SetIcon(icons.Refresh).SetShortcut("Command+U")
        // })
}

// ViewDiff views diff for given file Node, returning a textcore.DiffEditor
func (br *Browser) ViewDiff(fn *Node) *textcore.DiffEditor {
        df := fsx.DirAndFile(fn.FileA)
        tabs := br.Tabs()
        tab := tabs.RecycleTab(df)
        if tab.HasChildren() {
                dv := tab.Child(1).(*textcore.DiffEditor)
                return dv
        }
        tb := core.NewToolbar(tab)
        de := textcore.NewDiffEditor(tab)
        tb.Maker(de.MakeToolbar)
        de.SetFileA(fn.FileA).SetFileB(fn.FileB).SetRevisionA(fn.RevA).SetRevisionB(fn.RevB)
        de.DiffStrings(stringsx.SplitLines(fn.TextA), stringsx.SplitLines(fn.TextB))
        br.Update()
        return de
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package diffbrowser

import (
        "log/slog"
        "os"
        "path/filepath"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/tree"
)

// Node is an element in the diff tree
type Node struct {
        core.Tree

        // file names (full path) being compared. Name of node is just the filename.
        // Typically A is the older, base version and B is the newer one being compared.
        FileA, FileB string

        // VCS revisions for files if applicable
        RevA, RevB string

        // Status of the change from A to B: A=Added, D=Deleted, M=Modified, R=Renamed
        Status string

        // Text content of the files
        TextA, TextB string

        // Info about the B file, for getting icons etc
        Info fileinfo.FileInfo
}

func (tn *Node) Init() {
        tn.Tree.Init()
        tn.IconOpen = icons.FolderOpen
        tn.IconClosed = icons.Folder
        tn.ContextMenus = nil
        tn.AddContextMenu(tn.ContextMenu)

        tn.Parts.AsWidget().OnDoubleClick(func(e events.Event) {
                if tn.HasChildren() {
                        return
                }
                br := tn.Browser()
                if br == nil {
                        return
                }
                sels := tn.GetSelectedNodes()
                if sels != nil {
                        br.ViewDiff(tn)
                }
        })
        tn.Parts.Styler(func(s *styles.Style) {
                s.Gap.X.Em(0.4)
        })
        tree.AddChildInit(tn.Parts, "branch", func(w *core.Switch) {
                tree.AddChildInit(w, "stack", func(w *core.Frame) {
                        f := func(name string) {
                                tree.AddChildInit(w, name, func(w *core.Icon) {
                                        w.Styler(func(s *styles.Style) {
                                                s.Min.Set(units.Em(1))
                                        })
                                })
                        }
                        f("icon-on")
                        f("icon-off")
                        f("icon-indeterminate")
                })
        })
}

// Browser returns the parent browser
func (tn *Node) Browser() *Browser {
        return tree.ParentByType[*Browser](tn)
}

func (tn *Node) ContextMenu(m *core.Scene) {
        vd := core.NewButton(m).SetText("View Diffs").SetIcon(icons.Add)
        vd.Styler(func(s *styles.Style) {
                s.SetState(!tn.HasSelection(), states.Disabled)
        })
        vd.OnClick(func(e events.Event) {
                br := tn.Browser()
                if br == nil {
                        return
                }
                sels := tn.GetSelectedNodes()
                sn := sels[len(sels)-1].(*Node)
                br.ViewDiff(sn)
        })
}

// DiffDirs creates a tree of files within the two paths,
// where the files have the same names, yet differ in content.
// The excludeFile function, if non-nil, will exclude files or
// directories from consideration if it returns true.
func (br *Browser) DiffDirs(pathA, pathB string, excludeFile func(fname string) bool) {
        br.PathA = pathA
        br.PathB = pathB
        tv := br.Tree()
        tv.SetText(fsx.DirAndFile(pathA))
        br.diffDirsAt(pathA, pathB, tv, excludeFile)
}

// diffDirsAt creates a tree of files with the same names
// that differ within two dirs.
func (br *Browser) diffDirsAt(pathA, pathB string, node *Node, excludeFile func(fname string) bool) {
        da := fsx.Dirs(pathA)
        db := fsx.Dirs(pathB)

        node.SetFileA(pathA).SetFileB(pathB)

        for _, pa := range da {
                if excludeFile != nil && excludeFile(pa) {
                        continue
                }
                for _, pb := range db {
                        if pa == pb {
                                nn := NewNode(node)
                                nn.SetText(pa)
                                br.diffDirsAt(filepath.Join(pathA, pa), filepath.Join(pathB, pb), nn, excludeFile)
                        }
                }
        }

        fsa := fsx.Filenames(pathA)
        fsb := fsx.Filenames(pathB)

        for _, fa := range fsa {
                isDir := false
                for _, pa := range da {
                        if fa == pa {
                                isDir = true
                                break
                        }
                }
                if isDir {
                        continue
                }
                if excludeFile != nil && excludeFile(fa) {
                        continue
                }
                for _, fb := range fsb {
                        if fa != fb {
                                continue
                        }
                        pfa := filepath.Join(pathA, fa)
                        pfb := filepath.Join(pathB, fb)

                        ca, err := os.ReadFile(pfa)
                        if err != nil {
                                slog.Error(err.Error())
                                continue
                        }
                        cb, err := os.ReadFile(pfb)
                        if err != nil {
                                slog.Error(err.Error())
                                continue
                        }
                        sa := string(ca)
                        sb := string(cb)
                        if sa == sb {
                                continue
                        }
                        nn := NewNode(node)
                        nn.SetText(fa)
                        nn.SetFileA(pfa).SetFileB(pfb).SetTextA(sa).SetTextB(sb)
                        nn.Info.InitFile(pfb)
                        nn.IconLeaf = nn.Info.Ic
                }
        }
}

// Code generated by "core generate"; DO NOT EDIT.

package diffbrowser

import (
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/diffbrowser.Browser", IDName: "browser", Doc: "Browser is a diff browser, for browsing a set of paired files\nfor viewing differences between them, organized into a tree\nstructure, e.g., reflecting their source in a filesystem.", Methods: []types.Method{{Name: "OpenFiles", Doc: "OpenFiles Updates the tree based on files", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "PathA", Doc: "starting paths for the files being compared"}, {Name: "PathB", Doc: "starting paths for the files being compared"}}})

// NewBrowser returns a new [Browser] with the given optional parent:
// Browser is a diff browser, for browsing a set of paired files
// for viewing differences between them, organized into a tree
// structure, e.g., reflecting their source in a filesystem.
func NewBrowser(parent ...tree.Node) *Browser { return tree.New[Browser](parent...) }

// SetPathA sets the [Browser.PathA]:
// starting paths for the files being compared
func (t *Browser) SetPathA(v string) *Browser { t.PathA = v; return t }

// SetPathB sets the [Browser.PathB]:
// starting paths for the files being compared
func (t *Browser) SetPathB(v string) *Browser { t.PathB = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/diffbrowser.Node", IDName: "node", Doc: "Node is an element in the diff tree", Embeds: []types.Field{{Name: "Tree"}}, Fields: []types.Field{{Name: "FileA", Doc: "file names (full path) being compared. Name of node is just the filename.\nTypically A is the older, base version and B is the newer one being compared."}, {Name: "FileB", Doc: "file names (full path) being compared. Name of node is just the filename.\nTypically A is the older, base version and B is the newer one being compared."}, {Name: "RevA", Doc: "VCS revisions for files if applicable"}, {Name: "RevB", Doc: "VCS revisions for files if applicable"}, {Name: "Status", Doc: "Status of the change from A to B: A=Added, D=Deleted, M=Modified, R=Renamed"}, {Name: "TextA", Doc: "Text content of the files"}, {Name: "TextB", Doc: "Text content of the files"}, {Name: "Info", Doc: "Info about the B file, for getting icons etc"}}})

// NewNode returns a new [Node] with the given optional parent:
// Node is an element in the diff tree
func NewNode(parent ...tree.Node) *Node { return tree.New[Node](parent...) }

// SetFileA sets the [Node.FileA]:
// file names (full path) being compared. Name of node is just the filename.
// Typically A is the older, base version and B is the newer one being compared.
func (t *Node) SetFileA(v string) *Node { t.FileA = v; return t }

// SetFileB sets the [Node.FileB]:
// file names (full path) being compared. Name of node is just the filename.
// Typically A is the older, base version and B is the newer one being compared.
func (t *Node) SetFileB(v string) *Node { t.FileB = v; return t }

// SetRevA sets the [Node.RevA]:
// VCS revisions for files if applicable
func (t *Node) SetRevA(v string) *Node { t.RevA = v; return t }

// SetRevB sets the [Node.RevB]:
// VCS revisions for files if applicable
func (t *Node) SetRevB(v string) *Node { t.RevB = v; return t }

// SetStatus sets the [Node.Status]:
// Status of the change from A to B: A=Added, D=Deleted, M=Modified, R=Renamed
func (t *Node) SetStatus(v string) *Node { t.Status = v; return t }

// SetTextA sets the [Node.TextA]:
// Text content of the files
func (t *Node) SetTextA(v string) *Node { t.TextA = v; return t }

// SetTextB sets the [Node.TextB]:
// Text content of the files
func (t *Node) SetTextB(v string) *Node { t.TextB = v; return t }

// SetInfo sets the [Node.Info]:
// Info about the B file, for getting icons etc
func (t *Node) SetInfo(v fileinfo.FileInfo) *Node { t.Info = v; return t }

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package diffbrowser

import (
        "log/slog"
        "path/filepath"
        "strings"

        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/stringsx"
        "cogentcore.org/core/base/vcs"
)

// NewDiffBrowserVCS returns a new diff browser for files that differ
// between two given revisions in the repository.
func NewDiffBrowserVCS(repo vcs.Repo, revA, revB string) {
        brow, b := NewBrowserWindow()
        brow.DiffVCS(repo, revA, revB)
        b.RunWindow()
}

// DiffVCS creates a tree of files changed in given revision.
func (br *Browser) DiffVCS(repo vcs.Repo, revA, revB string) {
        cinfo, err := repo.FilesChanged(revA, revB, false)
        if err != nil {
                slog.Error(err.Error())
                return
        }
        br.PathA = repo.LocalPath()
        br.PathB = br.PathA
        files := stringsx.SplitLines(string(cinfo))
        tv := br.Tree()
        tv.SetText(fsx.DirAndFile(br.PathA))
        cdir := ""
        var cdirs []string
        var cnodes []*Node
        root := br.Tree()
        for _, fl := range files {
                fd := strings.Fields(fl)
                if len(fd) < 2 {
                        continue
                }
                status := fd[0]
                if len(status) > 1 {
                        status = status[:1]
                }
                fpa := fd[1]
                fpb := fpa
                if len(fd) == 3 {
                        fpb = fd[2]
                }
                fp := fpb
                dir, fn := filepath.Split(fp)
                dir = filepath.Dir(dir)
                if dir != cdir {
                        dirs := strings.Split(dir, "/")
                        nd := len(dirs)
                        mn := min(len(cdirs), nd)
                        di := 0
                        for i := 0; i < mn; i++ {
                                if cdirs[i] != dirs[i] {
                                        break
                                }
                                di = i
                        }
                        cnodes = cnodes[:di]
                        for i := di; i < nd; i++ {
                                var nn *Node
                                if i == 0 {
                                        nn = NewNode(root)
                                } else {
                                        nn = NewNode(cnodes[i-1])
                                }
                                dp := filepath.Join(br.PathA, filepath.Join(dirs[:i+1]...))
                                nn.SetFileA(dp).SetFileB(dp)
                                nn.SetText(dirs[i])
                                cnodes = append(cnodes, nn)
                        }
                        cdir = dir
                        cdirs = dirs
                }
                var nn *Node
                nd := len(cnodes)
                if nd == 0 {
                        nn = NewNode(root)
                } else {
                        nn = NewNode(cnodes[nd-1])
                }
                dpa := filepath.Join(br.PathA, fpa)
                dpb := filepath.Join(br.PathA, fpb)
                nn.SetFileA(dpa).SetFileB(dpb).SetRevA(revA).SetRevB(revB).SetStatus(status)
                nn.SetText(fn + " [" + status + "]")
                if status != "D" {
                        fbB, err := repo.FileContents(dpb, revB)
                        if err != nil {
                                slog.Error(err.Error())
                        }
                        nn.SetTextB(string(fbB))
                        nn.Info.InitFile(dpb)
                        nn.IconLeaf = nn.Info.Ic
                }
                if status != "A" {
                        fbA, err := repo.FileContents(dpa, revA)
                        if err != nil {
                                slog.Error(err.Error())
                        }
                        nn.SetTextA(string(fbA))
                        if status == "D" {
                                nn.Info.InitFile(dpa)
                                nn.IconLeaf = nn.Info.Ic
                        }
                }
        }
}

// Package bytes is a partial port of Python difflib module for bytes.
//
// It provides tools to compare sequences of bytes and generate textual diffs.
//
// The following class and functions have been ported:
//
// - SequenceMatcher
//
// - unified_diff
//
// - context_diff
//
// Getting unified diffs was the main goal of the port. Keep in mind this code
// is mostly suitable to output text differences in a human friendly way, there
// are no guarantees generated diffs are consumable by patch(1).
package bytes

import (
        "bufio"
        "bytes"
        "errors"
        "fmt"
        "hash/adler32"
        "io"
        "strings"
        "unicode"
)

func calculateRatio(matches, length int) float64 {
        if length > 0 {
                return 2.0 * float64(matches) / float64(length)
        }
        return 1.0
}

func listifyString(str []byte) (lst [][]byte) {
        lst = make([][]byte, len(str))
        for i := range str {
                lst[i] = str[i : i+1]
        }
        return lst
}

type Match struct {
        A    int
        B    int
        Size int
}

type OpCode struct {
        Tag byte
        I1  int
        I2  int
        J1  int
        J2  int
}

type lineHash uint32

func _hash(line []byte) lineHash {
        return lineHash(adler32.Checksum(line))
}

// B2J is essentially a map from lines to line numbers, so that later it can
// be made a bit cleverer than the standard map in that it will not need to
// store copies of the lines.
// It needs to hold a reference to the underlying slice of lines.
type B2J struct {
        store map[lineHash][][]int
        b     [][]byte
}

type lineType int8

const (
        lineNONE    lineType = 0
        lineNORMAL  lineType = 1
        lineJUNK    lineType = -1
        linePOPULAR lineType = -2
)

func (b2j *B2J) _find(line *[]byte) (h lineHash, slotIndex int,
        slot []int, lt lineType) {
        h = _hash(*line)
        for slotIndex, slot = range b2j.store[h] {
                // Thanks to the qualities of sha1, the probability of having more than
                // one line content with the same hash is very low. Nevertheless, store
                // each of them in a different slot, that we can differentiate by
                // looking at the line contents in the b slice.
                // In place of all the line numbers where the line appears, a slot can
                // also contain [lineno, -1] if b[lineno] is junk.
                if bytes.Equal(*line, b2j.b[slot[0]]) {
                        // The content already has a slot in its hash bucket.
                        if len(slot) == 2 && slot[1] < 0 {
                                lt = lineType(slot[1])
                        } else {
                                lt = lineNORMAL
                        }
                        return // every return variable has the correct value
                }
        }
        // The line content still has no slot.
        slotIndex = -1
        slot = nil
        lt = lineNONE
        return
}

func newB2J(b [][]byte, isJunk func([]byte) bool, autoJunk bool) *B2J {
        b2j := B2J{store: map[lineHash][][]int{}, b: b}
        ntest := len(b)
        if autoJunk && ntest >= 200 {
                ntest = ntest/100 + 1
        }
        for lineno, line := range b {
                h, slotIndex, slot, lt := b2j._find(&line)
                switch lt {
                case lineNORMAL:
                        if len(slot) >= ntest {
                                b2j.store[h][slotIndex] = []int{slot[0], int(linePOPULAR)}
                        } else {
                                b2j.store[h][slotIndex] = append(slot, lineno)
                        }
                case lineNONE:
                        if isJunk != nil && isJunk(line) {
                                b2j.store[h] = append(b2j.store[h], []int{lineno, int(lineJUNK)})
                        } else {
                                b2j.store[h] = append(b2j.store[h], []int{lineno})
                        }
                default:
                }
        }
        return &b2j
}

func (b2j *B2J) get(line []byte) []int {
        _, _, slot, lt := b2j._find(&line)
        if lt == lineNORMAL {
                return slot
        }
        return []int{}
}

func (b2j *B2J) isBJunk(line []byte) bool {
        _, _, _, lt := b2j._find(&line)
        return lt == lineJUNK
}

// SequenceMatcher compares sequence of strings. The basic
// algorithm predates, and is a little fancier than, an algorithm
// published in the late 1980's by Ratcliff and Obershelp under the
// hyperbolic name "gestalt pattern matching".  The basic idea is to find
// the longest contiguous matching subsequence that contains no "junk"
// elements (R-O doesn't address junk).  The same idea is then applied
// recursively to the pieces of the sequences to the left and to the right
// of the matching subsequence.  This does not yield minimal edit
// sequences, but does tend to yield matches that "look right" to people.
//
// SequenceMatcher tries to compute a "human-friendly diff" between two
// sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
// longest *contiguous* & junk-free matching subsequence.  That's what
// catches peoples' eyes.  The Windows(tm) windiff has another interesting
// notion, pairing up elements that appear uniquely in each sequence.
// That, and the method here, appear to yield more intuitive difference
// reports than does diff.  This method appears to be the least vulnerable
// to synching up on blocks of "junk lines", though (like blank lines in
// ordinary text files, or maybe "<P>" lines in HTML files).  That may be
// because this is the only method of the 3 that has a *concept* of
// "junk" <wink>.
//
// Timing:  Basic R-O is cubic time worst case and quadratic time expected
// case.  SequenceMatcher is quadratic time for the worst case and has
// expected-case behavior dependent in a complicated way on how many
// elements the sequences have in common; best case time is linear.
type SequenceMatcher struct {
        a              [][]byte
        b              [][]byte
        b2j            B2J
        IsJunk         func([]byte) bool
        autoJunk       bool
        matchingBlocks []Match
        fullBCount     map[lineHash]int
        opCodes        []OpCode
}

func NewMatcher(a, b [][]byte) *SequenceMatcher {
        m := SequenceMatcher{autoJunk: true}
        m.SetSeqs(a, b)
        return &m
}

func NewMatcherWithJunk(a, b [][]byte, autoJunk bool,
        isJunk func([]byte) bool) *SequenceMatcher {

        m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
        m.SetSeqs(a, b)
        return &m
}

// SetSeqs sets two sequences to be compared.
func (m *SequenceMatcher) SetSeqs(a, b [][]byte) {
        m.SetSeq1(a)
        m.SetSeq2(b)
}

// SetSeq1 sets the first sequence to be compared. The second sequence to be compared is
// not changed.
//
// SequenceMatcher computes and caches detailed information about the second
// sequence, so if you want to compare one sequence S against many sequences,
// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
// sequences.
//
// See also SetSeqs() and SetSeq2().
func (m *SequenceMatcher) SetSeq1(a [][]byte) {
        if &a == &m.a {
                return
        }
        m.a = a
        m.matchingBlocks = nil
        m.opCodes = nil
}

// SetSeq2 sets the second sequence to be compared. The first sequence to be compared is
// not changed.
func (m *SequenceMatcher) SetSeq2(b [][]byte) {
        if &b == &m.b {
                return
        }
        m.b = b
        m.matchingBlocks = nil
        m.opCodes = nil
        m.fullBCount = nil
        m.chainB()
}

func (m *SequenceMatcher) chainB() {
        // Populate line -> index mapping
        b2j := *newB2J(m.b, m.IsJunk, m.autoJunk)
        m.b2j = b2j
}

// Find longest matching block in a[alo:ahi] and b[blo:bhi].
//
// If IsJunk is not defined:
//
// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
//
//        alo <= i <= i+k <= ahi
//        blo <= j <= j+k <= bhi
//
// and for all (i',j',k') meeting those conditions,
//
//        k >= k'
//        i <= i'
//        and if i == i', j <= j'
//
// In other words, of all maximal matching blocks, return one that
// starts earliest in a, and of all those maximal matching blocks that
// start earliest in a, return the one that starts earliest in b.
//
// If IsJunk is defined, first the longest matching block is
// determined as above, but with the additional restriction that no
// junk element appears in the block.  Then that block is extended as
// far as possible by matching (only) junk elements on both sides.  So
// the resulting block never matches on junk except as identical junk
// happens to be adjacent to an "interesting" match.
//
// If no blocks match, return (alo, blo, 0).
func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
        // CAUTION:  stripping common prefix or suffix would be incorrect.
        // E.g.,
        //    ab
        //    acab
        // Longest matching block is "ab", but if common prefix is
        // stripped, it's "a" (tied with "b").  UNIX(tm) diff does so
        // strip, so ends up claiming that ab is changed to acab by
        // inserting "ca" in the middle.  That's minimal but unintuitive:
        // "it's obvious" that someone inserted "ac" at the front.
        // Windiff ends up at the same place as diff, but by pairing up
        // the unique 'b's and then matching the first two 'a's.
        besti, bestj, bestsize := alo, blo, 0

        // find longest junk-free match
        // during an iteration of the loop, j2len[j] = length of longest
        // junk-free match ending with a[i-1] and b[j]
        N := bhi - blo
        j2len := make([]int, N)
        newj2len := make([]int, N)
        var indices []int
        for i := alo; i != ahi; i++ {
                // look at all instances of a[i] in b; note that because
                // b2j has no junk keys, the loop is skipped if a[i] is junk
                newindices := m.b2j.get(m.a[i])
                for _, j := range newindices {
                        // a[i] matches b[j]
                        if j < blo {
                                continue
                        }
                        if j >= bhi {
                                break
                        }
                        k := 1
                        if j > blo {
                                k = j2len[j-1-blo] + 1
                        }
                        newj2len[j-blo] = k
                        if k > bestsize {
                                besti, bestj, bestsize = i-k+1, j-k+1, k
                        }
                }
                // j2len = newj2len, clear and reuse j2len as newj2len
                for _, j := range indices {
                        if j < blo {
                                continue
                        }
                        if j >= bhi {
                                break
                        }
                        j2len[j-blo] = 0
                }
                indices = newindices
                j2len, newj2len = newj2len, j2len
        }

        // Extend the best by non-junk elements on each end.  In particular,
        // "popular" non-junk elements aren't in b2j, which greatly speeds
        // the inner loop above, but also means "the best" match so far
        // doesn't contain any junk *or* popular non-junk elements.
        for besti > alo && bestj > blo && !m.b2j.isBJunk(m.b[bestj-1]) &&
                bytes.Equal(m.a[besti-1], m.b[bestj-1]) {
                besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
        }
        for besti+bestsize < ahi && bestj+bestsize < bhi &&
                !m.b2j.isBJunk(m.b[bestj+bestsize]) &&
                bytes.Equal(m.a[besti+bestsize], m.b[bestj+bestsize]) {
                bestsize += 1
        }

        // Now that we have a wholly interesting match (albeit possibly
        // empty!), we may as well suck up the matching junk on each
        // side of it too.  Can't think of a good reason not to, and it
        // saves post-processing the (possibly considerable) expense of
        // figuring out what to do with it.  In the case of an empty
        // interesting match, this is clearly the right thing to do,
        // because no other kind of match is possible in the regions.
        for besti > alo && bestj > blo && m.b2j.isBJunk(m.b[bestj-1]) &&
                bytes.Equal(m.a[besti-1], m.b[bestj-1]) {
                besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
        }
        for besti+bestsize < ahi && bestj+bestsize < bhi &&
                m.b2j.isBJunk(m.b[bestj+bestsize]) &&
                bytes.Equal(m.a[besti+bestsize], m.b[bestj+bestsize]) {
                bestsize += 1
        }

        return Match{A: besti, B: bestj, Size: bestsize}
}

// GetMatchingBlocks returns a list of triples describing matching subsequences.
//
// Each triple is of the form (i, j, n), and means that
// a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in
// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
// adjacent triples in the list, and the second is not the last triple in the
// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
// adjacent equal blocks.
//
// The last triple is a dummy, (len(a), len(b), 0), and is the only
// triple with n==0.
func (m *SequenceMatcher) GetMatchingBlocks() []Match {
        if m.matchingBlocks != nil {
                return m.matchingBlocks
        }

        var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
        matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
                match := m.findLongestMatch(alo, ahi, blo, bhi)
                i, j, k := match.A, match.B, match.Size
                if match.Size > 0 {
                        if alo < i && blo < j {
                                matched = matchBlocks(alo, i, blo, j, matched)
                        }
                        matched = append(matched, match)
                        if i+k < ahi && j+k < bhi {
                                matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
                        }
                }
                return matched
        }
        matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)

        // It's possible that we have adjacent equal blocks in the
        // matching_blocks list now.
        var nonAdjacent []Match
        i1, j1, k1 := 0, 0, 0
        for _, b := range matched {
                // Is this block adjacent to i1, j1, k1?
                i2, j2, k2 := b.A, b.B, b.Size
                if i1+k1 == i2 && j1+k1 == j2 {
                        // Yes, so collapse them -- this just increases the length of
                        // the first block by the length of the second, and the first
                        // block so lengthened remains the block to compare against.
                        k1 += k2
                } else {
                        // Not adjacent.  Remember the first block (k1==0 means it's
                        // the dummy we started with), and make the second block the
                        // new block to compare against.
                        if k1 > 0 {
                                nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
                        }
                        i1, j1, k1 = i2, j2, k2
                }
        }
        if k1 > 0 {
                nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
        }

        nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
        m.matchingBlocks = nonAdjacent
        return m.matchingBlocks
}

// GetOpCodes returns a list of 5-tuples describing how to turn a into b.
//
// Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple
// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
// tuple preceding it, and likewise for j1 == the previous j2.
//
// The tags are characters, with these meanings:
//
// 'r' (replace):  a[i1:i2] should be replaced by b[j1:j2]
//
// 'd' (delete):   a[i1:i2] should be deleted, j1==j2 in this case.
//
// 'i' (insert):   b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
//
// 'e' (equal):    a[i1:i2] == b[j1:j2]
func (m *SequenceMatcher) GetOpCodes() []OpCode {
        if m.opCodes != nil {
                return m.opCodes
        }
        i, j := 0, 0
        matching := m.GetMatchingBlocks()
        opCodes := make([]OpCode, 0, len(matching))
        for _, m := range matching {
                //  invariant:  we've pumped out correct diffs to change
                //  a[:i] into b[:j], and the next matching block is
                //  a[ai:ai+size] == b[bj:bj+size]. So we need to pump
                //  out a diff to change a[i:ai] into b[j:bj], pump out
                //  the matching block, and move (i,j) beyond the match
                ai, bj, size := m.A, m.B, m.Size
                tag := byte(0)
                if i < ai && j < bj {
                        tag = 'r'
                } else if i < ai {
                        tag = 'd'
                } else if j < bj {
                        tag = 'i'
                }
                if tag > 0 {
                        opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
                }
                i, j = ai+size, bj+size
                // the list of matching blocks is terminated by a
                // sentinel with size 0
                if size > 0 {
                        opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
                }
        }
        m.opCodes = opCodes
        return m.opCodes
}

// GetGroupedOpCodes isolates change clusters by eliminating ranges with no changes.
//
// Return a generator of groups with up to n lines of context.
// Each group is in the same format as returned by GetOpCodes().
func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
        if n < 0 {
                n = 3
        }
        codes := m.GetOpCodes()
        if len(codes) == 0 {
                codes = []OpCode{{'e', 0, 1, 0, 1}}
        }
        // Fixup leading and trailing groups if they show no changes.
        if codes[0].Tag == 'e' {
                c := codes[0]
                i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
                codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
        }
        if codes[len(codes)-1].Tag == 'e' {
                c := codes[len(codes)-1]
                i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
                codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
        }
        nn := n + n
        var groups [][]OpCode
        var group []OpCode
        for _, c := range codes {
                i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
                // End the current group and start a new one whenever
                // there is a large range with no changes.
                if c.Tag == 'e' && i2-i1 > nn {
                        group = append(group, OpCode{c.Tag, i1, min(i2, i1+n),
                                j1, min(j2, j1+n)})
                        groups = append(groups, group)
                        group = []OpCode{}
                        i1, j1 = max(i1, i2-n), max(j1, j2-n)
                }
                group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
        }
        if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {
                groups = append(groups, group)
        }
        return groups
}

// Ratio returns a measure of the sequences' similarity (float in [0,1]).
//
// Where T is the total number of elements in both sequences, and
// M is the number of matches, this is 2.0*M / T.
// Note that this is 1 if the sequences are identical, and 0 if
// they have nothing in common.
//
// .Ratio() is expensive to compute if you haven't already computed
// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
// want to try .QuickRatio() or .RealQuickRation() first to get an
// upper bound.
func (m *SequenceMatcher) Ratio() float64 {
        matches := 0
        for _, m := range m.GetMatchingBlocks() {
                matches += m.Size
        }
        return calculateRatio(matches, len(m.a)+len(m.b))
}

// QuickRatio returns an upper bound on ratio() relatively quickly.
//
// This isn't defined beyond that it is an upper bound on .Ratio(), and
// is faster to compute.
func (m *SequenceMatcher) QuickRatio() float64 {
        // viewing a and b as multisets, set matches to the cardinality
        // of their intersection; this counts the number of matches
        // without regard to order, so is clearly an upper bound. We do
        // so on hashes of the lines themselves, so this might even be
        // greater due hash collisions incurring false positives, but
        // we don't care because we want an upper bound anyway.
        if m.fullBCount == nil {
                m.fullBCount = map[lineHash]int{}
                for _, s := range m.b {
                        h := _hash(s)
                        m.fullBCount[h] = m.fullBCount[h] + 1
                }
        }

        // avail[x] is the number of times x appears in 'b' less the
        // number of times we've seen it in 'a' so far ... kinda
        avail := map[lineHash]int{}
        matches := 0
        for _, s := range m.a {
                h := _hash(s)
                n, ok := avail[h]
                if !ok {
                        n = m.fullBCount[h]
                }
                avail[h] = n - 1
                if n > 0 {
                        matches += 1
                }
        }
        return calculateRatio(matches, len(m.a)+len(m.b))
}

// RealQuickRatio returns an upper bound on ratio() very quickly.
//
// This isn't defined beyond that it is an upper bound on .Ratio(), and
// is faster to compute than either .Ratio() or .QuickRatio().
func (m *SequenceMatcher) RealQuickRatio() float64 {
        la, lb := len(m.a), len(m.b)
        return calculateRatio(min(la, lb), la+lb)
}

func count_leading(line []byte, ch byte) (count int) {
        // Return number of `ch` characters at the start of `line`.
        count = 0
        n := len(line)
        for (count < n) && (line[count] == ch) {
                count++
        }
        return count
}

type DiffLine struct {
        Tag  byte
        Line []byte
}

func NewDiffLine(tag byte, line []byte) (l DiffLine) {
        l = DiffLine{}
        l.Tag = tag
        l.Line = line
        return l
}

type Differ struct {
        Linejunk func([]byte) bool
        Charjunk func([]byte) bool
}

func NewDiffer() *Differ {
        return &Differ{}
}

var MINUS = []byte("-")
var SPACE = []byte(" ")
var PLUS = []byte("+")
var CARET = []byte("^")

func (d *Differ) Compare(a [][]byte, b [][]byte) (diffs [][]byte, err error) {
        // Compare two sequences of lines; generate the resulting delta.

        // Each sequence must contain individual single-line strings ending with
        // newlines. Such sequences can be obtained from the `readlines()` method
        // of file-like objects.  The delta generated also consists of newline-
        // terminated strings, ready to be printed as-is via the writeline()
        // method of a file-like object.
        diffs = [][]byte{}
        cruncher := NewMatcherWithJunk(a, b, true, d.Linejunk)
        opcodes := cruncher.GetOpCodes()
        for _, current := range opcodes {
                alo := current.I1
                ahi := current.I2
                blo := current.J1
                bhi := current.J2
                var g [][]byte
                if current.Tag == 'r' {
                        g, _ = d.FancyReplace(a, alo, ahi, b, blo, bhi)
                } else if current.Tag == 'd' {
                        g = d.Dump(MINUS, a, alo, ahi)
                } else if current.Tag == 'i' {
                        g = d.Dump(PLUS, b, blo, bhi)
                } else if current.Tag == 'e' {
                        g = d.Dump(SPACE, a, alo, ahi)
                } else {
                        return nil, fmt.Errorf("unknown tag %q", current.Tag)
                }
                diffs = append(diffs, g...)
        }
        return diffs, nil
}

func (d *Differ) StructuredDump(tag byte, x [][]byte, low int, high int) (out []DiffLine) {
        size := high - low
        out = make([]DiffLine, size)
        for i := 0; i < size; i++ {
                out[i] = NewDiffLine(tag, x[i+low])
        }
        return out
}

func (d *Differ) Dump(tag []byte, x [][]byte, low int, high int) (out [][]byte) {
        // Generate comparison results for a same-tagged range.
        sout := d.StructuredDump(tag[0], x, low, high)
        out = make([][]byte, len(sout))
        var bld bytes.Buffer
        bld.Grow(1024)
        for i, line := range sout {
                bld.Reset()
                bld.WriteByte(line.Tag)
                bld.Write(SPACE)
                bld.Write(line.Line)
                out[i] = append(out[i], bld.Bytes()...)
        }
        return out
}

func (d *Differ) PlainReplace(a [][]byte, alo int, ahi int, b [][]byte, blo int, bhi int) (out [][]byte, err error) {
        if !(alo < ahi) || !(blo < bhi) { // assertion
                return nil, errors.New("low greater than or equal to high")
        }
        // dump the shorter block first -- reduces the burden on short-term
        // memory if the blocks are of very different sizes
        if bhi-blo < ahi-alo {
                out = d.Dump(PLUS, b, blo, bhi)
                out = append(out, d.Dump(MINUS, a, alo, ahi)...)
        } else {
                out = d.Dump(MINUS, a, alo, ahi)
                out = append(out, d.Dump(PLUS, b, blo, bhi)...)
        }
        return out, nil
}

func (d *Differ) FancyReplace(a [][]byte, alo int, ahi int, b [][]byte, blo int, bhi int) (out [][]byte, err error) {
        // When replacing one block of lines with another, search the blocks
        // for *similar* lines; the best-matching pair (if any) is used as a
        // synch point, and intraline difference marking is done on the
        // similar pair. Lots of work, but often worth it.

        // don't synch up unless the lines have a similarity score of at
        // least cutoff; best_ratio tracks the best score seen so far
        best_ratio := 0.74
        cutoff := 0.75
        cruncher := NewMatcherWithJunk(a, b, true, d.Charjunk)
        eqi := -1 // 1st indices of equal lines (if any)
        eqj := -1
        out = [][]byte{}

        // search for the pair that matches best without being identical
        // (identical lines must be junk lines, & we don't want to synch up
        // on junk -- unless we have to)
        var best_i, best_j int
        for j := blo; j < bhi; j++ {
                bj := b[j]
                cruncher.SetSeq2(listifyString(bj))
                for i := alo; i < ahi; i++ {
                        ai := a[i]
                        if bytes.Equal(ai, bj) {
                                if eqi == -1 {
                                        eqi = i
                                        eqj = j
                                }
                                continue
                        }
                        cruncher.SetSeq1(listifyString(ai))
                        // computing similarity is expensive, so use the quick
                        // upper bounds first -- have seen this speed up messy
                        // compares by a factor of 3.
                        // note that ratio() is only expensive to compute the first
                        // time it's called on a sequence pair; the expensive part
                        // of the computation is cached by cruncher
                        if cruncher.RealQuickRatio() > best_ratio &&
                                cruncher.QuickRatio() > best_ratio &&
                                cruncher.Ratio() > best_ratio {
                                best_ratio = cruncher.Ratio()
                                best_i = i
                                best_j = j
                        }
                }
        }
        if best_ratio < cutoff {
                // no non-identical "pretty close" pair
                if eqi == -1 {
                        // no identical pair either -- treat it as a straight replace
                        out, _ = d.PlainReplace(a, alo, ahi, b, blo, bhi)
                        return out, nil
                }
                // no close pair, but an identical pair -- synch up on that
                best_i = eqi
                best_j = eqj
                best_ratio = 1.0
        } else {
                // there's a close pair, so forget the identical pair (if any)
                eqi = -1
        }
        // a[best_i] very similar to b[best_j]; eqi is None iff they're not
        // identical

        // pump out diffs from before the synch point
        out = append(out, d.fancyHelper(a, alo, best_i, b, blo, best_j)...)

        // do intraline marking on the synch pair
        aelt, belt := a[best_i], b[best_j]
        if eqi == -1 {
                // pump out a '-', '?', '+', '?' quad for the synched lines
                var atags, btags []byte
                cruncher.SetSeqs(listifyString(aelt), listifyString(belt))
                opcodes := cruncher.GetOpCodes()
                for _, current := range opcodes {
                        ai1 := current.I1
                        ai2 := current.I2
                        bj1 := current.J1
                        bj2 := current.J2
                        la, lb := ai2-ai1, bj2-bj1
                        if current.Tag == 'r' {
                                atags = append(atags, bytes.Repeat(CARET, la)...)
                                btags = append(btags, bytes.Repeat(CARET, lb)...)
                        } else if current.Tag == 'd' {
                                atags = append(atags, bytes.Repeat(MINUS, la)...)
                        } else if current.Tag == 'i' {
                                btags = append(btags, bytes.Repeat(PLUS, lb)...)
                        } else if current.Tag == 'e' {
                                atags = append(atags, bytes.Repeat(SPACE, la)...)
                                btags = append(btags, bytes.Repeat(SPACE, lb)...)
                        } else {
                                return nil, fmt.Errorf("unknown tag %q",
                                        current.Tag)
                        }
                }
                out = append(out, d.QFormat(aelt, belt, atags, btags)...)
        } else {
                // the synch pair is identical
                out = append(out, append([]byte{' ', ' '}, aelt...))
        }
        // pump out diffs from after the synch point
        out = append(out, d.fancyHelper(a, best_i+1, ahi, b, best_j+1, bhi)...)
        return out, nil
}

func (d *Differ) fancyHelper(a [][]byte, alo int, ahi int, b [][]byte, blo int, bhi int) (out [][]byte) {
        if alo < ahi {
                if blo < bhi {
                        out, _ = d.FancyReplace(a, alo, ahi, b, blo, bhi)
                } else {
                        out = d.Dump(MINUS, a, alo, ahi)
                }
        } else if blo < bhi {
                out = d.Dump(PLUS, b, blo, bhi)
        } else {
                out = [][]byte{}
        }
        return out
}

func (d *Differ) QFormat(aline []byte, bline []byte, atags []byte, btags []byte) (out [][]byte) {
        // Format "?" output and deal with leading tabs.

        // Can hurt, but will probably help most of the time.
        common := min(count_leading(aline, '\t'), count_leading(bline, '\t'))
        common = min(common, count_leading(atags[:common], ' '))
        common = min(common, count_leading(btags[:common], ' '))
        atags = bytes.TrimRightFunc(atags[common:], unicode.IsSpace)
        btags = bytes.TrimRightFunc(btags[common:], unicode.IsSpace)

        out = [][]byte{append([]byte("- "), aline...)}
        if len(atags) > 0 {
                t := make([]byte, 0, len(atags)+common+3)
                t = append(t, []byte("? ")...)
                for i := 0; i < common; i++ {
                        t = append(t, byte('\t'))
                }
                t = append(t, atags...)
                t = append(t, byte('\n'))
                out = append(out, t)
        }
        out = append(out, append([]byte("+ "), bline...))
        if len(btags) > 0 {
                t := make([]byte, 0, len(btags)+common+3)
                t = append(t, []byte("? ")...)
                for i := 0; i < common; i++ {
                        t = append(t, byte('\t'))
                }
                t = append(t, btags...)
                t = append(t, byte('\n'))
                out = append(out, t)
        }
        return out
}

// Convert range to the "ed" format
func formatRangeUnified(start, stop int) []byte {
        // Per the diff spec at http://www.unix.org/single_unix_specification/
        beginning := start + 1 // lines start numbering with one
        length := stop - start
        if length == 1 {
                return []byte(fmt.Sprintf("%d", beginning))
        }
        if length == 0 {
                beginning -= 1 // empty ranges begin at line just before the range
        }
        return []byte(fmt.Sprintf("%d,%d", beginning, length))
}

// UnifiedDiff contains unified diff parameters
type UnifiedDiff struct {
        A        [][]byte // First sequence lines
        FromFile string   // First file name
        FromDate string   // First file time
        B        [][]byte // Second sequence lines
        ToFile   string   // Second file name
        ToDate   string   // Second file time
        Eol      []byte   // Headers end of line, defaults to LF
        Context  int      // Number of context lines
}

// WriteUnifiedDiff compares two sequences of lines and generates the delta as a unified diff.
//
// Unified diffs are a compact way of showing line changes and a few
// lines of context.  The number of context lines is set by 'n' which
// defaults to three.
//
// By default, the diff control lines (those with ---, +++, or @@) are
// created with a trailing newline.  This is helpful so that inputs
// created from file.readlines() result in diffs that are suitable for
// file.writelines() since both the inputs and outputs have trailing
// newlines.
//
// For inputs that do not have trailing newlines, set the lineterm
// argument to "" so that the output will be uniformly newline free.
//
// The unidiff format normally has a header for filenames and modification
// times.  Any or all of these may be specified using strings for
// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
// The modification times are normally expressed in the ISO 8601 format.
func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {
        //buf := bufio.NewWriter(writer)
        //defer buf.Flush()
        var bld strings.Builder
        bld.Reset()
        wf := func(format string, args ...interface{}) error {
                _, err := fmt.Fprintf(&bld, format, args...)
                return err
        }
        ws := func(s []byte) error {
                _, err := bld.Write(s)
                return err
        }

        if len(diff.Eol) == 0 {
                diff.Eol = []byte("\n")
        }

        started := false
        m := NewMatcher(diff.A, diff.B)
        for _, g := range m.GetGroupedOpCodes(diff.Context) {
                if !started {
                        started = true
                        fromDate := ""
                        if len(diff.FromDate) > 0 {
                                fromDate = "\t" + diff.FromDate
                        }
                        toDate := ""
                        if len(diff.ToDate) > 0 {
                                toDate = "\t" + diff.ToDate
                        }
                        if diff.FromFile != "" || diff.ToFile != "" {
                                err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol)
                                if err != nil {
                                        return err
                                }
                                err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol)
                                if err != nil {
                                        return err
                                }
                        }
                }
                first, last := g[0], g[len(g)-1]
                range1 := formatRangeUnified(first.I1, last.I2)
                range2 := formatRangeUnified(first.J1, last.J2)
                if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil {
                        return err
                }
                for _, c := range g {
                        i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
                        if c.Tag == 'e' {
                                for _, line := range diff.A[i1:i2] {
                                        if err := ws(SPACE); err != nil {
                                                return err
                                        }
                                        if err := ws(line); err != nil {
                                                return err
                                        }
                                }
                                continue
                        }
                        if c.Tag == 'r' || c.Tag == 'd' {
                                for _, line := range diff.A[i1:i2] {
                                        if err := ws(MINUS); err != nil {
                                                return err
                                        }
                                        if err := ws(line); err != nil {
                                                return err
                                        }
                                }
                        }
                        if c.Tag == 'r' || c.Tag == 'i' {
                                for _, line := range diff.B[j1:j2] {
                                        if err := ws(PLUS); err != nil {
                                                return err
                                        }
                                        if err := ws(line); err != nil {
                                                return err
                                        }
                                }
                        }
                }
        }
        buf := bufio.NewWriter(writer)
        buf.WriteString(bld.String())
        buf.Flush()
        return nil
}

// GetUnifiedDiffString is like WriteUnifiedDiff but returns the diff a []byte.
func GetUnifiedDiffString(diff UnifiedDiff) ([]byte, error) {
        w := &bytes.Buffer{}
        err := WriteUnifiedDiff(w, diff)
        return w.Bytes(), err
}

// Convert range to the "ed" format.
func formatRangeContext(start, stop int) []byte {
        // Per the diff spec at http://www.unix.org/single_unix_specification/
        beginning := start + 1 // lines start numbering with one
        length := stop - start
        if length == 0 {
                beginning -= 1 // empty ranges begin at line just before the range
        }
        if length <= 1 {
                return []byte(fmt.Sprintf("%d", beginning))
        }
        return []byte(fmt.Sprintf("%d,%d", beginning, beginning+length-1))
}

type ContextDiff UnifiedDiff

// WriteContextDiff compare two sequences of lines and generates the delta as a context diff.
//
// Context diffs are a compact way of showing line changes and a few
// lines of context. The number of context lines is set by diff.Context
// which defaults to three.
//
// By default, the diff control lines (those with *** or ---) are
// created with a trailing newline.
//
// For inputs that do not have trailing newlines, set the diff.Eol
// argument to "" so that the output will be uniformly newline free.
//
// The context diff format normally has a header for filenames and
// modification times.  Any or all of these may be specified using
// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
// The modification times are normally expressed in the ISO 8601 format.
// If not specified, the strings default to blanks.
func WriteContextDiff(writer io.Writer, diff ContextDiff) error {
        buf := bufio.NewWriter(writer)
        defer buf.Flush()
        var diffErr error
        wf := func(format string, args ...interface{}) {
                _, err := buf.WriteString(fmt.Sprintf(format, args...))
                if diffErr == nil && err != nil {
                        diffErr = err
                }
        }
        ws := func(s []byte) {
                _, err := buf.Write(s)
                if diffErr == nil && err != nil {
                        diffErr = err
                }
        }

        if len(diff.Eol) == 0 {
                diff.Eol = []byte("\n")
        }

        prefix := map[byte][]byte{
                'i': []byte("+ "),
                'd': []byte("- "),
                'r': []byte("! "),
                'e': []byte("  "),
        }

        started := false
        m := NewMatcher(diff.A, diff.B)
        for _, g := range m.GetGroupedOpCodes(diff.Context) {
                if !started {
                        started = true
                        fromDate := ""
                        if len(diff.FromDate) > 0 {
                                fromDate = "\t" + diff.FromDate
                        }
                        toDate := ""
                        if len(diff.ToDate) > 0 {
                                toDate = "\t" + diff.ToDate
                        }
                        if diff.FromFile != "" || diff.ToFile != "" {
                                wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
                                wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
                        }
                }

                first, last := g[0], g[len(g)-1]
                ws([]byte("***************"))
                ws(diff.Eol)

                range1 := formatRangeContext(first.I1, last.I2)
                wf("*** %s ****%s", range1, diff.Eol)
                for _, c := range g {
                        if c.Tag == 'r' || c.Tag == 'd' {
                                for _, cc := range g {
                                        if cc.Tag == 'i' {
                                                continue
                                        }
                                        for _, line := range diff.A[cc.I1:cc.I2] {
                                                ws(prefix[cc.Tag])
                                                ws(line)
                                        }
                                }
                                break
                        }
                }

                range2 := formatRangeContext(first.J1, last.J2)
                wf("--- %s ----%s", range2, diff.Eol)
                for _, c := range g {
                        if c.Tag == 'r' || c.Tag == 'i' {
                                for _, cc := range g {
                                        if cc.Tag == 'd' {
                                                continue
                                        }
                                        for _, line := range diff.B[cc.J1:cc.J2] {
                                                ws(prefix[cc.Tag])
                                                ws(line)
                                        }
                                }
                                break
                        }
                }
        }
        return diffErr
}

// GetContextDiffString Like WriteContextDiff but returns the diff a []byte.
func GetContextDiffString(diff ContextDiff) ([]byte, error) {
        w := &bytes.Buffer{}
        err := WriteContextDiff(w, diff)
        return w.Bytes(), err
}

// SplitLines splits a []byte on "\n" while preserving them. The output can be used
// as input for UnifiedDiff and ContextDiff structures.
func SplitLines(s []byte) [][]byte {
        lines := bytes.SplitAfter(s, []byte("\n"))
        lines[len(lines)-1] = append(lines[len(lines)-1], '\n')
        return lines
}

// Package difflib is a partial port of Python difflib module.
//
// It provides tools to compare sequences of strings and generate textual diffs.
//
// The following class and functions have been ported:
//
// - SequenceMatcher
//
// - unified_diff
//
// - context_diff
//
// Getting unified diffs was the main goal of the port. Keep in mind this code
// is mostly suitable to output text differences in a human friendly way, there
// are no guarantees generated diffs are consumable by patch(1).
package difflib

import (
        "bufio"
        "bytes"
        "errors"
        "fmt"
        "io"
        "strings"
        "unicode"
)

func calculateRatio(matches, length int) float64 {
        if length > 0 {
                return 2.0 * float64(matches) / float64(length)
        }
        return 1.0
}

func listifyString(str string) (lst []string) {
        lst = make([]string, len(str))
        for i, c := range str {
                lst[i] = string(c)
        }
        return lst
}

type Match struct {
        A    int
        B    int
        Size int
}

type OpCode struct {
        Tag byte
        I1  int
        I2  int
        J1  int
        J2  int
}

// SequenceMatcher compares sequence of strings. The basic
// algorithm predates, and is a little fancier than, an algorithm
// published in the late 1980's by Ratcliff and Obershelp under the
// hyperbolic name "gestalt pattern matching".  The basic idea is to find
// the longest contiguous matching subsequence that contains no "junk"
// elements (R-O doesn't address junk).  The same idea is then applied
// recursively to the pieces of the sequences to the left and to the right
// of the matching subsequence.  This does not yield minimal edit
// sequences, but does tend to yield matches that "look right" to people.
//
// SequenceMatcher tries to compute a "human-friendly diff" between two
// sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
// longest *contiguous* & junk-free matching subsequence.  That's what
// catches peoples' eyes.  The Windows(tm) windiff has another interesting
// notion, pairing up elements that appear uniquely in each sequence.
// That, and the method here, appear to yield more intuitive difference
// reports than does diff.  This method appears to be the least vulnerable
// to synching up on blocks of "junk lines", though (like blank lines in
// ordinary text files, or maybe "<P>" lines in HTML files).  That may be
// because this is the only method of the 3 that has a *concept* of
// "junk" <wink>.
//
// Timing:  Basic R-O is cubic time worst case and quadratic time expected
// case.  SequenceMatcher is quadratic time for the worst case and has
// expected-case behavior dependent in a complicated way on how many
// elements the sequences have in common; best case time is linear.
type SequenceMatcher struct {
        a              []string
        b              []string
        b2j            map[string][]int
        IsJunk         func(string) bool
        autoJunk       bool
        bJunk          map[string]bool
        matchingBlocks []Match
        fullBCount     map[string]int
        bPopular       map[string]bool
        opCodes        []OpCode
}

func NewMatcher(a, b []string) *SequenceMatcher {
        m := SequenceMatcher{autoJunk: true}
        m.SetSeqs(a, b)
        return &m
}

func NewMatcherWithJunk(a, b []string, autoJunk bool,
        isJunk func(string) bool) *SequenceMatcher {

        m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
        m.SetSeqs(a, b)
        return &m
}

// SetSeqs sets two sequences to be compared.
func (m *SequenceMatcher) SetSeqs(a, b []string) {
        m.SetSeq1(a)
        m.SetSeq2(b)
}

// SetSeq1 sets the first sequence to be compared. The second sequence to be compared is
// not changed.
//
// SequenceMatcher computes and caches detailed information about the second
// sequence, so if you want to compare one sequence S against many sequences,
// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
// sequences.
//
// See also SetSeqs() and SetSeq2().
func (m *SequenceMatcher) SetSeq1(a []string) {
        if &a == &m.a {
                return
        }
        m.a = a
        m.matchingBlocks = nil
        m.opCodes = nil
}

// SetSeq2 sets the second sequence to be compared. The first sequence to be compared is
// not changed.
func (m *SequenceMatcher) SetSeq2(b []string) {
        if &b == &m.b {
                return
        }
        m.b = b
        m.matchingBlocks = nil
        m.opCodes = nil
        m.fullBCount = nil
        m.chainB()
}

func (m *SequenceMatcher) chainB() {
        // Populate line -> index mapping
        b2j := map[string][]int{}
        junk := map[string]bool{}
        popular := map[string]bool{}
        ntest := len(m.b)
        if m.autoJunk && ntest >= 200 {
                ntest = ntest/100 + 1
        }
        for i, s := range m.b {
                if !junk[s] {
                        if m.IsJunk != nil && m.IsJunk(s) {
                                junk[s] = true
                        } else if !popular[s] {
                                ids := append(b2j[s], i)
                                if len(ids) <= ntest {
                                        b2j[s] = ids
                                } else {
                                        delete(b2j, s)
                                        popular[s] = true
                                }
                        }
                }
        }

        m.b2j = b2j
        m.bJunk = junk
        m.bPopular = popular
}

func (m *SequenceMatcher) isBJunk(s string) bool {
        _, ok := m.bJunk[s]
        return ok
}

// Find longest matching block in a[alo:ahi] and b[blo:bhi].
//
// If IsJunk is not defined:
//
// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
//
//        alo <= i <= i+k <= ahi
//        blo <= j <= j+k <= bhi
//
// and for all (i',j',k') meeting those conditions,
//
//        k >= k'
//        i <= i'
//        and if i == i', j <= j'
//
// In other words, of all maximal matching blocks, return one that
// starts earliest in a, and of all those maximal matching blocks that
// start earliest in a, return the one that starts earliest in b.
//
// If IsJunk is defined, first the longest matching block is
// determined as above, but with the additional restriction that no
// junk element appears in the block.  Then that block is extended as
// far as possible by matching (only) junk elements on both sides.  So
// the resulting block never matches on junk except as identical junk
// happens to be adjacent to an "interesting" match.
//
// If no blocks match, return (alo, blo, 0).
func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
        // CAUTION:  stripping common prefix or suffix would be incorrect.
        // E.g.,
        //    ab
        //    acab
        // Longest matching block is "ab", but if common prefix is
        // stripped, it's "a" (tied with "b").  UNIX(tm) diff does so
        // strip, so ends up claiming that ab is changed to acab by
        // inserting "ca" in the middle.  That's minimal but unintuitive:
        // "it's obvious" that someone inserted "ac" at the front.
        // Windiff ends up at the same place as diff, but by pairing up
        // the unique 'b's and then matching the first two 'a's.
        besti, bestj, bestsize := alo, blo, 0

        // find longest junk-free match
        // during an iteration of the loop, j2len[j] = length of longest
        // junk-free match ending with a[i-1] and b[j]
        N := bhi - blo
        j2len := make([]int, N)
        newj2len := make([]int, N)
        var indices []int
        for i := alo; i != ahi; i++ {
                // look at all instances of a[i] in b; note that because
                // b2j has no junk keys, the loop is skipped if a[i] is junk
                newindices := m.b2j[m.a[i]]
                for _, j := range newindices {
                        // a[i] matches b[j]
                        if j < blo {
                                continue
                        }
                        if j >= bhi {
                                break
                        }
                        k := 1
                        if j > blo {
                                k = j2len[j-1-blo] + 1
                        }
                        newj2len[j-blo] = k
                        if k > bestsize {
                                besti, bestj, bestsize = i-k+1, j-k+1, k
                        }
                }
                // j2len = newj2len, clear and reuse j2len as newj2len
                for _, j := range indices {
                        if j < blo {
                                continue
                        }
                        if j >= bhi {
                                break
                        }
                        j2len[j-blo] = 0
                }
                indices = newindices
                j2len, newj2len = newj2len, j2len
        }

        // Extend the best by non-junk elements on each end.  In particular,
        // "popular" non-junk elements aren't in b2j, which greatly speeds
        // the inner loop above, but also means "the best" match so far
        // doesn't contain any junk *or* popular non-junk elements.
        for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
                m.a[besti-1] == m.b[bestj-1] {
                besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
        }
        for besti+bestsize < ahi && bestj+bestsize < bhi &&
                !m.isBJunk(m.b[bestj+bestsize]) &&
                m.a[besti+bestsize] == m.b[bestj+bestsize] {
                bestsize += 1
        }

        // Now that we have a wholly interesting match (albeit possibly
        // empty!), we may as well suck up the matching junk on each
        // side of it too.  Can't think of a good reason not to, and it
        // saves post-processing the (possibly considerable) expense of
        // figuring out what to do with it.  In the case of an empty
        // interesting match, this is clearly the right thing to do,
        // because no other kind of match is possible in the regions.
        for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
                m.a[besti-1] == m.b[bestj-1] {
                besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
        }
        for besti+bestsize < ahi && bestj+bestsize < bhi &&
                m.isBJunk(m.b[bestj+bestsize]) &&
                m.a[besti+bestsize] == m.b[bestj+bestsize] {
                bestsize += 1
        }

        return Match{A: besti, B: bestj, Size: bestsize}
}

// GetMatchingBlocks returns a list of triples describing matching subsequences.
//
// Each triple is of the form (i, j, n), and means that
// a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in
// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
// adjacent triples in the list, and the second is not the last triple in the
// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
// adjacent equal blocks.
//
// The last triple is a dummy, (len(a), len(b), 0), and is the only
// triple with n==0.
func (m *SequenceMatcher) GetMatchingBlocks() []Match {
        if m.matchingBlocks != nil {
                return m.matchingBlocks
        }

        var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
        matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
                match := m.findLongestMatch(alo, ahi, blo, bhi)
                i, j, k := match.A, match.B, match.Size
                if match.Size > 0 {
                        if alo < i && blo < j {
                                matched = matchBlocks(alo, i, blo, j, matched)
                        }
                        matched = append(matched, match)
                        if i+k < ahi && j+k < bhi {
                                matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
                        }
                }
                return matched
        }
        matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)

        // It's possible that we have adjacent equal blocks in the
        // matching_blocks list now.
        var nonAdjacent []Match
        i1, j1, k1 := 0, 0, 0
        for _, b := range matched {
                // Is this block adjacent to i1, j1, k1?
                i2, j2, k2 := b.A, b.B, b.Size
                if i1+k1 == i2 && j1+k1 == j2 {
                        // Yes, so collapse them -- this just increases the length of
                        // the first block by the length of the second, and the first
                        // block so lengthened remains the block to compare against.
                        k1 += k2
                } else {
                        // Not adjacent.  Remember the first block (k1==0 means it's
                        // the dummy we started with), and make the second block the
                        // new block to compare against.
                        if k1 > 0 {
                                nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
                        }
                        i1, j1, k1 = i2, j2, k2
                }
        }
        if k1 > 0 {
                nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
        }

        nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
        m.matchingBlocks = nonAdjacent
        return m.matchingBlocks
}

// GetOpCodes returns a list of 5-tuples describing how to turn a into b.
//
// Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple
// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
// tuple preceding it, and likewise for j1 == the previous j2.
//
// The tags are characters, with these meanings:
//
// 'r' (replace):  a[i1:i2] should be replaced by b[j1:j2]
//
// 'd' (delete):   a[i1:i2] should be deleted, j1==j2 in this case.
//
// 'i' (insert):   b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
//
// 'e' (equal):    a[i1:i2] == b[j1:j2]
func (m *SequenceMatcher) GetOpCodes() []OpCode {
        if m.opCodes != nil {
                return m.opCodes
        }
        i, j := 0, 0
        matching := m.GetMatchingBlocks()
        opCodes := make([]OpCode, 0, len(matching))
        for _, m := range matching {
                //  invariant:  we've pumped out correct diffs to change
                //  a[:i] into b[:j], and the next matching block is
                //  a[ai:ai+size] == b[bj:bj+size]. So we need to pump
                //  out a diff to change a[i:ai] into b[j:bj], pump out
                //  the matching block, and move (i,j) beyond the match
                ai, bj, size := m.A, m.B, m.Size
                tag := byte(0)
                if i < ai && j < bj {
                        tag = 'r'
                } else if i < ai {
                        tag = 'd'
                } else if j < bj {
                        tag = 'i'
                }
                if tag > 0 {
                        opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
                }
                i, j = ai+size, bj+size
                // the list of matching blocks is terminated by a
                // sentinel with size 0
                if size > 0 {
                        opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
                }
        }
        m.opCodes = opCodes
        return m.opCodes
}

// GetGroupedOpCodes isolates change clusters by eliminating ranges with no changes.
//
// Return a generator of groups with up to n lines of context.
// Each group is in the same format as returned by GetOpCodes().
func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
        if n < 0 {
                n = 3
        }
        codes := m.GetOpCodes()
        if len(codes) == 0 {
                codes = []OpCode{{'e', 0, 1, 0, 1}}
        }
        // Fixup leading and trailing groups if they show no changes.
        if codes[0].Tag == 'e' {
                c := codes[0]
                i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
                codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2}
        }
        if codes[len(codes)-1].Tag == 'e' {
                c := codes[len(codes)-1]
                i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
                codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)}
        }
        nn := n + n

        var (
                groups [][]OpCode
                group  []OpCode
        )

        for _, c := range codes {
                i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
                // End the current group and start a new one whenever
                // there is a large range with no changes.
                if c.Tag == 'e' && i2-i1 > nn {
                        group = append(group, OpCode{c.Tag, i1, min(i2, i1+n),
                                j1, min(j2, j1+n)})
                        groups = append(groups, group)
                        group = []OpCode{}
                        i1, j1 = max(i1, i2-n), max(j1, j2-n)
                }
                group = append(group, OpCode{c.Tag, i1, i2, j1, j2})
        }
        if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') {
                groups = append(groups, group)
        }
        return groups
}

// Ratio returns a measure of the sequences' similarity (float in [0,1]).
//
// Where T is the total number of elements in both sequences, and
// M is the number of matches, this is 2.0*M / T.
// Note that this is 1 if the sequences are identical, and 0 if
// they have nothing in common.
//
// .Ratio() is expensive to compute if you haven't already computed
// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
// want to try .QuickRatio() or .RealQuickRation() first to get an
// upper bound.
func (m *SequenceMatcher) Ratio() float64 {
        matches := 0
        for _, m := range m.GetMatchingBlocks() {
                matches += m.Size
        }
        return calculateRatio(matches, len(m.a)+len(m.b))
}

// QuickRatio returns an upper bound on ratio() relatively quickly.
//
// This isn't defined beyond that it is an upper bound on .Ratio(), and
// is faster to compute.
func (m *SequenceMatcher) QuickRatio() float64 {
        // viewing a and b as multisets, set matches to the cardinality
        // of their intersection; this counts the number of matches
        // without regard to order, so is clearly an upper bound
        if m.fullBCount == nil {
                m.fullBCount = map[string]int{}
                for _, s := range m.b {
                        m.fullBCount[s] = m.fullBCount[s] + 1
                }
        }

        // avail[x] is the number of times x appears in 'b' less the
        // number of times we've seen it in 'a' so far ... kinda
        avail := map[string]int{}
        matches := 0
        for _, s := range m.a {
                n, ok := avail[s]
                if !ok {
                        n = m.fullBCount[s]
                }
                avail[s] = n - 1
                if n > 0 {
                        matches += 1
                }
        }
        return calculateRatio(matches, len(m.a)+len(m.b))
}

// RealQuickRatio returns an upper bound on ratio() very quickly.
//
// This isn't defined beyond that it is an upper bound on .Ratio(), and
// is faster to compute than either .Ratio() or .QuickRatio().
func (m *SequenceMatcher) RealQuickRatio() float64 {
        la, lb := len(m.a), len(m.b)
        return calculateRatio(min(la, lb), la+lb)
}

func count_leading(line string, ch byte) (count int) {
        // Return number of `ch` characters at the start of `line`.
        count = 0
        n := len(line)
        for (count < n) && (line[count] == ch) {
                count++
        }
        return count
}

type DiffLine struct {
        Tag  byte
        Line string
}

func NewDiffLine(tag byte, line string) (l DiffLine) {
        l = DiffLine{}
        l.Tag = tag
        l.Line = line
        return l
}

type Differ struct {
        Linejunk func(string) bool
        Charjunk func(string) bool
}

func NewDiffer() *Differ {
        return &Differ{}
}

func (d *Differ) Compare(a []string, b []string) (diffs []string, err error) {
        // Compare two sequences of lines; generate the resulting delta.

        // Each sequence must contain individual single-line strings ending with
        // newlines. Such sequences can be obtained from the `readlines()` method
        // of file-like objects.  The delta generated also consists of newline-
        // terminated strings, ready to be printed as-is via the writeline()
        // method of a file-like object.
        diffs = []string{}
        cruncher := NewMatcherWithJunk(a, b, true, d.Linejunk)
        opcodes := cruncher.GetOpCodes()
        for _, current := range opcodes {
                alo := current.I1
                ahi := current.I2
                blo := current.J1
                bhi := current.J2
                var g []string
                if current.Tag == 'r' {
                        g, _ = d.FancyReplace(a, alo, ahi, b, blo, bhi)
                } else if current.Tag == 'd' {
                        g = d.Dump("-", a, alo, ahi)
                } else if current.Tag == 'i' {
                        g = d.Dump("+", b, blo, bhi)
                } else if current.Tag == 'e' {
                        g = d.Dump(" ", a, alo, ahi)
                } else {
                        return nil, fmt.Errorf("unknown tag %q", current.Tag)
                }
                diffs = append(diffs, g...)
        }
        return diffs, nil
}

func (d *Differ) StructuredDump(tag byte, x []string, low int, high int) (out []DiffLine) {
        size := high - low
        out = make([]DiffLine, size)
        for i := 0; i < size; i++ {
                out[i] = NewDiffLine(tag, x[i+low])
        }
        return out
}

func (d *Differ) Dump(tag string, x []string, low int, high int) (out []string) {
        // Generate comparison results for a same-tagged range.
        sout := d.StructuredDump(tag[0], x, low, high)
        out = make([]string, len(sout))
        var bld strings.Builder
        bld.Grow(1024)
        for i, line := range sout {
                bld.Reset()
                bld.WriteByte(line.Tag)
                bld.WriteString(" ")
                bld.WriteString(line.Line)
                out[i] = bld.String()
        }
        return out
}

func (d *Differ) PlainReplace(a []string, alo int, ahi int, b []string, blo int, bhi int) (out []string, err error) {
        if !(alo < ahi) || !(blo < bhi) { // assertion
                return nil, errors.New("low greater than or equal to high")
        }
        // dump the shorter block first -- reduces the burden on short-term
        // memory if the blocks are of very different sizes
        if bhi-blo < ahi-alo {
                out = d.Dump("+", b, blo, bhi)
                out = append(out, d.Dump("-", a, alo, ahi)...)
        } else {
                out = d.Dump("-", a, alo, ahi)
                out = append(out, d.Dump("+", b, blo, bhi)...)
        }
        return out, nil
}

func (d *Differ) FancyReplace(a []string, alo int, ahi int, b []string, blo int, bhi int) (out []string, err error) {
        // When replacing one block of lines with another, search the blocks
        // for *similar* lines; the best-matching pair (if any) is used as a
        // synch point, and intraline difference marking is done on the
        // similar pair. Lots of work, but often worth it.

        // don't synch up unless the lines have a similarity score of at
        // least cutoff; best_ratio tracks the best score seen so far
        best_ratio := 0.74
        cutoff := 0.75
        cruncher := NewMatcherWithJunk(a, b, true, d.Charjunk)
        eqi := -1 // 1st indices of equal lines (if any)
        eqj := -1
        out = []string{}

        // search for the pair that matches best without being identical
        // (identical lines must be junk lines, & we don't want to synch up
        // on junk -- unless we have to)
        var best_i, best_j int
        for j := blo; j < bhi; j++ {
                bj := b[j]
                cruncher.SetSeq2(listifyString(bj))
                for i := alo; i < ahi; i++ {
                        ai := a[i]
                        if ai == bj {
                                if eqi == -1 {
                                        eqi = i
                                        eqj = j
                                }
                                continue
                        }
                        cruncher.SetSeq1(listifyString(ai))
                        // computing similarity is expensive, so use the quick
                        // upper bounds first -- have seen this speed up messy
                        // compares by a factor of 3.
                        // note that ratio() is only expensive to compute the first
                        // time it's called on a sequence pair; the expensive part
                        // of the computation is cached by cruncher
                        if cruncher.RealQuickRatio() > best_ratio &&
                                cruncher.QuickRatio() > best_ratio &&
                                cruncher.Ratio() > best_ratio {
                                best_ratio = cruncher.Ratio()
                                best_i = i
                                best_j = j
                        }
                }
        }
        if best_ratio < cutoff {
                // no non-identical "pretty close" pair
                if eqi == -1 {
                        // no identical pair either -- treat it as a straight replace
                        out, _ = d.PlainReplace(a, alo, ahi, b, blo, bhi)
                        return out, nil
                }
                // no close pair, but an identical pair -- synch up on that
                best_i = eqi
                best_j = eqj
                best_ratio = 1.0
        } else {
                // there's a close pair, so forget the identical pair (if any)
                eqi = -1
        }
        // a[best_i] very similar to b[best_j]; eqi is None iff they're not
        // identical

        // pump out diffs from before the synch point
        out = append(out, d.fancyHelper(a, alo, best_i, b, blo, best_j)...)

        // do intraline marking on the synch pair
        aelt, belt := a[best_i], b[best_j]
        if eqi == -1 {
                // pump out a '-', '?', '+', '?' quad for the synched lines
                var atags, btags string
                cruncher.SetSeqs(listifyString(aelt), listifyString(belt))
                opcodes := cruncher.GetOpCodes()
                for _, current := range opcodes {
                        ai1 := current.I1
                        ai2 := current.I2
                        bj1 := current.J1
                        bj2 := current.J2
                        la, lb := ai2-ai1, bj2-bj1
                        if current.Tag == 'r' {
                                atags += strings.Repeat("^", la)
                                btags += strings.Repeat("^", lb)
                        } else if current.Tag == 'd' {
                                atags += strings.Repeat("-", la)
                        } else if current.Tag == 'i' {
                                btags += strings.Repeat("+", lb)
                        } else if current.Tag == 'e' {
                                atags += strings.Repeat(" ", la)
                                btags += strings.Repeat(" ", lb)
                        } else {
                                return nil, fmt.Errorf("unknown tag %q",
                                        current.Tag)
                        }
                }
                out = append(out, d.QFormat(aelt, belt, atags, btags)...)
        } else {
                // the synch pair is identical
                out = append(out, "  "+aelt)
        }
        // pump out diffs from after the synch point
        out = append(out, d.fancyHelper(a, best_i+1, ahi, b, best_j+1, bhi)...)
        return out, nil
}

func (d *Differ) fancyHelper(a []string, alo int, ahi int, b []string, blo int, bhi int) (out []string) {
        if alo < ahi {
                if blo < bhi {
                        out, _ = d.FancyReplace(a, alo, ahi, b, blo, bhi)
                } else {
                        out = d.Dump("-", a, alo, ahi)
                }
        } else if blo < bhi {
                out = d.Dump("+", b, blo, bhi)
        } else {
                out = []string{}
        }
        return out
}

func (d *Differ) QFormat(aline string, bline string, atags string, btags string) (out []string) {
        // Format "?" output and deal with leading tabs.

        // Can hurt, but will probably help most of the time.
        common := min(count_leading(aline, '\t'), count_leading(bline, '\t'))
        common = min(common, count_leading(atags[:common], ' '))
        common = min(common, count_leading(btags[:common], ' '))
        atags = strings.TrimRightFunc(atags[common:], unicode.IsSpace)
        btags = strings.TrimRightFunc(btags[common:], unicode.IsSpace)

        out = []string{"- " + aline}
        if len(atags) > 0 {
                out = append(out, fmt.Sprintf("? %s%s\n",
                        strings.Repeat("\t", common), atags))
        }
        out = append(out, "+ "+bline)
        if len(btags) > 0 {
                out = append(out, fmt.Sprintf("? %s%s\n",
                        strings.Repeat("\t", common), btags))
        }
        return out
}

// Convert range to the "ed" format
func formatRangeUnified(start, stop int) string {
        // Per the diff spec at http://www.unix.org/single_unix_specification/
        beginning := start + 1 // lines start numbering with one
        length := stop - start
        if length == 1 {
                return fmt.Sprintf("%d", beginning)
        }
        if length == 0 {
                beginning -= 1 // empty ranges begin at line just before the range
        }
        return fmt.Sprintf("%d,%d", beginning, length)
}

// LineDiffParams contains unified diff parameters
type LineDiffParams struct {
        A          []string          // First sequence lines
        FromFile   string            // First file name
        FromDate   string            // First file time
        B          []string          // Second sequence lines
        ToFile     string            // Second file name
        ToDate     string            // Second file time
        Eol        string            // Headers end of line, defaults to LF
        Context    int               // Number of context lines
        AutoJunk   bool              // If true, use autojunking
        IsJunkLine func(string) bool // How to spot junk lines
}

// WriteUnifiedDiff compares two sequences of lines and generates the delta as a unified diff.
//
// Unified diffs are a compact way of showing line changes and a few
// lines of context.  The number of context lines is set by 'n' which
// defaults to three.
//
// By default, the diff control lines (those with ---, +++, or @@) are
// created with a trailing newline.  This is helpful so that inputs
// created from file.readlines() result in diffs that are suitable for
// file.writelines() since both the inputs and outputs have trailing
// newlines.
//
// For inputs that do not have trailing newlines, set the lineterm
// argument to "" so that the output will be uniformly newline free.
//
// The unidiff format normally has a header for filenames and modification
// times.  Any or all of these may be specified using strings for
// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
// The modification times are normally expressed in the ISO 8601 format.
func WriteUnifiedDiff(writer io.Writer, diff LineDiffParams) error {
        //buf := bufio.NewWriter(writer)
        //defer buf.Flush()
        var bld strings.Builder
        bld.Reset()
        wf := func(format string, args ...any) error {
                _, err := fmt.Fprintf(&bld, format, args...)
                return err
        }
        ws := func(s string) error {
                _, err := bld.WriteString(s)
                return err
        }

        if len(diff.Eol) == 0 {
                diff.Eol = "\n"
        }

        started := false
        m := NewMatcher(diff.A, diff.B)
        if diff.AutoJunk || diff.IsJunkLine != nil {
                m = NewMatcherWithJunk(diff.A, diff.B, diff.AutoJunk, diff.IsJunkLine)
        }
        for _, g := range m.GetGroupedOpCodes(diff.Context) {
                if !started {
                        started = true
                        fromDate := ""
                        if len(diff.FromDate) > 0 {
                                fromDate = "\t" + diff.FromDate
                        }
                        toDate := ""
                        if len(diff.ToDate) > 0 {
                                toDate = "\t" + diff.ToDate
                        }
                        if diff.FromFile != "" || diff.ToFile != "" {
                                err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol)
                                if err != nil {
                                        return err
                                }
                                err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol)
                                if err != nil {
                                        return err
                                }
                        }
                }
                first, last := g[0], g[len(g)-1]
                range1 := formatRangeUnified(first.I1, last.I2)
                range2 := formatRangeUnified(first.J1, last.J2)
                if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil {
                        return err
                }
                for _, c := range g {
                        i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2
                        if c.Tag == 'e' {
                                for _, line := range diff.A[i1:i2] {
                                        if err := ws(" " + line); err != nil {
                                                return err
                                        }
                                }
                                continue
                        }
                        if c.Tag == 'r' || c.Tag == 'd' {
                                for _, line := range diff.A[i1:i2] {
                                        if err := ws("-" + line); err != nil {
                                                return err
                                        }
                                }
                        }
                        if c.Tag == 'r' || c.Tag == 'i' {
                                for _, line := range diff.B[j1:j2] {
                                        if err := ws("+" + line); err != nil {
                                                return err
                                        }
                                }
                        }
                }
        }
        buf := bufio.NewWriter(writer)
        buf.WriteString(bld.String())
        buf.Flush()
        return nil
}

// GetUnifiedDiffString is like WriteUnifiedDiff but returns the diff a string.
func GetUnifiedDiffString(diff LineDiffParams) (string, error) {
        w := &bytes.Buffer{}
        err := WriteUnifiedDiff(w, diff)
        return w.String(), err
}

// Convert range to the "ed" format.
func formatRangeContext(start, stop int) string {
        // Per the diff spec at http://www.unix.org/single_unix_specification/
        beginning := start + 1 // lines start numbering with one
        length := stop - start
        if length == 0 {
                beginning -= 1 // empty ranges begin at line just before the range
        }
        if length <= 1 {
                return fmt.Sprintf("%d", beginning)
        }
        return fmt.Sprintf("%d,%d", beginning, beginning+length-1)
}

// ContextDiff is for backward compatibility. Ugh.
type ContextDiff = LineDiffParams
type UnifiedDiff = LineDiffParams

// WriteContextDiff compares two sequences of lines and generates the delta as a context diff.
//
// Context diffs are a compact way of showing line changes and a few
// lines of context. The number of context lines is set by diff.Context
// which defaults to three.
//
// By default, the diff control lines (those with *** or ---) are
// created with a trailing newline.
//
// For inputs that do not have trailing newlines, set the diff.Eol
// argument to "" so that the output will be uniformly newline free.
//
// The context diff format normally has a header for filenames and
// modification times.  Any or all of these may be specified using
// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
// The modification times are normally expressed in the ISO 8601 format.
// If not specified, the strings default to blanks.
func WriteContextDiff(writer io.Writer, diff LineDiffParams) error {
        buf := bufio.NewWriter(writer)
        defer buf.Flush()
        var diffErr error
        wf := func(format string, args ...any) {
                _, err := buf.WriteString(fmt.Sprintf(format, args...))
                if diffErr == nil && err != nil {
                        diffErr = err
                }
        }
        ws := func(s string) {
                _, err := buf.WriteString(s)
                if diffErr == nil && err != nil {
                        diffErr = err
                }
        }

        if len(diff.Eol) == 0 {
                diff.Eol = "\n"
        }

        prefix := map[byte]string{
                'i': "+ ",
                'd': "- ",
                'r': "! ",
                'e': "  ",
        }

        started := false
        m := NewMatcher(diff.A, diff.B)
        if diff.AutoJunk || diff.IsJunkLine != nil {
                m = NewMatcherWithJunk(diff.A, diff.B, diff.AutoJunk, diff.IsJunkLine)
        }
        for _, g := range m.GetGroupedOpCodes(diff.Context) {
                if !started {
                        started = true
                        fromDate := ""
                        if len(diff.FromDate) > 0 {
                                fromDate = "\t" + diff.FromDate
                        }
                        toDate := ""
                        if len(diff.ToDate) > 0 {
                                toDate = "\t" + diff.ToDate
                        }
                        if diff.FromFile != "" || diff.ToFile != "" {
                                wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
                                wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
                        }
                }

                first, last := g[0], g[len(g)-1]
                ws("***************" + diff.Eol)

                range1 := formatRangeContext(first.I1, last.I2)
                wf("*** %s ****%s", range1, diff.Eol)
                for _, c := range g {
                        if c.Tag == 'r' || c.Tag == 'd' {
                                for _, cc := range g {
                                        if cc.Tag == 'i' {
                                                continue
                                        }
                                        for _, line := range diff.A[cc.I1:cc.I2] {
                                                ws(prefix[cc.Tag] + line)
                                        }
                                }
                                break
                        }
                }

                range2 := formatRangeContext(first.J1, last.J2)
                wf("--- %s ----%s", range2, diff.Eol)
                for _, c := range g {
                        if c.Tag == 'r' || c.Tag == 'i' {
                                for _, cc := range g {
                                        if cc.Tag == 'd' {
                                                continue
                                        }
                                        for _, line := range diff.B[cc.J1:cc.J2] {
                                                ws(prefix[cc.Tag] + line)
                                        }
                                }
                                break
                        }
                }
        }
        return diffErr
}

// GetContextDiffString is like WriteContextDiff but returns the diff as a string.
func GetContextDiffString(diff LineDiffParams) (string, error) {
        w := &bytes.Buffer{}
        err := WriteContextDiff(w, diff)
        return w.String(), err
}

// SplitLines splits a string on "\n" while preserving them. The output can be used
// as input for LineDiffParams.
func SplitLines(s string) []string {
        lines := strings.SplitAfter(s, "\n")
        lines[len(lines)-1] += "\n"
        return lines
}

package tester

import (
        "math/rand"
        "time"
)

func prepareStrings(seed int64) (A, B []string) {
        if seed == -1 {
                seed = time.Now().UnixNano()
        }
        rand.Seed(seed)
        // Generate 4000 random lines
        lines := [4000]string{}
        for i := range lines {
                l := rand.Intn(100)
                p := make([]byte, l)
                rand.Read(p)
                lines[i] = string(p)
        }
        // Generate two 4000 lines documents by picking some lines at random
        A = make([]string, 4000)
        B = make([]string, len(A))
        for i := range A {
                // make the first 50 lines more likely to appear
                if rand.Intn(100) < 40 {
                        A[i] = lines[rand.Intn(50)]
                } else {
                        A[i] = lines[rand.Intn(len(lines))]
                }
                if rand.Intn(100) < 40 {
                        B[i] = lines[rand.Intn(50)]
                } else {
                        B[i] = lines[rand.Intn(len(lines))]
                }
        }
        // Do some copies from A to B
        maxcopy := rand.Intn(len(A)-1) + 1
        for copied, tocopy := 0, rand.Intn(2*len(A)/3); copied < tocopy; {
                l := rand.Intn(rand.Intn(maxcopy-1) + 1)
                for a, b, n := rand.Intn(len(A)), rand.Intn(len(B)), 0; a < len(A) && b < len(B) && n < l; a, b, n = a+1, b+1, n+1 {
                        B[b] = A[a]
                        copied++
                }
        }
        // And some from B to A
        for copied, tocopy := 0, rand.Intn(2*len(A)/3); copied < tocopy; {
                l := rand.Intn(rand.Intn(maxcopy-1) + 1)
                for a, b, n := rand.Intn(len(A)), rand.Intn(len(B)), 0; a < len(A) && b < len(B) && n < l; a, b, n = a+1, b+1, n+1 {
                        A[a] = B[b]
                        copied++
                }
        }
        return
}

func PrepareStringsToDiff(count, seed int) (As, Bs [][]string) {
        As = make([][]string, count)
        Bs = make([][]string, count)
        for i := range As {
                As[i], Bs[i] = prepareStrings(int64(i + seed))
        }
        return
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

//go:generate core generate -add-types

import (
        "bytes"
        "fmt"
        "math"
        "os"
        "strconv"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/keylist"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/text/fonts"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/tree"
        "github.com/go-text/typesetting/font"
        "github.com/go-text/typesetting/font/opentype"
)

// Browser is a font browser.
type Browser struct {
        core.Frame

        Filename core.Filename
        IsEmoji  bool // true if an emoji font
        Font     *font.Face
        RuneMap  *keylist.List[rune, font.GID]
}

// OpenFile opens a font file.
func (fb *Browser) OpenFile(fname core.Filename) error { //types:add
        return fb.OpenFileIndex(fname, 0)
}

// OpenFileIndex opens a font file.
func (fb *Browser) OpenFileIndex(fname core.Filename, index int) error { //types:add
        b, err := os.ReadFile(string(fname))
        if errors.Log(err) != nil {
                return err
        }
        fb.Filename = fname
        fb.IsEmoji = strings.Contains(strings.ToLower(string(fb.Filename)), "emoji")
        if fb.IsEmoji {
                core.MessageSnackbar(fb, "Opening emoji font: "+string(fb.Filename)+" will take a while to render..")
        }
        return fb.OpenFontData(b, index)
}

// SelectFont selects a font from among a loaded list.
func (fb *Browser) SelectFont() { //types:add
        d := core.NewBody("Select Font")
        d.SetTitle("Select a font family")
        si := 0
        fl := fb.Scene.TextShaper().FontList()
        fi := fonts.Families(fl)
        tb := core.NewTable(d)
        tb.SetSlice(&fi).SetSelectedField("Family").
                SetSelectedValue(fb.Font.Describe().Family).BindSelect(&si)
        tb.SetTableStyler(func(w core.Widget, s *styles.Style, row, col int) {
                if col != 1 {
                        return
                }
                s.Font.CustomFont = rich.FontName(fi[row].Family)
                s.Font.Family = rich.Custom
                s.Font.Size.Dp(24)
        })
        d.AddBottomBar(func(bar *core.Frame) {
                d.AddOK(bar).OnClick(func(e events.Event) {
                        fam := fi[si].Family
                        idx := 0
                        for i := range fl {
                                if fl[i].Family == fam && (fl[i].Weight == rich.Medium || fl[i].Weight == rich.Normal) {
                                        idx = i
                                        break
                                }
                        }
                        loc := fl[idx].Font.Location
                        finfo := fmt.Sprintf("loading font: %s from: %s idx: %d, sel: %d", fam, loc.File, loc.Index, si)
                        fmt.Println(finfo)
                        core.MessageSnackbar(fb, finfo)
                        fb.OpenFileIndex(core.Filename(loc.File), int(loc.Index))
                })
        })
        d.RunWindowDialog(fb)
}

// OpenFontData opens given font data.
func (fb *Browser) OpenFontData(b []byte, index int) error {
        faces, err := font.ParseTTC(bytes.NewReader(b))
        if errors.Log(err) != nil {
                return err
        }
        // fmt.Println("number of faces:", len(faces), "index:", index)
        fb.Font = faces[index]
        for i, fnt := range faces {
                d := fnt.Describe()
                fmt.Println("index:", i, "family:", d.Family, "Aspect:", d.Aspect)
        }
        fb.UpdateRuneMap()
        fb.Update()
        return nil
}

func (fb *Browser) UpdateRuneMap() {
        fb.DeleteChildren()
        fb.RuneMap = keylist.New[rune, font.GID]()
        if fb.Font == nil {
                return
        }
        // for _, pr := range unicode.PrintRanges {
        //         for _, rv := range pr.R16 {
        //                 for r := rv.Lo; r <= rv.Hi; r += rv.Stride {
        //                         gid, has := fb.Font.NominalGlyph(rune(r))
        //                         if !has {
        //                                 continue
        //                         }
        //                         fb.RuneMap.Add(rune(r), gid)
        //                 }
        //         }
        // }
        if fb.IsEmoji {
                // for r := rune(0); r < math.MaxInt16; r++ {
                for r := rune(0); r < math.MaxInt32; r++ { // takes a LONG time..
                        gid, has := fb.Font.NominalGlyph(r)
                        if !has {
                                continue
                        }
                        fb.RuneMap.Add(r, gid)
                }
        } else {
                for r := rune(0); r < math.MaxInt16; r++ {
                        gid, has := fb.Font.NominalGlyph(r)
                        if !has {
                                continue
                        }
                        fb.RuneMap.Add(r, gid)
                }
        }
}

// SelectRune selects a rune in current font (first char) of string.
func (fb *Browser) SelectRune(r string) { //types:add
        rs := []rune(r)
        if len(rs) == 0 {
                core.MessageSnackbar(fb, "no runes!")
                return
        }
        ix := fb.RuneMap.IndexByKey(rs[0])
        if ix < 0 {
                core.MessageSnackbar(fb, "rune not found!")
                return
        }
        gi := fb.Child(ix).(core.Widget).AsWidget()
        gi.Styles.State.SetFlag(true, states.Selected, states.Active)
        gi.SetFocus()
        core.MessageSnackbar(fb, fmt.Sprintf("rune %s at index: %d GID: %d", r, ix, fb.RuneMap.Values[ix]))
}

// SelectRuneInt selects a rune in current font by number
func (fb *Browser) SelectRuneInt(r int) { //types:add
        ix := fb.RuneMap.IndexByKey(rune(r))
        if ix < 0 {
                core.MessageSnackbar(fb, "rune not found!")
                return
        }
        gi := fb.Child(ix).(core.Widget).AsWidget()
        gi.Styles.State.SetFlag(true, states.Selected, states.Active)
        gi.SetFocus()
        core.MessageSnackbar(fb, fmt.Sprintf("rune %s at index: %d GID: %d", string(rune(r)), ix, fb.RuneMap.Values[ix]))
}

// SelectGlyphID selects glyphID in current font.
func (fb *Browser) SelectGlyphID(gid opentype.GID) { //types:add
        ix := -1
        for i, g := range fb.RuneMap.Values {
                if gid == g {
                        ix = i
                        break
                }
        }
        if ix < 0 {
                core.MessageSnackbar(fb, "glyph id not found!")
                return
        }
        r := string(rune(fb.RuneMap.Keys[ix]))
        gi := fb.Child(ix).(core.Widget).AsWidget()
        gi.Styles.State.SetFlag(true, states.Selected, states.Active)
        gi.SetFocus()
        core.MessageSnackbar(fb, fmt.Sprintf("rune %s at index: %d GID: %d", r, ix, fb.RuneMap.Values[ix]))
}

// SaveUnicodes saves all the unicodes in hex format to a file called unicodes.md
func (fb *Browser) SaveUnicodes() { //types:add
        var b strings.Builder
        for _, r := range fb.RuneMap.Keys {
                b.WriteString(fmt.Sprintf("%X\n", r))
        }
        os.WriteFile("unicodes.md", []byte(b.String()), 0666)
}

func (fb *Browser) Init() {
        fb.Frame.Init()
        fb.Styler(func(s *styles.Style) {
                // s.Display = styles.Flex
                // s.Wrap = true
                // s.Direction = styles.Row
                s.Display = styles.Grid
                s.Columns = 32
        })
        fb.Maker(func(p *tree.Plan) {
                if fb.Font == nil {
                        return
                }
                for i, gid := range fb.RuneMap.Values {
                        r := fb.RuneMap.Keys[i]
                        nm := string(r) + "_" + strconv.Itoa(int(r))
                        tree.AddAt(p, nm, func(w *Glyph) {
                                w.SetBrowser(fb).SetRune(r).SetGID(gid)
                        })
                }
        })
}

func (fb *Browser) MakeToolbar(p *tree.Plan) {
        tree.Add(p, func(w *core.FuncButton) {
                w.SetFunc(fb.OpenFile).SetIcon(icons.Open).SetKey(keymap.Open)
                w.Args[0].SetValue(fb.Filename).SetTag(`extension:".ttf"`)
        })
        tree.Add(p, func(w *core.FuncButton) {
                w.SetFunc(fb.SelectFont).SetIcon(icons.Open)
        })
        tree.Add(p, func(w *core.FuncButton) {
                w.SetFunc(fb.SelectEmbedded).SetIcon(icons.Open)
        })
        tree.Add(p, func(w *core.FuncButton) {
                w.SetFunc(fb.SelectRune).SetIcon(icons.Select)
        })
        tree.Add(p, func(w *core.FuncButton) {
                w.SetFunc(fb.SelectRuneInt).SetIcon(icons.Select)
        })
        tree.Add(p, func(w *core.FuncButton) {
                w.SetFunc(fb.SelectGlyphID).SetIcon(icons.Select)
        })
        tree.Add(p, func(w *core.FuncButton) {
                w.SetFunc(fb.SaveUnicodes).SetIcon(icons.Save)
        })
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/fonts"
        "cogentcore.org/core/text/rich"
        "github.com/go-text/typesetting/font"
        "github.com/go-text/typesetting/font/opentype"
)

// GlyphInfo returns info about a glyph.
type GlyphInfo struct {
        // Rune is the unicode rune as a string
        Rune string

        // RuneInt is the unicode code point, int number.
        RuneInt rune

        // RuneHex is the unicode code point, hexidecimal number.
        RuneHex rune `format:"%0X"`

        // GID is the glyph ID, specific to each Font.
        GID font.GID

        // HAdvance is the horizontal advance.
        HAdvance float32

        // Extents give the size of the glyph.
        Extents opentype.GlyphExtents

        // Extents are the horizontal font size parameters.
        HExtents font.FontExtents

        // Outline has the end points of each segment of the outline.
        Outline []math32.Vector2
}

func NewGlyphInfo(face *font.Face, r rune, gid font.GID) *GlyphInfo {
        gi := &GlyphInfo{}
        gi.Set(face, r, gid)
        return gi
}

// Set sets the info from given [font.Face] and gid.
func (gi *GlyphInfo) Set(face *font.Face, r rune, gid font.GID) {
        gi.Rune = string(r)
        gi.RuneInt = r
        gi.RuneHex = r
        gi.GID = gid
        gi.HAdvance = face.HorizontalAdvance(gid)
        gi.HExtents, _ = face.FontHExtents()
        gi.Extents, _ = face.GlyphExtents(gid)
}

// Glyph displays an individual glyph in the browser
type Glyph struct {
        core.Canvas

        // Rune is the rune to render.
        Rune rune

        // GID is the glyph ID of the Rune
        GID font.GID

        // Outline is the set of control points (end points only).
        Outline []math32.Vector2 `set:"-"`

        // Stroke only renders the outline of the glyph, not the standard fill.
        Stroke bool

        // Points plots the control points.
        Points bool

        Browser *Browser
}

func (gi *Glyph) Init() {
        gi.Canvas.Init()
        gi.Styler(func(s *styles.Style) {
                s.Min.Set(units.Em(3))
                s.SetTextWrap(false)
                s.Cursor = cursors.Pointer
                if gi.Browser == nil {
                        return
                }
                s.SetAbilities(true, abilities.Clickable, abilities.Focusable, abilities.Activatable, abilities.Selectable)
                sty, tsty := s.NewRichText()
                fonts.Style(gi.Browser.Font, sty, tsty)
        })
        gi.OnClick(func(e events.Event) {
                if gi.Stroke || gi.Browser == nil || gi.Browser.Font == nil {
                        return
                }
                gli := NewGlyphInfo(gi.Browser.Font, gi.Rune, gi.GID)
                gli.Outline = gi.Outline
                d := core.NewBody("Glyph Info")
                bg := NewGlyph(d).SetBrowser(gi.Browser).SetRune(gi.Rune).SetGID(gi.GID).
                        SetStroke(true).SetPoints(true)
                bg.Styler(func(s *styles.Style) {
                        s.Min.Set(units.Em(40))
                })
                core.NewForm(d).SetStruct(gli).StartFocus()
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddOK(bar)
                })
                d.RunWindowDialog(gi.Browser)
        })
        gi.SetDraw(gi.draw)
}

func (gi *Glyph) drawShaped(pc *paint.Painter) {
        sty, tsty := gi.Styles.NewRichText()
        fonts.Style(gi.Browser.Font, sty, tsty)
        sz := gi.Geom.Size.Actual.Content
        msz := min(sz.X, sz.Y)
        sty.Size = float32(msz) / tsty.FontSize.Dots
        sty.Size *= 0.85
        tx := rich.NewText(sty, []rune{gi.Rune})
        lns := gi.Scene.TextShaper().WrapLines(tx, sty, tsty, &core.AppearanceSettings.Text, sz)
        off := math32.Vec2(0, 0)
        if msz > 200 {
                o := 0.2 * float32(msz)
                if gi.Browser.IsEmoji {
                        off = math32.Vec2(0.5*o, -o)
                } else { // for bitmap fonts, kinda random
                        off = math32.Vec2(o, o)
                }
        }
        pc.DrawText(lns, gi.Geom.Pos.Content.Add(off))
}

func (gi *Glyph) draw(pc *paint.Painter) {
        if gi.Browser == nil || gi.Browser.Font == nil {
                return
        }
        face := gi.Browser.Font
        data := face.GlyphData(gi.GID)
        gd, ok := data.(font.GlyphOutline)
        if !ok {
                gi.drawShaped(pc)
                return
        }
        scale := 0.7 / float32(face.Upem())
        x := float32(0.1)
        y := float32(0.8)
        gi.Outline = slicesx.SetLength(gi.Outline, len(gd.Segments))
        pc.Fill.Color = colors.Scheme.Surface
        if gi.StateIs(states.Active) || gi.StateIs(states.Focused) || gi.StateIs(states.Selected) {
                pc.Fill.Color = colors.Scheme.Select.Container
        }
        pc.Stroke.Color = colors.Scheme.OnSurface
        pc.Rectangle(0, 0, 1, 1)
        pc.Draw()
        pc.Fill.Color = nil
        pc.Line(0, y, 1, y)
        pc.Draw()
        if gi.Stroke {
                pc.Stroke.Width.Dp(2)
                pc.Stroke.Color = colors.Scheme.OnSurface
                pc.Fill.Color = nil
        } else {
                pc.Stroke.Color = nil
                pc.Fill.Color = colors.Scheme.OnSurface
        }
        ext, _ := face.GlyphExtents(gi.GID)
        if ext.XBearing < 0 {
                x -= scale * ext.XBearing
        }
        var gp ppath.Path
        for i, s := range gd.Segments {
                px := s.Args[0].X*scale + x
                py := -s.Args[0].Y*scale + y
                switch s.Op {
                case opentype.SegmentOpMoveTo:
                        gp.MoveTo(px, py)
                        gi.Outline[i] = math32.Vec2(px, py)
                case opentype.SegmentOpLineTo:
                        gp.LineTo(px, py)
                        gi.Outline[i] = math32.Vec2(px, py)
                case opentype.SegmentOpQuadTo:
                        p1x := s.Args[1].X*scale + x
                        p1y := -s.Args[1].Y*scale + y
                        gp.QuadTo(px, py, p1x, p1y)
                        gi.Outline[i] = math32.Vec2(p1x, p1y)
                case opentype.SegmentOpCubeTo:
                        p1x := s.Args[1].X*scale + x
                        p1y := -s.Args[1].Y*scale + y
                        p2x := s.Args[2].X*scale + x
                        p2y := -s.Args[2].Y*scale + y
                        gp.CubeTo(px, py, p1x, p1y, p2x, p2y)
                        gi.Outline[i] = math32.Vec2(p2x, p2y)
                }
        }
        bb := gp.FastBounds()
        sx := float32(1)
        sy := float32(1)
        if bb.Max.X >= 0.98 {
                sx = 0.9 / bb.Max.X
        }
        if bb.Min.Y < 0 {
                sy = 0.9 * (1 + bb.Min.Y) / 1.0
                gp = gp.Translate(0, -bb.Min.Y/sy)
                y -= bb.Min.Y / sy
        }
        if bb.Max.Y > 1 {
                sy *= 0.9 / bb.Max.Y
        }
        if sx != 1 || sy != 1 {
                gp = gp.Scale(sx, sy)
        }
        pc.State.Path = gp
        pc.Draw()

        // Points
        if !gi.Points {
                return
        }
        pc.Stroke.Color = nil
        pc.Fill.Color = colors.Scheme.Primary.Base
        radius := float32(0.01)
        for _, s := range gd.Segments {
                px := sx * (s.Args[0].X*scale + x)
                py := sy * (-s.Args[0].Y*scale + y)
                switch s.Op {
                case opentype.SegmentOpMoveTo, opentype.SegmentOpLineTo:
                        pc.Circle(px, py, radius)
                case opentype.SegmentOpQuadTo:
                        p1x := sx * (s.Args[1].X*scale + x)
                        p1y := sy * (-s.Args[1].Y*scale + y)
                        pc.Circle(p1x, p1y, radius)
                case opentype.SegmentOpCubeTo:
                        p2x := sx * (s.Args[2].X*scale + x)
                        p2y := sy * (-s.Args[2].Y*scale + y)
                        pc.Circle(p2x, p2y, radius)
                }
        }
        pc.Draw()

        radius *= 0.8
        pc.Stroke.Color = nil
        pc.Fill.Color = colors.Scheme.Error.Base
        for _, s := range gd.Segments {
                px := sx * (s.Args[0].X*scale + x)
                py := sy * (-s.Args[0].Y*scale + y)
                switch s.Op {
                case opentype.SegmentOpQuadTo:
                        pc.Circle(px, py, radius)
                case opentype.SegmentOpCubeTo:
                        p1x := sx * (s.Args[1].X*scale + x)
                        p1y := sy * (-s.Args[1].Y*scale + y)
                        pc.Circle(px, py, radius)
                        pc.Circle(p1x, p1y, radius)
                }
        }
        pc.Draw()

        pc.Stroke.Color = colors.Scheme.Error.Base
        pc.Fill.Color = nil
        for _, s := range gd.Segments {
                px := sx * (s.Args[0].X*scale + x)
                py := sy * (-s.Args[0].Y*scale + y)
                switch s.Op {
                case opentype.SegmentOpQuadTo:
                        p1x := sx * (s.Args[1].X*scale + x)
                        p1y := sy * (-s.Args[1].Y*scale + y)
                        pc.Line(p1x, p1y, px, py)
                case opentype.SegmentOpCubeTo:
                        p1x := sx * (s.Args[1].X*scale + x)
                        p1y := sy * (-s.Args[1].Y*scale + y)
                        p2x := sx * (s.Args[2].X*scale + x)
                        p2y := sy * (-s.Args[2].Y*scale + y)
                        pc.Line(px, py, p2x, p2y)
                        pc.Line(p1x, p1y, p2x, p2y)
                }
        }
        pc.Draw()

}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "cogentcore.org/core/core"

func main() {
        b := core.NewBody()
        fb := NewBrowser(b)
        fb.OpenFile("../noto/NotoSans-Regular.ttf")
        b.AddTopBar(func(bar *core.Frame) {
                core.NewToolbar(bar).Maker(fb.MakeToolbar)
        })
        b.RunMainWindow()
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/text/tex"
)

func init() {
        tex.LMFontsLoad()
}

// SelectEmbedded selects an embedded font from a list.
func (fb *Browser) SelectEmbedded() { //types:add
        d := core.NewBody("Select Font")
        d.SetTitle("Select an embedded font")
        si := 0
        fl := tex.LMFonts
        names := make([]string, len(fl))
        for i := range fl {
                names[i] = fl[i].Family
        }
        tb := core.NewList(d)
        tb.SetSlice(&names).BindSelect(&si)
        d.AddBottomBar(func(bar *core.Frame) {
                d.AddOK(bar).OnClick(func(e events.Event) {
                        fb.Font = fl[si].Fonts[0]
                        fb.UpdateRuneMap()
                        fb.Update()
                })
        })
        d.RunWindowDialog(fb)
}

// Code generated by "core generate -add-types"; DO NOT EDIT.

package main

import (
        "cogentcore.org/core/base/keylist"
        "cogentcore.org/core/core"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
        "github.com/go-text/typesetting/font"
)

var _ = types.AddType(&types.Type{Name: "main.Browser", IDName: "browser", Doc: "Browser is a font browser.", Methods: []types.Method{{Name: "OpenFile", Doc: "OpenFile opens a font file.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"fname"}, Returns: []string{"error"}}, {Name: "OpenFileIndex", Doc: "OpenFileIndex opens a font file.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"fname", "index"}, Returns: []string{"error"}}, {Name: "SelectFont", Doc: "SelectFont selects a font from among a loaded list.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "SelectRune", Doc: "SelectRune selects a rune in current font (first char) of string.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"r"}}, {Name: "SelectRuneInt", Doc: "SelectRuneInt selects a rune in current font by number", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"r"}}, {Name: "SelectGlyphID", Doc: "SelectGlyphID selects glyphID in current font.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"gid"}}, {Name: "SaveUnicodes", Doc: "SaveUnicodes saves all the unicodes in hex format to a file called unicodes.md", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "SelectEmbedded", Doc: "SelectEmbedded selects an embedded font from a list.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Filename"}, {Name: "IsEmoji"}, {Name: "Font"}, {Name: "RuneMap"}}})

// NewBrowser returns a new [Browser] with the given optional parent:
// Browser is a font browser.
func NewBrowser(parent ...tree.Node) *Browser { return tree.New[Browser](parent...) }

// SetFilename sets the [Browser.Filename]
func (t *Browser) SetFilename(v core.Filename) *Browser { t.Filename = v; return t }

// SetIsEmoji sets the [Browser.IsEmoji]
func (t *Browser) SetIsEmoji(v bool) *Browser { t.IsEmoji = v; return t }

// SetFont sets the [Browser.Font]
func (t *Browser) SetFont(v *font.Face) *Browser { t.Font = v; return t }

// SetRuneMap sets the [Browser.RuneMap]
func (t *Browser) SetRuneMap(v *keylist.List[rune, font.GID]) *Browser { t.RuneMap = v; return t }

var _ = types.AddType(&types.Type{Name: "main.GlyphInfo", IDName: "glyph-info", Doc: "GlyphInfo returns info about a glyph.", Fields: []types.Field{{Name: "Rune", Doc: "Rune is the unicode rune as a string"}, {Name: "RuneInt", Doc: "RuneInt is the unicode code point, int number."}, {Name: "RuneHex", Doc: "RuneHex is the unicode code point, hexidecimal number."}, {Name: "GID", Doc: "GID is the glyph ID, specific to each Font."}, {Name: "HAdvance", Doc: "HAdvance is the horizontal advance."}, {Name: "Extents", Doc: "Extents give the size of the glyph."}, {Name: "HExtents", Doc: "Extents are the horizontal font size parameters."}, {Name: "Outline", Doc: "Outline has the end points of each segment of the outline."}}})

var _ = types.AddType(&types.Type{Name: "main.Glyph", IDName: "glyph", Doc: "Glyph displays an individual glyph in the browser", Embeds: []types.Field{{Name: "Canvas"}}, Fields: []types.Field{{Name: "Rune", Doc: "Rune is the rune to render."}, {Name: "GID", Doc: "GID is the glyph ID of the Rune"}, {Name: "Outline", Doc: "Outline is the set of control points (end points only)."}, {Name: "Stroke", Doc: "Stroke only renders the outline of the glyph, not the standard fill."}, {Name: "Points", Doc: "Points plots the control points."}, {Name: "Browser"}}})

// NewGlyph returns a new [Glyph] with the given optional parent:
// Glyph displays an individual glyph in the browser
func NewGlyph(parent ...tree.Node) *Glyph { return tree.New[Glyph](parent...) }

// SetRune sets the [Glyph.Rune]:
// Rune is the rune to render.
func (t *Glyph) SetRune(v rune) *Glyph { t.Rune = v; return t }

// SetGID sets the [Glyph.GID]:
// GID is the glyph ID of the Rune
func (t *Glyph) SetGID(v font.GID) *Glyph { t.GID = v; return t }

// SetStroke sets the [Glyph.Stroke]:
// Stroke only renders the outline of the glyph, not the standard fill.
func (t *Glyph) SetStroke(v bool) *Glyph { t.Stroke = v; return t }

// SetPoints sets the [Glyph.Points]:
// Points plots the control points.
func (t *Glyph) SetPoints(v bool) *Glyph { t.Points = v; return t }

// SetBrowser sets the [Glyph.Browser]
func (t *Glyph) SetBrowser(v *Browser) *Glyph { t.Browser = v; return t }

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fonts

import (
        "bytes"
        "cmp"
        "slices"

        "cogentcore.org/core/text/rich"
        "github.com/go-text/typesetting/font"
        "github.com/go-text/typesetting/fontscan"
)

// Info contains basic font information for aviailable fonts.
// This is used for a chooser for example.
type Info struct {

        // Family name.
        Family string

        // Weight: normal, bold, etc
        Weight rich.Weights

        // Slant: normal or italic
        Slant rich.Slants

        // Stretch: normal, expanded, condensed, etc
        Stretch rich.Stretch

        // Font contains info about the location, family, etc of the font file.
        Font fontscan.Footprint `display:"-"`
}

// Family is used for selecting a font family in a font chooser.
type Family struct {

        // Family name.
        Family string

        // example text, styled according to font family in chooser.
        Example string
}

// InfoExample is example text to demonstrate fonts.
var InfoExample = "AaBbCcIiPpQq12369$€¢?.:/()àáâãäåæç日本中国⇧⌘"

// Label satisfies the Labeler interface
func (fi Info) Label() string {
        return fi.Family
}

// Label satisfies the Labeler interface
func (fi Family) Label() string {
        return fi.Family
}

// Families returns a list of [Family] with one representative per family.
func Families(fi []Info) []Family {
        slices.SortFunc(fi, func(a, b Info) int {
                return cmp.Compare(a.Family, b.Family)
        })
        n := len(fi)
        ff := make([]Family, 0, n)
        for i := 0; i < n; i++ {
                cur := fi[i].Family
                ff = append(ff, Family{Family: cur, Example: InfoExample})
                for i < n-1 {
                        if fi[i+1].Family != cur {
                                break
                        }
                        i++
                }
        }
        return ff
}

// Data contains font information for embedded font data.
type Data struct {

        // Family name.
        Family string

        // Weight: normal, bold, etc.
        Weight rich.Weights

        // Slant: normal or italic.
        Slant rich.Slants

        // Stretch: normal, expanded, condensed, etc.
        Stretch rich.Stretch

        // Data contains the font data.
        Data []byte `display:"-"`

        // Font contains the loaded font face(s).
        Fonts []*font.Face
}

// Load loads the data, setting the Font.
func (fd *Data) Load() error {
        faces, err := font.ParseTTC(bytes.NewReader(fd.Data))
        if err != nil {
                return err
        }
        fd.Fonts = faces
        return nil
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fonts

import (
        "fmt"
        "io/fs"

        "cogentcore.org/core/base/errors"
        "github.com/go-text/typesetting/font/opentype"
        "github.com/go-text/typesetting/fontscan"
)

// Embedded are embedded filesystems to get fonts from. By default,
// this includes a set of Noto Sans and Roboto Mono fonts. System fonts are
// automatically supported separate from this. Use [AddEmbedded] to add
// to this. This must be called before the text shaper is created to have an effect.
//
// On web, Embedded is only used for font metrics, as the actual font
// rendering happens through web fonts. See https://cogentcore.org/core/font for
// more information.
var Embedded = []fs.FS{Default}

// AddEmbedded adds to [Embedded] for font loading.
func AddEmbedded(fsys ...fs.FS) {
        Embedded = append(Embedded, fsys...)
}

// UseEmbeddedInMap adds the fonts from the current [Embedded] list to the given map.
func UseEmbeddedInMap(fontMap *fontscan.FontMap) error {
        return UseInMap(fontMap, Embedded)
}

// UseInMap adds the fonts from given file systems to the given map.
func UseInMap(fontMap *fontscan.FontMap, fss []fs.FS) error {
        var errs []error
        for _, fsys := range fss {
                err := fs.WalkDir(fsys, ".", func(path string, d fs.DirEntry, err error) error {
                        if err != nil {
                                errs = append(errs, err)
                                return err
                        }
                        if d.IsDir() {
                                return nil
                        }
                        f, err := fsys.Open(path)
                        if err != nil {
                                errs = append(errs, err)
                                return err
                        }
                        defer f.Close()
                        resource, ok := f.(opentype.Resource)
                        if !ok {
                                err = fmt.Errorf("file %q cannot be used as an opentype.Resource", path)
                                errs = append(errs, err)
                                return err
                        }
                        err = fontMap.AddFont(resource, path, "")
                        if err != nil {
                                errs = append(errs, err)
                                return err
                        }
                        return nil
                })
                if err != nil {
                        errs = append(errs, err)
                }
        }
        return errors.Join(errs...)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Command metricsonly extracts font metrics from font files,
// discarding all the glyph outlines and other data.
package main

import (
        "fmt"
        "os"
        "path/filepath"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/cli"
        "github.com/go-text/typesetting/font/opentype"
)

//go:generate core generate -add-types -add-funcs

func ExtractMetrics(fname, outfile string, debug bool) error {
        if debug {
                fmt.Println(fname, "->", outfile)
        }
        f, err := os.Open(fname)
        if err != nil {
                return err
        }
        font, err := opentype.NewLoader(f)
        if err != nil {
                return err
        }
        // full list from roboto:
        // GSUB OS/2 STAT cmap gasp glyf head hhea hmtx loca maxp name post prep

        // minimal effective list: you have to exclude both loca and glyf -- if
        // you have loca it needs glyf, but otherwise fine to exclude.
        // include := []string{"head", "hhea", "htmx", "maxp", "name", "cmap"}
        include := []string{"head", "hhea", "htmx", "maxp", "name", "cmap"}
        tags := font.Tables()
        tables := make([]opentype.Table, len(tags))
        var taglist []string
        for i, tag := range tags {
                if debug {
                        taglist = append(taglist, tag.String())
                }
                skip := true
                for _, in := range include {
                        if tag.String() == in {
                                skip = false
                                break
                        }
                }
                if skip {
                        continue
                }
                tables[i].Tag = tag
                tables[i].Content, err = font.RawTable(tag)
                if tag.String() == "name" {
                        fmt.Println("name:", string(tables[i].Content))
                }
        }
        if debug {
                fmt.Println("\t", taglist)
        }
        content := opentype.WriteTTF(tables)
        return os.WriteFile(outfile, content, 0666)
}

type Config struct {
        // Files to extract metrics from.
        Files []string `flag:"f,files" posarg:"all"`

        // directory to output the metrics only files.
        Output string `flag:"output,o"`

        // emit debug info while processing. todo: use verbose for this!
        Debug bool `flag:"d,debug"`
}

// Extract reads fonts and extracts metrics, saving to given output directory.
func Extract(c *Config) error {
        if c.Output != "" {
                err := os.MkdirAll(c.Output, 0777)
                if err != nil {
                        return err
                }
        }
        var errs []error
        for _, fn := range c.Files {
                _, fname := filepath.Split(fn)
                outfile := filepath.Join(c.Output, fname)
                err := ExtractMetrics(fn, outfile, c.Debug)
                if err != nil {
                        errs = append(errs, err)
                }
        }
        return errors.Join(errs...)
}

func main() { //types:skip
        opts := cli.DefaultOptions("metricsonly", "metricsonly extracts font metrics from font files, discarding all the glyph outlines and other data.")
        cli.Run(opts, &Config{}, Extract)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package fonts

import (
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
        "github.com/go-text/typesetting/font"
)

// Style sets the [rich.Style] and [text.Style] for the given [font.Face].
func Style(face *font.Face, sty *rich.Style, tsty *text.Style) {
        if face == nil {
                return
        }
        d := face.Describe()
        tsty.CustomFont = rich.FontName(d.Family)
        sty.Family = rich.Custom
        as := d.Aspect
        sty.Weight = rich.Weights(int(as.Weight / 100.0))
        sty.Slant = rich.Slants(as.Style - 1)
        // fi[i].Stretch = rich.Stretch() // not avail
        // fi[i].Stretch = rich.StretchNormal
}

// Code generated by "core generate -add-types"; DO NOT EDIT.

package highlighting

import (
        "cogentcore.org/core/enums"
)

var _TrileanValues = []Trilean{0, 1, 2}

// TrileanN is the highest valid value for type Trilean, plus one.
const TrileanN Trilean = 3

var _TrileanValueMap = map[string]Trilean{`Pass`: 0, `Yes`: 1, `No`: 2}

var _TrileanDescMap = map[Trilean]string{0: ``, 1: ``, 2: ``}

var _TrileanMap = map[Trilean]string{0: `Pass`, 1: `Yes`, 2: `No`}

// String returns the string representation of this Trilean value.
func (i Trilean) String() string { return enums.String(i, _TrileanMap) }

// SetString sets the Trilean value from its string representation,
// and returns an error if the string is invalid.
func (i *Trilean) SetString(s string) error {
        return enums.SetString(i, s, _TrileanValueMap, "Trilean")
}

// Int64 returns the Trilean value as an int64.
func (i Trilean) Int64() int64 { return int64(i) }

// SetInt64 sets the Trilean value from an int64.
func (i *Trilean) SetInt64(in int64) { *i = Trilean(in) }

// Desc returns the description of the Trilean value.
func (i Trilean) Desc() string { return enums.Desc(i, _TrileanDescMap) }

// TrileanValues returns all possible values for the type Trilean.
func TrileanValues() []Trilean { return _TrileanValues }

// Values returns all possible values for the type Trilean.
func (i Trilean) Values() []enums.Enum { return enums.Values(_TrileanValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Trilean) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Trilean) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Trilean") }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package highlighting

import (
        "log/slog"
        "strings"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/lexer"
        _ "cogentcore.org/core/text/parse/supportedlanguages"
        "cogentcore.org/core/text/token"
        "github.com/alecthomas/chroma/v2"
        "github.com/alecthomas/chroma/v2/formatters/html"
        "github.com/alecthomas/chroma/v2/lexers"
)

// Highlighter performs syntax highlighting,
// using [parse] if available, otherwise falls back on chroma.
type Highlighter struct {

        // syntax highlighting style to use
        StyleName HighlightingName

        // chroma-based language name for syntax highlighting the code
        language string

        // Has is whether there are highlighting parameters set
        // (only valid after [Highlighter.init] has been called).
        Has bool

        // tab size, in chars
        TabSize int

        // Commpiled CSS properties for given highlighting style
        CSSProperties map[string]any

        // parser state info
        parseState *parse.FileStates

        // if supported, this is the [parse.Language] support for parsing
        parseLanguage parse.Language

        // Style is the current highlighting style.
        Style *Style

        // external toggle to turn off automatic highlighting
        off          bool
        lastLanguage string
        lastStyle    HighlightingName
        lexer        chroma.Lexer
        formatter    *html.Formatter
}

// UsingParse returns true if markup is using parse lexer / parser, which affects
// use of results
func (hi *Highlighter) UsingParse() bool {
        return hi.parseLanguage != nil
}

// Init initializes the syntax highlighting for current params
func (hi *Highlighter) Init(info *fileinfo.FileInfo, pist *parse.FileStates) {
        if hi.Style == nil {
                hi.SetStyle(DefaultStyle)
        }
        hi.parseState = pist

        if info.Known != fileinfo.Unknown {
                if lp, err := parse.LanguageSupport.Properties(info.Known); err == nil {
                        if lp.Lang != nil {
                                hi.lexer = nil
                                hi.parseLanguage = lp.Lang
                        } else {
                                hi.parseLanguage = nil
                        }
                }
        }

        if hi.parseLanguage == nil {
                lexer := lexers.MatchMimeType(info.Mime)
                if lexer == nil {
                        lexer = lexers.Match(info.Name)
                }
                if lexer != nil {
                        hi.language = lexer.Config().Name
                        hi.lexer = lexer
                }
        }

        if hi.StyleName == "" || (hi.parseLanguage == nil && hi.lexer == nil) {
                hi.Has = false
                return
        }
        hi.Has = true

        if hi.StyleName != hi.lastStyle {
                hi.Style = AvailableStyle(hi.StyleName)
                hi.CSSProperties = hi.Style.ToProperties()
                hi.lastStyle = hi.StyleName
        }

        if hi.lexer != nil && hi.language != hi.lastLanguage {
                hi.lexer = chroma.Coalesce(lexers.Get(hi.language))
                hi.formatter = html.New(html.WithClasses(true), html.TabWidth(hi.TabSize))
                hi.lastLanguage = hi.language
        }
}

// SetStyle sets the highlighting style and updates corresponding settings
func (hi *Highlighter) SetStyle(style HighlightingName) {
        if style == "" {
                return
        }
        st := AvailableStyle(hi.StyleName)
        if st == nil {
                slog.Error("Highlighter Style not found:", "style", style)
                return
        }
        hi.StyleName = style
        hi.Style = st
        hi.CSSProperties = hi.Style.ToProperties()
        hi.lastStyle = hi.StyleName
}

// MarkupTagsAll returns all the markup tags according to current
// syntax highlighting settings
func (hi *Highlighter) MarkupTagsAll(txt []byte) ([]lexer.Line, error) {
        if hi.off {
                return nil, nil
        }
        if hi.parseLanguage != nil {
                hi.parseLanguage.ParseFile(hi.parseState, txt) // processes in Proc(), does Switch()
                lex := hi.parseState.Done().Src.Lexs
                return lex, nil // Done() is results of above
        } else if hi.lexer != nil {
                return hi.chromaTagsAll(txt)
        }
        return nil, nil
}

// MarkupTagsLine returns tags for one line according to current
// syntax highlighting settings
func (hi *Highlighter) MarkupTagsLine(ln int, txt []rune) (lexer.Line, error) {
        if hi.off {
                return nil, nil
        }
        if hi.parseLanguage != nil {
                ll := hi.parseLanguage.HighlightLine(hi.parseState, ln, txt)
                return ll, nil
        } else if hi.lexer != nil {
                return hi.chromaTagsLine(txt)
        }
        return nil, nil
}

// chromaTagsForLine generates the chroma tags for one line of chroma tokens
func chromaTagsForLine(tags *lexer.Line, toks []chroma.Token) {
        cp := 0
        for _, tok := range toks {
                str := []rune(strings.TrimSuffix(tok.Value, "\n"))
                slen := len(str)
                if slen == 0 {
                        continue
                }
                if tok.Type == chroma.None { // always a parsing err AFAIK
                        // fmt.Printf("type: %v  st: %v  ed: %v  txt: %v\n", tok.Type, cp, ep, str)
                        continue
                }
                ep := cp + slen
                if tok.Type < chroma.Text {
                        ht := TokenFromChroma(tok.Type)
                        tags.AddLex(token.KeyToken{Token: ht}, cp, ep)
                }
                cp = ep
        }
}

// chromaTagsAll returns all the markup tags according to current
// syntax highlighting settings
func (hi *Highlighter) chromaTagsAll(txt []byte) ([]lexer.Line, error) {
        txtstr := string(txt) // expensive!
        iterator, err := hi.lexer.Tokenise(nil, txtstr)
        if err != nil {
                slog.Error(err.Error())
                return nil, err
        }
        lines := chroma.SplitTokensIntoLines(iterator.Tokens())
        sz := len(lines)
        tags := make([]lexer.Line, sz)
        for li, lt := range lines {
                chromaTagsForLine(&tags[li], lt)
        }
        return tags, nil
}

// chromaTagsLine returns tags for one line according to current
// syntax highlighting settings
func (hi *Highlighter) chromaTagsLine(txt []rune) (lexer.Line, error) {
        return ChromaTagsLine(hi.lexer, string(txt))
}

// ChromaTagsLine returns tags for one line according to given chroma lexer
func ChromaTagsLine(clex chroma.Lexer, txt string) (lexer.Line, error) {
        n := len(txt)
        if n == 0 {
                return nil, nil
        }
        if txt[n-1] != '\n' {
                txt += "\n"
        }
        iterator, err := clex.Tokenise(nil, txt)
        if err != nil {
                slog.Error(err.Error())
                return nil, err
        }
        var tags lexer.Line
        toks := iterator.Tokens()
        chromaTagsForLine(&tags, toks)
        return tags, nil
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package highlighting

import (
        "html"

        "cogentcore.org/core/text/parse/lexer"
)

// maxLineLen prevents overflow in allocating line length
const (
        maxLineLen   = 64 * 1024
        maxNumTags   = 1024
        EscapeHTML   = true
        NoEscapeHTML = false
)

// MarkupLineHTML returns the line with html class tags added for each tag
// takes both the hi tags and extra tags.  Only fully nested tags are supported,
// with any dangling ends truncated.
func MarkupLineHTML(txt []rune, hitags, tags lexer.Line, escapeHTML bool) []byte {
        if len(txt) > maxLineLen { // avoid overflow
                return nil
        }
        sz := len(txt)
        if sz == 0 {
                return nil
        }
        var escf func([]rune) []byte
        if escapeHTML {
                escf = HTMLEscapeRunes
        } else {
                escf = func(r []rune) []byte {
                        return []byte(string(r))
                }
        }

        ttags := lexer.MergeLines(hitags, tags) // ensures that inner-tags are *after* outer tags
        nt := len(ttags)
        if nt == 0 || nt > maxNumTags {
                return escf(txt)
        }
        sps := []byte(`<span class="`)
        sps2 := []byte(`">`)
        spe := []byte(`</span>`)
        taglen := len(sps) + len(sps2) + len(spe) + 2

        musz := sz + nt*taglen
        mu := make([]byte, 0, musz)

        cp := 0
        var tstack []int // stack of tags indexes that remain to be completed, sorted soonest at end
        for i, tr := range ttags {
                if cp >= sz {
                        break
                }
                for si := len(tstack) - 1; si >= 0; si-- {
                        ts := ttags[tstack[si]]
                        if ts.End <= tr.Start {
                                ep := min(sz, ts.End)
                                if cp < ep {
                                        mu = append(mu, escf(txt[cp:ep])...)
                                        cp = ep
                                }
                                mu = append(mu, spe...)
                                tstack = append(tstack[:si], tstack[si+1:]...)
                        }
                }
                if cp >= sz || tr.Start >= sz {
                        break
                }
                if tr.Start > cp {
                        mu = append(mu, escf(txt[cp:tr.Start])...)
                }
                mu = append(mu, sps...)
                clsnm := tr.Token.Token.StyleName()
                mu = append(mu, []byte(clsnm)...)
                mu = append(mu, sps2...)
                ep := tr.End
                addEnd := true
                if i < nt-1 {
                        if ttags[i+1].Start < tr.End { // next one starts before we end, add to stack
                                addEnd = false
                                ep = ttags[i+1].Start
                                if len(tstack) == 0 {
                                        tstack = append(tstack, i)
                                } else {
                                        for si := len(tstack) - 1; si >= 0; si-- {
                                                ts := ttags[tstack[si]]
                                                if tr.End <= ts.End {
                                                        ni := si // + 1 // new index in stack -- right *before* current
                                                        tstack = append(tstack, i)
                                                        copy(tstack[ni+1:], tstack[ni:])
                                                        tstack[ni] = i
                                                }
                                        }
                                }
                        }
                }
                ep = min(len(txt), ep)
                if tr.Start < ep {
                        mu = append(mu, escf(txt[tr.Start:ep])...)
                }
                if addEnd {
                        mu = append(mu, spe...)
                }
                cp = ep
        }
        if sz > cp {
                mu = append(mu, escf(txt[cp:sz])...)
        }
        // pop any left on stack..
        for si := len(tstack) - 1; si >= 0; si-- {
                mu = append(mu, spe...)
        }
        return mu
}

// HTMLEscapeBytes escapes special characters like "<" to become "&lt;". It
// escapes only five such characters: <, >, &, ' and ".
// It operates on a *copy* of the byte string and does not modify the input!
// otherwise it causes major problems..
func HTMLEscapeBytes(b []byte) []byte {
        return []byte(html.EscapeString(string(b)))
}

// HTMLEscapeRunes escapes special characters like "<" to become "&lt;". It
// escapes only five such characters: <, >, &, ' and ".
// It operates on a *copy* of the byte string and does not modify the input!
// otherwise it causes major problems..
func HTMLEscapeRunes(r []rune) []byte {
        return []byte(html.EscapeString(string(r)))
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package highlighting

import (
        "fmt"

        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/runes"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// MarkupLineRich returns the [rich.Text] styled line for each tag.
// Takes both the hi highlighting tags and extra tags.
// The style provides the starting default style properties.
func MarkupLineRich(hs *Style, sty *rich.Style, txt []rune, hitags, tags lexer.Line) rich.Text {
        if len(txt) > maxLineLen { // avoid overflow
                return rich.NewText(sty, txt[:maxLineLen])
        }
        if hs == nil {
                return rich.NewText(sty, txt)
        }
        sz := len(txt)
        if sz == 0 {
                return nil
        }

        ttags := lexer.MergeLines(hitags, tags) // ensures that inner-tags are *after* outer tags
        // fmt.Println(ttags)
        nt := len(ttags)
        if nt == 0 || nt > maxNumTags {
                return rich.NewText(sty, txt)
        }

        // first ensure text has spans for each tag region.
        ln := len(txt)
        var tx rich.Text
        cp := 0
        for _, tr := range ttags {
                st := min(tr.Start, ln)
                if st > cp {
                        tx.AddSpan(sty, txt[cp:st])
                        cp = st
                } else if st < cp {
                        tx.SplitSpan(st)
                }
                ed := min(tr.End, ln)
                if ed > cp {
                        tx.AddSpan(sty, txt[cp:ed])
                        cp = ed
                } else {
                        tx.SplitSpan(ed)
                }
        }
        if cp < ln {
                tx.AddSpan(sty, txt[cp:])
        }

        // next, accumulate styles for each span
        for si := range tx {
                s, e := tx.Range(si)
                srng := textpos.Range{Start: s, End: e}
                cst := *sty
                for _, tr := range ttags {
                        trng := textpos.Range{Start: tr.Start, End: tr.End}
                        if srng.Intersect(trng).Len() <= 0 {
                                continue
                        }
                        entry := hs.Tag(tr.Token.Token)
                        if !entry.IsZero() {
                                entry.ToRichStyle(&cst)
                        } else {
                                if tr.Token.Token == token.TextSpellErr {
                                        cst.SetDecoration(rich.DottedUnderline)
                                        // fmt.Println(i, tr)
                                }
                        }
                }
                tx.SetSpanStyle(si, &cst)
        }
        return tx
}

// MarkupPathsAsLinks adds hyperlink span styles to given markup of given text,
// for any strings that look like file paths / urls.
// maxFields is the maximum number of fieldsto look for file paths in:
// 2 is a reasonable default, to avoid getting other false-alarm info later.
func MarkupPathsAsLinks(txt []rune, mu rich.Text, maxFields int) rich.Text {
        fl := runes.Fields(txt)
        mx := min(len(fl), maxFields)
        for i := range mx {
                ff := fl[i]
                if !runes.HasPrefix(ff, []rune("./")) && !runes.HasPrefix(ff, []rune("/")) && !runes.HasPrefix(ff, []rune("../")) {
                        // todo: use regex instead of this.
                        if !runes.Contains(ff, []rune("/")) && !runes.Contains(ff, []rune(":")) {
                                continue
                        }
                }
                fi := runes.Index(txt, ff)
                fnflds := runes.Split(ff, []rune(":"))
                fn := string(fnflds[0])
                pos := ""
                col := ""
                if len(fnflds) > 1 {
                        pos = string(fnflds[1])
                        col = ""
                        if len(fnflds) > 2 {
                                col = string(fnflds[2])
                        }
                }
                url := ""
                if col != "" {
                        url = fmt.Sprintf(`file:///%v#L%vC%v`, fn, pos, col)
                } else if pos != "" {
                        url = fmt.Sprintf(`file:///%v#L%v`, fn, pos)
                } else {
                        url = fmt.Sprintf(`file:///%v`, fn)
                }
                si := mu.SplitSpan(fi)
                efi := fi + len(ff)
                esi := mu.SplitSpan(efi)
                sty, _ := mu.Span(si)
                sty.SetLink(url)
                mu.SetSpanStyle(si, sty)
                if esi > 0 {
                        mu.InsertEndSpecial(esi)
                } else {
                        mu.EndSpecial()
                }
        }
        // if string(mu.Join()) != string(txt) {
        //         panic("markup is not the same: " + string(txt) + " mu: " + string(mu.Join()))
        // }
        return mu
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package highlighting provides syntax highlighting styles; it is based on
// github.com/alecthomas/chroma, which in turn was based on the python
// pygments package.  Note that this package depends on core and parse
// and cannot be imported there; is imported in texteditor.
package highlighting

//go:generate core generate -add-types

import (
        "encoding/json"
        "image/color"
        "log/slog"
        "os"
        "strings"

        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/cam/hct"
        "cogentcore.org/core/colors/matcolor"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/token"
)

type HighlightingName string

// Trilean value for StyleEntry value inheritance.
type Trilean int32 //enums:enum

const (
        Pass Trilean = iota
        Yes
        No
)

func (t Trilean) Prefix(s string) string {
        if t == Yes {
                return s
        } else if t == No {
                return "no" + s
        }
        return ""
}

// TODO(go1.24): use omitzero instead of omitempty in [StyleEntry]
// once we update to go1.24

// StyleEntry is one value in the map of highlight style values
type StyleEntry struct {

        // Color is the text color.
        Color color.RGBA `json:",omitempty"`

        // Background color.
        // In general it is not good to use this because it obscures highlighting.
        Background color.RGBA `json:",omitempty"`

        // Border color? not sure what this is -- not really used.
        Border color.RGBA `display:"-" json:",omitempty"`

        // Bold font.
        Bold Trilean `json:",omitempty"`

        // Italic font.
        Italic Trilean `json:",omitempty"`

        // Underline.
        Underline Trilean `json:",omitempty"`

        // DottedUnderline
        DottedUnderline Trilean `json:",omitempty"`

        // NoInherit indicates to not inherit these settings from sub-category or category levels.
        // Otherwise everything with a Pass is inherited.
        NoInherit bool `json:",omitempty"`

        // themeColor is the theme-adjusted text color.
        themeColor color.RGBA

        // themeBackground is the theme-adjusted background color.
        themeBackground color.RGBA
}

// // FromChroma copies styles from chroma
//
//        func (he *StyleEntry) FromChroma(ce chroma.StyleEntry) {
//                if ce.Colour.IsSet() {
//                        he.Color.SetString(ce.Colour.String(), nil)
//                } else {
//                        he.Color.SetToNil()
//                }
//                if ce.Background.IsSet() {
//                        he.Background.SetString(ce.Background.String(), nil)
//                } else {
//                        he.Background.SetToNil()
//                }
//                if ce.Border.IsSet() {
//                        he.Border.SetString(ce.Border.String(), nil)
//                } else {
//                        he.Border.SetToNil()
//                }
//                he.Bold = Trilean(ce.Bold)
//                he.Italic = Trilean(ce.Italic)
//                he.Underline = Trilean(ce.Underline)
//                he.NoInherit = ce.NoInherit
//        }
//
// // StyleEntryFromChroma returns a new style entry from corresponding chroma version
//
//        func StyleEntryFromChroma(ce chroma.StyleEntry) StyleEntry {
//                he := StyleEntry{}
//                he.FromChroma(ce)
//                return he
//        }

// UpdateFromTheme normalizes the colors of the style entry such that they have consistent
// chromas and tones that guarantee sufficient text contrast in accordance with the color theme.
func (se *StyleEntry) UpdateFromTheme() {
        hc := hct.FromColor(se.Color)
        ctone := float32(40)
        if matcolor.SchemeIsDark {
                ctone = 80
        }
        se.themeColor = hc.WithChroma(max(hc.Chroma, 48)).WithTone(ctone).AsRGBA()

        if !colors.IsNil(se.Background) {
                hb := hct.FromColor(se.Background)
                btone := max(hb.Tone, 94)
                if matcolor.SchemeIsDark {
                        btone = min(hb.Tone, 17)
                }
                se.themeBackground = hb.WithChroma(max(hb.Chroma, 6)).WithTone(btone).AsRGBA()
        }
}

func (se StyleEntry) String() string {
        out := []string{}
        if se.Bold != Pass {
                out = append(out, se.Bold.Prefix("bold"))
        }
        if se.Italic != Pass {
                out = append(out, se.Italic.Prefix("italic"))
        }
        if se.Underline != Pass {
                out = append(out, se.Underline.Prefix("underline"))
        }
        if se.DottedUnderline != Pass {
                out = append(out, se.Underline.Prefix("dotted-underline"))
        }
        if se.NoInherit {
                out = append(out, "noinherit")
        }
        if !colors.IsNil(se.themeColor) {
                out = append(out, colors.AsString(se.themeColor))
        }
        if !colors.IsNil(se.themeBackground) {
                out = append(out, "bg:"+colors.AsString(se.themeBackground))
        }
        if !colors.IsNil(se.Border) {
                out = append(out, "border:"+colors.AsString(se.Border))
        }
        return strings.Join(out, " ")
}

// ToCSS converts StyleEntry to CSS attributes.
func (se StyleEntry) ToCSS() string {
        styles := []string{}
        if !colors.IsNil(se.themeColor) {
                styles = append(styles, "color: "+colors.AsString(se.themeColor))
        }
        if !colors.IsNil(se.themeBackground) {
                styles = append(styles, "background-color: "+colors.AsString(se.themeBackground))
        }
        if se.Bold == Yes {
                styles = append(styles, "font-weight: bold")
        }
        if se.Italic == Yes {
                styles = append(styles, "font-style: italic")
        }
        if se.Underline == Yes {
                styles = append(styles, "text-decoration: underline")
        } else if se.DottedUnderline == Yes {
                styles = append(styles, "text-decoration: dotted-underline")
        }

        return strings.Join(styles, "; ")
}

// ToProperties converts the StyleEntry to key-value properties.
func (se StyleEntry) ToProperties() map[string]any {
        pr := map[string]any{}
        if !colors.IsNil(se.themeColor) {
                pr["color"] = se.themeColor
        }
        if !colors.IsNil(se.themeBackground) {
                pr["background-color"] = se.themeBackground
        }
        if se.Bold == Yes {
                pr["font-weight"] = rich.Bold
        }
        if se.Italic == Yes {
                pr["font-style"] = rich.Italic
        }
        if se.Underline == Yes {
                pr["text-decoration"] = 1 << uint32(rich.Underline)
        } else if se.Underline == Yes {
                pr["text-decoration"] = 1 << uint32(rich.DottedUnderline)
        }
        return pr
}

// ToRichStyle sets the StyleEntry to given [rich.Style].
func (se StyleEntry) ToRichStyle(sty *rich.Style) {
        if !colors.IsNil(se.themeColor) {
                sty.SetFillColor(se.themeColor)
        }
        if !colors.IsNil(se.themeBackground) {
                sty.SetBackground(se.themeBackground)
        }
        if se.Bold == Yes {
                sty.Weight = rich.Bold
        }
        if se.Italic == Yes {
                sty.Slant = rich.Italic
        }
        if se.Underline == Yes {
                sty.Decoration.SetFlag(true, rich.Underline)
        } else if se.DottedUnderline == Yes {
                sty.Decoration.SetFlag(true, rich.DottedUnderline)
        }
}

// Sub subtracts two style entries, returning an entry with only the differences set
func (se StyleEntry) Sub(e StyleEntry) StyleEntry {
        out := StyleEntry{}
        if e.Color != se.Color {
                out.Color = se.Color
                out.themeColor = se.themeColor
        }
        if e.Background != se.Background {
                out.Background = se.Background
                out.themeBackground = se.themeBackground
        }
        if e.Border != se.Border {
                out.Border = se.Border
        }
        if e.Bold != se.Bold {
                out.Bold = se.Bold
        }
        if e.Italic != se.Italic {
                out.Italic = se.Italic
        }
        if e.Underline != se.Underline {
                out.Underline = se.Underline
        }
        if e.DottedUnderline != se.DottedUnderline {
                out.DottedUnderline = se.DottedUnderline
        }
        return out
}

// Inherit styles from ancestors.
//
// Ancestors should be provided from oldest, furthest away to newest, closest.
func (se StyleEntry) Inherit(ancestors ...StyleEntry) StyleEntry {
        out := se
        for i := len(ancestors) - 1; i >= 0; i-- {
                if out.NoInherit {
                        return out
                }
                ancestor := ancestors[i]
                if colors.IsNil(out.themeColor) {
                        out.Color = ancestor.Color
                        out.themeColor = ancestor.themeColor
                }
                if colors.IsNil(out.themeBackground) {
                        out.Background = ancestor.Background
                        out.themeBackground = ancestor.themeBackground
                }
                if colors.IsNil(out.Border) {
                        out.Border = ancestor.Border
                }
                if out.Bold == Pass {
                        out.Bold = ancestor.Bold
                }
                if out.Italic == Pass {
                        out.Italic = ancestor.Italic
                }
                if out.Underline == Pass {
                        out.Underline = ancestor.Underline
                }
                if out.DottedUnderline == Pass {
                        out.DottedUnderline = ancestor.DottedUnderline
                }
        }
        return out
}

func (se StyleEntry) IsZero() bool {
        return colors.IsNil(se.Color) && colors.IsNil(se.Background) && colors.IsNil(se.Border) && se.Bold == Pass && se.Italic == Pass && se.Underline == Pass && se.DottedUnderline == Pass && !se.NoInherit
}

///////////////////////////////////////////////////////////////////////////////////
//  Style

// Style is a full style map of styles for different token.Tokens tag values
type Style map[token.Tokens]*StyleEntry

// CopyFrom copies a style from source style
func (hs *Style) CopyFrom(ss *Style) {
        if ss == nil {
                return
        }
        *hs = make(Style, len(*ss))
        for k, v := range *ss {
                (*hs)[k] = v
        }
}

// TagRaw returns a StyleEntry for given tag without any inheritance of anything
// will be IsZero if not defined for this style
func (hs Style) TagRaw(tag token.Tokens) StyleEntry {
        if len(hs) == 0 {
                return StyleEntry{}
        }
        if se, has := hs[tag]; has {
                return *se
        }
        return StyleEntry{}
}

// Tag returns a StyleEntry for given Tag.
// Will try sub-category or category if an exact match is not found.
// does NOT add the background properties -- those are always kept separate.
func (hs Style) Tag(tag token.Tokens) StyleEntry {
        se := hs.TagRaw(tag).Inherit(
                hs.TagRaw(token.Text),
                hs.TagRaw(tag.Cat()),
                hs.TagRaw(tag.SubCat()))
        return se
}

// ToCSS generates a CSS style sheet for this style, by token.Tokens tag
func (hs Style) ToCSS() map[token.Tokens]string {
        css := map[token.Tokens]string{}
        for ht := range token.Names {
                entry := hs.Tag(ht)
                if entry.IsZero() {
                        continue
                }
                css[ht] = entry.ToCSS()
        }
        return css
}

// ToProperties generates a list of key-value properties for this style.
func (hs Style) ToProperties() map[string]any {
        pr := map[string]any{}
        for ht, nm := range token.Names {
                entry := hs.Tag(ht)
                if entry.IsZero() {
                        if tp, ok := Properties[ht]; ok {
                                pr["."+nm] = tp
                        }
                        continue
                }
                pr["."+nm] = entry.ToProperties()
        }
        return pr
}

// Open hi style from a JSON-formatted file.
func (hs Style) OpenJSON(filename fsx.Filename) error {
        b, err := os.ReadFile(string(filename))
        if err != nil {
                // PromptDialog(nil, "File Not Found", err.Error(), true, false, nil, nil, nil)
                slog.Error(err.Error())
                return err
        }
        return json.Unmarshal(b, &hs)
}

// Save hi style to a JSON-formatted file.
func (hs Style) SaveJSON(filename fsx.Filename) error {
        b, err := json.MarshalIndent(hs, "", "  ")
        if err != nil {
                slog.Error(err.Error()) // unlikely
                return err
        }
        err = os.WriteFile(string(filename), b, 0644)
        if err != nil {
                // PromptDialog(nil, "Could not Save to File", err.Error(), true, false, nil, nil, nil)
                slog.Error(err.Error())
        }
        return err
}

// Properties are default properties for custom tags (tokens); if set in style then used
// there but otherwise we use these as a fallback; typically not overridden
var Properties = map[token.Tokens]map[string]any{
        token.TextSpellErr: {
                "text-decoration": 1 << uint32(rich.DottedUnderline), // bitflag!
        },
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package highlighting

import (
        _ "embed"
        "encoding/json"
        "fmt"
        "log/slog"
        "os"
        "path/filepath"
        "slices"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/parse"
)

// DefaultStyle is the initial default style.
var DefaultStyle = HighlightingName("emacs")

// Styles is a collection of styles
type Styles map[string]*Style

var (
        //go:embed defaults.highlighting
        defaults []byte

        // StandardStyles are the styles from chroma package
        StandardStyles Styles

        // CustomStyles are user's special styles
        CustomStyles = Styles{}

        // AvailableStyles are all highlighting styles
        AvailableStyles Styles

        // StyleDefault is the default highlighting style name
        StyleDefault = HighlightingName("emacs")

        // StyleNames are all the names of all the available highlighting styles
        StyleNames []string

        // SettingsStylesFilename is the name of the preferences file in App data
        // directory for saving / loading the custom styles
        SettingsStylesFilename = "highlighting.json"

        // StylesChanged is used for gui updating while editing
        StylesChanged = false
)

// UpdateFromTheme normalizes the colors of all style entry such that they have consistent
// chromas and tones that guarantee sufficient text contrast in accordance with the color theme.
func UpdateFromTheme() {
        for _, s := range AvailableStyles {
                for _, se := range *s {
                        se.UpdateFromTheme()
                }
        }
}

// AvailableStyle returns a style by name from the AvailStyles list -- if not found
// default is used as a fallback
func AvailableStyle(nm HighlightingName) *Style {
        if AvailableStyles == nil {
                Init()
        }
        if st, ok := AvailableStyles[string(nm)]; ok {
                return st
        }
        return AvailableStyles[string(StyleDefault)]
}

// Add adds a new style to the list
func (hs *Styles) Add() *Style {
        hse := &Style{}
        nm := fmt.Sprintf("NewStyle_%v", len(*hs))
        (*hs)[nm] = hse
        return hse
}

// CopyFrom copies styles from another collection
func (hs *Styles) CopyFrom(os Styles) {
        if *hs == nil {
                *hs = make(Styles, len(os))
        }
        for nm, cse := range os {
                (*hs)[nm] = cse
        }
}

// MergeAvailStyles updates AvailStyles as combination of std and custom styles
func MergeAvailStyles() {
        AvailableStyles = make(Styles, len(CustomStyles)+len(StandardStyles))
        AvailableStyles.CopyFrom(StandardStyles)
        AvailableStyles.CopyFrom(CustomStyles)
        StyleNames = AvailableStyles.Names()
}

// Open hi styles from a JSON-formatted file. You can save and open
// styles to / from files to share, experiment, transfer, etc.
func (hs *Styles) OpenJSON(filename fsx.Filename) error { //types:add
        b, err := os.ReadFile(string(filename))
        if err != nil {
                // PromptDialog(nil, "File Not Found", err.Error(), true, false, nil, nil, nil)
                // slog.Error(err.Error())
                return err
        }
        return json.Unmarshal(b, hs)
}

// Save hi styles to a JSON-formatted file. You can save and open
// styles to / from files to share, experiment, transfer, etc.
func (hs *Styles) SaveJSON(filename fsx.Filename) error { //types:add
        b, err := json.MarshalIndent(hs, "", "  ")
        if err != nil {
                slog.Error(err.Error()) // unlikely
                return err
        }
        err = os.WriteFile(string(filename), b, 0644)
        if err != nil {
                // PromptDialog(nil, "Could not Save to File", err.Error(), true, false, nil, nil, nil)
                slog.Error(err.Error())
        }
        return err
}

// OpenSettings opens Styles from Cogent Core standard prefs directory, using SettingsStylesFilename
func (hs *Styles) OpenSettings() error {
        pdir := system.TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, SettingsStylesFilename)
        StylesChanged = false
        return hs.OpenJSON(fsx.Filename(pnm))
}

// SaveSettings saves Styles to Cogent Core standard prefs directory, using SettingsStylesFilename
func (hs *Styles) SaveSettings() error {
        pdir := system.TheApp.CogentCoreDataDir()
        pnm := filepath.Join(pdir, SettingsStylesFilename)
        StylesChanged = false
        MergeAvailStyles()
        return hs.SaveJSON(fsx.Filename(pnm))
}

// SaveAll saves all styles individually to chosen directory
func (hs *Styles) SaveAll(dir fsx.Filename) {
        for nm, st := range *hs {
                fnm := filepath.Join(string(dir), nm+".highlighting")
                st.SaveJSON(fsx.Filename(fnm))
        }
}

// OpenDefaults opens the default highlighting styles (from chroma originally)
// These are encoded as an embed from defaults.highlighting
func (hs *Styles) OpenDefaults() error {
        err := json.Unmarshal(defaults, hs)
        if err != nil {
                return errors.Log(err)
        }
        return err
}

// Names outputs names of styles in collection
func (hs *Styles) Names() []string {
        nms := make([]string, len(*hs))
        idx := 0
        for nm := range *hs {
                nms[idx] = nm
                idx++
        }
        slices.Sort(nms)
        return nms
}

// Init must be called to initialize the hi styles -- post startup
// so chroma stuff is all in place, and loads custom styles
func Init() {
        parse.LanguageSupport.OpenStandard()
        StandardStyles.OpenDefaults()
        CustomStyles.OpenSettings()
        if len(CustomStyles) == 0 {
                cs := &Style{}
                cs.CopyFrom(StandardStyles[string(StyleDefault)])
                CustomStyles["custom-sample"] = cs
        }
        MergeAvailStyles()
        UpdateFromTheme()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package highlighting

import (
        "sync"

        "cogentcore.org/core/text/token"
        "github.com/alecthomas/chroma/v2"
)

// FromChroma converts a chroma.TokenType to a parse token.Tokens
func TokenFromChroma(ct chroma.TokenType) token.Tokens {
        chromaToTokensMu.Lock()
        defer chromaToTokensMu.Unlock()

        if chromaToTokensMap == nil {
                chromaToTokensMap = make(map[chroma.TokenType]token.Tokens, len(TokensToChromaMap))
                for k, v := range TokensToChromaMap {
                        chromaToTokensMap[v] = k
                }
        }
        tok := chromaToTokensMap[ct]
        return tok
}

// TokenToChroma converts to a chroma.TokenType
func TokenToChroma(tok token.Tokens) chroma.TokenType {
        return TokensToChromaMap[tok]
}

var (
        // chromaToTokensMap maps from chroma.TokenType to Tokens -- built from opposite map
        chromaToTokensMap map[chroma.TokenType]token.Tokens
        chromaToTokensMu  sync.Mutex
)

// TokensToChromaMap maps from Tokens to chroma.TokenType
var TokensToChromaMap = map[token.Tokens]chroma.TokenType{
        token.EOF:                 chroma.EOFType,
        token.Background:          chroma.Background,
        token.Error:               chroma.Error,
        token.None:                chroma.None,
        token.Keyword:             chroma.Keyword,
        token.KeywordConstant:     chroma.KeywordConstant,
        token.KeywordDeclaration:  chroma.KeywordDeclaration,
        token.KeywordNamespace:    chroma.KeywordNamespace,
        token.KeywordPseudo:       chroma.KeywordPseudo,
        token.KeywordReserved:     chroma.KeywordReserved,
        token.KeywordType:         chroma.KeywordType,
        token.Name:                chroma.Name,
        token.NameAttribute:       chroma.NameAttribute,
        token.NameBuiltin:         chroma.NameBuiltin,
        token.NameBuiltinPseudo:   chroma.NameBuiltinPseudo,
        token.NameClass:           chroma.NameClass,
        token.NameConstant:        chroma.NameConstant,
        token.NameDecorator:       chroma.NameDecorator,
        token.NameEntity:          chroma.NameEntity,
        token.NameException:       chroma.NameException,
        token.NameFunction:        chroma.NameFunction,
        token.NameFunctionMagic:   chroma.NameFunctionMagic,
        token.NameLabel:           chroma.NameLabel,
        token.NameNamespace:       chroma.NameNamespace,
        token.NameOperator:        chroma.NameOperator,
        token.NameOther:           chroma.NameOther,
        token.NamePseudo:          chroma.NamePseudo,
        token.NameProperty:        chroma.NameProperty,
        token.NameTag:             chroma.NameTag,
        token.NameVar:             chroma.NameVariable,
        token.NameVarAnonymous:    chroma.NameVariableAnonymous,
        token.NameVarClass:        chroma.NameVariableClass,
        token.NameVarGlobal:       chroma.NameVariableGlobal,
        token.NameVarInstance:     chroma.NameVariableInstance,
        token.NameVarMagic:        chroma.NameVariableMagic,
        token.Literal:             chroma.Literal,
        token.LiteralDate:         chroma.LiteralDate,
        token.LiteralOther:        chroma.LiteralOther,
        token.LitStr:              chroma.LiteralString,
        token.LitStrAffix:         chroma.LiteralStringAffix,
        token.LitStrAtom:          chroma.LiteralStringAtom,
        token.LitStrBacktick:      chroma.LiteralStringBacktick,
        token.LitStrBoolean:       chroma.LiteralStringBoolean,
        token.LitStrChar:          chroma.LiteralStringChar,
        token.LitStrDelimiter:     chroma.LiteralStringDelimiter,
        token.LitStrDoc:           chroma.LiteralStringDoc,
        token.LitStrDouble:        chroma.LiteralStringDouble,
        token.LitStrEscape:        chroma.LiteralStringEscape,
        token.LitStrHeredoc:       chroma.LiteralStringHeredoc,
        token.LitStrInterpol:      chroma.LiteralStringInterpol,
        token.LitStrName:          chroma.LiteralStringName,
        token.LitStrOther:         chroma.LiteralStringOther,
        token.LitStrRegex:         chroma.LiteralStringRegex,
        token.LitStrSingle:        chroma.LiteralStringSingle,
        token.LitStrSymbol:        chroma.LiteralStringSymbol,
        token.LitNum:              chroma.LiteralNumber,
        token.LitNumBin:           chroma.LiteralNumberBin,
        token.LitNumFloat:         chroma.LiteralNumberFloat,
        token.LitNumHex:           chroma.LiteralNumberHex,
        token.LitNumInteger:       chroma.LiteralNumberInteger,
        token.LitNumIntegerLong:   chroma.LiteralNumberIntegerLong,
        token.LitNumOct:           chroma.LiteralNumberOct,
        token.Operator:            chroma.Operator,
        token.OperatorWord:        chroma.OperatorWord,
        token.Punctuation:         chroma.Punctuation,
        token.Comment:             chroma.Comment,
        token.CommentHashbang:     chroma.CommentHashbang,
        token.CommentMultiline:    chroma.CommentMultiline,
        token.CommentSingle:       chroma.CommentSingle,
        token.CommentSpecial:      chroma.CommentSpecial,
        token.CommentPreproc:      chroma.CommentPreproc,
        token.CommentPreprocFile:  chroma.CommentPreprocFile,
        token.Text:                chroma.Text,
        token.TextWhitespace:      chroma.TextWhitespace,
        token.TextSymbol:          chroma.TextSymbol,
        token.TextPunctuation:     chroma.TextPunctuation,
        token.TextStyle:           chroma.Generic,
        token.TextStyleDeleted:    chroma.GenericDeleted,
        token.TextStyleEmph:       chroma.GenericEmph,
        token.TextStyleError:      chroma.GenericError,
        token.TextStyleHeading:    chroma.GenericHeading,
        token.TextStyleInserted:   chroma.GenericInserted,
        token.TextStyleOutput:     chroma.GenericOutput,
        token.TextStylePrompt:     chroma.GenericPrompt,
        token.TextStyleStrong:     chroma.GenericStrong,
        token.TextStyleSubheading: chroma.GenericSubheading,
        token.TextStyleTraceback:  chroma.GenericTraceback,
        token.TextStyleUnderline:  chroma.GenericUnderline,
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmltext

import (
        "bytes"
        "encoding/xml"
        "fmt"
        "html"
        "io"
        "strings"
        "unicode"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/stack"
        "cogentcore.org/core/styles/styleprops"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/runes"
        "golang.org/x/net/html/charset"
)

// HTMLToRich translates HTML-formatted rich text into a [rich.Text],
// using given initial text styling parameters and css properties.
// This uses the golang XML decoder system, which strips all whitespace
// and therefore does not capture any preformatted text. See HTMLPre.
// cssProps are a list of css key-value pairs that are used to set styling
// properties for the text, and can include class names with a value of
// another property map that is applied to elements of that class,
// including standard elements like a for links, etc.
func HTMLToRich(str []byte, sty *rich.Style, cssProps map[string]any) (rich.Text, error) {
        sz := len(str)
        if sz == 0 {
                return nil, nil
        }
        var errs []error

        spcstr := bytes.Join(bytes.Fields(str), []byte(" "))

        reader := bytes.NewReader(spcstr)
        decoder := xml.NewDecoder(reader)
        decoder.Strict = false
        decoder.AutoClose = xml.HTMLAutoClose
        decoder.Entity = xml.HTMLEntity
        decoder.CharsetReader = charset.NewReaderLabel

        // set when a </p> is encountered
        nextIsParaStart := false

        // stack of font styles
        fstack := make(stack.Stack[*rich.Style], 0)
        fstack.Push(sty)

        // stack of rich text spans that are later joined for final result
        spstack := make(stack.Stack[rich.Text], 0)
        curSp := rich.NewText(sty, nil)
        spstack.Push(curSp)

        for {
                t, err := decoder.Token()
                if err != nil {
                        if err == io.EOF {
                                break
                        }
                        errs = append(errs, err)
                        break
                }
                switch se := t.(type) {
                case xml.StartElement:
                        fs := fstack.Peek().Clone() // new style for new element
                        atStart := curSp.Len() == 0
                        if nextIsParaStart && atStart {
                                fs.Decoration.SetFlag(true, rich.ParagraphStart)
                        }
                        nextIsParaStart = false
                        nm := strings.ToLower(se.Name.Local)
                        insertText := []rune{}
                        special := rich.Nothing
                        linkURL := ""
                        if !fs.SetFromHTMLTag(nm) {
                                switch nm {
                                case "a":
                                        special = rich.Link
                                        fs.SetLinkStyle()
                                        for _, attr := range se.Attr {
                                                if attr.Name.Local == "href" {
                                                        linkURL = attr.Value
                                                }
                                        }
                                case "span": // todo: , "pre"
                                        // just uses properties
                                case "q":
                                        special = rich.Quote
                                case "math":
                                        special = rich.MathInline
                                case "sup":
                                        special = rich.Super
                                        fs.Size = 0.8
                                case "sub":
                                        special = rich.Sub
                                        fs.Size = 0.8
                                case "dfn":
                                        // no default styling
                                case "bdo":
                                        // todo: bidirectional override..
                                case "p":
                                        // todo: detect <p> at end of paragraph only
                                        fs.Decoration.SetFlag(true, rich.ParagraphStart)
                                case "br":
                                        // handled in end: standalone <br> is in both start and end
                                case "err":
                                        // custom; used to mark errors
                                default:
                                        err := fmt.Errorf("%q tag not recognized", nm)
                                        errs = append(errs, err)
                                }
                        }
                        if len(se.Attr) > 0 {
                                sprop := make(map[string]any, len(se.Attr))
                                for _, attr := range se.Attr {
                                        switch attr.Name.Local {
                                        case "style":
                                                styleprops.FromXMLString(attr.Value, sprop)
                                        case "class":
                                                if attr.Value == "math inline" {
                                                        special = rich.MathInline
                                                }
                                                if attr.Value == "math display" {
                                                        special = rich.MathDisplay
                                                }
                                                if cssProps != nil {
                                                        clnm := "." + attr.Value
                                                        if aggp, ok := SubProperties(clnm, cssProps); ok {
                                                                fs.FromProperties(nil, aggp, nil)
                                                        }
                                                }
                                        default:
                                                sprop[attr.Name.Local] = attr.Value
                                        }
                                }
                                fs.FromProperties(nil, sprop, nil)
                        }
                        if cssProps != nil {
                                FontStyleCSS(fs, nm, cssProps)
                        }
                        fstack.Push(fs)
                        if curSp.Len() == 0 && len(spstack) > 0 { // we started something but added nothing to it.
                                spstack.Pop()
                        }
                        if special != rich.Nothing {
                                ss := fs.Clone() // key about specials: make a new one-off style so special doesn't repeat
                                ss.Special = special
                                if special == rich.Link {
                                        ss.URL = linkURL
                                }
                                curSp = rich.NewText(ss, insertText)
                        } else {
                                curSp = rich.NewText(fs, insertText)
                        }
                        spstack.Push(curSp)
                case xml.EndElement:
                        switch se.Name.Local {
                        case "p":
                                curSp.AddRunes([]rune{'\n'})
                                nextIsParaStart = true
                        case "br":
                                curSp.AddRunes([]rune{'\n'})
                                nextIsParaStart = false
                        case "a", "q", "math", "sub", "sup": // important: any special must be ended!
                                nsp := rich.Text{}
                                nsp.EndSpecial()
                                spstack.Push(nsp)
                        case "span":
                                sty, stx := curSp.Span(0)
                                if sty.Special != rich.Nothing {
                                        if sty.IsMath() {
                                                stx = runes.TrimPrefix(stx, []rune("\\("))
                                                stx = runes.TrimSuffix(stx, []rune("\\)"))
                                                stx = runes.TrimPrefix(stx, []rune("\\["))
                                                stx = runes.TrimSuffix(stx, []rune("\\]"))
                                                // fmt.Println("math:", string(stx))
                                                curSp.SetSpanRunes(0, stx)
                                        }
                                        nsp := rich.Text{}
                                        nsp.EndSpecial()
                                        spstack.Push(nsp)
                                }
                        }

                        if len(fstack) > 0 {
                                fstack.Pop()
                                fs := fstack.Peek()
                                curSp = rich.NewText(fs, nil)
                                spstack.Push(curSp) // start a new span with previous style
                        } else {
                                err := fmt.Errorf("imbalanced start / end tags: %q", se.Name.Local)
                                errs = append(errs, err)
                        }
                case xml.CharData:
                        atStart := curSp.Len() == 0
                        sstr := html.UnescapeString(string(se))
                        if nextIsParaStart && atStart {
                                sstr = strings.TrimLeftFunc(sstr, func(r rune) bool {
                                        return unicode.IsSpace(r)
                                })
                        }
                        curSp.AddRunes([]rune(sstr))
                }
        }
        return rich.Join(spstack...), errors.Join(errs...)
}

// SubProperties returns a properties map[string]any from given key tag
// of given properties map, if the key exists and the value is a sub props map.
// Otherwise returns nil, false
func SubProperties(tag string, cssProps map[string]any) (map[string]any, bool) {
        tp, ok := cssProps[tag]
        if !ok {
                return nil, false
        }
        pmap, ok := tp.(map[string]any)
        if !ok {
                return nil, false
        }
        return pmap, true
}

// FontStyleCSS looks for "tag" name properties in cssProps properties, and applies those to
// style if found, and returns true -- false if no such tag found
func FontStyleCSS(fs *rich.Style, tag string, cssProps map[string]any) bool {
        if cssProps == nil {
                return false
        }
        pmap, ok := SubProperties(tag, cssProps)
        if !ok {
                return false
        }
        fs.FromProperties(nil, pmap, nil)
        return true
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmltext

import (
        "bytes"
        "errors"
        "fmt"
        "html"
        "strings"

        "cogentcore.org/core/base/stack"
        "cogentcore.org/core/styles/styleprops"
        "cogentcore.org/core/text/rich"
)

// HTMLPreToRich translates preformatted HTML-styled text into a [rich.Text]
// using given initial text styling parameters and css properties.
// This uses a custom decoder that preserves all whitespace characters,
// and decodes all standard inline HTML text style formatting tags in the string.
// Only basic styling tags, including <span> elements with style parameters
// (including class names) are decoded.  Whitespace is decoded as-is,
// including LF \n etc, except in WhiteSpacePreLine case which only preserves LF's.
func HTMLPreToRich(str []byte, sty *rich.Style, cssProps map[string]any) (rich.Text, error) {
        sz := len(str)
        if sz == 0 {
                return nil, nil
        }
        var errs []error

        // set when a </p> is encountered
        nextIsParaStart := false

        // stack of font styles
        fstack := make(stack.Stack[*rich.Style], 0)
        fstack.Push(sty)

        // stack of rich text spans that are later joined for final result
        spstack := make(stack.Stack[rich.Text], 0)
        curSp := rich.NewText(sty, nil)
        spstack.Push(curSp)

        tagstack := make(stack.Stack[string], 0)

        tmpbuf := make([]byte, 0, 1020)

        bidx := 0
        curTag := ""
        for bidx < sz {
                cb := str[bidx]
                ftag := ""
                if cb == '<' && sz > bidx+1 {
                        eidx := bytes.Index(str[bidx+1:], []byte(">"))
                        if eidx > 0 {
                                ftag = string(str[bidx+1 : bidx+1+eidx])
                                bidx += eidx + 2
                        } else { // get past <
                                curSp.AddRunes([]rune(string(str[bidx : bidx+1])))
                                bidx++
                        }
                }
                if ftag != "" {
                        if ftag[0] == '/' { // EndElement
                                etag := strings.ToLower(ftag[1:])
                                // fmt.Printf("%v  etag: %v\n", bidx, etag)
                                if etag == "pre" {
                                        continue // ignore
                                }
                                if etag != curTag {
                                        err := fmt.Errorf("end tag: %q doesn't match current tag: %q", etag, curTag)
                                        errs = append(errs, err)
                                }
                                switch etag {
                                case "p":
                                        curSp.AddRunes([]rune{'\n'})
                                        nextIsParaStart = true
                                case "br":
                                        curSp.AddRunes([]rune{'\n'})
                                        nextIsParaStart = false
                                case "a", "q", "math", "sub", "sup": // important: any special must be ended!
                                        curSp.EndSpecial()
                                }
                                if len(fstack) > 0 {
                                        fstack.Pop()
                                        fs := fstack.Peek()
                                        curSp = rich.NewText(fs, nil)
                                        spstack.Push(curSp) // start a new span with previous style
                                } else {
                                        err := fmt.Errorf("imbalanced start / end tags: %q", etag)
                                        errs = append(errs, err)
                                }
                                tslen := len(tagstack)
                                if tslen > 1 {
                                        tagstack.Pop()
                                        curTag = tagstack.Peek()
                                } else if tslen == 1 {
                                        tagstack.Pop()
                                        curTag = ""
                                } else {
                                        err := fmt.Errorf("imbalanced start / end tags: %q", curTag)
                                        errs = append(errs, err)
                                }
                        } else { // StartElement
                                parts := strings.Split(ftag, " ")
                                stag := strings.ToLower(strings.TrimSpace(parts[0]))
                                // fmt.Printf("%v  stag: %v\n", bidx, stag)
                                attrs := parts[1:]
                                attr := strings.Split(strings.Join(attrs, " "), "=")
                                nattr := len(attr) / 2
                                fs := fstack.Peek().Clone() // new style for new element
                                atStart := curSp.Len() == 0
                                if nextIsParaStart && atStart {
                                        fs.Decoration.SetFlag(true, rich.ParagraphStart)
                                }
                                nextIsParaStart = false
                                insertText := []rune{}
                                special := rich.Nothing
                                linkURL := ""
                                if !fs.SetFromHTMLTag(stag) {
                                        switch stag {
                                        case "a":
                                                special = rich.Link
                                                fs.SetLinkStyle()
                                                if nattr > 0 {
                                                        sprop := make(map[string]any, len(parts)-1)
                                                        for ai := 0; ai < nattr; ai++ {
                                                                nm := strings.TrimSpace(attr[ai*2])
                                                                vl := strings.TrimSuffix(strings.TrimPrefix(strings.TrimSpace(attr[ai*2+1]), `"`), `"`)
                                                                if nm == "href" {
                                                                        linkURL = vl
                                                                }
                                                                sprop[nm] = vl
                                                        }
                                                }
                                        case "span":
                                                // just uses properties
                                        case "q":
                                                special = rich.Quote
                                        case "math":
                                                special = rich.MathInline
                                        case "sup":
                                                special = rich.Super
                                                fs.Size = 0.8
                                        case "sub":
                                                special = rich.Sub
                                                fs.Size = 0.8
                                        case "dfn":
                                                // no default styling
                                        case "bdo":
                                                // todo: bidirectional override..
                                        case "pre": // nop
                                        case "p":
                                                fs.Decoration.SetFlag(true, rich.ParagraphStart)
                                        case "br":
                                                curSp = rich.NewText(fs, []rune{'\n'}) // br is standalone: do it!
                                                spstack.Push(curSp)
                                                nextIsParaStart = false
                                        default:
                                                err := fmt.Errorf("%q tag not recognized", stag)
                                                errs = append(errs, err)
                                        }
                                }
                                if nattr > 0 { // attr
                                        sprop := make(map[string]any, nattr)
                                        for ai := 0; ai < nattr; ai++ {
                                                nm := strings.TrimSpace(attr[ai*2])
                                                vl := strings.TrimSuffix(strings.TrimPrefix(strings.TrimSpace(attr[ai*2+1]), `"`), `"`)
                                                // fmt.Printf("nm: %v  val: %v\n", nm, vl)
                                                switch nm {
                                                case "style":
                                                        styleprops.FromXMLString(vl, sprop)
                                                case "class":
                                                        if vl == "math inline" {
                                                                special = rich.MathInline
                                                        }
                                                        if vl == "math display" {
                                                                special = rich.MathDisplay
                                                        }
                                                        if cssProps != nil {
                                                                clnm := "." + vl
                                                                if aggp, ok := SubProperties(clnm, cssProps); ok {
                                                                        fs.FromProperties(nil, aggp, nil)
                                                                }
                                                        }
                                                default:
                                                        sprop[nm] = vl
                                                }
                                        }
                                        fs.FromProperties(nil, sprop, nil)
                                }
                                if cssProps != nil {
                                        FontStyleCSS(fs, stag, cssProps)
                                }
                                fstack.Push(fs)
                                curTag = stag
                                tagstack.Push(curTag)
                                if curSp.Len() == 0 && len(spstack) > 0 { // we started something but added nothing to it.
                                        spstack.Pop()
                                }
                                if special != rich.Nothing {
                                        ss := fs.Clone() // key about specials: make a new one-off style so special doesn't repeat
                                        ss.Special = special
                                        if special == rich.Link {
                                                ss.URL = linkURL
                                        }
                                        curSp = rich.NewText(ss, insertText)
                                } else {
                                        curSp = rich.NewText(fs, insertText)
                                }
                                spstack.Push(curSp)
                        }
                } else { // raw chars
                        // todo: deal with WhiteSpacePreLine -- trim out non-LF ws
                        tmpbuf := tmpbuf[0:0]
                        didNl := false
                aggloop:
                        for ; bidx < sz; bidx++ {
                                nb := str[bidx] // re-gets cb so it can be processed here..
                                switch nb {
                                case '<':
                                        if (bidx > 0 && str[bidx-1] == '<') || sz == bidx+1 {
                                                tmpbuf = append(tmpbuf, nb)
                                                didNl = false
                                        } else {
                                                didNl = false
                                                break aggloop
                                        }
                                case '\n': // todo absorb other line endings
                                        unestr := html.UnescapeString(string(tmpbuf))
                                        curSp.AddRunes([]rune(unestr + "\n"))
                                        curSp = rich.NewText(fstack.Peek(), nil)
                                        spstack.Push(curSp) // start a new span with previous style
                                        tmpbuf = tmpbuf[0:0]
                                        didNl = true
                                default:
                                        didNl = false
                                        tmpbuf = append(tmpbuf, nb)
                                }
                        }
                        if !didNl {
                                unestr := html.UnescapeString(string(tmpbuf))
                                // fmt.Printf("%v added: %v\n", bidx, unestr)
                                curSp.AddRunes([]rune(unestr))
                        }
                }
        }
        return rich.Join(spstack...), errors.Join(errs...)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package htmltext

import (
        "strings"

        "cogentcore.org/core/text/rich"
)

// RichToHTML returns an HTML encoded representation of the rich.Text.
func RichToHTML(tx rich.Text) string {
        var b strings.Builder
        ns := tx.NumSpans()
        var lsty *rich.Style
        for si := range ns {
                sty, rs := tx.Span(si)
                var stags, etags string
                if sty.Weight != rich.Normal && (lsty == nil || lsty.Weight != sty.Weight) {
                        stags += "<" + sty.Weight.HTMLTag() + ">"
                } else if sty.Weight == rich.Normal && (lsty != nil && lsty.Weight != sty.Weight) {
                        etags += "</" + lsty.Weight.HTMLTag() + ">"
                }
                if sty.Slant != rich.SlantNormal && (lsty == nil || lsty.Slant != sty.Slant) {
                        stags += "<i>"
                } else if sty.Slant == rich.SlantNormal && lsty != nil && lsty.Slant != sty.Slant {
                        etags += "</i>"
                }
                if sty.Decoration.HasFlag(rich.Underline) && (lsty == nil || !lsty.Decoration.HasFlag(rich.Underline)) {
                        stags += "<u>"
                } else if !sty.Decoration.HasFlag(rich.Underline) && lsty != nil && lsty.Decoration.HasFlag(rich.Underline) {
                        etags += "</u>"
                }
                b.WriteString(etags)
                b.WriteString(stags)
                b.WriteString(string(rs))
                lsty = sty
        }
        return b.String()
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "image"
        "regexp"
        "slices"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/text/highlighting"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/search"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// this file contains the exported API for Lines

// NewLines returns a new empty Lines, with no views.
func NewLines() *Lines {
        ls := &Lines{}
        ls.Defaults()
        ls.setText([]byte(""))
        return ls
}

// NewLinesFromBytes returns a new Lines representation of given bytes of text,
// using given filename to determine the type of content that is represented
// in the bytes, based on the filename extension, and given initial display width.
// A width-specific view is created, with the unique view id returned: this id
// must be used for all subsequent view-specific calls.
// This uses all default styling settings.
func NewLinesFromBytes(filename string, width int, src []byte) (*Lines, int) {
        ls := &Lines{}
        ls.Defaults()
        fi, _ := fileinfo.NewFileInfo(filename)
        ls.setFileInfo(fi)
        _, vid := ls.newView(width)
        ls.setText(src)
        return ls, vid
}

func (ls *Lines) Defaults() {
        ls.Settings.Defaults()
        ls.fontStyle = rich.NewStyle().SetFamily(rich.Monospace)
        ls.links = make(map[int][]rich.Hyperlink)
}

// NewView makes a new view with given initial width,
// with a layout of the existing text at this width.
// The return value is a unique int handle that must be
// used for all subsequent calls that depend on the view.
func (ls *Lines) NewView(width int) int {
        ls.Lock()
        defer ls.Unlock()
        _, vid := ls.newView(width)
        return vid
}

// DeleteView deletes view for given unique view id.
// It is important to delete unused views to maintain efficient updating of
// existing views.
func (ls *Lines) DeleteView(vid int) {
        ls.Lock()
        defer ls.Unlock()
        ls.deleteView(vid)
}

// SetWidth sets the width for line wrapping, for given view id.
// If the width is different than current, the layout is updated,
// and a true is returned, else false.
func (ls *Lines) SetWidth(vid int, wd int) bool {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        if vw != nil {
                if vw.width == wd {
                        return false
                }
                vw.width = wd
                ls.layoutViewLines(vw)
                // fmt.Println("set width:", vw.width, "lines:", vw.viewLines, "mu:", len(vw.markup), len(vw.vlineStarts))
                return true
        }
        return false
}

// Width returns the width for line wrapping for given view id.
func (ls *Lines) Width(vid int) int {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        if vw != nil {
                return vw.width
        }
        return 0
}

// ViewLines returns the total number of line-wrapped view lines, for given view id.
func (ls *Lines) ViewLines(vid int) int {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        if vw != nil {
                return vw.viewLines
        }
        return 0
}

// SetFontStyle sets the font style to use in styling and rendering text.
// The Family of the font MUST be set to Monospace.
func (ls *Lines) SetFontStyle(fs *rich.Style) *Lines {
        ls.Lock()
        defer ls.Unlock()
        if fs.Family != rich.Monospace {
                errors.Log(errors.New("lines.Lines font style MUST be Monospace. Setting that but should fix upstream"))
                fs.Family = rich.Monospace
        }
        ls.fontStyle = fs
        return ls
}

// FontStyle returns the font style used for this lines.
func (ls *Lines) FontStyle() *rich.Style {
        ls.Lock()
        defer ls.Unlock()
        return ls.fontStyle
}

// SetText sets the text to the given bytes, and does
// full markup update and sends a Change event.
// Pass nil to initialize an empty lines.
func (ls *Lines) SetText(text []byte) *Lines {
        ls.Lock()
        ls.setText(text)
        ls.Unlock()
        ls.sendChange()
        return ls
}

// SetString sets the text to the given string.
func (ls *Lines) SetString(txt string) *Lines {
        return ls.SetText([]byte(txt))
}

// SetTextLines sets the source lines from given lines of bytes.
func (ls *Lines) SetTextLines(lns [][]byte) {
        ls.Lock()
        ls.setLineBytes(lns)
        ls.Unlock()
        ls.sendChange()
}

// Text returns the current text lines as a slice of bytes,
// with an additional line feed at the end, per POSIX standards.
// It does NOT call EditDone or send a Change event: that should
// happen prior or separately from this call.
func (ls *Lines) Text() []byte {
        ls.Lock()
        defer ls.Unlock()
        return ls.bytes(0)
}

// String returns the current text as a string.
// It does NOT call EditDone or send a Change event: that should
// happen prior or separately from this call.
func (ls *Lines) String() string {
        return string(ls.Text())
}

// SetHighlighting sets the highlighting style.
func (ls *Lines) SetHighlighting(style highlighting.HighlightingName) {
        ls.Lock()
        defer ls.Unlock()
        ls.Highlighter.SetStyle(style)
}

// Close should be called when done using the Lines.
// It first sends Close events to all views.
// An Editor widget will likely want to check IsNotSaved()
// and prompt the user to save or cancel first.
func (ls *Lines) Close() {
        ls.sendClose()
        ls.Lock()
        ls.stopDelayedReMarkup()
        ls.views = make(map[int]*view)
        ls.lines = nil
        ls.tags = nil
        ls.hiTags = nil
        ls.markup = nil
        // ls.parseState.Reset() // todo
        ls.undos.Reset()
        ls.markupEdits = nil
        ls.posHistory = nil
        ls.filename = ""
        ls.notSaved = false
        ls.Unlock()
}

// IsChanged reports whether any edits have been applied to text
func (ls *Lines) IsChanged() bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.changed
}

// SetChanged sets the changed flag to given value (e.g., when file saved)
func (ls *Lines) SetChanged(changed bool) {
        ls.Lock()
        defer ls.Unlock()
        ls.changed = changed
}

// SendChange sends an [event.Change] to the views of this lines,
// causing them to update.
func (ls *Lines) SendChange() {
        ls.Lock()
        defer ls.Unlock()
        ls.sendChange()
}

// SendInput sends an [event.Input] to the views of this lines,
// causing them to update.
func (ls *Lines) SendInput() {
        ls.Lock()
        defer ls.Unlock()
        ls.sendInput()
}

// NumLines returns the number of lines.
func (ls *Lines) NumLines() int {
        ls.Lock()
        defer ls.Unlock()
        return ls.numLines()
}

// IsValidLine returns true if given line number is in range.
func (ls *Lines) IsValidLine(ln int) bool {
        if ln < 0 {
                return false
        }
        ls.Lock()
        defer ls.Unlock()
        return ls.isValidLine(ln)
}

// ValidPos returns a position based on given pos that is valid.
func (ls *Lines) ValidPos(pos textpos.Pos) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()

        n := ls.numLines()
        if n == 0 {
                return textpos.Pos{}
        }
        if pos.Line < 0 {
                pos.Line = 0
        }
        if pos.Line >= n {
                pos.Line = n - 1
        }
        llen := len(ls.lines[pos.Line])
        if pos.Char < 0 {
                pos.Char = 0
        }
        if pos.Char > llen {
                pos.Char = llen // end of line is valid
        }
        return pos
}

// Line returns a (copy of) specific line of runes.
func (ls *Lines) Line(ln int) []rune {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidLine(ln) {
                return nil
        }
        return slices.Clone(ls.lines[ln])
}

// strings returns the current text as []string array.
// If addNewLine is true, each string line has a \n appended at end.
func (ls *Lines) Strings(addNewLine bool) []string {
        ls.Lock()
        defer ls.Unlock()
        return ls.strings(addNewLine)
}

// LineLen returns the length of the given source line, in runes.
func (ls *Lines) LineLen(ln int) int {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidLine(ln) {
                return 0
        }
        return len(ls.lines[ln])
}

// LineChar returns rune at given line and character position.
// returns a 0 if character position is not valid
func (ls *Lines) LineChar(ln, ch int) rune {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidLine(ln) {
                return 0
        }
        if len(ls.lines[ln]) <= ch {
                return 0
        }
        return ls.lines[ln][ch]
}

// HiTags returns the highlighting tags for given line, nil if invalid
func (ls *Lines) HiTags(ln int) lexer.Line {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidLine(ln) {
                return nil
        }
        return ls.hiTags[ln]
}

// LineLexDepth returns the starting lexical depth in terms of brackets, parens, etc
func (ls *Lines) LineLexDepth(ln int) int {
        ls.Lock()
        defer ls.Unlock()
        n := len(ls.hiTags)
        if ln >= n || len(ls.hiTags[ln]) == 0 {
                return 0
        }
        return ls.hiTags[ln][0].Token.Depth
}

// EndPos returns the ending position at end of lines.
func (ls *Lines) EndPos() textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        return ls.endPos()
}

// IsValidPos returns an true if the position is valid.
func (ls *Lines) IsValidPos(pos textpos.Pos) bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.isValidPos(pos)
}

// PosToView returns the view position in terms of ViewLines and Char
// offset into that view line for given source line, char position.
func (ls *Lines) PosToView(vid int, pos textpos.Pos) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.posToView(vw, pos)
}

// PosFromView returns the original source position from given
// view position in terms of ViewLines and Char offset into that view line.
// If the Char position is beyond the end of the line, it returns the
// end of the given line.
func (ls *Lines) PosFromView(vid int, pos textpos.Pos) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.posFromView(vw, pos)
}

// ViewLineLen returns the length in chars (runes) of the given view line.
func (ls *Lines) ViewLineLen(vid int, vln int) int {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.viewLineLen(vw, vln)
}

// ViewLineRegion returns the region in view coordinates of the given view line.
func (ls *Lines) ViewLineRegion(vid int, vln int) textpos.Region {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.viewLineRegion(vw, vln)
}

// ViewLineRegionLocked returns the region in view coordinates of the given view line,
// for case where Lines is already locked.
func (ls *Lines) ViewLineRegionLocked(vid int, vln int) textpos.Region {
        vw := ls.view(vid)
        return ls.viewLineRegion(vw, vln)
}

// RegionToView converts the given region in source coordinates into view coordinates.
func (ls *Lines) RegionToView(vid int, reg textpos.Region) textpos.Region {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.regionToView(vw, reg)
}

// RegionFromView converts the given region in view coordinates into source coordinates.
func (ls *Lines) RegionFromView(vid int, reg textpos.Region) textpos.Region {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.regionFromView(vw, reg)
}

// Region returns a Edit representation of text between start and end positions.
// returns nil if not a valid region.  sets the timestamp on the Edit to now.
func (ls *Lines) Region(st, ed textpos.Pos) *textpos.Edit {
        ls.Lock()
        defer ls.Unlock()
        return ls.region(st, ed)
}

// RegionRect returns a Edit representation of text between
// start and end positions as a rectangle,
// returns nil if not a valid region.  sets the timestamp on the Edit to now.
func (ls *Lines) RegionRect(st, ed textpos.Pos) *textpos.Edit {
        ls.Lock()
        defer ls.Unlock()
        return ls.regionRect(st, ed)
}

// AdjustRegion adjusts given text region for any edits that
// have taken place since time stamp on region (using the Undo stack).
// If region was wholly within a deleted region, then RegionNil will be
// returned, otherwise it is clipped appropriately as function of deletes.
func (ls *Lines) AdjustRegion(reg textpos.Region) textpos.Region {
        ls.Lock()
        defer ls.Unlock()
        return ls.undos.AdjustRegion(reg)
}

////////   Edits

// DeleteText is the primary method for deleting text from the lines.
// It deletes region of text between start and end positions.
// Sets the timestamp on resulting Edit to now.
// An Undo record is automatically saved depending on Undo.Off setting.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) DeleteText(st, ed textpos.Pos) *textpos.Edit {
        ls.Lock()
        ls.fileModCheck()
        tbe := ls.deleteText(st, ed)
        if tbe != nil && ls.Autosave {
                go ls.autoSave()
        }
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// DeleteTextRect deletes rectangular region of text between start, end
// defining the upper-left and lower-right corners of a rectangle.
// Fails if st.Char >= ed.Char. Sets the timestamp on resulting Edit to now.
// An Undo record is automatically saved depending on Undo.Off setting.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) DeleteTextRect(st, ed textpos.Pos) *textpos.Edit {
        ls.Lock()
        ls.fileModCheck()
        tbe := ls.deleteTextRect(st, ed)
        if tbe != nil && ls.Autosave {
                go ls.autoSave()
        }
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// InsertTextBytes is the primary method for inserting text,
// at given starting position. Sets the timestamp on resulting Edit to now.
// An Undo record is automatically saved depending on Undo.Off setting.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) InsertTextBytes(st textpos.Pos, text []byte) *textpos.Edit {
        ls.Lock()
        ls.fileModCheck()
        tbe := ls.insertText(st, []rune(string(text)))
        if tbe != nil && ls.Autosave {
                go ls.autoSave()
        }
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// InsertText is the primary method for inserting text,
// at given starting position. Sets the timestamp on resulting Edit to now.
// An Undo record is automatically saved depending on Undo.Off setting.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) InsertText(st textpos.Pos, text []rune) *textpos.Edit {
        ls.Lock()
        ls.fileModCheck()
        tbe := ls.insertText(st, text)
        if tbe != nil && ls.Autosave {
                go ls.autoSave()
        }
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// InsertTextLines is the primary method for inserting text,
// at given starting position. Sets the timestamp on resulting Edit to now.
// An Undo record is automatically saved depending on Undo.Off setting.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) InsertTextLines(st textpos.Pos, text [][]rune) *textpos.Edit {
        ls.Lock()
        ls.fileModCheck()
        tbe := ls.insertTextLines(st, text)
        if tbe != nil && ls.Autosave {
                go ls.autoSave()
        }
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// InsertTextRect inserts a rectangle of text defined in given Edit record,
// (e.g., from RegionRect or DeleteRect).
// Returns a copy of the Edit record with an updated timestamp.
// An Undo record is automatically saved depending on Undo.Off setting.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) InsertTextRect(tbe *textpos.Edit) *textpos.Edit {
        ls.Lock()
        ls.fileModCheck()
        tbe = ls.insertTextRect(tbe)
        if tbe != nil && ls.Autosave {
                go ls.autoSave()
        }
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// ReplaceText does DeleteText for given region, and then InsertText at given position
// (typically same as delSt but not necessarily).
// if matchCase is true, then the lexer.MatchCase function is called to match the
// case (upper / lower) of the new inserted text to that of the text being replaced.
// returns the Edit for the inserted text.
// An Undo record is automatically saved depending on Undo.Off setting.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) ReplaceText(delSt, delEd, insPos textpos.Pos, insTxt string, matchCase bool) *textpos.Edit {
        ls.Lock()
        ls.fileModCheck()
        tbe := ls.replaceText(delSt, delEd, insPos, insTxt, matchCase)
        if tbe != nil && ls.Autosave {
                go ls.autoSave()
        }
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// AppendTextMarkup appends new text to end of lines, using insert, returns
// edit, and uses supplied markup to render it, for preformatted output.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) AppendTextMarkup(text [][]rune, markup []rich.Text) *textpos.Edit {
        ls.Lock()
        ls.fileModCheck()
        tbe := ls.appendTextMarkup(text, markup)
        if tbe != nil && ls.Autosave {
                go ls.autoSave()
        }
        ls.collectLinks()
        ls.layoutViews()
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// ReMarkup starts a background task of redoing the markup
func (ls *Lines) ReMarkup() {
        ls.Lock()
        defer ls.Unlock()
        ls.reMarkup()
}

// SetUndoOn turns on or off the recording of undo records for every edit.
func (ls *Lines) SetUndoOn(on bool) {
        ls.Lock()
        defer ls.Unlock()
        ls.undos.Off = !on
}

// NewUndoGroup increments the undo group counter for batchiung
// the subsequent actions.
func (ls *Lines) NewUndoGroup() {
        ls.Lock()
        defer ls.Unlock()
        ls.undos.NewGroup()
}

// UndoReset resets all current undo records.
func (ls *Lines) UndoReset() {
        ls.Lock()
        defer ls.Unlock()
        ls.undos.Reset()
}

// Undo undoes next group of items on the undo stack,
// and returns all the edits performed.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) Undo() []*textpos.Edit {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        tbe := ls.undo()
        if tbe == nil || ls.undos.Pos == 0 { // no more undo = fully undone
                ls.clearNotSaved()
                ls.autosaveDelete()
        }
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// Redo redoes next group of items on the undo stack,
// and returns all the edits performed.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) Redo() []*textpos.Edit {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        tbe := ls.redo()
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// EmacsUndoSave is called by an editor at end of latest set of undo commands.
// If EmacsUndo mode is active, saves the current UndoStack to the regular Undo stack
// at the end, and moves undo to the very end; undo is a constant stream.
func (ls *Lines) EmacsUndoSave() {
        ls.Lock()
        defer ls.Unlock()
        if !ls.Settings.EmacsUndo {
                return
        }
        ls.undos.UndoStackSave()
}

/////////   Moving

// MoveForward moves given source position forward given number of rune steps.
func (ls *Lines) MoveForward(pos textpos.Pos, steps int) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        return ls.moveForward(pos, steps)
}

// MoveBackward moves given source position backward given number of rune steps.
func (ls *Lines) MoveBackward(pos textpos.Pos, steps int) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        return ls.moveBackward(pos, steps)
}

// MoveForwardWord moves given source position forward given number of word steps.
func (ls *Lines) MoveForwardWord(pos textpos.Pos, steps int) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        return ls.moveForwardWord(pos, steps)
}

// MoveBackwardWord moves given source position backward given number of word steps.
func (ls *Lines) MoveBackwardWord(pos textpos.Pos, steps int) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        return ls.moveBackwardWord(pos, steps)
}

// MoveDown moves given source position down given number of display line steps,
// always attempting to use the given column position if the line is long enough.
func (ls *Lines) MoveDown(vid int, pos textpos.Pos, steps, col int) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.moveDown(vw, pos, steps, col)
}

// MoveUp moves given source position up given number of display line steps,
// always attempting to use the given column position if the line is long enough.
func (ls *Lines) MoveUp(vid int, pos textpos.Pos, steps, col int) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.moveUp(vw, pos, steps, col)
}

// MoveLineStart moves given source position to start of view line.
func (ls *Lines) MoveLineStart(vid int, pos textpos.Pos) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.moveLineStart(vw, pos)
}

// MoveLineEnd moves given source position to end of view line.
func (ls *Lines) MoveLineEnd(vid int, pos textpos.Pos) textpos.Pos {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.moveLineEnd(vw, pos)
}

// TransposeChar swaps the character at the cursor with the one before it.
func (ls *Lines) TransposeChar(vid int, pos textpos.Pos) bool {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        return ls.transposeChar(vw, pos)
}

////////  Words

// IsWordEnd returns true if the cursor is just past the last letter of a word.
func (ls *Lines) IsWordEnd(pos textpos.Pos) bool {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidPos(pos) {
                return false
        }
        txt := ls.lines[pos.Line]
        sz := len(txt)
        if sz == 0 {
                return false
        }
        if pos.Char >= len(txt) { // end of line
                r := txt[len(txt)-1]
                return textpos.IsWordBreak(r, -1)
        }
        if pos.Char == 0 { // start of line
                r := txt[0]
                return !textpos.IsWordBreak(r, -1)
        }
        r1 := txt[pos.Char-1]
        r2 := txt[pos.Char]
        return !textpos.IsWordBreak(r1, rune(-1)) && textpos.IsWordBreak(r2, rune(-1))
}

// IsWordMiddle returns true if the cursor is anywhere inside a word,
// i.e. the character before the cursor and the one after the cursor
// are not classified as word break characters
func (ls *Lines) IsWordMiddle(pos textpos.Pos) bool {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidPos(pos) {
                return false
        }
        txt := ls.lines[pos.Line]
        sz := len(txt)
        if sz < 2 {
                return false
        }
        if pos.Char >= len(txt) { // end of line
                return false
        }
        if pos.Char == 0 { // start of line
                return false
        }
        r1 := txt[pos.Char-1]
        r2 := txt[pos.Char]
        return !textpos.IsWordBreak(r1, rune(-1)) && !textpos.IsWordBreak(r2, rune(-1))
}

// WordAt returns a Region for a word starting at given position.
// If the current position is a word break then go to next
// break after the first non-break.
func (ls *Lines) WordAt(pos textpos.Pos) textpos.Region {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidPos(pos) {
                return textpos.Region{}
        }
        txt := ls.lines[pos.Line]
        rng := textpos.WordAt(txt, pos.Char)
        st := pos
        st.Char = rng.Start
        ed := pos
        ed.Char = rng.End
        return textpos.NewRegionPos(st, ed)
}

// WordBefore returns the word before the given source position.
// uses IsWordBreak to determine the bounds of the word
func (ls *Lines) WordBefore(pos textpos.Pos) *textpos.Edit {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidPos(pos) {
                return &textpos.Edit{}
        }
        txt := ls.lines[pos.Line]
        ch := pos.Char
        ch = min(ch, len(txt))
        st := ch
        for i := ch - 1; i >= 0; i-- {
                if i == 0 { // start of line
                        st = 0
                        break
                }
                r1 := txt[i]
                r2 := txt[i-1]
                if textpos.IsWordBreak(r1, r2) {
                        st = i + 1
                        break
                }
        }
        if st != ch {
                return ls.region(textpos.Pos{Line: pos.Line, Char: st}, pos)
        }
        return nil
}

////////  PosHistory

// PosHistorySave saves the cursor position in history stack of cursor positions.
// Tracks across views. Returns false if position was on same line as last one saved.
func (ls *Lines) PosHistorySave(pos textpos.Pos) bool {
        ls.Lock()
        defer ls.Unlock()
        if ls.posHistory == nil {
                ls.posHistory = make([]textpos.Pos, 0, 1000)
        }
        sz := len(ls.posHistory)
        if sz > 0 {
                if ls.posHistory[sz-1].Line == pos.Line {
                        return false
                }
        }
        ls.posHistory = append(ls.posHistory, pos)
        // fmt.Printf("saved pos hist: %v\n", pos)
        return true
}

// PosHistoryLen returns the length of the position history stack.
func (ls *Lines) PosHistoryLen() int {
        ls.Lock()
        defer ls.Unlock()
        return len(ls.posHistory)
}

// PosHistoryAt returns the position history at given index.
// returns false if not a valid index.
func (ls *Lines) PosHistoryAt(idx int) (textpos.Pos, bool) {
        ls.Lock()
        defer ls.Unlock()
        if idx < 0 || idx >= len(ls.posHistory) {
                return textpos.Pos{}, false
        }
        return ls.posHistory[idx], true
}

/////////   Edit helpers

// InComment returns true if the given text position is within
// a commented region.
func (ls *Lines) InComment(pos textpos.Pos) bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.inComment(pos)
}

// HiTagAtPos returns the highlighting (markup) lexical tag at given position
// using current Markup tags, and index, -- could be nil if none or out of range.
func (ls *Lines) HiTagAtPos(pos textpos.Pos) (*lexer.Lex, int) {
        ls.Lock()
        defer ls.Unlock()
        return ls.hiTagAtPos(pos)
}

// InTokenSubCat returns true if the given text position is marked with lexical
// type in given SubCat sub-category.
func (ls *Lines) InTokenSubCat(pos textpos.Pos, subCat token.Tokens) bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.inTokenSubCat(pos, subCat)
}

// InLitString returns true if position is in a string literal.
func (ls *Lines) InLitString(pos textpos.Pos) bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.inLitString(pos)
}

// InTokenCode returns true if position is in a Keyword,
// Name, Operator, or Punctuation.
// This is useful for turning off spell checking in docs
func (ls *Lines) InTokenCode(pos textpos.Pos) bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.inTokenCode(pos)
}

// LexObjPathString returns the string at given lex, and including prior
// lex-tagged regions that include sequences of PunctSepPeriod and NameTag
// which are used for object paths -- used for e.g., debugger to pull out
// variable expressions that can be evaluated.
func (ls *Lines) LexObjPathString(ln int, lx *lexer.Lex) string {
        ls.Lock()
        defer ls.Unlock()
        return ls.lexObjPathString(ln, lx)
}

////////   Tags

// AddTag adds a new custom tag for given line, at given position.
func (ls *Lines) AddTag(ln, st, ed int, tag token.Tokens) {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidLine(ln) {
                return
        }

        tr := lexer.NewLex(token.KeyToken{Token: tag}, st, ed)
        tr.Time.Now()
        if len(ls.tags[ln]) == 0 {
                ls.tags[ln] = append(ls.tags[ln], tr)
        } else {
                ls.tags[ln] = ls.adjustedTags(ln) // must re-adjust before adding new ones!
                ls.tags[ln].AddSort(tr)
        }
        ls.markupLines(ln, ln)
}

// AddTagEdit adds a new custom tag for given line, using Edit for location.
func (ls *Lines) AddTagEdit(tbe *textpos.Edit, tag token.Tokens) {
        ls.AddTag(tbe.Region.Start.Line, tbe.Region.Start.Char, tbe.Region.End.Char, tag)
}

// RemoveTag removes tag (optionally only given tag if non-zero)
// at given position if it exists. returns tag.
func (ls *Lines) RemoveTag(pos textpos.Pos, tag token.Tokens) (reg lexer.Lex, ok bool) {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidLine(pos.Line) {
                return
        }

        ls.tags[pos.Line] = ls.adjustedTags(pos.Line) // re-adjust for current info
        for i, t := range ls.tags[pos.Line] {
                if t.ContainsPos(pos.Char) {
                        if tag > 0 && t.Token.Token != tag {
                                continue
                        }
                        ls.tags[pos.Line].DeleteIndex(i)
                        reg = t
                        ok = true
                        break
                }
        }
        if ok {
                ls.markupLines(pos.Line, pos.Line)
        }
        return
}

// SetTags tags for given line.
func (ls *Lines) SetTags(ln int, tags lexer.Line) {
        ls.Lock()
        defer ls.Unlock()
        if !ls.isValidLine(ln) {
                return
        }
        ls.tags[ln] = tags
}

// AdjustedTags updates tag positions for edits, for given line
// and returns the new tags
func (ls *Lines) AdjustedTags(ln int) lexer.Line {
        ls.Lock()
        defer ls.Unlock()
        return ls.adjustedTags(ln)
}

// AdjustedTagsLine updates tag positions for edits, for given list of tags,
// associated with given line of text.
func (ls *Lines) AdjustedTagsLine(tags lexer.Line, ln int) lexer.Line {
        ls.Lock()
        defer ls.Unlock()
        return ls.adjustedTagsLine(tags, ln)
}

// MarkupLines generates markup of given range of lines.
// end is *inclusive* line.  Called after edits, under Lock().
// returns true if all lines were marked up successfully.
func (ls *Lines) MarkupLines(st, ed int) bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.markupLines(st, ed)
}

// StartDelayedReMarkup starts a timer for doing markup after an interval.
func (ls *Lines) StartDelayedReMarkup() {
        ls.Lock()
        defer ls.Unlock()
        ls.startDelayedReMarkup()
}

// StopDelayedReMarkup stops the timer for doing markup after an interval.
func (ls *Lines) StopDelayedReMarkup() {
        ls.Lock()
        defer ls.Unlock()
        ls.stopDelayedReMarkup()
}

//////// Misc edit functions

// IndentLine indents line by given number of tab stops, using tabs or spaces,
// for given tab size (if using spaces). Either inserts or deletes to reach target.
// Returns edit record for any change.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) IndentLine(ln, ind int) *textpos.Edit {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        tbe := ls.indentLine(ln, ind)
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
        return tbe
}

// AutoIndent indents given line to the level of the prior line, adjusted
// appropriately if the current line starts with one of the given un-indent
// strings, or the prior line ends with one of the given indent strings.
// Returns any edit that took place (could be nil), along with the auto-indented
// level and character position for the indent of the current line.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) AutoIndent(ln int) (tbe *textpos.Edit, indLev, chPos int) {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        tbe, indLev, chPos = ls.autoIndent(ln)
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
        return
}

// AutoIndentRegion does auto-indent over given region; end is *exclusive*.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) AutoIndentRegion(start, end int) {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        ls.autoIndentRegion(start, end)
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
}

// CommentRegion inserts comment marker on given lines; end is *exclusive*.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) CommentRegion(start, end int) {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        ls.commentRegion(start, end)
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
}

// JoinParaLines merges sequences of lines with hard returns forming paragraphs,
// separated by blank lines, into a single line per paragraph,
// within the given line regions; endLine is *inclusive*.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) JoinParaLines(startLine, endLine int) {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        ls.joinParaLines(startLine, endLine)
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
}

// TabsToSpaces replaces tabs with spaces over given region; end is *exclusive*.
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) TabsToSpaces(start, end int) {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        ls.tabsToSpaces(start, end)
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
}

// SpacesToTabs replaces tabs with spaces over given region; end is *exclusive*
// Calls sendInput to send an Input event to views, so they update.
func (ls *Lines) SpacesToTabs(start, end int) {
        ls.Lock()
        autoSave := ls.batchUpdateStart()
        ls.spacesToTabs(start, end)
        ls.batchUpdateEnd(autoSave)
        ls.Unlock()
        ls.sendInput()
}

// CountWordsLinesRegion returns the count of words and lines in given region.
func (ls *Lines) CountWordsLinesRegion(reg textpos.Region) (words, lines int) {
        ls.Lock()
        defer ls.Unlock()
        words, lines = CountWordsLinesRegion(ls.lines, reg)
        return
}

// Diffs computes the diff between this lines and the other lines,
// reporting a sequence of operations that would convert this lines (a) into
// the other lines (b).  Each operation is either an 'r' (replace), 'd'
// (delete), 'i' (insert) or 'e' (equal).  Everything is line-based (0, offset).
func (ls *Lines) Diffs(ob *Lines) Diffs {
        ls.Lock()
        defer ls.Unlock()
        return ls.diffs(ob)
}

// PatchFrom patches (edits) using content from other,
// according to diff operations (e.g., as generated from Diffs).
func (ls *Lines) PatchFrom(ob *Lines, diffs Diffs) bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.patchFrom(ob, diffs)
}

// DiffsUnified computes the diff between this lines and the other lines,
// returning a unified diff with given amount of context (default of 3 will be
// used if -1)
func (ls *Lines) DiffsUnified(ob *Lines, context int) []byte {
        astr := ls.Strings(true) // needs newlines for some reason
        bstr := ob.Strings(true)

        return DiffLinesUnified(astr, bstr, context, ls.Filename(), ls.FileInfo().ModTime.String(),
                ob.Filename(), ob.FileInfo().ModTime.String())
}

////////   Search etc

// Search looks for a string (no regexp) within buffer,
// with given case-sensitivity, returning number of occurrences
// and specific match position list. Column positions are in runes.
func (ls *Lines) Search(find []byte, ignoreCase, lexItems bool) (int, []textpos.Match) {
        ls.Lock()
        defer ls.Unlock()
        if lexItems {
                return search.LexItems(ls.lines, ls.hiTags, find, ignoreCase)
        }
        return search.RuneLines(ls.lines, find, ignoreCase)
}

// SearchRegexp looks for a string (regexp) within buffer,
// returning number of occurrences and specific match position list.
// Column positions are in runes.
func (ls *Lines) SearchRegexp(re *regexp.Regexp) (int, []textpos.Match) {
        ls.Lock()
        defer ls.Unlock()
        return search.RuneLinesRegexp(ls.lines, re)
}

// BraceMatch finds the brace, bracket, or parens that is the partner
// of the one at the given position, if there is one of those at this position.
func (ls *Lines) BraceMatch(pos textpos.Pos) (textpos.Pos, bool) {
        ls.Lock()
        defer ls.Unlock()
        return ls.braceMatch(pos)
}

// BraceMatchRune finds the brace, bracket, or parens that is the partner
// of the given rune, starting at given position.
func (ls *Lines) BraceMatchRune(r rune, pos textpos.Pos) (textpos.Pos, bool) {
        ls.Lock()
        defer ls.Unlock()
        return lexer.BraceMatch(ls.lines, ls.hiTags, r, pos, maxScopeLines)
}

// LinkAt returns a hyperlink at given source position, if one exists,
// nil otherwise. this is fast so no problem to call frequently.
func (ls *Lines) LinkAt(pos textpos.Pos) *rich.Hyperlink {
        ls.Lock()
        defer ls.Unlock()
        return ls.linkAt(pos)
}

// NextLink returns the next hyperlink after given source position,
// if one exists, and the line it is on. nil, -1 otherwise.
func (ls *Lines) NextLink(pos textpos.Pos) (*rich.Hyperlink, int) {
        ls.Lock()
        defer ls.Unlock()
        return ls.nextLink(pos)
}

// PrevLink returns the previous hyperlink before given source position,
// if one exists, and the line it is on. nil, -1 otherwise.
func (ls *Lines) PrevLink(pos textpos.Pos) (*rich.Hyperlink, int) {
        ls.Lock()
        defer ls.Unlock()
        return ls.prevLink(pos)
}

// Links returns the full list of hyperlinks
func (ls *Lines) Links() map[int][]rich.Hyperlink {
        ls.Lock()
        defer ls.Unlock()
        return ls.links
}

////////   LineColors

// SetLineColor sets the color to use for rendering a circle next to the line
// number at the given line.
func (ls *Lines) SetLineColor(ln int, color image.Image) {
        ls.Lock()
        defer ls.Unlock()
        if ls.lineColors == nil {
                ls.lineColors = make(map[int]image.Image)
        }
        ls.lineColors[ln] = color
}

// LineColor returns the line color for given line, and bool indicating if set.
func (ls *Lines) LineColor(ln int) (image.Image, bool) {
        ls.Lock()
        defer ls.Unlock()
        if ln < 0 {
                return nil, false
        }
        if ls.lineColors == nil {
                return nil, false
        }
        clr, has := ls.lineColors[ln]
        return clr, has
}

// DeleteLineColor deletes the line color at the given line.
// Passing a -1 clears all current line colors.
func (ls *Lines) DeleteLineColor(ln int) {
        ls.Lock()
        defer ls.Unlock()

        if ln < 0 {
                ls.lineColors = nil
                return
        }
        if ls.lineColors == nil {
                return
        }
        delete(ls.lineColors, ln)
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "bytes"
        "fmt"
        "strings"

        "cogentcore.org/core/text/difflib"
        "cogentcore.org/core/text/textpos"
)

// note: original difflib is: "github.com/pmezard/go-difflib/difflib"

// Diffs are raw differences between text, in terms of lines, reporting a
// sequence of operations that would convert one buffer (a) into the other
// buffer (b).  Each operation is either an 'r' (replace), 'd' (delete), 'i'
// (insert) or 'e' (equal).
type Diffs []difflib.OpCode

// DiffForLine returns the diff record applying to given line, and its index in slice

func (di Diffs) DiffForLine(line int) (int, difflib.OpCode) {
        for i, df := range di {
                if line >= df.I1 && (line < df.I2 || line < df.J2) {
                        return i, df
                }
        }
        return -1, difflib.OpCode{}
}

func DiffOpReverse(op difflib.OpCode) difflib.OpCode {
        op.J1, op.I1 = op.I1, op.J1 // swap
        op.J2, op.I2 = op.I2, op.J2 // swap
        t := op.Tag
        switch t {
        case 'd':
                op.Tag = 'i'
        case 'i':
                op.Tag = 'd'
        }
        return op
}

// Reverse returns the reverse-direction diffs, switching a vs. b
func (di Diffs) Reverse() Diffs {
        rd := make(Diffs, len(di))
        for i := range di {
                rd[i] = DiffOpReverse(di[i])
        }
        return rd
}

func DiffOpString(op difflib.OpCode) string {
        switch op.Tag {
        case 'r':
                return fmt.Sprintf("delete lines: %v - %v, insert lines: %v - %v", op.I1, op.I2, op.J1, op.J2)
        case 'd':
                return fmt.Sprintf("delete lines: %v - %v", op.I1, op.I2)
        case 'i':
                return fmt.Sprintf("insert lines at %v: %v - %v", op.I1, op.J1, op.J2)
        case 'e':
                return fmt.Sprintf("same lines %v - %v == %v - %v", op.I1, op.I2, op.J1, op.J2)
        }
        return "<bad tag>"
}

// String satisfies the Stringer interface
func (di Diffs) String() string {
        var b strings.Builder
        for _, df := range di {
                b.WriteString(DiffOpString(df) + "\n")
        }
        return b.String()
}

// DiffLines computes the diff between two string arrays (one string per line),
// reporting a sequence of operations that would convert buffer a into buffer b.
// Each operation is either an 'r' (replace), 'd' (delete), 'i' (insert)
// or 'e' (equal).  Everything is line-based (0, offset).
func DiffLines(astr, bstr []string) Diffs {
        m := difflib.NewMatcherWithJunk(astr, bstr, false, nil) // no junk
        return m.GetOpCodes()
}

// DiffLinesUnified computes the diff between two string arrays (one string per line),
// returning a unified diff with given amount of context (default of 3 will be
// used if -1), with given file names and modification dates.
func DiffLinesUnified(astr, bstr []string, context int, afile, adate, bfile, bdate string) []byte {
        ud := difflib.UnifiedDiff{A: astr, FromFile: afile, FromDate: adate,
                B: bstr, ToFile: bfile, ToDate: bdate, Context: context}
        var buf bytes.Buffer
        difflib.WriteUnifiedDiff(&buf, ud)
        return buf.Bytes()
}

// PatchRec is a self-contained record of a DiffLines result that contains
// the source lines of the b buffer needed to patch a into b
type PatchRec struct {

        // diff operation: 'r', 'd', 'i', 'e'
        Op difflib.OpCode

        // lines from B buffer needed for 'r' and 'i' operations
        Blines []string
}

// Patch is a collection of patch records needed to turn original a buffer into b
type Patch []*PatchRec

// NumBlines returns the total number of Blines source code in the patch
func (pt Patch) NumBlines() int {
        nl := 0
        for _, pr := range pt {
                nl += len(pr.Blines)
        }
        return nl
}

// ToPatch creates a Patch list from given Diffs output from DiffLines and the
// b strings from which the needed lines of source are copied.
// ApplyPatch with this on the a strings will result in the b strings.
// The resulting Patch is independent of bstr slice.
func (dif Diffs) ToPatch(bstr []string) Patch {
        pt := make(Patch, len(dif))
        for pi, op := range dif {
                pr := &PatchRec{Op: op}
                if op.Tag == 'r' || op.Tag == 'i' {
                        nl := (op.J2 - op.J1)
                        pr.Blines = make([]string, nl)
                        for i := 0; i < nl; i++ {
                                pr.Blines[i] = bstr[op.J1+i]
                        }
                }
                pt[pi] = pr
        }
        return pt
}

// Apply applies given Patch to given file as list of strings
// this does no checking except range checking so it won't crash
// so if input string is not appropriate for given Patch, results
// may be nonsensical.
func (pt Patch) Apply(astr []string) []string {
        np := len(pt)
        if np == 0 {
                return astr
        }
        sz := len(astr)
        lr := pt[np-1]
        bstr := make([]string, lr.Op.J2)
        for _, pr := range pt {
                switch pr.Op.Tag {
                case 'e':
                        nl := (pr.Op.J2 - pr.Op.J1)
                        for i := 0; i < nl; i++ {
                                if pr.Op.I1+i < sz {
                                        bstr[pr.Op.J1+i] = astr[pr.Op.I1+i]
                                }
                        }
                case 'r', 'i':
                        nl := (pr.Op.J2 - pr.Op.J1)
                        for i := 0; i < nl; i++ {
                                bstr[pr.Op.J1+i] = pr.Blines[i]
                        }
                }
        }
        return bstr
}

////////  Lines api

// diffs computes the diff between this lines and the other lines,
// reporting a sequence of operations that would convert this lines (a) into
// the other lines (b).  Each operation is either an 'r' (replace), 'd'
// (delete), 'i' (insert) or 'e' (equal).  Everything is line-based (0, offset).
func (ls *Lines) diffs(ob *Lines) Diffs {
        astr := ls.strings(false)
        bstr := ob.strings(false)
        return DiffLines(astr, bstr)
}

// patchFrom patches (edits) using content from other,
// according to diff operations (e.g., as generated from DiffBufs).
func (ls *Lines) patchFrom(ob *Lines, diffs Diffs) bool {
        ls.undos.NewGroup()
        sz := len(diffs)
        mods := false
        for i := sz - 1; i >= 0; i-- { // go in reverse so changes are valid!
                df := diffs[i]
                switch df.Tag {
                case 'r':
                        ls.deleteText(textpos.Pos{Line: df.I1}, textpos.Pos{Line: df.I2})
                        ot := ob.Region(textpos.Pos{Line: df.J1}, textpos.Pos{Line: df.J2})
                        if ot != nil {
                                ls.insertTextLines(textpos.Pos{Line: df.I1}, ot.Text)
                                mods = true
                        }
                case 'd':
                        ls.deleteText(textpos.Pos{Line: df.I1}, textpos.Pos{Line: df.I2})
                        mods = true
                case 'i':
                        ot := ob.Region(textpos.Pos{Line: df.J1}, textpos.Pos{Line: df.J2})
                        if ot != nil {
                                ln := min(ls.numLines(), df.I1)
                                ls.insertTextLines(textpos.Pos{Line: ln}, ot.Text)
                                mods = true
                        }
                }
        }
        if mods {
                ls.undos.NewGroup()
        }
        return mods
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "slices"

        "cogentcore.org/core/text/difflib"
)

// DiffSelectData contains data for one set of text
type DiffSelectData struct {
        // original text
        Orig []string

        // edits applied
        Edit []string

        // mapping of original line numbers (index) to edited line numbers,
        // accounting for the edits applied so far
        LineMap []int

        // todo: in principle one should be able to reverse the edits to undo
        // but the orig is different -- figure it out later..

        // Undos: stack of diffs applied
        Undos Diffs

        // undo records
        EditUndo [][]string

        // undo records for ALineMap
        LineMapUndo [][]int
}

// SetStringLines sets the data from given lines of strings
// The Orig is set directly and Edit is cloned
// if the input will be modified during the processing,
// call slices.Clone first
func (ds *DiffSelectData) SetStringLines(s []string) {
        ds.Orig = s
        ds.Edit = slices.Clone(s)
        nl := len(s)
        ds.LineMap = make([]int, nl)
        for i := range ds.LineMap {
                ds.LineMap[i] = i
        }
}

func (ds *DiffSelectData) SaveUndo(op difflib.OpCode) {
        ds.Undos = append(ds.Undos, op)
        ds.EditUndo = append(ds.EditUndo, slices.Clone(ds.Edit))
        ds.LineMapUndo = append(ds.LineMapUndo, slices.Clone(ds.LineMap))
}

func (ds *DiffSelectData) Undo() bool {
        n := len(ds.LineMapUndo)
        if n == 0 {
                return false
        }
        ds.Undos = ds.Undos[:n-1]
        ds.LineMap = ds.LineMapUndo[n-1]
        ds.LineMapUndo = ds.LineMapUndo[:n-1]
        ds.Edit = ds.EditUndo[n-1]
        ds.EditUndo = ds.EditUndo[:n-1]
        return true
}

// ApplyOneDiff applies given diff operator to given "B" lines
// using original "A" lines and given b line map
func ApplyOneDiff(op difflib.OpCode, bedit *[]string, aorig []string, blmap []int) {
        // fmt.Println("applying:", DiffOpString(op))
        switch op.Tag {
        case 'r':
                na := op.J2 - op.J1
                nb := op.I2 - op.I1
                b1 := blmap[op.I1]
                nc := min(na, nb)
                for i := 0; i < nc; i++ {
                        (*bedit)[b1+i] = aorig[op.J1+i]
                }
                db := na - nb
                if db > 0 {
                        *bedit = slices.Insert(*bedit, b1+nb, aorig[op.J1+nb:op.J2]...)
                } else {
                        *bedit = slices.Delete(*bedit, b1+na, b1+nb)
                }
                for i := op.I2; i < len(blmap); i++ {
                        blmap[i] = blmap[i] + db
                }
        case 'd':
                nb := op.I2 - op.I1
                b1 := blmap[op.I1]
                *bedit = slices.Delete(*bedit, b1, b1+nb)
                for i := op.I2; i < len(blmap); i++ {
                        blmap[i] = blmap[i] - nb
                }
        case 'i':
                na := op.J2 - op.J1
                b1 := op.I1
                if op.I1 < len(blmap) {
                        b1 = blmap[op.I1]
                } else {
                        b1 = len(*bedit)
                }
                *bedit = slices.Insert(*bedit, b1, aorig[op.J1:op.J2]...)
                for i := op.I2; i < len(blmap); i++ {
                        blmap[i] = blmap[i] + na
                }
        }
}

// DiffSelected supports the incremental application of selected diffs
// between two files (either A -> B or B <- A), with Undo
type DiffSelected struct {
        A DiffSelectData
        B DiffSelectData

        // Diffs are the diffs between A and B
        Diffs Diffs
}

func NewDiffSelected(astr, bstr []string) *DiffSelected {
        ds := &DiffSelected{}
        ds.SetStringLines(astr, bstr)
        return ds
}

// SetStringLines sets the data from given lines of strings
func (ds *DiffSelected) SetStringLines(astr, bstr []string) {
        ds.A.SetStringLines(astr)
        ds.B.SetStringLines(bstr)
        ds.Diffs = DiffLines(astr, bstr)
}

// AtoB applies given diff index from A to B
func (ds *DiffSelected) AtoB(idx int) {
        op := DiffOpReverse(ds.Diffs[idx])
        ds.B.SaveUndo(op)
        ApplyOneDiff(op, &ds.B.Edit, ds.A.Orig, ds.B.LineMap)
}

// BtoA applies given diff index from B to A
func (ds *DiffSelected) BtoA(idx int) {
        op := ds.Diffs[idx]
        ds.A.SaveUndo(op)
        ApplyOneDiff(op, &ds.A.Edit, ds.B.Orig, ds.A.LineMap)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import "cogentcore.org/core/events"

// OnChange adds an event listener function to the view with given
// unique id, for the [events.Change] event.
// This is used for large-scale changes in the text, such as opening a
// new file or setting new text, or EditDone or Save.
func (ls *Lines) OnChange(vid int, fun func(e events.Event)) {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        if vw != nil {
                vw.listeners.Add(events.Change, fun)
        }
}

// OnInput adds an event listener function to the view with given
// unique id, for the [events.Input] event.
// This is sent after every fine-grained change in the text,
// and is used by text widgets to drive updates. It is blocked
// during batchUpdating.
func (ls *Lines) OnInput(vid int, fun func(e events.Event)) {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        if vw != nil {
                vw.listeners.Add(events.Input, fun)
        }
}

// OnClose adds an event listener function to the view with given
// unique id, for the [events.Close] event.
// This event is sent in the Close function.
func (ls *Lines) OnClose(vid int, fun func(e events.Event)) {
        ls.Lock()
        defer ls.Unlock()
        vw := ls.view(vid)
        if vw != nil {
                vw.listeners.Add(events.Close, fun)
        }
}

//////// unexported api

// sendChange sends a new [events.Change] event to all views listeners.
// Must never be called with the mutex lock in place!
// This is used to signal that the text has changed, for large-scale changes,
// such as opening a new file or setting new text, or EditoDone or Save.
func (ls *Lines) sendChange() {
        e := &events.Base{Typ: events.Change}
        e.Init()
        for _, vw := range ls.views {
                vw.listeners.Call(e)
        }
}

// sendInput sends a new [events.Input] event to all views listeners.
// Must never be called with the mutex lock in place!
// This is used to signal fine-grained changes in the text,
// and is used by text widgets to drive updates. It is blocked
// during batchUpdating.
func (ls *Lines) sendInput() {
        if ls.batchUpdating {
                return
        }
        e := &events.Base{Typ: events.Input}
        e.Init()
        for _, vw := range ls.views {
                vw.listeners.Call(e)
        }
}

// sendClose sends a new [events.Close] event to all views listeners.
// Must never be called with the mutex lock in place!
// Only sent in the Close function.
func (ls *Lines) sendClose() {
        e := &events.Base{Typ: events.Close}
        e.Init()
        for _, vw := range ls.views {
                vw.listeners.Call(e)
        }
}

// batchUpdateStart call this when starting a batch of updates.
// It calls AutoSaveOff and returns the prior state of that flag
// which must be restored using batchUpdateEnd.
func (ls *Lines) batchUpdateStart() (autoSave bool) {
        ls.batchUpdating = true
        ls.undos.NewGroup()
        autoSave = ls.autoSaveOff()
        return
}

// batchUpdateEnd call to complete BatchUpdateStart
func (ls *Lines) batchUpdateEnd(autoSave bool) {
        ls.autoSaveRestore(autoSave)
        ls.batchUpdating = false
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "io/fs"
        "log"
        "log/slog"
        "os"
        "path/filepath"
        "strings"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/text/parse"
)

//////// exported file api

// todo: cleanup and simplify the logic about language support!

// Filename returns the current filename
func (ls *Lines) Filename() string {
        ls.Lock()
        defer ls.Unlock()
        return ls.filename
}

// FileInfo returns the current fileinfo
func (ls *Lines) FileInfo() *fileinfo.FileInfo {
        ls.Lock()
        defer ls.Unlock()
        return &ls.fileInfo
}

// ParseState returns the current language properties and ParseState
// if it is a parse-supported known language, nil otherwise.
// Note: this API will change when LSP is implemented, and current
// use is likely to create race conditions / conflicts with markup.
func (ls *Lines) ParseState() (*parse.LanguageProperties, *parse.FileStates) {
        ls.Lock()
        defer ls.Unlock()
        lp, _ := parse.LanguageSupport.Properties(ls.parseState.Known)
        if lp != nil && lp.Lang != nil {
                return lp, &ls.parseState
        }
        return nil, nil
}

// ParseFileState returns the parsed file state if this is a
// parse-supported known language, nil otherwise.
// Note: this API will change when LSP is implemented, and current
// use is likely to create race conditions / conflicts with markup.
func (ls *Lines) ParseFileState() *parse.FileState {
        ls.Lock()
        defer ls.Unlock()
        lp, _ := parse.LanguageSupport.Properties(ls.parseState.Known)
        if lp != nil && lp.Lang != nil {
                return ls.parseState.Done()
        }
        return nil
}

// SetFilename sets the filename associated with the buffer and updates
// the code highlighting information accordingly.
func (ls *Lines) SetFilename(fn string) *Lines {
        ls.Lock()
        defer ls.Unlock()
        return ls.setFilename(fn)
}

// Stat gets info about the file, including the highlighting language.
func (ls *Lines) Stat() error {
        ls.Lock()
        defer ls.Unlock()
        return ls.stat()
}

// ConfigKnown configures options based on the supported language info in parse.
// Returns true if supported.
func (ls *Lines) ConfigKnown() bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.configKnown()
}

// SetFileInfo sets the syntax highlighting and other parameters
// based on the type of file specified by given [fileinfo.FileInfo].
func (ls *Lines) SetFileInfo(info *fileinfo.FileInfo) *Lines {
        ls.Lock()
        defer ls.Unlock()
        ls.setFileInfo(info)
        return ls
}

// SetFileType sets the syntax highlighting and other parameters
// based on the given fileinfo.Known file type
func (ls *Lines) SetLanguage(ftyp fileinfo.Known) *Lines {
        return ls.SetFileInfo(fileinfo.NewFileInfoType(ftyp))
}

// SetFileExt sets syntax highlighting and other parameters
// based on the given file extension (without the . prefix),
// for cases where an actual file with [fileinfo.FileInfo] is not
// available.
func (ls *Lines) SetFileExt(ext string) *Lines {
        if len(ext) == 0 {
                return ls
        }
        if ext[0] == '.' {
                ext = ext[1:]
        }
        fn := "_fake." + strings.ToLower(ext)
        fi, _ := fileinfo.NewFileInfo(fn)
        return ls.SetFileInfo(fi)
}

// Open loads the given file into the buffer.
func (ls *Lines) Open(filename string) error { //types:add
        ls.Lock()
        err := ls.openFile(filename)
        ls.Unlock()
        ls.sendChange()
        return err
}

// OpenFS loads the given file in the given filesystem into the buffer.
func (ls *Lines) OpenFS(fsys fs.FS, filename string) error {
        ls.Lock()
        err := ls.openFileFS(fsys, filename)
        ls.Unlock()
        ls.sendChange()
        return err
}

// SaveFile writes current buffer to file, with no prompting, etc
func (ls *Lines) SaveFile(filename string) error {
        ls.Lock()
        err := ls.saveFile(filename)
        if err == nil {
                ls.autosaveDelete()
        }
        ls.Unlock()
        return err
}

// Revert re-opens text from the current file,
// if the filename is set; returns false if not.
// It uses an optimized diff-based update to preserve
// existing formatting, making it very fast if not very different.
func (ls *Lines) Revert() bool { //types:add
        ls.Lock()
        did := ls.revert()
        ls.Unlock()
        ls.sendChange()
        return did
}

// IsNotSaved returns true if buffer was changed (edited) since last Save.
func (ls *Lines) IsNotSaved() bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.notSaved
}

// ClearNotSaved sets Changed and NotSaved to false.
func (ls *Lines) ClearNotSaved() {
        ls.Lock()
        defer ls.Unlock()
        ls.clearNotSaved()
}

// SetFileModOK sets the flag indicating that it is OK to edit even though
// the underlying file on disk has been edited.
func (ls *Lines) SetFileModOK(ok bool) {
        ls.Lock()
        defer ls.Unlock()
        ls.fileModOK = ok
}

// EditDone is called externally (e.g., by Editor widget) when the user
// has indicated that editing is done, and the results are to be consumed.
func (ls *Lines) EditDone() {
        ls.Lock()
        ls.changed = false
        ls.Unlock()
        ls.sendChange()
}

// SetReadOnly sets whether the buffer is read-only.
func (ls *Lines) SetReadOnly(readonly bool) *Lines {
        ls.Lock()
        defer ls.Unlock()
        return ls.setReadOnly(readonly)
}

// AutosaveFilename returns the autosave filename.
func (ls *Lines) AutosaveFilename() string {
        ls.Lock()
        defer ls.Unlock()
        return ls.autosaveFilename()
}

// AutosaveDelete deletes any existing autosave file.
func (ls *Lines) AutosaveDelete() {
        ls.Lock()
        defer ls.Unlock()
        ls.autosaveDelete()
}

// AutosaveCheck checks if an autosave file exists; logic for dealing with
// it is left to larger app; call this before opening a file.
func (ls *Lines) AutosaveCheck() bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.autosaveCheck()
}

// FileModCheck checks if the underlying file has been modified since last
// Stat (open, save); if haven't yet prompted, user is prompted to ensure
// that this is OK. It returns true if the file was modified.
func (ls *Lines) FileModCheck() bool {
        ls.Lock()
        defer ls.Unlock()
        return ls.fileModCheck()
}

////////  Unexported implementation

// setChanged sets the changed and notSaved flags
func (ls *Lines) setChanged() {
        ls.changed = true
        ls.notSaved = true
}

// clearNotSaved sets Changed and NotSaved to false.
func (ls *Lines) clearNotSaved() {
        ls.changed = false
        ls.notSaved = false
}

// setReadOnly sets whether the buffer is read-only.
// read-only buffers also do not record undo events.
func (ls *Lines) setReadOnly(readonly bool) *Lines {
        ls.readOnly = readonly
        ls.undos.Off = readonly
        return ls
}

// setFilename sets the filename associated with the buffer and updates
// the code highlighting information accordingly.
func (ls *Lines) setFilename(fn string) *Lines {
        ls.filename = fn
        ls.stat()
        ls.setFileInfo(&ls.fileInfo)
        return ls
}

// stat gets info about the file, including the highlighting language.
func (ls *Lines) stat() error {
        ls.fileModOK = false
        err := ls.fileInfo.InitFile(string(ls.filename))
        ls.configKnown() // may have gotten file type info even if not existing
        return err
}

// configKnown configures options based on the supported language info in parse.
// Returns true if supported.
func (ls *Lines) configKnown() bool {
        if ls.fileInfo.Known != fileinfo.Unknown {
                return ls.Settings.ConfigKnown(ls.fileInfo.Known)
        }
        return false
}

// openFile just loads the given file into the buffer, without doing
// any markup or signaling. It is typically used in other functions or
// for temporary buffers.
func (ls *Lines) openFile(filename string) error {
        txt, err := os.ReadFile(string(filename))
        if err != nil {
                return err
        }
        ls.setFilename(filename)
        ls.setText(txt)
        return nil
}

// openFileOnly just loads the given file into the buffer, without doing
// any markup or signaling. It is typically used in other functions or
// for temporary buffers.
func (ls *Lines) openFileOnly(filename string) error {
        txt, err := os.ReadFile(string(filename))
        if err != nil {
                return err
        }
        ls.setFilename(filename)
        ls.bytesToLines(txt) // not setText!
        return nil
}

// openFileFS loads the given file in the given filesystem into the buffer.
func (ls *Lines) openFileFS(fsys fs.FS, filename string) error {
        txt, err := fs.ReadFile(fsys, filename)
        if err != nil {
                return err
        }
        ls.setFilename(filename)
        ls.setText(txt)
        return nil
}

// revert re-opens text from the current file,
// if the filename is set; returns false if not.
// It uses an optimized diff-based update to preserve
// existing formatting, making it very fast if not very different.
func (ls *Lines) revert() bool {
        if ls.filename == "" {
                return false
        }

        ls.stopDelayedReMarkup()
        ls.autosaveDelete() // justin case

        didDiff := false
        if ls.numLines() < diffRevertLines {
                ob := NewLines()
                err := ob.openFileOnly(ls.filename)
                if errors.Log(err) != nil {
                        // sc := tb.sceneFromEditor() // todo:
                        // if sc != nil { // only if viewing
                        //         core.ErrorSnackbar(sc, err, "Error reopening file")
                        // }
                        return false
                }
                ls.stat() // "own" the new file..
                if ob.NumLines() < diffRevertLines {
                        diffs := ls.diffs(ob)
                        if len(diffs) < diffRevertDiffs {
                                ls.patchFrom(ob, diffs)
                                didDiff = true
                        }
                }
        }
        if !didDiff {
                ls.openFile(ls.filename)
        }
        ls.clearNotSaved()
        ls.autosaveDelete()
        return true
}

// saveFile writes current buffer to file, with no prompting, etc
func (ls *Lines) saveFile(filename string) error {
        err := os.WriteFile(string(filename), ls.bytes(0), 0644)
        if err != nil {
                // core.ErrorSnackbar(tb.sceneFromEditor(), err) // todo:
                slog.Error(err.Error())
        } else {
                ls.clearNotSaved()
                ls.filename = filename
                ls.stat()
        }
        return err
}

// fileModCheck checks if the underlying file has been modified since last
// Stat (open, save); if haven't yet prompted, user is prompted to ensure
// that this is OK. It returns true if the file was modified.
func (ls *Lines) fileModCheck() bool {
        if ls.filename == "" || ls.fileModOK {
                return false
        }
        info, err := os.Stat(string(ls.filename))
        if err != nil {
                return false
        }
        if info.ModTime() != time.Time(ls.fileInfo.ModTime) {
                if !ls.notSaved { // we haven't edited: just revert
                        ls.revert()
                        return true
                }
                if ls.FileModPromptFunc != nil {
                        ls.Unlock() // note: we assume anything getting here will be under lock
                        ls.FileModPromptFunc()
                        ls.Lock()
                }
                return true
        }
        return false
}

//////// Autosave

// autoSaveOff turns off autosave and returns the
// prior state of Autosave flag.
// Call AutosaveRestore with rval when done.
// See BatchUpdate methods for auto-use of this.
func (ls *Lines) autoSaveOff() bool {
        asv := ls.Autosave
        ls.Autosave = false
        return asv
}

// autoSaveRestore restores prior Autosave setting,
// from AutosaveOff
func (ls *Lines) autoSaveRestore(asv bool) {
        ls.Autosave = asv
}

// autosaveFilename returns the autosave filename.
func (ls *Lines) autosaveFilename() string {
        path, fn := filepath.Split(ls.filename)
        if fn == "" {
                fn = "new_file"
        }
        asfn := filepath.Join(path, "#"+fn+"#")
        return asfn
}

// autoSave does the autosave -- safe to call in a separate goroutine
func (ls *Lines) autoSave() error {
        if ls.autoSaving {
                return nil
        }
        ls.autoSaving = true
        asfn := ls.autosaveFilename()
        b := ls.bytes(0)
        err := os.WriteFile(asfn, b, 0644)
        if err != nil {
                log.Printf("Lines: Could not Autosave file: %v, error: %v\n", asfn, err)
        }
        ls.autoSaving = false
        return err
}

// autosaveDelete deletes any existing autosave file
func (ls *Lines) autosaveDelete() {
        asfn := ls.autosaveFilename()
        err := os.Remove(asfn)
        // the file may not exist, which is fine
        if err != nil && !errors.Is(err, fs.ErrNotExist) {
                errors.Log(err)
        }
}

// autosaveCheck checks if an autosave file exists; logic for dealing with
// it is left to larger app; call this before opening a file.
func (ls *Lines) autosaveCheck() bool {
        asfn := ls.autosaveFilename()
        if _, err := os.Stat(asfn); os.IsNotExist(err) {
                return false // does not exist
        }
        return true
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "unicode"

        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/textpos"
)

// layoutViewLines performs view-specific layout of all lines of current lines markup.
// This manages its own memory allocation, so it can be called on a new view.
// It must be called after any update to the source text or view layout parameters.
func (ls *Lines) layoutViewLines(vw *view) {
        n := len(ls.markup)
        if n == 0 {
                return
        }
        vw.markup = vw.markup[:0]
        vw.vlineStarts = vw.vlineStarts[:0]
        vw.lineToVline = slicesx.SetLength(vw.lineToVline, n)
        nln := 0
        for ln, mu := range ls.markup {
                muls, vst := ls.layoutViewLine(ln, vw.width, ls.lines[ln], mu)
                vw.lineToVline[ln] = len(vw.vlineStarts)
                vw.markup = append(vw.markup, muls...)
                vw.vlineStarts = append(vw.vlineStarts, vst...)
                nln += len(vst)
        }
        vw.viewLines = nln
}

// layoutViewLine performs layout and line wrapping on the given text,
// for given view text, with the given markup rich.Text.
// The layout is implemented in the markup that is returned.
// This clones and then modifies the given markup rich text.
func (ls *Lines) layoutViewLine(ln, width int, txt []rune, mu rich.Text) ([]rich.Text, []textpos.Pos) {
        lt := mu.Clone()
        n := len(txt)
        sp := textpos.Pos{Line: ln, Char: 0} // source startinng position
        vst := []textpos.Pos{sp}             // start with this line
        breaks := []int{}                    // line break indexes into lt spans
        clen := 0                            // current line length so far
        start := true
        prevWasTab := false
        i := 0
        for i < n {
                r := txt[i]
                si, sn, ri := lt.Index(i)
                startOfSpan := sn == ri
                // fmt.Printf("\n####\n%d\tclen:%d\tsi:%dsn:%d\tri:%d\t%v %v, sisrc: %q txt: %q\n", i, clen, si, sn, ri, startOfSpan, prevWasTab, string(lt[si][ri:]), string(txt[i:min(i+5, n)]))
                switch {
                case start && r == '\t':
                        clen += ls.Settings.TabSize
                        if !startOfSpan {
                                lt.SplitSpan(i) // each tab gets its own
                        }
                        prevWasTab = true
                        i++
                case r == '\t':
                        tp := (clen / 8) + 1
                        tp *= 8
                        clen = tp
                        if !startOfSpan {
                                lt.SplitSpan(i)
                        }
                        prevWasTab = true
                        i++
                case unicode.IsSpace(r):
                        start = false
                        clen++
                        if prevWasTab && !startOfSpan {
                                lt.SplitSpan(i)
                        }
                        prevWasTab = false
                        i++
                default:
                        start = false
                        didSplit := false
                        if prevWasTab && !startOfSpan {
                                lt.SplitSpan(i)
                                didSplit = true
                                si++
                        }
                        prevWasTab = false
                        ns := NextSpace(txt, i)
                        wlen := ns - i // length of word
                        // fmt.Println("word at:", i, "ns:", ns, string(txt[i:ns]))
                        if clen+wlen > width { // need to wrap
                                clen = 0
                                sp.Char = i
                                vst = append(vst, sp)
                                if !startOfSpan && !didSplit {
                                        lt.SplitSpan(i)
                                        si++
                                }
                                breaks = append(breaks, si)
                                if wlen > width {
                                        nb := wlen / width
                                        if nb*width == wlen {
                                                nb--
                                        }
                                        bp := i + width
                                        for range nb {
                                                si, sn, ri := lt.Index(bp)
                                                if sn != ri { // not start of span already
                                                        lt.SplitSpan(bp)
                                                        si++
                                                }
                                                breaks = append(breaks, si)
                                                sp.Char = bp
                                                vst = append(vst, sp)
                                                bp += width
                                        }
                                        clen = wlen - (nb * width)
                                }
                        }
                        clen += wlen
                        i = ns
                }
        }
        nb := len(breaks)
        if nb == 0 {
                return []rich.Text{lt}, vst
        }
        muls := make([]rich.Text, 0, nb+1)
        last := 0
        for _, si := range breaks {
                muls = append(muls, lt[last:si])
                last = si
        }
        muls = append(muls, lt[last:])
        return muls, vst
}

func NextSpace(txt []rune, pos int) int {
        n := len(txt)
        for i := pos; i < n; i++ {
                r := txt[i]
                if unicode.IsSpace(r) {
                        return i
                }
        }
        return n
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

//go:generate core generate -add-types

import (
        "bytes"
        "fmt"
        "image"
        "log"
        "slices"
        "sync"
        "time"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/metadata"
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/text/highlighting"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/runes"
        "cogentcore.org/core/text/textpos"
)

const (
        // ReplaceMatchCase is used for MatchCase arg in ReplaceText method
        ReplaceMatchCase = true

        // ReplaceNoMatchCase is used for MatchCase arg in ReplaceText method
        ReplaceNoMatchCase = false
)

var (
        // maximum number of lines to look for matching scope syntax (parens, brackets)
        maxScopeLines = 100 // `default:"100" min:"10" step:"10"`

        // maximum number of lines to apply syntax highlighting markup on
        maxMarkupLines = 10000 // `default:"10000" min:"1000" step:"1000"`

        // amount of time to wait before starting a new background markup process,
        // after text changes within a single line (always does after line insertion / deletion)
        markupDelay = 500 * time.Millisecond // `default:"500" min:"100" step:"100"`

        // text buffer max lines to use diff-based revert to more quickly update
        // e.g., after file has been reformatted
        diffRevertLines = 10000 // `default:"10000" min:"0" step:"1000"`

        // text buffer max diffs to use diff-based revert to more quickly update
        // e.g., after file has been reformatted -- if too many differences, just revert.
        diffRevertDiffs = 20 // `default:"20" min:"0" step:"1"`
)

// Lines manages multi-line monospaced text with a given line width in runes,
// so that all text wrapping, editing, and navigation logic can be managed
// purely in text space, allowing rendering and GUI layout to be relatively fast.
// This is suitable for text editing and terminal applications, among others.
// The text encoded as runes along with a corresponding [rich.Text] markup
// representation with syntax highlighting etc.
// The markup is updated in a separate goroutine for efficiency.
// Everything is protected by an overall sync.Mutex and is safe to concurrent access,
// and thus nothing is exported and all access is through protected accessor functions.
// In general, all unexported methods do NOT lock, and all exported methods do.
type Lines struct {

        // Settings are the options for how text editing and viewing works.
        Settings Settings

        // Highlighter does the syntax highlighting markup, and contains the
        // parameters thereof, such as the language and style.
        Highlighter highlighting.Highlighter

        // Autosave specifies whether an autosave copy of the file should
        // be automatically saved after changes are made.
        Autosave bool

        // FileModPromptFunc is called when a file has been modified in the filesystem
        // and it is about to be modified through an edit, in the fileModCheck function.
        // The prompt should determine whether the user wants to revert, overwrite, or
        // save current version as a different file. It must block until the user responds.
        FileModPromptFunc func()

        // Meta can be used to maintain misc metadata associated with the Lines text,
        // which allows the Lines object to be the primary data type for applications
        // dealing with text data, if there are just a few additional data elements needed.
        // Use standard Go camel-case key names, standards in [metadata].
        Meta metadata.Data

        // fontStyle is the default font styling to use for markup.
        // Is set to use the monospace font.
        fontStyle *rich.Style

        // undos is the undo manager.
        undos Undo

        // filename is the filename of the file that was last loaded or saved.
        // If this is empty then no file-related functionality is engaged.
        filename string

        // readOnly marks the contents as not editable. This is for the outer GUI
        // elements to consult, and is not enforced within Lines itself.
        readOnly bool

        // fileInfo is the full information about the current file, if one is set.
        fileInfo fileinfo.FileInfo

        // parseState is the parsing state information for the file.
        parseState parse.FileStates

        // changed indicates whether any changes have been made.
        // Use [IsChanged] method to access.
        changed bool

        // lines are the live lines of text being edited, with the latest modifications.
        // They are encoded as runes per line, which is necessary for one-to-one rune/glyph
        // rendering correspondence. All textpos positions are in rune indexes.
        lines [][]rune

        // tags are the extra custom tagged regions for each line.
        tags []lexer.Line

        // hiTags are the syntax highlighting tags, which are auto-generated.
        hiTags []lexer.Line

        // markup is the [rich.Text] encoded marked-up version of the text lines,
        // with the results of syntax highlighting. It just has the raw markup without
        // additional layout for a specific line width, which goes in a [view].
        markup []rich.Text

        // views are the distinct views of the lines, accessed via a unique view handle,
        // which is the key in the map. Each view can have its own width, and thus its own
        // markup and layout.
        views map[int]*view

        // lineColors associate a color with a given line number (key of map),
        // e.g., for a breakpoint or other such function.
        lineColors map[int]image.Image

        // markupEdits are the edits that were made during the time it takes to generate
        // the new markup tags. this is rare but it does happen.
        markupEdits []*textpos.Edit

        // markupDelayTimer is the markup delay timer.
        markupDelayTimer *time.Timer

        // markupDelayMu is the mutex for updating the markup delay timer.
        markupDelayMu sync.Mutex

        // posHistory is the history of cursor positions.
        // It can be used to move back through them.
        posHistory []textpos.Pos

        // links is the collection of all hyperlinks within the markup source,
        // indexed by the markup source line.
        // only updated at the full markup sweep.
        links map[int][]rich.Hyperlink

        // batchUpdating indicates that a batch update is under way,
        // so Input signals are not sent until the end.
        batchUpdating bool

        // autoSaving is used in atomically safe way to protect autosaving
        autoSaving bool

        // notSaved indicates if the text has been changed (edited) relative to the
        // original, since last Save. This can be true even when changed flag is
        // false, because changed is cleared on EditDone, e.g., when texteditor
        // is being monitored for OnChange and user does Control+Enter.
        // Use IsNotSaved() method to query state.
        notSaved bool

        // fileModOK have already asked about fact that file has changed since being
        // opened, user is ok
        fileModOK bool

        // use Lock(), Unlock() directly for overall mutex on any content updates
        sync.Mutex
}

func (ls *Lines) Metadata() *metadata.Data { return &ls.Meta }

// numLines returns number of lines
func (ls *Lines) numLines() int {
        return len(ls.lines)
}

// isValidLine returns true if given line number is in range.
func (ls *Lines) isValidLine(ln int) bool {
        if ln < 0 {
                return false
        }
        return ln < ls.numLines()
}

// setText sets the rune lines from source text,
// and triggers initial markup and delayed full markup.
func (ls *Lines) setText(txt []byte) {
        ls.bytesToLines(txt)
        ls.initialMarkup()
        ls.startDelayedReMarkup()
}

// bytesToLines sets the rune lines from source text.
// it does not trigger any markup but does allocate everything.
func (ls *Lines) bytesToLines(txt []byte) {
        if txt == nil {
                txt = []byte("")
        }
        ls.setLineBytes(bytes.Split(txt, []byte("\n")))
}

// setLineBytes sets the lines from source [][]byte.
func (ls *Lines) setLineBytes(lns [][]byte) {
        n := len(lns)
        if n > 1 && len(lns[n-1]) == 0 { // lines have lf at end typically
                lns = lns[:n-1]
                n--
        }
        if ls.fontStyle == nil {
                ls.Defaults()
        }
        ls.lines = slicesx.SetLength(ls.lines, n)
        ls.tags = slicesx.SetLength(ls.tags, n)
        ls.hiTags = slicesx.SetLength(ls.hiTags, n)
        ls.markup = slicesx.SetLength(ls.markup, n)
        for ln, txt := range lns {
                ls.lines[ln] = runes.SetFromBytes(ls.lines[ln], txt)
                ls.markup[ln] = rich.NewText(ls.fontStyle, ls.lines[ln]) // start with raw
        }
}

// bytes returns the current text lines as a slice of bytes, up to
// given number of lines if maxLines > 0.
// Adds an additional line feed at the end, per POSIX standards.
func (ls *Lines) bytes(maxLines int) []byte {
        nl := ls.numLines()
        if maxLines > 0 {
                nl = min(nl, maxLines)
        }
        nb := 80 * nl
        b := make([]byte, 0, nb)
        lastEmpty := false
        for ln := range nl {
                ll := []byte(string(ls.lines[ln]))
                if len(ll) == 0 {
                        lastEmpty = true
                }
                b = append(b, ll...)
                b = append(b, []byte("\n")...)
        }
        // https://stackoverflow.com/questions/729692/why-should-text-files-end-with-a-newline
        if !lastEmpty {
                b = append(b, []byte("\n")...)
        }
        return b
}

// strings returns the current text as []string array.
// If addNewLine is true, each string line has a \n appended at end.
func (ls *Lines) strings(addNewLine bool) []string {
        str := make([]string, ls.numLines())
        for i, l := range ls.lines {
                str[i] = string(l)
                if addNewLine {
                        str[i] += "\n"
                }
        }
        return str
}

////////   Appending Lines

// endPos returns the ending position at end of lines
func (ls *Lines) endPos() textpos.Pos {
        n := ls.numLines()
        if n == 0 {
                return textpos.Pos{}
        }
        return textpos.Pos{Line: n - 1, Char: len(ls.lines[n-1])}
}

// appendTextMarkup appends new lines of text to end of lines,
// using insert, returns edit, and uses supplied markup to render it.
func (ls *Lines) appendTextMarkup(text [][]rune, markup []rich.Text) *textpos.Edit {
        if len(text) == 0 {
                return &textpos.Edit{}
        }
        text = append(text, []rune{})
        ed := ls.endPos()
        tbe := ls.insertTextLines(ed, text)
        if tbe == nil {
                fmt.Println("nil insert", ed, text)
                return nil
        }
        st := tbe.Region.Start.Line
        el := tbe.Region.End.Line
        for ln := st; ln < el; ln++ {
                ls.markup[ln] = markup[ln-st]
        }
        return tbe
}

////////   Edits

// validCharPos returns the position with a valid Char position,
// if it is not valid. if the line is invalid, it returns false.
func (ls *Lines) validCharPos(pos textpos.Pos) (textpos.Pos, bool) {
        n := ls.numLines()
        if n == 0 {
                if pos.Line != 0 {
                        return pos, false
                }
                pos.Char = 0
                return pos, true
        }
        if pos.Line < 0 || pos.Line >= n {
                return pos, false
        }
        llen := len(ls.lines[pos.Line])
        if pos.Char < 0 {
                pos.Char = 0
                return pos, true
        }
        if pos.Char > llen {
                pos.Char = llen
                return pos, true
        }
        return pos, true
}

// isValidPos returns true if position is valid. Note that the end
// of the line (at length) is valid. This version does not panic or emit
// an error message, and should be used for cases where a position can
// legitimately be invalid, and is managed.
func (ls *Lines) isValidPos(pos textpos.Pos) bool {
        n := ls.numLines()
        if n == 0 {
                if pos.Line != 0 || pos.Char != 0 {
                        return false
                }
        }
        if pos.Line < 0 || pos.Line >= n {
                return false
        }
        llen := len(ls.lines[pos.Line])
        if pos.Char < 0 || pos.Char > llen {
                return false
        }
        return true
}

// mustValidPos panics if the position is invalid. Note that the end
// of the line (at length) is valid.
func (ls *Lines) mustValidPos(pos textpos.Pos) {
        n := ls.numLines()
        if n == 0 {
                if pos.Line != 0 || pos.Char != 0 {
                        panic("invalid position for empty text: " + pos.String())
                }
        }
        if pos.Line < 0 || pos.Line >= n {
                panic(fmt.Sprintf("invalid line number for n lines %d: pos: %s", n, pos))
        }
        llen := len(ls.lines[pos.Line])
        if pos.Char < 0 || pos.Char > llen {
                panic(fmt.Sprintf("invalid character position for pos, len: %d: pos: %s", llen, pos))
        }
}

// region returns a Edit representation of text between start and end positions
// returns nil and logs an error if not a valid region.
// sets the timestamp on the Edit to now
func (ls *Lines) region(st, ed textpos.Pos) *textpos.Edit {
        n := ls.numLines()
        ls.mustValidPos(st)
        if ed.Line == n && ed.Char == 0 { // end line: goes to endpos
                ed.Line = n - 1
                ed.Char = len(ls.lines[ed.Line])
        }
        ls.mustValidPos(ed)
        if st == ed {
                return nil
        }
        if !st.IsLess(ed) {
                log.Printf("lines.region: starting position must be less than ending!: st: %v, ed: %v\n", st, ed)
                return nil
        }
        tbe := &textpos.Edit{Region: textpos.NewRegionPos(st, ed)}
        if ed.Line == st.Line {
                sz := ed.Char - st.Char
                tbe.Text = make([][]rune, 1)
                tbe.Text[0] = make([]rune, sz)
                copy(tbe.Text[0][:sz], ls.lines[st.Line][st.Char:ed.Char])
        } else {
                nln := tbe.Region.NumLines()
                tbe.Text = make([][]rune, nln)
                stln := st.Line
                if st.Char > 0 {
                        ec := len(ls.lines[st.Line])
                        sz := ec - st.Char
                        if sz > 0 {
                                tbe.Text[0] = make([]rune, sz)
                                copy(tbe.Text[0], ls.lines[st.Line][st.Char:])
                        }
                        stln++
                }
                edln := ed.Line
                if ed.Char < len(ls.lines[ed.Line]) {
                        tbe.Text[ed.Line-st.Line] = make([]rune, ed.Char)
                        copy(tbe.Text[ed.Line-st.Line], ls.lines[ed.Line][:ed.Char])
                        edln--
                }
                for ln := stln; ln <= edln; ln++ {
                        ti := ln - st.Line
                        sz := len(ls.lines[ln])
                        tbe.Text[ti] = make([]rune, sz)
                        copy(tbe.Text[ti], ls.lines[ln])
                }
        }
        return tbe
}

// regionRect returns a Edit representation of text between start and end
// positions as a rectangle.
// returns nil and logs an error if not a valid region.
// sets the timestamp on the Edit to now
func (ls *Lines) regionRect(st, ed textpos.Pos) *textpos.Edit {
        ls.mustValidPos(st)
        ls.mustValidPos(ed)
        if st == ed {
                return nil
        }
        if !st.IsLess(ed) || st.Char >= ed.Char {
                log.Printf("core.Buf.RegionRect: starting position must be less than ending!: st: %v, ed: %v\n", st, ed)
                return nil
        }
        tbe := &textpos.Edit{Region: textpos.NewRegionPos(st, ed)}
        tbe.Rect = true
        nln := tbe.Region.NumLines()
        nch := (ed.Char - st.Char)
        tbe.Text = make([][]rune, nln)
        for i := range nln {
                ln := st.Line + i
                lr := ls.lines[ln]
                ll := len(lr)
                var txt []rune
                if ll > st.Char {
                        sz := min(ll-st.Char, nch)
                        txt = make([]rune, sz, nch)
                        edl := min(ed.Char, ll)
                        copy(txt, lr[st.Char:edl])
                }
                if len(txt) < nch { // rect
                        txt = append(txt, runes.Repeat([]rune(" "), nch-len(txt))...)
                }
                tbe.Text[i] = txt
        }
        return tbe
}

// deleteText is the primary method for deleting text,
// between start and end positions.
// An Undo record is automatically saved depending on Undo.Off setting.
func (ls *Lines) deleteText(st, ed textpos.Pos) *textpos.Edit {
        tbe := ls.deleteTextImpl(st, ed)
        ls.saveUndo(tbe)
        return tbe
}

func (ls *Lines) deleteTextImpl(st, ed textpos.Pos) *textpos.Edit {
        tbe := ls.region(st, ed)
        if tbe == nil {
                return nil
        }
        tbe.Delete = true
        nl := ls.numLines()
        if ed.Line == st.Line {
                if st.Line < nl {
                        ec := min(ed.Char, len(ls.lines[st.Line])) // somehow region can still not be valid.
                        ls.lines[st.Line] = append(ls.lines[st.Line][:st.Char], ls.lines[st.Line][ec:]...)
                        ls.linesEdited(tbe)
                }
        } else {
                // first get chars on start and end
                stln := st.Line + 1
                cpln := st.Line
                ls.lines[st.Line] = ls.lines[st.Line][:st.Char]
                eoedl := 0
                if ed.Line >= nl {
                        ed.Line = nl - 1
                }
                if ed.Char < len(ls.lines[ed.Line]) {
                        eoedl = len(ls.lines[ed.Line][ed.Char:])
                }
                var eoed []rune
                if eoedl > 0 { // save it
                        eoed = make([]rune, eoedl)
                        copy(eoed, ls.lines[ed.Line][ed.Char:])
                }
                ls.lines = append(ls.lines[:stln], ls.lines[ed.Line+1:]...)
                if eoed != nil {
                        ls.lines[cpln] = append(ls.lines[cpln], eoed...)
                }
                ls.linesDeleted(tbe)
        }
        ls.setChanged()
        return tbe
}

// deleteTextRect deletes rectangular region of text between start, end
// defining the upper-left and lower-right corners of a rectangle.
// Fails if st.Char >= ed.Char. Sets the timestamp on resulting Edit to now.
// An Undo record is automatically saved depending on Undo.Off setting.
func (ls *Lines) deleteTextRect(st, ed textpos.Pos) *textpos.Edit {
        tbe := ls.deleteTextRectImpl(st, ed)
        ls.saveUndo(tbe)
        return tbe
}

func (ls *Lines) deleteTextRectImpl(st, ed textpos.Pos) *textpos.Edit {
        tbe := ls.regionRect(st, ed)
        if tbe == nil {
                return nil
        }
        // fmt.Println("del:", tbe.Region)
        tbe.Delete = true
        for ln := st.Line; ln <= ed.Line; ln++ {
                l := ls.lines[ln]
                // fmt.Println(ln, string(l))
                if len(l) > st.Char {
                        if ed.Char <= len(l)-1 {
                                ls.lines[ln] = slices.Delete(l, st.Char, ed.Char)
                                // fmt.Println(ln, "del:", st.Char, ed.Char, string(ls.lines[ln]))
                        } else {
                                ls.lines[ln] = l[:st.Char]
                                // fmt.Println(ln, "trunc", st.Char, ed.Char, string(ls.lines[ln]))
                        }
                }
        }
        ls.linesEdited(tbe)
        ls.setChanged()
        return tbe
}

// insertText is the primary method for inserting text,
// at given starting position. Sets the timestamp on resulting Edit to now.
// An Undo record is automatically saved depending on Undo.Off setting.
func (ls *Lines) insertText(st textpos.Pos, txt []rune) *textpos.Edit {
        tbe := ls.insertTextImpl(st, runes.Split(txt, []rune("\n")))
        ls.saveUndo(tbe)
        return tbe
}

// insertTextLines is the primary method for inserting text,
// at given starting position, for text source that is already split
// into lines. Do NOT use Impl unless you really don't want to save
// the undo: in general very bad not to!
// Sets the timestamp on resulting Edit to now.
// An Undo record is automatically saved depending on Undo.Off setting.
func (ls *Lines) insertTextLines(st textpos.Pos, txt [][]rune) *textpos.Edit {
        tbe := ls.insertTextImpl(st, txt)
        ls.saveUndo(tbe)
        return tbe
}

// appendLines appends given number of lines at the end.
func (ls *Lines) appendLines(n int) {
        ls.lines = append(ls.lines, make([][]rune, n)...)
        ls.markup = append(ls.markup, make([]rich.Text, n)...)
        ls.tags = append(ls.tags, make([]lexer.Line, n)...)
        ls.hiTags = append(ls.hiTags, make([]lexer.Line, n)...)
        for _, vw := range ls.views {
                vw.lineToVline = append(vw.lineToVline, make([]int, n)...)
        }
}

// insertTextImpl inserts the Text at given starting position.
func (ls *Lines) insertTextImpl(st textpos.Pos, txt [][]rune) *textpos.Edit {
        if st.Line == ls.numLines() && st.Char == 0 { // adding new line
                ls.appendLines(1)
        }
        ls.mustValidPos(st)
        nl := len(txt)
        var tbe *textpos.Edit
        ed := st
        if nl == 1 {
                ls.lines[st.Line] = slices.Insert(ls.lines[st.Line], st.Char, txt[0]...)
                ed.Char += len(txt[0])
                tbe = ls.region(st, ed)
                ls.linesEdited(tbe)
        } else {
                if ls.lines[st.Line] == nil {
                        ls.lines[st.Line] = []rune{}
                }
                eostl := len(ls.lines[st.Line][st.Char:]) // end of starting line
                var eost []rune
                if eostl > 0 { // save it
                        eost = make([]rune, eostl)
                        copy(eost, ls.lines[st.Line][st.Char:])
                }
                ls.lines[st.Line] = append(ls.lines[st.Line][:st.Char], txt[0]...)
                nsz := nl - 1
                stln := st.Line + 1
                ls.lines = slices.Insert(ls.lines, stln, txt[1:]...)
                ed.Line += nsz
                ed.Char = len(ls.lines[ed.Line])
                if eost != nil {
                        ls.lines[ed.Line] = append(ls.lines[ed.Line], eost...)
                }
                tbe = ls.region(st, ed)
                ls.linesInserted(tbe)
        }
        ls.setChanged()
        return tbe
}

// insertTextRect inserts a rectangle of text defined in given Edit record,
// (e.g., from RegionRect or DeleteRect).
// Returns a copy of the Edit record with an updated timestamp.
// An Undo record is automatically saved depending on Undo.Off setting.
func (ls *Lines) insertTextRect(tbe *textpos.Edit) *textpos.Edit {
        re := ls.insertTextRectImpl(tbe)
        ls.saveUndo(re)
        return tbe
}

func (ls *Lines) insertTextRectImpl(tbe *textpos.Edit) *textpos.Edit {
        st := tbe.Region.Start
        ed := tbe.Region.End
        nlns := (ed.Line - st.Line) + 1
        if nlns <= 0 {
                return nil
        }
        ls.setChanged()
        // make sure there are enough lines -- add as needed
        cln := ls.numLines()
        if cln <= ed.Line {
                nln := (1 + ed.Line) - cln
                tmp := make([][]rune, nln)
                ls.lines = append(ls.lines, tmp...)
                ie := &textpos.Edit{}
                ie.Region.Start.Line = cln - 1
                ie.Region.End.Line = ed.Line
                ls.linesInserted(ie)
        }
        nch := (ed.Char - st.Char)
        for i := 0; i < nlns; i++ {
                ln := st.Line + i
                lr := ls.lines[ln]
                ir := tbe.Text[i]
                if len(ir) != nch {
                        panic(fmt.Sprintf("insertTextRectImpl: length of rect line: %d, %d != expected from region: %d", i, len(ir), nch))
                }
                if len(lr) < st.Char {
                        lr = append(lr, runes.Repeat([]rune{' '}, st.Char-len(lr))...)
                }
                nt := slices.Insert(lr, st.Char, ir...)
                ls.lines[ln] = nt
        }
        re := tbe.Clone()
        re.Rect = true
        re.Delete = false
        re.Region.TimeNow()
        ls.linesEdited(re)
        return re
}

// ReplaceText does DeleteText for given region, and then InsertText at given position
// (typically same as delSt but not necessarily).
// if matchCase is true, then the lexer.MatchCase function is called to match the
// case (upper / lower) of the new inserted text to that of the text being replaced.
// returns the Edit for the inserted text.
// An Undo record is automatically saved depending on Undo.Off setting.
func (ls *Lines) replaceText(delSt, delEd, insPos textpos.Pos, insTxt string, matchCase bool) *textpos.Edit {
        if matchCase {
                red := ls.region(delSt, delEd)
                cur := string(red.ToBytes())
                insTxt = lexer.MatchCase(cur, insTxt)
        }
        if len(insTxt) > 0 {
                ls.deleteText(delSt, delEd)
                return ls.insertText(insPos, []rune(insTxt))
        }
        return ls.deleteText(delSt, delEd)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "slices"
        "time"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/text/highlighting"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
        "golang.org/x/exp/maps"
)

// setFileInfo sets the syntax highlighting and other parameters
// based on the type of file specified by given [fileinfo.FileInfo].
func (ls *Lines) setFileInfo(info *fileinfo.FileInfo) {
        ls.parseState.SetSrc(string(info.Path), "", info.Known)
        ls.Highlighter.Init(info, &ls.parseState)
        ls.Settings.ConfigKnown(info.Known)
        if ls.numLines() > 0 {
                ls.initialMarkup()
                ls.startDelayedReMarkup()
        }
}

// initialMarkup does the first-pass markup on the file
func (ls *Lines) initialMarkup() {
        if !ls.Highlighter.Has || ls.numLines() == 0 {
                ls.collectLinks()
                ls.layoutViews()
                return
        }
        txt := ls.bytes(100)
        if ls.Highlighter.UsingParse() {
                fs := ls.parseState.Done() // initialize
                fs.Src.SetBytes(txt)
        }
        tags, err := ls.markupTags(txt)
        if err == nil {
                ls.markupApplyTags(tags)
        }
}

// startDelayedReMarkup starts a timer for doing markup after an interval.
func (ls *Lines) startDelayedReMarkup() {
        ls.markupDelayMu.Lock()
        defer ls.markupDelayMu.Unlock()

        if !ls.Highlighter.Has || ls.numLines() == 0 || ls.numLines() > maxMarkupLines {
                ls.collectLinks()
                ls.layoutViews()
                return
        }
        if ls.markupDelayTimer != nil {
                ls.markupDelayTimer.Stop()
                ls.markupDelayTimer = nil
        }
        ls.markupDelayTimer = time.AfterFunc(markupDelay, func() {
                ls.markupDelayTimer = nil
                ls.asyncMarkup() // already in a goroutine
        })
}

// stopDelayedReMarkup stops timer for doing markup after an interval
func (ls *Lines) stopDelayedReMarkup() {
        ls.markupDelayMu.Lock()
        defer ls.markupDelayMu.Unlock()

        if ls.markupDelayTimer != nil {
                ls.markupDelayTimer.Stop()
                ls.markupDelayTimer = nil
        }
}

// reMarkup runs re-markup on text in background
func (ls *Lines) reMarkup() {
        if !ls.Highlighter.Has || ls.numLines() == 0 || ls.numLines() > maxMarkupLines {
                return
        }
        ls.stopDelayedReMarkup()
        go ls.asyncMarkup()
}

// asyncMarkup does the markupTags from a separate goroutine.
// Does not start or end with lock, but acquires at end to apply.
func (ls *Lines) asyncMarkup() {
        ls.Lock()
        txt := ls.bytes(0)
        ls.markupEdits = nil // only accumulate after this point; very rare
        ls.Unlock()

        tags, err := ls.markupTags(txt)
        if err != nil {
                return
        }
        ls.Lock()
        ls.markupApplyTags(tags)
        ls.Unlock()
        ls.sendInput()
}

// markupTags generates the new markup tags from the highligher.
// this is a time consuming step, done via asyncMarkup typically.
// does not require any locking.
func (ls *Lines) markupTags(txt []byte) ([]lexer.Line, error) {
        return ls.Highlighter.MarkupTagsAll(txt)
}

// markupApplyEdits applies any edits in markupEdits to the
// tags prior to applying the tags. returns the updated tags.
// For parse-based updates, this is critical for getting full tags
// even if there aren't any markupEdits.
func (ls *Lines) markupApplyEdits(tags []lexer.Line) []lexer.Line {
        edits := ls.markupEdits
        ls.markupEdits = nil
        if ls.Highlighter.UsingParse() {
                pfs := ls.parseState.Done()
                for _, tbe := range edits {
                        if tbe.Delete {
                                stln := tbe.Region.Start.Line
                                edln := tbe.Region.End.Line
                                pfs.Src.LinesDeleted(stln, edln)
                        } else {
                                stln := tbe.Region.Start.Line + 1
                                nlns := (tbe.Region.End.Line - tbe.Region.Start.Line)
                                pfs.Src.LinesInserted(stln, nlns)
                        }
                }
                for ln := range tags { // todo: something weird about this -- not working in test
                        tags[ln] = pfs.LexLine(ln) // does clone, combines comments too
                }
        } else {
                for _, tbe := range edits {
                        if tbe.Delete {
                                stln := tbe.Region.Start.Line
                                edln := tbe.Region.End.Line
                                tags = append(tags[:stln], tags[edln:]...)
                        } else {
                                stln := tbe.Region.Start.Line + 1
                                nlns := (tbe.Region.End.Line - tbe.Region.Start.Line)
                                stln = min(stln, len(tags))
                                tags = slices.Insert(tags, stln, make([]lexer.Line, nlns)...)
                        }
                }
        }
        return tags
}

// markupApplyTags applies given tags to current text
// and sets the markup lines. Must be called under Lock.
func (ls *Lines) markupApplyTags(tags []lexer.Line) {
        tags = ls.markupApplyEdits(tags)
        maxln := min(len(tags), ls.numLines())
        for ln := range maxln {
                ls.hiTags[ln] = tags[ln]
                ls.tags[ln] = ls.adjustedTags(ln)
                mu := highlighting.MarkupLineRich(ls.Highlighter.Style, ls.fontStyle, ls.lines[ln], tags[ln], ls.tags[ln])
                ls.markup[ln] = mu
        }
        ls.collectLinks()
        ls.layoutViews()
}

// collectLinks finds all the links in markup into links.
func (ls *Lines) collectLinks() {
        ls.links = make(map[int][]rich.Hyperlink)
        for ln, mu := range ls.markup {
                lks := mu.GetLinks()
                if len(lks) > 0 {
                        ls.links[ln] = lks
                }
        }
}

// layoutViews updates layout of all view lines.
func (ls *Lines) layoutViews() {
        for _, vw := range ls.views {
                ls.layoutViewLines(vw)
        }
}

// markupLines generates markup of given range of lines.
// end is *inclusive* line. Called after edits, under Lock().
// returns true if all lines were marked up successfully.
func (ls *Lines) markupLines(st, ed int) bool {
        n := ls.numLines()
        if !ls.Highlighter.Has || n == 0 {
                return false
        }
        if ed >= n {
                ed = n - 1
        }
        allgood := true
        for ln := st; ln <= ed; ln++ {
                ltxt := ls.lines[ln]
                mt, err := ls.Highlighter.MarkupTagsLine(ln, ltxt)
                var mu rich.Text
                if err == nil {
                        ls.hiTags[ln] = mt
                        mu = highlighting.MarkupLineRich(ls.Highlighter.Style, ls.fontStyle, ltxt, mt, ls.adjustedTags(ln))
                        lks := mu.GetLinks()
                        if len(lks) > 0 {
                                ls.links[ln] = lks
                        }
                } else {
                        mu = rich.NewText(ls.fontStyle, ltxt)
                        allgood = false
                }
                ls.markup[ln] = mu
        }
        for _, vw := range ls.views {
                ls.layoutViewLines(vw)
        }
        // Now we trigger a background reparse of everything in a separate parse.FilesState
        // that gets switched into the current.
        return allgood
}

////////  Lines and tags

// linesEdited re-marks-up lines in edit (typically only 1).
func (ls *Lines) linesEdited(tbe *textpos.Edit) {
        if tbe == nil {
                return
        }
        st, ed := tbe.Region.Start.Line, tbe.Region.End.Line
        for ln := st; ln <= ed; ln++ {
                ls.markup[ln] = rich.NewText(ls.fontStyle, ls.lines[ln])
        }
        ls.markupLines(st, ed)
        ls.startDelayedReMarkup()
}

// linesInserted inserts new lines for all other line-based slices
// corresponding to lines inserted in the lines slice.
func (ls *Lines) linesInserted(tbe *textpos.Edit) {
        stln := tbe.Region.Start.Line + 1
        nsz := (tbe.Region.End.Line - tbe.Region.Start.Line)

        ls.markupEdits = append(ls.markupEdits, tbe)
        if nsz > 0 {
                ls.markup = slices.Insert(ls.markup, stln, make([]rich.Text, nsz)...)
                ls.tags = slices.Insert(ls.tags, stln, make([]lexer.Line, nsz)...)
                ls.hiTags = slices.Insert(ls.hiTags, stln, make([]lexer.Line, nsz)...)

                for _, vw := range ls.views {
                        vw.lineToVline = slices.Insert(vw.lineToVline, stln, make([]int, nsz)...)
                }
                if ls.Highlighter.UsingParse() {
                        pfs := ls.parseState.Done()
                        pfs.Src.LinesInserted(stln, nsz)
                }
        }
        ls.linesEdited(tbe)
}

// linesDeleted deletes lines in Markup corresponding to lines
// deleted in Lines text.
func (ls *Lines) linesDeleted(tbe *textpos.Edit) {
        ls.markupEdits = append(ls.markupEdits, tbe)
        stln := tbe.Region.Start.Line
        edln := tbe.Region.End.Line
        if edln > stln {
                ls.markup = append(ls.markup[:stln], ls.markup[edln:]...)
                ls.tags = append(ls.tags[:stln], ls.tags[edln:]...)
                ls.hiTags = append(ls.hiTags[:stln], ls.hiTags[edln:]...)
                if ls.Highlighter.UsingParse() {
                        pfs := ls.parseState.Done()
                        pfs.Src.LinesDeleted(stln, edln)
                }
        }
        // remarkup of start line:
        st := tbe.Region.Start.Line
        ls.markupLines(st, st)
        ls.startDelayedReMarkup()
}

// adjustedTags updates tag positions for edits, for given list of tags
func (ls *Lines) adjustedTags(ln int) lexer.Line {
        if !ls.isValidLine(ln) {
                return nil
        }
        return ls.adjustedTagsLine(ls.tags[ln], ln)
}

// adjustedTagsLine updates tag positions for edits, for given list of tags
func (ls *Lines) adjustedTagsLine(tags lexer.Line, ln int) lexer.Line {
        sz := len(tags)
        if sz == 0 {
                return nil
        }
        ntags := make(lexer.Line, 0, sz)
        for _, tg := range tags {
                reg := textpos.Region{Start: textpos.Pos{Line: ln, Char: tg.Start}, End: textpos.Pos{Line: ln, Char: tg.End}}
                reg.Time = tg.Time
                reg = ls.undos.AdjustRegion(reg)
                if !reg.IsNil() {
                        ntr := ntags.AddLex(tg.Token, reg.Start.Char, reg.End.Char)
                        ntr.Time.Now()
                }
        }
        return ntags
}

// lexObjPathString returns the string at given lex, and including prior
// lex-tagged regions that include sequences of PunctSepPeriod and NameTag
// which are used for object paths -- used for e.g., debugger to pull out
// variable expressions that can be evaluated.
func (ls *Lines) lexObjPathString(ln int, lx *lexer.Lex) string {
        if !ls.isValidLine(ln) {
                return ""
        }
        lln := len(ls.lines[ln])
        if lx.End > lln {
                return ""
        }
        stlx := lexer.ObjPathAt(ls.hiTags[ln], lx)
        if stlx.Start >= lx.End {
                return ""
        }
        return string(ls.lines[ln][stlx.Start:lx.End])
}

// hiTagAtPos returns the highlighting (markup) lexical tag at given position
// using current Markup tags, and index, -- could be nil if none or out of range
func (ls *Lines) hiTagAtPos(pos textpos.Pos) (*lexer.Lex, int) {
        if !ls.isValidLine(pos.Line) {
                return nil, -1
        }
        return ls.hiTags[pos.Line].AtPos(pos.Char)
}

// inTokenSubCat returns true if the given text position is marked with lexical
// type in given SubCat sub-category.
func (ls *Lines) inTokenSubCat(pos textpos.Pos, subCat token.Tokens) bool {
        lx, _ := ls.hiTagAtPos(pos)
        return lx != nil && lx.Token.Token.InSubCat(subCat)
}

// inLitString returns true if position is in a string literal
func (ls *Lines) inLitString(pos textpos.Pos) bool {
        return ls.inTokenSubCat(pos, token.LitStr)
}

// inTokenCode returns true if position is in a Keyword,
// Name, Operator, or Punctuation.
// This is useful for turning off spell checking in docs
func (ls *Lines) inTokenCode(pos textpos.Pos) bool {
        lx, _ := ls.hiTagAtPos(pos)
        if lx == nil {
                return false
        }
        return lx.Token.Token.IsCode()
}

func (ls *Lines) braceMatch(pos textpos.Pos) (textpos.Pos, bool) {
        if !ls.isValidPos(pos) {
                return textpos.Pos{}, false
        }
        txt := ls.lines[pos.Line]
        ch := pos.Char
        if ch >= len(txt) {
                return textpos.Pos{}, false
        }
        r := txt[ch]
        if r == '{' || r == '}' || r == '(' || r == ')' || r == '[' || r == ']' {
                return lexer.BraceMatch(ls.lines, ls.hiTags, r, pos, maxScopeLines)
        }
        return textpos.Pos{}, false
}

// linkAt returns a hyperlink at given source position, if one exists,
// nil otherwise. this is fast so no problem to call frequently.
func (ls *Lines) linkAt(pos textpos.Pos) *rich.Hyperlink {
        ll := ls.links[pos.Line]
        if len(ll) == 0 {
                return nil
        }
        for _, l := range ll {
                if l.Range.Contains(pos.Char) {
                        return &l
                }
        }
        return nil
}

// nextLink returns the next hyperlink after given source position,
// if one exists, and the line it is on. nil, -1 otherwise.
func (ls *Lines) nextLink(pos textpos.Pos) (*rich.Hyperlink, int) {
        cl := ls.linkAt(pos)
        if cl != nil {
                pos.Char = cl.Range.End
        }
        ll := ls.links[pos.Line]
        for _, l := range ll {
                if l.Range.Contains(pos.Char) {
                        return &l, pos.Line
                }
        }
        // find next line
        lns := maps.Keys(ls.links)
        slices.Sort(lns)
        for _, ln := range lns {
                if ln <= pos.Line {
                        continue
                }
                l := &ls.links[ln][0]
                return l, ln
        }
        return nil, -1
}

// prevLink returns the previous hyperlink before given source position,
// if one exists, and the line it is on. nil, -1 otherwise.
func (ls *Lines) prevLink(pos textpos.Pos) (*rich.Hyperlink, int) {
        cl := ls.linkAt(pos)
        if cl != nil {
                if cl.Range.Start == 0 {
                        pos = ls.moveBackward(pos, 1)
                } else {
                        pos.Char = cl.Range.Start - 1
                }
        }
        ll := ls.links[pos.Line]
        for _, l := range ll {
                if l.Range.End <= pos.Char {
                        return &l, pos.Line
                }
        }
        // find prev line
        lns := maps.Keys(ls.links)
        slices.Sort(lns)
        nl := len(lns)
        for i := nl - 1; i >= 0; i-- {
                ln := lns[i]
                if ln >= pos.Line {
                        continue
                }
                return &ls.links[ln][0], ln
        }
        return nil, -1
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "cogentcore.org/core/text/textpos"
)

// moveForward moves given source position forward given number of rune steps.
func (ls *Lines) moveForward(pos textpos.Pos, steps int) textpos.Pos {
        if !ls.isValidPos(pos) {
                return pos
        }
        for range steps {
                pos.Char++
                llen := len(ls.lines[pos.Line])
                if pos.Char > llen {
                        if pos.Line < len(ls.lines)-1 {
                                pos.Char = 0
                                pos.Line++
                        } else {
                                pos.Char = llen
                                break
                        }
                }
        }
        return pos
}

// moveBackward moves given source position backward given number of rune steps.
func (ls *Lines) moveBackward(pos textpos.Pos, steps int) textpos.Pos {
        if !ls.isValidPos(pos) {
                return pos
        }
        for range steps {
                pos.Char--
                if pos.Char < 0 {
                        if pos.Line > 0 {
                                pos.Line--
                                pos.Char = len(ls.lines[pos.Line])
                        } else {
                                pos.Char = 0
                                break
                        }
                }
        }
        return pos
}

// moveForwardWord moves given source position forward given number of word steps.
func (ls *Lines) moveForwardWord(pos textpos.Pos, steps int) textpos.Pos {
        if !ls.isValidPos(pos) {
                return pos
        }
        nstep := 0
        for nstep < steps {
                op := pos.Char
                np, ns := textpos.ForwardWord(ls.lines[pos.Line], op, steps)
                nstep += ns
                pos.Char = np
                if np == op || pos.Line >= len(ls.lines)-1 {
                        break
                }
                if nstep < steps {
                        pos.Line++
                        pos.Char = 0
                }
        }
        return pos
}

// moveBackwardWord moves given source position backward given number of word steps.
func (ls *Lines) moveBackwardWord(pos textpos.Pos, steps int) textpos.Pos {
        if !ls.isValidPos(pos) {
                return pos
        }
        nstep := 0
        for nstep < steps {
                op := pos.Char
                np, ns := textpos.BackwardWord(ls.lines[pos.Line], op, steps)
                nstep += ns
                pos.Char = np
                if pos.Line == 0 {
                        break
                }
                if nstep < steps {
                        pos.Line--
                        pos.Char = len(ls.lines[pos.Line])
                }
        }
        return pos
}

// moveDown moves given source position down given number of display line steps,
// always attempting to use the given column position if the line is long enough.
func (ls *Lines) moveDown(vw *view, pos textpos.Pos, steps, col int) textpos.Pos {
        if !ls.isValidPos(pos) {
                return pos
        }
        vl := vw.viewLines
        vp := ls.posToView(vw, pos)
        nvp := vp
        nvp.Line = min(nvp.Line+steps, vl-1)
        nvp.Char = col
        dp := ls.posFromView(vw, nvp)
        return dp
}

// moveUp moves given source position up given number of display line steps,
// always attempting to use the given column position if the line is long enough.
func (ls *Lines) moveUp(vw *view, pos textpos.Pos, steps, col int) textpos.Pos {
        if !ls.isValidPos(pos) {
                return pos
        }
        vp := ls.posToView(vw, pos)
        nvp := vp
        nvp.Line = max(nvp.Line-steps, 0)
        nvp.Char = col
        dp := ls.posFromView(vw, nvp)
        return dp
}

// moveLineStart moves given source position to start of view line.
func (ls *Lines) moveLineStart(vw *view, pos textpos.Pos) textpos.Pos {
        if !ls.isValidPos(pos) {
                return pos
        }
        vp := ls.posToView(vw, pos)
        vp.Char = 0
        return ls.posFromView(vw, vp)
}

// moveLineEnd moves given source position to end of view line.
func (ls *Lines) moveLineEnd(vw *view, pos textpos.Pos) textpos.Pos {
        if !ls.isValidPos(pos) {
                return pos
        }
        vp := ls.posToView(vw, pos)
        vp.Char = ls.viewLineLen(vw, vp.Line)
        return ls.posFromView(vw, vp)
}

// transposeChar swaps the character at the cursor with the one before it.
func (ls *Lines) transposeChar(vw *view, pos textpos.Pos) bool {
        if !ls.isValidPos(pos) {
                return false
        }
        vp := ls.posToView(vw, pos)
        pvp := vp
        pvp.Char--
        if pvp.Char < 0 {
                return false
        }
        ppos := ls.posFromView(vw, pvp)
        chr := ls.lines[pos.Line][pos.Char]
        pchr := ls.lines[ppos.Line][ppos.Char]
        repl := string([]rune{chr, pchr})
        pos.Char++
        ls.replaceText(ppos, pos, ppos, repl, ReplaceMatchCase)
        return true
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/text"
)

// Settings contains settings for editing text lines.
type Settings struct {
        text.EditorSettings

        // CommentLine are character(s) that start a single-line comment;
        // if empty then multi-line comment syntax will be used.
        CommentLine string

        // CommentStart are character(s) that start a multi-line comment
        // or one that requires both start and end.
        CommentStart string

        // Commentend are character(s) that end a multi-line comment
        // or one that requires both start and end.
        CommentEnd string
}

// CommentStrings returns the comment start and end strings,
// using line-based CommentLn first if set and falling back
// on multi-line / general purpose start / end syntax.
func (tb *Settings) CommentStrings() (comst, comed string) {
        comst = tb.CommentLine
        if comst == "" {
                comst = tb.CommentStart
                comed = tb.CommentEnd
        }
        return
}

// IndentChar returns the indent character based on SpaceIndent option
func (tb *Settings) IndentChar() indent.Character {
        if tb.SpaceIndent {
                return indent.Space
        }
        return indent.Tab
}

// ConfigKnown configures options based on the supported language info in parse.
// Returns true if supported.
func (tb *Settings) ConfigKnown(sup fileinfo.Known) bool {
        if sup == fileinfo.Unknown {
                return false
        }
        lp, ok := parse.StandardLanguageProperties[sup]
        if !ok {
                return false
        }
        tb.CommentLine = lp.CommentLn
        tb.CommentStart = lp.CommentSt
        tb.CommentEnd = lp.CommentEd
        for _, flg := range lp.Flags {
                switch flg {
                case parse.IndentSpace:
                        tb.SpaceIndent = true
                case parse.IndentTab:
                        tb.SpaceIndent = false
                }
        }
        return true
}

// KnownComments returns the comment strings for supported file types,
// and returns the standard C-style comments otherwise.
func KnownComments(fpath string) (comLn, comSt, comEd string) {
        comLn = "//"
        comSt = "/*"
        comEd = "*/"
        mtyp, _, err := fileinfo.MimeFromFile(fpath)
        if err != nil {
                return
        }
        sup := fileinfo.MimeKnown(mtyp)
        if sup == fileinfo.Unknown {
                return
        }
        lp, ok := parse.StandardLanguageProperties[sup]
        if !ok {
                return
        }
        comLn = lp.CommentLn
        comSt = lp.CommentSt
        comEd = lp.CommentEd
        return
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "fmt"
        "runtime/debug"
        "sync"
        "time"

        "cogentcore.org/core/text/textpos"
)

// UndoTrace; set to true to get a report of undo actions
var UndoTrace = false

// UndoGroupDelay is the amount of time above which a new group
// is started, for grouping undo events
var UndoGroupDelay = 250 * time.Millisecond

// Undo is the textview.Buf undo manager
type Undo struct {

        // if true, saving and using undos is turned off (e.g., inactive buffers)
        Off bool

        // undo stack of edits
        Stack []*textpos.Edit

        // undo stack of *undo* edits -- added to whenever an Undo is done -- for emacs-style undo
        UndoStack []*textpos.Edit

        // undo position in stack
        Pos int

        // group counter
        Group int

        // mutex protecting all updates
        Mu sync.Mutex `json:"-" xml:"-"`
}

// NewGroup increments the Group counter so subsequent undos will be grouped separately
func (un *Undo) NewGroup() {
        un.Mu.Lock()
        un.Group++
        un.Mu.Unlock()
}

// Reset clears all undo records
func (un *Undo) Reset() {
        un.Pos = 0
        un.Group = 0
        un.Stack = nil
        un.UndoStack = nil
}

// Save saves given edit to undo stack, with current group marker unless timer interval
// exceeds UndoGroupDelay since last item.
func (un *Undo) Save(tbe *textpos.Edit) {
        if un.Off {
                return
        }
        un.Mu.Lock()
        defer un.Mu.Unlock()
        if un.Pos < len(un.Stack) {
                if UndoTrace {
                        fmt.Printf("Undo: resetting to pos: %v len was: %v\n", un.Pos, len(un.Stack))
                }
                un.Stack = un.Stack[:un.Pos]
        }
        if len(un.Stack) > 0 {
                since := tbe.Region.Since(&un.Stack[len(un.Stack)-1].Region)
                if since > UndoGroupDelay {
                        un.Group++
                        if UndoTrace {
                                fmt.Printf("Undo: incrementing group to: %v since: %v\n", un.Group, since)
                        }
                }
        }
        tbe.Group = un.Group
        if UndoTrace {
                fmt.Printf("Undo: save to pos: %v: group: %v\n->\t%v\n", un.Pos, un.Group, string(tbe.ToBytes()))
        }
        un.Stack = append(un.Stack, tbe)
        un.Pos = len(un.Stack)
}

// UndoPop pops the top item off of the stack for use in Undo. returns nil if none.
func (un *Undo) UndoPop() *textpos.Edit {
        if un.Off {
                return nil
        }
        un.Mu.Lock()
        defer un.Mu.Unlock()
        if un.Pos == 0 {
                return nil
        }
        un.Pos--
        tbe := un.Stack[un.Pos]
        if UndoTrace {
                fmt.Printf("Undo: UndoPop of Gp: %v  pos: %v delete? %v at: %v text: %v\n", un.Group, un.Pos, tbe.Delete, tbe.Region, string(tbe.ToBytes()))
        }
        return tbe
}

// UndoPopIfGroup pops the top item off of the stack if it is the same as given group
func (un *Undo) UndoPopIfGroup(gp int) *textpos.Edit {
        if un.Off {
                return nil
        }
        un.Mu.Lock()
        defer un.Mu.Unlock()
        if un.Pos == 0 {
                return nil
        }
        tbe := un.Stack[un.Pos-1]
        if tbe.Group != gp {
                return nil
        }
        un.Pos--
        if UndoTrace {
                fmt.Printf("Undo: UndoPopIfGroup of Gp: %v pos: %v delete? %v at: %v text: %v\n", un.Group, un.Pos, tbe.Delete, tbe.Region, string(tbe.ToBytes()))
        }
        return tbe
}

// SaveUndo saves given edit to UndoStack (stack of undoes that have have undone..)
// for emacs mode.
func (un *Undo) SaveUndo(tbe *textpos.Edit) {
        un.UndoStack = append(un.UndoStack, tbe)
}

// UndoStackSave if EmacsUndo mode is active, saves the UndoStack
// to the regular Undo stack, at the end, and moves undo to the very end.
// Undo is a constant stream..
func (un *Undo) UndoStackSave() {
        if un.Off {
                return
        }
        un.Mu.Lock()
        defer un.Mu.Unlock()
        if len(un.UndoStack) == 0 {
                return
        }
        un.Stack = append(un.Stack, un.UndoStack...)
        un.Pos = len(un.Stack)
        un.UndoStack = nil
        if UndoTrace {
                fmt.Printf("Undo: undo stack saved to main stack, new pos: %v\n", un.Pos)
        }
}

// RedoNext returns the current item on Stack for Redo, and increments the position
// returns nil if at end of stack.
func (un *Undo) RedoNext() *textpos.Edit {
        if un.Off {
                return nil
        }
        un.Mu.Lock()
        defer un.Mu.Unlock()
        if un.Pos >= len(un.Stack) {
                return nil
        }
        tbe := un.Stack[un.Pos]
        if UndoTrace {
                fmt.Printf("Undo: RedoNext of Gp: %v at pos: %v delete? %v at: %v text: %v\n", un.Group, un.Pos, tbe.Delete, tbe.Region, string(tbe.ToBytes()))
        }
        un.Pos++
        return tbe
}

// RedoNextIfGroup returns the current item on Stack for Redo if it is same group
// and increments the position. returns nil if at end of stack.
func (un *Undo) RedoNextIfGroup(gp int) *textpos.Edit {
        if un.Off {
                return nil
        }
        un.Mu.Lock()
        defer un.Mu.Unlock()
        if un.Pos >= len(un.Stack) {
                return nil
        }
        tbe := un.Stack[un.Pos]
        if tbe.Group != gp {
                return nil
        }
        if UndoTrace {
                fmt.Printf("Undo: RedoNextIfGroup of Gp: %v at pos: %v delete? %v at: %v text: %v\n", un.Group, un.Pos, tbe.Delete, tbe.Region, string(tbe.ToBytes()))
        }
        un.Pos++
        return tbe
}

// AdjustRegion adjusts given text region for any edits that
// have taken place since time stamp on region (using the Undo stack).
// If region was wholly within a deleted region, then RegionNil will be
// returned -- otherwise it is clipped appropriately as function of deletes.
func (un *Undo) AdjustRegion(reg textpos.Region) textpos.Region {
        if un.Off {
                return reg
        }
        un.Mu.Lock()
        defer un.Mu.Unlock()
        for _, utbe := range un.Stack {
                reg = utbe.AdjustRegion(reg)
                if reg == (textpos.Region{}) {
                        return reg
                }
        }
        return reg
}

////////   Lines api

// saveUndo saves given edit to undo stack.
func (ls *Lines) saveUndo(tbe *textpos.Edit) {
        if tbe == nil {
                return
        }
        ls.undos.Save(tbe)
}

// undo undoes next group of items on the undo stack
func (ls *Lines) undo() []*textpos.Edit {
        tbe := ls.undos.UndoPop()
        if tbe == nil {
                // note: could clear the changed flag on tbe == nil in parent
                return nil
        }
        stgp := tbe.Group
        var eds []*textpos.Edit
        for {
                if tbe.Rect {
                        if tbe.Delete {
                                utbe := ls.insertTextRectImpl(tbe)
                                utbe.Group = stgp + tbe.Group
                                if ls.Settings.EmacsUndo {
                                        ls.undos.SaveUndo(utbe)
                                }
                                eds = append(eds, utbe)
                        } else {
                                utbe := ls.deleteTextRectImpl(tbe.Region.Start, tbe.Region.End)
                                utbe.Group = stgp + tbe.Group
                                if ls.Settings.EmacsUndo {
                                        ls.undos.SaveUndo(utbe)
                                }
                                eds = append(eds, utbe)
                        }
                } else {
                        if tbe.Delete {
                                utbe := ls.insertTextImpl(tbe.Region.Start, tbe.Text)
                                utbe.Group = stgp + tbe.Group
                                if ls.Settings.EmacsUndo {
                                        ls.undos.SaveUndo(utbe)
                                }
                                eds = append(eds, utbe)
                        } else {
                                if !ls.isValidPos(tbe.Region.End) {
                                        fmt.Println("lines.undo: invalid end region for undo. stack:", len(ls.undos.Stack), "tbe:", tbe)
                                        debug.PrintStack()
                                        break
                                }
                                utbe := ls.deleteTextImpl(tbe.Region.Start, tbe.Region.End)
                                utbe.Group = stgp + tbe.Group
                                if ls.Settings.EmacsUndo {
                                        ls.undos.SaveUndo(utbe)
                                }
                                eds = append(eds, utbe)
                        }
                }
                tbe = ls.undos.UndoPopIfGroup(stgp)
                if tbe == nil {
                        break
                }
        }
        return eds
}

// redo redoes next group of items on the undo stack,
// and returns the last record, nil if no more
func (ls *Lines) redo() []*textpos.Edit {
        tbe := ls.undos.RedoNext()
        if tbe == nil {
                return nil
        }
        var eds []*textpos.Edit
        stgp := tbe.Group
        for {
                if tbe.Rect {
                        if tbe.Delete {
                                ls.deleteTextRectImpl(tbe.Region.Start, tbe.Region.End)
                        } else {
                                ls.insertTextRectImpl(tbe)
                        }
                } else {
                        if tbe.Delete {
                                ls.deleteTextImpl(tbe.Region.Start, tbe.Region.End)
                        } else {
                                ls.insertTextImpl(tbe.Region.Start, tbe.Text)
                        }
                }
                eds = append(eds, tbe)
                tbe = ls.undos.RedoNextIfGroup(stgp)
                if tbe == nil {
                        break
                }
        }
        return eds
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "bufio"
        "bytes"
        "io"
        "log/slog"
        "os"
        "strings"

        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/runes"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// BytesToLineStrings returns []string lines from []byte input.
// If addNewLn is true, each string line has a \n appended at end.
func BytesToLineStrings(txt []byte, addNewLn bool) []string {
        lns := bytes.Split(txt, []byte("\n"))
        nl := len(lns)
        if nl == 0 {
                return nil
        }
        str := make([]string, nl)
        for i, l := range lns {
                str[i] = string(l)
                if addNewLn {
                        str[i] += "\n"
                }
        }
        return str
}

// StringLinesToByteLines returns [][]byte lines from []string lines
func StringLinesToByteLines(str []string) [][]byte {
        nl := len(str)
        bl := make([][]byte, nl)
        for i, s := range str {
                bl[i] = []byte(s)
        }
        return bl
}

// FileBytes returns the bytes of given file.
func FileBytes(fpath string) ([]byte, error) {
        fp, err := os.Open(fpath)
        if err != nil {
                slog.Error(err.Error())
                return nil, err
        }
        txt, err := io.ReadAll(fp)
        fp.Close()
        if err != nil {
                slog.Error(err.Error())
                return nil, err
        }
        return txt, nil
}

// FileRegionBytes returns the bytes of given file within given
// start / end lines, either of which might be 0 (in which case full file
// is returned).
// If preComments is true, it also automatically includes any comments
// that might exist just prior to the start line if stLn is > 0, going back
// a maximum of lnBack lines.
func FileRegionBytes(fpath string, stLn, edLn int, preComments bool, lnBack int) []byte {
        txt, err := FileBytes(fpath)
        if err != nil {
                return nil
        }
        if stLn == 0 && edLn == 0 {
                return txt
        }
        lns := bytes.Split(txt, []byte("\n"))
        nln := len(lns)

        if edLn > 0 && edLn > stLn && edLn < nln {
                el := min(edLn+1, nln-1)
                lns = lns[:el]
        }
        if preComments && stLn > 0 && stLn < nln {
                comLn, comSt, comEd := KnownComments(fpath)
                stLn = PreCommentStart(lns, stLn, comLn, comSt, comEd, lnBack)
        }

        if stLn > 0 && stLn < len(lns) {
                lns = lns[stLn:]
        }
        txt = bytes.Join(lns, []byte("\n"))
        txt = append(txt, '\n')
        return txt
}

// PreCommentStart returns the starting line for comment line(s) that just
// precede the given stLn line number within the given lines of bytes,
// using the given line-level and block start / end comment chars.
// returns stLn if nothing found.  Only looks back a total of lnBack lines.
func PreCommentStart(lns [][]byte, stLn int, comLn, comSt, comEd string, lnBack int) int {
        comLnb := []byte(strings.TrimSpace(comLn))
        comStb := []byte(strings.TrimSpace(comSt))
        comEdb := []byte(strings.TrimSpace(comEd))
        nback := 0
        gotEd := false
        for i := stLn - 1; i >= 0; i-- {
                l := lns[i]
                fl := bytes.Fields(l)
                if len(fl) == 0 {
                        stLn = i + 1
                        break
                }
                if !gotEd {
                        for _, ff := range fl {
                                if bytes.Equal(ff, comEdb) {
                                        gotEd = true
                                        break
                                }
                        }
                        if gotEd {
                                continue
                        }
                }
                if bytes.Equal(fl[0], comStb) {
                        stLn = i
                        break
                }
                if !bytes.Equal(fl[0], comLnb) && !gotEd {
                        stLn = i + 1
                        break
                }
                nback++
                if nback > lnBack {
                        stLn = i
                        break
                }
        }
        return stLn
}

// CountWordsLinesRegion counts the number of words (aka Fields, space-separated strings)
// and lines in given region of source (lines = 1 + End.Line - Start.Line)
func CountWordsLinesRegion(src [][]rune, reg textpos.Region) (words, lines int) {
        lns := len(src)
        mx := min(lns-1, reg.End.Line)
        for ln := reg.Start.Line; ln <= mx; ln++ {
                sln := src[ln]
                if ln == reg.Start.Line {
                        sln = sln[reg.Start.Char:]
                } else if ln == reg.End.Line {
                        sln = sln[:reg.End.Char]
                }
                flds := strings.Fields(string(sln))
                words += len(flds)
        }
        lines = 1 + (reg.End.Line - reg.Start.Line)
        return
}

// CountWordsLines counts the number of words (aka Fields, space-separated strings)
// and lines given io.Reader input
func CountWordsLines(reader io.Reader) (words, lines int) {
        scan := bufio.NewScanner(reader)
        for scan.Scan() {
                flds := bytes.Fields(scan.Bytes())
                words += len(flds)
                lines++
        }
        return
}

////////   Indenting

// see parse/lexer/indent.go for support functions

// indentLine indents line by given number of tab stops, using tabs or spaces,
// for given tab size (if using spaces) -- either inserts or deletes to reach target.
// Returns edit record for any change.
func (ls *Lines) indentLine(ln, ind int) *textpos.Edit {
        tabSz := ls.Settings.TabSize
        ichr := indent.Tab
        if ls.Settings.SpaceIndent {
                ichr = indent.Space
        }
        curind, _ := lexer.LineIndent(ls.lines[ln], tabSz)
        if ind > curind {
                txt := runes.SetFromBytes([]rune{}, indent.Bytes(ichr, ind-curind, tabSz))
                return ls.insertText(textpos.Pos{Line: ln}, txt)
        } else if ind < curind {
                spos := indent.Len(ichr, ind, tabSz)
                cpos := indent.Len(ichr, curind, tabSz)
                return ls.deleteText(textpos.Pos{Line: ln, Char: spos}, textpos.Pos{Line: ln, Char: cpos})
        }
        return nil
}

// autoIndent indents given line to the level of the prior line, adjusted
// appropriately if the current line starts with one of the given un-indent
// strings, or the prior line ends with one of the given indent strings.
// Returns any edit that took place (could be nil), along with the auto-indented
// level and character position for the indent of the current line.
func (ls *Lines) autoIndent(ln int) (tbe *textpos.Edit, indLev, chPos int) {
        tabSz := ls.Settings.TabSize
        lp, _ := parse.LanguageSupport.Properties(ls.parseState.Known)
        var pInd, delInd int
        if lp != nil && lp.Lang != nil {
                pInd, delInd, _, _ = lp.Lang.IndentLine(&ls.parseState, ls.lines, ls.hiTags, ln, tabSz)
        } else {
                pInd, delInd, _, _ = lexer.BracketIndentLine(ls.lines, ls.hiTags, ln, tabSz)
        }
        ichr := ls.Settings.IndentChar()
        indLev = max(pInd+delInd, 0)
        chPos = indent.Len(ichr, indLev, tabSz)
        tbe = ls.indentLine(ln, indLev)
        return
}

// autoIndentRegion does auto-indent over given region; end is *exclusive*
func (ls *Lines) autoIndentRegion(start, end int) {
        end = min(ls.numLines(), end)
        for ln := start; ln < end; ln++ {
                ls.autoIndent(ln)
        }
}

// commentStart returns the char index where the comment
// starts on given line, -1 if no comment.
func (ls *Lines) commentStart(ln int) int {
        if !ls.isValidLine(ln) {
                return -1
        }
        comst, _ := ls.Settings.CommentStrings()
        if comst == "" {
                return -1
        }
        return runes.Index(ls.lines[ln], []rune(comst))
}

// inComment returns true if the given text position is within
// a commented region.
func (ls *Lines) inComment(pos textpos.Pos) bool {
        if ls.inTokenSubCat(pos, token.Comment) {
                return true
        }
        cs := ls.commentStart(pos.Line)
        if cs < 0 {
                return false
        }
        return pos.Char > cs
}

// lineCommented returns true if the given line is a full-comment
// line (i.e., starts with a comment).
func (ls *Lines) lineCommented(ln int) bool {
        if !ls.isValidLine(ln) {
                return false
        }
        tags := ls.hiTags[ln]
        if len(tags) == 0 {
                return false
        }
        return tags[0].Token.Token.InCat(token.Comment)
}

// commentRegion inserts comment marker on given lines; end is *exclusive*.
func (ls *Lines) commentRegion(start, end int) {
        tabSz := ls.Settings.TabSize
        ch := 0
        ind, _ := lexer.LineIndent(ls.lines[start], tabSz)
        if ind > 0 {
                if ls.Settings.SpaceIndent {
                        ch = ls.Settings.TabSize * ind
                } else {
                        ch = ind
                }
        }

        comst, comed := ls.Settings.CommentStrings()
        if comst == "" {
                // log.Printf("text.Lines: attempt to comment region without any comment syntax defined")
                comst = "// "
                return
        }

        eln := min(ls.numLines(), end)
        ncom := 0
        nln := eln - start
        for ln := start; ln < eln; ln++ {
                if ls.lineCommented(ln) {
                        ncom++
                }
        }
        trgln := max(nln-2, 1)
        doCom := true
        if ncom >= trgln {
                doCom = false
        }
        rcomst := []rune(comst)
        rcomed := []rune(comed)

        for ln := start; ln < eln; ln++ {
                if doCom {
                        ipos, ok := ls.validCharPos(textpos.Pos{Line: ln, Char: ch})
                        if ok {
                                ls.insertText(ipos, rcomst)
                                if comed != "" {
                                        lln := len(ls.lines[ln]) // automatically ok
                                        ls.insertText(textpos.Pos{Line: ln, Char: lln}, rcomed)
                                }
                        }
                } else {
                        idx := ls.commentStart(ln)
                        if idx >= 0 {
                                ls.deleteText(textpos.Pos{Line: ln, Char: idx}, textpos.Pos{Line: ln, Char: idx + len(comst)})
                        }
                        if comed != "" {
                                idx := runes.IndexFold(ls.lines[ln], []rune(comed))
                                if idx >= 0 {
                                        ls.deleteText(textpos.Pos{Line: ln, Char: idx}, textpos.Pos{Line: ln, Char: idx + len(comed)})
                                }
                        }
                }
        }
}

// joinParaLines merges sequences of lines with hard returns forming paragraphs,
// separated by blank lines, into a single line per paragraph,
// within the given line regions; endLine is *inclusive*.
func (ls *Lines) joinParaLines(startLine, endLine int) {
        // current end of region being joined == last blank line
        curEd := endLine
        for ln := endLine; ln >= startLine; ln-- { // reverse order
                lr := ls.lines[ln]
                lrt := runes.TrimSpace(lr)
                if len(lrt) == 0 || ln == startLine {
                        if ln < curEd-1 {
                                stp := textpos.Pos{Line: ln + 1}
                                if ln == startLine {
                                        stp.Line--
                                }
                                ep := textpos.Pos{Line: curEd - 1}
                                if curEd == endLine {
                                        ep.Line = curEd
                                }
                                eln := ls.lines[ep.Line]
                                ep.Char = len(eln)
                                trt := runes.Join(ls.lines[stp.Line:ep.Line+1], []rune(" "))
                                ls.replaceText(stp, ep, stp, string(trt), ReplaceNoMatchCase)
                        }
                        curEd = ln
                }
        }
}

// tabsToSpacesLine replaces tabs with spaces in the given line.
func (ls *Lines) tabsToSpacesLine(ln int) {
        tabSz := ls.Settings.TabSize

        lr := ls.lines[ln]
        st := textpos.Pos{Line: ln}
        ed := textpos.Pos{Line: ln}
        i := 0
        for {
                if i >= len(lr) {
                        break
                }
                r := lr[i]
                if r == '\t' {
                        po := i % tabSz
                        nspc := tabSz - po
                        st.Char = i
                        ed.Char = i + 1
                        ls.replaceText(st, ed, st, indent.Spaces(1, nspc), ReplaceNoMatchCase)
                        i += nspc
                        lr = ls.lines[ln]
                } else {
                        i++
                }
        }
}

// tabsToSpaces replaces tabs with spaces over given region; end is *exclusive*.
func (ls *Lines) tabsToSpaces(start, end int) {
        end = min(ls.numLines(), end)
        for ln := start; ln < end; ln++ {
                ls.tabsToSpacesLine(ln)
        }
}

// spacesToTabsLine replaces spaces with tabs in the given line.
func (ls *Lines) spacesToTabsLine(ln int) {
        tabSz := ls.Settings.TabSize

        lr := ls.lines[ln]
        st := textpos.Pos{Line: ln}
        ed := textpos.Pos{Line: ln}
        i := 0
        nspc := 0
        for {
                if i >= len(lr) {
                        break
                }
                r := lr[i]
                if r == ' ' {
                        nspc++
                        if nspc == tabSz {
                                st.Char = i - (tabSz - 1)
                                ed.Char = i + 1
                                ls.replaceText(st, ed, st, "\t", ReplaceNoMatchCase)
                                i -= tabSz - 1
                                lr = ls.lines[ln]
                                nspc = 0
                        } else {
                                i++
                        }
                } else {
                        nspc = 0
                        i++
                }
        }
}

// spacesToTabs replaces tabs with spaces over given region; end is *exclusive*
func (ls *Lines) spacesToTabs(start, end int) {
        end = min(ls.numLines(), end)
        for ln := start; ln < end; ln++ {
                ls.spacesToTabsLine(ln)
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lines

import (
        "cogentcore.org/core/events"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/textpos"
)

// view provides a view onto a shared [Lines] text buffer,
// with a representation of view lines that are the wrapped versions of
// the original [Lines.lines] source lines, with wrapping according to
// the view width. Views are managed by the Lines.
type view struct {
        // width is the current line width in rune characters, used for line wrapping.
        width int

        // viewLines is the total number of line-wrapped lines.
        viewLines int

        // vlineStarts are the positions in the original [Lines.lines] source for
        // the start of each view line. This slice is viewLines in length.
        vlineStarts []textpos.Pos

        // markup is the view-specific version of the [Lines.markup] markup for
        // each view line (len = viewLines).
        markup []rich.Text

        // lineToVline maps the source [Lines.lines] indexes to the wrapped
        // viewLines. Each slice value contains the index into the viewLines space,
        // such that vlineStarts of that index is the start of the original source line.
        // Any subsequent vlineStarts with the same Line and Char > 0 following this
        // starting line represent additional wrapped content from the same source line.
        lineToVline []int

        // listeners is used for sending Change, Input, and Close events to views.
        listeners events.Listeners
}

// viewLineLen returns the length in chars (runes) of the given view line.
func (ls *Lines) viewLineLen(vw *view, vl int) int {
        n := len(vw.vlineStarts)
        if n == 0 {
                return 0
        }
        if vl < 0 {
                vl = 0
        }
        if vl >= n {
                vl = n - 1
        }
        vs := vw.vlineStarts[vl]
        sl := ls.lines[vs.Line]
        if vl == vw.viewLines-1 {
                return len(sl) + 1 - vs.Char
        }
        np := vw.vlineStarts[vl+1]
        if np.Line == vs.Line {
                return np.Char - vs.Char
        }
        return len(sl) + 1 - vs.Char
}

// viewLinesRange returns the start and end view lines for given
// source line number, using only lineToVline. ed is inclusive.
func (ls *Lines) viewLinesRange(vw *view, ln int) (st, ed int) {
        n := len(vw.lineToVline)
        st = vw.lineToVline[ln]
        if ln+1 < n {
                ed = vw.lineToVline[ln+1] - 1
        } else {
                ed = vw.viewLines - 1
        }
        return
}

// validViewLine returns a view line that is in range based on given
// source line.
func (ls *Lines) validViewLine(vw *view, ln int) int {
        if ln < 0 {
                return 0
        } else if ln >= len(vw.lineToVline) {
                return vw.viewLines - 1
        }
        return vw.lineToVline[ln]
}

// posToView returns the view position in terms of viewLines and Char
// offset into that view line for given source line, char position.
// Is robust to out-of-range positions.
func (ls *Lines) posToView(vw *view, pos textpos.Pos) textpos.Pos {
        vp := pos
        vl := ls.validViewLine(vw, pos.Line)
        vp.Line = vl
        vlen := ls.viewLineLen(vw, vl)
        if pos.Char < vlen {
                return vp
        }
        nl := vl + 1
        if nl == vw.viewLines {
                vp.Char = pos.Char
                return vp
        }
        for nl < vw.viewLines && vw.vlineStarts[nl].Line == pos.Line {
                np := vw.vlineStarts[nl]
                vlen := ls.viewLineLen(vw, nl)
                if pos.Char >= np.Char && pos.Char < np.Char+vlen {
                        np.Line = nl
                        np.Char = pos.Char - np.Char
                        return np
                }
                nl++
        }
        return vp
}

// posFromView returns the original source position from given
// view position in terms of viewLines and Char offset into that view line.
// If the Char position is beyond the end of the line, it returns the
// end of the given line.
func (ls *Lines) posFromView(vw *view, vp textpos.Pos) textpos.Pos {
        n := len(vw.vlineStarts)
        if n == 0 {
                return textpos.Pos{}
        }
        vl := vp.Line
        if vl < 0 {
                vl = 0
        } else if vl >= n {
                vl = n - 1
        }
        vlen := ls.viewLineLen(vw, vl)
        if vlen == 0 {
                vlen = 1
        }
        vp.Char = min(vp.Char, vlen-1)
        pos := vp
        sp := vw.vlineStarts[vl]
        pos.Line = sp.Line
        pos.Char = sp.Char + vp.Char
        return pos
}

// regionToView converts the given region in source coordinates into view coordinates.
func (ls *Lines) regionToView(vw *view, reg textpos.Region) textpos.Region {
        return textpos.Region{Start: ls.posToView(vw, reg.Start), End: ls.posToView(vw, reg.End)}
}

// regionFromView converts the given region in view coordinates into source coordinates.
func (ls *Lines) regionFromView(vw *view, reg textpos.Region) textpos.Region {
        return textpos.Region{Start: ls.posFromView(vw, reg.Start), End: ls.posFromView(vw, reg.End)}
}

// viewLineRegion returns the region in view coordinates of the given view line.
func (ls *Lines) viewLineRegion(vw *view, vln int) textpos.Region {
        llen := ls.viewLineLen(vw, vln)
        return textpos.Region{Start: textpos.Pos{Line: vln}, End: textpos.Pos{Line: vln, Char: llen}}
}

// initViews ensures that the views map is constructed.
func (ls *Lines) initViews() {
        if ls.views == nil {
                ls.views = make(map[int]*view)
        }
}

// view returns view for given unique view id. nil if not found.
func (ls *Lines) view(vid int) *view {
        ls.initViews()
        return ls.views[vid]
}

// newView makes a new view with next available id, using given initial width.
func (ls *Lines) newView(width int) (*view, int) {
        ls.initViews()
        mxi := 0
        for i := range ls.views {
                mxi = max(i, mxi)
        }
        id := mxi + 1
        vw := &view{width: width}
        ls.views[id] = vw
        ls.layoutViewLines(vw)
        return vw, id
}

// deleteView deletes view with given view id.
func (ls *Lines) deleteView(vid int) {
        delete(ls.views, vid)
}

// ViewMarkupLine returns the markup [rich.Text] line for given view and
// view line number. This must be called under the mutex Lock! It is the
// api for rendering the lines.
func (ls *Lines) ViewMarkupLine(vid, line int) rich.Text {
        vw := ls.view(vid)
        if line >= 0 && len(vw.markup) > line {
                return vw.markup[line]
        }
        return rich.Text{}
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "flag"
        "fmt"
        "os"
        "path/filepath"
        "strings"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/text/parse"
        _ "cogentcore.org/core/text/parse/languages"
        "cogentcore.org/core/text/parse/syms"
)

var Excludes []string

func main() {
        var path string
        var recurse bool
        var excl string

        parse.LanguageSupport.OpenStandard()

        flag.Usage = func() {
                fmt.Fprintf(flag.CommandLine.Output(), "Usage of %s:\n", os.Args[0])
                flag.PrintDefaults()
                fmt.Fprintf(flag.CommandLine.Output(), "\ne.g., on mac, to run all of the std go files except cmd which is large and slow:\npi -r -ex cmd /usr/local/Cellar/go/1.11.3/libexec/src\n\n")
        }

        // process command args
        flag.StringVar(&path, "path", "", "path to open; can be to a directory or a filename within the directory; or just last arg without a flag")
        flag.BoolVar(&recurse, "r", false, "recursive; apply to subdirectories")
        flag.StringVar(&excl, "ex", "", "comma-separated list of directory names to exclude, for recursive case")
        flag.Parse()
        if path == "" {
                if flag.NArg() > 0 {
                        path = flag.Arg(0)
                } else {
                        path = "."
                }
        }
        Excludes = strings.Split(excl, ",")

        // todo: assuming go for now
        if recurse {
                DoGoRecursive(path)
        } else {
                DoGoPath(path)
        }
}

func DoGoPath(path string) {
        fmt.Printf("Processing path: %v\n", path)
        lp, _ := parse.LanguageSupport.Properties(fileinfo.Go)
        pr := lp.Lang.Parser()
        pr.ReportErrs = true
        fs := parse.NewFileState()
        pkgsym := lp.Lang.ParseDir(fs, path, parse.LanguageDirOptions{Rebuild: true})
        if pkgsym != nil {
                syms.SaveSymDoc(pkgsym, fileinfo.Go, path)
        }
}

func DoGoRecursive(path string) {
        DoGoPath(path)
        drs := fsx.Dirs(path)
outer:
        for _, dr := range drs {
                if dr == "testdata" {
                        continue
                }
                for _, ex := range Excludes {
                        if dr == ex {
                                continue outer
                        }
                }
                sp := filepath.Join(path, dr)
                DoGoRecursive(sp)
        }
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Command update updates all of the .parse files within
// or beneath the current directory by opening and saving them.
package main

import (
        "io/fs"
        "path/filepath"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/text/parse"
)

func main() {
        errors.Log(filepath.Walk(".", func(path string, info fs.FileInfo, err error) error {
                if err != nil {
                        return err
                }
                if info.IsDir() {
                        return nil
                }
                if filepath.Ext(path) != ".parse" {
                        return nil
                }
                p := parse.NewParser()
                err = p.OpenJSON(path)
                if err != nil {
                        return err
                }
                return p.SaveJSON(path)
        }))
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package complete

import (
        "cmp"
        "path/filepath"
        "slices"
        "strings"
        "unicode"

        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/icons"
)

// Completion holds one potential completion
type Completion struct {

        // Text is the completion text: what will actually be inserted if selected.
        Text string

        // Label is the label text to show the user. It is only used if
        // non-empty; otherwise Text is used.
        Label string

        // Icon is the icon to render in core for the completion item.
        Icon icons.Icon

        // Desc is extra description information used in tooltips in core.
        Desc string
}

// Completions is a full list (slice) of completion options
type Completions []Completion

// Matches is used for passing completions around.
// contains seed in addition to completions
type Matches struct {

        // the matches based on seed
        Matches Completions

        // seed is the prefix we use to find possible completions
        Seed string
}

// Lookup is used for returning lookup results
type Lookup struct {

        // if non-empty, the result is to view this file (full path)
        Filename string

        // starting line number within file to display
        StLine int

        // ending line number within file
        EdLine int

        // if filename is empty, this is raw text to display for lookup result
        Text []byte
}

// SetFile sets file info
func (lk *Lookup) SetFile(fname string, st, ed int) {
        lk.Filename = fname
        lk.StLine = st
        lk.EdLine = ed
}

// Edit is returned from completion edit function
// to incorporate the selected completion
type Edit struct {

        // completion text after special edits
        NewText string

        // number of runes, past the cursor, to delete, if any
        ForwardDelete int

        // cursor adjustment if cursor should be placed in a location other than at end of newText
        CursorAdjust int
}

// MatchFunc is the function called to get the list of possible completions
// and also determines the correct seed based on the text
// passed as a parameter of CompletionFunc
type MatchFunc func(data any, text string, posLine, posChar int) Matches

// LookupFunc is the function called to get the lookup results for given
// input test and position.
type LookupFunc func(data any, text string, posLine, posChar int) Lookup

// EditFunc is passed the current text and the selected completion for text editing.
// Allows for other editing, e.g. adding "()" or adding "/", etc.
type EditFunc func(data any, text string, cursorPos int, comp Completion, seed string) Edit

// MatchSeedString returns a list of matches given a list of string
// possibilities and a seed. It checks whether different
// transformations of each possible completion contain a lowercase
// version of the seed. It returns nil if there are no matches.
func MatchSeedString(completions []string, seed string) []string {
        if len(seed) == 0 {
                // everything matches
                return completions
        }

        var matches []string
        lseed := strings.ToLower(seed)

        for _, c := range completions {
                if IsSeedMatching(lseed, c) {
                        matches = append(matches, c)
                }
        }
        slices.SortStableFunc(matches, func(a, b string) int {
                return cmp.Compare(MatchPrecedence(lseed, a), MatchPrecedence(lseed, b))
        })
        return matches
}

// MatchSeedCompletion returns a list of matches given a list of
// [Completion] possibilities and a seed. It checks whether different
// transformations of each possible completion contain a lowercase
// version of the seed. It returns nil if there are no matches.
func MatchSeedCompletion(completions []Completion, seed string) []Completion {
        if len(seed) == 0 {
                // everything matches
                return completions
        }

        var matches []Completion
        lseed := strings.ToLower(seed)

        for _, c := range completions {
                if IsSeedMatching(lseed, c.Text) {
                        matches = append(matches, c)
                }
        }
        slices.SortStableFunc(matches, func(a, b Completion) int {
                return cmp.Compare(MatchPrecedence(lseed, a.Text), MatchPrecedence(lseed, b.Text))
        })
        return matches
}

// IsSeedMatching returns whether the given lowercase seed matches
// the given completion string. It checks whether different
// transformations of the completion contain the lowercase
// version of the seed.
func IsSeedMatching(lseed string, completion string) bool {
        lc := strings.ToLower(completion)
        if strings.Contains(lc, lseed) {
                return true
        }

        // stripped version of completion
        // (space delimeted with no punctuation and symbols)
        cs := strings.Map(func(r rune) rune {
                if unicode.IsPunct(r) || unicode.IsSymbol(r) {
                        return -1
                }
                return r
        }, completion)
        cs = strcase.ToWordCase(cs, strcase.WordLowerCase, ' ')
        if strings.Contains(cs, lseed) {
                return true
        }

        // the initials (first letters) of every field
        ci := ""
        csdf := strings.Fields(cs)
        for _, f := range csdf {
                ci += string(f[0])
        }
        return strings.Contains(ci, lseed)
}

// MatchPrecedence returns the sorting precedence of the given
// completion relative to the given lowercase seed. The completion
// is assumed to already match the seed by [IsSeedMatching]. A
// lower return value indicates a higher precedence.
func MatchPrecedence(lseed string, completion string) int {
        lc := strings.ToLower(completion)
        if strings.HasPrefix(lc, lseed) {
                return 0
        }
        if len(lseed) > 0 && strings.HasPrefix(lc, lseed[:1]) {
                return 1
        }
        return 2
}

// SeedSpace returns the text after the last whitespace,
// which is typically used for creating a completion seed string.
func SeedSpace(text string) string {
        return SeedAfter(text, func(r rune) bool {
                return unicode.IsSpace(r)
        })
}

// SeedPath returns the text after the last whitespace and path/filepath
// separator, which is typically used for creating a completion seed string.
func SeedPath(text string) string {
        return SeedAfter(text, func(r rune) bool {
                return unicode.IsSpace(r) || r == '/' || r == filepath.Separator
        })
}

// SeedPath returns the text after the last rune for which the given
// function returns true, which is typically used for creating a completion
// seed string.
func SeedAfter(text string, f func(r rune) bool) string {
        seedStart := 0
        runes := []rune(text)
        for i := len(runes) - 1; i >= 0; i-- {
                r := runes[i]
                if f(r) {
                        seedStart = i + 1
                        break
                }
        }
        return string(runes[seedStart:])
}

// EditWord replaces the completion seed and any text up to the next whitespace with completion
func EditWord(text string, cursorPos int, completion string, seed string) (ed Edit) {
        s2 := string(text[cursorPos:])

        fd := 0 // number of characters past seed in word to be deleted (forward delete)
        r := rune(0)
        if len(s2) > 0 {
                for fd, r = range s2 {
                        if unicode.IsSpace(r) {
                                break
                        }
                }
        }
        if fd == len(s2)-1 { // last word case
                fd += 1
        }
        ed.NewText = completion
        ed.ForwardDelete = fd + len(seed)
        ed.CursorAdjust = 0
        return ed
}

// Code generated by "core generate -add-types"; DO NOT EDIT.

package parse

import (
        "cogentcore.org/core/enums"
)

var _LanguageFlagsValues = []LanguageFlags{0, 1, 2, 3}

// LanguageFlagsN is the highest valid value for type LanguageFlags, plus one.
const LanguageFlagsN LanguageFlags = 4

var _LanguageFlagsValueMap = map[string]LanguageFlags{`NoFlags`: 0, `IndentSpace`: 1, `IndentTab`: 2, `ReAutoIndent`: 3}

var _LanguageFlagsDescMap = map[LanguageFlags]string{0: `NoFlags = nothing special`, 1: `IndentSpace means that spaces must be used for this language`, 2: `IndentTab means that tabs must be used for this language`, 3: `ReAutoIndent causes current line to be re-indented during AutoIndent for Enter (newline) -- this should only be set for strongly indented languages where the previous + current line can tell you exactly what indent the current line should be at.`}

var _LanguageFlagsMap = map[LanguageFlags]string{0: `NoFlags`, 1: `IndentSpace`, 2: `IndentTab`, 3: `ReAutoIndent`}

// String returns the string representation of this LanguageFlags value.
func (i LanguageFlags) String() string { return enums.String(i, _LanguageFlagsMap) }

// SetString sets the LanguageFlags value from its string representation,
// and returns an error if the string is invalid.
func (i *LanguageFlags) SetString(s string) error {
        return enums.SetString(i, s, _LanguageFlagsValueMap, "LanguageFlags")
}

// Int64 returns the LanguageFlags value as an int64.
func (i LanguageFlags) Int64() int64 { return int64(i) }

// SetInt64 sets the LanguageFlags value from an int64.
func (i *LanguageFlags) SetInt64(in int64) { *i = LanguageFlags(in) }

// Desc returns the description of the LanguageFlags value.
func (i LanguageFlags) Desc() string { return enums.Desc(i, _LanguageFlagsDescMap) }

// LanguageFlagsValues returns all possible values for the type LanguageFlags.
func LanguageFlagsValues() []LanguageFlags { return _LanguageFlagsValues }

// Values returns all possible values for the type LanguageFlags.
func (i LanguageFlags) Values() []enums.Enum { return enums.Values(_LanguageFlagsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i LanguageFlags) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *LanguageFlags) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "LanguageFlags")
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package parse

import (
        "fmt"
        "path/filepath"
        "strings"
        "sync"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/parse/parser"
        "cogentcore.org/core/text/parse/syms"
)

// FileState contains the full lexing and parsing state information for a given file.
// It is the master state record for everything that happens in parse.  One of these
// should be maintained for each file; [lines.Lines] has one as parseState field.
//
// Separate State structs are maintained for each stage (Lexing, PassTwo, Parsing) and
// the final output of Parsing goes into the AST and Syms fields.
//
// The Src lexer.File field maintains all the info about the source file, and the basic
// tokenized version of the source produced initially by lexing and updated by the
// remaining passes.  It has everything that is maintained at a line-by-line level.
type FileState struct {

        // the source to be parsed -- also holds the full lexed tokens
        Src lexer.File `json:"-" xml:"-"`

        // state for lexing
        LexState lexer.State `json:"_" xml:"-"`

        // state for second pass nesting depth and EOS matching
        TwoState lexer.TwoState `json:"-" xml:"-"`

        // state for parsing
        ParseState parser.State `json:"-" xml:"-"`

        // ast output tree from parsing
        AST *parser.AST `json:"-" xml:"-"`

        // symbols contained within this file -- initialized at start of parsing and created by AddSymbol or PushNewScope actions.  These are then processed after parsing by the language-specific code, via Lang interface.
        Syms syms.SymMap `json:"-" xml:"-"`

        // External symbols that are entirely maintained in a language-specific way by the Lang interface code.  These are only here as a convenience and are not accessed in any way by the language-general parse code.
        ExtSyms syms.SymMap `json:"-" xml:"-"`

        // mutex protecting updates / reading of Syms symbols
        SymsMu sync.RWMutex `display:"-" json:"-" xml:"-"`

        // waitgroup for coordinating processing of other items
        WaitGp sync.WaitGroup `display:"-" json:"-" xml:"-"`

        // anonymous counter -- counts up
        AnonCtr int `display:"-" json:"-" xml:"-"`

        // path mapping cache -- for other files referred to by this file, this stores the full path associated with a logical path (e.g., in go, the logical import path -> local path with actual files) -- protected for access from any thread
        PathMap sync.Map `display:"-" json:"-" xml:"-"`
}

// Init initializes the file state
func (fs *FileState) Init() {
        // fmt.Println("fs init:", fs.Src.Filename)
        fs.AST = parser.NewAST()
        fs.LexState.Init()
        fs.TwoState.Init()
        fs.ParseState.Init(&fs.Src, fs.AST)
        fs.SymsMu.Lock()
        fs.Syms = make(syms.SymMap)
        fs.SymsMu.Unlock()
        fs.AnonCtr = 0
}

// NewFileState returns a new initialized file state
func NewFileState() *FileState {
        fs := &FileState{}
        fs.Init()
        return fs
}

func (fs *FileState) ClearAST() {
        fs.Syms.ClearAST()
        fs.ExtSyms.ClearAST()
}

func (fs *FileState) Destroy() {
        fs.ClearAST()
        fs.Syms = nil
        fs.ExtSyms = nil
        fs.AST.Destroy()
        fs.LexState.Init()
        fs.TwoState.Init()
        fs.ParseState.Destroy()
}

// SetSrc sets source to be parsed, and filename it came from, and also the
// base path for project for reporting filenames relative to
// (if empty, path to filename is used)
func (fs *FileState) SetSrc(src [][]rune, fname, basepath string, sup fileinfo.Known) {
        fs.Init()
        fs.Src.SetSrc(src, fname, basepath, sup)
        fs.LexState.Filename = fname
}

// LexAtEnd returns true if lexing state is now at end of source
func (fs *FileState) LexAtEnd() bool {
        return fs.LexState.Line >= fs.Src.NLines()
}

// LexLine returns the lexing output for given line, combining comments and all other tokens
// and allocating new memory using clone
func (fs *FileState) LexLine(ln int) lexer.Line {
        return fs.Src.LexLine(ln)
}

// LexLineString returns a string rep of the current lexing output for the current line
func (fs *FileState) LexLineString() string {
        return fs.LexState.LineString()
}

// LexNextSrcLine returns the next line of source that the lexer is currently at
func (fs *FileState) LexNextSrcLine() string {
        return fs.LexState.NextSrcLine()
}

// LexHasErrs returns true if there were errors from lexing
func (fs *FileState) LexHasErrs() bool {
        return len(fs.LexState.Errs) > 0
}

// LexErrReport returns a report of all the lexing errors -- these should only
// occur during development of lexer so we use a detailed report format
func (fs *FileState) LexErrReport() string {
        return fs.LexState.Errs.Report(0, fs.Src.BasePath, true, true)
}

// PassTwoHasErrs returns true if there were errors from pass two processing
func (fs *FileState) PassTwoHasErrs() bool {
        return len(fs.TwoState.Errs) > 0
}

// PassTwoErrString returns all the pass two errors as a string -- these should
// only occur during development so we use a detailed report format
func (fs *FileState) PassTwoErrReport() string {
        return fs.TwoState.Errs.Report(0, fs.Src.BasePath, true, true)
}

// ParseAtEnd returns true if parsing state is now at end of source
func (fs *FileState) ParseAtEnd() bool {
        return fs.ParseState.AtEofNext()
}

// ParseNextSrcLine returns the next line of source that the parser is currently at
func (fs *FileState) ParseNextSrcLine() string {
        return fs.ParseState.NextSrcLine()
}

// ParseHasErrs returns true if there were errors from parsing
func (fs *FileState) ParseHasErrs() bool {
        return len(fs.ParseState.Errs) > 0
}

// ParseErrReport returns at most 10 parsing errors in end-user format, sorted
func (fs *FileState) ParseErrReport() string {
        fs.ParseState.Errs.Sort()
        return fs.ParseState.Errs.Report(10, fs.Src.BasePath, true, false)
}

// ParseErrReportAll returns all parsing errors in end-user format, sorted
func (fs *FileState) ParseErrReportAll() string {
        fs.ParseState.Errs.Sort()
        return fs.ParseState.Errs.Report(0, fs.Src.BasePath, true, false)
}

// ParseErrReportDetailed returns at most 10 parsing errors in detailed format, sorted
func (fs *FileState) ParseErrReportDetailed() string {
        fs.ParseState.Errs.Sort()
        return fs.ParseState.Errs.Report(10, fs.Src.BasePath, true, true)
}

// RuleString returns the rule info for entire source -- if full
// then it includes the full stack at each point -- otherwise just the top
// of stack
func (fs *FileState) ParseRuleString(full bool) string {
        return fs.ParseState.RuleString(full)
}

////////////////////////////////////////////////////////////////////////
//  Syms symbol processing support

// FindNameScoped looks for given symbol name within given map first
// (if non nil) and then in fs.Syms and ExtSyms maps,
// and any children on those global maps that are of subcategory
// token.NameScope (i.e., namespace, module, package, library)
func (fs *FileState) FindNameScoped(nm string, scope syms.SymMap) (*syms.Symbol, bool) {
        var sy *syms.Symbol
        has := false
        if scope != nil {
                sy, has = scope.FindName(nm)
                if has {
                        return sy, true
                }
        }
        sy, has = fs.Syms.FindNameScoped(nm)
        if has {
                return sy, true
        }
        sy, has = fs.ExtSyms.FindNameScoped(nm)
        if has {
                return sy, true
        }
        return nil, false
}

// FindChildren fills out map with direct children of given symbol
// If seed is non-empty it is used as a prefix for filtering children names.
// Returns false if no children were found.
func (fs *FileState) FindChildren(sym *syms.Symbol, seed string, scope syms.SymMap, kids *syms.SymMap) bool {
        if len(sym.Children) == 0 {
                if sym.Type != "" {
                        typ, got := fs.FindNameScoped(sym.NonPtrTypeName(), scope)
                        if got {
                                sym = typ
                        } else {
                                return false
                        }
                }
        }
        if seed != "" {
                sym.Children.FindNamePrefix(seed, kids)
        } else {
                kids.CopyFrom(sym.Children, true) // src is newer
        }
        return len(*kids) > 0
}

// FindAnyChildren fills out map with either direct children of given symbol
// or those of the type of this symbol -- useful for completion.
// If seed is non-empty it is used as a prefix for filtering children names.
// Returns false if no children were found.
func (fs *FileState) FindAnyChildren(sym *syms.Symbol, seed string, scope syms.SymMap, kids *syms.SymMap) bool {
        if len(sym.Children) == 0 {
                if sym.Type != "" {
                        typ, got := fs.FindNameScoped(sym.NonPtrTypeName(), scope)
                        if got {
                                sym = typ
                        } else {
                                return false
                        }
                }
        }
        if seed != "" {
                sym.Children.FindNamePrefixRecursive(seed, kids)
        } else {
                kids.CopyFrom(sym.Children, true) // src is newer
        }
        return len(*kids) > 0
}

// FindNamePrefixScoped looks for given symbol name prefix within given map first
// (if non nil) and then in fs.Syms and ExtSyms maps,
// and any children on those global maps that are of subcategory
// token.NameScope (i.e., namespace, module, package, library)
// adds to given matches map (which can be nil), for more efficient recursive use
func (fs *FileState) FindNamePrefixScoped(seed string, scope syms.SymMap, matches *syms.SymMap) {
        lm := len(*matches)
        if scope != nil {
                scope.FindNamePrefixRecursive(seed, matches)
        }
        if len(*matches) != lm {
                return
        }
        fs.Syms.FindNamePrefixScoped(seed, matches)
        if len(*matches) != lm {
                return
        }
        fs.ExtSyms.FindNamePrefixScoped(seed, matches)
}

// NextAnonName returns the next anonymous name for this file, using counter here
// and given context name (e.g., package name)
func (fs *FileState) NextAnonName(ctxt string) string {
        fs.AnonCtr++
        fn := filepath.Base(fs.Src.Filename)
        ext := filepath.Ext(fn)
        if ext != "" {
                fn = strings.TrimSuffix(fn, ext)
        }
        return fmt.Sprintf("anon_%s_%d", ctxt, fs.AnonCtr)
}

// PathMapLoad does a mutex-protected load of PathMap for given string,
// returning value and true if found
func (fs *FileState) PathMapLoad(path string) (string, bool) {
        fabs, ok := fs.PathMap.Load(path)
        fs.PathMap.Load(path)
        if ok {
                return fabs.(string), ok
        }
        return "", ok
}

// PathMapStore does a mutex-protected store of abs path for given path key
func (fs *FileState) PathMapStore(path, abs string) {
        fs.PathMap.Store(path, abs)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package parse

import (
        "sync"

        "cogentcore.org/core/base/fileinfo"
)

// FileStates contains two FileState's: one is being processed while the
// other is being used externally.  The FileStates maintains
// a common set of file information set in each of the FileState items when
// they are used.
type FileStates struct {

        // the filename
        Filename string

        // the known file type, if known (typically only known files are processed)
        Known fileinfo.Known

        // base path for reporting file names -- this must be set externally e.g., by gide for the project root path
        BasePath string

        // index of the state that is done
        DoneIndex int

        // one filestate
        FsA FileState

        // one filestate
        FsB FileState

        // mutex locking the switching of Done vs. Proc states
        SwitchMu sync.Mutex

        // mutex locking the parsing of Proc state -- reading states can happen fine with this locked, but no switching
        ProcMu sync.Mutex

        // extra meta data associated with this FileStates
        Meta map[string]string
}

// NewFileStates returns a new FileStates for given filename, basepath,
// and known file type.
func NewFileStates(fname, basepath string, sup fileinfo.Known) *FileStates {
        fs := &FileStates{}
        fs.SetSrc(fname, basepath, sup)
        return fs
}

// SetSrc sets the source that is processed by this FileStates
// if basepath is empty then it is set to the path for the filename.
func (fs *FileStates) SetSrc(fname, basepath string, sup fileinfo.Known) {
        fs.ProcMu.Lock() // make sure processing is done
        defer fs.ProcMu.Unlock()
        fs.SwitchMu.Lock()
        defer fs.SwitchMu.Unlock()

        fs.Filename = fname
        fs.BasePath = basepath
        fs.Known = sup

        fs.FsA.SetSrc(nil, fname, basepath, sup)
        fs.FsB.SetSrc(nil, fname, basepath, sup)
}

// Done returns the filestate that is done being updated, and is ready for
// use by external clients etc.  Proc is the other one which is currently
// being processed by the parser and is not ready to be used externally.
// The state is accessed under a lock, and as long as any use of state is
// fast enough, it should be usable over next two switches (typically true).
func (fs *FileStates) Done() *FileState {
        fs.SwitchMu.Lock()
        defer fs.SwitchMu.Unlock()
        return fs.DoneNoLock()
}

// DoneNoLock returns the filestate that is done being updated, and is ready for
// use by external clients etc.  Proc is the other one which is currently
// being processed by the parser and is not ready to be used externally.
// The state is accessed under a lock, and as long as any use of state is
// fast enough, it should be usable over next two switches (typically true).
func (fs *FileStates) DoneNoLock() *FileState {
        switch fs.DoneIndex {
        case 0:
                return &fs.FsA
        case 1:
                return &fs.FsB
        }
        return &fs.FsA
}

// Proc returns the filestate that is currently being processed by
// the parser etc and is not ready for external use.
// Access is protected by a lock so it will wait if currently switching.
// The state is accessed under a lock, and as long as any use of state is
// fast enough, it should be usable over next two switches (typically true).
func (fs *FileStates) Proc() *FileState {
        fs.SwitchMu.Lock()
        defer fs.SwitchMu.Unlock()
        return fs.ProcNoLock()
}

// ProcNoLock returns the filestate that is currently being processed by
// the parser etc and is not ready for external use.
// Access is protected by a lock so it will wait if currently switching.
// The state is accessed under a lock, and as long as any use of state is
// fast enough, it should be usable over next two switches (typically true).
func (fs *FileStates) ProcNoLock() *FileState {
        switch fs.DoneIndex {
        case 0:
                return &fs.FsB
        case 1:
                return &fs.FsA
        }
        return &fs.FsB
}

// StartProc should be called when starting to process the file, and returns the
// FileState to use for processing.  It locks the Proc state, sets the current
// source code, and returns the filestate for subsequent processing.
func (fs *FileStates) StartProc(txt []byte) *FileState {
        fs.ProcMu.Lock()
        pfs := fs.ProcNoLock()
        pfs.Src.BasePath = fs.BasePath
        pfs.Src.SetBytes(txt)
        return pfs
}

// EndProc is called when primary processing (parsing) has been completed --
// there still may be ongoing updating of symbols after this point but parse
// is done.  This calls Switch to move Proc over to done, under cover of ProcMu Lock
func (fs *FileStates) EndProc() {
        fs.Switch()
        fs.ProcMu.Unlock()
}

// Switch switches so that the current Proc() filestate is now the Done()
// it is assumed to be called under ProcMu.Locking cover, and also
// does the Swtich locking.
func (fs *FileStates) Switch() {
        fs.SwitchMu.Lock()
        defer fs.SwitchMu.Unlock()
        fs.DoneIndex++
        fs.DoneIndex = fs.DoneIndex % 2
        // fmt.Printf("switched: %v  %v\n", fs.DoneIndex, fs.Filename)
}

// MetaData returns given meta data string for given key,
// returns true if present, false if not
func (fs *FileStates) MetaData(key string) (string, bool) {
        if fs.Meta == nil {
                return "", false
        }
        md, ok := fs.Meta[key]
        return md, ok
}

// SetMetaData sets given meta data record
func (fs *FileStates) SetMetaData(key, value string) {
        if fs.Meta == nil {
                fs.Meta = make(map[string]string)
        }
        fs.Meta[key] = value
}

// DeleteMetaData deletes given meta data record
func (fs *FileStates) DeleteMetaData(key string) {
        if fs.Meta == nil {
                return
        }
        delete(fs.Meta, key)
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Copied and only lightly modified from:
// https://github.com/nickng/bibtex
// Licensed under an Apache-2.0 license
// and presumably Copyright (c) 2017 by Nick Ng

package bibtex

import (
        "bytes"
        "fmt"
        "slices"
        "sort"
        "strconv"
        "strings"
        "text/tabwriter"
)

// BibString is a segment of a bib string.
type BibString interface {
        RawString() string // Internal representation.
        String() string    // Displayed string.
}

// BibVar is a string variable.
type BibVar struct {
        Key   string    // Variable key.
        Value BibString // Variable actual value.
}

// RawString is the internal representation of the variable.
func (v *BibVar) RawString() string {
        return v.Key
}

func (v *BibVar) String() string {
        if v == nil {
                return ""
        }
        return v.Value.String()
}

// BibConst is a string constant.
type BibConst string

// NewBibConst converts a constant string to BibConst.
func NewBibConst(c string) BibConst {
        return BibConst(c)
}

// RawString is the internal representation of the constant (i.e. the string).
func (c BibConst) RawString() string {
        return fmt.Sprintf("{%s}", string(c))
}

func (c BibConst) String() string {
        return string(c)
}

// BibComposite is a composite string, may contain both variable and string.
type BibComposite []BibString

// NewBibComposite creates a new composite with one element.
func NewBibComposite(s BibString) *BibComposite {
        comp := &BibComposite{}
        return comp.Append(s)
}

// Append adds a BibString to the composite
func (c *BibComposite) Append(s BibString) *BibComposite {
        comp := append(*c, s)
        return &comp
}

func (c *BibComposite) String() string {
        var buf bytes.Buffer
        for _, s := range *c {
                buf.WriteString(s.String())
        }
        return buf.String()
}

// RawString returns a raw (bibtex) representation of the composite string.
func (c *BibComposite) RawString() string {
        var buf bytes.Buffer
        for i, comp := range *c {
                if i > 0 {
                        buf.WriteString(" # ")
                }
                switch comp := comp.(type) {
                case *BibConst:
                        buf.WriteString(comp.RawString())
                case *BibVar:
                        buf.WriteString(comp.RawString())
                case *BibComposite:
                        buf.WriteString(comp.RawString())
                }
        }
        return buf.String()
}

// BibEntry is a record of BibTeX record.
type BibEntry struct {
        Type     string
        CiteName string
        Fields   map[string]BibString
}

// NewBibEntry creates a new BibTeX entry.
func NewBibEntry(entryType string, citeName string) *BibEntry {
        spaceStripper := strings.NewReplacer(" ", "")
        cleanedType := strings.ToLower(spaceStripper.Replace(entryType))
        cleanedName := spaceStripper.Replace(citeName)
        return &BibEntry{
                Type:     cleanedType,
                CiteName: cleanedName,
                Fields:   map[string]BibString{},
        }
}

// AddField adds a field (key-value) to a BibTeX entry.
func (entry *BibEntry) AddField(name string, value BibString) {
        entry.Fields[strings.TrimSpace(name)] = value
}

// BibTex is a list of BibTeX entries.
type BibTex struct {
        Preambles []BibString          // List of Preambles
        Entries   []*BibEntry          // Items in a bibliography.
        KeyMap    map[string]*BibEntry // fast key lookup map -- made on demand in Lookup
        StringVar map[string]*BibVar   // Map from string variable to string.
}

// NewBibTex creates a new BibTex data structure.
func NewBibTex() *BibTex {
        return &BibTex{
                Preambles: []BibString{},
                Entries:   []*BibEntry{},
                StringVar: make(map[string]*BibVar),
        }
}

// AddPreamble adds a preamble to a bibtex.
func (bib *BibTex) AddPreamble(p BibString) {
        bib.Preambles = append(bib.Preambles, p)
}

// AddEntry adds an entry to the BibTeX data structure.
func (bib *BibTex) AddEntry(entry *BibEntry) {
        bib.Entries = append(bib.Entries, entry)
}

// AddStringVar adds a new string var (if does not exist).
func (bib *BibTex) AddStringVar(key string, val BibString) {
        bib.StringVar[key] = &BibVar{Key: key, Value: val}
}

// SortEntries sorts entries by CiteName.
func (bib *BibTex) SortEntries() {
        slices.SortFunc(bib.Entries, func(a, b *BibEntry) int {
                return strings.Compare(a.CiteName, b.CiteName)
        })
}

// GetStringVar looks up a string by its key.
func (bib *BibTex) GetStringVar(key string) *BibVar {
        if bv, ok := bib.StringVar[key]; ok {
                return bv
        }
        // at this point, key is usually a month -- just pass through
        bib.AddStringVar(key, NewBibConst(key))
        return bib.StringVar[key]
}

// String returns a BibTex data structure as a simplified BibTex string.
func (bib *BibTex) String() string {
        var bibtex bytes.Buffer
        for _, entry := range bib.Entries {
                bibtex.WriteString(fmt.Sprintf("@%s{%s,\n", entry.Type, entry.CiteName))
                for key, val := range entry.Fields {
                        if i, err := strconv.Atoi(strings.TrimSpace(val.String())); err == nil {
                                bibtex.WriteString(fmt.Sprintf("  %s = %d,\n", key, i))
                        } else {
                                bibtex.WriteString(fmt.Sprintf("  %s = {%s},\n", key, strings.TrimSpace(val.String())))
                        }
                }
                bibtex.Truncate(bibtex.Len() - 2)
                bibtex.WriteString(fmt.Sprintf("\n}\n"))
        }
        return bibtex.String()
}

// RawString returns a BibTex data structure in its internal representation.
func (bib *BibTex) RawString() string {
        var bibtex bytes.Buffer
        for k, strvar := range bib.StringVar {
                bibtex.WriteString(fmt.Sprintf("@string{%s = {%s}}\n", k, strvar.String()))
        }
        for _, preamble := range bib.Preambles {
                bibtex.WriteString(fmt.Sprintf("@preamble{%s}\n", preamble.RawString()))
        }
        for _, entry := range bib.Entries {
                bibtex.WriteString(fmt.Sprintf("@%s{%s,\n", entry.Type, entry.CiteName))
                for key, val := range entry.Fields {
                        if i, err := strconv.Atoi(strings.TrimSpace(val.String())); err == nil {
                                bibtex.WriteString(fmt.Sprintf("  %s = %d,\n", key, i))
                        } else {
                                bibtex.WriteString(fmt.Sprintf("  %s = %s,\n", key, val.RawString()))
                        }
                }
                bibtex.Truncate(bibtex.Len() - 2)
                bibtex.WriteString(fmt.Sprintf("\n}\n"))
        }
        return bibtex.String()
}

// PrettyString pretty prints a BibTex.
func (bib *BibTex) PrettyString() string {
        var buf bytes.Buffer
        for i, entry := range bib.Entries {
                if i != 0 {
                        fmt.Fprint(&buf, "\n")
                }
                fmt.Fprintf(&buf, "@%s{%s,\n", entry.Type, entry.CiteName)

                // Determine key order.
                keys := []string{}
                for key := range entry.Fields {
                        keys = append(keys, key)
                }

                priority := map[string]int{"title": -3, "author": -2, "url": -1}
                sort.Slice(keys, func(i, j int) bool {
                        pi, pj := priority[keys[i]], priority[keys[j]]
                        return pi < pj || (pi == pj && keys[i] < keys[j])
                })

                // Write fields.
                tw := tabwriter.NewWriter(&buf, 1, 4, 1, ' ', 0)
                for _, key := range keys {
                        value := entry.Fields[key].String()
                        format := stringformat(value)
                        fmt.Fprintf(tw, "    %s\t=\t"+format+",\n", key, value)
                }
                tw.Flush()

                // Close.
                buf.WriteString("}\n")
        }
        return buf.String()

}

// stringformat determines the correct formatting verb for the given BibTeX field value.
func stringformat(v string) string {
        // Numbers may be represented unquoted.
        if _, err := strconv.Atoi(v); err == nil {
                return "%s"
        }

        // Strings with certain characters must be brace quoted.
        if strings.ContainsAny(v, "\"{}") {
                return "{%s}"
        }

        // Default to quoted string.
        return "%q"
}

// MakeKeyMap creates the KeyMap from CiteName to entry
func (bib *BibTex) MakeKeyMap() {
        bib.KeyMap = make(map[string]*BibEntry, len(bib.Entries))
        for _, be := range bib.Entries {
                bib.KeyMap[be.CiteName] = be
        }
}

// Lookup finds CiteName in entries, using fast KeyMap (made on demand)
// returns nil, false if not found
func (bib *BibTex) Lookup(cite string) (*BibEntry, bool) {
        if bib.KeyMap == nil {
                bib.MakeKeyMap()
        }
        be, has := bib.KeyMap[cite]
        return be, has
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Copied and only lightly modified from:
// https://github.com/nickng/bibtex
// Licensed under an Apache-2.0 license
// and presumably Copyright (c) 2017 by Nick Ng

package bibtex

import (
        __yyfmt__ "fmt"
        "io"
)

type bibTag struct {
        key string
        val BibString
}

var bib *BibTex // Only for holding current bib

type bibtexSymType struct {
        yys      int
        bibtex   *BibTex
        strval   string
        bibentry *BibEntry
        bibtag   *bibTag
        bibtags  []*bibTag
        strings  BibString
}

const COMMENT = 57346
const STRING = 57347
const PREAMBLE = 57348
const ATSIGN = 57349
const COLON = 57350
const EQUAL = 57351
const COMMA = 57352
const POUND = 57353
const LBRACE = 57354
const RBRACE = 57355
const DQUOTE = 57356
const LPAREN = 57357
const RPAREN = 57358
const BAREIDENT = 57359
const IDENT = 57360

var bibtexToknames = [...]string{
        "$end",
        "error",
        "$unk",
        "COMMENT",
        "STRING",
        "PREAMBLE",
        "ATSIGN",
        "COLON",
        "EQUAL",
        "COMMA",
        "POUND",
        "LBRACE",
        "RBRACE",
        "DQUOTE",
        "LPAREN",
        "RPAREN",
        "BAREIDENT",
        "IDENT",
}
var bibtexStatenames = [...]string{}

const bibtexEofCode = 1
const bibtexErrCode = 2
const bibtexInitialStackSize = 16

// Parse is the entry point to the bibtex parser.
func Parse(r io.Reader) (*BibTex, error) {
        l := NewLexer(r)
        bibtexParse(l)
        select {
        case err := <-l.Errors:
                return nil, err
        default:
                return bib, nil
        }
}

var bibtexExca = [...]int{
        -1, 1,
        1, -1,
        -2, 0,
}

const bibtexPrivate = 57344

const bibtexLast = 61

var bibtexAct = [...]int{

        22, 39, 40, 41, 9, 10, 11, 24, 23, 44,
        43, 27, 48, 26, 21, 20, 25, 8, 50, 28,
        29, 33, 33, 49, 18, 16, 38, 19, 17, 14,
        31, 12, 15, 42, 13, 30, 45, 46, 33, 33,
        52, 51, 48, 36, 33, 47, 37, 33, 35, 34,
        54, 53, 33, 7, 32, 4, 1, 6, 5, 3,
        2,
}
var bibtexPact = [...]int{

        -1000, -1000, 46, -1000, -1000, -1000, -1000, 0, 19, 17,
        13, 12, -2, -3, -10, -10, -4, -6, -10, -10,
        25, 20, 41, -1000, -1000, 36, 39, 34, 33, 10,
        -14, -14, -1000, -8, -1000, -10, -10, -1000, -1000, 32,
        -1000, 14, 2, -1000, -1000, 28, 27, -1000, -14, -10,
        -1000, -1000, -1000, -1000, 11,
}
var bibtexPgo = [...]int{

        0, 60, 59, 2, 58, 1, 0, 57, 56, 55,
}
var bibtexR1 = [...]int{

        0, 8, 1, 1, 1, 1, 1, 2, 2, 9,
        9, 4, 4, 7, 7, 6, 6, 6, 6, 3,
        3, 5, 5,
}
var bibtexR2 = [...]int{

        0, 1, 0, 2, 2, 2, 2, 7, 7, 5,
        5, 7, 7, 5, 5, 1, 1, 3, 3, 0,
        3, 1, 3,
}
var bibtexChk = [...]int{

        -1000, -8, -1, -2, -9, -4, -7, 7, 17, 4,
        5, 6, 12, 15, 12, 15, 12, 15, 12, 15,
        17, 17, -6, 18, 17, -6, 17, 17, -6, -6,
        10, 10, 13, 11, 13, 9, 9, 13, 16, -5,
        -3, 17, -5, 18, 17, -6, -6, 13, 10, 9,
        16, 13, 13, -3, -6,
}
var bibtexDef = [...]int{

        2, -2, 1, 3, 4, 5, 6, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 15, 16, 0, 0, 0, 0, 0,
        19, 19, 9, 0, 10, 0, 0, 13, 14, 0,
        21, 0, 0, 17, 18, 0, 0, 7, 19, 0,
        8, 11, 12, 22, 20,
}
var bibtexToken1 = [...]int{

        1,
}
var bibtexToken2 = [...]int{

        2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
        12, 13, 14, 15, 16, 17, 18,
}
var bibtexTokem3 = [...]int{
        0,
}

var bibtexErrorMessages = [...]struct {
        state int
        token int
        msg   string
}{}

/*        parser for yacc output        */

var (
        bibtexDebug        = 0
        bibtexErrorVerbose = false
)

type bibtexLexer interface {
        Lex(lval *bibtexSymType) int
        Error(s string)
}

type bibtexParser interface {
        Parse(bibtexLexer) int
        Lookahead() int
}

type bibtexParserImpl struct {
        lval  bibtexSymType
        stack [bibtexInitialStackSize]bibtexSymType
        char  int
}

func (p *bibtexParserImpl) Lookahead() int {
        return p.char
}

func bibtexNewParser() bibtexParser {
        return &bibtexParserImpl{}
}

const bibtexFlag = -1000

func bibtexTokname(c int) string {
        if c >= 1 && c-1 < len(bibtexToknames) {
                if bibtexToknames[c-1] != "" {
                        return bibtexToknames[c-1]
                }
        }
        return __yyfmt__.Sprintf("tok-%v", c)
}

func bibtexStatname(s int) string {
        if s >= 0 && s < len(bibtexStatenames) {
                if bibtexStatenames[s] != "" {
                        return bibtexStatenames[s]
                }
        }
        return __yyfmt__.Sprintf("state-%v", s)
}

func bibtexErrorMessage(state, lookAhead int) string {
        const TOKSTART = 4

        if !bibtexErrorVerbose {
                return "syntax error"
        }

        for _, e := range bibtexErrorMessages {
                if e.state == state && e.token == lookAhead {
                        return "syntax error: " + e.msg
                }
        }

        res := "syntax error: unexpected " + bibtexTokname(lookAhead)

        // To match Bison, suggest at most four expected tokens.
        expected := make([]int, 0, 4)

        // Look for shiftable tokens.
        base := bibtexPact[state]
        for tok := TOKSTART; tok-1 < len(bibtexToknames); tok++ {
                if n := base + tok; n >= 0 && n < bibtexLast && bibtexChk[bibtexAct[n]] == tok {
                        if len(expected) == cap(expected) {
                                return res
                        }
                        expected = append(expected, tok)
                }
        }

        if bibtexDef[state] == -2 {
                i := 0
                for bibtexExca[i] != -1 || bibtexExca[i+1] != state {
                        i += 2
                }

                // Look for tokens that we accept or reduce.
                for i += 2; bibtexExca[i] >= 0; i += 2 {
                        tok := bibtexExca[i]
                        if tok < TOKSTART || bibtexExca[i+1] == 0 {
                                continue
                        }
                        if len(expected) == cap(expected) {
                                return res
                        }
                        expected = append(expected, tok)
                }

                // If the default action is to accept or reduce, give up.
                if bibtexExca[i+1] != 0 {
                        return res
                }
        }

        for i, tok := range expected {
                if i == 0 {
                        res += ", expecting "
                } else {
                        res += " or "
                }
                res += bibtexTokname(tok)
        }
        return res
}

func bibtexlex1(lex bibtexLexer, lval *bibtexSymType) (char, token int) {
        token = 0
        char = lex.Lex(lval)
        if char <= 0 {
                token = bibtexToken1[0]
                goto out
        }
        if char < len(bibtexToken1) {
                token = bibtexToken1[char]
                goto out
        }
        if char >= bibtexPrivate {
                if char < bibtexPrivate+len(bibtexToken2) {
                        token = bibtexToken2[char-bibtexPrivate]
                        goto out
                }
        }
        for i := 0; i < len(bibtexTokem3); i += 2 {
                token = bibtexTokem3[i+0]
                if token == char {
                        token = bibtexTokem3[i+1]
                        goto out
                }
        }

out:
        if token == 0 {
                token = bibtexToken2[1] /* unknown char */
        }
        if bibtexDebug >= 3 {
                __yyfmt__.Printf("lex %s(%d)\n", bibtexTokname(token), uint(char))
        }
        return char, token
}

func bibtexParse(bibtexlex bibtexLexer) int {
        return bibtexNewParser().Parse(bibtexlex)
}

func (bibtexrcvr *bibtexParserImpl) Parse(bibtexlex bibtexLexer) int {
        var bibtexn int
        var bibtexVAL bibtexSymType
        var bibtexDollar []bibtexSymType
        _ = bibtexDollar // silence set and not used
        bibtexS := bibtexrcvr.stack[:]

        Nerrs := 0   /* number of errors */
        Errflag := 0 /* error recovery flag */
        bibtexstate := 0
        bibtexrcvr.char = -1
        bibtextoken := -1 // bibtexrcvr.char translated into internal numbering
        defer func() {
                // Make sure we report no lookahead when not parsing.
                bibtexstate = -1
                bibtexrcvr.char = -1
                bibtextoken = -1
        }()
        bibtexp := -1
        goto bibtexstack

ret0:
        return 0

ret1:
        return 1

bibtexstack:
        /* put a state and value onto the stack */
        if bibtexDebug >= 4 {
                __yyfmt__.Printf("char %v in %v\n", bibtexTokname(bibtextoken), bibtexStatname(bibtexstate))
        }

        bibtexp++
        if bibtexp >= len(bibtexS) {
                nyys := make([]bibtexSymType, len(bibtexS)*2)
                copy(nyys, bibtexS)
                bibtexS = nyys
        }
        bibtexS[bibtexp] = bibtexVAL
        bibtexS[bibtexp].yys = bibtexstate

bibtexnewstate:
        bibtexn = bibtexPact[bibtexstate]
        if bibtexn <= bibtexFlag {
                goto bibtexdefault /* simple state */
        }
        if bibtexrcvr.char < 0 {
                bibtexrcvr.char, bibtextoken = bibtexlex1(bibtexlex, &bibtexrcvr.lval)
        }
        bibtexn += bibtextoken
        if bibtexn < 0 || bibtexn >= bibtexLast {
                goto bibtexdefault
        }
        bibtexn = bibtexAct[bibtexn]
        if bibtexChk[bibtexn] == bibtextoken { /* valid shift */
                bibtexrcvr.char = -1
                bibtextoken = -1
                bibtexVAL = bibtexrcvr.lval
                bibtexstate = bibtexn
                if Errflag > 0 {
                        Errflag--
                }
                goto bibtexstack
        }

bibtexdefault:
        /* default state action */
        bibtexn = bibtexDef[bibtexstate]
        if bibtexn == -2 {
                if bibtexrcvr.char < 0 {
                        bibtexrcvr.char, bibtextoken = bibtexlex1(bibtexlex, &bibtexrcvr.lval)
                }

                /* look through exception table */
                xi := 0
                for {
                        if bibtexExca[xi+0] == -1 && bibtexExca[xi+1] == bibtexstate {
                                break
                        }
                        xi += 2
                }
                for xi += 2; ; xi += 2 {
                        bibtexn = bibtexExca[xi+0]
                        if bibtexn < 0 || bibtexn == bibtextoken {
                                break
                        }
                }
                bibtexn = bibtexExca[xi+1]
                if bibtexn < 0 {
                        goto ret0
                }
        }
        if bibtexn == 0 {
                /* error ... attempt to resume parsing */
                switch Errflag {
                case 0: /* brand new error */
                        bibtexlex.Error(bibtexErrorMessage(bibtexstate, bibtextoken))
                        Nerrs++
                        if bibtexDebug >= 1 {
                                __yyfmt__.Printf("%s", bibtexStatname(bibtexstate))
                                __yyfmt__.Printf(" saw %s\n", bibtexTokname(bibtextoken))
                        }
                        fallthrough

                case 1, 2: /* incompletely recovered error ... try again */
                        Errflag = 3

                        /* find a state where "error" is a legal shift action */
                        for bibtexp >= 0 {
                                bibtexn = bibtexPact[bibtexS[bibtexp].yys] + bibtexErrCode
                                if bibtexn >= 0 && bibtexn < bibtexLast {
                                        bibtexstate = bibtexAct[bibtexn] /* simulate a shift of "error" */
                                        if bibtexChk[bibtexstate] == bibtexErrCode {
                                                goto bibtexstack
                                        }
                                }

                                /* the current p has no shift on "error", pop stack */
                                if bibtexDebug >= 2 {
                                        __yyfmt__.Printf("error recovery pops state %d\n", bibtexS[bibtexp].yys)
                                }
                                bibtexp--
                        }
                        /* there is no state on the stack with an error shift ... abort */
                        goto ret1

                case 3: /* no shift yet; clobber input char */
                        if bibtexDebug >= 2 {
                                __yyfmt__.Printf("error recovery discards %s\n", bibtexTokname(bibtextoken))
                        }
                        if bibtextoken == bibtexEofCode {
                                goto ret1
                        }
                        bibtexrcvr.char = -1
                        bibtextoken = -1
                        goto bibtexnewstate /* try again in the same state */
                }
        }

        /* reduction by production bibtexn */
        if bibtexDebug >= 2 {
                __yyfmt__.Printf("reduce %v in:\n\t%v\n", bibtexn, bibtexStatname(bibtexstate))
        }

        bibtexnt := bibtexn
        bibtexpt := bibtexp
        _ = bibtexpt // guard against "declared and not used"

        bibtexp -= bibtexR2[bibtexn]
        // bibtexp is now the index of $0. Perform the default action. Iff the
        // reduced production is ε, $1 is possibly out of range.
        if bibtexp+1 >= len(bibtexS) {
                nyys := make([]bibtexSymType, len(bibtexS)*2)
                copy(nyys, bibtexS)
                bibtexS = nyys
        }
        bibtexVAL = bibtexS[bibtexp+1]

        /* consult goto table to find next state */
        bibtexn = bibtexR1[bibtexn]
        bibtexg := bibtexPgo[bibtexn]
        bibtexj := bibtexg + bibtexS[bibtexp].yys + 1

        if bibtexj >= bibtexLast {
                bibtexstate = bibtexAct[bibtexg]
        } else {
                bibtexstate = bibtexAct[bibtexj]
                if bibtexChk[bibtexstate] != -bibtexn {
                        bibtexstate = bibtexAct[bibtexg]
                }
        }
        // dummy call; replaced with literal code
        switch bibtexnt {

        case 1:
                bibtexDollar = bibtexS[bibtexpt-1 : bibtexpt+1]
                {
                }
        case 2:
                bibtexDollar = bibtexS[bibtexpt-0 : bibtexpt+1]
                {
                        bibtexVAL.bibtex = NewBibTex()
                        bib = bibtexVAL.bibtex
                }
        case 3:
                bibtexDollar = bibtexS[bibtexpt-2 : bibtexpt+1]
                {
                        bibtexVAL.bibtex = bibtexDollar[1].bibtex
                        bibtexVAL.bibtex.AddEntry(bibtexDollar[2].bibentry)
                }
        case 4:
                bibtexDollar = bibtexS[bibtexpt-2 : bibtexpt+1]
                {
                        bibtexVAL.bibtex = bibtexDollar[1].bibtex
                }
        case 5:
                bibtexDollar = bibtexS[bibtexpt-2 : bibtexpt+1]
                {
                        bibtexVAL.bibtex = bibtexDollar[1].bibtex
                        bibtexVAL.bibtex.AddStringVar(bibtexDollar[2].bibtag.key, bibtexDollar[2].bibtag.val)
                }
        case 6:
                bibtexDollar = bibtexS[bibtexpt-2 : bibtexpt+1]
                {
                        bibtexVAL.bibtex = bibtexDollar[1].bibtex
                        bibtexVAL.bibtex.AddPreamble(bibtexDollar[2].strings)
                }
        case 7:
                bibtexDollar = bibtexS[bibtexpt-7 : bibtexpt+1]
                {
                        bibtexVAL.bibentry = NewBibEntry(bibtexDollar[2].strval, bibtexDollar[4].strval)
                        for _, t := range bibtexDollar[6].bibtags {
                                bibtexVAL.bibentry.AddField(t.key, t.val)
                        }
                }
        case 8:
                bibtexDollar = bibtexS[bibtexpt-7 : bibtexpt+1]
                {
                        bibtexVAL.bibentry = NewBibEntry(bibtexDollar[2].strval, bibtexDollar[4].strval)
                        for _, t := range bibtexDollar[6].bibtags {
                                bibtexVAL.bibentry.AddField(t.key, t.val)
                        }
                }
        case 9:
                bibtexDollar = bibtexS[bibtexpt-5 : bibtexpt+1]
                {
                }
        case 10:
                bibtexDollar = bibtexS[bibtexpt-5 : bibtexpt+1]
                {
                }
        case 11:
                bibtexDollar = bibtexS[bibtexpt-7 : bibtexpt+1]
                {
                        bibtexVAL.bibtag = &bibTag{key: bibtexDollar[4].strval, val: bibtexDollar[6].strings}
                }
        case 12:
                bibtexDollar = bibtexS[bibtexpt-7 : bibtexpt+1]
                {
                        bibtexVAL.bibtag = &bibTag{key: bibtexDollar[4].strval, val: bibtexDollar[6].strings}
                }
        case 13:
                bibtexDollar = bibtexS[bibtexpt-5 : bibtexpt+1]
                {
                        bibtexVAL.strings = bibtexDollar[4].strings
                }
        case 14:
                bibtexDollar = bibtexS[bibtexpt-5 : bibtexpt+1]
                {
                        bibtexVAL.strings = bibtexDollar[4].strings
                }
        case 15:
                bibtexDollar = bibtexS[bibtexpt-1 : bibtexpt+1]
                {
                        bibtexVAL.strings = NewBibConst(bibtexDollar[1].strval)
                }
        case 16:
                bibtexDollar = bibtexS[bibtexpt-1 : bibtexpt+1]
                {
                        bibtexVAL.strings = bib.GetStringVar(bibtexDollar[1].strval)
                }
        case 17:
                bibtexDollar = bibtexS[bibtexpt-3 : bibtexpt+1]
                {
                        bibtexVAL.strings = NewBibComposite(bibtexDollar[1].strings)
                        bibtexVAL.strings.(*BibComposite).Append(NewBibConst(bibtexDollar[3].strval))
                }
        case 18:
                bibtexDollar = bibtexS[bibtexpt-3 : bibtexpt+1]
                {
                        bibtexVAL.strings = NewBibComposite(bibtexDollar[1].strings)
                        bibtexVAL.strings.(*BibComposite).Append(bib.GetStringVar(bibtexDollar[3].strval))
                }
        case 19:
                bibtexDollar = bibtexS[bibtexpt-0 : bibtexpt+1]
                {
                }
        case 20:
                bibtexDollar = bibtexS[bibtexpt-3 : bibtexpt+1]
                {
                        bibtexVAL.bibtag = &bibTag{key: bibtexDollar[1].strval, val: bibtexDollar[3].strings}
                }
        case 21:
                bibtexDollar = bibtexS[bibtexpt-1 : bibtexpt+1]
                {
                        bibtexVAL.bibtags = []*bibTag{bibtexDollar[1].bibtag}
                }
        case 22:
                bibtexDollar = bibtexS[bibtexpt-3 : bibtexpt+1]
                {
                        if bibtexDollar[3].bibtag == nil {
                                bibtexVAL.bibtags = bibtexDollar[1].bibtags
                        } else {
                                bibtexVAL.bibtags = append(bibtexDollar[1].bibtags, bibtexDollar[3].bibtag)
                        }
                }
        }
        goto bibtexstack /* stack new state and value */
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Copied and only lightly modified from:
// https://github.com/nickng/bibtex
// Licensed under an Apache-2.0 license
// and presumably Copyright (c) 2017 by Nick Ng

package bibtex

import (
        "errors"
        "fmt"
)

var (
        // ErrUnexpectedAtsign is an error for unexpected @ in {}.
        ErrUnexpectedAtsign = errors.New("Unexpected @ sign")
        // ErrUnknownStringVar is an error for looking up undefined string var.
        ErrUnknownStringVar = errors.New("Unknown string variable")
)

// ErrParse is a parse error.
type ErrParse struct {
        Pos TokenPos
        Err string // Error string returned from parser.
}

func (e *ErrParse) Error() string {
        return fmt.Sprintf("Parse failed at %s: %s", e.Pos, e.Err)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bibtex

import (
        "errors"
        "fmt"
        "os"
        "path/filepath"
        "time"
)

// File maintains a record for an bibtex file
type File struct {

        // file name -- full path
        File string

        // bibtex data loaded from file
        BibTex *BibTex

        // mod time for loaded bibfile -- to detect updates
        Mod time.Time
}

// FullPath returns full path to given bibtex file,
// looking on standard BIBINPUTS or TEXINPUTS env var paths if not found locally.
func FullPath(fname string) (string, error) {
        _, err := os.Stat(fname)
        path := fname
        nfErr := fmt.Errorf("bibtex file not found, even on BIBINPUTS or TEXINPUTS paths: %s", fname)
        if os.IsNotExist(err) {
                bin := os.Getenv("BIBINPUTS")
                if bin == "" {
                        bin = os.Getenv("TEXINPUTS")
                }
                if bin == "" {
                        return "", errors.New("BIBINPUTS and TEXINPUTS variables are empty")
                }
                pth := filepath.SplitList(bin)
                got := false
                for _, p := range pth {
                        bf := filepath.Join(p, fname)
                        _, err = os.Stat(bf)
                        if err == nil {
                                path = bf
                                got = true
                                break
                        }
                }
                if !got {
                        return "", nfErr
                }
        }
        path, err = filepath.Abs(path)
        if err != nil {
                return path, err
        }
        return path, nil
}

// Open [re]opens the given filename, looking on standard BIBINPUTS or TEXINPUTS
// env var paths if not found locally.  If Mod >= mod timestamp on the file,
// and BibTex is already loaded, then nothing happens (already have it), but
// otherwise it parses the file and puts contents in BibTex field.
func (fl *File) Open(fname string) error {
        path := fname
        var err error
        if fl.File == "" {
                path, err = FullPath(fname)
                if err != nil {
                        return err
                }
                fl.File = path
                fl.BibTex = nil
                fl.Mod = time.Time{}
                // fmt.Printf("first open file: %s path: %s\n", fname, fl.File)
        }
        st, err := os.Stat(fl.File)
        if err != nil {
                return err
        }
        if fl.BibTex != nil && !fl.Mod.Before(st.ModTime()) {
                // fmt.Printf("existing file: %v is fine: file mod: %v  last mod: %v\n", fl.File, st.ModTime(), fl.Mod)
                return nil
        }
        f, err := os.Open(fl.File)
        if err != nil {
                return err
        }
        defer f.Close()
        parsed, err := Parse(f)
        if err != nil {
                err = fmt.Errorf("Bibtex bibliography: %s not loaded due to error(s):\n%v", fl.File, err)
                return err
        }
        fl.BibTex = parsed
        fl.Mod = st.ModTime()
        // fmt.Printf("(re)loaded bibtex bibliography: %s\n", fl.File)
        return nil
}

//////// Files

// Files is a map of bibtex files
type Files map[string]*File

// Open [re]opens the given filename, looking on standard BIBINPUTS or TEXINPUTS
// env var paths if not found locally.  If Mod >= mod timestamp on the file,
// and BibTex is already loaded, then nothing happens (already have it), but
// otherwise it parses the file and puts contents in BibTex field.
func (fl *Files) Open(fname string) (*File, error) {
        if *fl == nil {
                *fl = make(Files)
        }
        fr, has := (*fl)[fname]
        if has {
                err := fr.Open(fname)
                return fr, err
        }
        fr = &File{}
        err := fr.Open(fname)
        if err != nil {
                return nil, err
        }
        (*fl)[fname] = fr
        return fr, nil
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Copied and only lightly modified from:
// https://github.com/nickng/bibtex
// Licensed under an Apache-2.0 license
// and presumably Copyright (c) 2017 by Nick Ng

//go:generate goyacc -p bibtex -o bibtex.y.go bibtex.y

package bibtex

import "io"

// Lexer for bibtex.
type Lexer struct {
        scanner *Scanner
        Errors  chan error
}

// NewLexer returns a new yacc-compatible lexer.
func NewLexer(r io.Reader) *Lexer {
        return &Lexer{scanner: NewScanner(r), Errors: make(chan error, 1)}
}

// Lex is provided for yacc-compatible parser.
func (l *Lexer) Lex(yylval *bibtexSymType) int {
        token, strval := l.scanner.Scan()
        yylval.strval = strval
        return int(token)
}

// Error handles error.
func (l *Lexer) Error(err string) {
        l.Errors <- &ErrParse{Err: err, Pos: l.scanner.pos}
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Copied and only lightly modified from:
// https://github.com/nickng/bibtex
// Licensed under an Apache-2.0 license
// and presumably Copyright (c) 2017 by Nick Ng

package bibtex

import (
        "bufio"
        "bytes"
        "io"
        "strconv"
        "strings"
)

var parseField bool

// Scanner is a lexical scanner
type Scanner struct {
        r   *bufio.Reader
        pos TokenPos
}

// NewScanner returns a new instance of Scanner.
func NewScanner(r io.Reader) *Scanner {
        return &Scanner{r: bufio.NewReader(r), pos: TokenPos{Char: 0, Lines: []int{}}}
}

// read reads the next rune from the buffered reader.
// Returns the rune(0) if an error occurs (or io.eof is returned).
func (s *Scanner) read() rune {
        ch, _, err := s.r.ReadRune()
        if err != nil {
                return eof
        }
        if ch == '\n' {
                s.pos.Lines = append(s.pos.Lines, s.pos.Char)
                s.pos.Char = 0
        } else {
                s.pos.Char++
        }
        return ch
}

// unread places the previously read rune back on the reader.
func (s *Scanner) unread() {
        _ = s.r.UnreadRune()
        if s.pos.Char == 0 {
                s.pos.Char = s.pos.Lines[len(s.pos.Lines)-1]
                s.pos.Lines = s.pos.Lines[:len(s.pos.Lines)-1]
        } else {
                s.pos.Char--
        }
}

// Scan returns the next token and literal value.
func (s *Scanner) Scan() (tok Token, lit string) {
        ch := s.read()
        if isWhitespace(ch) {
                s.ignoreWhitespace()
                ch = s.read()
        }
        if isAlphanum(ch) {
                s.unread()
                return s.scanIdent()
        }
        switch ch {
        case eof:
                return 0, ""
        case '@':
                return ATSIGN, string(ch)
        case ':':
                return COLON, string(ch)
        case ',':
                parseField = false // reset parseField if reached end of field.
                return COMMA, string(ch)
        case '=':
                parseField = true // set parseField if = sign outside quoted or ident.
                return EQUAL, string(ch)
        case '"':
                return s.scanQuoted()
        case '{':
                if parseField {
                        return s.scanBraced()
                }
                return LBRACE, string(ch)
        case '}':
                if parseField { // reset parseField if reached end of entry.
                        parseField = false
                }
                return RBRACE, string(ch)
        case '#':
                return POUND, string(ch)
        case ' ':
                s.ignoreWhitespace()
        }
        return ILLEGAL, string(ch)
}

// scanIdent categorises a string to one of three categories.
func (s *Scanner) scanIdent() (tok Token, lit string) {
        switch ch := s.read(); ch {
        case '"':
                return s.scanQuoted()
        case '{':
                return s.scanBraced()
        default:
                s.unread() // Not open quote/brace.
                return s.scanBare()
        }
}

func (s *Scanner) scanBare() (Token, string) {
        var buf bytes.Buffer
        for {
                ch := s.read()
                if ch == eof {
                        break
                }
                if !isAlphanum(ch) && !isBareSymbol(ch) || isWhitespace(ch) {
                        s.unread()
                        break
                }
                _, _ = buf.WriteRune(ch)
        }
        str := buf.String()
        if strings.ToLower(str) == "comment" {
                return COMMENT, str
        } else if strings.ToLower(str) == "preamble" {
                return PREAMBLE, str
        } else if strings.ToLower(str) == "string" {
                return STRING, str
        } else if _, err := strconv.Atoi(str); err == nil && parseField { // Special case for numeric
                return IDENT, str
        }
        return BAREIDENT, str
}

// scanBraced parses a braced string, like {this}.
func (s *Scanner) scanBraced() (Token, string) {
        var buf bytes.Buffer
        var macro bool
        brace := 1
        for {
                if ch := s.read(); ch == eof {
                        break
                } else if ch == '\\' {
                        _, _ = buf.WriteRune(ch)
                        macro = true
                } else if ch == '{' {
                        _, _ = buf.WriteRune(ch)
                        brace++
                } else if ch == '}' {
                        brace--
                        macro = false
                        if brace == 0 { // Balances open brace.
                                return IDENT, buf.String()
                        }
                        _, _ = buf.WriteRune(ch)
                } else if ch == '@' {
                        if macro {
                                _, _ = buf.WriteRune(ch)
                                // } else {
                                //         log.Printf("%s: %s", ErrUnexpectedAtsign, buf.String())
                        }
                } else if isWhitespace(ch) {
                        _, _ = buf.WriteRune(ch)
                        macro = false
                } else {
                        _, _ = buf.WriteRune(ch)
                }
        }
        return ILLEGAL, buf.String()
}

// scanQuoted parses a quoted string, like "this".
func (s *Scanner) scanQuoted() (Token, string) {
        var buf bytes.Buffer
        brace := 0
        for {
                if ch := s.read(); ch == eof {
                        break
                } else if ch == '{' {
                        brace++
                } else if ch == '}' {
                        brace--
                } else if ch == '"' {
                        if brace == 0 { // Matches open quote, unescaped
                                return IDENT, buf.String()
                        }
                        _, _ = buf.WriteRune(ch)
                } else {
                        _, _ = buf.WriteRune(ch)
                }
        }
        return ILLEGAL, buf.String()
}

// ignoreWhitespace consumes the current rune and all contiguous whitespace.
func (s *Scanner) ignoreWhitespace() {
        for {
                if ch := s.read(); ch == eof {
                        break
                } else if !isWhitespace(ch) {
                        s.unread()
                        break
                }
        }
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Copied and only lightly modified from:
// https://github.com/nickng/bibtex
// Licensed under an Apache-2.0 license
// and presumably Copyright (c) 2017 by Nick Ng

package bibtex

import (
        "fmt"
        "strings"
)

// Lexer token.
type Token int

const (
        // ILLEGAL stands for an invalid token.
        ILLEGAL Token = iota
)

var eof = rune(0)

// TokenPos is a pair of coordinate to identify start of token.
type TokenPos struct {
        Char  int
        Lines []int
}

func (p TokenPos) String() string {
        return fmt.Sprintf("%d:%d", len(p.Lines)+1, p.Char)
}

func isWhitespace(ch rune) bool {
        return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'
}

func isAlpha(ch rune) bool {
        return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')
}

func isDigit(ch rune) bool {
        return ('0' <= ch && ch <= '9')
}

func isAlphanum(ch rune) bool {
        return isAlpha(ch) || isDigit(ch)
}

func isBareSymbol(ch rune) bool {
        return strings.ContainsRune("-_:./+", ch)
}

// isSymbol returns true if ch is a valid symbol
func isSymbol(ch rune) bool {
        return strings.ContainsRune("!?&*+-./:;<>[]^_`|~@", ch)
}

func isOpenQuote(ch rune) bool {
        return ch == '{' || ch == '"'
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        "strings"
        "unsafe"

        "cogentcore.org/core/icons"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/parse/syms"
)

var BuiltinTypes syms.TypeMap

// InstallBuiltinTypes initializes the BuiltinTypes map
func InstallBuiltinTypes() {
        if len(BuiltinTypes) != 0 {
                return
        }
        for _, tk := range BuiltinTypeKind {
                ty := syms.NewType(tk.Name, tk.Kind)
                ty.Size = []int{tk.Size}
                BuiltinTypes.Add(ty)
        }
}

func (gl *GoLang) CompleteBuiltins(fs *parse.FileState, seed string, md *complete.Matches) {
        for _, tk := range BuiltinTypeKind {
                if strings.HasPrefix(tk.Name, seed) {
                        c := complete.Completion{Text: tk.Name, Label: tk.Name, Icon: icons.Type}
                        md.Matches = append(md.Matches, c)
                }
        }
        for _, bs := range BuiltinMisc {
                if strings.HasPrefix(bs, seed) {
                        c := complete.Completion{Text: bs, Label: bs, Icon: icons.Variable}
                        md.Matches = append(md.Matches, c)
                }
        }
        for _, bs := range BuiltinFuncs {
                if strings.HasPrefix(bs, seed) {
                        bs = bs + "()"
                        c := complete.Completion{Text: bs, Label: bs, Icon: icons.Function}
                        md.Matches = append(md.Matches, c)
                }
        }
        for _, bs := range BuiltinPackages {
                if strings.HasPrefix(bs, seed) {
                        c := complete.Completion{Text: bs, Label: bs, Icon: icons.Type} // todo: was types
                        md.Matches = append(md.Matches, c)
                }
        }
        for _, bs := range BuiltinKeywords {
                if strings.HasPrefix(bs, seed) {
                        c := complete.Completion{Text: bs, Label: bs, Icon: icons.Constant}
                        md.Matches = append(md.Matches, c)
                }
        }
}

// BuiltinTypeKind are the type names and kinds for builtin Go primitive types
// (i.e., those with names)
var BuiltinTypeKind = []syms.TypeKindSize{
        {"int", syms.Int, int(unsafe.Sizeof(int(0)))},
        {"int8", syms.Int8, 1},
        {"int16", syms.Int16, 2},
        {"int32", syms.Int32, 4},
        {"int64", syms.Int64, 8},

        {"uint", syms.Uint, int(unsafe.Sizeof(uint(0)))},
        {"uint8", syms.Uint8, 1},
        {"uint16", syms.Uint16, 2},
        {"uint32", syms.Uint32, 4},
        {"uint64", syms.Uint64, 8},
        {"uintptr", syms.Uintptr, 8},

        {"byte", syms.Uint8, 1},
        {"rune", syms.Int32, 4},

        {"float32", syms.Float32, 4},
        {"float64", syms.Float64, 8},

        {"complex64", syms.Complex64, 8},
        {"complex128", syms.Complex128, 16},

        {"bool", syms.Bool, 1},

        {"string", syms.String, 0},

        {"error", syms.Interface, 0},

        {"struct{}", syms.Struct, 0},
        {"interface{}", syms.Interface, 0},
}

// BuiltinMisc are misc builtin items
var BuiltinMisc = []string{
        "true",
        "false",
}

// BuiltinFuncs are functions builtin to the Go language
var BuiltinFuncs = []string{
        "append",
        "copy",
        "delete",
        "len",
        "cap",
        "make",
        "new",
        "complex",
        "real",
        "imag",
        "close",
        "panic",
        "recover",
}

// BuiltinKeywords are keywords built into Go -- for, range, etc
var BuiltinKeywords = []string{
        "break",
        "case",
        "chan",
        "const",
        "continue",
        "default",
        "defer",
        "else",
        "fallthrough",
        "for",
        "func",
        "go",
        "goto",
        "if",
        "import",
        "interface",
        "map",
        "package",
        "range",
        "return",
        "select",
        "struct",
        "switch",
        "type",
        "var",
}

// BuiltinPackages are the standard library packages
var BuiltinPackages = []string{
        "bufio",
        "bytes",
        "context",
        "crypto",
        "compress",
        "encoding",
        "errors",
        "expvar",
        "flag",
        "fmt",
        "hash",
        "html",
        "image",
        "io",
        "log",
        "math",
        "mime",
        "net",
        "os",
        "path",
        "plugin",
        "reflect",
        "regexp",
        "runtime",
        "sort",
        "strconv",
        "strings",
        "sync",
        "syscall",
        "testing",
        "time",
        "unicode",
        "unsafe",
        "tar",
        "zip",
        "bzip2",
        "flate",
        "gzip",
        "lzw",
        "zlib",
        "heap",
        "list",
        "ring",
        "aes",
        "cipher",
        "des",
        "dsa",
        "ecdsa",
        "ed25519",
        "elliptic",
        "hmac",
        "md5",
        "rc4",
        "rsa",
        "sha1",
        "sha256",
        "sha512",
        "tls",
        "x509",
        "sql",
        "ascii85",
        "asn1",
        "base32",
        "base64",
        "binary",
        "csv",
        "gob",
        "hex",
        "json",
        "pem",
        "xml",
        "ast",
        "build",
        "constant",
        "doc",
        "format",
        "importer",
        "parser",
        "printer",
        "scanner",
        "token",
        "types",
        "adler32",
        "crc32",
        "crc64",
        "fnv",
        "template",
        "color",
        "draw",
        "gif",
        "jpeg",
        "png",
        "suffixarray",
        "ioutil",
        "syslog",
        "big",
        "bits",
        "cmplx",
        "rand",
        "multipart",
        "quotedprintable",
        "http",
        "cookiejar",
        "cgi",
        "httptrace",
        "httputil",
        "pprof",
        "socktest",
        "mail",
        "rpc",
        "jsonrpc",
        "smtp",
        "textproto",
        "url",
        "exec",
        "signal",
        "user",
        "filepath",
        "syntax",
        "cgo",
        "debug",
        "atomic",
        "math",
        "sys",
        "msan",
        "race",
        "trace",
        "atomic",
        "js",
        "scanner",
        "tabwriter",
        "template",
        "utf16",
        "utf8",
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        "fmt"
        "os"
        "path/filepath"
        "strings"
        "unicode"

        "cogentcore.org/core/icons"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/parse/parser"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
        "cogentcore.org/core/tree"
)

var CompleteTrace = false

// Lookup is the main api called by completion code in giv/complete.go to lookup item
func (gl *GoLang) Lookup(fss *parse.FileStates, str string, pos textpos.Pos) (ld complete.Lookup) {
        if str == "" {
                return
        }
        origStr := str
        str = lexer.LastScopedString(str)
        if len(str) == 0 {
                return
        }
        fs := fss.Done()
        if len(fs.ParseState.Scopes) == 0 {
                return // need a package
        }

        fs.SymsMu.RLock()
        defer fs.SymsMu.RUnlock()

        pr := gl.Parser()
        if pr == nil {
                return
        }
        fpath, _ := filepath.Abs(fs.Src.Filename)

        if CompleteTrace {
                fmt.Printf("lookup str:  %v  orig: %v\n", str, origStr)
        }
        lfs := pr.ParseString(str, fpath, fs.Src.Known)
        if lfs == nil {
                return
        }

        if CompleteTrace {
                lfs.ParseState.AST.WriteTree(os.Stdout, 0)
                lfs.LexState.Errs.Report(20, "", true, true)
                lfs.ParseState.Errs.Report(20, "", true, true)
        }

        var scopes syms.SymMap // scope(s) for position, fname
        scope := gl.CompletePosScope(fs, pos, fpath, &scopes)

        start, last := gl.CompleteASTStart(lfs.ParseState.AST, scope)
        if CompleteTrace {
                if start == nil {
                        fmt.Printf("start = nil\n")
                        return
                }
                fmt.Printf("\n####################\nlookup start in scope: %v\n", scope)
                lfs.ParseState.AST.WriteTree(os.Stdout, 0)
                fmt.Printf("Start tree:\n")
                start.WriteTree(os.Stdout, 0)
        }

        pkg := fs.ParseState.Scopes[0]
        start.SrcReg.Start = pos

        if start == last { // single-item
                seed := start.Src
                if seed != "" {
                        return gl.LookupString(fs, pkg, scopes, seed)
                }
                return gl.LookupString(fs, pkg, scopes, str)
        }

        typ, nxt, got := gl.TypeFromASTExprStart(fs, pkg, pkg, start)
        lststr := ""
        if nxt != nil {
                lststr = nxt.Src
        }
        if got {
                if lststr != "" {
                        for _, mt := range typ.Meths {
                                nm := mt.Name
                                if !strings.HasPrefix(nm, lststr) {
                                        continue
                                }
                                if mt.Filename != "" {
                                        ld.SetFile(mt.Filename, mt.Region.Start.Line, mt.Region.End.Line)
                                        return
                                }
                        }
                }
                // fmt.Printf("got lookup type: %v, last str: %v\n", typ.String(), lststr)
                ld.SetFile(typ.Filename, typ.Region.Start.Line, typ.Region.End.Line)
                return
        }
        // see if it starts with a package name..
        snxt := start.NextAST()
        lststr = last.Src
        if snxt != nil && snxt.Src != "" {
                ststr := snxt.Src
                if lststr != "" && lststr != ststr {
                        ld = gl.LookupString(fs, pkg, nil, ststr+"."+lststr)
                } else {
                        ld = gl.LookupString(fs, pkg, nil, ststr)
                }
        } else {
                ld = gl.LookupString(fs, pkg, scopes, lststr)
        }
        if ld.Filename == "" { // didn't work
                ld = gl.LookupString(fs, pkg, scopes, str)
        }
        return
}

// CompleteLine is the main api called by completion code in giv/complete.go
func (gl *GoLang) CompleteLine(fss *parse.FileStates, str string, pos textpos.Pos) (md complete.Matches) {
        if str == "" {
                return
        }
        origStr := str
        str = lexer.LastScopedString(str)
        if len(str) > 0 {
                lstchr := str[len(str)-1]
                mbrace, right := lexer.BracePair(rune(lstchr))
                if mbrace != 0 && right { // don't try to match after closing expr
                        return
                }
        }

        fs := fss.Done()
        if len(fs.ParseState.Scopes) == 0 {
                return // need a package
        }

        fs.SymsMu.RLock()
        defer fs.SymsMu.RUnlock()

        pr := gl.Parser()
        if pr == nil {
                return
        }
        fpath, _ := filepath.Abs(fs.Src.Filename)

        if CompleteTrace {
                fmt.Printf("complete str:  %v  orig: %v\n", str, origStr)
        }
        lfs := pr.ParseString(str, fpath, fs.Src.Known)
        if lfs == nil {
                return
        }

        if CompleteTrace {
                lfs.ParseState.AST.WriteTree(os.Stdout, 0)
                lfs.LexState.Errs.Report(20, "", true, true)
                lfs.ParseState.Errs.Report(20, "", true, true)
        }

        var scopes syms.SymMap // scope(s) for position, fname
        scope := gl.CompletePosScope(fs, pos, fpath, &scopes)

        start, last := gl.CompleteASTStart(lfs.ParseState.AST, scope)
        if CompleteTrace {
                if start == nil {
                        fmt.Printf("start = nil\n")
                        return
                }
                fmt.Printf("\n####################\ncompletion start in scope: %v\n", scope)
                lfs.ParseState.AST.WriteTree(os.Stdout, 0)
                fmt.Printf("Start tree:\n")
                start.WriteTree(os.Stdout, 0)
        }

        pkg := fs.ParseState.Scopes[0]
        start.SrcReg.Start = pos

        if start == last { // single-item
                seed := start.Src
                if CompleteTrace {
                        fmt.Printf("start == last: %v\n", seed)
                }
                md.Seed = seed
                if start.Name == "TypeNm" {
                        gl.CompleteTypeName(fs, pkg, seed, &md)
                        return
                }
                if len(scopes) > 0 {
                        syms.AddCompleteSymsPrefix(scopes, "", seed, &md)
                }
                gl.CompletePkgSyms(fs, pkg, seed, &md)
                gl.CompleteBuiltins(fs, seed, &md)
                return
        }

        typ, nxt, got := gl.TypeFromASTExprStart(fs, pkg, pkg, start)
        lststr := ""
        if nxt != nil {
                lststr = nxt.Src
        }
        if got && typ != nil {
                // fmt.Printf("got completion type: %v, last str: %v\n", typ.String(), lststr)
                syms.AddCompleteTypeNames(typ, typ.Name, lststr, &md)
        } else {
                // see if it starts with a package name..
                // todo: move this to a function as in lookup
                snxt := start.NextAST()
                if snxt != nil && snxt.Src != "" {
                        ststr := snxt.Src
                        psym, has := gl.PkgSyms(fs, pkg.Children, ststr)
                        if has {
                                lststr := last.Src
                                if lststr != "" && lststr != ststr {
                                        var matches syms.SymMap
                                        psym.Children.FindNamePrefixScoped(lststr, &matches)
                                        syms.AddCompleteSyms(matches, ststr, &md)
                                        md.Seed = lststr
                                } else {
                                        syms.AddCompleteSyms(psym.Children, ststr, &md)
                                }
                                return
                        }
                }
                if CompleteTrace {
                        fmt.Printf("completion type not found\n")
                }
        }

        // if len(md.Matches) == 0 {
        //         fmt.Printf("complete str:  %v  orig: %v\n", str, origStr)
        //         lfs.ParseState.AST.WriteTree(os.Stdout, 0)
        // }

        return
}

// CompletePosScope returns the scope for given position in given filename,
// and fills in the scoping symbol(s) in scMap
func (gl *GoLang) CompletePosScope(fs *parse.FileState, pos textpos.Pos, fpath string, scopes *syms.SymMap) token.Tokens {
        fs.Syms.FindContainsRegion(fpath, pos, 2, token.None, scopes) // None matches any, 2 extra lines to add for new typing
        if len(*scopes) == 0 {
                return token.None
        }
        if len(*scopes) == 1 {
                for _, sy := range *scopes {
                        if CompleteTrace {
                                fmt.Printf("scope: %v  reg: %v  pos: %v\n", sy.Name, sy.Region, pos)
                        }
                        return sy.Kind
                }
        }
        var last *syms.Symbol
        for _, sy := range *scopes {
                if sy.Kind.SubCat() == token.NameFunction {
                        return sy.Kind
                }
                last = sy
        }
        if CompleteTrace {
                fmt.Printf(" > 1 scopes!\n")
                scopes.WriteDoc(os.Stdout, 0)
        }
        return last.Kind
}

// CompletePkgSyms matches all package symbols using seed
func (gl *GoLang) CompletePkgSyms(fs *parse.FileState, pkg *syms.Symbol, seed string, md *complete.Matches) {
        md.Seed = seed
        var matches syms.SymMap
        pkg.Children.FindNamePrefixScoped(seed, &matches)
        syms.AddCompleteSyms(matches, "", md)
}

// CompleteTypeName matches builtin and package type names to seed
func (gl *GoLang) CompleteTypeName(fs *parse.FileState, pkg *syms.Symbol, seed string, md *complete.Matches) {
        md.Seed = seed
        for _, tk := range BuiltinTypeKind {
                if strings.HasPrefix(tk.Name, seed) {
                        c := complete.Completion{Text: tk.Name, Label: tk.Name, Icon: icons.Type}
                        md.Matches = append(md.Matches, c)
                }
        }
        sfunc := strings.HasPrefix(seed, "func ")
        for _, tk := range pkg.Types {
                if !sfunc && strings.HasPrefix(tk.Name, "func ") {
                        continue
                }
                if strings.HasPrefix(tk.Name, seed) {
                        c := complete.Completion{Text: tk.Name, Label: tk.Name, Icon: icons.Type}
                        md.Matches = append(md.Matches, c)
                }
        }
}

// LookupString attempts to lookup a string, which could be a type name,
// (with package qualifier), could be partial, etc
func (gl *GoLang) LookupString(fs *parse.FileState, pkg *syms.Symbol, scopes syms.SymMap, str string) (ld complete.Lookup) {
        str = lexer.TrimLeftToAlpha(str)
        pnm, tnm := SplitType(str)
        if pnm != "" && tnm != "" {
                psym, has := gl.PkgSyms(fs, pkg.Children, pnm)
                if has {
                        tnm = lexer.TrimLeftToAlpha(tnm)
                        var matches syms.SymMap
                        psym.Children.FindNamePrefixScoped(tnm, &matches)
                        if len(matches) == 1 {
                                var psy *syms.Symbol
                                for _, sy := range matches {
                                        psy = sy
                                }
                                ld.SetFile(psy.Filename, psy.Region.Start.Line, psy.Region.End.Line)
                                return
                        }
                }
                if CompleteTrace {
                        fmt.Printf("Lookup: package-qualified string not found: %v\n", str)
                }
                return
        }
        // try types to str:
        var tym *syms.Type
        nmatch := 0
        for _, tk := range pkg.Types {
                if strings.HasPrefix(tk.Name, str) {
                        tym = tk
                        nmatch++
                }
        }
        if nmatch == 1 {
                ld.SetFile(tym.Filename, tym.Region.Start.Line, tym.Region.End.Line)
                return
        }
        var matches syms.SymMap
        if len(scopes) > 0 {
                scopes.FindNamePrefixRecursive(str, &matches)
                if len(matches) > 0 {
                        for _, sy := range matches {
                                ld.SetFile(sy.Filename, sy.Region.Start.Line, sy.Region.End.Line) // take first
                                return
                        }
                }
        }

        pkg.Children.FindNamePrefixScoped(str, &matches)
        if len(matches) > 0 {
                for _, sy := range matches {
                        ld.SetFile(sy.Filename, sy.Region.Start.Line, sy.Region.End.Line) // take first
                        return
                }
        }
        if CompleteTrace {
                fmt.Printf("Lookup: string not found: %v\n", str)
        }
        return
}

// CompleteASTStart finds the best starting point in the given current-line AST
// to start completion process, which walks back down from that starting point
func (gl *GoLang) CompleteASTStart(ast *parser.AST, scope token.Tokens) (start, last *parser.AST) {
        curi := tree.Last(ast)
        if curi == nil {
                return
        }
        cur := curi.(*parser.AST)
        last = cur
        start = cur
        prv := cur
        for {
                var parent *parser.AST
                if cur.Parent != nil {
                        parent = cur.Parent.(*parser.AST)
                }
                switch {
                case cur.Name == "TypeNm":
                        return cur, last
                case cur.Name == "File":
                        if prv != last && prv.Src == last.Src {
                                return last, last // triggers single-item completion
                        }
                        return prv, last
                case cur.Name == "Selector":
                        if parent != nil {
                                if parent.Name[:4] == "Asgn" {
                                        return cur, last
                                }
                                if strings.HasSuffix(parent.Name, "Expr") {
                                        return cur, last
                                }
                        } else {
                                flds := strings.Fields(cur.Src)
                                cur.Src = flds[len(flds)-1] // skip any spaces
                                return cur, last
                        }
                case cur.Name == "Name":
                        if cur.Src == "if" { // weird parsing if incomplete
                                if prv != last && prv.Src == last.Src {
                                        return last, last // triggers single-item completion
                                }
                                return prv, last
                        }
                        if parent != nil {
                                if parent.Name[:4] == "Asgn" {
                                        return prv, last
                                }
                                if strings.HasSuffix(parent.Name, "Expr") {
                                        return cur, last
                                }
                        }
                case cur.Name == "ExprStmt":
                        if scope == token.None {
                                return prv, last
                        }
                        if cur.Src != "(" && cur.Src == prv.Src {
                                return prv, last
                        }
                        if cur.Src != "(" && prv != last {
                                return prv, last
                        }
                case strings.HasSuffix(cur.Name, "Stmt"):
                        return prv, last
                case cur.Name == "Args":
                        return prv, last
                }
                nxt := cur.PrevAST()
                if nxt == nil {
                        return cur, last
                }
                prv = cur
                cur = nxt
        }
        return cur, last
}

// CompleteEdit returns the completion edit data for integrating the selected completion
// into the source
func (gl *GoLang) CompleteEdit(fss *parse.FileStates, text string, cp int, comp complete.Completion, seed string) (ed complete.Edit) {
        // if the original is ChildByName() and the cursor is between d and B and the comp is Children,
        // then delete the portion after "Child" and return the new comp and the number or runes past
        // the cursor to delete
        s2 := text[cp:]
        gotParen := false
        if len(s2) > 0 && lexer.IsLetterOrDigit(rune(s2[0])) {
                for i, c := range s2 {
                        if c == '(' {
                                gotParen = true
                                s2 = s2[:i]
                                break
                        }
                        isalnum := c == '_' || unicode.IsLetter(c) || unicode.IsDigit(c)
                        if !isalnum {
                                s2 = s2[:i]
                                break
                        }
                }
        } else {
                s2 = ""
        }

        var nw = comp.Text
        if gotParen && strings.HasSuffix(nw, "()") {
                nw = nw[:len(nw)-2]
        }

        // fmt.Printf("text: %v|%v  comp: %v  s2: %v\n", text[:cp], text[cp:], nw, s2)
        ed.NewText = nw
        ed.ForwardDelete = len(s2)
        return ed
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        "fmt"
        "os"
        "path/filepath"
        "strings"

        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/parser"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/token"
)

// TypeFromASTExprStart starts walking the ast expression to find the type.
// This computes the last ast point as the stopping point for processing
// and then calls TypeFromASTExpr.
// It returns the type, any AST node that remained unprocessed at the end, and bool if found.
func (gl *GoLang) TypeFromASTExprStart(fs *parse.FileState, origPkg, pkg *syms.Symbol, tyast *parser.AST) (*syms.Type, *parser.AST, bool) {
        last := tyast.NextSiblingAST()
        // fmt.Printf("last: %v \n", last.PathUnique())
        return gl.TypeFromASTExpr(fs, origPkg, pkg, tyast, last)
}

// TypeFromASTExpr walks the ast expression to find the type.
// It returns the type, any AST node that remained unprocessed at the end, and bool if found.
func (gl *GoLang) TypeFromASTExpr(fs *parse.FileState, origPkg, pkg *syms.Symbol, tyast, last *parser.AST) (*syms.Type, *parser.AST, bool) {
        pos := tyast.SrcReg.Start
        fpath, _ := filepath.Abs(fs.Src.Filename)
        // containers of given region -- local scoping
        var conts syms.SymMap
        fs.Syms.FindContainsRegion(fpath, pos, 2, token.NameFunction, &conts) // 2 extra lines always!
        // if TraceTypes && len(conts) == 0 {
        //         fmt.Printf("TExpr: no conts for fpath: %v  pos: %v\n", fpath, pos)
        // }
        // if TraceTypes {
        //         tyast.WriteTree(os.Stdout, 0)
        // }

        tnm := tyast.Name

        switch {
        case tnm == "FuncCall":
                fun := tyast.NextAST()
                if fun == nil {
                        return nil, nil, false
                }
                funm := fun.Src
                sym, got := fs.FindNameScoped(funm, conts)
                if got {
                        if !gl.InferEmptySymbolType(sym, fs, pkg) {
                                return nil, fun, false
                        }
                        if sym.Type == "" {
                                if TraceTypes {
                                        fmt.Printf("TExpr: FuncCall: function type not set yet: %v\n", funm)
                                }
                                gl.InferSymbolType(sym, fs, pkg, true)
                        }
                        ftnm := sym.Type
                        ftyp, _ := gl.FindTypeName(ftnm, fs, pkg)
                        if ftyp != nil && len(ftyp.Size) == 2 {
                                return gl.TypeFromFuncCall(fs, origPkg, pkg, tyast, last, ftyp)
                        }
                        if TraceTypes {
                                fmt.Printf("TExpr: FuncCall: could not find function: %v\n", funm)
                        }
                        return nil, fun, false
                }
                if funm == "len" || funm == "cap" {
                        return BuiltinTypes["int"], nil, true
                }
                if funm == "append" {
                        farg := fun.NextAST().NextAST()
                        return gl.TypeFromASTExpr(fs, origPkg, pkg, farg, last)
                }
                ctyp, _ := gl.FindTypeName(funm, fs, pkg) // conversion
                if ctyp != nil {
                        return ctyp, nil, true
                }
                if TraceTypes {
                        fmt.Printf("TExpr: FuncCall: could not find function: %v\n", funm)
                }
                return nil, fun, false
        case tnm == "Selector":
                if tyast.NumChildren() == 0 { // incomplete
                        return nil, nil, false
                }
                tnmA := tyast.ChildAST(0)
                if tnmA.Name != "Name" {
                        if TraceTypes {
                                fmt.Printf("TExpr: selector start node kid is not a Name: %v, src: %v\n", tnmA.Name, tnmA.Src)
                                tnmA.WriteTree(os.Stdout, 0)
                        }
                        return nil, tnmA, false
                }
                return gl.TypeFromASTName(fs, origPkg, pkg, tnmA, last, conts)
        case tnm == "Slice": // strings.HasPrefix(tnm, "Slice"):
                if tyast.NumChildren() == 0 { // incomplete
                        return nil, nil, false
                }
                tnmA := tyast.ChildAST(0)
                if tnmA.Name != "Name" {
                        if TraceTypes {
                                fmt.Printf("TExpr: slice start node kid is not a Name: %v, src: %v\n", tnmA.Name, tnmA.Src)
                        }
                        return nil, tnmA, false
                }
                snm := tnmA.Src
                sym, got := fs.FindNameScoped(snm, conts)
                if got {
                        return gl.TypeFromASTSym(fs, origPkg, pkg, tnmA, last, sym)
                }
                if TraceTypes {
                        fmt.Printf("TExpr: could not find symbol for slice var name: %v\n", snm)
                }
                return nil, tnmA, false
        case tnm == "Name":
                return gl.TypeFromASTName(fs, origPkg, pkg, tyast, last, conts)
        case strings.HasPrefix(tnm, "Lit"):
                sty, got := gl.TypeFromASTLit(fs, pkg, nil, tyast)
                return sty, nil, got
        case strings.HasSuffix(tnm, "AutoType"):
                sty, got := gl.SubTypeFromAST(fs, pkg, tyast, 0)
                return sty, nil, got
        case tnm == "CompositeLit":
                sty, got := gl.SubTypeFromAST(fs, pkg, tyast, 0)
                return sty, nil, got
        case tnm == "AddrExpr":
                if !tyast.HasChildren() {
                        return nil, nil, false
                }
                ch := tyast.ChildAST(0)
                snm := tyast.Src[1:] // after &
                var sty *syms.Type
                switch ch.Name {
                case "CompositeLit":
                        sty, _ = gl.SubTypeFromAST(fs, pkg, ch, 0)
                case "Selector":
                        sty, _ = gl.TypeFromAST(fs, pkg, nil, ch)
                case "Name":
                        sym, got := fs.FindNameScoped(snm, conts)
                        if got {
                                sty, _, got = gl.TypeFromASTSym(fs, origPkg, pkg, ch, last, sym)
                        } else {
                                if snm == "true" || snm == "false" {
                                        return BuiltinTypes["bool"], nil, true
                                }
                                if TraceTypes {
                                        fmt.Printf("TExpr: could not find symbol named: %v\n", snm)
                                }
                        }
                }
                if sty != nil {
                        ty := &syms.Type{}
                        ty.Kind = syms.Ptr
                        tynm := SymTypeNameForPkg(sty, pkg)
                        ty.Name = "*" + tynm
                        ty.Els.Add("ptr", tynm)
                        return ty, nil, true
                }
                if TraceTypes {
                        fmt.Printf("TExpr: could not process addr expr:\n")
                        tyast.WriteTree(os.Stdout, 0)
                }
                return nil, tyast, false
        case tnm == "DePtrExpr":
                sty, got := gl.SubTypeFromAST(fs, pkg, tyast, 0) // first child
                return sty, nil, got
        case strings.HasSuffix(tnm, "Expr"):
                // note: could figure out actual numerical type, but in practice we don't care
                // for lookup / completion, so ignoring for now.
                return BuiltinTypes["float64"], nil, true
        case tnm == "TypeAssert":
                sty, got := gl.SubTypeFromAST(fs, pkg, tyast, 1) // type is second child
                return sty, nil, got
        case tnm == "MakeCall":
                sty, got := gl.SubTypeFromAST(fs, pkg, tyast, 0)
                return sty, nil, got
        case strings.Contains(tnm, "Chan"):
                sty, got := gl.SubTypeFromAST(fs, pkg, tyast, 0)
                return sty, nil, got
        default:
                if TraceTypes {
                        fmt.Printf("TExpr: cannot start with: %v\n", tyast.Name)
                        tyast.WriteTree(os.Stdout, 0)
                }
                return nil, tyast, false
        }
        return nil, tyast, false
}

// TypeFromASTSym attempts to get the type from given symbol as part of expression.
// It returns the type, any AST node that remained unprocessed at the end, and bool if found.
func (gl *GoLang) TypeFromASTSym(fs *parse.FileState, origPkg, pkg *syms.Symbol, tyast, last *parser.AST, sym *syms.Symbol) (*syms.Type, *parser.AST, bool) {
        // if TraceTypes {
        //         fmt.Printf("TExpr: sym named: %v  kind: %v  type: %v\n", sym.Name, sym.Kind, sym.Type)
        // }
        if sym.Kind.SubCat() == token.NameScope {
                // if TraceTypes {
                //         fmt.Printf("TExpr: symbol has scope type (package) -- will be looked up in a sec\n")
                // }
                return nil, nil, false // higher-level will catch it
        }
        if !gl.InferEmptySymbolType(sym, fs, pkg) {
                return nil, tyast, false
        }
        tnm := sym.Type
        return gl.TypeFromASTType(fs, origPkg, pkg, tyast, last, tnm)
}

// TypeFromASTType walks the ast expression to find the type, starting from current type name.
// It returns the type, any AST node that remained unprocessed at the end, and bool if found.
func (gl *GoLang) TypeFromASTType(fs *parse.FileState, origPkg, pkg *syms.Symbol, tyast, last *parser.AST, tnm string) (*syms.Type, *parser.AST, bool) {
        if tnm[0] == '*' {
                tnm = tnm[1:]
        }
        ttp, npkg := gl.FindTypeName(tnm, fs, pkg)
        if ttp == nil {
                if TraceTypes {
                        fmt.Printf("TExpr: error -- couldn't find type name: %v\n", tnm)
                }
                return nil, tyast, false
        }
        pkgnm := ""
        if pi := strings.Index(ttp.Name, "."); pi > 0 {
                pkgnm = ttp.Name[:pi]
        }
        if npkg != origPkg { // need to make a package-qualified copy of type
                if pkgnm == "" {
                        pkgnm = npkg.Name
                        qtnm := QualifyType(pkgnm, ttp.Name)
                        if qtnm != ttp.Name {
                                if etyp, ok := pkg.Types[qtnm]; ok {
                                        ttp = etyp
                                } else {
                                        ntyp := &syms.Type{}
                                        *ntyp = *ttp
                                        ntyp.Name = qtnm
                                        origPkg.Types.Add(ntyp)
                                        ttp = ntyp
                                }
                        }
                }
        }
        pkg = npkg // update to new context
        // if TraceTypes {
        //         fmt.Printf("TExpr: found type: %v  kind: %v\n", ttp.Name, ttp.Kind)
        // }

        if tyast == nil || tyast == last {
                return ttp, tyast, true
        }

        if tyast.Name == "QualType" && tnm != tyast.Src {
                // tyast.Src is new type name
                return gl.TypeFromASTType(fs, origPkg, pkg, tyast, last, tyast.Src)
        }

        nxt := tyast
        for {
                nxt = nxt.NextAST()
                if nxt == nil || nxt == last {
                        // if TraceTypes {
                        //         fmt.Printf("TExpr: returning terminal type\n")
                        // }
                        return ttp, nxt, true
                }
                brk := false
                switch {
                case nxt.Name == "Name":
                        brk = true
                case strings.HasPrefix(nxt.Name, "Lit"):
                        sty, got := gl.TypeFromASTLit(fs, pkg, nil, nxt)
                        return sty, nil, got
                case nxt.Name == "TypeAssert":
                        sty, got := gl.SubTypeFromAST(fs, origPkg, nxt, 1) // type is second child, switch back to orig pkg
                        return sty, nil, got
                case nxt.Name == "Slice":
                        continue
                case strings.HasPrefix(nxt.Name, "Slice"):
                        eltyp := ttp.Els.ByName("val")
                        if eltyp != nil {
                                elnm := QualifyType(pkgnm, eltyp.Type)
                                // if TraceTypes {
                                //         fmt.Printf("TExpr: slice/map el type: %v\n", elnm)
                                // }
                                return gl.TypeFromASTType(fs, origPkg, pkg, nxt, last, elnm)
                        }
                        if ttp.Name == "string" {
                                return BuiltinTypes["string"], nil, true
                        }
                        if TraceTypes {
                                fmt.Printf("TExpr: slice operator not on slice: %v\n", ttp.Name)
                                tyast.WriteTree(os.Stdout, 0)
                        }
                case nxt.Name == "FuncCall":
                        // ttp is the function type name
                        fun := nxt.NextAST()
                        if fun == nil || fun == last {
                                return ttp, fun, true
                        }
                        funm := fun.Src
                        ftyp, got := ttp.Meths[funm]
                        if got && len(ftyp.Size) == 2 {
                                return gl.TypeFromFuncCall(fs, origPkg, pkg, nxt, last, ftyp)
                        }
                        if TraceTypes {
                                fmt.Printf("TExpr: FuncCall: could not find method: %v in type: %v\n", funm, ttp.Name)
                                tyast.WriteTree(os.Stdout, 0)
                        }
                        return nil, fun, false

                }
                if brk || nxt == nil || nxt == last {
                        break
                }
                // if TraceTypes {
                //         fmt.Printf("TExpr: skipping over %v\n", nxt.Nm)
                // }
        }
        if nxt == nil {
                return ttp, nxt, false
        }
        nm := nxt.Src
        stp := ttp.Els.ByName(nm)
        if stp != nil {
                // if TraceTypes {
                //         fmt.Printf("TExpr: found Name: %v in type els\n", nm)
                // }
                return gl.TypeFromASTType(fs, origPkg, pkg, nxt, last, stp.Type)
        }
        // if TraceTypes {
        //         fmt.Printf("TExpr: error -- Name: %v not found in type els\n", nm)
        //         // ttp.WriteDoc(os.Stdout, 0)
        // }
        return ttp, nxt, true // robust, needed for completion
}

// TypeFromASTFuncCall gets return type of function call as return value, and returns the sibling node to
// continue parsing in, skipping over everything in the function call
func (gl *GoLang) TypeFromFuncCall(fs *parse.FileState, origPkg, pkg *syms.Symbol, tyast, last *parser.AST, ftyp *syms.Type) (*syms.Type, *parser.AST, bool) {
        nxt := tyast.NextSiblingAST() // skip over everything within method in ast
        if len(ftyp.Size) != 2 {
                if TraceTypes {
                        fmt.Printf("TExpr: FuncCall: %v is not properly initialized with sizes\n", ftyp.Name)
                }
                return nil, nxt, false
        }
        npars := ftyp.Size[0] // first size is number of params
        nrval := ftyp.Size[1] // second size is number of return values
        if nrval == 0 {
                if TraceTypes {
                        fmt.Printf("TExpr: FuncCall: %v has no return value\n", ftyp.Name)
                }
                return nil, nxt, false // no return -- shouldn't happen
        }
        rtyp := ftyp.Els[npars]               // first return
        if nxt != nil && nxt.Name == "Name" { // direct de-ref on function return value -- ASTType assumes nxt is type el
                prv := nxt.PrevAST()
                if prv != tyast {
                        nxt = prv
                }
        }
        // if TraceTypes {
        //         fmt.Printf("got return type: %v\n", rtyp)
        // }
        return gl.TypeFromASTType(fs, origPkg, pkg, nxt, last, rtyp.Type)
}

// TypeFromASTName gets type from a Name in a given context (conts)
func (gl *GoLang) TypeFromASTName(fs *parse.FileState, origPkg, pkg *syms.Symbol, tyast, last *parser.AST, conts syms.SymMap) (*syms.Type, *parser.AST, bool) {
        snm := tyast.Src
        sym, got := fs.FindNameScoped(snm, conts)
        if got && sym.Kind.SubCat() != token.NameScope {
                tsym, nnxt, got := gl.TypeFromASTSym(fs, origPkg, pkg, tyast, last, sym)
                if got {
                        return tsym, nnxt, got
                }
                if TraceTypes {
                        fmt.Printf("TExpr: got symbol but could not get type from sym name: %v\n", snm)
                        // tyast.WriteTree(os.Stdout, 0)
                }
        }
        if snm == "true" || snm == "false" {
                return BuiltinTypes["bool"], nil, true
        }
        // maybe it is a package name
        psym, has := gl.PkgSyms(fs, pkg.Children, snm)
        if has {
                // if TraceTypes {
                //         fmt.Printf("TExpr: entering package name: %v\n", snm)
                // }
                nxt := tyast.NextAST()
                if nxt != nil {
                        if nxt.Name == "Selector" {
                                nxt = nxt.NextAST()
                        }
                        return gl.TypeFromASTExpr(fs, origPkg, psym, nxt, last)
                }
                if TraceTypes {
                        fmt.Printf("TExpr: package alone not useful\n")
                }
                return nil, tyast, false // package alone not useful
        }
        if TraceTypes {
                fmt.Printf("TExpr: could not find symbol for name: %v\n", snm)
        }
        return nil, tyast, false
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        "fmt"
        "unicode"

        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/parser"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/token"
)

// TypeMeths gathers method types from the type symbol's children
func (gl *GoLang) TypeMeths(fs *parse.FileState, pkg *syms.Symbol, ty *syms.Type) {
        _, tnm := SplitType(ty.Name)
        tsym, got := pkg.Children.FindNameScoped(tnm)
        if !got {
                if !unicode.IsLower(rune(tnm[0])) && TraceTypes {
                        fmt.Printf("TypeMeths: error -- did NOT get type sym: %v in pkg: %v\n", tnm, pkg.Name)
                }
                return
        }
        for _, sy := range tsym.Children {
                if sy.Kind.SubCat() != token.NameFunction || sy.AST == nil {
                        continue
                }

                fty := gl.FuncTypeFromAST(fs, pkg, sy.AST.(*parser.AST), nil)
                if fty != nil {
                        fty.Kind = syms.Method
                        fty.Name = sy.Name
                        fty.Filename = sy.Filename
                        fty.Region = sy.Region
                        ty.Meths.Add(fty)
                        // if TraceTypes {
                        //         fmt.Printf("TypeMeths: Added method: %v\n", fty)
                        // }
                } else {
                        if TraceTypes {
                                fmt.Printf("TypeMeths: method failed: %v\n", sy.Name)
                        }
                }
        }
}

// NamesFromAST returns a slice of name(s) from namelist nodes
func (gl *GoLang) NamesFromAST(fs *parse.FileState, pkg *syms.Symbol, ast *parser.AST, idx int) []string {
        sast := ast.ChildAST(idx)
        if sast == nil {
                if TraceTypes {
                        fmt.Printf("TraceTypes: could not find child 0 on ast %v", ast)
                }
                return nil
        }
        var sary []string
        if sast.HasChildren() {
                for i := range sast.Children {
                        sary = append(sary, gl.NamesFromAST(fs, pkg, sast, i)...)
                }
        } else {
                sary = append(sary, sast.Src)
        }
        return sary
}

// FuncTypeFromAST initializes a function type from ast -- type can either be anon
// or a named type -- if anon then the name is the full type signature without param names
func (gl *GoLang) FuncTypeFromAST(fs *parse.FileState, pkg *syms.Symbol, ast *parser.AST, fty *syms.Type) *syms.Type {
        // ast.WriteTree(os.Stdout, 0)

        if ast == nil || !ast.HasChildren() {
                return nil
        }
        pars := ast.ChildAST(0)
        if pars == nil {
                if TraceTypes {
                        fmt.Printf("TraceTypes: could not find child 0 on ast %v", ast)
                }
                return nil
        }
        if fty == nil {
                fty = &syms.Type{}
                fty.Kind = syms.Func
        }
        poff := 0
        isMeth := false
        if pars.Name == "MethRecvName" && len(ast.Children) > 2 {
                isMeth = true
                rcv := pars.Children[0].(*parser.AST)
                rtyp := pars.Children[1].(*parser.AST)
                fty.Els.Add(rcv.Src, rtyp.Src)
                poff = 2
                pars = ast.ChildAST(2)
        } else if pars.Name == "Name" && len(ast.Children) > 1 {
                poff = 1
                pars = ast.ChildAST(1)
        }
        npars := len(pars.Children)
        var sigpars *parser.AST
        if npars > 0 && (pars.Name == "SigParams" || pars.Name == "SigParamsResult") {
                if ps := pars.ChildAST(0); ps == nil {
                        sigpars = pars
                        pars = ps
                        npars = len(pars.Children)
                } else {
                        npars = 0 // not really
                }
        }
        if npars > 0 {
                gl.ParamsFromAST(fs, pkg, pars, fty, "param")
                npars = len(fty.Els) // how many we added -- auto-includes receiver for method
        } else {
                if isMeth {
                        npars = 1
                }
        }
        nrvals := 0
        if sigpars != nil && len(sigpars.Children) >= 2 {
                rvals := sigpars.ChildAST(1)
                gl.RvalsFromAST(fs, pkg, rvals, fty)
                nrvals = len(fty.Els) - npars // how many we added..
        } else if poff < 2 && (len(ast.Children) >= poff+2) {
                rvals := ast.ChildAST(poff + 1)
                gl.RvalsFromAST(fs, pkg, rvals, fty)
                nrvals = len(fty.Els) - npars // how many we added..
        }
        fty.Size = []int{npars, nrvals}
        return fty
}

// ParamsFromAST sets params as Els for given function type (also for return types)
func (gl *GoLang) ParamsFromAST(fs *parse.FileState, pkg *syms.Symbol, pars *parser.AST, fty *syms.Type, name string) {
        npars := len(pars.Children)
        var pnames []string // param names that all share same type
        for i := 0; i < npars; i++ {
                par := pars.Children[i].(*parser.AST)
                psz := len(par.Children)
                if par.Name == "ParType" && psz == 1 {
                        ptypa := par.Children[0].(*parser.AST)
                        if ptypa.Name == "TypeNm" { // could be multiple args with same type or a separate type-only arg
                                if ptl, _ := gl.FindTypeName(par.Src, fs, pkg); ptl != nil {
                                        fty.Els.Add(fmt.Sprintf("%s_%v", name, i), par.Src)
                                        continue
                                }
                                pnames = append(pnames, par.Src) // add to later type
                        } else {
                                ptyp, ok := gl.SubTypeFromAST(fs, pkg, par, 0)
                                if ok {
                                        pnsz := len(pnames)
                                        if pnsz > 0 {
                                                for _, pn := range pnames {
                                                        fty.Els.Add(pn, ptyp.Name)
                                                }
                                        }
                                        fty.Els.Add(fmt.Sprintf("%s_%v", name, i), ptyp.Name)
                                        continue
                                }
                                pnames = nil
                        }
                } else if psz == 2 { // ParName
                        pnm := par.Children[0].(*parser.AST)
                        ptyp, ok := gl.SubTypeFromAST(fs, pkg, par, 1)
                        if ok {
                                pnsz := len(pnames)
                                if pnsz > 0 {
                                        for _, pn := range pnames {
                                                fty.Els.Add(pn, ptyp.Name)
                                        }
                                }
                                fty.Els.Add(pnm.Src, ptyp.Name)
                                continue
                        }
                        pnames = nil
                }
        }
}

// RvalsFromAST sets return value(s) as Els for given function type
func (gl *GoLang) RvalsFromAST(fs *parse.FileState, pkg *syms.Symbol, rvals *parser.AST, fty *syms.Type) {
        if rvals.Name == "Block" { // todo: maybe others
                return
        }
        nrvals := len(rvals.Children)
        if nrvals == 1 { // single rval, unnamed, has type directly..
                rval := rvals.ChildAST(0)
                if rval.Name != "ParName" {
                        nrvals = 1
                        rtyp, ok := gl.SubTypeFromAST(fs, pkg, rvals, 0)
                        if ok {
                                fty.Els.Add("rval", rtyp.Name)
                                return
                        }
                }
        }
        gl.ParamsFromAST(fs, pkg, rvals, fty, "rval")
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        _ "embed"
        "fmt"
        "log"
        "os"
        "path/filepath"
        "unicode"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/languages"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

//go:embed go.parse
var parserBytes []byte

// GoLang implements the Lang interface for the Go language
type GoLang struct {
        Pr *parse.Parser
}

// TheGoLang is the instance variable providing support for the Go language
var TheGoLang = GoLang{}

func init() {
        parse.StandardLanguageProperties[fileinfo.Go].Lang = &TheGoLang
        languages.ParserBytes[fileinfo.Go] = parserBytes
}

func (gl *GoLang) Parser() *parse.Parser {
        if gl.Pr != nil {
                return gl.Pr
        }
        lp, _ := parse.LanguageSupport.Properties(fileinfo.Go)
        if lp.Parser == nil {
                parse.LanguageSupport.OpenStandard()
        }
        gl.Pr = lp.Parser
        if gl.Pr == nil {
                return nil
        }
        return gl.Pr
}

// ParseFile is the main point of entry for external calls into the parser
func (gl *GoLang) ParseFile(fss *parse.FileStates, txt []byte) {
        pr := gl.Parser()
        if pr == nil {
                log.Println("ParseFile: no parser; must call parse.LangSupport.OpenStandard() at startup!")
                return
        }
        pfs := fss.StartProc(txt) // current processing one
        ext := filepath.Ext(pfs.Src.Filename)
        if ext == ".mod" { // note: mod doesn't parse!
                fss.EndProc()
                return
        }
        // fmt.Println("\nstarting Parse:", pfs.Src.Filename)
        // lprf := profile.Start("LexAll")
        pr.LexAll(pfs)
        // lprf.End()
        // pprf := profile.Start("ParseAll")
        pr.ParseAll(pfs)
        // pprf.End()
        fss.EndProc() // only symbols still need locking, done separately
        path := filepath.Dir(pfs.Src.Filename)
        // fmt.Println("done parse")
        if len(pfs.ParseState.Scopes) > 0 { // should be for complete files, not for snippets
                pkg := pfs.ParseState.Scopes[0]
                pfs.Syms[pkg.Name] = pkg // keep around..
                // fmt.Printf("main pkg name: %v\n", pkg.Name)
                pfs.WaitGp.Add(1)
                go func() {
                        gl.AddPathToSyms(pfs, path)
                        gl.AddImportsToExts(fss, pfs, pkg) // will do ResolveTypes when it finishes
                        // fmt.Println("done import")
                }()
        } else {
                if TraceTypes {
                        fmt.Printf("not importing scope for: %v\n", path)
                }
                pfs.ClearAST()
                if pfs.AST.HasChildren() {
                        pfs.AST.DeleteChildren()
                }
                // fmt.Println("done no import")
        }
}

func (gl *GoLang) LexLine(fs *parse.FileState, line int, txt []rune) lexer.Line {
        pr := gl.Parser()
        if pr == nil {
                return nil
        }
        return pr.LexLine(fs, line, txt)
}

func (gl *GoLang) ParseLine(fs *parse.FileState, line int) *parse.FileState {
        pr := gl.Parser()
        if pr == nil {
                return nil
        }
        lfs := pr.ParseLine(fs, line) // should highlight same line?
        return lfs
}

func (gl *GoLang) HighlightLine(fss *parse.FileStates, line int, txt []rune) lexer.Line {
        pr := gl.Parser()
        if pr == nil {
                return nil
        }
        pfs := fss.Done()
        ll := pr.LexLine(pfs, line, txt)
        lfs := pr.ParseLine(pfs, line)
        if lfs != nil {
                ll = lfs.Src.Lexs[0]
                cml := pfs.Src.Comments[line]
                merge := lexer.MergeLines(ll, cml)
                mc := merge.Clone()
                if len(cml) > 0 {
                        initDepth := pfs.Src.PrevDepth(line)
                        pr.PassTwo.NestDepthLine(mc, initDepth)
                }
                lfs.Syms.WriteDoc(os.Stdout, 0)
                lfs.Destroy()
                return mc
        }
        return ll
}

// IndentLine returns the indentation level for given line based on
// previous line's indentation level, and any delta change based on
// e.g., brackets starting or ending the previous or current line, or
// other language-specific keywords.  See lexer.BracketIndentLine for example.
// Indent level is in increments of tabSz for spaces, and tabs for tabs.
// Operates on rune source with markup lex tags per line.
func (gl *GoLang) IndentLine(fs *parse.FileStates, src [][]rune, tags []lexer.Line, ln int, tabSz int) (pInd, delInd, pLn int, ichr indent.Character) {
        pInd, pLn, ichr = lexer.PrevLineIndent(src, tags, ln, tabSz)

        curUnd, _ := lexer.LineStartEndBracket(src[ln], tags[ln])
        _, prvInd := lexer.LineStartEndBracket(src[pLn], tags[pLn])

        brackParen := false      // true if line only has bracket and paren -- outdent current
        if len(tags[pLn]) >= 2 { // allow for comments
                pl := tags[pLn][0]
                ll := tags[pLn][1]
                if ll.Token.Token == token.PunctGpRParen && pl.Token.Token == token.PunctGpRBrace {
                        brackParen = true
                }
        }

        delInd = 0
        if brackParen {
                delInd-- // outdent
        }
        switch {
        case prvInd && curUnd:
        case prvInd:
                delInd++
        case curUnd:
                delInd--
        }

        pwrd := lexer.FirstWord(string(src[pLn]))
        cwrd := lexer.FirstWord(string(src[ln]))

        if cwrd == "case" || cwrd == "default" {
                if pwrd == "switch" {
                        delInd = 0
                } else if pwrd == "case" {
                        delInd = 0
                } else {
                        delInd = -1
                }
        } else if pwrd == "case" || pwrd == "default" {
                delInd = 1
        }

        if pInd == 0 && delInd < 0 { // error..
                delInd = 0
        }
        return
}

// AutoBracket returns what to do when a user types a starting bracket character
// (bracket, brace, paren) while typing.
// pos = position where bra will be inserted, and curLn is the current line
// match = insert the matching ket, and newLine = insert a new line.
func (gl *GoLang) AutoBracket(fs *parse.FileStates, bra rune, pos textpos.Pos, curLn []rune) (match, newLine bool) {
        lnLen := len(curLn)
        if bra == '{' {
                if pos.Char == lnLen {
                        if lnLen == 0 || unicode.IsSpace(curLn[pos.Char-1]) {
                                newLine = true
                        }
                        match = true
                } else {
                        match = unicode.IsSpace(curLn[pos.Char])
                }
        } else {
                match = pos.Char == lnLen || unicode.IsSpace(curLn[pos.Char]) // at end or if space after
        }
        return
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        "fmt"
        "log"
        "os"
        "path/filepath"
        "strings"
        "sync"
        "unicode"
        "unicode/utf8"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/token"
        "golang.org/x/tools/go/packages"
)

// ParseDirLock provides a lock protecting parsing of a package directory
type ParseDirLock struct {

        // logical import path
        Path string

        Processing bool

        // mutex protecting processing of this path
        Mu sync.Mutex `json:"-" xml:"-"`
}

// ParseDirLocks manages locking for parsing package directories
type ParseDirLocks struct {

        // map of paths with processing status
        Dirs map[string]*ParseDirLock

        // mutex protecting access to Dirs
        Mu sync.Mutex `json:"-" xml:"-"`
}

// TheParseDirs is the parse dirs locking manager
var TheParseDirs ParseDirLocks

// ParseDir is how you call ParseDir on a given path in a secure way that is
// managed for multiple accesses.  If dir is currently being parsed, then
// the mutex is locked and caller will wait until that is done -- at which point
// the next one should be able to load parsed symbols instead of parsing fresh.
// Once the symbols are returned, then the local FileState SymsMu lock must be
// used when integrating any external symbols back into another filestate.
// As long as all the symbol resolution etc is all happening outside of the
// external syms linking, then it does not need to be protected.
func (pd *ParseDirLocks) ParseDir(gl *GoLang, fs *parse.FileState, path string, opts parse.LanguageDirOptions) *syms.Symbol {
        pfld := strings.Fields(path)
        if len(pfld) > 1 { // remove first alias
                path = pfld[1]
        }
        pd.Mu.Lock()
        if pd.Dirs == nil {
                pd.Dirs = make(map[string]*ParseDirLock)
        }
        ds, has := pd.Dirs[path]
        if !has {
                ds = &ParseDirLock{Path: path}
                pd.Dirs[path] = ds
        }
        pd.Mu.Unlock()
        ds.Mu.Lock()
        ds.Processing = true
        rsym := gl.ParseDirImpl(fs, path, opts)
        ds.Processing = false
        ds.Mu.Unlock()
        return rsym
}

// ParseDirExcludes are files to exclude in processing directories
// because they take a long time and aren't very useful (data files).
// Any file that contains one of these strings is excluded.
var ParseDirExcludes = []string{
        "/image/font/gofont/",
        "zerrors_",
        "unicode/tables.go",
        "filecat/mimetype.go",
        "/html/entity.go",
        "/draw/impl.go",
        "/truetype/hint.go",
        "/runtime/proc.go",
}

// ParseDir is the interface call for parsing a directory
func (gl *GoLang) ParseDir(fs *parse.FileState, path string, opts parse.LanguageDirOptions) *syms.Symbol {
        if path == "" || path == "C" || path[0] == '_' {
                return nil
        }
        return TheParseDirs.ParseDir(gl, fs, path, opts)
}

// ParseDirImpl does the actual work of parsing a directory.
// Path is assumed to be a package import path or a local file name
func (gl *GoLang) ParseDirImpl(fs *parse.FileState, path string, opts parse.LanguageDirOptions) *syms.Symbol {
        var files []string
        var pkgPathAbs string
        gm := os.Getenv("GO111MODULE")
        if filepath.IsAbs(path) {
                pkgPathAbs = path
        } else {
                pkgPathAbs = path
                if gm == "off" { // note: using GOPATH manual mechanism as packages.Load is very slow
                        // fmt.Printf("nomod\n")
                        _, err := os.Stat(pkgPathAbs)
                        if os.IsNotExist(err) {
                                pkgPathAbs, err = fsx.GoSrcDir(pkgPathAbs)
                                if err != nil {
                                        if TraceTypes {
                                                log.Println(err)
                                        }
                                        return nil
                                }
                        } else if err != nil {
                                log.Println(err.Error())
                                return nil
                        }
                        pkgPathAbs, _ = filepath.Abs(pkgPathAbs)
                } else { // modules mode
                        fabs, has := fs.PathMapLoad(path) // only use cache for modules mode -- GOPATH is fast
                        if has && !opts.Rebuild {         // rebuild always re-paths
                                pkgPathAbs = fabs
                                // fmt.Printf("using cached path: %s to: %s\n", path, pkgPathAbs)
                        } else {
                                // fmt.Printf("mod: loading package: %s\n", path)
                                // packages automatically deals with GOPATH vs. modules, etc.
                                pkgs, err := packages.Load(&packages.Config{Mode: packages.NeedName | packages.NeedFiles}, path)
                                if err != nil {
                                        // this is too many errors!
                                        // log.Println(err)
                                        return nil
                                }
                                if len(pkgs) != 1 {
                                        fmt.Printf("More than one package for path: %v\n", path)
                                        return nil
                                }
                                pkg := pkgs[0]

                                if len(pkg.GoFiles) == 0 {
                                        // fmt.Printf("No Go files found in package: %v\n", path)
                                        return nil
                                }
                                // files = pkg.GoFiles
                                fgo := pkg.GoFiles[0]
                                pkgPathAbs, _ = filepath.Abs(filepath.Dir(fgo))
                                // fmt.Printf("mod: %v  package: %v PkgPath: %s\n", gm, path, pkgPathAbs)
                        }
                        fs.PathMapStore(path, pkgPathAbs) // cache for later
                }
                // fmt.Printf("Parsing, loading path: %v\n", path)
        }

        files = fsx.Filenames(pkgPathAbs, ".go")
        if len(files) == 0 {
                // fmt.Printf("No go files, bailing\n")
                return nil
        }
        for i, pt := range files {
                files[i] = filepath.Join(pkgPathAbs, pt)
        }

        if !opts.Rebuild {
                csy, cts, err := syms.OpenSymCache(fileinfo.Go, pkgPathAbs)
                if err == nil && csy != nil {
                        sydir := filepath.Dir(csy.Filename)
                        diffPath := sydir != pkgPathAbs
                        // if diffPath {
                        //         fmt.Printf("rebuilding %v because path: %v != cur path: %v\n", path, sydir, pkgPathAbs)
                        // }
                        if diffPath || (!gl.Pr.ModTime.IsZero() && cts.Before(gl.Pr.ModTime)) {
                                // fmt.Printf("rebuilding %v because parser: %v is newer than cache: %v\n", path, gl.Pr.ModTime, cts)
                        } else {
                                lstmod := fsx.LatestMod(pkgPathAbs, ".go")
                                if lstmod.Before(cts) {
                                        // fmt.Printf("loaded cache for: %v from: %v\n", pkgPathAbs, cts)
                                        return csy
                                }
                        }
                }
        }

        pr := gl.Parser()
        var pkgsym *syms.Symbol
        var fss []*parse.FileState // file states for each file
        for _, fpath := range files {
                fnm := filepath.Base(fpath)
                if strings.HasSuffix(fnm, "_test.go") {
                        continue
                }
                // avoid processing long slow files that aren't needed anyway:
                excl := false
                for _, ex := range ParseDirExcludes {
                        if strings.Contains(fpath, ex) {
                                excl = true
                                break
                        }
                }
                if excl {
                        continue
                }
                fs := parse.NewFileState() // we use a separate fs for each file, so we have full ast
                fss = append(fss, fs)
                // optional monitoring of parsing
                // fs.ParseState.Trace.On = true
                // fs.ParseState.Trace.Match = true
                // fs.ParseState.Trace.NoMatch = true
                // fs.ParseState.Trace.Run = true
                // fs.ParseState.Trace.RunAct = true
                // fs.ParseState.Trace.StdOut()
                err := fs.Src.OpenFile(fpath)
                if err != nil {
                        continue
                }
                // fmt.Printf("parsing file: %v\n", fnm)
                // stt := time.Now()
                pr.LexAll(fs)
                // lxdur := time.Since(stt)
                pr.ParseAll(fs)
                // prdur := time.Since(stt)
                // if prdur > 500*time.Millisecond {
                //         fmt.Printf("file: %s full parse: %v\n", fpath, prdur)
                // }
                if len(fs.ParseState.Scopes) > 0 { // should be
                        pkg := fs.ParseState.Scopes[0]
                        gl.DeleteUnexported(pkg, pkg.Name)
                        if pkgsym == nil {
                                pkgsym = pkg
                        } else {
                                pkgsym.CopyFromScope(pkg)
                                if TraceTypes {
                                        pkgsym.Types.PrintUnknowns()
                                }
                        }
                        // } else {
                        //         fmt.Printf("\tno parse state scopes!\n")
                }
        }
        if pkgsym == nil || len(fss) == 0 {
                return nil
        }
        pfs := fss[0]                       // parse.NewFileState()            // master overall package file state
        gl.ResolveTypes(pfs, pkgsym, false) // false = don't include function-internal scope items
        gl.DeleteExternalTypes(pkgsym)
        if !opts.Nocache {
                syms.SaveSymCache(pkgsym, fileinfo.Go, pkgPathAbs)
        }
        pkgsym.ClearAST() // otherwise memory can be huge -- can comment this out for debugging
        for _, fs := range fss {
                fs.Destroy()
        }
        return pkgsym
}

/////////////////////////////////////////////////////////////////////////////
// Go util funcs

// DeleteUnexported deletes lower-case unexported items from map, and
// children of symbols on map
func (gl *GoLang) DeleteUnexported(sy *syms.Symbol, pkgsc string) {
        if sy.Kind.SubCat() != token.NameScope { // only for top-level scopes
                return
        }
        for nm, ss := range sy.Children {
                if ss == sy {
                        fmt.Printf("warning: child is self!: %v\n", sy.String())
                        delete(sy.Children, nm)
                        continue
                }
                if ss.Kind.SubCat() != token.NameScope { // typically lowercase
                        rn, _ := utf8.DecodeRuneInString(nm)
                        if nm == "" || unicode.IsLower(rn) {
                                delete(sy.Children, nm)
                                continue
                        }
                        // sc, has := ss.Scopes[token.NamePackage]
                        // if has && sc != pkgsc {
                        //         fmt.Printf("excluding out-of-scope symbol: %v  %v\n", sc, ss.String())
                        //         delete(sy.Children, nm)
                        //         continue
                        // }
                }
                if ss.HasChildren() {
                        gl.DeleteUnexported(ss, pkgsc)
                }
        }
}

// DeleteExternalTypes deletes types from outside current package scope.
// These can be created during ResolveTypes but should be deleted before
// saving symbol type.
func (gl *GoLang) DeleteExternalTypes(sy *syms.Symbol) {
        pkgsc := sy.Name
        for nm, ty := range sy.Types {
                sc, has := ty.Scopes[token.NamePackage]
                if has && sc != pkgsc {
                        // fmt.Printf("excluding out-of-scope type: %v  %v\n", sc, ty.String())
                        delete(sy.Types, nm)
                        continue
                }
        }
}

// ImportPathPkg returns the package (last dir) and base of import path
// from import path string -- removes any quotes around path first.
func (gl *GoLang) ImportPathPkg(im string) (path, base, pkg string) {
        sz := len(im)
        if sz < 3 {
                return
        }
        path = im
        if im[0] == '"' {
                path = im[1 : sz-1]
        }
        base, pkg = filepath.Split(path)
        return
}

// PkgSyms attempts to find package symbols for given package name.
// Is also passed any current package symbol context in psyms which might be
// different from default filestate context.
func (gl *GoLang) PkgSyms(fs *parse.FileState, psyms syms.SymMap, pnm string) (*syms.Symbol, bool) {
        psym, has := fs.ExtSyms[pnm]
        if has {
                return psym, has
        }
        ipsym, has := gl.FindImportPkg(fs, psyms, pnm) // look for import within psyms package symbols
        if has {
                gl.AddImportToExts(fs, ipsym.Name, false) // no lock
                psym, has = fs.ExtSyms[pnm]
        }
        return psym, has
}

// AddImportsToExts adds imports from given package into parse.FileState.ExtSyms list
// imports are coded as NameLibrary symbols with names = import path
func (gl *GoLang) AddImportsToExts(fss *parse.FileStates, pfs *parse.FileState, pkg *syms.Symbol) {
        var imps syms.SymMap
        pfs.SymsMu.RLock()
        pkg.Children.FindKindScoped(token.NameLibrary, &imps)
        pfs.SymsMu.RUnlock()
        if len(imps) == 0 {
                goto reset
                return
        }
        for _, im := range imps {
                if im.Name == "C" {
                        continue
                }
                // pfs.WaitGp.Add(1) // note: already under an outer-loop go routine
                // with *same* waitgp
                gl.AddImportToExts(pfs, im.Name, false) // no lock
        }
        // pfs.WaitGp.Wait() // each goroutine will do done when done..
        // now all the info is in place: parse it
        if TraceTypes {
                fmt.Printf("\n#####################\nResolving Types now for: %v\n", pfs.Src.Filename)
        }
        gl.ResolveTypes(pfs, pkg, true) // true = do include function-internal scope items
reset:
        pfs.ClearAST()
        pkg.ClearAST()
        // if pfs.AST.HasChildren() {
        //         pfs.AST.DeleteChildren()
        // }
}

// AddImportToExts adds given import into parse.FileState.ExtSyms list
// assumed to be called as a separate goroutine
func (gl *GoLang) AddImportToExts(fs *parse.FileState, im string, lock bool) {
        im, _, pkg := gl.ImportPathPkg(im)
        psym := gl.ParseDir(fs, im, parse.LanguageDirOptions{})
        if psym != nil {
                psym.Name = pkg
                if lock {
                        fs.SymsMu.Lock()
                }
                gl.AddPkgToExts(fs, psym)
                if lock {
                        fs.SymsMu.Unlock()
                }
        }
        if lock {
                fs.WaitGp.Done()
        }
}

// AddPathToSyms adds given path into parse.FileState.Syms list
// Is called as a separate goroutine in ParseFile with WaitGp
func (gl *GoLang) AddPathToSyms(fs *parse.FileState, path string) {
        psym := gl.ParseDir(fs, path, parse.LanguageDirOptions{})
        if psym != nil {
                gl.AddPkgToSyms(fs, psym)
        }
        fs.WaitGp.Done()
}

// AddPkgToSyms adds given package symbol, with children from package
// to parse.FileState.Syms map -- merges with anything already there
// does NOT add imports -- that is an optional second step.
// Returns true if there was an existing entry for this package.
func (gl *GoLang) AddPkgToSyms(fs *parse.FileState, pkg *syms.Symbol) bool {
        fs.SymsMu.Lock()
        psy, has := fs.Syms[pkg.Name]
        if has {
                // fmt.Printf("AddPkgToSyms: importing pkg types: %v\n", pkg.Name)
                psy.CopyFromScope(pkg)
                if TraceTypes {
                        psy.Types.PrintUnknowns()
                }
        } else {
                fs.Syms[pkg.Name] = pkg
        }
        fs.SymsMu.Unlock()
        return has
}

// AddPathToExts adds given path into parse.FileState.ExtSyms list
// assumed to be called as a separate goroutine
func (gl *GoLang) AddPathToExts(fs *parse.FileState, path string) {
        psym := gl.ParseDir(fs, path, parse.LanguageDirOptions{})
        if psym != nil {
                gl.AddPkgToExts(fs, psym)
        }
}

// AddPkgToExts adds given package symbol, with children from package
// to parse.FileState.ExtSyms map -- merges with anything already there
// does NOT add imports -- that is an optional second step.
// Returns true if there was an existing entry for this package.
func (gl *GoLang) AddPkgToExts(fs *parse.FileState, pkg *syms.Symbol) bool {
        psy, has := fs.ExtSyms[pkg.Name]
        if has {
                psy.CopyFromScope(pkg)
                pkg = psy
        } else {
                if fs.ExtSyms == nil {
                        fs.ExtSyms = make(syms.SymMap)
                }
                fs.ExtSyms[pkg.Name] = pkg
        }
        return has
}

// FindImportPkg attempts to find an import package based on symbols in
// an existing package.  For indirect loading of packages from other packages
// that we don't direct import.
func (gl *GoLang) FindImportPkg(fs *parse.FileState, psyms syms.SymMap, nm string) (*syms.Symbol, bool) {
        for _, sy := range psyms {
                if sy.Kind != token.NameLibrary {
                        continue
                }
                _, _, pkg := gl.ImportPathPkg(sy.Name)
                if pkg == nm {
                        return sy, true
                }
        }
        return nil, false
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        "fmt"
        "os"
        "strings"

        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/parser"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/token"
)

// TypeErr indicates is the type name we use to indicate that the type could not be inferred
var TypeErr = "<err>"

// TypeInProcess indicates is the type name we use to indicate that the type
// is currently being processed -- prevents loops
var TypeInProcess = "<in-process>"

// InferSymbolType infers the symbol types for given symbol and all of its children
// funInternal determines whether to include function-internal symbols
// (e.g., variables within function scope -- only for local files).
func (gl *GoLang) InferSymbolType(sy *syms.Symbol, fs *parse.FileState, pkg *syms.Symbol, funInternal bool) {
        if sy.Name == "" {
                sy.Type = TypeErr
                return
        }
        if sy.Name[0] == '_' {
                sy.Type = TypeErr
                return
        }
        if sy.AST != nil {
                ast := sy.AST.(*parser.AST)
                switch {
                case sy.Kind == token.NameField:
                        stsc, ok := sy.Scopes[token.NameStruct]
                        if ok {
                                stty, _ := gl.FindTypeName(stsc, fs, pkg)
                                if stty != nil {
                                        fldel := stty.Els.ByName(sy.Name)
                                        if fldel != nil {
                                                sy.Type = fldel.Type
                                                // fmt.Printf("set field type: %s\n", sy.Label())
                                        } else {
                                                if TraceTypes {
                                                        fmt.Printf("InferSymbolType: field named: %v not found in struct type: %v\n", sy.Name, stty.Name)
                                                }
                                        }
                                } else {
                                        if TraceTypes {
                                                fmt.Printf("InferSymbolType: field named: %v struct type: %v not found\n", sy.Name, stsc)
                                        }
                                }
                                if sy.Type == "" {
                                        sy.Type = stsc + "." + sy.Name
                                }
                        } else {
                                if TraceTypes {
                                        fmt.Printf("InferSymbolType: field named: %v doesn't have NameStruct scope\n", sy.Name)
                                }
                        }
                case sy.Kind == token.NameVarClass: // method receiver
                        stsc, ok := sy.Scopes.SubCat(token.NameType)
                        if ok {
                                sy.Type = stsc
                        }
                case sy.Kind.SubCat() == token.NameVar:
                        var astyp *parser.AST
                        if ast.HasChildren() {
                                if strings.HasPrefix(ast.Name, "ForRange") {
                                        gl.InferForRangeSymbolType(sy, fs, pkg)
                                } else {
                                        astyp = ast.ChildAST(len(ast.Children) - 1)
                                        vty, ok := gl.TypeFromAST(fs, pkg, nil, astyp)
                                        if ok {
                                                sy.Type = SymTypeNameForPkg(vty, pkg)
                                                // if TraceTypes {
                                                //         fmt.Printf("namevar: %v  type: %v from ast\n", sy.Name, sy.Type)
                                                // }
                                        } else {
                                                sy.Type = TypeErr // actively mark as err so not re-processed
                                                if TraceTypes {
                                                        fmt.Printf("InferSymbolType: NameVar: %v NOT resolved from ast: %v\n", sy.Name, astyp.Path())
                                                        astyp.WriteTree(os.Stdout, 0)
                                                }
                                        }
                                }
                        } else {
                                sy.Type = TypeErr
                                if TraceTypes {
                                        fmt.Printf("InferSymbolType: NameVar: %v has no children\n", sy.Name)
                                }
                        }
                case sy.Kind == token.NameConstant:
                        if !strings.HasPrefix(ast.Name, "ConstSpec") {
                                if TraceTypes {
                                        fmt.Printf("InferSymbolType: NameConstant: %v not a const: %v\n", sy.Name, ast.Name)
                                }
                                return
                        }
                        parent := ast.ParentAST()
                        if parent != nil && parent.HasChildren() {
                                fc := parent.ChildAST(0)
                                if fc.HasChildren() {
                                        ffc := fc.ChildAST(0)
                                        if ffc.Name == "Name" {
                                                ffc = ffc.NextAST()
                                        }
                                        var vty *syms.Type
                                        if ffc != nil {
                                                vty, _ = gl.TypeFromAST(fs, pkg, nil, ffc)
                                        }
                                        if vty != nil {
                                                sy.Type = SymTypeNameForPkg(vty, pkg)
                                        } else {
                                                sy.Type = TypeErr
                                                if TraceTypes {
                                                        fmt.Printf("InferSymbolType: NameConstant: %v NOT resolved from ast: %v\n", sy.Name, ffc.Path())
                                                        ffc.WriteTree(os.Stdout, 1)
                                                }
                                        }
                                } else {
                                        sy.Type = TypeErr
                                }
                        } else {
                                sy.Type = TypeErr
                        }
                case sy.Kind.SubCat() == token.NameType:
                        vty, _ := gl.FindTypeName(sy.Name, fs, pkg)
                        if vty != nil {
                                sy.Type = SymTypeNameForPkg(vty, pkg)
                        } else {
                                // if TraceTypes {
                                //         fmt.Printf("InferSymbolType: NameType: %v\n", sy.Name)
                                // }
                                if ast.HasChildren() {
                                        astyp := ast.ChildAST(len(ast.Children) - 1)
                                        if astyp.Name == "FieldTag" {
                                                // ast.WriteTree(os.Stdout, 1)
                                                astyp = ast.ChildAST(len(ast.Children) - 2)
                                        }
                                        vty, ok := gl.TypeFromAST(fs, pkg, nil, astyp)
                                        if ok {
                                                sy.Type = SymTypeNameForPkg(vty, pkg)
                                                // if TraceTypes {
                                                //         fmt.Printf("InferSymbolType: NameType: %v  type: %v from ast\n", sy.Name, sy.Type)
                                                // }
                                        } else {
                                                sy.Type = TypeErr // actively mark as err so not re-processed
                                                if TraceTypes {
                                                        fmt.Printf("InferSymbolType: NameType: %v NOT resolved from ast: %v\n", sy.Name, astyp.Path())
                                                        ast.WriteTree(os.Stdout, 1)
                                                }
                                        }
                                } else {
                                        sy.Type = TypeErr
                                }
                        }
                case sy.Kind == token.NameFunction:
                        ftyp := gl.FuncTypeFromAST(fs, pkg, ast, nil)
                        if ftyp != nil {
                                ftyp.Name = "func " + sy.Name
                                ftyp.Filename = sy.Filename
                                ftyp.Region = sy.Region
                                sy.Type = ftyp.Name
                                pkg.Types.Add(ftyp)
                                sy.Detail = "(" + ftyp.ArgString() + ") " + ftyp.ReturnString()
                                // if TraceTypes {
                                //         fmt.Printf("InferSymbolType: added function type: %v  %v\n", ftyp.Name, ftyp.String())
                                // }
                        }
                }
        }
        if !funInternal && sy.Kind.SubCat() == token.NameFunction {
                sy.Children = nil // nuke!
        } else {
                for _, ss := range sy.Children {
                        if sy != ss {
                                if false && TraceTypes {
                                        fmt.Printf("InferSymbolType: processing child: %v\n", ss)
                                }
                                gl.InferSymbolType(ss, fs, pkg, funInternal)
                        }
                }
        }
}

// InferForRangeSymbolType infers the type of a ForRange expr
// gets the container type properly
func (gl *GoLang) InferForRangeSymbolType(sy *syms.Symbol, fs *parse.FileState, pkg *syms.Symbol) {
        ast := sy.AST.(*parser.AST)
        if ast.NumChildren() < 2 {
                sy.Type = TypeErr // actively mark as err so not re-processed
                if TraceTypes {
                        fmt.Printf("InferSymbolType: ForRange NameVar: %v does not have expected 2+ children\n", sy.Name)
                        ast.WriteTree(os.Stdout, 0)
                }
                return
        }
        // vars are in first child, type is in second child, rest of code is on last node
        astyp := ast.ChildAST(1)
        vty, ok := gl.TypeFromAST(fs, pkg, nil, astyp)
        if !ok {
                sy.Type = TypeErr // actively mark as err so not re-processed
                if TraceTypes {
                        fmt.Printf("InferSymbolType: NameVar: %v NOT resolved from ForRange ast: %v\n", sy.Name, astyp.Path())
                        astyp.WriteTree(os.Stdout, 0)
                }
                return
        }

        varidx := 1 // which variable are we: first or second?
        vast := ast.ChildAST(0)
        if vast.NumChildren() <= 1 {
                varidx = 0
        } else if vast.ChildAST(0).Src == sy.Name {
                varidx = 0
        }
        // vty is the container -- first el should be the type of element
        switch vty.Kind {
        case syms.Map: // need to know if we are the key or el
                if len(vty.Els) > 1 {
                        tn := vty.Els[varidx].Type
                        if IsQualifiedType(vty.Name) && !IsQualifiedType(tn) {
                                pnm, _ := SplitType(vty.Name)
                                sy.Type = QualifyType(pnm, tn)
                        } else {
                                sy.Type = tn
                        }
                } else {
                        sy.Type = TypeErr
                        if TraceTypes {
                                fmt.Printf("InferSymbolType: %s has ForRange over Map on type without an el type: %v\n", sy.Name, vty.Name)
                        }
                }
        case syms.Array, syms.List:
                if varidx == 0 {
                        sy.Type = "int"
                } else if len(vty.Els) > 0 {
                        tn := vty.Els[0].Type
                        if IsQualifiedType(vty.Name) && !IsQualifiedType(tn) {
                                pnm, _ := SplitType(vty.Name)
                                sy.Type = QualifyType(pnm, tn)
                        } else {
                                sy.Type = tn
                        }
                } else {
                        sy.Type = TypeErr
                        if TraceTypes {
                                fmt.Printf("InferSymbolType: %s has ForRange over Array, List on type without an el type: %v\n", sy.Name, vty.Name)
                        }
                }
        case syms.String:
                if varidx == 0 {
                        sy.Type = "int"
                } else {
                        sy.Type = "rune"
                }
        default:
                sy.Type = TypeErr
                if TraceTypes {
                        fmt.Printf("InferSymbolType: %s has ForRange over non-container type: %v kind: %v\n", sy.Name, vty.Name, vty.Kind)
                }
        }
}

// InferEmptySymbolType ensures that any empty symbol type is resolved during
// processing of other type information -- returns true if was able to resolve
func (gl *GoLang) InferEmptySymbolType(sym *syms.Symbol, fs *parse.FileState, pkg *syms.Symbol) bool {
        if sym.Type == "" { // hasn't happened yet
                // if TraceTypes {
                //         fmt.Printf("TExpr: trying to infer type\n")
                // }
                sym.Type = TypeInProcess
                gl.InferSymbolType(sym, fs, pkg, true)
        }
        if sym.Type == TypeInProcess {
                if TraceTypes {
                        fmt.Printf("TExpr: source symbol is in process -- we have a loop: %v  kind: %v\n", sym.Name, sym.Kind)
                }
                sym.Type = TypeErr
                return false
        }
        if sym.Type == TypeErr {
                if TraceTypes {
                        fmt.Printf("TExpr: source symbol has type err: %v  kind: %v\n", sym.Name, sym.Kind)
                }
                return false
        }
        if sym.Type == "" { // shouldn't happen
                sym.Type = TypeErr
                if TraceTypes {
                        fmt.Printf("TExpr: source symbol has type err (but wasn't marked): %v  kind: %v\n", sym.Name, sym.Kind)
                }
                return false
        }
        return true
}

func SymTypeNameForPkg(ty *syms.Type, pkg *syms.Symbol) string {
        sc, has := ty.Scopes[token.NamePackage]
        if has && sc != pkg.Name {
                return QualifyType(sc, ty.Name)
        }
        return ty.Name
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/token"
)

// FuncParams returns the parameters of given function / method symbol,
// in proper order, name type for each param space separated in string
func (gl *GoLang) FuncParams(fsym *syms.Symbol) []string {
        var ps []string
        for _, cs := range fsym.Children {
                if cs.Kind != token.NameVarParam {
                        continue
                }
                if len(ps) <= cs.Index {
                        op := ps
                        ps = make([]string, cs.Index+1)
                        copy(ps, op)
                }
                s := cs.Name + " " + cs.Type
                ps[cs.Index] = s
        }
        return ps
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package golang

import (
        "fmt"
        "strings"

        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/parser"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/token"
)

var TraceTypes = false

// IsQualifiedType returns true if type is qualified by a package prefix
// is sensitive to [] or map[ prefix so it does NOT report as a qualified type in that
// case -- it is a compound local type defined in terms of a qualified type.
func IsQualifiedType(tnm string) bool {
        if strings.HasPrefix(tnm, "[]") || strings.HasPrefix(tnm, "map[") {
                return false
        }
        return strings.Index(tnm, ".") > 0
}

// QualifyType returns the type name tnm qualified by pkgnm if it is non-empty
// and only if tnm is not a basic type name
func QualifyType(pkgnm, tnm string) string {
        if pkgnm == "" || IsQualifiedType(tnm) {
                return tnm
        }
        if _, btyp := BuiltinTypes[tnm]; btyp {
                return tnm
        }
        return pkgnm + "." + tnm
}

// SplitType returns the package and type names from a potentially qualified
// type name -- if it is not qualified, package name is empty.
// is sensitive to [] prefix so it does NOT split in that case
func SplitType(nm string) (pkgnm, tnm string) {
        if !IsQualifiedType(nm) {
                return "", nm
        }
        sci := strings.Index(nm, ".")
        return nm[:sci], nm[sci+1:]
}

// PrefixType returns the type name prefixed with given prefix -- keeps any
// package name as the outer scope.
func PrefixType(pfx, nm string) string {
        pkgnm, tnm := SplitType(nm)
        return QualifyType(pkgnm, pfx+tnm)
}

// FindTypeName finds given type name in pkg and in broader context
// returns new package symbol if type name is in a different package
// else returns pkg arg.
func (gl *GoLang) FindTypeName(tynm string, fs *parse.FileState, pkg *syms.Symbol) (*syms.Type, *syms.Symbol) {
        if tynm == "" {
                return nil, nil
        }
        if tynm[0] == '*' {
                tynm = tynm[1:]
        }
        pnm, tnm := SplitType(tynm)
        if pnm == "" {
                if btyp, ok := BuiltinTypes[tnm]; ok {
                        return btyp, pkg
                }
                if gtyp, ok := pkg.Types[tnm]; ok {
                        return gtyp, pkg
                }
                // if TraceTypes {
                //         fmt.Printf("FindTypeName: unqualified type name: %v not found in package: %v\n", tnm, pkg.Name)
                // }
                return nil, pkg
        }
        if npkg, ok := gl.PkgSyms(fs, pkg.Children, pnm); ok {
                if gtyp, ok := npkg.Types[tnm]; ok {
                        return gtyp, npkg
                }
                if TraceTypes {
                        fmt.Printf("FindTypeName: type name: %v not found in package: %v\n", tnm, pnm)
                }
        } else {
                if TraceTypes {
                        fmt.Printf("FindTypeName: could not find package: %v\n", pnm)
                }
        }
        if TraceTypes {
                fmt.Printf("FindTypeName: type name: %v not found in package: %v\n", tynm, pkg.Name)
        }
        return nil, pkg
}

// ResolveTypes initializes all user-defined types from AST data
// and then resolves types of symbols.  The pkg must be a single
// package symbol i.e., the children there are all the elements of the
// package and the types are all the global types within the package.
// funInternal determines whether to include function-internal symbols
// (e.g., variables within function scope -- only for local files).
func (gl *GoLang) ResolveTypes(fs *parse.FileState, pkg *syms.Symbol, funInternal bool) {
        fs.SymsMu.Lock()
        gl.TypesFromAST(fs, pkg)
        gl.InferSymbolType(pkg, fs, pkg, funInternal)
        fs.SymsMu.Unlock()
}

// TypesFromAST initializes the types from their AST parse
func (gl *GoLang) TypesFromAST(fs *parse.FileState, pkg *syms.Symbol) {
        InstallBuiltinTypes()

        for _, ty := range pkg.Types {
                gl.InitTypeFromAST(fs, pkg, ty)
        }
}

// InitTypeFromAST initializes given type from ast
func (gl *GoLang) InitTypeFromAST(fs *parse.FileState, pkg *syms.Symbol, ty *syms.Type) {
        if ty.AST == nil || len(ty.AST.AsTree().Children) < 2 {
                // if TraceTypes {
                //         fmt.Printf("TypesFromAST: Type has nil AST! %v\n", ty.String())
                // }
                return
        }
        tyast := ty.AST.(*parser.AST).ChildAST(1)
        if tyast == nil {
                if TraceTypes {
                        fmt.Printf("TypesFromAST: Type has invalid AST! %v missing child 1\n", ty.String())
                }
                return
        }
        if ty.Name == "" {
                if TraceTypes {
                        fmt.Printf("TypesFromAST: Type has no name! %v\n", ty.String())
                }
                return
        }
        if ty.Initialized {
                // if TraceTypes {
                //         fmt.Printf("Type: %v already initialized\n", ty.Name)
                // }
                return
        }
        gl.TypeFromAST(fs, pkg, ty, tyast)
        gl.TypeMeths(fs, pkg, ty) // all top-level named types might have methods
        ty.Initialized = true
}

// SubTypeFromAST returns a subtype from child ast at given index, nil if failed
func (gl *GoLang) SubTypeFromAST(fs *parse.FileState, pkg *syms.Symbol, ast *parser.AST, idx int) (*syms.Type, bool) {
        sast := ast.ChildASTTry(idx)
        if sast == nil {
                if TraceTypes {
                        fmt.Printf("TraceTypes: could not find child %d on ast %v", idx, ast)
                }
                return nil, false
        }
        return gl.TypeFromAST(fs, pkg, nil, sast)
}

// TypeToKindMap maps AST type names to syms.Kind basic categories for how we
// treat them for subsequent processing.  Basically: Primitive or Composite
var TypeToKindMap = map[string]syms.Kinds{
        "BasicType":     syms.Primitive,
        "TypeNm":        syms.Primitive,
        "QualType":      syms.Primitive,
        "PointerType":   syms.Primitive,
        "MapType":       syms.Composite,
        "SliceType":     syms.Composite,
        "ArrayType":     syms.Composite,
        "StructType":    syms.Composite,
        "InterfaceType": syms.Composite,
        "FuncType":      syms.Composite,
        "StringDbl":     syms.KindsN, // note: Lit is removed by ASTTypeName
        "StringTicks":   syms.KindsN,
        "Rune":          syms.KindsN,
        "NumInteger":    syms.KindsN,
        "NumFloat":      syms.KindsN,
        "NumImag":       syms.KindsN,
}

// ASTTypeName returns the effective type name from ast node
// dropping the "Lit" for example.
func (gl *GoLang) ASTTypeName(tyast *parser.AST) string {
        tnm := tyast.Name
        if strings.HasPrefix(tnm, "Lit") {
                tnm = tnm[3:]
        }
        return tnm
}

// TypeFromAST returns type from AST parse -- returns true if successful.
// This is used both for initialization of global types via TypesFromAST
// and also for online type processing in the course of tracking down
// other types while crawling the AST.  In the former case, ty is non-nil
// and the goal is to fill out the type information -- the ty will definitely
// have a name already.  In the latter case, the ty will be nil, but the
// tyast node may have a Src name that will first be looked up to determine
// if a previously processed type is already available.  The tyast.Name is
// the parser categorization of the type  (BasicType, StructType, etc).
func (gl *GoLang) TypeFromAST(fs *parse.FileState, pkg *syms.Symbol, ty *syms.Type, tyast *parser.AST) (*syms.Type, bool) {
        tnm := gl.ASTTypeName(tyast)
        bkind, ok := TypeToKindMap[tnm]
        if !ok { // must be some kind of expression
                sty, _, got := gl.TypeFromASTExprStart(fs, pkg, pkg, tyast)
                return sty, got
        }
        switch bkind {
        case syms.Primitive:
                return gl.TypeFromASTPrim(fs, pkg, ty, tyast)
        case syms.Composite:
                return gl.TypeFromASTComp(fs, pkg, ty, tyast)
        case syms.KindsN:
                return gl.TypeFromASTLit(fs, pkg, ty, tyast)
        }
        return nil, false
}

// TypeFromASTPrim handles primitive (non composite) type processing
func (gl *GoLang) TypeFromASTPrim(fs *parse.FileState, pkg *syms.Symbol, ty *syms.Type, tyast *parser.AST) (*syms.Type, bool) {
        tnm := gl.ASTTypeName(tyast)
        src := tyast.Src
        etyp, tpkg := gl.FindTypeName(src, fs, pkg)
        if etyp != nil {
                if ty == nil { // if we can find an existing type, and not filling in global, use it
                        if tpkg != pkg {
                                pkgnm := tpkg.Name
                                qtnm := QualifyType(pkgnm, etyp.Name)
                                if qtnm != etyp.Name {
                                        if letyp, ok := pkg.Types[qtnm]; ok {
                                                etyp = letyp
                                        } else {
                                                ntyp := &syms.Type{}
                                                *ntyp = *etyp
                                                ntyp.Name = qtnm
                                                pkg.Types.Add(ntyp)
                                                etyp = ntyp
                                        }
                                }
                        }
                        return etyp, true
                }
        } else {
                if TraceTypes && src != "" {
                        fmt.Printf("TypeFromAST: primitive type name: %v not found\n", src)
                }
        }
        switch tnm {
        case "BasicType":
                if etyp != nil {
                        ty.Kind = etyp.Kind
                        ty.Els.Add("par", etyp.Name) // parent type
                        return ty, true
                }
                return nil, false
        case "TypeNm", "QualType":
                if etyp != nil && etyp != ty {
                        ty.Kind = etyp.Kind
                        if ty.Name != etyp.Name {
                                ty.Els.Add("par", etyp.Name) // parent type
                                if TraceTypes {
                                        fmt.Printf("TypeFromAST: TypeNm %v defined from parent type: %v\n", ty.Name, etyp.Name)
                                }
                        }
                        return ty, true
                }
                return nil, false
        case "PointerType":
                if ty == nil {
                        ty = &syms.Type{}
                }
                ty.Kind = syms.Ptr
                if sty, ok := gl.SubTypeFromAST(fs, pkg, tyast, 0); ok {
                        ty.Els.Add("ptr", sty.Name)
                        if ty.Name == "" {
                                ty.Name = "*" + sty.Name
                                pkg.Types.Add(ty) // add pointers so we don't have to keep redefining
                                if TraceTypes {
                                        fmt.Printf("TypeFromAST: Adding PointerType: %v\n", ty.String())
                                }
                        }
                        return ty, true
                }
                return nil, false
        }
        return nil, false
}

// TypeFromASTComp handles composite type processing
func (gl *GoLang) TypeFromASTComp(fs *parse.FileState, pkg *syms.Symbol, ty *syms.Type, tyast *parser.AST) (*syms.Type, bool) {
        tnm := gl.ASTTypeName(tyast)
        newTy := false
        if ty == nil {
                newTy = true
                ty = &syms.Type{}
        }
        switch tnm {
        case "MapType":
                ty.Kind = syms.Map
                keyty, kok := gl.SubTypeFromAST(fs, pkg, tyast, 0)
                valty, vok := gl.SubTypeFromAST(fs, pkg, tyast, 1)
                if kok && vok {
                        ty.Els.Add("key", SymTypeNameForPkg(keyty, pkg))
                        ty.Els.Add("val", SymTypeNameForPkg(valty, pkg))
                        if newTy {
                                ty.Name = "map[" + keyty.Name + "]" + valty.Name
                        }
                } else {
                        return nil, false
                }
        case "SliceType":
                ty.Kind = syms.List
                valty, ok := gl.SubTypeFromAST(fs, pkg, tyast, 0)
                if ok {
                        ty.Els.Add("val", SymTypeNameForPkg(valty, pkg))
                        if newTy {
                                ty.Name = "[]" + valty.Name
                        }
                } else {
                        return nil, false
                }
        case "ArrayType":
                ty.Kind = syms.Array
                valty, ok := gl.SubTypeFromAST(fs, pkg, tyast, 1)
                if ok {
                        ty.Els.Add("val", SymTypeNameForPkg(valty, pkg))
                        if newTy {
                                ty.Name = "[]" + valty.Name // todo: get size from child0, set to Size
                        }
                } else {
                        return nil, false
                }
        case "StructType":
                ty.Kind = syms.Struct
                nfld := len(tyast.Children)
                if nfld == 0 {
                        return BuiltinTypes["struct{}"], true
                }
                ty.Size = []int{nfld}
                for i := 0; i < nfld; i++ {
                        fld := tyast.Children[i].(*parser.AST)
                        fsrc := fld.Src
                        switch fld.Name {
                        case "NamedField":
                                if len(fld.Children) <= 1 { // anonymous, non-qualified
                                        ty.Els.Add(fsrc, fsrc)
                                        gl.StructInheritEls(fs, pkg, ty, fsrc)
                                        continue
                                }
                                fldty, ok := gl.SubTypeFromAST(fs, pkg, fld, 1)
                                if ok {
                                        nms := gl.NamesFromAST(fs, pkg, fld, 0)
                                        for _, nm := range nms {
                                                ty.Els.Add(nm, SymTypeNameForPkg(fldty, pkg))
                                        }
                                }
                        case "AnonQualField":
                                ty.Els.Add(fsrc, fsrc) // anon two are same
                                gl.StructInheritEls(fs, pkg, ty, fsrc)
                        }
                }
                if newTy {
                        ty.Name = fs.NextAnonName(pkg.Name + "_struct")
                }
                // if TraceTypes {
                //         fmt.Printf("TypeFromAST: New struct type defined: %v\n", ty.Name)
                //         ty.WriteDoc(os.Stdout, 0)
                // }
        case "InterfaceType":
                ty.Kind = syms.Interface
                nmth := len(tyast.Children)
                if nmth == 0 {
                        return BuiltinTypes["interface{}"], true
                }
                ty.Size = []int{nmth}
                for i := 0; i < nmth; i++ {
                        fld := tyast.Children[i].(*parser.AST)
                        fsrc := fld.Src
                        switch fld.Name {
                        case "MethSpecAnonLocal":
                                fallthrough
                        case "MethSpecAnonQual":
                                ty.Els.Add(fsrc, fsrc) // anon two are same
                        case "MethSpecName":
                                if nm := fld.ChildAST(0); nm != nil {
                                        mty := syms.NewType(ty.Name+":"+nm.Src, syms.Method)
                                        pkg.Types.Add(mty)                    // add interface methods as new types..
                                        gl.FuncTypeFromAST(fs, pkg, fld, mty) // todo: this is not working -- debug
                                        ty.Els.Add(nm.Src, mty.Name)
                                }
                        }
                }
                if newTy {
                        if nmth == 0 {
                                ty.Name = "interface{}"
                        } else {
                                ty.Name = fs.NextAnonName(pkg.Name + "_interface")
                        }
                }
        case "FuncType":
                ty.Kind = syms.Func
                gl.FuncTypeFromAST(fs, pkg, tyast, ty)
                if newTy {
                        if len(ty.Els) == 0 {
                                ty.Name = "func()"
                        } else {
                                ty.Name = fs.NextAnonName(pkg.Name + "_func")
                        }
                }
        }
        if newTy {
                etyp, has := pkg.Types[ty.Name]
                if has {
                        return etyp, true
                }
                pkg.Types.Add(ty) // add anon composite types
                // if TraceTypes {
                //         fmt.Printf("TypeFromASTComp: Created new anon composite type: %v %s\n", ty.Name, ty.String())
                // }
        }
        return ty, true // fallthrough is true..
}

// TypeFromASTLit gets type from literals
func (gl *GoLang) TypeFromASTLit(fs *parse.FileState, pkg *syms.Symbol, ty *syms.Type, tyast *parser.AST) (*syms.Type, bool) {
        tnm := tyast.Name
        var bty *syms.Type
        switch tnm {
        case "LitStringDbl":
                bty = BuiltinTypes["string"]
        case "LitStringTicks":
                bty = BuiltinTypes["string"]
        case "LitRune":
                bty = BuiltinTypes["rune"]
        case "LitNumInteger":
                bty = BuiltinTypes["int"]
        case "LitNumFloat":
                bty = BuiltinTypes["float64"]
        case "LitNumImag":
                bty = BuiltinTypes["complex128"]
        }
        if bty == nil {
                return nil, false
        }
        if ty == nil {
                return bty, true
        }
        ty.Kind = bty.Kind
        ty.Els.Add("par", bty.Name) // parent type
        return ty, true
}

// StructInheritEls inherits struct fields and meths from given embedded type.
// Ensures that copied values are properly qualified if from another package.
func (gl *GoLang) StructInheritEls(fs *parse.FileState, pkg *syms.Symbol, ty *syms.Type, etynm string) {
        ety, _ := gl.FindTypeName(etynm, fs, pkg)
        if ety == nil {
                if TraceTypes {
                        fmt.Printf("Embedded struct type not found: %v for type: %v\n", etynm, ty.Name)
                }
                return
        }
        if !ety.Initialized {
                // if TraceTypes {
                //         fmt.Printf("Embedded struct type not yet initialized, initializing: %v for type: %v\n", ety.Name, ty.Name)
                // }
                gl.InitTypeFromAST(fs, pkg, ety)
        }
        pkgnm := pkg.Name
        diffPkg := false
        epkg, has := ety.Scopes[token.NamePackage]
        if has && epkg != pkgnm {
                diffPkg = true
        }
        if diffPkg {
                for i := range ety.Els {
                        nt := ety.Els[i].Clone()
                        tnm := nt.Type
                        _, isb := BuiltinTypes[tnm]
                        if !isb && !IsQualifiedType(tnm) {
                                tnm = QualifyType(epkg, tnm)
                                // fmt.Printf("Fixed type: %v to %v\n", ety.Els[i].Type, tnm)
                        }
                        nt.Type = tnm
                        ty.Els = append(ty.Els, *nt)
                }
                nmt := len(ety.Meths)
                if nmt > 0 {
                        ty.Meths = make(syms.TypeMap, nmt)
                        for mn, mt := range ety.Meths {
                                nmt := mt.Clone()
                                for i := range nmt.Els {
                                        t := &nmt.Els[i]
                                        tnm := t.Type
                                        _, isb := BuiltinTypes[tnm]
                                        if !isb && !IsQualifiedType(tnm) {
                                                tnm = QualifyType(epkg, tnm)
                                        }
                                        t.Type = tnm
                                }
                                ty.Meths[mn] = nmt
                        }
                }
        } else {
                ty.Els.CopyFrom(ety.Els)
                ty.Meths.CopyFrom(ety.Meths, false) // dest is newer
        }
        ty.Size[0] += len(ety.Els)
        // if TraceTypes {
        //         fmt.Printf("Struct Type: %v inheriting from: %v\n", ty.Name, ety.Name)
        // }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package languages

import (
        "fmt"

        "cogentcore.org/core/base/fileinfo"
)

var ParserBytes map[fileinfo.Known][]byte = make(map[fileinfo.Known][]byte)

func OpenParser(sl fileinfo.Known) ([]byte, error) {
        parserBytes, ok := ParserBytes[sl]
        if !ok {
                return nil, fmt.Errorf("langs.OpenParser: no parser bytes for %v", sl)
        }
        return parserBytes, nil
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package markdown

import (
        "log"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/text/csl"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/parse/languages/bibtex"
        "cogentcore.org/core/text/textpos"
)

// CompleteCite does completion on citation
func (ml *MarkdownLang) CompleteCite(fss *parse.FileStates, origStr, str string, pos textpos.Pos) (md complete.Matches) {
        bfile, has := fss.MetaData("bibfile")
        if !has {
                return
        }
        if strings.HasSuffix(bfile, ".bib") {
                bf, err := ml.Bibs.Open(bfile)
                if err != nil {
                        return
                }
                md.Seed = str
                for _, be := range bf.BibTex.Entries {
                        if strings.HasPrefix(be.CiteName, str) {
                                c := complete.Completion{Text: be.CiteName, Label: be.CiteName, Icon: icons.Field}
                                md.Matches = append(md.Matches, c)
                        }
                }
                return md
        }
        bf, err := ml.CSLs.Open(bfile)
        if errors.Log(err) != nil {
                return
        }
        md.Seed = str
        for _, it := range bf.Items.Values {
                if strings.HasPrefix(it.CitationKey, str) {
                        c := complete.Completion{Text: it.CitationKey, Label: it.CitationKey, Icon: icons.Field}
                        md.Matches = append(md.Matches, c)
                }
        }
        return md
}

// LookupCite does lookup on citation.
func (ml *MarkdownLang) LookupCite(fss *parse.FileStates, origStr, str string, pos textpos.Pos) (ld complete.Lookup) {
        bfile, has := fss.MetaData("bibfile")
        if !has {
                return
        }
        if strings.HasSuffix(bfile, ".bib") {
                bf, err := ml.Bibs.Open(bfile)
                if err != nil {
                        return
                }
                lkbib := bibtex.NewBibTex()
                for _, be := range bf.BibTex.Entries {
                        if strings.HasPrefix(be.CiteName, str) {
                                lkbib.Entries = append(lkbib.Entries, be)
                        }
                }
                if len(lkbib.Entries) > 0 {
                        ld.SetFile(fss.Filename, 0, 0)
                        ld.Text = []byte(lkbib.PrettyString())
                }
                return ld
        }
        bf, err := ml.CSLs.Open(bfile)
        if err != nil {
                return
        }
        var items []csl.Item
        for _, be := range bf.Items.Values {
                if strings.HasPrefix(be.CitationKey, str) {
                        items = append(items, *be)
                }
        }
        if len(items) > 0 {
                kl := csl.NewKeyList(items)
                ld.SetFile(fss.Filename, 0, 0)
                ld.Text = []byte(kl.PrettyString())
        }
        return ld
}

// OpenBibfile attempts to find the bibliography file, and load it.
// Sets meta data "bibfile" to resulting file if found, and deletes it if not.
func (ml *MarkdownLang) OpenBibfile(fss *parse.FileStates, pfs *parse.FileState) error {
        bfile := ml.FindBibliography(pfs)
        if bfile == "" {
                fss.DeleteMetaData("bibfile")
                return nil
        }
        if strings.HasSuffix(bfile, ".bib") {
                _, err := ml.Bibs.Open(bfile)
                if err != nil {
                        log.Println(err)
                        fss.DeleteMetaData("bibfile")
                        return err
                }
                fss.SetMetaData("bibfile", bfile)
                return nil
        }
        _, err := ml.CSLs.Open(bfile)
        if err != nil {
                log.Println(err)
                fss.DeleteMetaData("bibfile")
                return err
        }
        fss.SetMetaData("bibfile", bfile)
        return nil
}

// FindBibliography looks for yaml metadata at top of markdown file
func (ml *MarkdownLang) FindBibliography(pfs *parse.FileState) string {
        nlines := pfs.Src.NLines()
        if nlines < 3 {
                return ""
        }
        fln := string(pfs.Src.Lines[0])
        if !(fln == "---" || fln == "+++") {
                return ""
        }
        trg := `bibfile`
        trgln := len(trg)
        mx := min(nlines, 100)
        for i := 1; i < mx; i++ {
                sln := pfs.Src.Lines[i]
                lstr := string(sln)
                if lstr == "---" || lstr == "+++" {
                        return ""
                }
                lnln := len(sln)
                if lnln < trgln {
                        continue
                }
                if strings.HasPrefix(lstr, trg) {
                        fnm := lstr[trgln:lnln]
                        if fnm[0] == ':' {
                                return fnm
                        }
                        flds := strings.Fields(fnm)
                        if len(flds) != 2 || flds[0] != "=" {
                                continue
                        }
                        if flds[1][0] == '"' {
                                fnm = flds[1][1 : len(flds[1])-1]
                                return fnm
                        }
                }
        }
        return ""
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package markdown

import (
        _ "embed"
        "strings"
        "unicode"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/csl"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/parse/languages"
        "cogentcore.org/core/text/parse/languages/bibtex"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

//go:embed markdown.parse
var parserBytes []byte

// MarkdownLang implements the Lang interface for the Markdown language
type MarkdownLang struct {
        Pr *parse.Parser

        // BibBeX bibliography files that have been loaded,
        // keyed by file path from bibfile metadata stored in filestate.
        Bibs bibtex.Files

        // CSL bibliography files that have been loaded,
        // keyed by file path from bibfile metadata stored in filestate.
        CSLs csl.Files
}

// TheMarkdownLang is the instance variable providing support for the Markdown language
var TheMarkdownLang = MarkdownLang{}

func init() {
        parse.StandardLanguageProperties[fileinfo.Markdown].Lang = &TheMarkdownLang
        languages.ParserBytes[fileinfo.Markdown] = parserBytes
}

func (ml *MarkdownLang) Parser() *parse.Parser {
        if ml.Pr != nil {
                return ml.Pr
        }
        lp, _ := parse.LanguageSupport.Properties(fileinfo.Markdown)
        if lp.Parser == nil {
                parse.LanguageSupport.OpenStandard()
        }
        ml.Pr = lp.Parser
        if ml.Pr == nil {
                return nil
        }
        return ml.Pr
}

func (ml *MarkdownLang) ParseFile(fss *parse.FileStates, txt []byte) {
        pr := ml.Parser()
        if pr == nil {
                return
        }
        pfs := fss.StartProc(txt) // current processing one
        pr.LexAll(pfs)
        ml.OpenBibfile(fss, pfs)
        fss.EndProc() // now done
        // no parser
}

func (ml *MarkdownLang) LexLine(fs *parse.FileState, line int, txt []rune) lexer.Line {
        pr := ml.Parser()
        if pr == nil {
                return nil
        }
        return pr.LexLine(fs, line, txt)
}

func (ml *MarkdownLang) ParseLine(fs *parse.FileState, line int) *parse.FileState {
        // n/a
        return nil
}

func (ml *MarkdownLang) HighlightLine(fss *parse.FileStates, line int, txt []rune) lexer.Line {
        fs := fss.Done()
        return ml.LexLine(fs, line, txt)
}

// citeKeyStr returns a string with a citation key of the form @[^]Ref
// or empty string if not of this form.
func citeKeyStr(str string) string {
        if len(str) < 2 {
                return ""
        }
        if str[0] != '@' {
                return ""
        }
        str = str[1:]
        if str[0] == '^' { // narrative cite
                str = str[1:]
        }
        return str
}

func (ml *MarkdownLang) CompleteLine(fss *parse.FileStates, str string, pos textpos.Pos) (md complete.Matches) {
        origStr := str
        lfld := lexer.LastField(str)
        str = citeKeyStr(lexer.InnerBracketScope(lfld, "[", "]"))
        if str != "" {
                return ml.CompleteCite(fss, origStr, str, pos)
        }
        // n/a
        return md
}

// Lookup is the main api called by completion code in giv/complete.go to lookup item
func (ml *MarkdownLang) Lookup(fss *parse.FileStates, str string, pos textpos.Pos) (ld complete.Lookup) {
        origStr := str
        lfld := lexer.LastField(str)
        str = citeKeyStr(lexer.InnerBracketScope(lfld, "[", "]"))
        if str != "" {
                return ml.LookupCite(fss, origStr, str, pos)
        }
        return
}

func (ml *MarkdownLang) CompleteEdit(fs *parse.FileStates, text string, cp int, comp complete.Completion, seed string) (ed complete.Edit) {
        // if the original is ChildByName() and the cursor is between d and B and the comp is Children,
        // then delete the portion after "Child" and return the new comp and the number or runes past
        // the cursor to delete
        s2 := text[cp:]
        // gotParen := false
        if len(s2) > 0 && lexer.IsLetterOrDigit(rune(s2[0])) {
                for i, c := range s2 {
                        if c == '{' {
                                // gotParen = true
                                s2 = s2[:i]
                                break
                        }
                        isalnum := c == '_' || unicode.IsLetter(c) || unicode.IsDigit(c)
                        if !isalnum {
                                s2 = s2[:i]
                                break
                        }
                }
        } else {
                s2 = ""
        }

        var nw = comp.Text
        // if gotParen && strings.HasSuffix(nw, "()") {
        //         nw = nw[:len(nw)-2]
        // }

        // fmt.Printf("text: %v|%v  comp: %v  s2: %v\n", text[:cp], text[cp:], nw, s2)
        ed.NewText = nw
        ed.ForwardDelete = len(s2)
        return ed
}

func (ml *MarkdownLang) ParseDir(fs *parse.FileState, path string, opts parse.LanguageDirOptions) *syms.Symbol {
        // n/a
        return nil
}

// List keywords (for indent)
var ListKeys = map[string]struct{}{"*": {}, "+": {}, "-": {}}

// IndentLine returns the indentation level for given line based on
// previous line's indentation level, and any delta change based on
// e.g., brackets starting or ending the previous or current line, or
// other language-specific keywords.  See lexer.BracketIndentLine for example.
// Indent level is in increments of tabSz for spaces, and tabs for tabs.
// Operates on rune source with markup lex tags per line.
func (ml *MarkdownLang) IndentLine(fs *parse.FileStates, src [][]rune, tags []lexer.Line, ln int, tabSz int) (pInd, delInd, pLn int, ichr indent.Character) {
        pInd, pLn, ichr = lexer.PrevLineIndent(src, tags, ln, tabSz)
        delInd = 0
        ptg := tags[pLn]
        ctg := tags[ln]
        if len(ptg) == 0 || len(ctg) == 0 {
                return
        }
        fpt := ptg[0]
        fct := ctg[0]
        if fpt.Token.Token != token.Keyword || fct.Token.Token != token.Keyword {
                return
        }
        pk := strings.TrimSpace(string(fpt.Src(src[pLn])))
        ck := strings.TrimSpace(string(fct.Src(src[ln])))
        // fmt.Printf("pk: %v  ck: %v\n", string(pk), string(ck))
        if len(pk) >= 1 && len(ck) >= 1 {
                _, pky := ListKeys[pk]
                _, cky := ListKeys[ck]
                if unicode.IsDigit(rune(pk[0])) {
                        pk = "1"
                        pky = true
                }
                if unicode.IsDigit(rune(ck[0])) {
                        ck = "1"
                        cky = true
                }
                if pky && cky {
                        if pk != ck {
                                delInd = 1
                                return
                        }
                        return
                }
        }
        return
}

// AutoBracket returns what to do when a user types a starting bracket character
// (bracket, brace, paren) while typing.
// pos = position where bra will be inserted, and curLn is the current line
// match = insert the matching ket, and newLine = insert a new line.
func (ml *MarkdownLang) AutoBracket(fs *parse.FileStates, bra rune, pos textpos.Pos, curLn []rune) (match, newLine bool) {
        lnLen := len(curLn)
        match = pos.Char == lnLen || unicode.IsSpace(curLn[pos.Char]) // at end or if space after
        newLine = false
        return
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tex

import (
        "log"
        "strings"

        "cogentcore.org/core/icons"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/parse/languages/bibtex"
        "cogentcore.org/core/text/textpos"
)

// CompleteCite does completion on citation
func (tl *TexLang) CompleteCite(fss *parse.FileStates, origStr, str string, pos textpos.Pos) (md complete.Matches) {
        bfile, has := fss.MetaData("bibfile")
        if !has {
                return
        }
        bf, err := tl.Bibs.Open(bfile)
        if err != nil {
                return
        }
        md.Seed = str
        for _, be := range bf.BibTex.Entries {
                if strings.HasPrefix(be.CiteName, str) {
                        c := complete.Completion{Text: be.CiteName, Label: be.CiteName, Icon: icons.Field}
                        md.Matches = append(md.Matches, c)
                }
        }
        return md
}

// LookupCite does lookup on citation
func (tl *TexLang) LookupCite(fss *parse.FileStates, origStr, str string, pos textpos.Pos) (ld complete.Lookup) {
        bfile, has := fss.MetaData("bibfile")
        if !has {
                return
        }
        bf, err := tl.Bibs.Open(bfile)
        if err != nil {
                return
        }
        lkbib := bibtex.NewBibTex()
        for _, be := range bf.BibTex.Entries {
                if strings.HasPrefix(be.CiteName, str) {
                        lkbib.Entries = append(lkbib.Entries, be)
                }
        }
        if len(lkbib.Entries) > 0 {
                ld.SetFile(fss.Filename, 0, 0)
                ld.Text = []byte(lkbib.PrettyString())
        }
        return ld
}

// OpenBibfile attempts to open the /bibliography file.
// Sets meta data "bibfile" to resulting file if found, and deletes it if not.
func (tl *TexLang) OpenBibfile(fss *parse.FileStates, pfs *parse.FileState) error {
        bfile := tl.FindBibliography(pfs)
        if bfile == "" {
                fss.DeleteMetaData("bibfile")
                return nil
        }
        _, err := tl.Bibs.Open(bfile)
        if err != nil {
                log.Println(err)
                fss.DeleteMetaData("bibfile")
                return err
        }
        fss.SetMetaData("bibfile", bfile)
        return nil
}

func (tl *TexLang) FindBibliography(pfs *parse.FileState) string {
        nlines := pfs.Src.NLines()
        trg := `\bibliography{`
        trgln := len(trg)
        for i := nlines - 1; i >= 0; i-- {
                sln := pfs.Src.Lines[i]
                lnln := len(sln)
                if lnln == 0 {
                        continue
                }
                if sln[0] != '\\' {
                        continue
                }
                if lnln > 100 {
                        continue
                }
                lstr := string(sln)
                if strings.HasPrefix(lstr, trg) {
                        return lstr[trgln:len(sln)-1] + ".bib"
                }
        }
        return ""
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tex

import (
        "strings"
        "unicode"

        "cogentcore.org/core/icons"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/textpos"
)

func (tl *TexLang) CompleteLine(fss *parse.FileStates, str string, pos textpos.Pos) (md complete.Matches) {
        origStr := str
        lfld := lexer.LastField(str)
        str = lexer.LastScopedString(str)
        if len(lfld) < 2 {
                return md
        }
        if lfld[0] == '\\' && lfld[1:] == str { // use the /
                str = lfld
        }
        if HasCite(lfld) {
                return tl.CompleteCite(fss, origStr, str, pos)
        }
        md.Seed = str
        if len(LaTeXCommandsAll) == 0 {
                LaTeXCommandsAll = append(LaTeXCommands, CiteCommands...)
        }
        for _, ls := range LaTeXCommandsAll {
                if strings.HasPrefix(ls, str) {
                        c := complete.Completion{Text: ls, Label: ls, Icon: icons.Function}
                        md.Matches = append(md.Matches, c)
                }
        }
        return md
}

// Lookup is the main api called by completion code in giv/complete.go to lookup item
func (tl *TexLang) Lookup(fss *parse.FileStates, str string, pos textpos.Pos) (ld complete.Lookup) {
        origStr := str
        lfld := lexer.LastField(str)
        str = lexer.LastScopedString(str)
        if HasCite(lfld) {
                return tl.LookupCite(fss, origStr, str, pos)
        }
        return
}

func (tl *TexLang) CompleteEdit(fss *parse.FileStates, text string, cp int, comp complete.Completion, seed string) (ed complete.Edit) {
        // if the original is ChildByName() and the cursor is between d and B and the comp is Children,
        // then delete the portion after "Child" and return the new comp and the number or runes past
        // the cursor to delete
        s2 := text[cp:]
        // gotParen := false
        if len(s2) > 0 && lexer.IsLetterOrDigit(rune(s2[0])) {
                for i, c := range s2 {
                        if c == '{' {
                                // gotParen = true
                                s2 = s2[:i]
                                break
                        }
                        isalnum := c == '_' || unicode.IsLetter(c) || unicode.IsDigit(c)
                        if !isalnum {
                                s2 = s2[:i]
                                break
                        }
                }
        } else {
                s2 = ""
        }

        var nw = comp.Text
        // if gotParen && strings.HasSuffix(nw, "()") {
        //         nw = nw[:len(nw)-2]
        // }

        // fmt.Printf("text: %v|%v  comp: %v  s2: %v\n", text[:cp], text[cp:], nw, s2)
        ed.NewText = nw
        ed.ForwardDelete = len(s2)
        return ed
}

// CiteCommands is a list of latex citation commands (APA style requires many variations).
// We include all the variations so they show up in completion.
var CiteCommands = []string{`\cite`, `\citep`, `\citet`, `\citeNP`, `\citeyearpar`, `\citeyear`, `\citeauthor`, `\citeA`, `\citealp`, `\citeyearNP`, `\parencite`, `\textcite`, `\nptextcite`, `\incite`, `\nopcite`, `\yrcite`, `\yrnopcite`, `\abbrevcite`, `\abbrevincite`}

// HasCite returns true if string has Prefix in CiteCmds
func HasCite(str string) bool {
        for _, cc := range CiteCommands {
                if strings.HasPrefix(str, cc) {
                        return true
                }
        }
        return false
}

// LaTeXCommandsAll concatenates LaTeXCmds and CiteCmds
var LaTeXCommandsAll []string

// LaTeXCommands is a big list of standard commands
var LaTeXCommands = []string{
        `\em`,
        `\emph`,
        `\textbf`,
        `\textit`,
        `\texttt`,
        `\textsf`,
        `\textrm`,
        `\tiny`,
        `\scriptsize`,
        `\footnotesize`,
        `\small`,
        `\normalsize`,
        `\large`,
        `\Large`,
        `\LARGE`,
        `\huge`,
        `\Huge`,
        `\begin`,
        `\end`,
        `enumerate`,
        `itemize`,
        `description`,
        `\item`,
        `figure`,
        `table`,
        `tabular`,
        `array`,
        `\hline`,
        `\cline`,
        `\multicolumn`,
        `equation`,
        `center`,
        `\centering`,
        `\verb`,
        `verbatim`,
        `quote`,
        `\section`,
        `\subsection`,
        `\subsubsection`,
        `\paragraph`,
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tex

import (
        _ "embed"
        "strings"
        "unicode"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/languages"
        "cogentcore.org/core/text/parse/languages/bibtex"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/textpos"
)

//go:embed tex.parse
var parserBytes []byte

// TexLang implements the Lang interface for the Tex / LaTeX language
type TexLang struct {
        Pr *parse.Parser

        // bibliography files that have been loaded, keyed by file path from bibfile metadata stored in filestate
        Bibs bibtex.Files
}

// TheTexLang is the instance variable providing support for the Go language
var TheTexLang = TexLang{}

func init() {
        parse.StandardLanguageProperties[fileinfo.TeX].Lang = &TheTexLang
        languages.ParserBytes[fileinfo.TeX] = parserBytes
}

func (tl *TexLang) Parser() *parse.Parser {
        if tl.Pr != nil {
                return tl.Pr
        }
        lp, _ := parse.LanguageSupport.Properties(fileinfo.TeX)
        if lp.Parser == nil {
                parse.LanguageSupport.OpenStandard()
        }
        tl.Pr = lp.Parser
        if tl.Pr == nil {
                return nil
        }
        return tl.Pr
}

func (tl *TexLang) ParseFile(fss *parse.FileStates, txt []byte) {
        pr := tl.Parser()
        if pr == nil {
                return
        }
        pfs := fss.StartProc(txt) // current processing one
        pr.LexAll(pfs)
        tl.OpenBibfile(fss, pfs)
        fss.EndProc() // now done
        // no parser
}

func (tl *TexLang) LexLine(fs *parse.FileState, line int, txt []rune) lexer.Line {
        pr := tl.Parser()
        if pr == nil {
                return nil
        }
        return pr.LexLine(fs, line, txt)
}

func (tl *TexLang) ParseLine(fs *parse.FileState, line int) *parse.FileState {
        // n/a
        return nil
}

func (tl *TexLang) HighlightLine(fss *parse.FileStates, line int, txt []rune) lexer.Line {
        fs := fss.Done()
        return tl.LexLine(fs, line, txt)
}

func (tl *TexLang) ParseDir(fs *parse.FileState, path string, opts parse.LanguageDirOptions) *syms.Symbol {
        // n/a
        return nil
}

// IndentLine returns the indentation level for given line based on
// previous line's indentation level, and any delta change based on
// e.g., brackets starting or ending the previous or current line, or
// other language-specific keywords.  See lexer.BracketIndentLine for example.
// Indent level is in increments of tabSz for spaces, and tabs for tabs.
// Operates on rune source with markup lex tags per line.
func (tl *TexLang) IndentLine(fs *parse.FileStates, src [][]rune, tags []lexer.Line, ln int, tabSz int) (pInd, delInd, pLn int, ichr indent.Character) {
        pInd, pLn, ichr = lexer.PrevLineIndent(src, tags, ln, tabSz)

        curUnd, _ := lexer.LineStartEndBracket(src[ln], tags[ln])
        _, prvInd := lexer.LineStartEndBracket(src[pLn], tags[pLn])

        delInd = 0
        switch {
        case prvInd && curUnd:
                delInd = 0 // offset
        case prvInd:
                delInd = 1 // indent
        case curUnd:
                delInd = -1 // undent
        }

        pst := lexer.FirstNonSpaceRune(src[pLn])
        cst := lexer.FirstNonSpaceRune(src[ln])

        pbeg := false
        if pst >= 0 {
                sts := string(src[pLn][pst:])
                if strings.HasPrefix(sts, "\\begin{") {
                        pbeg = true
                }
        }

        cend := false
        if cst >= 0 {
                sts := string(src[ln][cst:])
                if strings.HasPrefix(sts, "\\end{") {
                        cend = true
                }
        }

        switch {
        case pbeg && cend:
                delInd = 0
        case pbeg:
                delInd = 1
        case cend:
                delInd = -1
        }

        if pInd == 0 && delInd < 0 { // error..
                delInd = 0
        }
        return
}

// AutoBracket returns what to do when a user types a starting bracket character
// (bracket, brace, paren) while typing.
// pos = position where bra will be inserted, and curLn is the current line
// match = insert the matching ket, and newLine = insert a new line.
func (tl *TexLang) AutoBracket(fs *parse.FileStates, bra rune, pos textpos.Pos, curLn []rune) (match, newLine bool) {
        lnLen := len(curLn)
        match = pos.Char == lnLen || unicode.IsSpace(curLn[pos.Char]) // at end or if space after
        newLine = false
        return
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package parse

import (
        "fmt"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/text/parse/languages"
        "cogentcore.org/core/text/parse/lexer"
)

// LanguageFlags are special properties of a given language
type LanguageFlags int32 //enums:enum

// LangFlags
const (
        // NoFlags = nothing special
        NoFlags LanguageFlags = iota

        // IndentSpace means that spaces must be used for this language
        IndentSpace

        // IndentTab means that tabs must be used for this language
        IndentTab

        // ReAutoIndent causes current line to be re-indented during AutoIndent for Enter
        // (newline) -- this should only be set for strongly indented languages where
        // the previous + current line can tell you exactly what indent the current line
        // should be at.
        ReAutoIndent
)

// LanguageProperties contains properties of languages supported by the parser
// framework
type LanguageProperties struct {

        // known language -- must be a supported one from Known list
        Known fileinfo.Known

        // character(s) that start a single-line comment -- if empty then multi-line comment syntax will be used
        CommentLn string

        // character(s) that start a multi-line comment or one that requires both start and end
        CommentSt string

        // character(s) that end a multi-line comment or one that requires both start and end
        CommentEd string

        // special properties for this language -- as an explicit list of options to make them easier to see and set in defaults
        Flags []LanguageFlags

        // Lang interface for this language
        Lang Language `json:"-" xml:"-"`

        // parser for this language -- initialized in OpenStandard
        Parser *Parser `json:"-" xml:"-"`
}

// HasFlag returns true if given flag is set in Flags
func (lp *LanguageProperties) HasFlag(flg LanguageFlags) bool {
        for _, f := range lp.Flags {
                if f == flg {
                        return true
                }
        }
        return false
}

// StandardLanguageProperties is the standard compiled-in set of language properties
var StandardLanguageProperties = map[fileinfo.Known]*LanguageProperties{
        fileinfo.Ada:        {fileinfo.Ada, "--", "", "", nil, nil, nil},
        fileinfo.Bash:       {fileinfo.Bash, "# ", "", "", nil, nil, nil},
        fileinfo.Csh:        {fileinfo.Csh, "# ", "", "", nil, nil, nil},
        fileinfo.C:          {fileinfo.C, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.CSharp:     {fileinfo.CSharp, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.D:          {fileinfo.D, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.ObjC:       {fileinfo.ObjC, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.Go:         {fileinfo.Go, "// ", "/* ", " */", []LanguageFlags{IndentTab}, nil, nil},
        fileinfo.Java:       {fileinfo.Java, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.JavaScript: {fileinfo.JavaScript, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.Eiffel:     {fileinfo.Eiffel, "--", "", "", nil, nil, nil},
        fileinfo.Haskell:    {fileinfo.Haskell, "--", "{- ", "-}", nil, nil, nil},
        fileinfo.Lisp:       {fileinfo.Lisp, "; ", "", "", nil, nil, nil},
        fileinfo.Lua:        {fileinfo.Lua, "--", "---[[ ", "--]]", nil, nil, nil},
        fileinfo.Makefile:   {fileinfo.Makefile, "# ", "", "", []LanguageFlags{IndentTab}, nil, nil},
        fileinfo.Matlab:     {fileinfo.Matlab, "% ", "%{ ", " %}", nil, nil, nil},
        fileinfo.OCaml:      {fileinfo.OCaml, "", "(* ", " *)", nil, nil, nil},
        fileinfo.Pascal:     {fileinfo.Pascal, "// ", " ", " }", nil, nil, nil},
        fileinfo.Perl:       {fileinfo.Perl, "# ", "", "", nil, nil, nil},
        fileinfo.Python:     {fileinfo.Python, "# ", "", "", []LanguageFlags{IndentSpace}, nil, nil},
        fileinfo.Php:        {fileinfo.Php, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.R:          {fileinfo.R, "# ", "", "", nil, nil, nil},
        fileinfo.Ruby:       {fileinfo.Ruby, "# ", "", "", nil, nil, nil},
        fileinfo.Rust:       {fileinfo.Rust, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.Scala:      {fileinfo.Scala, "// ", "/* ", " */", nil, nil, nil},
        fileinfo.Html:       {fileinfo.Html, "", "<!-- ", " -->", nil, nil, nil},
        fileinfo.TeX:        {fileinfo.TeX, "% ", "", "", nil, nil, nil},
        fileinfo.Markdown:   {fileinfo.Markdown, "", "<!--- ", " -->", []LanguageFlags{IndentSpace}, nil, nil},
        fileinfo.Yaml:       {fileinfo.Yaml, "#", "", "", []LanguageFlags{IndentSpace}, nil, nil},
}

// LanguageSupporter provides general support for supported languages.
// e.g., looking up lexers and parsers by name.
// Also implements the lexer.LangLexer interface to provide access to other
// Guest Lexers
type LanguageSupporter struct{}

// LanguageSupport is the main language support hub for accessing parse
// support interfaces for each supported language
var LanguageSupport = LanguageSupporter{}

// OpenStandard opens all the standard parsers for languages, from the langs/ directory
func (ll *LanguageSupporter) OpenStandard() error {
        lexer.TheLanguageLexer = &LanguageSupport

        for sl, lp := range StandardLanguageProperties {
                pib, err := languages.OpenParser(sl)
                if err != nil {
                        continue
                }
                pr := NewParser()
                err = pr.ReadJSON(pib)
                if err != nil {
                        return errors.Log(err)
                }
                pr.ModTime = time.Date(2023, 02, 10, 00, 00, 00, 0, time.UTC)
                pr.InitAll()
                lp.Parser = pr
        }
        return nil
}

// Properties looks up language properties by fileinfo.Known const int type
func (ll *LanguageSupporter) Properties(sup fileinfo.Known) (*LanguageProperties, error) {
        lp, has := StandardLanguageProperties[sup]
        if !has {
                err := fmt.Errorf("parse.LangSupport.Properties: no specific support for language: %v", sup)
                return nil, err
        }
        return lp, nil
}

// PropertiesByName looks up language properties by string name of language
// (with case-insensitive fallback). Returns error if not supported.
func (ll *LanguageSupporter) PropertiesByName(lang string) (*LanguageProperties, error) {
        sup, err := fileinfo.KnownByName(lang)
        if err != nil {
                // log.Println(err.Error()) // don't want output during lexing..
                return nil, err
        }
        return ll.Properties(sup)
}

// LexerByName looks up Lexer for given language by name
// (with case-insensitive fallback). Returns nil if not supported.
func (ll *LanguageSupporter) LexerByName(lang string) *lexer.Rule {
        lp, err := ll.PropertiesByName(lang)
        if err != nil {
                return nil
        }
        if lp.Parser == nil {
                // log.Printf("core.LangSupport: no lexer / parser support for language: %v\n", lang)
                return nil
        }
        return lp.Parser.Lexer
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// BracePair returns the matching brace-like punctuation for given rune,
// which must be a left or right brace {}, bracket [] or paren ().
// Also returns true if it is *right*
func BracePair(r rune) (match rune, right bool) {
        right = false
        switch r {
        case '{':
                match = '}'
        case '}':
                right = true
                match = '{'
        case '(':
                match = ')'
        case ')':
                right = true
                match = '('
        case '[':
                match = ']'
        case ']':
                right = true
                match = '['
        }
        return
}

// BraceMatch finds the brace, bracket, or paren that is the partner
// of the one passed to function, within maxLns lines of start.
// Operates on rune source with markup lex tags per line (tags exclude comments).
func BraceMatch(src [][]rune, tags []Line, r rune, st textpos.Pos, maxLns int) (en textpos.Pos, found bool) {
        en.Line = -1
        found = false
        match, rt := BracePair(r)
        var left int
        var right int
        if rt {
                right++
        } else {
                left++
        }
        ch := st.Char
        ln := st.Line
        nln := len(src)
        mx := min(nln-ln, maxLns)
        mn := min(ln, maxLns)
        txt := src[ln]
        tln := tags[ln]
        if left > right {
                for l := ln + 1; l < ln+mx; l++ {
                        for i := ch + 1; i < len(txt); i++ {
                                if txt[i] == r {
                                        lx, _ := tln.AtPos(i)
                                        if lx == nil || lx.Token.Token.Cat() != token.Comment {
                                                left++
                                                continue
                                        }
                                }
                                if txt[i] == match {
                                        lx, _ := tln.AtPos(i)
                                        if lx == nil || lx.Token.Token.Cat() != token.Comment {
                                                right++
                                                if left == right {
                                                        en.Line = l - 1
                                                        en.Char = i
                                                        break
                                                }
                                        }
                                }
                        }
                        if en.Line >= 0 {
                                found = true
                                break
                        }
                        txt = src[l]
                        tln = tags[l]
                        ch = -1
                }
        } else {
                for l := ln - 1; l >= ln-mn; l-- {
                        ch = min(ch, len(txt))
                        for i := ch - 1; i >= 0; i-- {
                                if txt[i] == r {
                                        lx, _ := tln.AtPos(i)
                                        if lx == nil || lx.Token.Token.Cat() != token.Comment {
                                                right++
                                                continue
                                        }
                                }
                                if txt[i] == match {
                                        lx, _ := tln.AtPos(i)
                                        if lx == nil || lx.Token.Token.Cat() != token.Comment {
                                                left++
                                                if left == right {
                                                        en.Line = l + 1
                                                        en.Char = i
                                                        break
                                                }
                                        }
                                }
                        }
                        if en.Line >= 0 {
                                found = true
                                break
                        }
                        txt = src[l]
                        tln = tags[l]
                        ch = len(txt)
                }
        }
        return en, found
}

// Code generated by "core generate"; DO NOT EDIT.

package lexer

import (
        "cogentcore.org/core/enums"
)

var _ActionsValues = []Actions{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

// ActionsN is the highest valid value for type Actions, plus one.
const ActionsN Actions = 11

var _ActionsValueMap = map[string]Actions{`Next`: 0, `Name`: 1, `Number`: 2, `Quoted`: 3, `QuotedRaw`: 4, `EOL`: 5, `ReadUntil`: 6, `PushState`: 7, `PopState`: 8, `SetGuestLex`: 9, `PopGuestLex`: 10}

var _ActionsDescMap = map[Actions]string{0: `Next means advance input position to the next character(s) after the matched characters`, 1: `Name means read in an entire name, which is letters, _ and digits after first letter position will be advanced to just after`, 2: `Number means read in an entire number -- the token type will automatically be set to the actual type of number that was read in, and position advanced to just after`, 3: `Quoted means read in an entire string enclosed in quote delimeter that is present at current position, with proper skipping of escaped. Position advanced to just after`, 4: `QuotedRaw means read in an entire string enclosed in quote delimeter that is present at start position, with proper skipping of escaped. Position advanced to just after. Raw version supports multi-line and includes CR etc at end of lines (e.g., back-tick in various languages)`, 5: `EOL means read till the end of the line (e.g., for single-line comments)`, 6: `ReadUntil reads until string(s) in the Until field are found, or until the EOL if none are found`, 7: `PushState means push the given state value onto the state stack`, 8: `PopState means pop given state value off the state stack`, 9: `SetGuestLex means install the Name (must be a prior action) as the guest lexer -- it will take over lexing until PopGuestLex is called`, 10: `PopGuestLex removes the current guest lexer and returns to the original language lexer`}

var _ActionsMap = map[Actions]string{0: `Next`, 1: `Name`, 2: `Number`, 3: `Quoted`, 4: `QuotedRaw`, 5: `EOL`, 6: `ReadUntil`, 7: `PushState`, 8: `PopState`, 9: `SetGuestLex`, 10: `PopGuestLex`}

// String returns the string representation of this Actions value.
func (i Actions) String() string { return enums.String(i, _ActionsMap) }

// SetString sets the Actions value from its string representation,
// and returns an error if the string is invalid.
func (i *Actions) SetString(s string) error {
        return enums.SetString(i, s, _ActionsValueMap, "Actions")
}

// Int64 returns the Actions value as an int64.
func (i Actions) Int64() int64 { return int64(i) }

// SetInt64 sets the Actions value from an int64.
func (i *Actions) SetInt64(in int64) { *i = Actions(in) }

// Desc returns the description of the Actions value.
func (i Actions) Desc() string { return enums.Desc(i, _ActionsDescMap) }

// ActionsValues returns all possible values for the type Actions.
func ActionsValues() []Actions { return _ActionsValues }

// Values returns all possible values for the type Actions.
func (i Actions) Values() []enums.Enum { return enums.Values(_ActionsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Actions) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Actions) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Actions") }

var _MatchesValues = []Matches{0, 1, 2, 3, 4, 5, 6}

// MatchesN is the highest valid value for type Matches, plus one.
const MatchesN Matches = 7

var _MatchesValueMap = map[string]Matches{`String`: 0, `StrName`: 1, `Letter`: 2, `Digit`: 3, `WhiteSpace`: 4, `CurState`: 5, `AnyRune`: 6}

var _MatchesDescMap = map[Matches]string{0: `String means match a specific string as given in the rule Note: this only looks for the string with no constraints on what happens after this string -- use StrName to match entire names`, 1: `StrName means match a specific string that is a complete alpha-numeric string (including underbar _) with some other char at the end must use this for all keyword matches to ensure that it isn't just the start of a longer name`, 2: `Match any letter, including underscore`, 3: `Match digit 0-9`, 4: `Match any white space (space, tab) -- input is already broken into lines`, 5: `CurState means match current state value set by a PushState action, using String value in rule all CurState cases must generally be first in list of rules so they can preempt other rules when the state is active`, 6: `AnyRune means match any rune -- use this as the last condition where other terminators come first!`}

var _MatchesMap = map[Matches]string{0: `String`, 1: `StrName`, 2: `Letter`, 3: `Digit`, 4: `WhiteSpace`, 5: `CurState`, 6: `AnyRune`}

// String returns the string representation of this Matches value.
func (i Matches) String() string { return enums.String(i, _MatchesMap) }

// SetString sets the Matches value from its string representation,
// and returns an error if the string is invalid.
func (i *Matches) SetString(s string) error {
        return enums.SetString(i, s, _MatchesValueMap, "Matches")
}

// Int64 returns the Matches value as an int64.
func (i Matches) Int64() int64 { return int64(i) }

// SetInt64 sets the Matches value from an int64.
func (i *Matches) SetInt64(in int64) { *i = Matches(in) }

// Desc returns the description of the Matches value.
func (i Matches) Desc() string { return enums.Desc(i, _MatchesDescMap) }

// MatchesValues returns all possible values for the type Matches.
func MatchesValues() []Matches { return _MatchesValues }

// Values returns all possible values for the type Matches.
func (i Matches) Values() []enums.Enum { return enums.Values(_MatchesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Matches) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Matches) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Matches") }

var _MatchPosValues = []MatchPos{0, 1, 2, 3, 4, 5, 6}

// MatchPosN is the highest valid value for type MatchPos, plus one.
const MatchPosN MatchPos = 7

var _MatchPosValueMap = map[string]MatchPos{`AnyPos`: 0, `StartOfLine`: 1, `EndOfLine`: 2, `MiddleOfLine`: 3, `StartOfWord`: 4, `EndOfWord`: 5, `MiddleOfWord`: 6}

var _MatchPosDescMap = map[MatchPos]string{0: `AnyPos matches at any position`, 1: `StartOfLine matches at start of line`, 2: `EndOfLine matches at end of line`, 3: `MiddleOfLine matches not at the start or end`, 4: `StartOfWord matches at start of word`, 5: `EndOfWord matches at end of word`, 6: `MiddleOfWord matches not at the start or end`}

var _MatchPosMap = map[MatchPos]string{0: `AnyPos`, 1: `StartOfLine`, 2: `EndOfLine`, 3: `MiddleOfLine`, 4: `StartOfWord`, 5: `EndOfWord`, 6: `MiddleOfWord`}

// String returns the string representation of this MatchPos value.
func (i MatchPos) String() string { return enums.String(i, _MatchPosMap) }

// SetString sets the MatchPos value from its string representation,
// and returns an error if the string is invalid.
func (i *MatchPos) SetString(s string) error {
        return enums.SetString(i, s, _MatchPosValueMap, "MatchPos")
}

// Int64 returns the MatchPos value as an int64.
func (i MatchPos) Int64() int64 { return int64(i) }

// SetInt64 sets the MatchPos value from an int64.
func (i *MatchPos) SetInt64(in int64) { *i = MatchPos(in) }

// Desc returns the description of the MatchPos value.
func (i MatchPos) Desc() string { return enums.Desc(i, _MatchPosDescMap) }

// MatchPosValues returns all possible values for the type MatchPos.
func MatchPosValues() []MatchPos { return _MatchPosValues }

// Values returns all possible values for the type MatchPos.
func (i MatchPos) Values() []enums.Enum { return enums.Values(_MatchPosValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i MatchPos) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *MatchPos) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "MatchPos") }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Much of this is directly copied from Go's go/scanner package:

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "fmt"
        "io"
        "path/filepath"
        "reflect"
        "sort"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/tree"
)

// In an ErrorList, an error is represented by an *Error.
// The position Pos, if valid, points to the beginning of
// the offending token, and the error condition is described
// by Msg.
type Error struct {

        // position where the error occurred in the source
        Pos textpos.Pos

        // full filename with path
        Filename string

        // brief error message
        Msg string

        // line of source where error was
        Src string

        // lexer or parser rule that emitted the error
        Rule tree.Node
}

// Error implements the error interface -- gives the minimal version of error string
func (e Error) Error() string {
        if e.Filename != "" {
                _, fn := filepath.Split(e.Filename)
                return fn + ":" + e.Pos.String() + ": " + e.Msg
        }
        return e.Pos.String() + ": " + e.Msg
}

// Report provides customizable output options for viewing errors:
// - basepath if non-empty shows filename relative to that path.
// - showSrc shows the source line on a second line -- truncated to 30 chars around err
// - showRule prints the rule name
func (e Error) Report(basepath string, showSrc, showRule bool) string {
        var err error
        fnm := ""
        if e.Filename != "" {
                if basepath != "" {
                        fnm, err = filepath.Rel(basepath, e.Filename)
                }
                if basepath == "" || err != nil {
                        _, fnm = filepath.Split(e.Filename)
                }
        }
        str := fnm + ":" + e.Pos.String() + ": " + e.Msg
        if showRule && !reflectx.IsNil(reflect.ValueOf(e.Rule)) {
                str += fmt.Sprintf(" (rule: %v)", e.Rule.AsTree().Name)
        }
        ssz := len(e.Src)
        if showSrc && ssz > 0 && ssz >= e.Pos.Char {
                str += "<br>\n\t> "
                if ssz > e.Pos.Char+30 {
                        str += e.Src[e.Pos.Char : e.Pos.Char+30]
                } else if ssz > e.Pos.Char {
                        str += e.Src[e.Pos.Char:]
                }
        }
        return str
}

// ErrorList is a list of *Errors.
// The zero value for an ErrorList is an empty ErrorList ready to use.
type ErrorList []*Error

// Add adds an Error with given position and error message to an ErrorList.
func (p *ErrorList) Add(pos textpos.Pos, fname, msg string, srcln string, rule tree.Node) *Error {
        e := &Error{pos, fname, msg, srcln, rule}
        *p = append(*p, e)
        return e
}

// Reset resets an ErrorList to no errors.
func (p *ErrorList) Reset() { *p = (*p)[0:0] }

// ErrorList implements the sort Interface.
func (p ErrorList) Len() int      { return len(p) }
func (p ErrorList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

func (p ErrorList) Less(i, j int) bool {
        e := p[i]
        f := p[j]
        if e.Filename != f.Filename {
                return e.Filename < f.Filename
        }
        if e.Pos.Line != f.Pos.Line {
                return e.Pos.Line < f.Pos.Line
        }
        if e.Pos.Char != f.Pos.Char {
                return e.Pos.Char < f.Pos.Char
        }
        return e.Msg < f.Msg
}

// Sort sorts an ErrorList. *Error entries are sorted by position,
// other errors are sorted by error message, and before any *Error
// entry.
func (p ErrorList) Sort() {
        sort.Sort(p)
}

// RemoveMultiples sorts an ErrorList and removes all but the first error per line.
func (p *ErrorList) RemoveMultiples() {
        sort.Sort(p)
        var last textpos.Pos // initial last.Line is != any legal error line
        var lastfn string
        i := 0
        for _, e := range *p {
                if e.Filename != lastfn || e.Pos.Line != last.Line {
                        last = e.Pos
                        lastfn = e.Filename
                        (*p)[i] = e
                        i++
                }
        }
        (*p) = (*p)[0:i]
}

// An ErrorList implements the error interface.
func (p ErrorList) Error() string {
        switch len(p) {
        case 0:
                return "no errors"
        case 1:
                return p[0].Error()
        }
        return fmt.Sprintf("%s (and %d more errors)", p[0], len(p)-1)
}

// Err returns an error equivalent to this error list.
// If the list is empty, Err returns nil.
func (p ErrorList) Err() error {
        if len(p) == 0 {
                return nil
        }
        return p
}

// Report returns all (or up to maxN if > 0) errors in the list in one string
// with customizable output options for viewing errors:
// - basepath if non-empty shows filename relative to that path.
// - showSrc shows the source line on a second line -- truncated to 30 chars around err
// - showRule prints the rule name
func (p ErrorList) Report(maxN int, basepath string, showSrc, showRule bool) string {
        ne := len(p)
        if ne == 0 {
                return ""
        }
        str := ""
        if maxN == 0 {
                maxN = ne
        } else {
                maxN = min(ne, maxN)
        }
        cnt := 0
        lstln := -1
        for ei := 0; ei < ne; ei++ {
                er := p[ei]
                if er.Pos.Line == lstln {
                        continue
                }
                str += p[ei].Report(basepath, showSrc, showRule) + "<br>\n"
                lstln = er.Pos.Line
                cnt++
                if cnt > maxN {
                        break
                }
        }
        if ne > maxN {
                str += fmt.Sprintf("... and %v more errors<br>\n", ne-maxN)
        }
        return str
}

// PrintError is a utility function that prints a list of errors to w,
// one error per line, if the err parameter is an ErrorList. Otherwise
// it prints the err string.
func PrintError(w io.Writer, err error) {
        if list, ok := err.(ErrorList); ok {
                for _, e := range list {
                        fmt.Fprintf(w, "%s\n", e)
                }
        } else if err != nil {
                fmt.Fprintf(w, "%s\n", err)
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "bytes"
        "io"
        "log"
        "os"
        "slices"
        "strings"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// File contains the contents of the file being parsed -- all kept in
// memory, and represented by Line as runes, so that positions in
// the file are directly convertible to indexes in Lines structure
type File struct {

        // the current file being lex'd
        Filename string

        // the known file type, if known (typically only known files are processed)
        Known fileinfo.Known

        // base path for reporting file names -- this must be set externally e.g., by gide for the project root path
        BasePath string

        // lex'd version of the lines -- allocated to size of Lines
        Lexs []Line

        // comment tokens are stored separately here, so parser doesn't need to worry about them, but they are available for highlighting and other uses
        Comments []Line

        // stack present at the end of each line -- needed for contextualizing line-at-time lexing while editing
        LastStacks []Stack

        // token positions per line for the EOS (end of statement) tokens -- very important for scoping top-down parsing
        EosPos []EosPos

        // contents of the file as lines of runes
        Lines [][]rune
}

// SetSrc sets the source to given content, and alloc Lexs -- if basepath is empty
// then it is set to the path for the filename
func (fl *File) SetSrc(src [][]rune, fname, basepath string, known fileinfo.Known) {
        fl.Filename = fname
        if basepath != "" {
                fl.BasePath = basepath
        }
        fl.Known = known
        fl.Lines = src
        fl.AllocLines()
}

// AllocLines allocates the data per line: lex outputs and stack.
// We reset state so stale state is not hanging around.
func (fl *File) AllocLines() {
        if fl.Lines == nil {
                return
        }
        nlines := fl.NLines()
        fl.Lexs = make([]Line, nlines)
        fl.Comments = make([]Line, nlines)
        fl.LastStacks = make([]Stack, nlines)
        fl.EosPos = make([]EosPos, nlines)
}

// LinesInserted inserts new lines -- called e.g., by core.TextBuf to sync
// the markup with ongoing edits
func (fl *File) LinesInserted(stln, nlns int) {
        // Lexs
        n := len(fl.Lexs)
        if stln > n {
                stln = n
        }
        fl.Lexs = slices.Insert(fl.Lexs, stln, make([]Line, nlns)...)
        fl.Comments = slices.Insert(fl.Comments, stln, make([]Line, nlns)...)
        fl.LastStacks = slices.Insert(fl.LastStacks, stln, make([]Stack, nlns)...)
        fl.EosPos = slices.Insert(fl.EosPos, stln, make([]EosPos, nlns)...)
}

// LinesDeleted deletes lines -- called e.g., by core.TextBuf to sync
// the markup with ongoing edits
func (fl *File) LinesDeleted(stln, edln int) {
        edln = min(edln, len(fl.Lexs))
        fl.Lexs = append(fl.Lexs[:stln], fl.Lexs[edln:]...)
        fl.Comments = append(fl.Comments[:stln], fl.Comments[edln:]...)
        fl.LastStacks = append(fl.LastStacks[:stln], fl.LastStacks[edln:]...)
        fl.EosPos = append(fl.EosPos[:stln], fl.EosPos[edln:]...)
}

// RunesFromBytes returns the lines of runes from a basic byte array
func RunesFromBytes(b []byte) [][]rune {
        lns := bytes.Split(b, []byte("\n"))
        nlines := len(lns)
        rns := make([][]rune, nlines)
        for ln, txt := range lns {
                rns[ln] = bytes.Runes(txt)
        }
        return rns
}

// RunesFromString returns the lines of runes from a string (more efficient
// than converting to bytes)
func RunesFromString(str string) [][]rune {
        lns := strings.Split(str, "\n")
        nlines := len(lns)
        rns := make([][]rune, nlines)
        for ln, txt := range lns {
                rns[ln] = []rune(txt)
        }
        return rns
}

// OpenFileBytes returns bytes in given file, and logs any errors as well
func OpenFileBytes(fname string) ([]byte, error) {
        fp, err := os.Open(fname)
        if err != nil {
                log.Println(err.Error())
                return nil, err
        }
        alltxt, err := io.ReadAll(fp)
        fp.Close()
        if err != nil {
                log.Println(err.Error())
                return nil, err
        }
        return alltxt, nil
}

// OpenFile sets source to be parsed from given filename
func (fl *File) OpenFile(fname string) error {
        alltxt, err := OpenFileBytes(fname)
        if err != nil {
                return err
        }
        rns := RunesFromBytes(alltxt)
        known := fileinfo.KnownFromFile(fname)
        fl.SetSrc(rns, fname, "", known)
        return nil
}

// SetBytes sets source to be parsed from given bytes
func (fl *File) SetBytes(txt []byte) {
        if txt == nil {
                return
        }
        fl.Lines = RunesFromBytes(txt)
        fl.AllocLines()
}

// SetLineSrc sets source runes from given line of runes.
// Returns false if out of range.
func (fl *File) SetLineSrc(ln int, txt []rune) bool {
        nlines := fl.NLines()
        if ln >= nlines || ln < 0 || txt == nil {
                return false
        }
        fl.Lines[ln] = slices.Clone(txt)
        return true
}

// InitFromLine initializes from one line of source file
func (fl *File) InitFromLine(sfl *File, ln int) bool {
        nlines := sfl.NLines()
        if ln >= nlines || ln < 0 {
                return false
        }
        src := [][]rune{sfl.Lines[ln], {}} // need extra blank
        fl.SetSrc(src, sfl.Filename, sfl.BasePath, sfl.Known)
        fl.Lexs = []Line{sfl.Lexs[ln], {}}
        fl.Comments = []Line{sfl.Comments[ln], {}}
        fl.EosPos = []EosPos{sfl.EosPos[ln], {}}
        return true
}

// InitFromString initializes from given string. Returns false if string is empty
func (fl *File) InitFromString(str string, fname string, known fileinfo.Known) bool {
        if str == "" {
                return false
        }
        src := RunesFromString(str)
        if len(src) == 1 { // need more than 1 line
                src = append(src, []rune{})
        }
        fl.SetSrc(src, fname, "", known)
        return true
}

///////////////////////////////////////////////////////////////////////////
//  Accessors

// NLines returns the number of lines in source
func (fl *File) NLines() int {
        if fl.Lines == nil {
                return 0
        }
        return len(fl.Lines)
}

// SrcLine returns given line of source, as a string, or "" if out of range
func (fl *File) SrcLine(ln int) string {
        nlines := fl.NLines()
        if ln < 0 || ln >= nlines {
                return ""
        }
        return string(fl.Lines[ln])
}

// SetLine sets the line data from the lexer -- does a clone to keep the copy
func (fl *File) SetLine(ln int, lexs, comments Line, stack Stack) {
        if len(fl.Lexs) <= ln {
                fl.AllocLines()
        }
        if len(fl.Lexs) <= ln {
                return
        }
        fl.Lexs[ln] = lexs.Clone()
        fl.Comments[ln] = comments.Clone()
        fl.LastStacks[ln] = stack.Clone()
        fl.EosPos[ln] = nil
}

// LexLine returns the lexing output for given line,
// combining comments and all other tokens
// and allocating new memory using clone
func (fl *File) LexLine(ln int) Line {
        if len(fl.Lexs) <= ln {
                return nil
        }
        merge := MergeLines(fl.Lexs[ln], fl.Comments[ln])
        return merge.Clone()
}

// NTokens returns number of lex tokens for given line
func (fl *File) NTokens(ln int) int {
        if fl == nil || fl.Lexs == nil {
                return 0
        }
        if len(fl.Lexs) <= ln {
                return 0
        }
        return len(fl.Lexs[ln])
}

// IsLexPosValid returns true if given lexical token position is valid
func (fl *File) IsLexPosValid(pos textpos.Pos) bool {
        if pos.Line < 0 || pos.Line >= fl.NLines() {
                return false
        }
        nt := fl.NTokens(pos.Line)
        if pos.Char < 0 || pos.Char >= nt {
                return false
        }
        return true
}

// LexAt returns Lex item at given position, with no checking
func (fl *File) LexAt(cp textpos.Pos) *Lex {
        return &fl.Lexs[cp.Line][cp.Char]
}

// LexAtSafe returns the Lex item at given position, or last lex item if beyond end
func (fl *File) LexAtSafe(cp textpos.Pos) Lex {
        nln := fl.NLines()
        if nln == 0 {
                return Lex{}
        }
        if cp.Line >= nln {
                cp.Line = nln - 1
        }
        sz := len(fl.Lexs[cp.Line])
        if sz == 0 {
                if cp.Line > 0 {
                        cp.Line--
                        return fl.LexAtSafe(cp)
                }
                return Lex{}
        }
        if cp.Char < 0 {
                cp.Char = 0
        }
        if cp.Char >= sz {
                cp.Char = sz - 1
        }
        return *fl.LexAt(cp)
}

// ValidTokenPos returns the next valid token position starting at given point,
// false if at end of tokens
func (fl *File) ValidTokenPos(pos textpos.Pos) (textpos.Pos, bool) {
        for pos.Char >= fl.NTokens(pos.Line) {
                pos.Line++
                pos.Char = 0
                if pos.Line >= fl.NLines() {
                        pos.Line = fl.NLines() - 1 // make valid
                        return pos, false
                }
        }
        return pos, true
}

// NextTokenPos returns the next token position, false if at end of tokens
func (fl *File) NextTokenPos(pos textpos.Pos) (textpos.Pos, bool) {
        pos.Char++
        return fl.ValidTokenPos(pos)
}

// PrevTokenPos returns the previous token position, false if at end of tokens
func (fl *File) PrevTokenPos(pos textpos.Pos) (textpos.Pos, bool) {
        pos.Char--
        if pos.Char < 0 {
                pos.Line--
                if pos.Line < 0 {
                        return pos, false
                }
                for fl.NTokens(pos.Line) == 0 {
                        pos.Line--
                        if pos.Line < 0 {
                                pos.Line = 0
                                pos.Char = 0
                                return pos, false
                        }
                }
                pos.Char = fl.NTokens(pos.Line) - 1
        }
        return pos, true
}

// Token gets lex token at given Pos (Ch = token index)
func (fl *File) Token(pos textpos.Pos) token.KeyToken {
        return fl.Lexs[pos.Line][pos.Char].Token
}

// PrevDepth returns the depth of the token immediately prior to given line
func (fl *File) PrevDepth(ln int) int {
        pos := textpos.Pos{ln, 0}
        pos, ok := fl.PrevTokenPos(pos)
        if !ok {
                return 0
        }
        lx := fl.LexAt(pos)
        depth := lx.Token.Depth
        if lx.Token.Token.IsPunctGpLeft() {
                depth++
        }
        return depth
}

// PrevStack returns the stack from the previous line
func (fl *File) PrevStack(ln int) Stack {
        if ln <= 0 {
                return nil
        }
        if len(fl.LastStacks) <= ln {
                return nil
        }
        return fl.LastStacks[ln-1]
}

// TokenMapReg creates a TokenMap of tokens in region, including their
// Cat and SubCat levels -- err's on side of inclusiveness -- used
// for optimizing token matching
func (fl *File) TokenMapReg(reg textpos.Region) TokenMap {
        m := make(TokenMap)
        cp, ok := fl.ValidTokenPos(reg.Start)
        for ok && cp.IsLess(reg.End) {
                tok := fl.Token(cp).Token
                m.Set(tok)
                subc := tok.SubCat()
                if subc != tok {
                        m.Set(subc)
                }
                cat := tok.Cat()
                if cat != tok {
                        m.Set(cat)
                }
                cp, ok = fl.NextTokenPos(cp)
        }
        return m
}

/////////////////////////////////////////////////////////////////////
//  Source access from pos, reg, tok

// TokenSrc gets source runes for given token position
func (fl *File) TokenSrc(pos textpos.Pos) []rune {
        if !fl.IsLexPosValid(pos) {
                return nil
        }
        lx := fl.Lexs[pos.Line][pos.Char]
        return fl.Lines[pos.Line][lx.Start:lx.End]
}

// TokenSrcPos returns source reg associated with lex token at given token position
func (fl *File) TokenSrcPos(pos textpos.Pos) textpos.Region {
        if !fl.IsLexPosValid(pos) {
                return textpos.Region{}
        }
        lx := fl.Lexs[pos.Line][pos.Char]
        return textpos.Region{Start: textpos.Pos{pos.Line, lx.Start}, End: textpos.Pos{pos.Line, lx.End}}
}

// TokenSrcReg translates a region of tokens into a region of source
func (fl *File) TokenSrcReg(reg textpos.Region) textpos.Region {
        if !fl.IsLexPosValid(reg.Start) || reg.IsNil() {
                return textpos.Region{}
        }
        st := fl.Lexs[reg.Start.Line][reg.Start.Char].Start
        ep, _ := fl.PrevTokenPos(reg.End) // ed is exclusive -- go to prev
        ed := fl.Lexs[ep.Line][ep.Char].End
        return textpos.Region{Start: textpos.Pos{reg.Start.Line, st}, End: textpos.Pos{ep.Line, ed}}
}

// RegSrc returns the source (as a string) for given region
func (fl *File) RegSrc(reg textpos.Region) string {
        if reg.End.Line == reg.Start.Line {
                if reg.End.Char > reg.Start.Char {
                        return string(fl.Lines[reg.End.Line][reg.Start.Char:reg.End.Char])
                }
                return ""
        }
        src := string(fl.Lines[reg.Start.Line][reg.Start.Char:])
        nln := reg.End.Line - reg.Start.Line
        if nln > 10 {
                src += "|>" + string(fl.Lines[reg.Start.Line+1]) + "..."
                src += "|>" + string(fl.Lines[reg.End.Line-1])
                return src
        }
        for ln := reg.Start.Line + 1; ln < reg.End.Line; ln++ {
                src += "|>" + string(fl.Lines[ln])
        }
        src += "|>" + string(fl.Lines[reg.End.Line][:reg.End.Char])
        return src
}

// TokenRegSrc returns the source code associated with the given token region
func (fl *File) TokenRegSrc(reg textpos.Region) string {
        if !fl.IsLexPosValid(reg.Start) {
                return ""
        }
        srcreg := fl.TokenSrcReg(reg)
        return fl.RegSrc(srcreg)
}

// LexTagSrcLn returns the lex'd tagged source line for given line
func (fl *File) LexTagSrcLn(ln int) string {
        return fl.Lexs[ln].TagSrc(fl.Lines[ln])
}

// LexTagSrc returns the lex'd tagged source for entire source
func (fl *File) LexTagSrc() string {
        txt := ""
        nlines := fl.NLines()
        for ln := 0; ln < nlines; ln++ {
                txt += fl.LexTagSrcLn(ln) + "\n"
        }
        return txt
}

/////////////////////////////////////////////////////////////////
// EOS end of statement processing

// InsertEos inserts an EOS just after the given token position
// (e.g., cp = last token in line)
func (fl *File) InsertEos(cp textpos.Pos) textpos.Pos {
        np := textpos.Pos{cp.Line, cp.Char + 1}
        elx := fl.LexAt(cp)
        depth := elx.Token.Depth
        fl.Lexs[cp.Line].Insert(np.Char, Lex{Token: token.KeyToken{Token: token.EOS, Depth: depth}, Start: elx.End, End: elx.End})
        fl.EosPos[np.Line] = append(fl.EosPos[np.Line], np.Char)
        return np
}

// ReplaceEos replaces given token with an EOS
func (fl *File) ReplaceEos(cp textpos.Pos) {
        clex := fl.LexAt(cp)
        clex.Token.Token = token.EOS
        fl.EosPos[cp.Line] = append(fl.EosPos[cp.Line], cp.Char)
}

// EnsureFinalEos makes sure that the given line ends with an EOS (if it
// has tokens).
// Used for line-at-time parsing just to make sure it matches even if
// you haven't gotten to the end etc.
func (fl *File) EnsureFinalEos(ln int) {
        if ln >= fl.NLines() {
                return
        }
        sz := len(fl.Lexs[ln])
        if sz == 0 {
                return // can't get depth or anything -- useless
        }
        ep := textpos.Pos{ln, sz - 1}
        elx := fl.LexAt(ep)
        if elx.Token.Token == token.EOS {
                return
        }
        fl.InsertEos(ep)
}

// NextEos finds the next EOS position at given depth, false if none
func (fl *File) NextEos(stpos textpos.Pos, depth int) (textpos.Pos, bool) {
        // prf := profile.Start("NextEos")
        // defer prf.End()

        ep := stpos
        nlines := fl.NLines()
        if stpos.Line >= nlines {
                return ep, false
        }
        eps := fl.EosPos[stpos.Line]
        for i := range eps {
                if eps[i] < stpos.Char {
                        continue
                }
                ep.Char = eps[i]
                lx := fl.LexAt(ep)
                if lx.Token.Depth == depth {
                        return ep, true
                }
        }
        for ep.Line = stpos.Line + 1; ep.Line < nlines; ep.Line++ {
                eps := fl.EosPos[ep.Line]
                sz := len(eps)
                if sz == 0 {
                        continue
                }
                for i := 0; i < sz; i++ {
                        ep.Char = eps[i]
                        lx := fl.LexAt(ep)
                        if lx.Token.Depth == depth {
                                return ep, true
                        }
                }
        }
        return ep, false
}

// NextEosAnyDepth finds the next EOS at any depth
func (fl *File) NextEosAnyDepth(stpos textpos.Pos) (textpos.Pos, bool) {
        ep := stpos
        nlines := fl.NLines()
        if stpos.Line >= nlines {
                return ep, false
        }
        eps := fl.EosPos[stpos.Line]
        if np := eps.FindGtEq(stpos.Char); np >= 0 {
                ep.Char = np
                return ep, true
        }
        ep.Char = 0
        for ep.Line = stpos.Line + 1; ep.Line < nlines; ep.Line++ {
                sz := len(fl.EosPos[ep.Line])
                if sz == 0 {
                        continue
                }
                return ep, true
        }
        return ep, false
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/token"
)

// these functions support indentation algorithms,
// operating on marked-up rune source.

// LineIndent returns the number of tabs or spaces at start of given rune-line,
// based on target tab-size (only relevant for spaces).
// If line starts with tabs, then those are counted, else spaces --
// combinations of tabs and spaces won't produce sensible results.
func LineIndent(src []rune, tabSz int) (ind int, ichr indent.Character) {
        ichr = indent.Tab
        sz := len(src)
        if sz == 0 {
                return
        }
        if src[0] == ' ' {
                ichr = indent.Space
                ind = 1
        } else if src[0] != '\t' {
                return
        } else {
                ind = 1
        }
        if ichr == indent.Space {
                for i := 1; i < sz; i++ {
                        if src[i] == ' ' {
                                ind++
                        } else {
                                ind /= tabSz
                                return
                        }
                }
                ind /= tabSz
                return
        }
        for i := 1; i < sz; i++ {
                if src[i] == '\t' {
                        ind++
                } else {
                        return
                }
        }
        return
}

// PrevLineIndent returns indentation level of previous line
// from given line that has indentation -- skips blank lines.
// Returns indent level and previous line number, and indent char.
// indent level is in increments of tabSz for spaces, and tabs for tabs.
// Operates on rune source with markup lex tags per line.
func PrevLineIndent(src [][]rune, tags []Line, ln int, tabSz int) (ind, pln int, ichr indent.Character) {
        ln--
        for ln >= 0 {
                if len(src[ln]) == 0 {
                        ln--
                        continue
                }
                ind, ichr = LineIndent(src[ln], tabSz)
                pln = ln
                return
        }
        ind = 0
        pln = 0
        return
}

// BracketIndentLine returns the indentation level for given line based on
// previous line's indentation level, and any delta change based on
// brackets starting or ending the previous or current line.
// indent level is in increments of tabSz for spaces, and tabs for tabs.
// Operates on rune source with markup lex tags per line.
func BracketIndentLine(src [][]rune, tags []Line, ln int, tabSz int) (pInd, delInd, pLn int, ichr indent.Character) {
        pInd, pLn, ichr = PrevLineIndent(src, tags, ln, tabSz)

        curUnd, _ := LineStartEndBracket(src[ln], tags[ln])
        _, prvInd := LineStartEndBracket(src[pLn], tags[pLn])

        delInd = 0
        switch {
        case prvInd && curUnd:
                delInd = 0 // offset
        case prvInd:
                delInd = 1 // indent
        case curUnd:
                delInd = -1 // undent
        }
        if pInd == 0 && delInd < 0 { // error..
                delInd = 0
        }
        return
}

// LastTokenIgnoreComment returns the last token of the tags, ignoring
// any final comment at end
func LastLexIgnoreComment(tags Line) (*Lex, int) {
        var ll *Lex
        li := -1
        nt := len(tags)
        for i := nt - 1; i >= 0; i-- {
                l := &tags[i]
                if l.Token.Token.Cat() == token.Comment || l.Token.Token < token.Keyword {
                        continue
                }
                ll = l
                li = i
                break
        }
        return ll, li
}

// LineStartEndBracket checks if line starts with a closing bracket
// or ends with an opening bracket. This is used for auto-indent for example.
// Bracket is Paren, Bracket, or Brace.
func LineStartEndBracket(src []rune, tags Line) (start, end bool) {
        if len(src) == 0 {
                return
        }
        nt := len(tags)
        if nt > 0 {
                ftok := tags[0].Token.Token
                if ftok.InSubCat(token.PunctGp) {
                        if ftok.IsPunctGpRight() {
                                start = true
                        }
                }
                ll, _ := LastLexIgnoreComment(tags)
                if ll != nil {
                        ltok := ll.Token.Token
                        if ltok.InSubCat(token.PunctGp) {
                                if ltok.IsPunctGpLeft() {
                                        end = true
                                }
                        }
                }
                return
        }
        // no tags -- do it manually
        fi := FirstNonSpaceRune(src)
        if fi >= 0 {
                bp, rt := BracePair(src[fi])
                if bp != 0 && rt {
                        start = true
                }
        }
        li := LastNonSpaceRune(src)
        if li >= 0 {
                bp, rt := BracePair(src[li])
                if bp != 0 && !rt {
                        end = true
                }
        }
        return
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package lexer provides all the lexing functions that transform text
// into lexical tokens, using token types defined in the token package.
// It also has the basic file source and position / region management
// functionality.
package lexer

//go:generate core generate

import (
        "fmt"

        "cogentcore.org/core/base/nptime"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// Lex represents a single lexical element, with a token, and start and end rune positions
// within a line of a file.  Critically it also contains the nesting depth computed from
// all the parens, brackets, braces.  Todo: also support XML < > </ > tag depth.
type Lex struct {

        // Token includes cache of keyword for keyword types, and also has nesting depth: starting at 0 at start of file and going up for every increment in bracket / paren / start tag and down for every decrement. Is computed once and used extensively in parsing.
        Token token.KeyToken

        // start rune index within original source line for this token
        Start int

        // end rune index within original source line for this token (exclusive -- ends one before this)
        End int

        // time when region was set -- used for updating locations in the text based on time stamp (using efficient non-pointer time)
        Time nptime.Time
}

func NewLex(tok token.KeyToken, st, ed int) Lex {
        lx := Lex{Token: tok, Start: st, End: ed}
        return lx
}

// Src returns the rune source for given lex item (does no validity checking)
func (lx *Lex) Src(src []rune) []rune {
        return src[lx.Start:lx.End]
}

// Now sets the time stamp to now
func (lx *Lex) Now() {
        lx.Time.Now()
}

// String satisfies the fmt.Stringer interface
func (lx *Lex) String() string {
        return fmt.Sprintf("[+%d:%v:%v:%v]", lx.Token.Depth, lx.Start, lx.End, lx.Token.String())
}

// ContainsPos returns true if the Lex element contains given character position
func (lx *Lex) ContainsPos(pos int) bool {
        return pos >= lx.Start && pos < lx.End
}

// OverlapsReg returns true if the two regions overlap
func (lx *Lex) OverlapsReg(or Lex) bool {
        // start overlaps
        if (lx.Start >= or.Start && lx.Start < or.End) || (or.Start >= lx.Start && or.Start < lx.End) {
                return true
        }
        // end overlaps
        return (lx.End > or.Start && lx.End <= or.End) || (or.End > lx.Start && or.End <= lx.End)
}

// Region returns the region for this lexical element, at given line
func (lx *Lex) Region(ln int) textpos.Region {
        return textpos.Region{Start: textpos.Pos{Line: ln, Char: lx.Start}, End: textpos.Pos{Line: ln, Char: lx.End}}
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "slices"
        "sort"
        "unicode"

        "cogentcore.org/core/text/token"
)

// Line is one line of Lex'd text
type Line []Lex

// Add adds one element to the lex line (just append)
func (ll *Line) Add(lx Lex) {
        *ll = append(*ll, lx)
}

// Add adds one element to the lex line with given params, returns pointer to that new lex
func (ll *Line) AddLex(tok token.KeyToken, st, ed int) *Lex {
        lx := NewLex(tok, st, ed)
        li := len(*ll)
        ll.Add(lx)
        return &(*ll)[li]
}

// Insert inserts one element to the lex line at given point
func (ll *Line) Insert(idx int, lx Lex) {
        sz := len(*ll)
        *ll = append(*ll, lx)
        if idx < sz {
                copy((*ll)[idx+1:], (*ll)[idx:sz])
                (*ll)[idx] = lx
        }
}

// AtPos returns the Lex in place for given position, and index, or nil, -1 if none
func (ll *Line) AtPos(pos int) (*Lex, int) {
        for i := range *ll {
                lx := &((*ll)[i])
                if lx.ContainsPos(pos) {
                        return lx, i
                }
        }
        return nil, -1
}

// Clone returns a new copy of the line
func (ll *Line) Clone() Line {
        if len(*ll) == 0 {
                return nil
        }
        cp := make(Line, len(*ll))
        for i := range *ll {
                cp[i] = (*ll)[i]
        }
        return cp
}

// AddSort adds a new lex element in sorted order to list, sorted by start
// position, and if at the same start position, then sorted *decreasing*
// by end position -- this allows outer tags to be processed before inner tags
// which fits a stack-based tag markup logic.
func (ll *Line) AddSort(lx Lex) {
        for i, t := range *ll {
                if t.Start < lx.Start {
                        continue
                }
                if t.Start == lx.Start && t.End >= lx.End {
                        continue
                }
                *ll = append(*ll, lx)
                copy((*ll)[i+1:], (*ll)[i:])
                (*ll)[i] = lx
                return
        }
        *ll = append(*ll, lx)
}

// Sort sorts the lex elements by starting pos, and ending pos *decreasing* if a tie
func (ll *Line) Sort() {
        sort.Slice((*ll), func(i, j int) bool {
                return (*ll)[i].Start < (*ll)[j].Start || ((*ll)[i].Start == (*ll)[j].Start && (*ll)[i].End > (*ll)[j].End)
        })
}

// DeleteIndex deletes at given index
func (ll *Line) DeleteIndex(idx int) {
        *ll = append((*ll)[:idx], (*ll)[idx+1:]...)
}

// DeleteToken deletes a specific token type from list
func (ll *Line) DeleteToken(tok token.Tokens) {
        nt := len(*ll)
        for i := nt - 1; i >= 0; i-- { // remove
                t := (*ll)[i]
                if t.Token.Token == tok {
                        ll.DeleteIndex(i)
                }
        }
}

// RuneStrings returns array of strings for Lex regions defined in Line, for
// given rune source string
func (ll *Line) RuneStrings(rstr []rune) []string {
        regs := make([]string, len(*ll))
        for i, t := range *ll {
                regs[i] = string(rstr[t.Start:t.End])
        }
        return regs
}

// MergeLines merges the two lines of lex regions into a combined list
// properly ordered by sequence of tags within the line.
func MergeLines(t1, t2 Line) Line {
        sz1 := len(t1)
        sz2 := len(t2)
        if sz1 == 0 {
                return t2
        }
        if sz2 == 0 {
                return t1
        }
        tsz := sz1 + sz2
        tl := make(Line, sz1, tsz)
        copy(tl, t1)
        for i := 0; i < sz2; i++ {
                tl.AddSort(t2[i])
        }
        return tl
}

// String satisfies the fmt.Stringer interface
func (ll *Line) String() string {
        str := ""
        for _, t := range *ll {
                str += t.String() + " "
        }
        return str
}

// TagSrc returns the token-tagged source
func (ll *Line) TagSrc(src []rune) string {
        str := ""
        for _, t := range *ll {
                s := t.Src(src)
                str += t.String() + `"` + string(s) + `"` + " "
        }
        return str
}

// Strings returns a slice of strings for each of the Lex items in given rune src
// split by Line Lex's.  Returns nil if Line empty.
func (ll *Line) Strings(src []rune) []string {
        nl := len(*ll)
        if nl == 0 {
                return nil
        }
        sa := make([]string, nl)
        for i, t := range *ll {
                sa[i] = string(t.Src(src))
        }
        return sa
}

// NonCodeWords returns a Line of white-space separated word tokens in given tagged source
// that ignores token.IsCode token regions -- i.e., the "regular" words
// present in the source line -- this is useful for things like spell checking
// or manual parsing.
func (ll *Line) NonCodeWords(src []rune) Line {
        wsrc := slices.Clone(src)
        for _, t := range *ll { // blank out code parts first
                if t.Token.Token.IsCode() {
                        for i := t.Start; i < t.End; i++ {
                                wsrc[i] = ' '
                        }
                }
        }
        return RuneFields(wsrc)
}

// RuneFields returns a Line of Lex's defining the non-white-space "fields"
// in the given rune string
func RuneFields(src []rune) Line {
        if len(src) == 0 {
                return nil
        }
        var ln Line
        cur := Lex{}
        pspc := unicode.IsSpace(src[0])
        cspc := pspc
        for i, r := range src {
                cspc = unicode.IsSpace(r)
                if pspc {
                        if !cspc {
                                cur.Start = i
                        }
                } else {
                        if cspc {
                                cur.End = i
                                ln.Add(cur)
                        }
                }
                pspc = cspc
        }
        if !pspc {
                cur.End = len(src)
                cur.Now()
                ln.Add(cur)
        }
        return ln
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "strings"
        "unicode"

        "cogentcore.org/core/text/token"
)

// These functions provide "manual" lexing support for specific cases, such as completion, where a string must be processed further.

// FirstWord returns the first contiguous sequence of purely [unicode.IsLetter] runes within the given string.
// It skips over any leading non-letters until a letter is found.
// Note that this function does not include numbers. For that, you can use the FirstWordDigits function.
func FirstWord(str string) string {
        rstr := ""
        for _, s := range str {
                if !IsLetter(s) {
                        if len(rstr) == 0 {
                                continue
                        }
                        break
                }
                rstr += string(s)
        }
        return rstr
}

// FirstWordDigits returns the first contiguous sequence of purely [IsLetterOrDigit]
// runes within the given string. It skips over any leading non-letters until a letter
// (not digit) is found.
func FirstWordDigits(str string) string {
        rstr := ""
        for _, s := range str {
                if !IsLetterOrDigit(s) {
                        if len(rstr) == 0 {
                                continue
                        }
                        break
                }
                if len(rstr) == 0 && IsDigit(s) { // can't start with digit
                        continue
                }
                rstr += string(s)
        }
        return rstr
}

// FirstWordApostrophe returns the first contiguous sequence of purely
// [unicode.IsLetter] runes that can also contain an apostrophe within
// the word but not at the end. This is for spell checking: also excludes
// any _ values.
func FirstWordApostrophe(str string) string {
        rstr := ""
        for _, s := range str {
                if !(IsLetterNoUnderbar(s) || s == '\'') {
                        if len(rstr) == 0 {
                                continue
                        }
                        break
                }
                if len(rstr) == 0 && s == '\'' { // can't start with '
                        continue
                }
                rstr += string(s)
        }
        rstr = strings.TrimRight(rstr, "'") // get rid of any trailing ones!
        return rstr
}

// TrimLeftToAlpha returns string without any leading non-alpha runes.
func TrimLeftToAlpha(nm string) string {
        return strings.TrimLeftFunc(nm, func(r rune) bool {
                return !unicode.IsLetter(r)
        })
}

// FirstNonSpaceRune returns the index of first non-space rune, -1 if not found
func FirstNonSpaceRune(src []rune) int {
        for i, s := range src {
                if !unicode.IsSpace(s) {
                        return i
                }
        }
        return -1
}

// LastNonSpaceRune returns the index of last non-space rune, -1 if not found
func LastNonSpaceRune(src []rune) int {
        sz := len(src)
        if sz == 0 {
                return -1
        }
        for i := sz - 1; i >= 0; i-- {
                s := src[i]
                if !unicode.IsSpace(s) {
                        return i
                }
        }
        return -1
}

// InnerBracketScope returns the inner scope for a given bracket type if it is
// imbalanced. It is important to do completion based on just that inner scope
// if that is where the user is at.
func InnerBracketScope(str string, brl, brr string) string {
        nlb := strings.Count(str, brl)
        nrb := strings.Count(str, brr)
        if nlb == nrb {
                return str
        }
        if nlb > nrb {
                li := strings.LastIndex(str, brl)
                if li == len(str)-1 {
                        return InnerBracketScope(str[:li], brl, brr) // get rid of open ending and try again
                }
                str = str[li+1:]
                ri := strings.Index(str, brr)
                if ri < 0 {
                        return str
                }
                return str[:ri]
        }
        // nrb > nlb -- we're missing the left guys -- go to first rb
        ri := strings.Index(str, brr)
        if ri == 0 {
                return InnerBracketScope(str[1:], brl, brr) // get rid of opening and try again
        }
        str = str[:ri]
        li := strings.Index(str, brl)
        if li < 0 {
                return str
        }
        return str[li+1:]
}

// LastField returns the last white-space separated string
func LastField(str string) string {
        if str == "" {
                return ""
        }
        flds := strings.Fields(str)
        return flds[len(flds)-1]
}

// ObjPathAt returns the starting Lex, before given lex,
// that include sequences of PunctSepPeriod and NameTag
// which are used for object paths (e.g., field.field.field)
func ObjPathAt(line Line, lx *Lex) *Lex {
        stlx := lx
        if lx.Start > 1 {
                _, lxidx := line.AtPos(lx.Start - 1)
                for i := lxidx; i >= 0; i-- {
                        clx := &line[i]
                        if clx.Token.Token == token.PunctSepPeriod || clx.Token.Token.InCat(token.Name) {
                                stlx = clx
                        } else {
                                break
                        }
                }
        }
        return stlx
}

// LastScopedString returns the last white-space separated, and bracket
// enclosed string from given string.
func LastScopedString(str string) string {
        str = LastField(str)
        bstr := str
        str = InnerBracketScope(str, "{", "}")
        str = InnerBracketScope(str, "(", ")")
        str = InnerBracketScope(str, "[", "]")
        if str == "" {
                return bstr
        }
        str = TrimLeftToAlpha(str)
        if str == "" {
                str = TrimLeftToAlpha(bstr)
                if str == "" {
                        return bstr
                }
        }
        flds := strings.Split(str, ",")
        return flds[len(flds)-1]
}

// HasUpperCase returns true if string has an upper-case letter
func HasUpperCase(str string) bool {
        for _, r := range str {
                if unicode.IsUpper(r) {
                        return true
                }
        }
        return false
}

// MatchCase uses the source string case (upper / lower) to set corresponding
// case in target string, returning that string.
func MatchCase(src, trg string) string {
        rsc := []rune(src)
        rtg := []rune(trg)
        mx := min(len(rsc), len(rtg))
        for i := 0; i < mx; i++ {
                t := rtg[i]
                if unicode.IsUpper(rsc[i]) {
                        if !unicode.IsUpper(t) {
                                rtg[i] = unicode.ToUpper(t)
                        }
                } else {
                        if !unicode.IsLower(t) {
                                rtg[i] = unicode.ToLower(t)
                        }
                }
        }
        return string(rtg)
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "unicode"
        "unicode/utf8"
)

// Matches are what kind of lexing matches to make
type Matches int32 //enums:enum

// Matching rules
const (
        // String means match a specific string as given in the rule
        // Note: this only looks for the string with no constraints on
        // what happens after this string -- use StrName to match entire names
        String Matches = iota

        // StrName means match a specific string that is a complete alpha-numeric
        // string (including underbar _) with some other char at the end
        // must use this for all keyword matches to ensure that it isn't just
        // the start of a longer name
        StrName

        // Match any letter, including underscore
        Letter

        // Match digit 0-9
        Digit

        // Match any white space (space, tab) -- input is already broken into lines
        WhiteSpace

        // CurState means match current state value set by a PushState action, using String value in rule
        // all CurState cases must generally be first in list of rules so they can preempt
        // other rules when the state is active
        CurState

        // AnyRune means match any rune -- use this as the last condition where other terminators
        // come first!
        AnyRune
)

// MatchPos are special positions for a match to occur
type MatchPos int32 //enums:enum

// Matching position rules
const (
        // AnyPos matches at any position
        AnyPos MatchPos = iota

        // StartOfLine matches at start of line
        StartOfLine

        // EndOfLine matches at end of line
        EndOfLine

        // MiddleOfLine matches not at the start or end
        MiddleOfLine

        // StartOfWord matches at start of word
        StartOfWord

        // EndOfWord matches at end of word
        EndOfWord

        // MiddleOfWord matches not at the start or end
        MiddleOfWord
)

//////// Match functions -- see also state for more complex ones

func IsLetter(ch rune) bool {
        return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || (ch >= utf8.RuneSelf && unicode.IsLetter(ch))
}

func IsLetterNoUnderbar(ch rune) bool {
        return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || (ch >= utf8.RuneSelf && unicode.IsLetter(ch))
}

func IsDigit(ch rune) bool {
        return '0' <= ch && ch <= '9' || ch >= utf8.RuneSelf && unicode.IsDigit(ch)
}

func IsLetterOrDigit(ch rune) bool {
        return IsLetter(ch) || IsDigit(ch)
}

func IsWhiteSpace(ch rune) bool {
        return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// PassTwo performs second pass(s) through the lexicalized version of the source,
// computing nesting depth for every token once and for all -- this is essential for
// properly matching tokens and also for colorization in syntax highlighting.
// Optionally, a subsequent pass finds end-of-statement (EOS) tokens, which are essential
// for parsing to first break the source down into statement-sized chunks.  A separate
// list of EOS token positions is maintained for very fast access.
type PassTwo struct {

        // should we perform EOS detection on this type of file?
        DoEos bool

        // use end-of-line as a default EOS, if nesting depth is same as start of line (python) -- see also EolToks
        Eol bool

        // replace all semicolons with EOS to keep it consistent (C, Go..)
        Semi bool

        // use backslash as a line continuer (python)
        Backslash bool

        // if a right-brace } is detected anywhere in the line, insert an EOS *before* RBrace AND after it (needed for Go) -- do not include RBrace in EolToks in this case
        RBraceEos bool

        // specific tokens to recognize at the end of a line that trigger an EOS (Go)
        EolToks token.KeyTokenList
}

// TwoState is the state maintained for the PassTwo process
type TwoState struct {

        // position in lex tokens we're on
        Pos textpos.Pos

        // file that we're operating on
        Src *File

        // stack of nesting tokens
        NestStack []token.Tokens

        // any error messages accumulated during lexing specifically
        Errs ErrorList
}

// Init initializes state for a new pass -- called at start of NestDepth
func (ts *TwoState) Init() {
        ts.Pos = textpos.PosZero
        ts.NestStack = ts.NestStack[0:0]
}

// SetSrc sets the source we're operating on
func (ts *TwoState) SetSrc(src *File) {
        ts.Src = src
}

// NextLine advances to next line
func (ts *TwoState) NextLine() {
        ts.Pos.Line++
        ts.Pos.Char = 0
}

// Error adds an passtwo error at current position
func (ts *TwoState) Error(msg string) {
        ppos := ts.Pos
        ppos.Char--
        clex := ts.Src.LexAtSafe(ppos)
        ts.Errs.Add(textpos.Pos{ts.Pos.Line, clex.Start}, ts.Src.Filename, "PassTwo: "+msg, ts.Src.SrcLine(ts.Pos.Line), nil)
}

// NestStackStr returns the token stack as strings
func (ts *TwoState) NestStackStr() string {
        str := ""
        for _, tok := range ts.NestStack {
                switch tok {
                case token.PunctGpLParen:
                        str += "paren ( "
                case token.PunctGpLBrack:
                        str += "bracket [ "
                case token.PunctGpLBrace:
                        str += "brace { "
                }
        }
        return str
}

/////////////////////////////////////////////////////////////////////
//  PassTwo

// Error adds an passtwo error at given position
func (pt *PassTwo) Error(ts *TwoState, msg string) {
        ts.Error(msg)
}

// HasErrs reports if there are errors in eosing process
func (pt *PassTwo) HasErrs(ts *TwoState) bool {
        return len(ts.Errs) > 0
}

// MismatchError reports a mismatch for given type of parentheses / bracket
func (pt *PassTwo) MismatchError(ts *TwoState, tok token.Tokens) {
        switch tok {
        case token.PunctGpRParen:
                pt.Error(ts, "mismatching parentheses -- right paren ')' without matching left paren '('")
        case token.PunctGpRBrack:
                pt.Error(ts, "mismatching square brackets -- right bracket ']' without matching left bracket '['")
        case token.PunctGpRBrace:
                pt.Error(ts, "mismatching curly braces -- right brace '}' without matching left bracket '{'")
        }
}

// PushNest pushes a nesting left paren / bracket onto stack
func (pt *PassTwo) PushNest(ts *TwoState, tok token.Tokens) {
        ts.NestStack = append(ts.NestStack, tok)
}

// PopNest attempts to pop given token off of nesting stack, generating error if it mismatches
func (pt *PassTwo) PopNest(ts *TwoState, tok token.Tokens) {
        sz := len(ts.NestStack)
        if sz == 0 {
                pt.MismatchError(ts, tok)
                return
        }
        cur := ts.NestStack[sz-1]
        ts.NestStack = ts.NestStack[:sz-1] // better to clear than keep even if err
        if cur != tok.PunctGpMatch() {
                pt.MismatchError(ts, tok)
        }
}

// Perform nesting depth computation
func (pt *PassTwo) NestDepth(ts *TwoState) {
        ts.Init()
        nlines := ts.Src.NLines()
        if nlines == 0 {
                return
        }
        // if len(ts.Src.Lexs[nlines-1]) > 0 { // last line ends with tokens -- parser needs empty last line..
        //         ts.Src.Lexs = append(ts.Src.Lexs, Line{})
        //         *ts.Src.Lines = append(*ts.Src.Lines, []rune{})
        // }
        for ts.Pos.Line < nlines {
                sz := len(ts.Src.Lexs[ts.Pos.Line])
                if sz == 0 {
                        ts.NextLine()
                        continue
                }
                lx := ts.Src.LexAt(ts.Pos)
                tok := lx.Token.Token
                if tok.IsPunctGpLeft() {
                        lx.Token.Depth = len(ts.NestStack) // depth increments AFTER -- this turns out to be ESSENTIAL!
                        pt.PushNest(ts, tok)
                } else if tok.IsPunctGpRight() {
                        pt.PopNest(ts, tok)
                        lx.Token.Depth = len(ts.NestStack) // end has same depth as start, which is same as SURROUND
                } else {
                        lx.Token.Depth = len(ts.NestStack)
                }
                ts.Pos.Char++
                if ts.Pos.Char >= sz {
                        ts.NextLine()
                }
        }
        stsz := len(ts.NestStack)
        if stsz > 0 {
                pt.Error(ts, "mismatched grouping -- end of file with these left unmatched: "+ts.NestStackStr())
        }
}

// Perform nesting depth computation on only one line, starting at
// given initial depth -- updates the given line
func (pt *PassTwo) NestDepthLine(line Line, initDepth int) {
        sz := len(line)
        if sz == 0 {
                return
        }
        depth := initDepth
        for i := 0; i < sz; i++ {
                lx := &line[i]
                tok := lx.Token.Token
                if tok.IsPunctGpLeft() {
                        lx.Token.Depth = depth
                        depth++
                } else if tok.IsPunctGpRight() {
                        depth--
                        lx.Token.Depth = depth
                } else {
                        lx.Token.Depth = depth
                }
        }
}

// Perform EOS detection
func (pt *PassTwo) EosDetect(ts *TwoState) {
        nlines := ts.Src.NLines()
        pt.EosDetectPos(ts, textpos.PosZero, nlines)
}

// Perform EOS detection at given starting position, for given number of lines
func (pt *PassTwo) EosDetectPos(ts *TwoState, pos textpos.Pos, nln int) {
        ts.Pos = pos
        nlines := ts.Src.NLines()
        ok := false
        for lc := 0; ts.Pos.Line < nlines && lc < nln; lc++ {
                sz := len(ts.Src.Lexs[ts.Pos.Line])
                if sz == 0 {
                        ts.NextLine()
                        continue
                }
                if pt.Semi {
                        for ts.Pos.Char = 0; ts.Pos.Char < sz; ts.Pos.Char++ {
                                lx := ts.Src.LexAt(ts.Pos)
                                if lx.Token.Token == token.PunctSepSemicolon {
                                        ts.Src.ReplaceEos(ts.Pos)
                                }
                        }
                }
                if pt.RBraceEos {
                        skip := false
                        for ci := 0; ci < sz; ci++ {
                                lx := ts.Src.LexAt(textpos.Pos{ts.Pos.Line, ci})
                                if lx.Token.Token == token.PunctGpRBrace {
                                        if ci == 0 {
                                                ip := textpos.Pos{ts.Pos.Line, 0}
                                                ip, ok = ts.Src.PrevTokenPos(ip)
                                                if ok {
                                                        ilx := ts.Src.LexAt(ip)
                                                        if ilx.Token.Token != token.PunctGpLBrace && ilx.Token.Token != token.EOS {
                                                                ts.Src.InsertEos(ip)
                                                        }
                                                }
                                        } else {
                                                ip := textpos.Pos{ts.Pos.Line, ci - 1}
                                                ilx := ts.Src.LexAt(ip)
                                                if ilx.Token.Token != token.PunctGpLBrace {
                                                        ts.Src.InsertEos(ip)
                                                        ci++
                                                        sz++
                                                }
                                        }
                                        if ci == sz-1 {
                                                ip := textpos.Pos{ts.Pos.Line, ci}
                                                ts.Src.InsertEos(ip)
                                                sz++
                                                skip = true
                                        }
                                }
                        }
                        if skip {
                                ts.NextLine()
                                continue
                        }
                }
                ep := textpos.Pos{ts.Pos.Line, sz - 1} // end of line token
                elx := ts.Src.LexAt(ep)
                if pt.Eol {
                        sp := textpos.Pos{ts.Pos.Line, 0} // start of line token
                        slx := ts.Src.LexAt(sp)
                        if slx.Token.Depth == elx.Token.Depth {
                                ts.Src.InsertEos(ep)
                        }
                }
                if len(pt.EolToks) > 0 { // not depth specific
                        if pt.EolToks.Match(elx.Token) {
                                ts.Src.InsertEos(ep)
                        }
                }
                ts.NextLine()
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "cogentcore.org/core/text/token"
)

// EosPos is a line of EOS token positions, always sorted low-to-high
type EosPos []int

// FindGt returns any pos value greater than given token pos, -1 if none
func (ep EosPos) FindGt(ch int) int {
        for i := range ep {
                if ep[i] > ch {
                        return ep[i]
                }
        }
        return -1
}

// FindGtEq returns any pos value greater than or equal to given token pos, -1 if none
func (ep EosPos) FindGtEq(ch int) int {
        for i := range ep {
                if ep[i] >= ch {
                        return ep[i]
                }
        }
        return -1
}

////////  TokenMap

// TokenMap is a token map, for optimizing token exclusion
type TokenMap map[token.Tokens]struct{}

// Set sets map for given token
func (tm TokenMap) Set(tok token.Tokens) {
        tm[tok] = struct{}{}
}

// Has returns true if given token is in the map
func (tm TokenMap) Has(tok token.Tokens) bool {
        _, has := tm[tok]
        return has
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "fmt"
        "io"
        "strings"
        "text/tabwriter"
        "unicode"

        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/token"
        "cogentcore.org/core/tree"
)

// Trace is whether to print debug trace info.
var Trace = false

// Rule operates on the text input to produce the lexical tokens.
//
// Lexing is done line-by-line -- you must push and pop states to
// coordinate across multiple lines, e.g., for multi-line comments.
//
// There is full access to entire line and you can decide based on future
// (offset) characters.
//
// In general it is best to keep lexing as simple as possible and
// leave the more complex things for the parsing step.
type Rule struct {
        tree.NodeBase

        // disable this rule -- useful for testing and exploration
        Off bool `json:",omitempty"`

        // description / comments about this rule
        Desc string `json:",omitempty"`

        // the token value that this rule generates -- use None for non-terminals
        Token token.Tokens

        // the lexical match that we look for to engage this rule
        Match Matches

        // position where match can occur
        Pos MatchPos

        // if action is LexMatch, this is the string we match
        String string

        // offset into the input to look for a match: 0 = current char, 1 = next one, etc
        Offset int `json:",omitempty"`

        // adjusts the size of the region (plus or minus) that is processed for the Next action -- allows broader and narrower matching relative to tagging
        SizeAdj int `json:",omitempty"`

        // the action(s) to perform, in order, if there is a match -- these are performed prior to iterating over child nodes
        Acts []Actions

        // string(s) for ReadUntil action -- will read until any of these strings are found -- separate different options with | -- if you need to read until a literal | just put two || in a row and that will show up as a blank, which is interpreted as a literal |
        Until string `json:",omitempty"`

        // the state to push if our action is PushState -- note that State matching is on String, not this value
        PushState string `json:",omitempty"`

        // create an optimization map for this rule, which must be a parent with children that all match against a Name string -- this reads the Name and directly activates the associated rule with that String, without having to iterate through them -- use this for keywords etc -- produces a SIGNIFICANT speedup for long lists of keywords.
        NameMap bool `json:",omitempty"`

        // length of source that matched -- if Next is called, this is what will be skipped to
        MatchLen int `display:"-" json:"-" xml:"-"`

        // NameMap lookup map -- created during Compile
        NmMap map[string]*Rule `edit:"-" json:"-" xml:"-"`
}

// CompileAll is called on the top-level Rule to compile all nodes.
// returns true if everything is ok
func (lr *Rule) CompileAll(ls *State) bool {
        allok := false
        lr.WalkDown(func(k tree.Node) bool {
                lri := k.(*Rule)
                ok := lri.Compile(ls)
                if !ok {
                        allok = false
                }
                return true
        })
        return allok
}

// Compile performs any one-time compilation steps on the rule
// returns false if there are any problems.
func (lr *Rule) Compile(ls *State) bool {
        if lr.Off {
                lr.SetProperty("inactive", true)
        } else {
                lr.DeleteProperty("inactive")
        }
        valid := true
        lr.ComputeMatchLen(ls)
        if lr.NameMap {
                if !lr.CompileNameMap(ls) {
                        valid = false
                }
        }
        return valid
}

// CompileNameMap compiles name map -- returns false if there are problems.
func (lr *Rule) CompileNameMap(ls *State) bool {
        valid := true
        lr.NmMap = make(map[string]*Rule, len(lr.Children))
        for _, klri := range lr.Children {
                klr := klri.(*Rule)
                if !klr.Validate(ls) {
                        valid = false
                }
                if klr.String == "" {
                        ls.Error(0, "CompileNameMap: must have non-empty String to match", lr)
                        valid = false
                        continue
                }
                if _, has := lr.NmMap[klr.String]; has {
                        ls.Error(0, fmt.Sprintf("CompileNameMap: multiple rules have the same string name: %v -- must be unique!", klr.String), lr)
                        valid = false
                } else {
                        lr.NmMap[klr.String] = klr
                }
        }
        return valid
}

// Validate checks for any errors in the rules and issues warnings,
// returns true if valid (no err) and false if invalid (errs)
func (lr *Rule) Validate(ls *State) bool {
        valid := true
        if !tree.IsRoot(lr) {
                switch lr.Match {
                case StrName:
                        fallthrough
                case String:
                        if len(lr.String) == 0 {
                                valid = false
                                ls.Error(0, "match = String or StrName but String is empty", lr)
                        }
                case CurState:
                        for _, act := range lr.Acts {
                                if act == Next {
                                        valid = false
                                        ls.Error(0, "match = CurState cannot have Action = Next -- no src match", lr)
                                }
                        }
                        if len(lr.String) == 0 {
                                ls.Error(0, "match = CurState must have state to match in String -- is empty", lr)
                        }
                        if len(lr.PushState) > 0 {
                                ls.Error(0, "match = CurState has non-empty PushState -- must have state to match in String instead", lr)
                        }
                }
        }

        if !lr.HasChildren() && len(lr.Acts) == 0 {
                valid = false
                ls.Error(0, "rule has no children and no action -- does nothing", lr)
        }

        hasPos := false
        for _, act := range lr.Acts {
                if act >= Name && act <= EOL {
                        hasPos = true
                }
                if act == Next && hasPos {
                        valid = false
                        ls.Error(0, "action = Next incompatible with action that reads item such as Name, Number, Quoted", lr)
                }
        }

        if lr.Token.Cat() == token.Keyword && lr.Match != StrName {
                valid = false
                ls.Error(0, "Keyword token must use StrName to match entire name", lr)
        }

        // now we iterate over our kids
        for _, klri := range lr.Children {
                klr := klri.(*Rule)
                if !klr.Validate(ls) {
                        valid = false
                }
        }
        return valid
}

// ComputeMatchLen computes MatchLen based on match type
func (lr *Rule) ComputeMatchLen(ls *State) {
        switch lr.Match {
        case String:
                sz := len(lr.String)
                lr.MatchLen = lr.Offset + sz + lr.SizeAdj
        case StrName:
                sz := len(lr.String)
                lr.MatchLen = lr.Offset + sz + lr.SizeAdj
        case Letter:
                lr.MatchLen = lr.Offset + 1 + lr.SizeAdj
        case Digit:
                lr.MatchLen = lr.Offset + 1 + lr.SizeAdj
        case WhiteSpace:
                lr.MatchLen = lr.Offset + 1 + lr.SizeAdj
        case CurState:
                lr.MatchLen = 0
        case AnyRune:
                lr.MatchLen = lr.Offset + 1 + lr.SizeAdj
        }
}

// LexStart is called on the top-level lex node to start lexing process for one step
func (lr *Rule) LexStart(ls *State) *Rule {
        hasGuest := ls.GuestLex != nil
        cpos := ls.Pos
        lxsz := len(ls.Lex)
        mrule := lr
        for _, klri := range lr.Children {
                klr := klri.(*Rule)
                if mrule = klr.Lex(ls); mrule != nil { // first to match takes it -- order matters!
                        break
                }
        }
        if hasGuest && ls.GuestLex != nil && lr != ls.GuestLex {
                ls.Pos = cpos // backup and undo what the standard rule did, and redo with guest..
                // this is necessary to allow main lex to detect when to turn OFF the guest!
                if lxsz > 0 {
                        ls.Lex = ls.Lex[:lxsz]
                } else {
                        ls.Lex = nil
                }
                mrule = ls.GuestLex.LexStart(ls)
        }
        if !ls.AtEol() && cpos == ls.Pos {
                ls.Error(cpos, "did not advance position -- need more rules to match current input", lr)
                return nil
        }
        return mrule
}

// Lex tries to apply rule to given input state, returns lowest-level rule that matched, nil if none
func (lr *Rule) Lex(ls *State) *Rule {
        if lr.Off || !lr.IsMatch(ls) {
                return nil
        }
        st := ls.Pos // starting pos that we're consuming
        tok := token.KeyToken{Token: lr.Token}
        for _, act := range lr.Acts {
                lr.DoAct(ls, act, &tok)
        }
        ed := ls.Pos // our ending state
        if ed > st {
                if tok.Token.IsKeyword() {
                        tok.Key = lr.String //  if we matched, this is it
                }
                ls.Add(tok, st, ed)
                if Trace {
                        fmt.Println("Lex:", lr.Desc, "Added token:", tok, "at:", st, ed)
                }
        }
        if !lr.HasChildren() {
                return lr
        }

        if lr.NameMap && lr.NmMap != nil {
                nm := ls.ReadNameTmp(lr.Offset)
                klr, ok := lr.NmMap[nm]
                if ok {
                        if mrule := klr.Lex(ls); mrule != nil { // should!
                                return mrule
                        }
                }
        } else {
                // now we iterate over our kids
                for _, klri := range lr.Children {
                        klr := klri.(*Rule)
                        if mrule := klr.Lex(ls); mrule != nil { // first to match takes it -- order matters!
                                return mrule
                        }
                }
        }

        // if kids don't match and we don't have any actions, we are just a grouper
        // and thus we depend entirely on kids matching
        if len(lr.Acts) == 0 {
                if Trace {
                        fmt.Println("Lex:", lr.Desc, "fallthrough")
                }
                return nil
        }

        return lr
}

// IsMatch tests if the rule matches for current input state, returns true if so, false if not
func (lr *Rule) IsMatch(ls *State) bool {
        if !lr.IsMatchPos(ls) {
                return false
        }

        switch lr.Match {
        case String:
                sz := len(lr.String)
                str, ok := ls.String(lr.Offset, sz)
                if !ok {
                        return false
                }
                if str != lr.String {
                        return false
                }
                return true
        case StrName:
                nm := ls.ReadNameTmp(lr.Offset)
                if nm != lr.String {
                        return false
                }
                return true
        case Letter:
                rn, ok := ls.RuneAt(lr.Offset)
                if !ok {
                        return false
                }
                if IsLetter(rn) {
                        return true
                }
                return false
        case Digit:
                rn, ok := ls.RuneAt(lr.Offset)
                if !ok {
                        return false
                }
                if IsDigit(rn) {
                        return true
                }
                return false
        case WhiteSpace:
                rn, ok := ls.RuneAt(lr.Offset)
                if !ok {
                        return false
                }
                if IsWhiteSpace(rn) {
                        return true
                }
                return false
        case CurState:
                if ls.MatchState(lr.String) {
                        return true
                }
                return false
        case AnyRune:
                _, ok := ls.RuneAt(lr.Offset)
                return ok
        }
        return false
}

// IsMatchPos tests if the rule matches position
func (lr *Rule) IsMatchPos(ls *State) bool {
        lsz := len(ls.Src)
        switch lr.Pos {
        case AnyPos:
                return true
        case StartOfLine:
                return ls.Pos == 0
        case EndOfLine:
                tsz := lr.TargetLen(ls)
                return ls.Pos == lsz-1-tsz
        case MiddleOfLine:
                if ls.Pos == 0 {
                        return false
                }
                tsz := lr.TargetLen(ls)
                return ls.Pos != lsz-1-tsz
        case StartOfWord:
                return ls.Pos == 0 || unicode.IsSpace(ls.Src[ls.Pos-1])
        case EndOfWord:
                tsz := lr.TargetLen(ls)
                ep := ls.Pos + tsz
                return ep == lsz || (ep+1 < lsz && unicode.IsSpace(ls.Src[ep+1]))
        case MiddleOfWord:
                if ls.Pos == 0 || unicode.IsSpace(ls.Src[ls.Pos-1]) {
                        return false
                }
                tsz := lr.TargetLen(ls)
                ep := ls.Pos + tsz
                if ep == lsz || (ep+1 < lsz && unicode.IsSpace(ls.Src[ep+1])) {
                        return false
                }
                return true
        }
        return true
}

// TargetLen returns the length of the target including offset
func (lr *Rule) TargetLen(ls *State) int {
        switch lr.Match {
        case StrName:
                fallthrough
        case String:
                sz := len(lr.String)
                return lr.Offset + sz
        case Letter:
                return lr.Offset + 1
        case Digit:
                return lr.Offset + 1
        case WhiteSpace:
                return lr.Offset + 1
        case AnyRune:
                return lr.Offset + 1
        case CurState:
                return 0
        }
        return 0
}

// DoAct performs given action
func (lr *Rule) DoAct(ls *State, act Actions, tok *token.KeyToken) {
        switch act {
        case Next:
                ls.Next(lr.MatchLen)
        case Name:
                ls.ReadName()
        case Number:
                tok.Token = ls.ReadNumber()
        case Quoted:
                ls.ReadQuoted()
        case QuotedRaw:
                ls.ReadQuoted() // todo: raw!
        case EOL:
                ls.Pos = len(ls.Src)
        case ReadUntil:
                ls.ReadUntil(lr.Until)
                ls.Pos += lr.SizeAdj
        case PushState:
                ls.PushState(lr.PushState)
        case PopState:
                ls.PopState()
        case SetGuestLex:
                if ls.LastName == "" {
                        ls.Error(ls.Pos, "SetGuestLex action requires prior Name action -- name is empty", lr)
                } else {
                        lx := TheLanguageLexer.LexerByName(ls.LastName)
                        if lx != nil {
                                ls.GuestLex = lx
                                ls.SaveStack = ls.Stack.Clone()
                        }
                }
        case PopGuestLex:
                if ls.SaveStack != nil {
                        ls.Stack = ls.SaveStack
                        ls.SaveStack = nil
                }
                ls.GuestLex = nil
        }
}

///////////////////////////////////////////////////////////////////////
//  Non-lexing functions

// Find looks for rules in the tree that contain given string in String or Name fields
func (lr *Rule) Find(find string) []*Rule {
        var res []*Rule
        lr.WalkDown(func(k tree.Node) bool {
                lri := k.(*Rule)
                if strings.Contains(lri.String, find) || strings.Contains(lri.Name, find) {
                        res = append(res, lri)
                }
                return true
        })
        return res
}

// WriteGrammar outputs the lexer rules as a formatted grammar in a BNF-like format
// it is called recursively
func (lr *Rule) WriteGrammar(writer io.Writer, depth int) {
        if tree.IsRoot(lr) {
                for _, k := range lr.Children {
                        lri := k.(*Rule)
                        lri.WriteGrammar(writer, depth)
                }
        } else {
                ind := indent.Tabs(depth)
                gpstr := ""
                if lr.HasChildren() {
                        gpstr = " {"
                }
                offstr := ""
                if lr.Pos != AnyPos {
                        offstr += fmt.Sprintf("@%v:", lr.Pos)
                }
                if lr.Offset > 0 {
                        offstr += fmt.Sprintf("+%d:", lr.Offset)
                }
                actstr := ""
                if len(lr.Acts) > 0 {
                        actstr = "\t do: "
                        for _, ac := range lr.Acts {
                                actstr += ac.String()
                                if ac == PushState {
                                        actstr += ": " + lr.PushState
                                } else if ac == ReadUntil {
                                        actstr += ": \"" + lr.Until + "\""
                                }
                                actstr += "; "
                        }
                }
                if lr.Desc != "" {
                        fmt.Fprintf(writer, "%v// %v %v \n", ind, lr.Name, lr.Desc)
                }
                if (lr.Match >= Letter && lr.Match <= WhiteSpace) || lr.Match == AnyRune {
                        fmt.Fprintf(writer, "%v%v:\t\t %v\t\t if %v%v%v%v\n", ind, lr.Name, lr.Token, offstr, lr.Match, actstr, gpstr)
                } else {
                        fmt.Fprintf(writer, "%v%v:\t\t %v\t\t if %v%v == \"%v\"%v%v\n", ind, lr.Name, lr.Token, offstr, lr.Match, lr.String, actstr, gpstr)
                }
                if lr.HasChildren() {
                        w := tabwriter.NewWriter(writer, 4, 4, 2, ' ', 0)
                        for _, k := range lr.Children {
                                lri := k.(*Rule)
                                lri.WriteGrammar(w, depth+1)
                        }
                        w.Flush()
                        fmt.Fprintf(writer, "%v}\n", ind)
                }
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

// Stack is the stack for states
type Stack []string

// Top returns the state at the top of the stack
func (ss *Stack) Top() string {
        sz := len(*ss)
        if sz == 0 {
                return ""
        }
        return (*ss)[sz-1]
}

// Push appends state to stack
func (ss *Stack) Push(state string) {
        *ss = append(*ss, state)
}

// Pop takes state off the stack and returns it
func (ss *Stack) Pop() string {
        sz := len(*ss)
        if sz == 0 {
                return ""
        }
        st := (*ss)[sz-1]
        *ss = (*ss)[:sz-1]
        return st
}

// Clone returns a copy of the stack
func (ss *Stack) Clone() Stack {
        sz := len(*ss)
        if sz == 0 {
                return nil
        }
        cl := make(Stack, sz)
        copy(cl, *ss)
        return cl
}

// Reset stack
func (ss *Stack) Reset() {
        *ss = nil
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package lexer

import (
        "fmt"
        "strings"
        "unicode"

        "cogentcore.org/core/base/nptime"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// LanguageLexer looks up lexer for given language; implementation in parent parse package
// so we need the interface
type LanguageLexer interface {
        // LexerByName returns the top-level [Rule] for given language (case invariant lookup)
        LexerByName(lang string) *Rule
}

// TheLanguageLexer is the instance of LangLexer interface used to lookup lexers
// for languages -- is set in parse/languages.go
var TheLanguageLexer LanguageLexer

// State is the state maintained for lexing
type State struct {

        // the current file being lex'd
        Filename string

        // if true, record whitespace tokens -- else ignore
        KeepWS bool

        // the current line of source being processed
        Src []rune

        // the lex output for this line
        Lex Line

        // the comments output for this line -- kept separately
        Comments Line

        // the current rune char position within the line
        Pos int

        // the line within overall source that we're operating on (0 indexed)
        Line int

        // the current rune read by NextRune
        Rune rune

        // state stack
        Stack Stack

        // the last name that was read
        LastName string

        // a guest lexer that can be installed for managing a different language type, e.g., quoted text in markdown files
        GuestLex *Rule

        // copy of stack at point when guest lexer was installed -- restore when popped
        SaveStack Stack

        // time stamp for lexing -- set at start of new lex process
        Time nptime.Time

        // any error messages accumulated during lexing specifically
        Errs ErrorList
}

// Init initializes the state at start of parsing
func (ls *State) Init() {
        ls.GuestLex = nil
        ls.Stack.Reset()
        ls.Line = 0
        ls.SetLine(nil)
        ls.SaveStack = nil
        ls.Errs.Reset()
}

// SetLine sets a new line for parsing and initializes the lex output and pos
func (ls *State) SetLine(src []rune) {
        ls.Src = src
        ls.Lex = nil
        ls.Comments = nil
        ls.Pos = 0
}

// LineString returns the current lex output as tagged source
func (ls *State) LineString() string {
        return fmt.Sprintf("[%v,%v]: %v", ls.Line, ls.Pos, ls.Lex.TagSrc(ls.Src))
}

// Error adds a lexing error at given position
func (ls *State) Error(pos int, msg string, rule *Rule) {
        ls.Errs.Add(textpos.Pos{ls.Line, pos}, ls.Filename, "Lexer: "+msg, string(ls.Src), rule)
}

// AtEol returns true if current position is at end of line
func (ls *State) AtEol() bool {
        sz := len(ls.Src)
        return ls.Pos >= sz
}

// String gets the string at given offset and length from current position, returns false if out of range
func (ls *State) String(off, sz int) (string, bool) {
        idx := ls.Pos + off
        ei := idx + sz
        if ei > len(ls.Src) {
                return "", false
        }
        return string(ls.Src[idx:ei]), true
}

// Rune gets the rune at given offset from current position, returns false if out of range
func (ls *State) RuneAt(off int) (rune, bool) {
        idx := ls.Pos + off
        if idx >= len(ls.Src) {
                return 0, false
        }
        return ls.Src[idx], true
}

// Next moves to next position using given increment in source line -- returns false if at end
func (ls *State) Next(inc int) bool {
        sz := len(ls.Src)
        ls.Pos += inc
        if ls.Pos >= sz {
                ls.Pos = sz
                return false
        }
        return true
}

// NextRune reads the next rune into Ch and returns false if at end of line
func (ls *State) NextRune() bool {
        sz := len(ls.Src)
        ls.Pos++
        if ls.Pos >= sz {
                ls.Pos = sz
                return false
        }
        ls.Rune = ls.Src[ls.Pos]
        return true
}

// CurRune reads the current rune into Ch and returns false if at end of line
func (ls *State) CurRuneAt() bool {
        sz := len(ls.Src)
        if ls.Pos >= sz {
                ls.Pos = sz
                return false
        }
        ls.Rune = ls.Src[ls.Pos]
        return true
}

// Add adds a lex token for given region -- merges with prior if same
func (ls *State) Add(tok token.KeyToken, st, ed int) {
        if tok.Token == token.TextWhitespace && !ls.KeepWS {
                return
        }
        lxl := &ls.Lex
        if tok.Token.Cat() == token.Comment {
                lxl = &ls.Comments
        }
        sz := len(*lxl)
        if sz > 0 && tok.Token.CombineRepeats() {
                lst := &(*lxl)[sz-1]
                if lst.Token.Token == tok.Token && lst.End == st {
                        lst.End = ed
                        return
                }
        }
        lx := (*lxl).AddLex(tok, st, ed)
        lx.Time = ls.Time
}

// PushState pushes state onto stack
func (ls *State) PushState(st string) {
        ls.Stack.Push(st)
}

// CurState returns the current state
func (ls *State) CurState() string {
        return ls.Stack.Top()
}

// PopState pops state off of stack
func (ls *State) PopState() string {
        return ls.Stack.Pop()
}

// MatchState returns true if the current state matches the string
func (ls *State) MatchState(st string) bool {
        sz := len(ls.Stack)
        if sz == 0 {
                return false
        }
        return ls.Stack[sz-1] == st
}

// ReadNameTmp reads a standard alpha-numeric_ name and returns it.
// Does not update the lexing position -- a "lookahead" name read
func (ls *State) ReadNameTmp(off int) string {
        cp := ls.Pos
        ls.Pos += off
        ls.ReadName()
        ls.Pos = cp
        return ls.LastName
}

// ReadName reads a standard alpha-numeric_ name -- saves in LastName
func (ls *State) ReadName() {
        str := ""
        sz := len(ls.Src)
        for ls.Pos < sz {
                rn := ls.Src[ls.Pos]
                if IsLetterOrDigit(rn) {
                        str += string(rn)
                        ls.Pos++
                } else {
                        break
                }
        }
        ls.LastName = str
}

// NextSrcLine returns the next line of text
func (ls *State) NextSrcLine() string {
        if ls.AtEol() {
                return "EOL"
        }
        return string(ls.Src[ls.Pos:])
}

// ReadUntil reads until given string(s) -- does do depth tracking if looking for a bracket
// open / close kind of symbol.
// For multiple "until" string options, separate each by |
// and use empty to match a single | or || in combination with other options.
// Terminates at end of line without error
func (ls *State) ReadUntil(until string) {
        ustrs := strings.Split(until, "|")
        if len(ustrs) == 0 || (len(ustrs) == 1 && len(ustrs[0]) == 0) {
                ustrs = []string{"|"}
        }
        sz := len(ls.Src)
        got := false
        depth := 0
        match := rune(0)
        if len(ustrs) == 1 && len(ustrs[0]) == 1 {
                switch ustrs[0][0] {
                case '}':
                        match = '{'
                case ')':
                        match = '('
                case ']':
                        match = '['
                }
        }
        for ls.NextRune() {
                if match != 0 {
                        if ls.Rune == match {
                                depth++
                                continue
                        } else if ls.Rune == rune(ustrs[0][0]) {
                                if depth > 0 {
                                        depth--
                                        continue
                                }
                        }
                        if depth > 0 {
                                continue
                        }
                }
                for _, un := range ustrs {
                        usz := len(un)
                        if usz == 0 { // ||
                                if ls.Rune == '|' {
                                        ls.NextRune() // move past
                                        break
                                }
                        } else {
                                ep := ls.Pos + usz
                                if ep < sz && ls.Pos < ep {
                                        sm := string(ls.Src[ls.Pos:ep])
                                        if sm == un {
                                                ls.Pos += usz
                                                got = true
                                                break
                                        }
                                }
                        }
                }
                if got {
                        break
                }
        }
}

// ReadNumber reads a number of any sort, returning the type of the number
func (ls *State) ReadNumber() token.Tokens {
        offs := ls.Pos
        tok := token.LitNumInteger
        ls.CurRuneAt()
        if ls.Rune == '0' {
                // int or float
                offs := ls.Pos
                ls.NextRune()
                if ls.Rune == 'x' || ls.Rune == 'X' {
                        // hexadecimal int
                        ls.NextRune()
                        ls.ScanMantissa(16)
                        if ls.Pos-offs <= 2 {
                                // only scanned "0x" or "0X"
                                ls.Error(offs, "illegal hexadecimal number", nil)
                        }
                } else {
                        // octal int or float
                        seenDecimalDigit := false
                        ls.ScanMantissa(8)
                        if ls.Rune == '8' || ls.Rune == '9' {
                                // illegal octal int or float
                                seenDecimalDigit = true
                                ls.ScanMantissa(10)
                        }
                        if ls.Rune == '.' || ls.Rune == 'e' || ls.Rune == 'E' || ls.Rune == 'i' {
                                goto fraction
                        }
                        // octal int
                        if seenDecimalDigit {
                                ls.Error(offs, "illegal octal number", nil)
                        }
                }
                goto exit
        }

        // decimal int or float
        ls.ScanMantissa(10)

fraction:
        if ls.Rune == '.' {
                tok = token.LitNumFloat
                ls.NextRune()
                ls.ScanMantissa(10)
        }

        if ls.Rune == 'e' || ls.Rune == 'E' {
                tok = token.LitNumFloat
                ls.NextRune()
                if ls.Rune == '-' || ls.Rune == '+' {
                        ls.NextRune()
                }
                if DigitValue(ls.Rune) < 10 {
                        ls.ScanMantissa(10)
                } else {
                        ls.Error(offs, "illegal floating-point exponent", nil)
                }
        }

        if ls.Rune == 'i' {
                tok = token.LitNumImag
                ls.NextRune()
        }

exit:
        return tok
}

func DigitValue(ch rune) int {
        switch {
        case '0' <= ch && ch <= '9':
                return int(ch - '0')
        case 'a' <= ch && ch <= 'f':
                return int(ch - 'a' + 10)
        case 'A' <= ch && ch <= 'F':
                return int(ch - 'A' + 10)
        }
        return 16 // larger than any legal digit val
}

func (ls *State) ScanMantissa(base int) {
        for DigitValue(ls.Rune) < base {
                if !ls.NextRune() {
                        break
                }
        }
}

func (ls *State) ReadQuoted() {
        delim, _ := ls.RuneAt(0)
        offs := ls.Pos
        ls.NextRune()
        for {
                ch := ls.Rune
                if ch == delim {
                        ls.NextRune() // move past
                        break
                }
                if ch == '\\' {
                        ls.ReadEscape(delim)
                }
                if !ls.NextRune() {
                        ls.Error(offs, "string literal not terminated", nil)
                        break
                }
        }
}

// ReadEscape parses an escape sequence where rune is the accepted
// escaped quote. In case of a syntax error, it stops at the offending
// character (without consuming it) and returns false. Otherwise
// it returns true.
func (ls *State) ReadEscape(quote rune) bool {
        offs := ls.Pos

        var n int
        var base, max uint32
        switch ls.Rune {
        case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', quote:
                ls.NextRune()
                return true
        case '0', '1', '2', '3', '4', '5', '6', '7':
                n, base, max = 3, 8, 255
        case 'x':
                ls.NextRune()
                n, base, max = 2, 16, 255
        case 'u':
                ls.NextRune()
                n, base, max = 4, 16, unicode.MaxRune
        case 'U':
                ls.NextRune()
                n, base, max = 8, 16, unicode.MaxRune
        default:
                msg := "unknown escape sequence"
                if ls.Rune < 0 {
                        msg = "escape sequence not terminated"
                }
                ls.Error(offs, msg, nil)
                return false
        }

        var x uint32
        for n > 0 {
                d := uint32(DigitValue(ls.Rune))
                if d >= base {
                        msg := fmt.Sprintf("illegal character %#U in escape sequence", ls.Rune)
                        if ls.Rune < 0 {
                                msg = "escape sequence not terminated"
                        }
                        ls.Error(ls.Pos, msg, nil)
                        return false
                }
                x = x*base + d
                ls.NextRune()
                n--
        }

        if x > max || 0xD800 <= x && x < 0xE000 {
                ls.Error(ls.Pos, "escape sequence is invalid Unicode code point", nil)
                return false
        }

        return true
}

// Code generated by "core generate"; DO NOT EDIT.

package lexer

import (
        "cogentcore.org/core/text/token"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/parse/lexer.Rule", IDName: "rule", Doc: "Rule operates on the text input to produce the lexical tokens.\n\nLexing is done line-by-line -- you must push and pop states to\ncoordinate across multiple lines, e.g., for multi-line comments.\n\nThere is full access to entire line and you can decide based on future\n(offset) characters.\n\nIn general it is best to keep lexing as simple as possible and\nleave the more complex things for the parsing step.", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Off", Doc: "disable this rule -- useful for testing and exploration"}, {Name: "Desc", Doc: "description / comments about this rule"}, {Name: "Token", Doc: "the token value that this rule generates -- use None for non-terminals"}, {Name: "Match", Doc: "the lexical match that we look for to engage this rule"}, {Name: "Pos", Doc: "position where match can occur"}, {Name: "String", Doc: "if action is LexMatch, this is the string we match"}, {Name: "Offset", Doc: "offset into the input to look for a match: 0 = current char, 1 = next one, etc"}, {Name: "SizeAdj", Doc: "adjusts the size of the region (plus or minus) that is processed for the Next action -- allows broader and narrower matching relative to tagging"}, {Name: "Acts", Doc: "the action(s) to perform, in order, if there is a match -- these are performed prior to iterating over child nodes"}, {Name: "Until", Doc: "string(s) for ReadUntil action -- will read until any of these strings are found -- separate different options with | -- if you need to read until a literal | just put two || in a row and that will show up as a blank, which is interpreted as a literal |"}, {Name: "PushState", Doc: "the state to push if our action is PushState -- note that State matching is on String, not this value"}, {Name: "NameMap", Doc: "create an optimization map for this rule, which must be a parent with children that all match against a Name string -- this reads the Name and directly activates the associated rule with that String, without having to iterate through them -- use this for keywords etc -- produces a SIGNIFICANT speedup for long lists of keywords."}, {Name: "MatchLen", Doc: "length of source that matched -- if Next is called, this is what will be skipped to"}, {Name: "NmMap", Doc: "NameMap lookup map -- created during Compile"}}})

// NewRule returns a new [Rule] with the given optional parent:
// Rule operates on the text input to produce the lexical tokens.
//
// Lexing is done line-by-line -- you must push and pop states to
// coordinate across multiple lines, e.g., for multi-line comments.
//
// There is full access to entire line and you can decide based on future
// (offset) characters.
//
// In general it is best to keep lexing as simple as possible and
// leave the more complex things for the parsing step.
func NewRule(parent ...tree.Node) *Rule { return tree.New[Rule](parent...) }

// SetOff sets the [Rule.Off]:
// disable this rule -- useful for testing and exploration
func (t *Rule) SetOff(v bool) *Rule { t.Off = v; return t }

// SetDesc sets the [Rule.Desc]:
// description / comments about this rule
func (t *Rule) SetDesc(v string) *Rule { t.Desc = v; return t }

// SetToken sets the [Rule.Token]:
// the token value that this rule generates -- use None for non-terminals
func (t *Rule) SetToken(v token.Tokens) *Rule { t.Token = v; return t }

// SetMatch sets the [Rule.Match]:
// the lexical match that we look for to engage this rule
func (t *Rule) SetMatch(v Matches) *Rule { t.Match = v; return t }

// SetPos sets the [Rule.Pos]:
// position where match can occur
func (t *Rule) SetPos(v MatchPos) *Rule { t.Pos = v; return t }

// SetString sets the [Rule.String]:
// if action is LexMatch, this is the string we match
func (t *Rule) SetString(v string) *Rule { t.String = v; return t }

// SetOffset sets the [Rule.Offset]:
// offset into the input to look for a match: 0 = current char, 1 = next one, etc
func (t *Rule) SetOffset(v int) *Rule { t.Offset = v; return t }

// SetSizeAdj sets the [Rule.SizeAdj]:
// adjusts the size of the region (plus or minus) that is processed for the Next action -- allows broader and narrower matching relative to tagging
func (t *Rule) SetSizeAdj(v int) *Rule { t.SizeAdj = v; return t }

// SetActs sets the [Rule.Acts]:
// the action(s) to perform, in order, if there is a match -- these are performed prior to iterating over child nodes
func (t *Rule) SetActs(v ...Actions) *Rule { t.Acts = v; return t }

// SetUntil sets the [Rule.Until]:
// string(s) for ReadUntil action -- will read until any of these strings are found -- separate different options with | -- if you need to read until a literal | just put two || in a row and that will show up as a blank, which is interpreted as a literal |
func (t *Rule) SetUntil(v string) *Rule { t.Until = v; return t }

// SetPushState sets the [Rule.PushState]:
// the state to push if our action is PushState -- note that State matching is on String, not this value
func (t *Rule) SetPushState(v string) *Rule { t.PushState = v; return t }

// SetNameMap sets the [Rule.NameMap]:
// create an optimization map for this rule, which must be a parent with children that all match against a Name string -- this reads the Name and directly activates the associated rule with that String, without having to iterate through them -- use this for keywords etc -- produces a SIGNIFICANT speedup for long lists of keywords.
func (t *Rule) SetNameMap(v bool) *Rule { t.NameMap = v; return t }

// SetMatchLen sets the [Rule.MatchLen]:
// length of source that matched -- if Next is called, this is what will be skipped to
func (t *Rule) SetMatchLen(v int) *Rule { t.MatchLen = v; return t }

// SetNmMap sets the [Rule.NmMap]:
// NameMap lookup map -- created during Compile
func (t *Rule) SetNmMap(v map[string]*Rule) *Rule { t.NmMap = v; return t }

// Code generated by "core generate"; DO NOT EDIT.

package lsp

import (
        "cogentcore.org/core/enums"
)

var _CompletionKindValues = []CompletionKind{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25}

// CompletionKindN is the highest valid value for type CompletionKind, plus one.
const CompletionKindN CompletionKind = 26

var _CompletionKindValueMap = map[string]CompletionKind{`None`: 0, `Text`: 1, `Method`: 2, `Function`: 3, `Constructor`: 4, `Field`: 5, `Variable`: 6, `Class`: 7, `Interface`: 8, `Module`: 9, `Property`: 10, `Unit`: 11, `Value`: 12, `Enum`: 13, `Keyword`: 14, `Snippet`: 15, `Color`: 16, `File`: 17, `Reference`: 18, `Folder`: 19, `EnumMember`: 20, `Constant`: 21, `Struct`: 22, `Event`: 23, `Operator`: 24, `TypeParameter`: 25}

var _CompletionKindDescMap = map[CompletionKind]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``, 5: ``, 6: ``, 7: ``, 8: ``, 9: ``, 10: ``, 11: ``, 12: ``, 13: ``, 14: ``, 15: ``, 16: ``, 17: ``, 18: ``, 19: ``, 20: ``, 21: ``, 22: ``, 23: ``, 24: ``, 25: ``}

var _CompletionKindMap = map[CompletionKind]string{0: `None`, 1: `Text`, 2: `Method`, 3: `Function`, 4: `Constructor`, 5: `Field`, 6: `Variable`, 7: `Class`, 8: `Interface`, 9: `Module`, 10: `Property`, 11: `Unit`, 12: `Value`, 13: `Enum`, 14: `Keyword`, 15: `Snippet`, 16: `Color`, 17: `File`, 18: `Reference`, 19: `Folder`, 20: `EnumMember`, 21: `Constant`, 22: `Struct`, 23: `Event`, 24: `Operator`, 25: `TypeParameter`}

// String returns the string representation of this CompletionKind value.
func (i CompletionKind) String() string { return enums.String(i, _CompletionKindMap) }

// SetString sets the CompletionKind value from its string representation,
// and returns an error if the string is invalid.
func (i *CompletionKind) SetString(s string) error {
        return enums.SetString(i, s, _CompletionKindValueMap, "CompletionKind")
}

// Int64 returns the CompletionKind value as an int64.
func (i CompletionKind) Int64() int64 { return int64(i) }

// SetInt64 sets the CompletionKind value from an int64.
func (i *CompletionKind) SetInt64(in int64) { *i = CompletionKind(in) }

// Desc returns the description of the CompletionKind value.
func (i CompletionKind) Desc() string { return enums.Desc(i, _CompletionKindDescMap) }

// CompletionKindValues returns all possible values for the type CompletionKind.
func CompletionKindValues() []CompletionKind { return _CompletionKindValues }

// Values returns all possible values for the type CompletionKind.
func (i CompletionKind) Values() []enums.Enum { return enums.Values(_CompletionKindValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i CompletionKind) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *CompletionKind) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "CompletionKind")
}

var _SymbolKindValues = []SymbolKind{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26}

// SymbolKindN is the highest valid value for type SymbolKind, plus one.
const SymbolKindN SymbolKind = 27

var _SymbolKindValueMap = map[string]SymbolKind{`NoSymbolKind`: 0, `File`: 1, `Module`: 2, `Namespace`: 3, `Package`: 4, `Class`: 5, `Method`: 6, `Property`: 7, `Field`: 8, `Constructor`: 9, `Enum`: 10, `Interface`: 11, `Function`: 12, `Variable`: 13, `Constant`: 14, `String`: 15, `Number`: 16, `Boolean`: 17, `Array`: 18, `Object`: 19, `Key`: 20, `Null`: 21, `EnumMember`: 22, `Struct`: 23, `Event`: 24, `Operator`: 25, `TypeParameter`: 26}

var _SymbolKindDescMap = map[SymbolKind]string{0: ``, 1: ``, 2: ``, 3: ``, 4: ``, 5: ``, 6: ``, 7: ``, 8: ``, 9: ``, 10: ``, 11: ``, 12: ``, 13: ``, 14: ``, 15: ``, 16: ``, 17: ``, 18: ``, 19: ``, 20: ``, 21: ``, 22: ``, 23: ``, 24: ``, 25: ``, 26: ``}

var _SymbolKindMap = map[SymbolKind]string{0: `NoSymbolKind`, 1: `File`, 2: `Module`, 3: `Namespace`, 4: `Package`, 5: `Class`, 6: `Method`, 7: `Property`, 8: `Field`, 9: `Constructor`, 10: `Enum`, 11: `Interface`, 12: `Function`, 13: `Variable`, 14: `Constant`, 15: `String`, 16: `Number`, 17: `Boolean`, 18: `Array`, 19: `Object`, 20: `Key`, 21: `Null`, 22: `EnumMember`, 23: `Struct`, 24: `Event`, 25: `Operator`, 26: `TypeParameter`}

// String returns the string representation of this SymbolKind value.
func (i SymbolKind) String() string { return enums.String(i, _SymbolKindMap) }

// SetString sets the SymbolKind value from its string representation,
// and returns an error if the string is invalid.
func (i *SymbolKind) SetString(s string) error {
        return enums.SetString(i, s, _SymbolKindValueMap, "SymbolKind")
}

// Int64 returns the SymbolKind value as an int64.
func (i SymbolKind) Int64() int64 { return int64(i) }

// SetInt64 sets the SymbolKind value from an int64.
func (i *SymbolKind) SetInt64(in int64) { *i = SymbolKind(in) }

// Desc returns the description of the SymbolKind value.
func (i SymbolKind) Desc() string { return enums.Desc(i, _SymbolKindDescMap) }

// SymbolKindValues returns all possible values for the type SymbolKind.
func SymbolKindValues() []SymbolKind { return _SymbolKindValues }

// Values returns all possible values for the type SymbolKind.
func (i SymbolKind) Values() []enums.Enum { return enums.Values(_SymbolKindValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i SymbolKind) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *SymbolKind) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "SymbolKind")
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package lsp contains types for the Language Server Protocol
// LSP: https://microsoft.github.io/language-server-protocol/specification
// and mappings from these elements into the token.Tokens types
// which are used internally in parse.
package lsp

//go:generate core generate

import (
        "cogentcore.org/core/text/token"
)

// SymbolKind is the Language Server Protocol (LSP) SymbolKind, which
// we map onto the token.Tokens that are used internally.
type SymbolKind int32 //enums:enum

// SymbolKind is the list of SymbolKind items from LSP
const (
        NoSymbolKind SymbolKind = iota
        File                    // 1 in LSP
        Module
        Namespace
        Package
        Class
        Method
        Property
        Field
        Constructor
        Enum
        Interface
        Function
        Variable
        Constant
        String
        Number
        Boolean
        Array
        Object
        Key
        Null
        EnumMember
        Struct
        Event
        Operator
        TypeParameter // 26 in LSP
)

// SymbolKindTokenMap maps between symbols and token.Tokens
var SymbolKindTokenMap = map[SymbolKind]token.Tokens{
        Module:        token.NameModule,
        Namespace:     token.NameNamespace,
        Package:       token.NamePackage,
        Class:         token.NameClass,
        Method:        token.NameMethod,
        Property:      token.NameProperty,
        Field:         token.NameField,
        Constructor:   token.NameConstructor,
        Enum:          token.NameEnum,
        Interface:     token.NameInterface,
        Function:      token.NameFunction,
        Variable:      token.NameVar,
        Constant:      token.NameConstant,
        String:        token.LitStr,
        Number:        token.LitNum,
        Boolean:       token.LiteralBool,
        Array:         token.NameArray,
        Object:        token.NameObject,
        Key:           token.NameTag,
        Null:          token.None,
        EnumMember:    token.NameEnumMember,
        Struct:        token.NameStruct,
        Event:         token.NameEvent,
        Operator:      token.Operator,
        TypeParameter: token.NameTypeParam,
}

// TokenSymbolKindMap maps from tokens to LSP SymbolKind
var TokenSymbolKindMap map[token.Tokens]SymbolKind

func init() {
        for s, t := range SymbolKindTokenMap {
                TokenSymbolKindMap[t] = s
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package parse

//go:generate core generate -add-types

import (
        "encoding/json"
        "fmt"
        "os"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/iox/jsonx"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/parse/parser"
        "cogentcore.org/core/text/textpos"
)

// Parser is the overall parser for managing the parsing
type Parser struct {

        // lexer rules for first pass of lexing file
        Lexer *lexer.Rule

        // second pass after lexing -- computes nesting depth and EOS finding
        PassTwo lexer.PassTwo

        // parser rules for parsing lexed tokens
        Parser *parser.Rule

        // file name for overall parser (not file being parsed!)
        Filename string

        // if true, reports errors after parsing, to stdout
        ReportErrs bool

        // when loaded from file, this is the modification time of the parser -- re-processes cache if parser is newer than cached files
        ModTime time.Time `json:"-" xml:"-"`
}

// Init initializes the parser -- must be called after creation
func (pr *Parser) Init() {
        pr.Lexer = lexer.NewRule()
        pr.Parser = parser.NewRule()
}

// NewParser returns a new initialized parser
func NewParser() *Parser {
        pr := &Parser{}
        pr.Init()
        return pr
}

// InitAll initializes everything about the parser -- call this when setting up a new
// parser after it has been loaded etc
func (pr *Parser) InitAll() {
        fs := &FileState{} // dummy, for error recording
        fs.Init()
        pr.Lexer.CompileAll(&fs.LexState)
        pr.Lexer.Validate(&fs.LexState)
        pr.Parser.CompileAll(&fs.ParseState)
        pr.Parser.Validate(&fs.ParseState)
}

// LexInit gets the lexer ready to start lexing
func (pr *Parser) LexInit(fs *FileState) {
        fs.LexState.Init()
        fs.LexState.Time.Now()
        fs.TwoState.Init()
        if fs.Src.NLines() > 0 {
                fs.LexState.SetLine(fs.Src.Lines[0])
        }
}

// LexNext does next step of lexing -- returns lowest-level rule that
// matched, and nil when nomatch err or at end of source input
func (pr *Parser) LexNext(fs *FileState) *lexer.Rule {
        if fs.LexState.Line >= fs.Src.NLines() {
                return nil
        }
        for {
                if fs.LexState.AtEol() {
                        fs.Src.SetLine(fs.LexState.Line, fs.LexState.Lex, fs.LexState.Comments, fs.LexState.Stack)
                        fs.LexState.Line++
                        if fs.LexState.Line >= fs.Src.NLines() {
                                return nil
                        }
                        fs.LexState.SetLine(fs.Src.Lines[fs.LexState.Line])
                }
                mrule := pr.Lexer.LexStart(&fs.LexState)
                if mrule != nil {
                        return mrule
                }
                if !fs.LexState.AtEol() { // err
                        break
                }
        }
        return nil
}

// LexNextLine does next line of lexing -- returns lowest-level rule that
// matched at end, and nil when nomatch err or at end of source input
func (pr *Parser) LexNextLine(fs *FileState) *lexer.Rule {
        if fs.LexState.Line >= fs.Src.NLines() {
                return nil
        }
        var mrule *lexer.Rule
        for {
                if fs.LexState.AtEol() {
                        fs.Src.SetLine(fs.LexState.Line, fs.LexState.Lex, fs.LexState.Comments, fs.LexState.Stack)
                        fs.LexState.Line++
                        if fs.LexState.Line >= fs.Src.NLines() {
                                return nil
                        }
                        fs.LexState.SetLine(fs.Src.Lines[fs.LexState.Line])
                        return mrule
                }
                mrule = pr.Lexer.LexStart(&fs.LexState)
                if mrule == nil {
                        return nil
                }
        }
}

// LexRun keeps running LextNext until it stops
func (pr *Parser) LexRun(fs *FileState) {
        for {
                if pr.LexNext(fs) == nil {
                        break
                }
        }
}

// LexLine runs lexer for given single line of source, which is updated
// from the given text (if non-nil)
// Returns merged regular and token comment lines, cloned and ready for use.
func (pr *Parser) LexLine(fs *FileState, ln int, txt []rune) lexer.Line {
        nlines := fs.Src.NLines()
        if ln >= nlines || ln < 0 {
                return nil
        }
        fs.Src.SetLineSrc(ln, txt)
        fs.LexState.SetLine(fs.Src.Lines[ln])
        pst := fs.Src.PrevStack(ln)
        fs.LexState.Stack = pst.Clone()
        for !fs.LexState.AtEol() {
                mrule := pr.Lexer.LexStart(&fs.LexState)
                if mrule == nil {
                        break
                }
        }
        initDepth := fs.Src.PrevDepth(ln)
        pr.PassTwo.NestDepthLine(fs.LexState.Lex, initDepth)                         // important to set this one's depth
        fs.Src.SetLine(ln, fs.LexState.Lex, fs.LexState.Comments, fs.LexState.Stack) // before saving here
        fs.TwoState.SetSrc(&fs.Src)
        fs.Src.EosPos[ln] = nil // reset eos
        pr.PassTwo.EosDetectPos(&fs.TwoState, textpos.Pos{Line: ln}, 1)
        merge := lexer.MergeLines(fs.LexState.Lex, fs.LexState.Comments)
        mc := merge.Clone()
        if len(fs.LexState.Comments) > 0 {
                pr.PassTwo.NestDepthLine(mc, initDepth)
        }
        return mc
}

// DoPassTwo does the second pass after lexing
func (pr *Parser) DoPassTwo(fs *FileState) {
        fs.TwoState.SetSrc(&fs.Src)
        pr.PassTwo.NestDepth(&fs.TwoState)
        if pr.PassTwo.DoEos {
                pr.PassTwo.EosDetect(&fs.TwoState)
        }
}

// LexAll runs a complete pass of the lexer and pass two, on current state
func (pr *Parser) LexAll(fs *FileState) {
        pr.LexInit(fs)
        // lprf := profile.Start("LexRun") // quite fast now..
        pr.LexRun(fs)
        // fs.LexErrReport()
        // lprf.End()
        pr.DoPassTwo(fs) // takes virtually no time
}

// ParserInit initializes the parser prior to running
func (pr *Parser) ParserInit(fs *FileState) bool {
        fs.AnonCtr = 0
        fs.ParseState.Init(&fs.Src, fs.AST)
        return true
}

// ParseNext does next step of parsing -- returns lowest-level rule that matched
// or nil if no match error or at end
func (pr *Parser) ParseNext(fs *FileState) *parser.Rule {
        mrule := pr.Parser.StartParse(&fs.ParseState)
        return mrule
}

// ParseRun continues running the parser until the end of the file
func (pr *Parser) ParseRun(fs *FileState) {
        for {
                pr.Parser.StartParse(&fs.ParseState)
                if fs.ParseState.AtEofNext() {
                        break
                }
        }
}

// ParseAll does full parsing, including ParseInit and ParseRun, assuming LexAll
// has been done already
func (pr *Parser) ParseAll(fs *FileState) {
        if !pr.ParserInit(fs) {
                return
        }
        pr.ParseRun(fs)
        if pr.ReportErrs {
                if fs.ParseHasErrs() {
                        fmt.Println(fs.ParseErrReport())
                }
        }
}

// ParseLine runs parser for given single line of source
// does Parsing in a separate FileState and returns that with
// AST etc (or nil if nothing).  Assumes LexLine has already
// been run on given line.
func (pr *Parser) ParseLine(fs *FileState, ln int) *FileState {
        nlines := fs.Src.NLines()
        if ln >= nlines || ln < 0 {
                return nil
        }
        lfs := NewFileState()
        lfs.Src.InitFromLine(&fs.Src, ln)
        lfs.Src.EnsureFinalEos(0)
        lfs.ParseState.Init(&lfs.Src, lfs.AST)
        pr.ParseRun(lfs)
        return lfs
}

// ParseString runs lexer and parser on given string of text, returning
// FileState of results (can be nil if string is empty or no lexical tokens).
// Also takes supporting contextual info for file / language that this string
// is associated with (only for reference)
func (pr *Parser) ParseString(str string, fname string, sup fileinfo.Known) *FileState {
        if str == "" {
                return nil
        }
        lfs := NewFileState()
        lfs.Src.InitFromString(str, fname, sup)
        // lfs.ParseState.Trace.FullOn()
        // lfs.ParseSTate.Trace.StdOut()
        lfs.ParseState.Init(&lfs.Src, lfs.AST)
        pr.LexAll(lfs)
        lxs := lfs.Src.Lexs[0]
        if len(lxs) == 0 {
                return nil
        }
        lfs.Src.EnsureFinalEos(0)
        pr.ParseAll(lfs)
        return lfs
}

// ReadJSON opens lexer and parser rules from Bytes, in a standard JSON-formatted file
func (pr *Parser) ReadJSON(b []byte) error {
        err := json.Unmarshal(b, pr)
        return errors.Log(err)
}

// OpenJSON opens lexer and parser rules from the given filename, in a standard JSON-formatted file
func (pr *Parser) OpenJSON(filename string) error {
        err := jsonx.Open(pr, filename)
        return errors.Log(err)
}

// SaveJSON saves lexer and parser rules, in a standard JSON-formatted file
func (pr *Parser) SaveJSON(filename string) error {
        err := jsonx.Save(pr, filename)
        return errors.Log(err)
}

// SaveGrammar saves lexer and parser grammar rules to BNF-like .parsegrammar file
func (pr *Parser) SaveGrammar(filename string) error {
        ofl, err := os.Create(filename)
        if err != nil {
                return errors.Log(err)
        }
        fmt.Fprintf(ofl, "// %v Lexer\n\n", filename)
        pr.Lexer.WriteGrammar(ofl, 0)
        fmt.Fprintf(ofl, "\n\n///////////////////////////////////////////////////\n// %v Parser\n\n", filename)
        pr.Parser.WriteGrammar(ofl, 0)
        return ofl.Close()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package parser

import (
        "fmt"

        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/token"
)

// Actions are parsing actions to perform
type Actions int32 //enums:enum

// The parsing acts
const (
        // ChangeToken changes the token to the Tok specified in the Act action
        ChangeToken Actions = iota

        // AddSymbol means add name as a symbol, using current scoping and token type
        // or the token specified in the Act action if != None
        AddSymbol

        // PushScope means look for an existing symbol of given name
        // to push onto current scope -- adding a new one if not found --
        // does not add new item to overall symbol list.  This is useful
        // for e.g., definitions of methods on a type, where this is not
        // the definition of the type itself.
        PushScope

        // PushNewScope means add a new symbol to the list and also push
        // onto scope stack, using given token type or the token specified
        // in the Act action if != None
        PushNewScope

        // PopScope means remove the most recently added scope item
        PopScope

        // PopScopeReg means remove the most recently added scope item, and also
        // updates the source region for that item based on final SrcReg from
        // corresponding AST node -- for "definitional" scope
        PopScopeReg

        // AddDetail adds src at given path as detail info for the last-added symbol
        // if there is already something there, a space is added for this new addition
        AddDetail

        // AddType Adds a type with the given name -- sets the AST node for this rule
        // and actual type is resolved later in a second language-specific pass
        AddType

        // PushStack adds name to stack -- provides context-sensitivity option for
        // optimizing and ambiguity resolution
        PushStack

        // PopStack pops the stack
        PopStack
)

// Act is one action to perform, operating on the AST output
type Act struct {

        // at what point during sequence of sub-rules / tokens should this action be run?  -1 = at end, 0 = before first rule, 1 = before second rule, etc -- must be at point when relevant AST nodes have been added, but for scope setting, must be early enough so that scope is present
        RunIndex int

        // what action to perform
        Act Actions

        // AST path, relative to current node: empty = current node; specifies a child node by index, and a name specifies it by name -- include name/name for sub-nodes etc -- multiple path options can be specified by | or & and will be tried in order until one succeeds (for |) or all that succeed will be used for &. ... means use all nodes with given name (only for change token) -- for PushStack, this is what to push on the stack
        Path string `width:"50"`

        // for ChangeToken, the new token type to assign to token at given path
        Token token.Tokens

        // for ChangeToken, only change if token is this to start with (only if != None))
        FromToken token.Tokens
}

// String satisfies fmt.Stringer interface
func (ac Act) String() string {
        if ac.FromToken != token.None {
                return fmt.Sprintf(`%v:%v:"%v":%v<-%v`, ac.RunIndex, ac.Act, ac.Path, ac.Token, ac.FromToken)
        }
        return fmt.Sprintf(`%v:%v:"%v":%v`, ac.RunIndex, ac.Act, ac.Path, ac.Token)
}

// ChangeToken changes the token type, using FromToken logic
func (ac *Act) ChangeToken(lx *lexer.Lex) {
        if ac.FromToken == token.None {
                lx.Token.Token = ac.Token
                return
        }
        if lx.Token.Token != ac.FromToken {
                return
        }
        lx.Token.Token = ac.Token
}

// Acts are multiple actions
type Acts []Act

// String satisfies fmt.Stringer interface
func (ac Acts) String() string {
        if len(ac) == 0 {
                return ""
        }
        str := "{ "
        for i := range ac {
                str += ac[i].String() + "; "
        }
        str += "}"
        return str
}

// ASTActs are actions to perform on the [AST] nodes
type ASTActs int32 //enums:enum

// The [AST] actions
const (
        // NoAST means don't create an AST node for this rule
        NoAST ASTActs = iota

        // AddAST means create an AST node for this rule, adding it to the current anchor AST.
        // Any sub-rules within this rule are *not* added as children of this node -- see
        // SubAST and AnchorAST.  This is good for token-only terminal nodes and list elements
        // that should be added to a list.
        AddAST

        // SubAST means create an AST node and add all the elements of *this rule* as
        // children of this new node (including sub-rules), *except* for the very last rule
        // which is assumed to be a recursive rule -- that one goes back up to the parent node.
        // This is good for adding more complex elements with sub-rules to a recursive list,
        // without creating a new hierarchical depth level for every such element.
        SubAST

        // AnchorAST means create an AST node and set it as the anchor that subsequent
        // sub-nodes are added into.  This is for a new hierarchical depth level
        // where everything under this rule gets organized.
        AnchorAST

        // AnchorFirstAST means create an AST node and set it as the anchor that subsequent
        // sub-nodes are added into, *only* if this is the first time that this rule has
        // matched within the current sequence (i.e., if the parent of this rule is the same
        // rule then don't add a new AST node).  This is good for starting a new list
        // of recursively defined elements, without creating increasing depth levels.
        AnchorFirstAST
)

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package parse does the parsing stage after lexing
package parser

//go:generate core generate

import (
        "fmt"
        "io"

        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/tree"
)

// AST is a node in the abstract syntax tree generated by the parsing step
// the name of the node (from tree.NodeBase) is the type of the element
// (e.g., expr, stmt, etc)
// These nodes are generated by the parser.Rule's by matching tokens
type AST struct {
        tree.NodeBase

        // region in source lexical tokens corresponding to this AST node -- Ch = index in lex lines
        TokReg textpos.Region `set:"-"`

        // region in source file corresponding to this AST node
        SrcReg textpos.Region `set:"-"`

        // source code corresponding to this AST node
        Src string `set:"-"`

        // stack of symbols created for this node
        Syms syms.SymStack `set:"-"`
}

func (ast *AST) Destroy() {
        ast.Syms.ClearAST()
        ast.Syms = nil
        ast.NodeBase.Destroy()
}

// ChildAST returns the Child at given index as an AST.
// Will panic if index is invalid -- use Try if unsure.
func (ast *AST) ChildAST(idx int) *AST {
        return ast.Child(idx).(*AST)
}

// ChildASTTry returns the Child at given index as an AST,
// nil if not in range.
func (ast *AST) ChildASTTry(idx int) *AST {
        if ast == nil {
                return nil
        }
        if idx < 0 || idx >= len(ast.Children) {
                return nil
        }
        return ast.Child(idx).(*AST)
}

// ParentAST returns the Parent as an AST.
func (ast *AST) ParentAST() *AST {
        if ast.Parent == nil {
                return nil
        }
        pn := ast.Parent.AsTree().This
        if pn == nil {
                return nil
        }
        return pn.(*AST)
}

// NextAST returns the next node in the AST tree, or nil if none
func (ast *AST) NextAST() *AST {
        nxti := tree.Next(ast)
        if nxti == nil {
                return nil
        }
        return nxti.(*AST)
}

// NextSiblingAST returns the next sibling node in the AST tree, or nil if none
func (ast *AST) NextSiblingAST() *AST {
        nxti := tree.NextSibling(ast)
        if nxti == nil {
                return nil
        }
        return nxti.(*AST)
}

// PrevAST returns the previous node in the AST tree, or nil if none
func (ast *AST) PrevAST() *AST {
        nxti := tree.Previous(ast)
        if nxti == nil {
                return nil
        }
        return nxti.(*AST)
}

// SetTokReg sets the token region for this rule to given region
func (ast *AST) SetTokReg(reg textpos.Region, src *lexer.File) {
        ast.TokReg = reg
        ast.SrcReg = src.TokenSrcReg(ast.TokReg)
        ast.Src = src.RegSrc(ast.SrcReg)
}

// SetTokRegEnd updates the ending token region to given position --
// token regions are typically over-extended and get narrowed as tokens actually match
func (ast *AST) SetTokRegEnd(pos textpos.Pos, src *lexer.File) {
        ast.TokReg.End = pos
        ast.SrcReg = src.TokenSrcReg(ast.TokReg)
        ast.Src = src.RegSrc(ast.SrcReg)
}

// WriteTree writes the AST tree data to the writer -- not attempting to re-render
// source code -- just for debugging etc
func (ast *AST) WriteTree(out io.Writer, depth int) {
        ind := indent.Tabs(depth)
        fmt.Fprintf(out, "%v%v: %v\n", ind, ast.Name, ast.Src)
        for _, k := range ast.Children {
                ai := k.(*AST)
                ai.WriteTree(out, depth+1)
        }
}

// Code generated by "core generate"; DO NOT EDIT.

package parser

import (
        "cogentcore.org/core/enums"
)

var _ActionsValues = []Actions{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

// ActionsN is the highest valid value for type Actions, plus one.
const ActionsN Actions = 10

var _ActionsValueMap = map[string]Actions{`ChangeToken`: 0, `AddSymbol`: 1, `PushScope`: 2, `PushNewScope`: 3, `PopScope`: 4, `PopScopeReg`: 5, `AddDetail`: 6, `AddType`: 7, `PushStack`: 8, `PopStack`: 9}

var _ActionsDescMap = map[Actions]string{0: `ChangeToken changes the token to the Tok specified in the Act action`, 1: `AddSymbol means add name as a symbol, using current scoping and token type or the token specified in the Act action if != None`, 2: `PushScope means look for an existing symbol of given name to push onto current scope -- adding a new one if not found -- does not add new item to overall symbol list. This is useful for e.g., definitions of methods on a type, where this is not the definition of the type itself.`, 3: `PushNewScope means add a new symbol to the list and also push onto scope stack, using given token type or the token specified in the Act action if != None`, 4: `PopScope means remove the most recently added scope item`, 5: `PopScopeReg means remove the most recently added scope item, and also updates the source region for that item based on final SrcReg from corresponding AST node -- for "definitional" scope`, 6: `AddDetail adds src at given path as detail info for the last-added symbol if there is already something there, a space is added for this new addition`, 7: `AddType Adds a type with the given name -- sets the AST node for this rule and actual type is resolved later in a second language-specific pass`, 8: `PushStack adds name to stack -- provides context-sensitivity option for optimizing and ambiguity resolution`, 9: `PopStack pops the stack`}

var _ActionsMap = map[Actions]string{0: `ChangeToken`, 1: `AddSymbol`, 2: `PushScope`, 3: `PushNewScope`, 4: `PopScope`, 5: `PopScopeReg`, 6: `AddDetail`, 7: `AddType`, 8: `PushStack`, 9: `PopStack`}

// String returns the string representation of this Actions value.
func (i Actions) String() string { return enums.String(i, _ActionsMap) }

// SetString sets the Actions value from its string representation,
// and returns an error if the string is invalid.
func (i *Actions) SetString(s string) error {
        return enums.SetString(i, s, _ActionsValueMap, "Actions")
}

// Int64 returns the Actions value as an int64.
func (i Actions) Int64() int64 { return int64(i) }

// SetInt64 sets the Actions value from an int64.
func (i *Actions) SetInt64(in int64) { *i = Actions(in) }

// Desc returns the description of the Actions value.
func (i Actions) Desc() string { return enums.Desc(i, _ActionsDescMap) }

// ActionsValues returns all possible values for the type Actions.
func ActionsValues() []Actions { return _ActionsValues }

// Values returns all possible values for the type Actions.
func (i Actions) Values() []enums.Enum { return enums.Values(_ActionsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Actions) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Actions) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Actions") }

var _ASTActsValues = []ASTActs{0, 1, 2, 3, 4}

// ASTActsN is the highest valid value for type ASTActs, plus one.
const ASTActsN ASTActs = 5

var _ASTActsValueMap = map[string]ASTActs{`NoAST`: 0, `AddAST`: 1, `SubAST`: 2, `AnchorAST`: 3, `AnchorFirstAST`: 4}

var _ASTActsDescMap = map[ASTActs]string{0: `NoAST means don't create an AST node for this rule`, 1: `AddAST means create an AST node for this rule, adding it to the current anchor AST. Any sub-rules within this rule are *not* added as children of this node -- see SubAST and AnchorAST. This is good for token-only terminal nodes and list elements that should be added to a list.`, 2: `SubAST means create an AST node and add all the elements of *this rule* as children of this new node (including sub-rules), *except* for the very last rule which is assumed to be a recursive rule -- that one goes back up to the parent node. This is good for adding more complex elements with sub-rules to a recursive list, without creating a new hierarchical depth level for every such element.`, 3: `AnchorAST means create an AST node and set it as the anchor that subsequent sub-nodes are added into. This is for a new hierarchical depth level where everything under this rule gets organized.`, 4: `AnchorFirstAST means create an AST node and set it as the anchor that subsequent sub-nodes are added into, *only* if this is the first time that this rule has matched within the current sequence (i.e., if the parent of this rule is the same rule then don't add a new AST node). This is good for starting a new list of recursively defined elements, without creating increasing depth levels.`}

var _ASTActsMap = map[ASTActs]string{0: `NoAST`, 1: `AddAST`, 2: `SubAST`, 3: `AnchorAST`, 4: `AnchorFirstAST`}

// String returns the string representation of this ASTActs value.
func (i ASTActs) String() string { return enums.String(i, _ASTActsMap) }

// SetString sets the ASTActs value from its string representation,
// and returns an error if the string is invalid.
func (i *ASTActs) SetString(s string) error {
        return enums.SetString(i, s, _ASTActsValueMap, "ASTActs")
}

// Int64 returns the ASTActs value as an int64.
func (i ASTActs) Int64() int64 { return int64(i) }

// SetInt64 sets the ASTActs value from an int64.
func (i *ASTActs) SetInt64(in int64) { *i = ASTActs(in) }

// Desc returns the description of the ASTActs value.
func (i ASTActs) Desc() string { return enums.Desc(i, _ASTActsDescMap) }

// ASTActsValues returns all possible values for the type ASTActs.
func ASTActsValues() []ASTActs { return _ASTActsValues }

// Values returns all possible values for the type ASTActs.
func (i ASTActs) Values() []enums.Enum { return enums.Values(_ASTActsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i ASTActs) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *ASTActs) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "ASTActs") }

var _StepsValues = []Steps{0, 1, 2, 3, 4}

// StepsN is the highest valid value for type Steps, plus one.
const StepsN Steps = 5

var _StepsValueMap = map[string]Steps{`Match`: 0, `SubMatch`: 1, `NoMatch`: 2, `Run`: 3, `RunAct`: 4}

var _StepsDescMap = map[Steps]string{0: `Match happens when a rule matches`, 1: `SubMatch is when a sub-rule within a rule matches`, 2: `NoMatch is when the rule fails to match (recorded at first non-match, which terminates matching process`, 3: `Run is when the rule is running and iterating through its sub-rules`, 4: `RunAct is when the rule is running and performing actions`}

var _StepsMap = map[Steps]string{0: `Match`, 1: `SubMatch`, 2: `NoMatch`, 3: `Run`, 4: `RunAct`}

// String returns the string representation of this Steps value.
func (i Steps) String() string { return enums.String(i, _StepsMap) }

// SetString sets the Steps value from its string representation,
// and returns an error if the string is invalid.
func (i *Steps) SetString(s string) error { return enums.SetString(i, s, _StepsValueMap, "Steps") }

// Int64 returns the Steps value as an int64.
func (i Steps) Int64() int64 { return int64(i) }

// SetInt64 sets the Steps value from an int64.
func (i *Steps) SetInt64(in int64) { *i = Steps(in) }

// Desc returns the description of the Steps value.
func (i Steps) Desc() string { return enums.Desc(i, _StepsDescMap) }

// StepsValues returns all possible values for the type Steps.
func StepsValues() []Steps { return _StepsValues }

// Values returns all possible values for the type Steps.
func (i Steps) Values() []enums.Enum { return enums.Values(_StepsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Steps) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Steps) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Steps") }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package parser does the parsing stage after lexing, using a top-down recursive-descent
// (TDRD) strategy, with a special reverse mode to deal with left-associative binary expressions
// which otherwise end up being right-associative for TDRD parsing.
// Higher-level rules provide scope to lower-level ones, with a special EOS end-of-statement
// scope recognized for
package parser

import (
        "fmt"
        "io"
        "strconv"
        "strings"
        "text/tabwriter"

        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
        "cogentcore.org/core/tree"
)

// Set GUIActive to true if the gui (parseview) is active -- ensures that the
// AST tree is updated when nodes are swapped in reverse mode, and maybe
// other things
var GUIActive = false

// DepthLimit is the infinite recursion prevention cutoff
var DepthLimit = 10000

// parser.Rule operates on the lexically tokenized input, not the raw source.
//
// The overall strategy is pragmatically based on the current known form of
// most languages, which are organized around a sequence of statements having
// a clear scoping defined by the EOS (end of statement), which is identified
// in a first pass through tokenized output in PassTwo.
//
// We use a top-down, recursive-descent style parsing, with flexible lookahead
// based on scoping provided by the EOS tags.  Each rule progressively scopes
// down the space, using token matches etc to bracket the space for flexible
// elements.
//
// There are two different rule types:
// 1. Parents with multiple children (i.e. Groups), which are all the different
// variations for satisfying that rule, with precedence encoded directly in the
// ordering of the children.  These have empty "Rule" string and Rules.
// 2. Explicit rules specified in the Rule string.

// The first step is matching which searches in order for matches within the
// children of parent nodes, and for explicit rule nodes, it looks first
// through all the explicit tokens in the rule.  If there are no explicit tokens
// then matching defers to ONLY the first node listed by default -- you can
// add a @ prefix to indicate a rule that is also essential to match.
//
// After a rule matches, it then proceeds through the rules narrowing the scope
// and calling the sub-nodes..
type Rule struct {
        tree.NodeBase

        // disable this rule -- useful for testing and exploration
        Off bool `json:",omitempty"`

        // description / comments about this rule
        Desc string `json:",omitempty"`

        // the rule as a space-separated list of rule names and token(s) -- use single quotes around 'tokens' (using token.Tokens names or symbols). For keywords use 'key:keyword'.  All tokens are matched at the same nesting depth as the start of the scope of this rule, unless they have a +D relative depth value differential before the token.  Use @ prefix for a sub-rule to require that rule to match -- by default explicit tokens are used if available, and then only the first sub-rule failing that.  Use ! by itself to define start of an exclusionary rule -- doesn't match when those rule elements DO match.  Use : prefix for a special group node that matches a single token at start of scope, and then defers to the child rules to perform full match -- this is used for FirstTokenMap when there are multiple versions of a given keyword rule.  Use - prefix for tokens anchored by the end (next token) instead of the previous one -- typically just for token prior to 'EOS' but also a block of tokens that need to go backward in the middle of a sequence to avoid ambiguity can be marked with -
        Rule string

        // if present, this rule only fires if stack has this on it
        StackMatch string `json:",omitempty"`

        // what action should be take for this node when it matches
        AST ASTActs

        // actions to perform based on parsed AST tree data, when this rule is done executing
        Acts Acts `json:",omitempty"`

        // for group-level rules having lots of children and lots of recursiveness, and also of high-frequency, when we first encounter such a rule, make a map of all the tokens in the entire scope, and use that for a first-pass rejection on matching tokens
        OptTokenMap bool `json:",omitempty"`

        // for group-level rules with a number of rules that match based on first tokens / keywords, build map to directly go to that rule -- must also organize all of these rules sequentially from the start -- if no match, goes directly to first non-lookup case
        FirstTokenMap bool `json:",omitempty"`

        // rule elements compiled from Rule string
        Rules RuleList `json:"-" xml:"-"`

        // strategic matching order for matching the rules
        Order []int `edit:"-" json:"-" xml:"-"`

        // map from first tokens / keywords to rules for FirstTokenMap case
        FiTokenMap map[string]*Rule `edit:"-" json:"-" xml:"-" set:"-"`

        // for FirstTokenMap, the start of the else cases not covered by the map
        FiTokenElseIndex int `edit:"-" json:"-" xml:"-" set:"-"`

        // exclusionary key index -- this is the token in Rules that we need to exclude matches for using ExclFwd and ExclRev rules
        ExclKeyIndex int `edit:"-" json:"-" xml:"-" set:"-"`

        // exclusionary forward-search rule elements compiled from Rule string
        ExclFwd RuleList `edit:"-" json:"-" xml:"-" set:"-"`

        // exclusionary reverse-search rule elements compiled from Rule string
        ExclRev RuleList `edit:"-" json:"-" xml:"-" set:"-"`

        // Bool flags:

        // setsScope means that this rule sets its own scope, because it ends with EOS
        setsScope bool

        // reverse means that this rule runs in reverse (starts with - sign) -- for arithmetic
        // binary expressions only: this is needed to produce proper associativity result for
        // mathematical expressions in the recursive descent parser.
        // Only for rules of form: Expr '+' Expr -- two sub-rules with a token operator
        // in the middle.
        reverse bool

        // noTokens means that this rule doesn't have any explicit tokens -- only refers to
        // other rules
        noTokens bool

        // onlyTokens means that this rule only has explicit tokens for matching -- can be
        // optimized
        onlyTokens bool

        // tokenMatchGroup is a group node that also has a single token match, so it can
        // be used in a FirstTokenMap to optimize lookup of rules
        tokenMatchGroup bool
}

// RuleEl is an element of a parsing rule -- either a pointer to another rule or a token
type RuleEl struct {

        // sub-rule for this position -- nil if token
        Rule *Rule

        // token, None if rule
        Token token.KeyToken

        // start increment for matching -- this is the number of non-optional, non-match items between (start | last match) and this item -- increments start region for matching
        StInc int

        // if true, this rule must match for rule to fire -- by default only tokens and, failing that, the first sub-rule is used for matching -- use @ to require a match
        Match bool

        // this rule is optional -- will absorb tokens if they exist -- indicated with ? prefix
        Opt bool

        // match this rule working backward from the next token -- triggered by - (minus) prefix and optimizes cases where there can be a lot of tokens going forward but few going from end -- must be anchored by a terminal EOS or other FromNext elements and is ignored if at the very end
        FromNext bool
}

func (re RuleEl) IsRule() bool {
        return re.Rule != nil
}

func (re RuleEl) IsToken() bool {
        return re.Rule == nil
}

// RuleList is a list (slice) of rule elements
type RuleList []RuleEl

// Last returns the last rule -- only used in cases where there are rules
func (rl RuleList) Last() *RuleEl {
        return &rl[len(rl)-1]
}

// RuleMap is a map of all the rule names, for quick lookup
var RuleMap map[string]*Rule

// Matches encodes the regions of each match, Err for no match
type Matches []textpos.Region

// StartEnd returns the first and last non-zero positions in the Matches list as a region
func (mm Matches) StartEnd() textpos.Region {
        reg := textpos.RegionZero
        for _, mp := range mm {
                if mp.Start != textpos.PosZero {
                        if reg.Start == textpos.PosZero {
                                reg.Start = mp.Start
                        }
                        reg.End = mp.End
                }
        }
        return reg
}

// StartEndExcl returns the first and last non-zero positions in the Matches list as a region
// moves the end to next toke to make it the usual exclusive end pos
func (mm Matches) StartEndExcl(ps *State) textpos.Region {
        reg := mm.StartEnd()
        reg.End, _ = ps.Src.NextTokenPos(reg.End)
        return reg
}

///////////////////////////////////////////////////////////////////////
//  Rule

// IsGroup returns true if this node is a group, else it should have rules
func (pr *Rule) IsGroup() bool {
        return pr.HasChildren()
}

// SetRuleMap is called on the top-level Rule and initializes the RuleMap
func (pr *Rule) SetRuleMap(ps *State) {
        RuleMap = map[string]*Rule{}
        pr.WalkDown(func(k tree.Node) bool {
                pri := k.(*Rule)
                if epr, has := RuleMap[pri.Name]; has {
                        ps.Error(textpos.PosZero, fmt.Sprintf("Parser Compile: multiple rules with same name: %v and %v", pri.Path(), epr.Path()), pri)
                } else {
                        RuleMap[pri.Name] = pri
                }
                return true
        })
}

// CompileAll is called on the top-level Rule to compile all nodes
// it calls SetRuleMap first.
// Returns true if everything is ok, false if there were compile errors
func (pr *Rule) CompileAll(ps *State) bool {
        pr.SetRuleMap(ps)
        allok := true
        pr.WalkDown(func(k tree.Node) bool {
                pri := k.(*Rule)
                ok := pri.Compile(ps)
                if !ok {
                        allok = false
                }
                return true
        })
        return allok
}

// Compile compiles string rules into their runnable elements.
// Returns true if everything is ok, false if there were compile errors.
func (pr *Rule) Compile(ps *State) bool {
        if pr.Off {
                pr.SetProperty("inactive", true)
        } else {
                pr.DeleteProperty("inactive")
        }
        if pr.Rule == "" { // parent
                pr.Rules = nil
                pr.setsScope = false
                return true
        }
        valid := true
        rstr := pr.Rule
        if pr.Rule[0] == '-' {
                rstr = rstr[1:]
                pr.reverse = true
        } else {
                pr.reverse = false
        }
        rs := strings.Split(rstr, " ")
        nr := len(rs)

        pr.Rules = make(RuleList, nr)
        pr.ExclFwd = nil
        pr.ExclRev = nil
        pr.noTokens = false
        pr.onlyTokens = true // default is this..
        pr.setsScope = false
        pr.tokenMatchGroup = false
        pr.Order = nil
        nmatch := 0
        ntok := 0
        curStInc := 0
        eoses := 0
        for ri := range rs {
                rn := strings.TrimSpace(rs[ri])
                if len(rn) == 0 {
                        ps.Error(textpos.PosZero, "Compile: Rules has empty string -- make sure there is only one space between rule elements", pr)
                        valid = false
                        break
                }
                if rn == "!" { // exclusionary rule
                        nr = ri
                        pr.Rules = pr.Rules[:ri]
                        pr.CompileExcl(ps, rs, ri+1)
                        break
                }
                if rn[0] == ':' {
                        pr.tokenMatchGroup = true
                }
                rr := &pr.Rules[ri]
                tokst := strings.Index(rn, "'")
                if tokst >= 0 {
                        if rn[0] == '?' {
                                rr.Opt = true
                        } else {
                                rr.StInc = curStInc
                                rr.Match = true // all tokens match by default
                                pr.Order = append(pr.Order, ri)
                                nmatch++
                                ntok++
                                curStInc = 0
                        }
                        sz := len(rn)
                        if rn[0] == '+' {
                                td, _ := strconv.ParseInt(rn[1:tokst], 10, 64)
                                rr.Token.Depth = int(td)
                        } else if rn[0] == '-' {
                                rr.FromNext = true
                        }
                        tn := rn[tokst+1 : sz-1]
                        if len(tn) > 4 && tn[:4] == "key:" {
                                rr.Token.Token = token.Keyword
                                rr.Token.Key = tn[4:]
                        } else {
                                if pmt, has := token.OpPunctMap[tn]; has {
                                        rr.Token.Token = pmt
                                } else {
                                        err := rr.Token.Token.SetString(tn)
                                        if err != nil {
                                                ps.Error(textpos.PosZero, fmt.Sprintf("Compile: token convert error: %v", err.Error()), pr)
                                                valid = false
                                        }
                                }
                        }
                        if rr.Token.Token == token.EOS {
                                eoses++
                                if ri == nr-1 {
                                        rr.StInc = eoses
                                        pr.setsScope = true
                                }
                        }
                } else {
                        st := 0
                        if rn[:2] == "?@" || rn[:2] == "@?" {
                                st = 2
                                rr.Opt = true
                                rr.Match = true
                        } else if rn[0] == '?' {
                                st = 1
                                rr.Opt = true
                        } else if rn[0] == '@' {
                                st = 1
                                rr.Match = true
                                pr.onlyTokens = false
                                pr.Order = append(pr.Order, ri)
                                nmatch++
                        } else {
                                curStInc++
                        }
                        rp, ok := RuleMap[rn[st:]]
                        if !ok {
                                ps.Error(textpos.PosZero, fmt.Sprintf("Compile: refers to rule %v not found", rn), pr)
                                valid = false
                        } else {
                                rr.Rule = rp
                        }
                }
        }
        if pr.reverse {
                pr.AST = AnchorAST // must be
        }
        if ntok == 0 && nmatch == 0 {
                pr.Rules[0].Match = true
                pr.Order = append(pr.Order, 0)
                pr.noTokens = true
        } else {
                pr.OptimizeOrder(ps)
        }
        return valid
}

// OptimizeOrder optimizes the order of processing rule elements, including:
// * A block of reversed elements that match from next
func (pr *Rule) OptimizeOrder(ps *State) {
        osz := len(pr.Order)
        if osz == 0 {
                return
        }
        nfmnxt := 0
        fmnSt := -1
        fmnEd := -1
        lastwas := false
        for oi := 0; oi < osz; oi++ {
                ri := pr.Order[oi]
                rr := &pr.Rules[ri]
                if rr.FromNext {
                        nfmnxt++
                        if fmnSt < 0 {
                                fmnSt = oi
                        }
                        if lastwas {
                                fmnEd = oi // end of block
                        }
                        lastwas = true
                } else {
                        lastwas = false
                }
        }
        if nfmnxt > 1 && fmnEd > 0 {
                nword := make([]int, osz)
                for oi := 0; oi < fmnSt; oi++ {
                        nword[oi] = pr.Order[oi]
                }
                idx := fmnSt
                for oi := fmnEd - 1; oi >= fmnSt; oi-- {
                        nword[idx] = pr.Order[oi]
                        idx++
                }
                for oi := fmnEd; oi < osz; oi++ {
                        nword[oi] = pr.Order[oi]
                }
                pr.Order = nword
        }
}

// CompileTokMap compiles first token map
func (pr *Rule) CompileTokMap(ps *State) bool {
        valid := true
        pr.FiTokenMap = make(map[string]*Rule, len(pr.Children))
        pr.FiTokenElseIndex = len(pr.Children)
        for i, kpri := range pr.Children {
                kpr := kpri.(*Rule)
                if len(kpr.Rules) == 0 || !kpr.Rules[0].IsToken() {
                        pr.FiTokenElseIndex = i
                        break
                }
                fr := kpr.Rules[0]
                skey := fr.Token.StringKey()
                if _, has := pr.FiTokenMap[skey]; has {
                        ps.Error(textpos.PosZero, fmt.Sprintf("CompileFirstTokenMap: multiple rules have the same first token: %v -- must be unique -- use a :'tok' group to match that first token and put all the sub-rules as children of that node", fr.Token), pr)
                        pr.FiTokenElseIndex = 0
                        valid = false
                } else {
                        pr.FiTokenMap[skey] = kpr
                }
        }
        return valid
}

// CompileExcl compiles exclusionary rules starting at given point
// currently only working for single-token matching rule
func (pr *Rule) CompileExcl(ps *State, rs []string, rist int) bool {
        valid := true
        nr := len(rs)
        var ktok token.KeyToken

        ktoki := -1
        for ri := 0; ri < rist; ri++ {
                rr := &pr.Rules[ri]
                if !rr.IsToken() {
                        continue
                }
                ktok = rr.Token
                ktoki = ri
                break
        }

        if ktoki < 0 {
                ps.Error(textpos.PosZero, "CompileExcl: no token found for matching exclusion rules", pr)
                return false
        }

        pr.ExclRev = make(RuleList, nr-rist)
        ki := -1
        for ri := rist; ri < nr; ri++ {
                rn := strings.TrimSpace(rs[ri])
                rr := &pr.ExclRev[ri-rist]
                if rn[0] == '?' {
                        rr.Opt = true
                }
                tokst := strings.Index(rn, "'")
                if tokst < 0 {
                        continue // pure optional
                }
                if !rr.Opt {
                        rr.Match = true // all tokens match by default
                }
                sz := len(rn)
                if rn[0] == '+' {
                        td, _ := strconv.ParseInt(rn[1:tokst], 10, 64)
                        rr.Token.Depth = int(td)
                }
                tn := rn[tokst+1 : sz-1]
                if len(tn) > 4 && tn[:4] == "key:" {
                        rr.Token.Token = token.Keyword
                        rr.Token.Key = tn[4:]
                } else {
                        if pmt, has := token.OpPunctMap[tn]; has {
                                rr.Token.Token = pmt
                        } else {
                                err := rr.Token.Token.SetString(tn)
                                if err != nil {
                                        ps.Error(textpos.PosZero, fmt.Sprintf("CompileExcl: token convert error: %v", err.Error()), pr)
                                        valid = false
                                }
                        }
                }
                if rr.Token.Equal(ktok) {
                        ki = ri
                }
        }
        if ki < 0 {
                ps.Error(textpos.PosZero, fmt.Sprintf("CompileExcl: key token: %v not found in exclusion rule", ktok), pr)
                valid = false
                return valid
        }
        pr.ExclKeyIndex = ktoki
        pr.ExclFwd = pr.ExclRev[ki+1-rist:]
        pr.ExclRev = pr.ExclRev[:ki-rist]
        return valid
}

// Validate checks for any errors in the rules and issues warnings,
// returns true if valid (no err) and false if invalid (errs)
func (pr *Rule) Validate(ps *State) bool {
        valid := true

        // do this here so everything else is compiled
        if len(pr.Rules) == 0 && pr.FirstTokenMap {
                pr.CompileTokMap(ps)
        }

        if len(pr.Rules) == 0 && !pr.HasChildren() && !tree.IsRoot(pr) {
                ps.Error(textpos.PosZero, "Validate: rule has no rules and no children", pr)
                valid = false
        }
        if !pr.tokenMatchGroup && len(pr.Rules) > 0 && pr.HasChildren() {
                ps.Error(textpos.PosZero, "Validate: rule has both rules and children -- should be either-or", pr)
                valid = false
        }
        if pr.reverse {
                if len(pr.Rules) != 3 {
                        ps.Error(textpos.PosZero, "Validate: a Reverse (-) rule must have 3 children -- for binary operator expressions only", pr)
                        valid = false
                } else {
                        if !pr.Rules[1].IsToken() {
                                ps.Error(textpos.PosZero, "Validate: a Reverse (-) rule must have a token to be recognized in the middle of two rules -- for binary operator expressions only", pr)
                        }
                }
        }

        if len(pr.Rules) > 0 {
                if pr.Rules[0].IsRule() && (pr.Rules[0].Rule == pr || pr.ParentLevel(pr.Rules[0].Rule) >= 0) { // left recursive
                        if pr.Rules[0].Match {
                                ps.Error(textpos.PosZero, fmt.Sprintf("Validate: rule refers to itself recursively in first sub-rule: %v and that sub-rule is marked as a Match -- this is infinite recursion and is not allowed!  Must use distinctive tokens in rule to match this rule, and then left-recursive elements will be filled in when the rule runs, but they cannot be used for matching rule.", pr.Rules[0].Rule.Name), pr)
                                valid = false
                        }
                        ntok := 0
                        for _, rr := range pr.Rules {
                                if rr.IsToken() {
                                        ntok++
                                }
                        }
                        if ntok == 0 {
                                ps.Error(textpos.PosZero, fmt.Sprintf("Validate: rule refers to itself recursively in first sub-rule: %v, and does not have any tokens in the rule -- MUST promote tokens to this rule to disambiguate match, otherwise will just do infinite recursion!", pr.Rules[0].Rule.Name), pr)
                                valid = false
                        }
                }
        }

        // now we iterate over our kids
        for _, kpri := range pr.Children {
                kpr := kpri.(*Rule)
                if !kpr.Validate(ps) {
                        valid = false
                }
        }
        return valid
}

// StartParse is called on the root of the parse rule tree to start the parsing process
func (pr *Rule) StartParse(ps *State) *Rule {
        if ps.AtEofNext() || !pr.HasChildren() {
                ps.GotoEof()
                return nil
        }
        kpr := pr.Children[0].(*Rule) // first rule is special set of valid top-level matches
        var parAST *AST
        scope := textpos.Region{Start: ps.Pos}
        if ps.AST.HasChildren() {
                parAST = ps.AST.ChildAST(0)
        } else {
                parAST = NewAST(ps.AST)
                parAST.SetName(kpr.Name)
                ok := false
                scope.Start, ok = ps.Src.ValidTokenPos(scope.Start)
                if !ok {
                        ps.GotoEof()
                        return nil
                }
                ps.Pos = scope.Start
        }
        didErr := false
        for {
                cpos := ps.Pos
                mrule := kpr.Parse(ps, pr, parAST, scope, nil, 0)
                ps.ResetNonMatches()
                if ps.AtEof() {
                        return nil
                }
                if cpos == ps.Pos {
                        if !didErr {
                                ps.Error(cpos, "did not advance position -- need more rules to match current input -- skipping to next EOS", pr)
                                didErr = true
                        }
                        cp, ok := ps.Src.NextTokenPos(ps.Pos)
                        if !ok {
                                ps.GotoEof()
                                return nil
                        }
                        ep, ok := ps.Src.NextEosAnyDepth(cp)
                        if !ok {
                                ps.GotoEof()
                                return nil
                        }
                        ps.Pos = ep
                } else {
                        return mrule
                }
        }
}

// Parse tries to apply rule to given input state, returns rule that matched or nil
// parent is the parent rule that we're being called from.
// parAST is the current ast node that we add to.
// scope is the region to search within, defined by parent or EOS if we have a terminal
// one
func (pr *Rule) Parse(ps *State, parent *Rule, parAST *AST, scope textpos.Region, optMap lexer.TokenMap, depth int) *Rule {
        if pr.Off {
                return nil
        }

        if depth >= DepthLimit {
                ps.Error(scope.Start, "depth limit exceeded -- parser rules error -- look for recursive cases", pr)
                return nil
        }

        nr := len(pr.Rules)
        if !pr.tokenMatchGroup && nr > 0 {
                return pr.ParseRules(ps, parent, parAST, scope, optMap, depth)
        }

        if optMap == nil && pr.OptTokenMap {
                optMap = ps.Src.TokenMapReg(scope)
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, Run, scope.Start, scope, parAST, fmt.Sprintf("made optmap of size: %d", len(optMap)))
                }
        }

        // pure group types just iterate over kids
        for _, kpri := range pr.Children {
                kpr := kpri.(*Rule)
                if mrule := kpr.Parse(ps, pr, parAST, scope, optMap, depth+1); mrule != nil {
                        return mrule
                }
        }
        return nil
}

// ParseRules parses rules and returns this rule if it matches, nil if not
func (pr *Rule) ParseRules(ps *State, parent *Rule, parAST *AST, scope textpos.Region, optMap lexer.TokenMap, depth int) *Rule {
        ok := false
        if pr.setsScope {
                scope, ok = pr.Scope(ps, parAST, scope)
                if !ok {
                        return nil
                }
        } else if GUIActive {
                if scope == textpos.RegionZero {
                        ps.Error(scope.Start, "scope is empty and no EOS in rule -- invalid rules -- starting rules must all have EOS", pr)
                        return nil
                }
        }
        match, nscope, mpos := pr.Match(ps, parAST, scope, 0, optMap)
        if !match {
                return nil
        }

        rparent := parent.Parent.(*Rule)

        if parent.AST != NoAST && parent.IsGroup() {
                if parAST.Name != parent.Name {
                        mreg := mpos.StartEndExcl(ps)
                        newAST := ps.AddAST(parAST, parent.Name, mreg)
                        if parent.AST == AnchorAST {
                                parAST = newAST
                        }
                }
        } else if parent.IsGroup() && rparent.AST != NoAST && rparent.IsGroup() { // two-level group...
                if parAST.Name != rparent.Name {
                        mreg := mpos.StartEndExcl(ps)
                        newAST := ps.AddAST(parAST, rparent.Name, mreg)
                        if rparent.AST == AnchorAST {
                                parAST = newAST
                        }
                }
        }
        valid := pr.DoRules(ps, parent, parAST, nscope, mpos, optMap, depth) // returns validity but we don't care once matched..
        if !valid {
                return nil
        }
        return pr
}

// Scope finds the potential scope region for looking for tokens -- either from
// EOS position or State ScopeStack pushed from parents.
// Returns new scope and false if no valid scope found.
func (pr *Rule) Scope(ps *State, parAST *AST, scope textpos.Region) (textpos.Region, bool) {
        // prf := profile.Start("Scope")
        // defer prf.End()

        nscope := scope
        creg := scope
        lr := pr.Rules.Last()
        for ei := 0; ei < lr.StInc; ei++ {
                stlx := ps.Src.LexAt(creg.Start)
                ep, ok := ps.Src.NextEos(creg.Start, stlx.Token.Depth)
                if !ok {
                        // ps.Error(creg.Start, "could not find EOS at target nesting depth -- parens / bracket / brace mismatch?", pr)
                        return nscope, false
                }
                if scope.End != textpos.PosZero && lr.Opt && scope.End.IsLess(ep) {
                        // optional tokens can't take us out of scope
                        return scope, true
                }
                if ei == lr.StInc-1 {
                        nscope.End = ep
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, SubMatch, nscope.Start, nscope, parAST, fmt.Sprintf("from EOS: starting scope: %v new scope: %v end pos: %v depth: %v", scope, nscope, ep, stlx.Token.Depth))
                        }
                } else {
                        creg.Start, ok = ps.Src.NextTokenPos(ep) // advance
                        if !ok {
                                // ps.Error(scope.St, "end of file looking for EOS tokens -- premature file end?", pr)
                                return nscope, false
                        }
                }
        }
        return nscope, true
}

// Match attempts to match the rule, returns true if it matches, and the
// match positions, along with any update to the scope
func (pr *Rule) Match(ps *State, parAST *AST, scope textpos.Region, depth int, optMap lexer.TokenMap) (bool, textpos.Region, Matches) {
        if pr.Off {
                return false, scope, nil
        }

        if depth > DepthLimit {
                ps.Error(scope.Start, "depth limit exceeded -- parser rules error -- look for recursive cases", pr)
                return false, scope, nil
        }

        if ps.IsNonMatch(scope, pr) {
                return false, scope, nil
        }

        if pr.StackMatch != "" {
                if ps.Stack.Top() != pr.StackMatch {
                        return false, scope, nil
                }
        }

        // mprf := profile.Start("Match")
        // defer mprf.End()
        // Note: uncomment the following to see which rules are taking the most
        // time -- very helpful for focusing effort on optimizing those rules.
        // prf := profile.Start(pr.Nm)
        // defer prf.End()

        nr := len(pr.Rules)
        if pr.tokenMatchGroup || nr == 0 { // Group
                return pr.MatchGroup(ps, parAST, scope, depth, optMap)
        }

        // prf := profile.Start("IsMatch")
        if mst, match := ps.IsMatch(pr, scope); match {
                // prf.End()
                return true, scope, mst.Regs
        }
        // prf.End()

        var mpos Matches
        match := false

        if pr.noTokens {
                match, mpos = pr.MatchNoToks(ps, parAST, scope, depth, optMap)
        } else if pr.onlyTokens {
                match, mpos = pr.MatchOnlyToks(ps, parAST, scope, depth, optMap)
        } else {
                match, mpos = pr.MatchMixed(ps, parAST, scope, depth, optMap)
        }
        if !match {
                ps.AddNonMatch(scope, pr)
                return false, scope, nil
        }

        if len(pr.ExclFwd) > 0 || len(pr.ExclRev) > 0 {
                ktpos := mpos[pr.ExclKeyIndex]
                if pr.MatchExclude(ps, scope, ktpos, depth, optMap) {
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, NoMatch, ktpos.Start, scope, parAST, "Exclude criteria matched")
                        }
                        ps.AddNonMatch(scope, pr)
                        return false, scope, nil
                }
        }

        mreg := mpos.StartEnd()
        ps.AddMatch(pr, scope, mpos)
        if ps.Trace.On {
                ps.Trace.Out(ps, pr, Match, mreg.Start, scope, parAST, fmt.Sprintf("Full Match reg: %v", mreg))
        }
        return true, scope, mpos
}

// MatchOnlyToks matches rules having only tokens
func (pr *Rule) MatchOnlyToks(ps *State, parAST *AST, scope textpos.Region, depth int, optMap lexer.TokenMap) (bool, Matches) {
        nr := len(pr.Rules)

        var mpos Matches

        scstlx := ps.Src.LexAt(scope.Start) // scope starting lex
        scstDepth := scstlx.Token.Depth

        creg := scope
        osz := len(pr.Order)
        for oi := 0; oi < osz; oi++ {
                ri := pr.Order[oi]
                rr := &pr.Rules[ri]
                kt := rr.Token
                if optMap != nil && !optMap.Has(kt.Token) { // not even a possibility
                        return false, nil
                }
                if rr.FromNext {
                        if mpos == nil {
                                mpos = make(Matches, nr) // make on demand -- cuts out a lot of allocations!
                        }
                        mpos[nr-1] = textpos.Region{Start: scope.End, End: scope.End}
                }
                kt.Depth += scstDepth // always use starting scope depth
                match, tpos := pr.MatchToken(ps, rr, ri, kt, &creg, mpos, parAST, scope, depth, optMap)
                if !match {
                        if ps.Trace.On {
                                if tpos != textpos.PosZero {
                                        tlx := ps.Src.LexAt(tpos)
                                        ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parAST, fmt.Sprintf("%v token: %v, was: %v", ri, kt.String(), tlx.String()))
                                } else {
                                        ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parAST, fmt.Sprintf("%v token: %v, nil region", ri, kt.String()))
                                }
                        }
                        return false, nil
                }
                if mpos == nil {
                        mpos = make(Matches, nr) // make on demand -- cuts out a lot of allocations!
                }
                mpos[ri] = textpos.Region{Start: tpos, End: tpos}
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, SubMatch, creg.Start, creg, parAST, fmt.Sprintf("%v token: %v", ri, kt.String()))
                }
        }

        return true, mpos
}

// MatchToken matches one token sub-rule -- returns true for match and
// false if no match -- and the position where it was / should have been
func (pr *Rule) MatchToken(ps *State, rr *RuleEl, ri int, kt token.KeyToken, creg *textpos.Region, mpos Matches, parAST *AST, scope textpos.Region, depth int, optMap lexer.TokenMap) (bool, textpos.Pos) {
        nr := len(pr.Rules)
        ok := false
        matchst := false // match start of creg
        matched := false // match end of creg
        var tpos textpos.Pos
        if ri == 0 {
                matchst = true
        } else if mpos != nil {
                lpos := mpos[ri-1].End
                if lpos != textpos.PosZero { // previous has matched
                        matchst = true
                } else if ri < nr-1 && rr.FromNext {
                        lpos := mpos[ri+1].Start
                        if lpos != textpos.PosZero { // previous has matched
                                creg.End, _ = ps.Src.PrevTokenPos(lpos)
                                matched = true
                        }
                }
        }
        for stinc := 0; stinc < rr.StInc; stinc++ {
                creg.Start, _ = ps.Src.NextTokenPos(creg.Start)
        }
        if ri == nr-1 && rr.Token.Token == token.EOS {
                return true, scope.End
        }
        if creg.IsNil() && !matched {
                return false, tpos
        }

        if matchst { // start token must be right here
                if !ps.MatchToken(kt, creg.Start) {
                        return false, creg.Start
                }
                tpos = creg.Start
        } else if matched {
                if !ps.MatchToken(kt, creg.End) {
                        return false, creg.End
                }
                tpos = creg.End
        } else {
                // prf := profile.Start("FindToken")
                if pr.reverse {
                        tpos, ok = ps.FindTokenReverse(kt, *creg)
                } else {
                        tpos, ok = ps.FindToken(kt, *creg)
                }
                // prf.End()
                if !ok {
                        return false, tpos
                }
        }
        creg.Start, _ = ps.Src.NextTokenPos(tpos) // always ratchet up
        return true, tpos
}

// MatchMixed matches mixed tokens and non-tokens
func (pr *Rule) MatchMixed(ps *State, parAST *AST, scope textpos.Region, depth int, optMap lexer.TokenMap) (bool, Matches) {
        nr := len(pr.Rules)
        var mpos Matches

        scstlx := ps.Src.LexAt(scope.Start) // scope starting lex
        scstDepth := scstlx.Token.Depth

        creg := scope
        osz := len(pr.Order)

        //         first pass filter on tokens
        if optMap != nil {
                for oi := 0; oi < osz; oi++ {
                        ri := pr.Order[oi]
                        rr := &pr.Rules[ri]
                        if rr.IsToken() {
                                kt := rr.Token
                                if !optMap.Has(kt.Token) { // not even a possibility
                                        return false, nil
                                }
                        }
                }
        }

        for oi := 0; oi < osz; oi++ {
                ri := pr.Order[oi]
                rr := &pr.Rules[ri]

                /////////////////////////////////////////////
                // Token
                if rr.IsToken() {
                        kt := rr.Token
                        if rr.FromNext {
                                if mpos == nil {
                                        mpos = make(Matches, nr) // make on demand -- cuts out a lot of allocations!
                                }
                                mpos[nr-1] = textpos.Region{Start: scope.End, End: scope.End}
                        }
                        kt.Depth += scstDepth // always use starting scope depth
                        match, tpos := pr.MatchToken(ps, rr, ri, kt, &creg, mpos, parAST, scope, depth, optMap)
                        if !match {
                                if ps.Trace.On {
                                        if tpos != textpos.PosZero {
                                                tlx := ps.Src.LexAt(tpos)
                                                ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parAST, fmt.Sprintf("%v token: %v, was: %v", ri, kt.String(), tlx.String()))
                                        } else {
                                                ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parAST, fmt.Sprintf("%v token: %v, nil region", ri, kt.String()))
                                        }
                                }
                                return false, nil
                        }
                        if mpos == nil {
                                mpos = make(Matches, nr) // make on demand -- cuts out a lot of allocations!
                        }
                        mpos[ri] = textpos.Region{Start: tpos, End: tpos}
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, SubMatch, creg.Start, creg, parAST, fmt.Sprintf("%v token: %v", ri, kt.String()))
                        }
                        continue
                }

                //////////////////////////////////////////////
                // Sub-Rule

                if creg.IsNil() {
                        ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parAST, fmt.Sprintf("%v sub-rule: %v, nil region", ri, rr.Rule.Name))
                        return false, nil
                }

                // first, limit region to same depth or greater as start of region -- prevents
                // overflow beyond natural boundaries
                stlx := ps.Src.LexAt(creg.Start) // scope starting lex
                cp, _ := ps.Src.NextTokenPos(creg.Start)
                stdp := stlx.Token.Depth
                for cp.IsLess(creg.End) {
                        lx := ps.Src.LexAt(cp)
                        if lx.Token.Depth < stdp {
                                creg.End = cp
                                break
                        }
                        cp, _ = ps.Src.NextTokenPos(cp)
                }

                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, SubMatch, creg.Start, creg, parAST, fmt.Sprintf("%v trying sub-rule: %v", ri, rr.Rule.Name))
                }
                match, _, smpos := rr.Rule.Match(ps, parAST, creg, depth+1, optMap)
                if !match {
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parAST, fmt.Sprintf("%v sub-rule: %v", ri, rr.Rule.Name))
                        }
                        return false, nil
                }
                creg.End = scope.End // back to full scope
                // look through smpos for last valid position -- use that as last match pos
                mreg := smpos.StartEnd()
                lmnpos, ok := ps.Src.NextTokenPos(mreg.End)
                if !ok && !(ri == nr-1 || (ri == nr-2 && pr.setsScope)) {
                        // if at end, or ends in EOS, then ok..
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parAST, fmt.Sprintf("%v sub-rule: %v -- not at end and no tokens left", ri, rr.Rule.Name))
                        }
                        return false, nil
                }
                if mpos == nil {
                        mpos = make(Matches, nr) // make on demand -- cuts out a lot of allocations!
                }
                mpos[ri] = mreg
                creg.Start = lmnpos
                if ps.Trace.On {
                        msreg := mreg
                        msreg.End = lmnpos
                        ps.Trace.Out(ps, pr, SubMatch, mreg.Start, msreg, parAST, fmt.Sprintf("%v rule: %v reg: %v", ri, rr.Rule.Name, msreg))
                }
        }

        return true, mpos
}

// MatchNoToks matches NoToks case -- just does single sub-rule match
func (pr *Rule) MatchNoToks(ps *State, parAST *AST, scope textpos.Region, depth int, optMap lexer.TokenMap) (bool, Matches) {
        creg := scope
        ri := 0
        rr := &pr.Rules[0]
        if ps.Trace.On {
                ps.Trace.Out(ps, pr, SubMatch, creg.Start, creg, parAST, fmt.Sprintf("%v trying sub-rule: %v", ri, rr.Rule.Name))
        }
        match, _, smpos := rr.Rule.Match(ps, parAST, creg, depth+1, optMap)
        if !match {
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parAST, fmt.Sprintf("%v sub-rule: %v", ri, rr.Rule.Name))
                }
                return false, nil
        }
        if ps.Trace.On {
                mreg := smpos.StartEnd() // todo: should this include creg start instead?
                ps.Trace.Out(ps, pr, SubMatch, mreg.Start, mreg, parAST, fmt.Sprintf("%v rule: %v reg: %v", ri, rr.Rule.Name, mreg))
        }
        return true, smpos
}

// MatchGroup does matching for Group rules
func (pr *Rule) MatchGroup(ps *State, parAST *AST, scope textpos.Region, depth int, optMap lexer.TokenMap) (bool, textpos.Region, Matches) {
        // prf := profile.Start("SubMatch")
        if mst, match := ps.IsMatch(pr, scope); match {
                //         prf.End()
                return true, scope, mst.Regs
        }
        // prf.End()
        sti := 0
        nk := len(pr.Children)
        if pr.FirstTokenMap {
                stlx := ps.Src.LexAt(scope.Start)
                if kpr, has := pr.FiTokenMap[stlx.Token.StringKey()]; has {
                        match, nscope, mpos := kpr.Match(ps, parAST, scope, depth+1, optMap)
                        if match {
                                if ps.Trace.On {
                                        ps.Trace.Out(ps, pr, SubMatch, scope.Start, scope, parAST, fmt.Sprintf("first token group child: %v", kpr.Name))
                                }
                                ps.AddMatch(pr, scope, mpos)
                                return true, nscope, mpos
                        }
                }
                sti = pr.FiTokenElseIndex
        }

        for i := sti; i < nk; i++ {
                kpri := pr.Children[i]
                kpr := kpri.(*Rule)
                match, nscope, mpos := kpr.Match(ps, parAST, scope, depth+1, optMap)
                if match {
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, SubMatch, scope.Start, scope, parAST, fmt.Sprintf("group child: %v", kpr.Name))
                        }
                        ps.AddMatch(pr, scope, mpos)
                        return true, nscope, mpos
                }
        }
        ps.AddNonMatch(scope, pr)
        return false, scope, nil
}

// MatchExclude looks for matches of exclusion tokens -- if found, they exclude this rule
// return is true if exclude matches and rule should be excluded
func (pr *Rule) MatchExclude(ps *State, scope textpos.Region, ktpos textpos.Region, depth int, optMap lexer.TokenMap) bool {
        nf := len(pr.ExclFwd)
        nr := len(pr.ExclRev)
        scstlx := ps.Src.LexAt(scope.Start) // scope starting lex
        scstDepth := scstlx.Token.Depth
        if nf > 0 {
                cp, ok := ps.Src.NextTokenPos(ktpos.Start)
                if !ok {
                        return false
                }
                prevAny := false
                for ri := 0; ri < nf; ri++ {
                        rr := pr.ExclFwd[ri]
                        kt := rr.Token
                        kt.Depth += scstDepth // always use starting scope depth
                        if kt.Token == token.None {
                                prevAny = true // wild card
                                continue
                        }
                        if prevAny {
                                creg := scope
                                creg.Start = cp
                                pos, ok := ps.FindToken(kt, creg)
                                if !ok {
                                        return false
                                }
                                cp = pos
                        } else {
                                if !ps.MatchToken(kt, cp) {
                                        if !rr.Opt {
                                                return false
                                        }
                                        lx := ps.Src.LexAt(cp)
                                        if lx.Token.Depth != kt.Depth {
                                                break
                                        }
                                        // ok, keep going -- no info..
                                }
                        }
                        cp, ok = ps.Src.NextTokenPos(cp)
                        if !ok && ri < nf-1 {
                                return false
                        }
                        if scope.End == cp || scope.End.IsLess(cp) { // out of scope -- if non-opt left, nomatch
                                ri++
                                for ; ri < nf; ri++ {
                                        rr := pr.ExclFwd[ri]
                                        if !rr.Opt {
                                                return false
                                        }
                                }
                                break
                        }
                        prevAny = false
                }
        }
        if nr > 0 {
                cp, ok := ps.Src.PrevTokenPos(ktpos.Start)
                if !ok {
                        return false
                }
                prevAny := false
                for ri := nr - 1; ri >= 0; ri-- {
                        rr := pr.ExclRev[ri]
                        kt := rr.Token
                        kt.Depth += scstDepth // always use starting scope depth
                        if kt.Token == token.None {
                                prevAny = true // wild card
                                continue
                        }
                        if prevAny {
                                creg := scope
                                creg.End = cp
                                pos, ok := ps.FindTokenReverse(kt, creg)
                                if !ok {
                                        return false
                                }
                                cp = pos
                        } else {
                                if !ps.MatchToken(kt, cp) {
                                        if !rr.Opt {
                                                return false
                                        }
                                        lx := ps.Src.LexAt(cp)
                                        if lx.Token.Depth != kt.Depth {
                                                break
                                        }
                                        // ok, keep going -- no info..
                                }
                        }
                        cp, ok = ps.Src.PrevTokenPos(cp)
                        if !ok && ri > 0 {
                                return false
                        }
                        if cp.IsLess(scope.Start) {
                                ri--
                                for ; ri >= 0; ri-- {
                                        rr := pr.ExclRev[ri]
                                        if !rr.Opt {
                                                return false
                                        }
                                }
                                break
                        }
                        prevAny = false
                }
        }
        return true
}

// DoRules after we have matched, goes through rest of the rules -- returns false if
// there were any issues encountered
func (pr *Rule) DoRules(ps *State, parent *Rule, parentAST *AST, scope textpos.Region, mpos Matches, optMap lexer.TokenMap, depth int) bool {
        trcAST := parentAST
        var ourAST *AST
        anchorFirst := (pr.AST == AnchorFirstAST && parentAST.Name != pr.Name)

        if pr.AST != NoAST {
                // prf := profile.Start("AddAST")
                ourAST = ps.AddAST(parentAST, pr.Name, scope)
                // prf.End()
                trcAST = ourAST
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, Run, scope.Start, scope, trcAST, fmt.Sprintf("running with new ast: %v", trcAST.Path()))
                }
        } else {
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, Run, scope.Start, scope, trcAST, fmt.Sprintf("running with parent ast: %v", trcAST.Path()))
                }
        }

        if pr.reverse {
                return pr.DoRulesRevBinExp(ps, parent, parentAST, scope, mpos, ourAST, optMap, depth)
        }

        nr := len(pr.Rules)
        valid := true
        creg := scope
        for ri := 0; ri < nr; ri++ {
                pr.DoActs(ps, ri, parent, ourAST, parentAST)
                rr := &pr.Rules[ri]
                if rr.IsToken() && !rr.Opt {
                        mp := mpos[ri].Start
                        if mp == ps.Pos {
                                ps.Pos, _ = ps.Src.NextTokenPos(ps.Pos) // already matched -- move past
                                if ps.Trace.On {
                                        ps.Trace.Out(ps, pr, Run, mp, scope, trcAST, fmt.Sprintf("%v: token at expected pos: %v", ri, rr.Token))
                                }
                        } else if mp.IsLess(ps.Pos) {
                                // ps.Pos has moved beyond our expected token -- sub-rule has eaten more than expected!
                                if rr.Token.Token == token.EOS {
                                        if ps.Trace.On {
                                                ps.Trace.Out(ps, pr, Run, mp, scope, trcAST, fmt.Sprintf("%v: EOS token consumed by sub-rule: %v", ri, rr.Token))
                                        }
                                } else {
                                        ps.Error(mp, fmt.Sprintf("expected token: %v (at rule index: %v) was consumed by prior sub-rule(s)", rr.Token, ri), pr)
                                }
                        } else if ri == nr-1 && rr.Token.Token == token.EOS {
                                ps.ResetNonMatches() // passed this chunk of inputs -- don't need those nonmatches
                        } else {
                                ps.Error(mp, fmt.Sprintf("token: %v (at rule index: %v) has extra preceding input inconsistent with grammar", rr.Token, ri), pr)
                                ps.Pos, _ = ps.Src.NextTokenPos(mp) // move to token for more robustness
                        }
                        if ourAST != nil {
                                ourAST.SetTokRegEnd(ps.Pos, ps.Src) // update our end to any tokens that match
                        }
                        continue
                }
                creg.Start = ps.Pos
                creg.End = scope.End
                if !pr.noTokens {
                        for mi := ri + 1; mi < nr; mi++ {
                                if mpos[mi].Start != textpos.PosZero {
                                        creg.End = mpos[mi].Start // only look up to point of next matching token
                                        break
                                }
                        }
                }
                if rr.IsToken() { // opt by definition here
                        if creg.IsNil() { // no tokens left..
                                if ps.Trace.On {
                                        ps.Trace.Out(ps, pr, Run, creg.Start, scope, trcAST, fmt.Sprintf("%v: opt token: %v no more src", ri, rr.Token))
                                }
                                continue
                        }
                        stlx := ps.Src.LexAt(creg.Start)
                        kt := rr.Token
                        kt.Depth += stlx.Token.Depth
                        pos, ok := ps.FindToken(kt, creg)
                        if !ok {
                                if ps.Trace.On {
                                        ps.Trace.Out(ps, pr, NoMatch, creg.Start, creg, parentAST, fmt.Sprintf("%v token: %v", ri, kt.String()))
                                }
                                continue
                        }
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, Match, pos, creg, parentAST, fmt.Sprintf("%v token: %v", ri, kt))
                        }
                        ps.Pos, _ = ps.Src.NextTokenPos(pos)
                        continue
                }

                ////////////////////////////////////////////////////
                //  Below here is a Sub-Rule

                if creg.IsNil() { // no tokens left..
                        if rr.Opt {
                                if ps.Trace.On {
                                        ps.Trace.Out(ps, pr, Run, creg.Start, scope, trcAST, fmt.Sprintf("%v: opt rule: %v no more src", ri, rr.Rule.Name))
                                }
                                continue
                        }
                        ps.Error(creg.Start, fmt.Sprintf("missing expected input for: %v", rr.Rule.Name), pr)
                        valid = false
                        break // no point in continuing
                }
                useAST := parentAST
                if pr.AST == AnchorAST || anchorFirst || (pr.AST == SubAST && ri < nr-1) {
                        useAST = ourAST
                }
                // NOTE: we can't use anything about the previous match here, because it could have
                // come from a sub-sub-rule and in any case is not where you want to start
                // because is could have been a token in the middle.
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, Run, creg.Start, creg, trcAST, fmt.Sprintf("%v: trying rule: %v", ri, rr.Rule.Name))
                }
                subm := rr.Rule.Parse(ps, pr, useAST, creg, optMap, depth+1)
                if subm == nil {
                        if !rr.Opt {
                                ps.Error(creg.Start, fmt.Sprintf("required element: %v did not match input", rr.Rule.Name), pr)
                                valid = false
                                break
                        }
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, Run, creg.Start, creg, trcAST, fmt.Sprintf("%v: optional rule: %v failed", ri, rr.Rule.Name))
                        }
                }
                if !rr.Opt && ourAST != nil {
                        ourAST.SetTokRegEnd(ps.Pos, ps.Src) // update our end to include non-optional elements
                }
        }
        if valid {
                pr.DoActs(ps, -1, parent, ourAST, parentAST)
        }
        return valid
}

// DoRulesRevBinExp reverse version of do rules for binary expression rule with
// one key token in the middle -- we just pay attention to scoping rest of sub-rules
// relative to that, and don't otherwise adjust scope or position.  In particular all
// the position updating taking place in sup-rules is then just ignored and we set the
// position to the end position matched by the "last" rule (which was the first processed)
func (pr *Rule) DoRulesRevBinExp(ps *State, parent *Rule, parentAST *AST, scope textpos.Region, mpos Matches, ourAST *AST, optMap lexer.TokenMap, depth int) bool {
        nr := len(pr.Rules)
        valid := true
        creg := scope

        trcAST := parentAST
        if ourAST != nil {
                trcAST = ourAST
        }
        tokpos := mpos[1].Start
        aftMpos, ok := ps.Src.NextTokenPos(tokpos)
        if !ok {
                ps.Error(tokpos, "premature end of input", pr)
                return false
        }

        epos := scope.End
        for i := nr - 1; i >= 0; i-- {
                rr := &pr.Rules[i]
                if i > 1 {
                        creg.Start = aftMpos // end expr is in region from key token to end of scope
                        ps.Pos = creg.Start  // only works for a single rule after key token -- sub-rules not necc reverse
                        creg.End = scope.End
                } else if i == 1 {
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, Run, tokpos, scope, trcAST, fmt.Sprintf("%v: key token: %v", i, rr.Token))
                        }
                        continue
                } else { // start
                        creg.Start = scope.Start
                        ps.Pos = creg.Start
                        creg.End = tokpos
                }
                if rr.IsRule() { // non-key tokens ignored
                        if creg.IsNil() { // no tokens left..
                                ps.Error(creg.Start, fmt.Sprintf("missing expected input for: %v", rr.Rule.Name), pr)
                                valid = false
                                continue
                        }
                        useAST := parentAST
                        if pr.AST == AnchorAST {
                                useAST = ourAST
                        }
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, Run, creg.Start, creg, trcAST, fmt.Sprintf("%v: trying rule: %v", i, rr.Rule.Name))
                        }
                        subm := rr.Rule.Parse(ps, pr, useAST, creg, optMap, depth+1)
                        if subm == nil {
                                if !rr.Opt {
                                        ps.Error(creg.Start, fmt.Sprintf("required element: %v did not match input", rr.Rule.Name), pr)
                                        valid = false
                                }
                        }
                }
        }
        // our AST is now backwards -- need to swap them
        if len(ourAST.Children) == 2 {
                slicesx.Swap(ourAST.Children, 0, 1)
                // if GuiActive {
                // we have a very strange situation here: the tree of the AST will typically
                // have two children, named identically (e.g., Expr, Expr) and it will not update
                // after our swap.  If we could use UniqNames then it would be ok, but that doesn't
                // work for tree names.. really need an option that supports uniqname AND reg names
                // https://cogentcore.org/core/ki/issues/2
                // ourAST.NewChild(ASTType, "Dummy")
                // ourAST.DeleteChildAt(2, true)
                // }
        }

        ps.Pos = epos
        return valid
}

// DoActs performs actions at given point in rule execution (ri = rule index, is -1 at end)
func (pr *Rule) DoActs(ps *State, ri int, parent *Rule, ourAST, parentAST *AST) bool {
        if len(pr.Acts) == 0 {
                return false
        }
        // prf := profile.Start("DoActs")
        // defer prf.End()
        valid := true
        for ai := range pr.Acts {
                act := &pr.Acts[ai]
                if act.RunIndex != ri {
                        continue
                }
                if !pr.DoAct(ps, act, parent, ourAST, parentAST) {
                        valid = false
                }
        }
        return valid
}

// DoAct performs one action after a rule executes
func (pr *Rule) DoAct(ps *State, act *Act, parent *Rule, ourAST, parAST *AST) bool {
        if act.Act == PushStack {
                ps.Stack.Push(act.Path)
                return true
        } else if act.Act == PopStack {
                ps.Stack.Pop()
                return true
        }

        useAST := ourAST
        if useAST == nil {
                useAST = parAST
        }
        apath := useAST.Path()
        var node tree.Node
        var adnl []tree.Node // additional nodes
        if act.Path == "" {
                node = useAST
        } else if andidx := strings.Index(act.Path, "&"); andidx >= 0 {
                pths := strings.Split(act.Path, "&")
                for _, p := range pths {
                        findAll := false
                        if strings.HasSuffix(p, "...") {
                                findAll = true
                                p = strings.TrimSuffix(p, "...")
                        }
                        var nd tree.Node
                        if p[:3] == "../" {
                                nd = parAST.FindPath(p[3:])
                        } else {
                                nd = useAST.FindPath(p)
                        }
                        if nd != nil {
                                if node == nil {
                                        node = nd
                                }
                                if findAll {
                                        pn := nd.AsTree().Parent
                                        for _, pk := range pn.AsTree().Children {
                                                if pk != nd && pk.AsTree().Name == nd.AsTree().Name {
                                                        adnl = append(adnl, pk)
                                                }
                                        }
                                } else if node != nd {
                                        adnl = append(adnl, nd)
                                }
                        }
                }
        } else {
                pths := strings.Split(act.Path, "|")
                for _, p := range pths {
                        findAll := false
                        if strings.HasSuffix(p, "...") {
                                findAll = true
                                p = strings.TrimSuffix(p, "...")
                        }
                        if p[:3] == "../" {
                                node = parAST.FindPath(p[3:])
                        } else {
                                node = useAST.FindPath(p)
                        }
                        if node != nil {
                                if findAll {
                                        pn := node.AsTree().Parent
                                        for _, pk := range pn.AsTree().Children {
                                                if pk != node && pk.AsTree().Name == node.AsTree().Name {
                                                        adnl = append(adnl, pk)
                                                }
                                        }
                                }
                                break
                        }
                }
        }
        if node == nil {
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, RunAct, ps.Pos, textpos.RegionZero, useAST, fmt.Sprintf("Act %v: ERROR: node not found at path(s): %v in node: %v", act.Act, act.Path, apath))
                }
                return false
        }
        ast := node.(*AST)
        lx := ps.Src.LexAt(ast.TokReg.Start)
        useTok := lx.Token.Token
        if act.Token != token.None {
                useTok = act.Token
        }
        nm := ast.Src
        nms := strings.Split(nm, ",")
        if len(adnl) > 0 {
                for _, pk := range adnl {
                        nast := pk.(*AST)
                        if nast != ast {
                                nms = append(nms, strings.Split(nast.Src, ",")...)
                        }
                }
        }
        for i := range nms {
                nms[i] = strings.TrimSpace(nms[i])
        }
        switch act.Act {
        case ChangeToken:
                cp := ast.TokReg.Start
                for cp.IsLess(ast.TokReg.End) {
                        tlx := ps.Src.LexAt(cp)
                        act.ChangeToken(tlx)
                        cp, _ = ps.Src.NextTokenPos(cp)
                }
                if len(adnl) > 0 {
                        for _, pk := range adnl {
                                nast := pk.(*AST)
                                cp := nast.TokReg.Start
                                for cp.IsLess(nast.TokReg.End) {
                                        tlx := ps.Src.LexAt(cp)
                                        act.ChangeToken(tlx)
                                        cp, _ = ps.Src.NextTokenPos(cp)
                                }
                        }
                }
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Token set to: %v from path: %v = %v in node: %v", act.Token, act.Path, nm, apath))
                }
                return false
        case AddSymbol:
                for i := range nms {
                        n := nms[i]
                        if n == "" || n == "_" { // go special case..
                                continue
                        }
                        sy, has := ps.FindNameTopScope(n) // only look in top scope
                        added := false
                        if has {
                                sy.Region = ast.SrcReg
                                sy.Kind = useTok
                                if ps.Trace.On {
                                        ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Add sym already exists: %v from path: %v = %v in node: %v", sy.String(), act.Path, n, apath))
                                }
                        } else {
                                sy = syms.NewSymbol(n, useTok, ps.Src.Filename, ast.SrcReg)
                                added = sy.AddScopesStack(ps.Scopes)
                                if !added {
                                        ps.Syms.Add(sy)
                                }
                        }
                        useAST.Syms.Push(sy)
                        sy.AST = useAST.This
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Added sym: %v from path: %v = %v in node: %v", sy.String(), act.Path, n, apath))
                        }
                }
        case PushScope:
                sy, has := ps.FindNameTopScope(nm) // Scoped(nm)
                if !has {
                        sy = syms.NewSymbol(nm, useTok, ps.Src.Filename, ast.SrcReg) // textpos.RegionZero) // zero = tmp
                        added := sy.AddScopesStack(ps.Scopes)
                        if !added {
                                ps.Syms.Add(sy)
                        }
                }
                ps.Scopes.Push(sy)
                useAST.Syms.Push(sy)
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Pushed Sym: %v from path: %v = %v in node: %v", sy.String(), act.Path, nm, apath))
                }
        case PushNewScope:
                // add plus push
                sy, has := ps.FindNameTopScope(nm) // Scoped(nm)
                if has {
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Push New sym already exists: %v from path: %v = %v in node: %v", sy.String(), act.Path, nm, apath))
                        }
                } else {
                        sy = syms.NewSymbol(nm, useTok, ps.Src.Filename, ast.SrcReg)
                        added := sy.AddScopesStack(ps.Scopes)
                        if !added {
                                ps.Syms.Add(sy)
                        }
                }
                ps.Scopes.Push(sy) // key diff from add..
                useAST.Syms.Push(sy)
                sy.AST = useAST.This
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Pushed New Sym: %v from path: %v = %v in node: %v", sy.String(), act.Path, nm, apath))
                }
        case PopScope:
                sy := ps.Scopes.Pop()
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Popped Sym: %v in node: %v", sy.String(), apath))
                }
        case PopScopeReg:
                sy := ps.Scopes.Pop()
                sy.Region = ast.SrcReg // update source region to final -- select remains initial trigger one
                if ps.Trace.On {
                        ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Popped Sym: %v in node: %v", sy.String(), apath))
                }
        case AddDetail:
                sy := useAST.Syms.Top()
                if sy != nil {
                        if sy.Detail == "" {
                                sy.Detail = nm
                        } else {
                                sy.Detail += " " + nm
                        }
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Added Detail: %v to Sym: %v in node: %v", nm, sy.String(), apath))
                        }
                } else {
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Add Detail: %v ERROR -- symbol not found in node: %v", nm, apath))
                        }
                }
        case AddType:
                scp := ps.Scopes.Top()
                if scp == nil {
                        ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Add Type: %v ERROR -- requires current scope -- none set in node: %v", nm, apath))
                        return false
                }
                for i := range nms {
                        n := nms[i]
                        if n == "" || n == "_" { // go special case..
                                continue
                        }
                        ty := syms.NewType(n, syms.Unknown)
                        ty.Filename = ps.Src.Filename
                        ty.Region = ast.SrcReg
                        ty.AST = useAST.This
                        ty.AddScopesStack(ps.Scopes)
                        scp.Types.Add(ty)
                        if ps.Trace.On {
                                ps.Trace.Out(ps, pr, RunAct, ast.TokReg.Start, ast.TokReg, ast, fmt.Sprintf("Act: Added type: %v from path: %v = %v in node: %v", ty.String(), act.Path, n, apath))
                        }
                }
        }
        return true
}

///////////////////////////////////////////////////////////////////////
//  Non-parsing functions

// Find looks for rules in the tree that contain given string in Rule or Name fields
func (pr *Rule) Find(find string) []*Rule {
        var res []*Rule
        pr.WalkDown(func(k tree.Node) bool {
                pri := k.(*Rule)
                if strings.Contains(pri.Rule, find) || strings.Contains(pri.Name, find) {
                        res = append(res, pri)
                }
                return true
        })
        return res
}

// WriteGrammar outputs the parser rules as a formatted grammar in a BNF-like format
// it is called recursively
func (pr *Rule) WriteGrammar(writer io.Writer, depth int) {
        if tree.IsRoot(pr) {
                for _, k := range pr.Children {
                        pri := k.(*Rule)
                        pri.WriteGrammar(writer, depth)
                }
        } else {
                ind := indent.Tabs(depth)
                nmstr := pr.Name
                if pr.Off {
                        nmstr = "// OFF: " + nmstr
                }
                if pr.Desc != "" {
                        fmt.Fprintf(writer, "%v// %v %v \n", ind, nmstr, pr.Desc)
                }
                if pr.IsGroup() {
                        fmt.Fprintf(writer, "%v%v {\n", ind, nmstr)
                        w := tabwriter.NewWriter(writer, 4, 4, 2, ' ', 0)
                        for _, k := range pr.Children {
                                pri := k.(*Rule)
                                pri.WriteGrammar(w, depth+1)
                        }
                        w.Flush()
                        fmt.Fprintf(writer, "%v}\n", ind)
                } else {
                        astr := ""
                        switch pr.AST {
                        case AddAST:
                                astr = "+AST"
                        case SubAST:
                                astr = "_AST"
                        case AnchorAST:
                                astr = ">AST"
                        case AnchorFirstAST:
                                astr = ">1AST"
                        }
                        fmt.Fprintf(writer, "%v%v:\t%v\t%v\n", ind, nmstr, pr.Rule, astr)
                        if len(pr.Acts) > 0 {
                                fmt.Fprintf(writer, "%v--->Acts:%v\n", ind, pr.Acts.String())
                        }
                }
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package parser

import (
        "fmt"

        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/parse/syms"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// parser.State is the state maintained for parsing
type State struct {

        // source and lexed version of source we're parsing
        Src *lexer.File `display:"no-inline"`

        // tracing for this parser
        Trace TraceOptions

        // root of the AST abstract syntax tree we're updating
        AST *AST

        // symbol map that everything gets added to from current file of parsing -- typically best for subsequent management to just have a single outer-most scoping symbol here (e.g., in Go it is the package), and then everything is a child under that
        Syms syms.SymMap

        // stack of scope(s) added to FileSyms e.g., package, library, module-level elements of which this file is a part -- these are reset at the start and must be added by parsing actions within the file itself
        Scopes syms.SymStack

        // the current lex token position
        Pos textpos.Pos

        // any error messages accumulated during parsing specifically
        Errs lexer.ErrorList `display:"no-inline"`

        // rules that matched and ran at each point, in 1-to-1 correspondence with the Src.Lex tokens for the lines and char pos dims
        Matches [][]MatchStack `display:"no-inline"`

        // rules that did NOT match -- represented as a map by scope of a RuleSet
        NonMatches ScopeRuleSet `display:"no-inline"`

        // stack for context-sensitive rules
        Stack lexer.Stack `display:"no-inline"`
}

// Init initializes the state at start of parsing
func (ps *State) Init(src *lexer.File, ast *AST) {
        // fmt.Println("in init")
        // if ps.Src != nil {
        //         fmt.Println("was:", ps.Src.Filename)
        // }
        // if src != nil {
        //         fmt.Println("new:", src.Filename)
        // }
        ps.Src = src
        if ps.AST != nil && ps.AST.This != nil {
                // fmt.Println("deleting old ast")
                ps.AST.DeleteChildren()
        }
        ps.AST = ast
        if ps.AST != nil && ps.AST.This != nil {
                // fmt.Println("deleting new ast")
                ps.AST.DeleteChildren()
        }
        ps.ClearAST()
        ps.Syms.Reset()
        ps.Scopes.Reset()
        ps.Stack.Reset()
        if ps.Src != nil {
                ps.Pos, _ = ps.Src.ValidTokenPos(textpos.PosZero)
        }
        ps.Errs.Reset()
        ps.Trace.Init()
        ps.AllocRules()
}

func (ps *State) ClearAST() {
        ps.Syms.ClearAST()
        ps.Scopes.ClearAST()
}

func (ps *State) Destroy() {
        if ps.AST != nil && ps.AST.This != nil {
                ps.AST.DeleteChildren()
        }
        ps.AST = nil
        ps.ClearAST()
        ps.Syms.Reset()
        ps.Scopes.Reset()
        ps.Stack.Reset()
        if ps.Src != nil {
                ps.Pos, _ = ps.Src.ValidTokenPos(textpos.PosZero)
        }
        ps.Errs.Reset()
        ps.Trace.Init()
}

// AllocRules allocate the match, nonmatch rule state in correspondence with the src state
func (ps *State) AllocRules() {
        nlines := ps.Src.NLines()
        if nlines == 0 {
                return
        }
        if len(ps.Src.Lexs) != nlines {
                return
        }
        ps.Matches = make([][]MatchStack, nlines)
        ntot := 0
        for ln := 0; ln < nlines; ln++ {
                sz := len(ps.Src.Lexs[ln])
                if sz > 0 {
                        ps.Matches[ln] = make([]MatchStack, sz)
                        ntot += sz
                }
        }
        ps.NonMatches = make(ScopeRuleSet, ntot*10)
}

// Error adds a parsing error at given lex token position
func (ps *State) Error(pos textpos.Pos, msg string, rule *Rule) {
        if pos != textpos.PosZero {
                pos = ps.Src.TokenSrcPos(pos).Start
        }
        e := ps.Errs.Add(pos, ps.Src.Filename, msg, ps.Src.SrcLine(pos.Line), rule)
        if GUIActive {
                erstr := e.Report(ps.Src.BasePath, true, true)
                fmt.Fprintln(ps.Trace.OutWrite, "ERROR: "+erstr)
        }
}

// AtEof returns true if current position is at end of file -- this includes
// common situation where it is just at the very last token
func (ps *State) AtEof() bool {
        if ps.Pos.Line >= ps.Src.NLines() {
                return true
        }
        _, ok := ps.Src.ValidTokenPos(ps.Pos)
        return !ok
}

// AtEofNext returns true if current OR NEXT position is at end of file -- this includes
// common situation where it is just at the very last token
func (ps *State) AtEofNext() bool {
        if ps.AtEof() {
                return true
        }
        return ps.Pos.Line == ps.Src.NLines()-1
}

// GotoEof sets current position at EOF
func (ps *State) GotoEof() {
        ps.Pos.Line = ps.Src.NLines()
        ps.Pos.Char = 0
}

// NextSrcLine returns the next line of text
func (ps *State) NextSrcLine() string {
        sp, ok := ps.Src.ValidTokenPos(ps.Pos)
        if !ok {
                return ""
        }
        ep := sp
        ep.Char = ps.Src.NTokens(ep.Line)
        if ep.Char == sp.Char+1 { // only one
                nep, ok := ps.Src.ValidTokenPos(ep)
                if ok {
                        ep = nep
                        ep.Char = ps.Src.NTokens(ep.Line)
                }
        }
        reg := textpos.Region{Start: sp, End: ep}
        return ps.Src.TokenRegSrc(reg)
}

// MatchLex is our optimized matcher method, matching tkey depth as well
func (ps *State) MatchLex(lx *lexer.Lex, tkey token.KeyToken, isCat, isSubCat bool, cp textpos.Pos) bool {
        if lx.Token.Depth != tkey.Depth {
                return false
        }
        if !(lx.Token.Token == tkey.Token || (isCat && lx.Token.Token.Cat() == tkey.Token) || (isSubCat && lx.Token.Token.SubCat() == tkey.Token)) {
                return false
        }
        if tkey.Key == "" {
                return true
        }
        return tkey.Key == lx.Token.Key
}

// FindToken looks for token in given region, returns position where found, false if not.
// Only matches when depth is same as at reg.Start start at the start of the search.
// All positions in token indexes.
func (ps *State) FindToken(tkey token.KeyToken, reg textpos.Region) (textpos.Pos, bool) {
        // prf := profile.Start("FindToken")
        // defer prf.End()
        cp, ok := ps.Src.ValidTokenPos(reg.Start)
        if !ok {
                return cp, false
        }
        tok := tkey.Token
        isCat := tok.Cat() == tok
        isSubCat := tok.SubCat() == tok
        for cp.IsLess(reg.End) {
                lx := ps.Src.LexAt(cp)
                if ps.MatchLex(lx, tkey, isCat, isSubCat, cp) {
                        return cp, true
                }
                cp, ok = ps.Src.NextTokenPos(cp)
                if !ok {
                        return cp, false
                }
        }
        return cp, false
}

// MatchToken returns true if token matches at given position -- must be
// a valid position!
func (ps *State) MatchToken(tkey token.KeyToken, pos textpos.Pos) bool {
        tok := tkey.Token
        isCat := tok.Cat() == tok
        isSubCat := tok.SubCat() == tok
        lx := ps.Src.LexAt(pos)
        tkey.Depth = lx.Token.Depth
        return ps.MatchLex(lx, tkey, isCat, isSubCat, pos)
}

// FindTokenReverse looks *backwards* for token in given region, with same depth as reg.End-1 end
// where the search starts. Returns position where found, false if not.
// Automatically deals with possible confusion with unary operators -- if there are two
// ambiguous operators in a row, automatically gets the first one.  This is mainly / only used for
// binary operator expressions (mathematical binary operators).
// All positions are in token indexes.
func (ps *State) FindTokenReverse(tkey token.KeyToken, reg textpos.Region) (textpos.Pos, bool) {
        // prf := profile.Start("FindTokenReverse")
        // defer prf.End()
        cp, ok := ps.Src.PrevTokenPos(reg.End)
        if !ok {
                return cp, false
        }
        tok := tkey.Token
        isCat := tok.Cat() == tok
        isSubCat := tok.SubCat() == tok
        isAmbigUnary := tok.IsAmbigUnaryOp()
        for reg.Start.IsLess(cp) || cp == reg.Start {
                lx := ps.Src.LexAt(cp)
                if ps.MatchLex(lx, tkey, isCat, isSubCat, cp) {
                        if isAmbigUnary { // make sure immed prior is not also!
                                pp, ok := ps.Src.PrevTokenPos(cp)
                                if ok {
                                        pt := ps.Src.Token(pp)
                                        if tok == token.OpMathMul {
                                                if !pt.Token.IsUnaryOp() {
                                                        return cp, true
                                                }
                                        } else {
                                                if !pt.Token.IsAmbigUnaryOp() {
                                                        return cp, true
                                                }
                                        }
                                        // otherwise we don't match -- cannot match second opr
                                } else {
                                        return cp, true
                                }
                        } else {
                                return cp, true
                        }
                }
                ok := false
                cp, ok = ps.Src.PrevTokenPos(cp)
                if !ok {
                        return cp, false
                }
        }
        return cp, false
}

// AddAST adds a child AST node to given parent AST node
func (ps *State) AddAST(parAST *AST, rule string, reg textpos.Region) *AST {
        chAST := NewAST(parAST)
        chAST.SetName(rule)
        chAST.SetTokReg(reg, ps.Src)
        return chAST
}

///////////////////////////////////////////////////////////////////////////
//  Match State, Stack

// MatchState holds state info for rules that matched, recorded at starting position of match
type MatchState struct {

        // rule that either matched or ran here
        Rule *Rule

        // scope for match
        Scope textpos.Region

        // regions of match for each sub-region
        Regs Matches
}

// String is fmt.Stringer
func (rs MatchState) String() string {
        if rs.Rule == nil {
                return ""
        }
        return fmt.Sprintf("%v%v", rs.Rule.Name, rs.Scope)
}

// MatchStack is the stack of rules that matched or ran for each token point
type MatchStack []MatchState

// Add given rule to stack
func (rs *MatchStack) Add(pr *Rule, scope textpos.Region, regs Matches) {
        *rs = append(*rs, MatchState{Rule: pr, Scope: scope, Regs: regs})
}

// Find looks for given rule and scope on the stack
func (rs *MatchStack) Find(pr *Rule, scope textpos.Region) (*MatchState, bool) {
        for i := range *rs {
                r := &(*rs)[i]
                if r.Rule == pr && r.Scope == scope {
                        return r, true
                }
        }
        return nil, false
}

// AddMatch adds given rule to rule stack at given scope
func (ps *State) AddMatch(pr *Rule, scope textpos.Region, regs Matches) {
        rs := &ps.Matches[scope.Start.Line][scope.Start.Char]
        rs.Add(pr, scope, regs)
}

// IsMatch looks for rule at given scope in list of matches, if found
// returns match state info
func (ps *State) IsMatch(pr *Rule, scope textpos.Region) (*MatchState, bool) {
        rs := &ps.Matches[scope.Start.Line][scope.Start.Char]
        sz := len(*rs)
        if sz == 0 {
                return nil, false
        }
        return rs.Find(pr, scope)
}

// RuleString returns the rule info for entire source -- if full
// then it includes the full stack at each point -- otherwise just the top
// of stack
func (ps *State) RuleString(full bool) string {
        txt := ""
        nlines := ps.Src.NLines()
        for ln := 0; ln < nlines; ln++ {
                sz := len(ps.Matches[ln])
                if sz == 0 {
                        txt += "\n"
                } else {
                        for ch := 0; ch < sz; ch++ {
                                rs := ps.Matches[ln][ch]
                                sd := len(rs)
                                txt += ` "` + string(ps.Src.TokenSrc(textpos.Pos{ln, ch})) + `"`
                                if sd == 0 {
                                        txt += "-"
                                } else {
                                        if !full {
                                                txt += rs[sd-1].String()
                                        } else {
                                                txt += fmt.Sprintf("[%v: ", sd)
                                                for i := 0; i < sd; i++ {
                                                        txt += rs[i].String()
                                                }
                                                txt += "]"
                                        }
                                }
                        }
                        txt += "\n"
                }
        }
        return txt
}

///////////////////////////////////////////////////////////////////////////
//  ScopeRuleSet and NonMatch

// ScopeRule is a scope and a rule, for storing matches / nonmatch
type ScopeRule struct {
        Scope textpos.Region
        Rule  *Rule
}

// ScopeRuleSet is a map by scope of RuleSets, for non-matching rules
type ScopeRuleSet map[ScopeRule]struct{}

// Add a rule to scope set, with auto-alloc
func (rs ScopeRuleSet) Add(scope textpos.Region, pr *Rule) {
        sr := ScopeRule{scope, pr}
        rs[sr] = struct{}{}
}

// Has checks if scope rule set has given scope, rule
func (rs ScopeRuleSet) Has(scope textpos.Region, pr *Rule) bool {
        sr := ScopeRule{scope, pr}
        _, has := rs[sr]
        return has
}

// AddNonMatch adds given rule to non-matching rule set for this scope
func (ps *State) AddNonMatch(scope textpos.Region, pr *Rule) {
        ps.NonMatches.Add(scope, pr)
}

// IsNonMatch looks for rule in nonmatch list at given scope
func (ps *State) IsNonMatch(scope textpos.Region, pr *Rule) bool {
        return ps.NonMatches.Has(scope, pr)
}

// ResetNonMatches resets the non-match map -- do after every EOS
func (ps *State) ResetNonMatches() {
        ps.NonMatches = make(ScopeRuleSet)
}

///////////////////////////////////////////////////////////////////////////
//  Symbol management

// FindNameScoped searches top-down in the stack for something with the given name
// in symbols that are of subcategory token.NameScope (i.e., namespace, module, package, library)
// also looks in ps.Syms if not found in Scope stack.
func (ps *State) FindNameScoped(nm string) (*syms.Symbol, bool) {
        sy, has := ps.Scopes.FindNameScoped(nm)
        if has {
                return sy, has
        }
        return ps.Syms.FindNameScoped(nm)
}

// FindNameTopScope searches only in top of current scope for something
// with the given name in symbols
// also looks in ps.Syms if not found in Scope stack.
func (ps *State) FindNameTopScope(nm string) (*syms.Symbol, bool) {
        sy := ps.Scopes.Top()
        if sy == nil {
                return nil, false
        }
        chs, has := sy.Children[nm]
        return chs, has
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package parser

import (
        "fmt"
        "os"
        "strings"

        "cogentcore.org/core/text/textpos"
)

// TraceOptions provides options for debugging / monitoring the rule matching and execution process
type TraceOptions struct {

        // perform tracing
        On bool

        // trace specific named rules here (space separated) -- if blank, then all rules are traced
        Rules string `width:"50"`

        // trace full rule matches -- when a rule fully matches
        Match bool

        // trace sub-rule matches -- when the parts of each rule match
        SubMatch bool

        // trace sub-rule non-matches -- why a rule doesn't match -- which terminates the matching process at first non-match (can be a lot of info)
        NoMatch bool

        // trace progress running through each of the sub-rules when a rule has matched and is 'running'
        Run bool

        // trace actions performed by running rules
        RunAct bool

        // if true, shows the full scope source for every trace statement
        ScopeSrc bool

        // for the ParseOut display, whether to display the full stack of rules at each position, or just the deepest one
        FullStackOut bool

        // list of rules
        RulesList []string `display:"-" json:"-" xml:"-"`

        // trace output is written here, connected via os.Pipe to OutRead
        OutWrite *os.File `display:"-" json:"-" xml:"-"`

        // trace output is read here; can connect this using [textcore.OutputBuffer] to monitor tracing output
        OutRead *os.File `display:"-" json:"-" xml:"-"`
}

// Init intializes tracer after any changes -- opens pipe if not already open
func (pt *TraceOptions) Init() {
        if pt.Rules == "" {
                pt.RulesList = nil
        } else {
                pt.RulesList = strings.Split(pt.Rules, " ")
        }
}

// FullOn sets all options on
func (pt *TraceOptions) FullOn() {
        pt.On = true
        pt.Match = true
        pt.SubMatch = true
        pt.NoMatch = true
        pt.Run = true
        pt.RunAct = true
        pt.ScopeSrc = true
}

// PipeOut sets output to a pipe for monitoring (OutWrite -> OutRead)
func (pt *TraceOptions) PipeOut() {
        if pt.OutWrite == nil {
                pt.OutRead, pt.OutWrite, _ = os.Pipe() // seriously, does this ever fail?
        }
}

// Stdout sets [TraceOptions.OutWrite] to [os.Stdout]
func (pt *TraceOptions) Stdout() {
        pt.OutWrite = os.Stdout
}

// CheckRule checks if given rule should be traced
func (pt *TraceOptions) CheckRule(rule string) bool {
        if len(pt.RulesList) == 0 {
                if pt.Rules != "" {
                        pt.Init()
                        if len(pt.RulesList) == 0 {
                                return true
                        }
                } else {
                        return true
                }
        }
        for _, rn := range pt.RulesList {
                if rn == rule {
                        return true
                }
        }
        return false
}

// Out outputs a trace message -- returns true if actually output
func (pt *TraceOptions) Out(ps *State, pr *Rule, step Steps, pos textpos.Pos, scope textpos.Region, ast *AST, msg string) bool {
        if !pt.On {
                return false
        }
        if !pt.CheckRule(pr.Name) {
                return false
        }
        switch step {
        case Match:
                if !pt.Match {
                        return false
                }
        case SubMatch:
                if !pt.SubMatch {
                        return false
                }
        case NoMatch:
                if !pt.NoMatch {
                        return false
                }
        case Run:
                if !pt.Run {
                        return false
                }
        case RunAct:
                if !pt.RunAct {
                        return false
                }
        }
        tokSrc := pos.String() + `"` + string(ps.Src.TokenSrc(pos)) + `"`
        plev := ast.ParentLevel(ps.AST)
        ind := ""
        for i := 0; i < plev; i++ {
                ind += "\t"
        }
        fmt.Fprintf(pt.OutWrite, "%v%v:\t %v\t %v\t tok: %v\t scope: %v\t ast: %v\n", ind, pr.Name, step, msg, tokSrc, scope, ast.Path())
        if pt.ScopeSrc {
                scopeSrc := ps.Src.TokenRegSrc(scope)
                fmt.Fprintf(pt.OutWrite, "%v\t%v\n", ind, scopeSrc)
        }
        return true
}

// CopyOpts copies just the options
func (pt *TraceOptions) CopyOpts(ot *TraceOptions) {
        pt.On = ot.On
        pt.Rules = ot.Rules
        pt.Match = ot.Match
        pt.SubMatch = ot.SubMatch
        pt.NoMatch = ot.NoMatch
        pt.Run = ot.Run
        pt.RunAct = ot.RunAct
        pt.ScopeSrc = ot.ScopeSrc
}

// Steps are the different steps of the parsing processing
type Steps int32 //enums:enum

// The parsing steps
const (
        // Match happens when a rule matches
        Match Steps = iota

        // SubMatch is when a sub-rule within a rule matches
        SubMatch

        // NoMatch is when the rule fails to match (recorded at first non-match, which terminates
        // matching process
        NoMatch

        // Run is when the rule is running and iterating through its sub-rules
        Run

        // RunAct is when the rule is running and performing actions
        RunAct
)

// Code generated by "core generate"; DO NOT EDIT.

package parser

import (
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/parse/parser.AST", IDName: "ast", Doc: "AST is a node in the abstract syntax tree generated by the parsing step\nthe name of the node (from tree.NodeBase) is the type of the element\n(e.g., expr, stmt, etc)\nThese nodes are generated by the parser.Rule's by matching tokens", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "TokReg", Doc: "region in source lexical tokens corresponding to this AST node -- Ch = index in lex lines"}, {Name: "SrcReg", Doc: "region in source file corresponding to this AST node"}, {Name: "Src", Doc: "source code corresponding to this AST node"}, {Name: "Syms", Doc: "stack of symbols created for this node"}}})

// NewAST returns a new [AST] with the given optional parent:
// AST is a node in the abstract syntax tree generated by the parsing step
// the name of the node (from tree.NodeBase) is the type of the element
// (e.g., expr, stmt, etc)
// These nodes are generated by the parser.Rule's by matching tokens
func NewAST(parent ...tree.Node) *AST { return tree.New[AST](parent...) }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/parse/parser.Rule", IDName: "rule", Doc: "The first step is matching which searches in order for matches within the\nchildren of parent nodes, and for explicit rule nodes, it looks first\nthrough all the explicit tokens in the rule.  If there are no explicit tokens\nthen matching defers to ONLY the first node listed by default -- you can\nadd a @ prefix to indicate a rule that is also essential to match.\n\nAfter a rule matches, it then proceeds through the rules narrowing the scope\nand calling the sub-nodes..", Embeds: []types.Field{{Name: "NodeBase"}}, Fields: []types.Field{{Name: "Off", Doc: "disable this rule -- useful for testing and exploration"}, {Name: "Desc", Doc: "description / comments about this rule"}, {Name: "Rule", Doc: "the rule as a space-separated list of rule names and token(s) -- use single quotes around 'tokens' (using token.Tokens names or symbols). For keywords use 'key:keyword'.  All tokens are matched at the same nesting depth as the start of the scope of this rule, unless they have a +D relative depth value differential before the token.  Use @ prefix for a sub-rule to require that rule to match -- by default explicit tokens are used if available, and then only the first sub-rule failing that.  Use ! by itself to define start of an exclusionary rule -- doesn't match when those rule elements DO match.  Use : prefix for a special group node that matches a single token at start of scope, and then defers to the child rules to perform full match -- this is used for FirstTokenMap when there are multiple versions of a given keyword rule.  Use - prefix for tokens anchored by the end (next token) instead of the previous one -- typically just for token prior to 'EOS' but also a block of tokens that need to go backward in the middle of a sequence to avoid ambiguity can be marked with -"}, {Name: "StackMatch", Doc: "if present, this rule only fires if stack has this on it"}, {Name: "AST", Doc: "what action should be take for this node when it matches"}, {Name: "Acts", Doc: "actions to perform based on parsed AST tree data, when this rule is done executing"}, {Name: "OptTokenMap", Doc: "for group-level rules having lots of children and lots of recursiveness, and also of high-frequency, when we first encounter such a rule, make a map of all the tokens in the entire scope, and use that for a first-pass rejection on matching tokens"}, {Name: "FirstTokenMap", Doc: "for group-level rules with a number of rules that match based on first tokens / keywords, build map to directly go to that rule -- must also organize all of these rules sequentially from the start -- if no match, goes directly to first non-lookup case"}, {Name: "Rules", Doc: "rule elements compiled from Rule string"}, {Name: "Order", Doc: "strategic matching order for matching the rules"}, {Name: "FiTokenMap", Doc: "map from first tokens / keywords to rules for FirstTokenMap case"}, {Name: "FiTokenElseIndex", Doc: "for FirstTokenMap, the start of the else cases not covered by the map"}, {Name: "ExclKeyIndex", Doc: "exclusionary key index -- this is the token in Rules that we need to exclude matches for using ExclFwd and ExclRev rules"}, {Name: "ExclFwd", Doc: "exclusionary forward-search rule elements compiled from Rule string"}, {Name: "ExclRev", Doc: "exclusionary reverse-search rule elements compiled from Rule string"}, {Name: "setsScope", Doc: "setsScope means that this rule sets its own scope, because it ends with EOS"}, {Name: "reverse", Doc: "reverse means that this rule runs in reverse (starts with - sign) -- for arithmetic\nbinary expressions only: this is needed to produce proper associativity result for\nmathematical expressions in the recursive descent parser.\nOnly for rules of form: Expr '+' Expr -- two sub-rules with a token operator\nin the middle."}, {Name: "noTokens", Doc: "noTokens means that this rule doesn't have any explicit tokens -- only refers to\nother rules"}, {Name: "onlyTokens", Doc: "onlyTokens means that this rule only has explicit tokens for matching -- can be\noptimized"}, {Name: "tokenMatchGroup", Doc: "tokenMatchGroup is a group node that also has a single token match, so it can\nbe used in a FirstTokenMap to optimize lookup of rules"}}})

// NewRule returns a new [Rule] with the given optional parent:
// The first step is matching which searches in order for matches within the
// children of parent nodes, and for explicit rule nodes, it looks first
// through all the explicit tokens in the rule.  If there are no explicit tokens
// then matching defers to ONLY the first node listed by default -- you can
// add a @ prefix to indicate a rule that is also essential to match.
//
// After a rule matches, it then proceeds through the rules narrowing the scope
// and calling the sub-nodes..
func NewRule(parent ...tree.Node) *Rule { return tree.New[Rule](parent...) }

// SetOff sets the [Rule.Off]:
// disable this rule -- useful for testing and exploration
func (t *Rule) SetOff(v bool) *Rule { t.Off = v; return t }

// SetDesc sets the [Rule.Desc]:
// description / comments about this rule
func (t *Rule) SetDesc(v string) *Rule { t.Desc = v; return t }

// SetRule sets the [Rule.Rule]:
// the rule as a space-separated list of rule names and token(s) -- use single quotes around 'tokens' (using token.Tokens names or symbols). For keywords use 'key:keyword'.  All tokens are matched at the same nesting depth as the start of the scope of this rule, unless they have a +D relative depth value differential before the token.  Use @ prefix for a sub-rule to require that rule to match -- by default explicit tokens are used if available, and then only the first sub-rule failing that.  Use ! by itself to define start of an exclusionary rule -- doesn't match when those rule elements DO match.  Use : prefix for a special group node that matches a single token at start of scope, and then defers to the child rules to perform full match -- this is used for FirstTokenMap when there are multiple versions of a given keyword rule.  Use - prefix for tokens anchored by the end (next token) instead of the previous one -- typically just for token prior to 'EOS' but also a block of tokens that need to go backward in the middle of a sequence to avoid ambiguity can be marked with -
func (t *Rule) SetRule(v string) *Rule { t.Rule = v; return t }

// SetStackMatch sets the [Rule.StackMatch]:
// if present, this rule only fires if stack has this on it
func (t *Rule) SetStackMatch(v string) *Rule { t.StackMatch = v; return t }

// SetAST sets the [Rule.AST]:
// what action should be take for this node when it matches
func (t *Rule) SetAST(v ASTActs) *Rule { t.AST = v; return t }

// SetActs sets the [Rule.Acts]:
// actions to perform based on parsed AST tree data, when this rule is done executing
func (t *Rule) SetActs(v Acts) *Rule { t.Acts = v; return t }

// SetOptTokenMap sets the [Rule.OptTokenMap]:
// for group-level rules having lots of children and lots of recursiveness, and also of high-frequency, when we first encounter such a rule, make a map of all the tokens in the entire scope, and use that for a first-pass rejection on matching tokens
func (t *Rule) SetOptTokenMap(v bool) *Rule { t.OptTokenMap = v; return t }

// SetFirstTokenMap sets the [Rule.FirstTokenMap]:
// for group-level rules with a number of rules that match based on first tokens / keywords, build map to directly go to that rule -- must also organize all of these rules sequentially from the start -- if no match, goes directly to first non-lookup case
func (t *Rule) SetFirstTokenMap(v bool) *Rule { t.FirstTokenMap = v; return t }

// SetRules sets the [Rule.Rules]:
// rule elements compiled from Rule string
func (t *Rule) SetRules(v RuleList) *Rule { t.Rules = v; return t }

// SetOrder sets the [Rule.Order]:
// strategic matching order for matching the rules
func (t *Rule) SetOrder(v ...int) *Rule { t.Order = v; return t }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syms

import (
        "go/build"
        "log"
        "os"
        "os/user"
        "path/filepath"
        "strings"
        "time"

        "cogentcore.org/core/base/fileinfo"
)

// ParseCacheDir returns the parse cache directory for given language, and ensures that it exists.
func ParseCacheDir(lang fileinfo.Known) (string, error) {
        ucdir, err := os.UserCacheDir()
        if err != nil {
                return "", err
        }
        cdir := filepath.Join(filepath.Join(ucdir, "Cogent Core", "parse"), lang.String())
        err = os.MkdirAll(cdir, 0775)
        if err != nil {
                log.Printf("ParseCacheDir: cache not available: %v\n", err)
        }
        return cdir, err
}

// GoRelPath returns the GOPATH or GOROOT relative path for given filename
func GoRelPath(filename string) (string, error) {
        absfn, err := filepath.Abs(filename)
        if err != nil {
                return absfn, err
        }
        relfn := absfn
        got := false
        for _, srcDir := range build.Default.SrcDirs() {
                if strings.HasPrefix(absfn, srcDir) {
                        relfn = strings.TrimPrefix(absfn, srcDir)
                        got = true
                        break
                }
        }
        if got {
                return relfn, nil
        }
        usr, err := user.Current()
        if err != nil {
                return relfn, err
        }
        homedir := usr.HomeDir
        if strings.HasPrefix(absfn, homedir) {
                relfn = strings.TrimPrefix(absfn, homedir)
        }
        return relfn, nil
}

// CacheFilename returns the filename to use for cache file for given filename
func CacheFilename(lang fileinfo.Known, filename string) (string, error) {
        cdir, err := ParseCacheDir(lang)
        if err != nil {
                return "", err
        }
        relfn, err := GoRelPath(filename)
        if err != nil {
                return "", err
        }
        path := relfn
        if filepath.Ext(path) != "" { // if it has an ext, it is not a dir..
                path, _ = filepath.Split(path)
        }
        path = filepath.Clean(path)
        if path[0] == filepath.Separator {
                path = path[1:]
        }
        path = strings.Replace(path, string(filepath.Separator), "%", -1)
        path = filepath.Join(cdir, path)
        return path, nil
}

// SaveSymCache saves cache of symbols starting with given symbol
// (typically a package, module, library), which is at given
// filename
func SaveSymCache(sy *Symbol, lang fileinfo.Known, filename string) error {
        cfile, err := CacheFilename(lang, filename)
        if err != nil {
                return err
        }
        return sy.SaveJSON(cfile)
}

// SaveSymDoc saves doc file of syms -- for double-checking contents etc
func SaveSymDoc(sy *Symbol, lang fileinfo.Known, filename string) error {
        cfile, err := CacheFilename(lang, filename)
        if err != nil {
                return err
        }
        cfile += ".doc"
        ofl, err := os.Create(cfile)
        if err != nil {
                return err
        }
        sy.WriteDoc(ofl, 0)
        return nil
}

// OpenSymCache opens cache of symbols into given symbol
// (typically a package, module, library), which is at given
// filename -- returns time stamp when cache was last saved
func OpenSymCache(lang fileinfo.Known, filename string) (*Symbol, time.Time, error) {
        cfile, err := CacheFilename(lang, filename)
        if err != nil {
                return nil, time.Time{}, err
        }
        info, err := os.Stat(cfile)
        if os.IsNotExist(err) {
                return nil, time.Time{}, err
        }
        sy := &Symbol{}
        err = sy.OpenJSON(cfile)
        return sy, info.ModTime(), err
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syms

import (
        "strings"

        "cogentcore.org/core/icons"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/token"
)

// AddCompleteSyms adds given symbols as matches in the given match data
// Scope is e.g., type name (label only)
func AddCompleteSyms(sym SymMap, scope string, md *complete.Matches) {
        if len(sym) == 0 {
                return
        }
        sys := sym.Slice(true) // sorted
        for _, sy := range sys {
                if sy.Name[0] == '_' { // internal / import
                        continue
                }
                nm := sy.Name
                lbl := sy.Label()
                if sy.Kind.SubCat() == token.NameFunction {
                        nm += "()"
                }
                if scope != "" {
                        lbl = lbl + " (" + scope + ".)"
                }
                c := complete.Completion{Text: nm, Label: lbl, Icon: sy.Kind.Icon(), Desc: sy.Detail}
                // fmt.Printf("nm: %v  kind: %v  icon: %v\n", nm, sy.Kind, c.Icon)
                md.Matches = append(md.Matches, c)
        }
}

// AddCompleteTypeNames adds names from given type as matches in the given match data
// Scope is e.g., type name (label only), and seed is prefix filter for names
func AddCompleteTypeNames(typ *Type, scope, seed string, md *complete.Matches) {
        md.Seed = seed
        for _, te := range typ.Els {
                nm := te.Name
                if seed != "" {
                        if !strings.HasPrefix(nm, seed) {
                                continue
                        }
                }
                lbl := nm
                if scope != "" {
                        lbl = lbl + " (" + scope + ".)"
                }
                icon := icons.Field // assume..
                c := complete.Completion{Text: nm, Label: lbl, Icon: icon}
                // fmt.Printf("nm: %v  kind: %v  icon: %v\n", nm, sy.Kind, c.Icon)
                md.Matches = append(md.Matches, c)
        }
        for _, mt := range typ.Meths {
                nm := mt.Name
                if seed != "" {
                        if !strings.HasPrefix(nm, seed) {
                                continue
                        }
                }
                lbl := nm + "(" + mt.ArgString() + ") " + mt.ReturnString()
                if scope != "" {
                        lbl = lbl + " (" + scope + ".)"
                }
                nm += "()"
                icon := icons.Method // assume..
                c := complete.Completion{Text: nm, Label: lbl, Icon: icon}
                // fmt.Printf("nm: %v  kind: %v  icon: %v\n", nm, sy.Kind, c.Icon)
                md.Matches = append(md.Matches, c)
        }
}

// AddCompleteSymsPrefix adds subset of symbols that match seed prefix to given match data
func AddCompleteSymsPrefix(sym SymMap, scope, seed string, md *complete.Matches) {
        matches := &sym
        if seed != "" {
                matches = &SymMap{}
                md.Seed = seed
                sym.FindNamePrefixRecursive(seed, matches)
        }
        AddCompleteSyms(*matches, scope, md)
}

// Code generated by "core generate"; DO NOT EDIT.

package syms

import (
        "cogentcore.org/core/enums"
)

var _KindsValues = []Kinds{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50}

// KindsN is the highest valid value for type Kinds, plus one.
const KindsN Kinds = 51

var _KindsValueMap = map[string]Kinds{`Unknown`: 0, `Primitive`: 1, `Numeric`: 2, `Integer`: 3, `Signed`: 4, `Int`: 5, `Int8`: 6, `Int16`: 7, `Int32`: 8, `Int64`: 9, `Unsigned`: 10, `Uint`: 11, `Uint8`: 12, `Uint16`: 13, `Uint32`: 14, `Uint64`: 15, `Uintptr`: 16, `Ptr`: 17, `Ref`: 18, `UnsafePtr`: 19, `Fixed`: 20, `Fixed26_6`: 21, `Fixed16_6`: 22, `Fixed0_32`: 23, `Float`: 24, `Float16`: 25, `Float32`: 26, `Float64`: 27, `Complex`: 28, `Complex64`: 29, `Complex128`: 30, `Bool`: 31, `Composite`: 32, `Tuple`: 33, `Range`: 34, `Array`: 35, `List`: 36, `String`: 37, `Matrix`: 38, `Tensor`: 39, `Map`: 40, `Set`: 41, `FrozenSet`: 42, `Struct`: 43, `Class`: 44, `Object`: 45, `Chan`: 46, `Function`: 47, `Func`: 48, `Method`: 49, `Interface`: 50}

var _KindsDescMap = map[Kinds]string{0: `Unknown is the nil kind -- kinds should be known in general..`, 1: `Category: Primitive, in the strict sense of low-level, atomic, small, fixed size`, 2: `SubCat: Numeric`, 3: `Sub2Cat: Integer`, 4: `Sub3Cat: Signed -- track this using properties in types, not using Sub3 level`, 5: ``, 6: ``, 7: ``, 8: ``, 9: ``, 10: `Sub3Cat: Unsigned`, 11: ``, 12: ``, 13: ``, 14: ``, 15: ``, 16: ``, 17: `Sub3Cat: Ptr, Ref etc -- in Numeric, Integer even though in some languages pointer arithmetic might not be allowed, for some cases, etc`, 18: ``, 19: ``, 20: `Sub2Cat: Fixed point -- could be under integer, but..`, 21: ``, 22: ``, 23: ``, 24: `Sub2Cat: Floating point`, 25: ``, 26: ``, 27: ``, 28: `Sub3Cat: Complex -- under floating point`, 29: ``, 30: ``, 31: `SubCat: Bool`, 32: `Category: Composite -- types composed of above primitive types`, 33: `SubCat: Tuple -- a fixed length 1d collection of elements that can be of any type Type.Els required for each element`, 34: ``, 35: `SubCat: Array -- a fixed length 1d collection of same-type elements Type.Els has one element for type`, 36: `SubCat: List -- a variable-length 1d collection of same-type elements This is Slice for Go Type.Els has one element for type`, 37: ``, 38: `SubCat: Matrix -- a twod collection of same-type elements has two Size values, one for each dimension`, 39: `SubCat: Tensor -- an n-dimensional collection of same-type elements first element of Size is number of dimensions, rest are dimensions`, 40: `SubCat: Map -- an associative array / hash map / dictionary Type.Els first el is key, second is type`, 41: `SubCat: Set -- typically a degenerate form of hash map with no value`, 42: ``, 43: `SubCat: Struct -- like a tuple but with specific semantics in most languages Type.Els are the fields, and if there is an inheritance relationship these are put first with relevant identifiers -- in Go these are unnamed fields`, 44: ``, 45: ``, 46: `Chan: a channel (Go Specific)`, 47: `Category: Function -- types that are functions Type.Els are the params and return values in order, with Size[0] being number of params and Size[1] number of returns`, 48: `SubCat: Func -- a standalone function`, 49: `SubCat: Method -- a function with a specific receiver (e.g., on a Class in C++, or on any type in Go). First Type.Els is receiver param -- included in Size[0]`, 50: `SubCat: Interface -- an abstract definition of a set of methods (in Go) Type.Els are the Methods with the receiver type missing or Unknown`}

var _KindsMap = map[Kinds]string{0: `Unknown`, 1: `Primitive`, 2: `Numeric`, 3: `Integer`, 4: `Signed`, 5: `Int`, 6: `Int8`, 7: `Int16`, 8: `Int32`, 9: `Int64`, 10: `Unsigned`, 11: `Uint`, 12: `Uint8`, 13: `Uint16`, 14: `Uint32`, 15: `Uint64`, 16: `Uintptr`, 17: `Ptr`, 18: `Ref`, 19: `UnsafePtr`, 20: `Fixed`, 21: `Fixed26_6`, 22: `Fixed16_6`, 23: `Fixed0_32`, 24: `Float`, 25: `Float16`, 26: `Float32`, 27: `Float64`, 28: `Complex`, 29: `Complex64`, 30: `Complex128`, 31: `Bool`, 32: `Composite`, 33: `Tuple`, 34: `Range`, 35: `Array`, 36: `List`, 37: `String`, 38: `Matrix`, 39: `Tensor`, 40: `Map`, 41: `Set`, 42: `FrozenSet`, 43: `Struct`, 44: `Class`, 45: `Object`, 46: `Chan`, 47: `Function`, 48: `Func`, 49: `Method`, 50: `Interface`}

// String returns the string representation of this Kinds value.
func (i Kinds) String() string { return enums.String(i, _KindsMap) }

// SetString sets the Kinds value from its string representation,
// and returns an error if the string is invalid.
func (i *Kinds) SetString(s string) error { return enums.SetString(i, s, _KindsValueMap, "Kinds") }

// Int64 returns the Kinds value as an int64.
func (i Kinds) Int64() int64 { return int64(i) }

// SetInt64 sets the Kinds value from an int64.
func (i *Kinds) SetInt64(in int64) { *i = Kinds(in) }

// Desc returns the description of the Kinds value.
func (i Kinds) Desc() string { return enums.Desc(i, _KindsDescMap) }

// KindsValues returns all possible values for the type Kinds.
func KindsValues() []Kinds { return _KindsValues }

// Values returns all possible values for the type Kinds.
func (i Kinds) Values() []enums.Enum { return enums.Values(_KindsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Kinds) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Kinds) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Kinds") }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syms

//go:generate core generate

import (
        "reflect"
)

// Kinds is a complete set of basic type categories and sub(sub..) categories -- these
// describe builtin types -- user-defined types must be some combination / version
// of these builtin types.
//
// See: https://en.wikipedia.org/wiki/List_of_data_structures
type Kinds int32 //enums:enum

// CatMap is the map into the category level for each kind
var CatMap map[Kinds]Kinds

// SubCatMap is the map into the sub-category level for each kind
var SubCatMap map[Kinds]Kinds

// Sub2CatMap is the map into the sub2-category level for each kind
var Sub2CatMap map[Kinds]Kinds

func init() {
        InitCatMap()
        InitSubCatMap()
        InitSub2CatMap()
}

// Cat returns the category that a given kind lives in, using CatMap
func (tk Kinds) Cat() Kinds {
        return CatMap[tk]
}

// SubCat returns the sub-category that a given kind lives in, using SubCatMap
func (tk Kinds) SubCat() Kinds {
        return SubCatMap[tk]
}

// Sub2Cat returns the sub2-category that a given kind lives in, using Sub2CatMap
func (tk Kinds) Sub2Cat() Kinds {
        return Sub2CatMap[tk]
}

// IsCat returns true if this is a category-level kind
func (tk Kinds) IsCat() bool {
        return tk.Cat() == tk
}

// IsSubCat returns true if this is a sub-category-level kind
func (tk Kinds) IsSubCat() bool {
        return tk.SubCat() == tk
}

// IsSub2Cat returns true if this is a sub2-category-level kind
func (tk Kinds) IsSub2Cat() bool {
        return tk.Sub2Cat() == tk
}

func (tk Kinds) InCat(other Kinds) bool {
        return tk.Cat() == other.Cat()
}

func (tk Kinds) InSubCat(other Kinds) bool {
        return tk.SubCat() == other.SubCat()
}

func (tk Kinds) InSub2Cat(other Kinds) bool {
        return tk.Sub2Cat() == other.Sub2Cat()
}

func (tk Kinds) IsPtr() bool {
        return tk >= Ptr && tk <= UnsafePtr
}

func (tk Kinds) IsPrimitiveNonPtr() bool {
        return tk.Cat() == Primitive && !tk.IsPtr()
}

// The list of Kinds
const (
        // Unknown is the nil kind -- kinds should be known in general..
        Unknown Kinds = iota

        // Category: Primitive, in the strict sense of low-level, atomic, small, fixed size
        Primitive

        // SubCat: Numeric
        Numeric

        // Sub2Cat: Integer
        Integer

        // Sub3Cat: Signed -- track this using properties in types, not using Sub3 level
        Signed
        Int
        Int8
        Int16
        Int32
        Int64

        // Sub3Cat: Unsigned
        Unsigned
        Uint
        Uint8
        Uint16
        Uint32
        Uint64
        Uintptr // generic raw pointer data value -- see also Ptr, Ref for more semantic cases

        // Sub3Cat: Ptr, Ref etc -- in Numeric, Integer even though in some languages
        // pointer arithmetic might not be allowed, for some cases, etc
        Ptr       // pointer -- element is what we point to (kind of a composite type)
        Ref       // reference -- element is what we refer to
        UnsafePtr // for case where these are distinguished from Ptr (Go) -- similar to Uintptr

        // Sub2Cat: Fixed point -- could be under integer, but..
        Fixed
        Fixed26_6
        Fixed16_6
        Fixed0_32

        // Sub2Cat: Floating point
        Float
        Float16
        Float32
        Float64

        // Sub3Cat: Complex -- under floating point
        Complex
        Complex64
        Complex128

        // SubCat: Bool
        Bool

        // Category: Composite -- types composed of above primitive types
        Composite

        // SubCat: Tuple -- a fixed length 1d collection of elements that can be of any type
        // Type.Els required for each element
        Tuple
        Range // a special kind of tuple for Python ranges

        // SubCat: Array -- a fixed length 1d collection of same-type elements
        // Type.Els has one element for type
        Array

        // SubCat: List -- a variable-length 1d collection of same-type elements
        // This is Slice for Go
        // Type.Els has one element for type
        List
        String // List of some type of char rep -- Type.Els is type, as all Lists

        // SubCat: Matrix -- a twod collection of same-type elements
        // has two Size values, one for each dimension
        Matrix

        // SubCat: Tensor -- an n-dimensional collection of same-type elements
        // first element of Size is number of dimensions, rest are dimensions
        Tensor

        // SubCat: Map -- an associative array / hash map / dictionary
        // Type.Els first el is key, second is type
        Map

        // SubCat: Set -- typically a degenerate form of hash map with no value
        Set
        FrozenSet // python's frozen set of fixed values

        // SubCat: Struct -- like a tuple but with specific semantics in most languages
        // Type.Els are the fields, and if there is an inheritance relationship these
        // are put first with relevant identifiers -- in Go these are unnamed fields
        Struct
        Class
        Object

        // Chan: a channel (Go Specific)
        Chan

        // Category: Function -- types that are functions
        // Type.Els are the params and return values in order, with Size[0] being number
        // of params and Size[1] number of returns
        Function

        // SubCat: Func -- a standalone function
        Func

        // SubCat: Method -- a function with a specific receiver (e.g., on a Class in C++,
        // or on any type in Go).
        // First Type.Els is receiver param -- included in Size[0]
        Method

        // SubCat: Interface -- an abstract definition of a set of methods (in Go)
        // Type.Els are the Methods with the receiver type missing or Unknown
        Interface
)

// Categories
var Cats = []Kinds{
        Unknown,
        Primitive,
        Composite,
        Function,
        KindsN,
}

// Sub-Categories
var SubCats = []Kinds{
        Unknown,
        Primitive,
        Numeric,
        Bool,
        Composite,
        Tuple,
        Array,
        List,
        Matrix,
        Tensor,
        Map,
        Set,
        Struct,
        Chan,
        Function,
        Func,
        Method,
        Interface,
        KindsN,
}

// Sub2-Categories
var Sub2Cats = []Kinds{
        Unknown,
        Primitive,
        Numeric,
        Integer,
        Fixed,
        Float,
        Bool,
        Composite,
        Tuple,
        Array,
        List,
        Matrix,
        Tensor,
        Map,
        Set,
        Struct,
        Chan,
        Function,
        Func,
        Method,
        Interface,
        KindsN,
}

// InitCatMap initializes the CatMap
func InitCatMap() {
        if CatMap != nil {
                return
        }
        CatMap = make(map[Kinds]Kinds, KindsN)
        for tk := Unknown; tk < KindsN; tk++ {
                for c := 1; c < len(Cats); c++ {
                        if tk < Cats[c] {
                                CatMap[tk] = Cats[c-1]
                                break
                        }
                }
        }
}

// InitSubCatMap initializes the SubCatMap
func InitSubCatMap() {
        if SubCatMap != nil {
                return
        }
        SubCatMap = make(map[Kinds]Kinds, KindsN)
        for tk := Unknown; tk < KindsN; tk++ {
                for c := 1; c < len(SubCats); c++ {
                        if tk < SubCats[c] {
                                SubCatMap[tk] = SubCats[c-1]
                                break
                        }
                }
        }
}

// InitSub2CatMap initializes the SubCatMap
func InitSub2CatMap() {
        if Sub2CatMap != nil {
                return
        }
        Sub2CatMap = make(map[Kinds]Kinds, KindsN)
        for tk := Unknown; tk < KindsN; tk++ {
                for c := 1; c < len(SubCats); c++ {
                        if tk < Sub2Cats[c] {
                                Sub2CatMap[tk] = Sub2Cats[c-1]
                                break
                        }
                }
        }
}

///////////////////////////////////////////////////////////////////////
//   Reflect map

// ReflectKindMap maps reflect kinds to syms.Kinds

var ReflectKindMap = map[reflect.Kind]Kinds{
        reflect.Invalid:       Unknown,
        reflect.Int:           Int,
        reflect.Int8:          Int8,
        reflect.Int16:         Int16,
        reflect.Int32:         Int32,
        reflect.Int64:         Int64,
        reflect.Uint:          Uint,
        reflect.Uint8:         Uint8,
        reflect.Uint16:        Uint16,
        reflect.Uint32:        Uint32,
        reflect.Uint64:        Uint64,
        reflect.Uintptr:       Uintptr,
        reflect.Float32:       Float32,
        reflect.Float64:       Float64,
        reflect.Complex64:     Complex64,
        reflect.Complex128:    Complex128,
        reflect.Bool:          Bool,
        reflect.Array:         Array,
        reflect.Chan:          Chan,
        reflect.Func:          Func,
        reflect.Interface:     Interface,
        reflect.Map:           Map,
        reflect.Pointer:       Ptr,
        reflect.Slice:         List,
        reflect.String:        String,
        reflect.Struct:        Struct,
        reflect.UnsafePointer: Ptr,
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package syms defines the symbols and their properties that
// are accumulated from a parsed file, and are then used for
// e.g., completion lookup, etc.
//
// We looked at several different standards for formats, types, etc:
//
// LSP: https://microsoft.github.io/language-server-protocol/specification
// useful to enable parse to act as an LSP server at some point.
// additional symbol kinds:
// https://github.com/Microsoft/language-server-protocol/issues/344
//
// See also: github.com/sourcegraph/sourcegraph
// and specifically: /cmd/frontend/graphqlbackend/search_symbols.go
// it seems to use https://github.com/universal-ctags/ctags
// for the raw data..
//
// Other relevant guidance comes from the go compiler system which is
// used extensively in github.com/mdemsky/gocode for example.
// In particular: go/types/scope.go type.go, and package.go contain the
// relevant data structures for how information is organized for
// compiled go packages, which have all this data cached and avail
// to be imported via the go/importer which returns a go/types/Package
// which in turn contains Scope's which in turn contain Objects that
// define the elements of the compiled language.
package syms

import (
        "encoding/json"
        "fmt"
        "io"
        "os"
        "strings"

        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
        "cogentcore.org/core/tree"
)

// Symbol contains the information for everything about a given
// symbol that is created by parsing, and can be looked up.
// It corresponds to the LSP DocumentSymbol structure, and
// the Go Object type.
type Symbol struct {

        // name of the symbol
        Name string

        // additional detail and specification of the symbol -- e.g. if a function, the signature of the function
        Detail string

        // lexical kind of symbol, using token.Tokens list
        Kind token.Tokens

        // Type name for this symbol -- if it is a type, this is its corresponding type representation -- if it is a variable then this is its type
        Type string

        // index for ordering children within a given scope, e.g., fields in a struct / class
        Index int

        // full filename / URI of source
        Filename string

        // region in source encompassing this item -- if = RegZero then this is a temp symbol and children are not added to it
        Region textpos.Region

        // region that should be selected when activated, etc
        SelectReg textpos.Region

        // relevant scoping / parent symbols, e.g., namespace, package, module, class, function, etc..
        Scopes SymNames

        // children of this symbol -- this includes e.g., methods and fields of classes / structs / types, and all elements within packages, etc
        Children SymMap

        // types defined within the scope of this symbol
        Types TypeMap

        // AST node that created this symbol -- only valid during parsing
        AST tree.Node `json:"-" xml:"-"`
}

// NewSymbol returns a new symbol with the basic info filled in -- SelectReg defaults to Region
func NewSymbol(name string, kind token.Tokens, fname string, reg textpos.Region) *Symbol {
        sy := &Symbol{Name: name, Kind: kind, Filename: fname, Region: reg, SelectReg: reg}
        return sy
}

// CopyFromSrc copies all the source-related fields from other symbol
// (no Type, Types, or Children).  AST is only copied if non-nil.
func (sy *Symbol) CopyFromSrc(cp *Symbol) {
        sy.Detail = cp.Detail
        sy.Kind = cp.Kind
        sy.Index = cp.Index
        sy.Filename = cp.Filename
        sy.Region = cp.Region
        sy.SelectReg = cp.SelectReg
        // if cp.AST != nil {
        //         sy.AST = cp.AST
        // }
}

// IsTemp returns true if this is temporary symbol that is used for scoping but is not
// otherwise permanently added to list of symbols.  Indicated by Zero Region.
func (sy *Symbol) IsTemp() bool {
        return sy.Region == textpos.RegionZero
}

// HasChildren returns true if this symbol has children
func (sy *Symbol) HasChildren() bool {
        return len(sy.Children) > 0
}

// String satisfies fmt.Stringer interface
func (sy *Symbol) String() string {
        return fmt.Sprintf("%v: %v (%v)", sy.Name, sy.Kind, sy.Region)
}

// Label satisfies core.Labeler interface -- nicer presentation label
func (sy *Symbol) Label() string {
        lbl := sy.Name
        switch {
        case sy.Kind.SubCat() == token.NameFunction:
                pi := strings.Index(sy.Detail, "(")
                if pi >= 0 {
                        lbl += sy.Detail[pi:]
                } else {
                        lbl += "()"
                }
        default:
                if sy.Type != "" {
                        lbl += " (" + sy.Type + ")"
                }
        }
        return lbl
}

// Clone returns a clone copy of this symbol.
// Does NOT copy the Children or Types -- caller can decide about that.
func (sy *Symbol) Clone() *Symbol {
        nsy := &Symbol{Name: sy.Name, Detail: sy.Detail, Kind: sy.Kind, Type: sy.Type, Index: sy.Index, Filename: sy.Filename, Region: sy.Region, SelectReg: sy.SelectReg}
        nsy.Scopes = sy.Scopes.Clone()
        // nsy.AST = sy.AST
        return nsy
}

// AddChild adds a child symbol, if this parent symbol is not temporary
// returns true if item name was added and NOT already on the map,
// and false if it was already or parent is temp.
// Always adds new symbol in any case.
// If parent symbol is of the NameType subcategory, then index of child is set
// to the size of this child map before adding.
func (sy *Symbol) AddChild(child *Symbol) bool {
        // if sy.IsTemp() {
        //         return false
        // }
        sy.Children.Alloc()
        _, on := sy.Children[child.Name]
        idx := len(sy.Children)
        child.Index = idx // always record index
        sy.Children[child.Name] = child
        return !on
}

// AllocScopes allocates scopes map if nil
func (sy *Symbol) AllocScopes() {
        if sy.Scopes == nil {
                sy.Scopes = make(SymNames)
        }
}

// AddScopesMap adds a given scope element(s) from map to this Symbol.
// if add is true, add this symbol to those scopes if they are not temporary.
func (sy *Symbol) AddScopesMap(sm SymMap, add bool) {
        if len(sm) == 0 {
                return
        }
        sy.AllocScopes()
        for _, s := range sm {
                sy.Scopes[s.Kind] = s.Name
                if add {
                        s.AddChild(sy)
                }
        }
}

// AddScopesStack adds a given scope element(s) from stack to this Symbol.
// Adds this symbol as a child to the top of the scopes if it is not temporary --
// returns true if so added.
func (sy *Symbol) AddScopesStack(ss SymStack) bool {
        sz := len(ss)
        if sz == 0 {
                return false
        }
        sy.AllocScopes()
        added := false
        for i := 0; i < sz; i++ {
                sc := ss[i]
                sy.Scopes[sc.Kind] = sc.Name
                if i == sz-1 {
                        added = sc.AddChild(sy)
                }
        }
        return added
}

// FindAnyChildren finds children of this symbol using either
// direct children if those are present, or the type name if
// present -- used for completion routines.  Adds to kids map.
// scope1, scope2 are used for looking up type name.
// If seed is non-empty it is used as a prefix for filtering children names.
// Returns false if no children were found.
func (sy *Symbol) FindAnyChildren(seed string, scope1, scope2 SymMap, kids *SymMap) bool {
        sym := sy
        if len(sym.Children) == 0 {
                if sym.Type != "" {
                        tynm := sym.NonPtrTypeName()
                        if typ, got := scope1.FindNameScoped(tynm); got {
                                sym = typ
                        } else if typ, got := scope2.FindNameScoped(tynm); got {
                                sym = typ
                        } else {
                                return false
                        }
                }
        }
        if seed != "" {
                sym.Children.FindNamePrefixRecursive(seed, kids)
        } else {
                kids.CopyFrom(sym.Children, true) // srcIsNewer
        }
        return len(*kids) > 0

}

// NonPtrTypeName returns the name of the type without any leading * or &
func (sy *Symbol) NonPtrTypeName() string {
        return strings.TrimPrefix(strings.TrimPrefix(sy.Type, "&"), "*")
}

// CopyFromScope copies the Children and Types from given other symbol
// for scopes (e.g., Go package), to merge with existing.
func (sy *Symbol) CopyFromScope(src *Symbol) {
        sy.Children.CopyFrom(src.Children, false) // src is NOT newer
        sy.Types.CopyFrom(src.Types, false)       // src is NOT newer
}

// OpenJSON opens from a JSON-formatted file.
func (sy *Symbol) OpenJSON(filename string) error {
        b, err := os.ReadFile(filename)
        if err != nil {
                return err
        }
        return json.Unmarshal(b, sy)
}

// SaveJSON saves to a JSON-formatted file.
func (sy *Symbol) SaveJSON(filename string) error {
        b, err := json.MarshalIndent(sy, "", "  ")
        if err != nil {
                return err
        }
        err = os.WriteFile(filename, b, 0644)
        return err
}

// WriteDoc writes basic doc info
func (sy *Symbol) WriteDoc(out io.Writer, depth int) {
        ind := indent.Tabs(depth)
        fmt.Fprintf(out, "%v%v: %v", ind, sy.Name, sy.Kind)
        if sy.Type != "" {
                fmt.Fprintf(out, " (%v)", sy.Type)
        }
        if len(sy.Types) > 0 {
                fmt.Fprint(out, " Types: {\n")
                sy.Types.WriteDoc(out, depth+1)
                fmt.Fprintf(out, "%v}\n", ind)
        }
        if sy.HasChildren() {
                fmt.Fprint(out, " {\n")
                sy.Children.WriteDoc(out, depth+1)
                fmt.Fprintf(out, "%v}\n", ind)
        } else {
                fmt.Fprint(out, "\n")
        }
}

// ClearAST sets the AST pointers to nil for all symbols in this one.
// otherwise the AST memory is never freed and can get quite large.
func (sm *Symbol) ClearAST() {
        sm.AST = nil
        sm.Children.ClearAST()
        sm.Types.ClearAST()
}

// ClearAST sets the AST pointers to nil for all symbols.
// otherwise the AST memory is never freed and can get quite large.
func (sm *SymMap) ClearAST() {
        for _, ss := range *sm {
                ss.ClearAST()
        }
}

// ClearAST sets the AST pointers to nil for all symbols in this one.
// otherwise the AST memory is never freed and can get quite large.
func (ty *Type) ClearAST() {
        ty.AST = nil
        ty.Meths.ClearAST()
}

// ClearAST sets the AST pointers to nil for all symbols.
// otherwise the AST memory is never freed and can get quite large.
func (tm *TypeMap) ClearAST() {
        for _, ty := range *tm {
                ty.ClearAST()
        }
}

//////////////////////////////////////////////////////////////////
// SymNames

// SymNames provides a map-list of symbol names, indexed by their token kinds.
// Used primarily for specifying Scopes
type SymNames map[token.Tokens]string

// SubCat returns a scope with the given SubCat type, or false if not found
func (sn *SymNames) SubCat(sc token.Tokens) (string, bool) {
        for tk, nm := range *sn {
                if tk.SubCat() == sc {
                        return nm, true
                }
        }
        return "", false
}

// Clone returns a clone copy of this map (nil if empty)
func (sn *SymNames) Clone() SymNames {
        sz := len(*sn)
        if sz == 0 {
                return nil
        }
        nsn := make(SymNames, sz)
        for tk, nm := range *sn {
                nsn[tk] = nm
        }
        return nsn
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syms

import (
        "encoding/json"
        "io"
        "os"
        "path/filepath"
        "sort"
        "strings"

        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// SymMap is a map between symbol names and their full information.
// A given project will have a top-level SymMap and perhaps local
// maps for individual files, etc.  Namespaces / packages can be
// created and elements added to them to create appropriate
// scoping structure etc.  Note that we have to use pointers
// for symbols b/c otherwise it is very expensive to re-assign
// values all the time -- https://github.com/golang/go/issues/3117
type SymMap map[string]*Symbol

// Alloc ensures that map is made
func (sm *SymMap) Alloc() {
        if *sm == nil {
                *sm = make(SymMap)
        }
}

// Add adds symbol to map
func (sm *SymMap) Add(sy *Symbol) {
        sm.Alloc()
        (*sm)[sy.Name] = sy
}

// AddNew adds a new symbol to the map with the basic info
func (sm *SymMap) AddNew(name string, kind token.Tokens, fname string, reg textpos.Region) *Symbol {
        sy := NewSymbol(name, kind, fname, reg)
        sm.Alloc()
        (*sm)[name] = sy
        return sy
}

// Reset resets the symbol map
func (sm *SymMap) Reset() {
        *sm = make(SymMap)
}

// CopyFrom copies all the symbols from given source map into this one,
// including merging everything from common elements.
// Symbols with Type resolved are retained when there are duplicates.
// srcIsNewer means that the src map has the newer information to grab for
// updating the symbol region info during the merge.
func (sm *SymMap) CopyFrom(src SymMap, srcIsNewer bool) {
        sm.Alloc()
        for nm, ssy := range src {
                dsy, has := (*sm)[nm]
                if !has {
                        (*sm)[nm] = ssy
                        continue
                }
                if srcIsNewer {
                        dsy.CopyFromSrc(ssy)
                } else {
                        ssy.CopyFromSrc(dsy)
                }
                if dsy.Type != "" {
                        // fmt.Printf("dupe sym: %v, using existing with type: %v\n", nm, dsy.Type)
                        // fmt.Printf("\texisting region: %v  new source region: %v\n", dsy.Region, ssy.Region)
                        dsy.Children.CopyFrom(ssy.Children, srcIsNewer)
                } else if ssy.Type != "" {
                        // fmt.Printf("dupe sym: %v, using new with type: %v\n", nm, ssy.Type)
                        // fmt.Printf("\texisting region: %v  new source region: %v\n", dsy.Region, ssy.Region)
                        ssy.Children.CopyFrom(dsy.Children, !srcIsNewer)
                        (*sm)[nm] = ssy
                } else {
                        dsy.Children.CopyFrom(ssy.Children, srcIsNewer)
                }
        }
}

// First returns the first symbol in the map -- only sensible when there
// is just one such element
func (sm *SymMap) First() *Symbol {
        for _, sy := range *sm {
                return sy
        }
        return nil
}

// Slice returns a slice of the elements in the map, optionally sorted by name
func (sm *SymMap) Slice(sorted bool) []*Symbol {
        sys := make([]*Symbol, len(*sm))
        idx := 0
        for _, sy := range *sm {
                sys[idx] = sy
                idx++
        }
        if sorted {
                sort.Slice(sys, func(i, j int) bool {
                        return sys[i].Name < sys[j].Name
                })
        }
        return sys
}

// FindName looks for given symbol name within this map and any children on the map
func (sm *SymMap) FindName(nm string) (*Symbol, bool) {
        if *sm == nil {
                return nil, false
        }
        sy, has := (*sm)[nm]
        if has {
                return sy, has
        }
        for _, ss := range *sm {
                if sy, has = ss.Children.FindName(nm); has {
                        return sy, has
                }
        }
        return nil, false
}

// FindNameScoped looks for given symbol name within this map and any children on the map
// that are of subcategory token.NameScope (i.e., namespace, module, package, library)
func (sm *SymMap) FindNameScoped(nm string) (*Symbol, bool) {
        if *sm == nil {
                return nil, false
        }
        sy, has := (*sm)[nm]
        if has {
                return sy, has
        }
        for _, ss := range *sm {
                if ss.Kind.SubCat() == token.NameScope {
                        if sy, has = ss.Children.FindNameScoped(nm); has {
                                return sy, has
                        }
                }
        }
        return nil, false
}

// FindKind looks for given symbol kind within this map and any children on the map
// Returns all instances found.  Uses cat / subcat based token matching -- if you
// specify a category-level or subcategory level token, it will match everything in that group
func (sm *SymMap) FindKind(kind token.Tokens, matches *SymMap) {
        if *sm == nil {
                return
        }
        for _, sy := range *sm {
                if kind.Match(sy.Kind) {
                        if *matches == nil {
                                *matches = make(SymMap)
                        }
                        (*matches)[sy.Name] = sy
                }
        }
        for _, ss := range *sm {
                ss.Children.FindKind(kind, matches)
        }
}

// FindKindScoped looks for given symbol kind within this map and any children on the map
// that are of subcategory token.NameScope (i.e., namespace, module, package, library).
// Returns all instances found.  Uses cat / subcat based token matching -- if you
// specify a category-level or subcategory level token, it will match everything in that group
func (sm *SymMap) FindKindScoped(kind token.Tokens, matches *SymMap) {
        if *sm == nil {
                return
        }
        for _, sy := range *sm {
                if kind.Match(sy.Kind) {
                        if *matches == nil {
                                *matches = make(SymMap)
                        }
                        (*matches)[sy.Name] = sy
                }
        }
        for _, ss := range *sm {
                if ss.Kind.SubCat() == token.NameScope {
                        ss.Children.FindKindScoped(kind, matches)
                }
        }
}

// FindContainsRegion looks for given symbol kind that contains the given
// source file path (must be filepath.Abs file path) and position.
// Returns all instances found.  Uses cat / subcat based token matching -- if you
// specify a category-level or subcategory level token, it will match everything
// in that group.  if you specify kind = token.None then all tokens that contain
// region will be returned.  extraLns are extra lines added to the symbol region
// for purposes of matching.
func (sm *SymMap) FindContainsRegion(fpath string, pos textpos.Pos, extraLns int, kind token.Tokens, matches *SymMap) {
        if *sm == nil {
                return
        }
        for _, sy := range *sm {
                fp, _ := filepath.Abs(sy.Filename)
                if fp != fpath {
                        continue
                }
                reg := sy.Region
                if extraLns > 0 {
                        reg.End.Line += extraLns
                }
                if !reg.Contains(pos) {
                        continue
                }
                if kind == token.None || kind.Match(sy.Kind) {
                        if *matches == nil {
                                *matches = make(SymMap)
                        }
                        (*matches)[sy.Name] = sy
                }
        }
        for _, ss := range *sm {
                ss.Children.FindContainsRegion(fpath, pos, extraLns, kind, matches)
        }
}

// OpenJSON opens from a JSON-formatted file.
func (sm *SymMap) OpenJSON(filename string) error {
        b, err := os.ReadFile(filename)
        if err != nil {
                return err
        }
        return json.Unmarshal(b, sm)
}

// SaveJSON saves to a JSON-formatted file.
func (sm *SymMap) SaveJSON(filename string) error {
        b, err := json.MarshalIndent(sm, "", "  ")
        if err != nil {
                return err
        }
        err = os.WriteFile(filename, b, 0644)
        return err
}

// Names returns a slice of the names in this map, optionally sorted
func (sm *SymMap) Names(sorted bool) []string {
        nms := make([]string, len(*sm))
        idx := 0
        for _, sy := range *sm {
                nms[idx] = sy.Name
                idx++
        }
        if sorted {
                sort.StringSlice(nms).Sort()
        }
        return nms
}

// KindNames returns a slice of the kind:names in this map, optionally sorted
func (sm *SymMap) KindNames(sorted bool) []string {
        nms := make([]string, len(*sm))
        idx := 0
        for _, sy := range *sm {
                nms[idx] = sy.Kind.String() + ":" + sy.Name
                idx++
        }
        if sorted {
                sort.StringSlice(nms).Sort()
        }
        return nms
}

// WriteDoc writes basic doc info, sorted by kind and name
func (sm *SymMap) WriteDoc(out io.Writer, depth int) {
        nms := sm.KindNames(true)
        for _, nm := range nms {
                ci := strings.Index(nm, ":")
                sy := (*sm)[nm[ci+1:]]
                sy.WriteDoc(out, depth)
        }
}

//////////////////////////////////////////////////////////////////////
// Partial lookups

// FindNamePrefix looks for given symbol name prefix within this map
// adds to given matches map (which can be nil), for more efficient recursive use
func (sm *SymMap) FindNamePrefix(seed string, matches *SymMap) {
        noCase := true
        if lexer.HasUpperCase(seed) {
                noCase = false
        }
        for _, sy := range *sm {
                nm := sy.Name
                if noCase {
                        nm = strings.ToLower(nm)
                }
                if strings.HasPrefix(nm, seed) {
                        if *matches == nil {
                                *matches = make(SymMap)
                        }
                        (*matches)[sy.Name] = sy
                }
        }
}

// FindNamePrefixRecursive looks for given symbol name prefix within this map
// and any children on the map.
// adds to given matches map (which can be nil), for more efficient recursive use
func (sm *SymMap) FindNamePrefixRecursive(seed string, matches *SymMap) {
        noCase := true
        if lexer.HasUpperCase(seed) {
                noCase = false
        }
        for _, sy := range *sm {
                nm := sy.Name
                if noCase {
                        nm = strings.ToLower(nm)
                }
                if strings.HasPrefix(nm, seed) {
                        if *matches == nil {
                                *matches = make(SymMap)
                        }
                        (*matches)[sy.Name] = sy
                }
        }
        for _, ss := range *sm {
                ss.Children.FindNamePrefixRecursive(seed, matches)
        }
}

// FindNamePrefixScoped looks for given symbol name prefix within this map
// and any children on the map that are of subcategory
// token.NameScope (i.e., namespace, module, package, library)
// adds to given matches map (which can be nil), for more efficient recursive use
func (sm *SymMap) FindNamePrefixScoped(seed string, matches *SymMap) {
        noCase := true
        if lexer.HasUpperCase(seed) {
                noCase = false
        }
        for _, sy := range *sm {
                nm := sy.Name
                if nm[0] == '"' {
                        nm = strings.Trim(nm, `"`) // path names may be quoted
                        nm = filepath.Base(nm)     // sorry, this is a bit of a Go-specific hack to look at package names only
                        sy = sy.Clone()
                        sy.Name = nm
                }
                if noCase {
                        nm = strings.ToLower(nm)
                }
                if strings.HasPrefix(nm, seed) {
                        if *matches == nil {
                                *matches = make(SymMap)
                        }
                        (*matches)[nm] = sy
                }
        }
        for _, ss := range *sm {
                if ss.Kind.SubCat() == token.NameScope {
                        ss.Children.FindNamePrefixScoped(seed, matches)
                }
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syms

import (
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// SymStack is a simple stack (slice) of symbols
type SymStack []*Symbol

// Top returns the state at the top of the stack (could be nil)
func (ss *SymStack) Top() *Symbol {
        sz := len(*ss)
        if sz == 0 {
                return nil
        }
        return (*ss)[sz-1]
}

// Push appends symbol to stack
func (ss *SymStack) Push(sy *Symbol) {
        *ss = append(*ss, sy)
}

// PushNew adds a new symbol to the stack with the basic info
func (ss *SymStack) PushNew(name string, kind token.Tokens, fname string, reg textpos.Region) *Symbol {
        sy := NewSymbol(name, kind, fname, reg)
        ss.Push(sy)
        return sy
}

// Pop takes symbol off the stack and returns it
func (ss *SymStack) Pop() *Symbol {
        sz := len(*ss)
        if sz == 0 {
                return nil
        }
        sy := (*ss)[sz-1]
        *ss = (*ss)[:sz-1]
        return sy
}

// Reset resets the stack
func (ss *SymStack) Reset() {
        *ss = nil
}

// FindNameScoped searches top-down in the stack for something with the given name
// in symbols that are of subcategory token.NameScope (i.e., namespace, module, package, library)
func (ss *SymStack) FindNameScoped(nm string) (*Symbol, bool) {
        sz := len(*ss)
        if sz == 0 {
                return nil, false
        }
        for i := sz - 1; i >= 0; i-- {
                sy := (*ss)[i]
                if sy.Name == nm {
                        return sy, true
                }
                ssy, has := sy.Children.FindNameScoped(nm)
                if has {
                        return ssy, true
                }
        }
        return nil, false
}

func (ss *SymStack) ClearAST() {
        for _, sy := range *ss {
                sy.ClearAST()
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syms

import (
        "fmt"
        "io"
        "maps"
        "slices"

        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/tree"
)

// Type contains all the information about types.  Types can be builtin
// or composed of builtin types.  Each type can have one or more elements,
// e.g., fields for a struct or class, multiple values for a go function,
// or the two types for a map (key, value), etc..
type Type struct {

        // name of the type -- can be the name of a field or the role for a type element
        Name string

        // kind of type -- overall nature of the type
        Kind Kinds

        // documentation about this type, extracted from code
        Desc string

        // set to true after type has been initialized during post-parse processing
        Initialized bool `edit:"-"`

        // elements of this type -- ordering and meaning varies depending on the Kind of type -- for Primitive types this is the parent type, for Composite types it describes the key elements of the type: Tuple = each element's type; Array = type of elements; Struct = each field, etc (see docs for each in Kinds)
        Els TypeEls

        // methods defined for this type
        Meths TypeMap

        // for primitive types, this is the number of bytes, for composite types, it is the number of elements, which can be multi-dimensional (e.g., for functions, number of params is (including receiver param for methods) and return vals is )
        Size []int

        // full filename / URI of source where type is defined (may be empty for auto types)
        Filename string

        // region in source encompassing this type
        Region textpos.Region

        // relevant scoping / parent symbols, e.g., namespace, package, module, class, function, etc..
        Scopes SymNames

        // additional type properties, such as const, virtual, static -- these are just recorded textually and not systematized to keep things open-ended -- many of the most important properties can be inferred from the Kind property
        Properties map[string]any

        // AST node that corresponds to this type -- only valid during parsing
        AST tree.Node `json:"-" xml:"-"`
}

// NewType returns a new Type struct initialized with given name and kind
func NewType(name string, kind Kinds) *Type {
        ty := &Type{Name: name, Kind: kind}
        return ty
}

// AllocScopes allocates scopes map if nil
func (ty *Type) AllocScopes() {
        if ty.Scopes == nil {
                ty.Scopes = make(SymNames)
        }
}

// CopyFromSrc copies source-level data from given other type
func (ty *Type) CopyFromSrc(cp *Type) {
        ty.Filename = cp.Filename
        ty.Region = cp.Region
        if cp.AST != nil {
                ty.AST = cp.AST
        }
}

// Clone returns a deep copy of this type, cloning / copying all sub-elements
// except the AST and Initialized
func (ty *Type) Clone() *Type {
        // note: not copying Initialized
        nty := &Type{Name: ty.Name, Kind: ty.Kind, Desc: ty.Desc, Filename: ty.Filename, Region: ty.Region, AST: ty.AST}
        nty.Els.CopyFrom(ty.Els)
        nty.Meths = ty.Meths.Clone()
        nty.Size = slices.Clone(ty.Size)
        nty.Scopes = ty.Scopes.Clone()
        maps.Copy(nty.Properties, ty.Properties)
        return nty
}

// AddScopesStack adds a given scope element(s) from stack to this Type.
func (ty *Type) AddScopesStack(ss SymStack) {
        sz := len(ss)
        if sz == 0 {
                return
        }
        ty.AllocScopes()
        for i := 0; i < sz; i++ {
                sc := ss[i]
                ty.Scopes[sc.Kind] = sc.Name
        }
}

// String() satisfies the fmt.Stringer interface
func (ty *Type) String() string {
        switch {
        case ty.Kind.Cat() == Function && len(ty.Size) == 2:
                str := "func "
                npars := ty.Size[0]
                if ty.Kind.SubCat() == Method {
                        str += "(" + ty.Els.StringRange(0, 1) + ") " + ty.Name + "(" + ty.Els.StringRange(1, npars-1) + ")"
                } else {
                        str += ty.Name + "(" + ty.Els.StringRange(0, npars) + ")"
                }
                nrets := ty.Size[1]
                if nrets == 1 {
                        tel := ty.Els[npars]
                        str += " " + tel.Type
                } else if nrets > 1 {
                        str += " (" + ty.Els.StringRange(npars, nrets) + ")"
                }
                return str
        case ty.Kind.SubCat() == Map:
                return "map[" + ty.Els[0].Type + "]" + ty.Els[1].Type
        case ty.Kind == String:
                return "string"
        case ty.Kind.SubCat() == List:
                return "[]" + ty.Els[0].Type
        }
        return ty.Name + ": " + ty.Kind.String()
}

// ArgString() returns string of args to function if it is a function type
func (ty *Type) ArgString() string {
        if ty.Kind.Cat() != Function || len(ty.Size) != 2 {
                return ""
        }
        npars := ty.Size[0]
        if ty.Kind.SubCat() == Method {
                return ty.Els.StringRange(1, npars-1)
        }
        return ty.Els.StringRange(0, npars)
}

// ReturnString() returns string of return vals of function if it is a function type
func (ty *Type) ReturnString() string {
        if ty.Kind.Cat() != Function || len(ty.Size) != 2 {
                return ""
        }
        npars := ty.Size[0]
        nrets := ty.Size[1]
        if nrets == 1 {
                tel := ty.Els[npars]
                return tel.Type
        } else if nrets > 1 {
                return "(" + ty.Els.StringRange(npars, nrets) + ")"
        }
        return ""
}

// NonPtrType returns the non-pointer name of this type, if it is a pointer type
// otherwise just returns Name
func (ty *Type) NonPtrType() string {
        if !(ty.Kind == Ptr || ty.Kind == Ref || ty.Kind == UnsafePtr) {
                return ty.Name
        }
        if len(ty.Els) == 1 {
                return ty.Els[0].Type
        }
        return ty.Name // shouldn't happen
}

// WriteDoc writes basic doc info
func (ty *Type) WriteDoc(out io.Writer, depth int) {
        ind := indent.Tabs(depth)
        fmt.Fprintf(out, "%v%v: %v", ind, ty.Name, ty.Kind)
        if len(ty.Size) == 1 {
                fmt.Fprintf(out, " Size: %v", ty.Size[0])
        } else if len(ty.Size) > 1 {
                fmt.Fprint(out, " Size: { ")
                for i := range ty.Size {
                        fmt.Fprintf(out, "%v, ", ty.Size[i])
                }
                fmt.Fprint(out, " }")
        }
        if ty.Kind.SubCat() == Struct && len(ty.Els) > 0 {
                fmt.Fprint(out, " {\n")
                indp := indent.Tabs(depth + 1)
                for i := range ty.Els {
                        fmt.Fprintf(out, "%v%v\n", indp, ty.Els[i].String())
                }
                fmt.Fprintf(out, "%v}\n", ind)
        } else {
                fmt.Fprint(out, "\n")
        }
        if len(ty.Meths) > 0 {
                fmt.Fprint(out, "Methods: {\n")
                indp := indent.Tabs(depth + 1)
                for _, m := range ty.Meths {
                        fmt.Fprintf(out, "%v%v\n", indp, m.String())
                }
                fmt.Fprintf(out, "%v}\n", ind)
        } else {
                fmt.Fprint(out, "\n")
        }
}

//////////////////////////////////////////////////////////////////////////////////
// TypeEls

// TypeEl is a type element -- has a name (local to the type, e.g., field name)
// and a type name that can be looked up in a master list of types
type TypeEl struct {

        // element name -- e.g., field name for struct, or functional name for other types
        Name string

        // type name -- looked up on relevant lists -- includes scoping / package / namespace name as appropriate
        Type string
}

// String() satisfies the fmt.Stringer interface
func (tel *TypeEl) String() string {
        if tel.Name != "" {
                return tel.Name + " " + tel.Type
        }
        return tel.Type
}

// Clone() returns a copy of this el
func (tel *TypeEl) Clone() *TypeEl {
        te := &TypeEl{Name: tel.Name, Type: tel.Type}
        return te
}

// TypeEls are the type elements for types
type TypeEls []TypeEl

// Add adds a new type element
func (te *TypeEls) Add(nm, typ string) {
        (*te) = append(*te, TypeEl{Name: nm, Type: typ})
}

// CopyFrom copies from another list
func (te *TypeEls) CopyFrom(cp TypeEls) {
        for _, t := range cp {
                (*te) = append(*te, t)
        }
}

// ByName returns type el with given name, nil if not there
func (te *TypeEls) ByName(nm string) *TypeEl {
        for i := range *te {
                el := &(*te)[i]
                if el.Name == nm {
                        return el
                }
        }
        return nil
}

// ByType returns type el with given type, nil if not there
func (te *TypeEls) ByType(typ string) *TypeEl {
        for i := range *te {
                el := &(*te)[i]
                if el.Type == typ {
                        return el
                }
        }
        return nil
}

// String() satisfies the fmt.Stringer interface
func (te *TypeEls) String() string {
        return te.StringRange(0, len(*te))
}

// StringRange() returns a string rep of range of items
func (te *TypeEls) StringRange(st, n int) string {
        n = min(n, len(*te))
        str := ""
        for i := 0; i < n; i++ {
                tel := (*te)[st+i]
                str += tel.String()
                if i < n-1 {
                        str += ", "
                }
        }
        return str
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syms

import (
        "fmt"
        "io"
        "sort"
        "strings"
)

// TypeMap is a map of types for quick looking up by name
type TypeMap map[string]*Type

// Alloc ensures that map is made
func (tm *TypeMap) Alloc() {
        if *tm == nil {
                *tm = make(TypeMap)
        }
}

// Add adds a type to the map, handling allocation for nil maps
func (tm *TypeMap) Add(ty *Type) {
        tm.Alloc()
        (*tm)[ty.Name] = ty
}

// CopyFrom copies all the types from given source map into this one.
// Types that have Kind != Unknown are retained over unknown ones.
// srcIsNewer means that the src type is newer and should be used for
// other data like source
func (tm *TypeMap) CopyFrom(src TypeMap, srcIsNewer bool) {
        tm.Alloc()
        for nm, sty := range src {
                ety, has := (*tm)[nm]
                if !has {
                        (*tm)[nm] = sty
                        continue
                }
                if srcIsNewer {
                        ety.CopyFromSrc(sty)
                } else {
                        sty.CopyFromSrc(ety)
                }
                if ety.Kind != Unknown {
                        // if len(sty.Els) > 0 && len(sty.Els) != len(ety.Els) {
                        //         fmt.Printf("TypeMap dupe type: %v existing kind: %v els: %v new els: %v  kind: %v\n", nm, ety.Kind, len(ety.Els), len(sty.Els), sty.Kind)
                        // }
                } else if sty.Kind != Unknown {
                        // if len(ety.Els) > 0 && len(sty.Els) != len(ety.Els) {
                        //         fmt.Printf("TypeMap dupe type: %v new kind: %v els: %v existing els: %v\n", nm, sty.Kind, len(sty.Els), len(ety.Els))
                        // }
                        (*tm)[nm] = sty
                        // } else {
                        //         fmt.Printf("TypeMap dupe type: %v both unknown: existing els: %v new els: %v\n", nm, len(ety.Els), len(sty.Els))
                }
        }
}

// Clone returns deep copy of this type map -- types are Clone() copies.
// returns nil if this map is empty
func (tm *TypeMap) Clone() TypeMap {
        sz := len(*tm)
        if sz == 0 {
                return nil
        }
        ntm := make(TypeMap, sz)
        for nm, sty := range *tm {
                ntm[nm] = sty.Clone()
        }
        return ntm
}

// Names returns a slice of the names in this map, optionally sorted
func (tm *TypeMap) Names(sorted bool) []string {
        nms := make([]string, len(*tm))
        idx := 0
        for _, ty := range *tm {
                nms[idx] = ty.Name
                idx++
        }
        if sorted {
                sort.StringSlice(nms).Sort()
        }
        return nms
}

// KindNames returns a slice of the kind:names in this map, optionally sorted
func (tm *TypeMap) KindNames(sorted bool) []string {
        nms := make([]string, len(*tm))
        idx := 0
        for _, ty := range *tm {
                nms[idx] = ty.Kind.String() + ":" + ty.Name
                idx++
        }
        if sorted {
                sort.StringSlice(nms).Sort()
        }
        return nms
}

// PrintUnknowns prints all the types that have a Kind = Unknown
// indicates an error in type resolution
func (tm *TypeMap) PrintUnknowns() {
        for _, ty := range *tm {
                if ty.Kind != Unknown {
                        continue
                }
                fmt.Printf("Type named: %v has Kind = Unknown!  From file: %v:%v\n", ty.Name, ty.Filename, ty.Region)
        }
}

// WriteDoc writes basic doc info, sorted by kind and name
func (tm *TypeMap) WriteDoc(out io.Writer, depth int) {
        nms := tm.KindNames(true)
        for _, nm := range nms {
                ci := strings.Index(nm, ":")
                ty := (*tm)[nm[ci+1:]]
                ty.WriteDoc(out, depth)
        }
}

// TypeKindSize is used for initialization of builtin typemaps
type TypeKindSize struct {
        Name string
        Kind Kinds
        Size int
}

// Code generated by "core generate"; DO NOT EDIT.

package rich

import (
        "cogentcore.org/core/enums"
)

var _FamilyValues = []Family{0, 1, 2, 3, 4, 5, 6, 7, 8}

// FamilyN is the highest valid value for type Family, plus one.
const FamilyN Family = 9

var _FamilyValueMap = map[string]Family{`sans-serif`: 0, `serif`: 1, `monospace`: 2, `cursive`: 3, `fantasy`: 4, `math`: 5, `emoji`: 6, `fangsong`: 7, `custom`: 8}

var _FamilyDescMap = map[Family]string{0: `SansSerif is a font without serifs, where glyphs have plain stroke endings, without ornamentation. Example sans-serif fonts include Arial, Helvetica, Open Sans, Fira Sans, Lucida Sans, Lucida Sans Unicode, Trebuchet MS, Liberation Sans, and Nimbus Sans L.`, 1: `Serif is a small line or stroke attached to the end of a larger stroke in a letter. In serif fonts, glyphs have finishing strokes, flared or tapering ends. Examples include Times New Roman, Lucida Bright, Lucida Fax, Palatino, Palatino Linotype, Palladio, and URW Palladio.`, 2: `Monospace fonts have all glyphs with he same fixed width. Example monospace fonts include Fira Mono, DejaVu Sans Mono, Menlo, Consolas, Liberation Mono, Monaco, and Lucida Console.`, 3: `Cursive glyphs generally have either joining strokes or other cursive characteristics beyond those of italic typefaces. The glyphs are partially or completely connected, and the result looks more like handwritten pen or brush writing than printed letter work. Example cursive fonts include Brush Script MT, Brush Script Std, Lucida Calligraphy, Lucida Handwriting, and Apple Chancery.`, 4: `Fantasy fonts are primarily decorative fonts that contain playful representations of characters. Example fantasy fonts include Papyrus, Herculanum, Party LET, Curlz MT, and Harrington.`, 5: `Math fonts are for displaying mathematical expressions, for example superscript and subscript, brackets that cross several lines, nesting expressions, and double-struck glyphs with distinct meanings.`, 6: `Emoji fonts are specifically designed to render emoji.`, 7: `Fangsong are a particular style of Chinese characters that are between serif-style Song and cursive-style Kai forms. This style is often used for government documents.`, 8: `Custom is a custom font name that is specified in the [text.Style] CustomFont name.`}

var _FamilyMap = map[Family]string{0: `sans-serif`, 1: `serif`, 2: `monospace`, 3: `cursive`, 4: `fantasy`, 5: `math`, 6: `emoji`, 7: `fangsong`, 8: `custom`}

// String returns the string representation of this Family value.
func (i Family) String() string { return enums.String(i, _FamilyMap) }

// SetString sets the Family value from its string representation,
// and returns an error if the string is invalid.
func (i *Family) SetString(s string) error { return enums.SetString(i, s, _FamilyValueMap, "Family") }

// Int64 returns the Family value as an int64.
func (i Family) Int64() int64 { return int64(i) }

// SetInt64 sets the Family value from an int64.
func (i *Family) SetInt64(in int64) { *i = Family(in) }

// Desc returns the description of the Family value.
func (i Family) Desc() string { return enums.Desc(i, _FamilyDescMap) }

// FamilyValues returns all possible values for the type Family.
func FamilyValues() []Family { return _FamilyValues }

// Values returns all possible values for the type Family.
func (i Family) Values() []enums.Enum { return enums.Values(_FamilyValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Family) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Family) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Family") }

var _SlantsValues = []Slants{0, 1}

// SlantsN is the highest valid value for type Slants, plus one.
const SlantsN Slants = 2

var _SlantsValueMap = map[string]Slants{`normal`: 0, `italic`: 1}

var _SlantsDescMap = map[Slants]string{0: `A face that is neither italic not obliqued.`, 1: `A form that is generally cursive in nature or slanted. This groups what is usually called Italic or Oblique.`}

var _SlantsMap = map[Slants]string{0: `normal`, 1: `italic`}

// String returns the string representation of this Slants value.
func (i Slants) String() string { return enums.String(i, _SlantsMap) }

// SetString sets the Slants value from its string representation,
// and returns an error if the string is invalid.
func (i *Slants) SetString(s string) error { return enums.SetString(i, s, _SlantsValueMap, "Slants") }

// Int64 returns the Slants value as an int64.
func (i Slants) Int64() int64 { return int64(i) }

// SetInt64 sets the Slants value from an int64.
func (i *Slants) SetInt64(in int64) { *i = Slants(in) }

// Desc returns the description of the Slants value.
func (i Slants) Desc() string { return enums.Desc(i, _SlantsDescMap) }

// SlantsValues returns all possible values for the type Slants.
func SlantsValues() []Slants { return _SlantsValues }

// Values returns all possible values for the type Slants.
func (i Slants) Values() []enums.Enum { return enums.Values(_SlantsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Slants) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Slants) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Slants") }

var _WeightsValues = []Weights{0, 1, 2, 3, 4, 5, 6, 7, 8}

// WeightsN is the highest valid value for type Weights, plus one.
const WeightsN Weights = 9

var _WeightsValueMap = map[string]Weights{`thin`: 0, `extra-light`: 1, `light`: 2, `normal`: 3, `medium`: 4, `semibold`: 5, `bold`: 6, `extra-bold`: 7, `black`: 8}

var _WeightsDescMap = map[Weights]string{0: `Thin weight (100), the thinnest value.`, 1: `Extra light weight (200).`, 2: `Light weight (300).`, 3: `Normal (400).`, 4: `Medium weight (500, higher than normal).`, 5: `Semibold weight (600).`, 6: `Bold weight (700).`, 7: `Extra-bold weight (800).`, 8: `Black weight (900), the thickest value.`}

var _WeightsMap = map[Weights]string{0: `thin`, 1: `extra-light`, 2: `light`, 3: `normal`, 4: `medium`, 5: `semibold`, 6: `bold`, 7: `extra-bold`, 8: `black`}

// String returns the string representation of this Weights value.
func (i Weights) String() string { return enums.String(i, _WeightsMap) }

// SetString sets the Weights value from its string representation,
// and returns an error if the string is invalid.
func (i *Weights) SetString(s string) error {
        return enums.SetString(i, s, _WeightsValueMap, "Weights")
}

// Int64 returns the Weights value as an int64.
func (i Weights) Int64() int64 { return int64(i) }

// SetInt64 sets the Weights value from an int64.
func (i *Weights) SetInt64(in int64) { *i = Weights(in) }

// Desc returns the description of the Weights value.
func (i Weights) Desc() string { return enums.Desc(i, _WeightsDescMap) }

// WeightsValues returns all possible values for the type Weights.
func WeightsValues() []Weights { return _WeightsValues }

// Values returns all possible values for the type Weights.
func (i Weights) Values() []enums.Enum { return enums.Values(_WeightsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Weights) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Weights) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Weights") }

var _StretchValues = []Stretch{0, 1, 2, 3, 4, 5, 6, 7, 8}

// StretchN is the highest valid value for type Stretch, plus one.
const StretchN Stretch = 9

var _StretchValueMap = map[string]Stretch{`ultra-condensed`: 0, `extra-condensed`: 1, `condensed`: 2, `semi-condensed`: 3, `normal`: 4, `semi-expanded`: 5, `expanded`: 6, `extra-expanded`: 7, `ultra-expanded`: 8}

var _StretchDescMap = map[Stretch]string{0: `Ultra-condensed width (50%), the narrowest possible.`, 1: `Extra-condensed width (62.5%).`, 2: `Condensed width (75%).`, 3: `Semi-condensed width (87.5%).`, 4: `Normal width (100%).`, 5: `Semi-expanded width (112.5%).`, 6: `Expanded width (125%).`, 7: `Extra-expanded width (150%).`, 8: `Ultra-expanded width (200%), the widest possible.`}

var _StretchMap = map[Stretch]string{0: `ultra-condensed`, 1: `extra-condensed`, 2: `condensed`, 3: `semi-condensed`, 4: `normal`, 5: `semi-expanded`, 6: `expanded`, 7: `extra-expanded`, 8: `ultra-expanded`}

// String returns the string representation of this Stretch value.
func (i Stretch) String() string { return enums.String(i, _StretchMap) }

// SetString sets the Stretch value from its string representation,
// and returns an error if the string is invalid.
func (i *Stretch) SetString(s string) error {
        return enums.SetString(i, s, _StretchValueMap, "Stretch")
}

// Int64 returns the Stretch value as an int64.
func (i Stretch) Int64() int64 { return int64(i) }

// SetInt64 sets the Stretch value from an int64.
func (i *Stretch) SetInt64(in int64) { *i = Stretch(in) }

// Desc returns the description of the Stretch value.
func (i Stretch) Desc() string { return enums.Desc(i, _StretchDescMap) }

// StretchValues returns all possible values for the type Stretch.
func StretchValues() []Stretch { return _StretchValues }

// Values returns all possible values for the type Stretch.
func (i Stretch) Values() []enums.Enum { return enums.Values(_StretchValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Stretch) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Stretch) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Stretch") }

var _DecorationsValues = []Decorations{0, 1, 2, 3, 4, 5, 6, 7}

// DecorationsN is the highest valid value for type Decorations, plus one.
const DecorationsN Decorations = 8

var _DecorationsValueMap = map[string]Decorations{`underline`: 0, `overline`: 1, `line-through`: 2, `dotted-underline`: 3, `paragraph-start`: 4, `fill-color`: 5, `stroke-color`: 6, `background`: 7}

var _DecorationsDescMap = map[Decorations]string{0: `Underline indicates to place a line below text.`, 1: `Overline indicates to place a line above text.`, 2: `LineThrough indicates to place a line through text.`, 3: `DottedUnderline is used for abbr tag.`, 4: `ParagraphStart indicates that this text is the start of a paragraph, and therefore may be indented according to [text.Style] settings.`, 5: `FillColor means that the fill color of the glyph is set. The standard font rendering uses this fill color (compare to StrokeColor).`, 6: `StrokeColor means that the stroke color of the glyph is set. This is normally not rendered: it looks like an outline of the glyph at larger font sizes, and will make smaller font sizes look significantly thicker.`, 7: `Background means that the background region behind the text is colored. The background is not normally colored so it renders over any background.`}

var _DecorationsMap = map[Decorations]string{0: `underline`, 1: `overline`, 2: `line-through`, 3: `dotted-underline`, 4: `paragraph-start`, 5: `fill-color`, 6: `stroke-color`, 7: `background`}

// String returns the string representation of this Decorations value.
func (i Decorations) String() string { return enums.BitFlagString(i, _DecorationsValues) }

// BitIndexString returns the string representation of this Decorations value
// if it is a bit index value (typically an enum constant), and
// not an actual bit flag value.
func (i Decorations) BitIndexString() string { return enums.String(i, _DecorationsMap) }

// SetString sets the Decorations value from its string representation,
// and returns an error if the string is invalid.
func (i *Decorations) SetString(s string) error { *i = 0; return i.SetStringOr(s) }

// SetStringOr sets the Decorations value from its string representation
// while preserving any bit flags already set, and returns an
// error if the string is invalid.
func (i *Decorations) SetStringOr(s string) error {
        return enums.SetStringOr(i, s, _DecorationsValueMap, "Decorations")
}

// Int64 returns the Decorations value as an int64.
func (i Decorations) Int64() int64 { return int64(i) }

// SetInt64 sets the Decorations value from an int64.
func (i *Decorations) SetInt64(in int64) { *i = Decorations(in) }

// Desc returns the description of the Decorations value.
func (i Decorations) Desc() string { return enums.Desc(i, _DecorationsDescMap) }

// DecorationsValues returns all possible values for the type Decorations.
func DecorationsValues() []Decorations { return _DecorationsValues }

// Values returns all possible values for the type Decorations.
func (i Decorations) Values() []enums.Enum { return enums.Values(_DecorationsValues) }

// HasFlag returns whether these bit flags have the given bit flag set.
func (i *Decorations) HasFlag(f enums.BitFlag) bool { return enums.HasFlag((*int64)(i), f) }

// SetFlag sets the value of the given flags in these flags to the given value.
func (i *Decorations) SetFlag(on bool, f ...enums.BitFlag) { enums.SetFlag((*int64)(i), on, f...) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Decorations) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Decorations) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Decorations")
}

var _SpecialsValues = []Specials{0, 1, 2, 3, 4, 5, 6, 7}

// SpecialsN is the highest valid value for type Specials, plus one.
const SpecialsN Specials = 8

var _SpecialsValueMap = map[string]Specials{`nothing`: 0, `super`: 1, `sub`: 2, `link`: 3, `math-inline`: 4, `math-display`: 5, `quote`: 6, `end`: 7}

var _SpecialsDescMap = map[Specials]string{0: `Nothing special.`, 1: `Super starts super-scripted text.`, 2: `Sub starts sub-scripted text.`, 3: `Link starts a hyperlink, which is in the URL field of the style, and encoded in the runes after the style runes. It also identifies this span for functional interactions such as hovering and clicking. It does not specify the styling, which therefore must be set in addition.`, 4: `MathInline starts a TeX formatted math sequence, styled for inclusion inline with other text.`, 5: `MathDisplay starts a TeX formatted math sequence, styled as a larger standalone display.`, 6: `Quote starts an indented paragraph-level quote.`, 7: `End must be added to terminate the last Special started: use [Text.AddEnd]. The renderer maintains a stack of special elements.`}

var _SpecialsMap = map[Specials]string{0: `nothing`, 1: `super`, 2: `sub`, 3: `link`, 4: `math-inline`, 5: `math-display`, 6: `quote`, 7: `end`}

// String returns the string representation of this Specials value.
func (i Specials) String() string { return enums.String(i, _SpecialsMap) }

// SetString sets the Specials value from its string representation,
// and returns an error if the string is invalid.
func (i *Specials) SetString(s string) error {
        return enums.SetString(i, s, _SpecialsValueMap, "Specials")
}

// Int64 returns the Specials value as an int64.
func (i Specials) Int64() int64 { return int64(i) }

// SetInt64 sets the Specials value from an int64.
func (i *Specials) SetInt64(in int64) { *i = Specials(in) }

// Desc returns the description of the Specials value.
func (i Specials) Desc() string { return enums.Desc(i, _SpecialsDescMap) }

// SpecialsValues returns all possible values for the type Specials.
func SpecialsValues() []Specials { return _SpecialsValues }

// Values returns all possible values for the type Specials.
func (i Specials) Values() []enums.Enum { return enums.Values(_SpecialsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Specials) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Specials) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Specials") }

var _DirectionsValues = []Directions{0, 1, 2, 3, 4}

// DirectionsN is the highest valid value for type Directions, plus one.
const DirectionsN Directions = 5

var _DirectionsValueMap = map[string]Directions{`ltr`: 0, `rtl`: 1, `ttb`: 2, `btt`: 3, `default`: 4}

var _DirectionsDescMap = map[Directions]string{0: `LTR is Left-to-Right text.`, 1: `RTL is Right-to-Left text.`, 2: `TTB is Top-to-Bottom text.`, 3: `BTT is Bottom-to-Top text.`, 4: `Default uses the [text.Style] default direction.`}

var _DirectionsMap = map[Directions]string{0: `ltr`, 1: `rtl`, 2: `ttb`, 3: `btt`, 4: `default`}

// String returns the string representation of this Directions value.
func (i Directions) String() string { return enums.String(i, _DirectionsMap) }

// SetString sets the Directions value from its string representation,
// and returns an error if the string is invalid.
func (i *Directions) SetString(s string) error {
        return enums.SetString(i, s, _DirectionsValueMap, "Directions")
}

// Int64 returns the Directions value as an int64.
func (i Directions) Int64() int64 { return int64(i) }

// SetInt64 sets the Directions value from an int64.
func (i *Directions) SetInt64(in int64) { *i = Directions(in) }

// Desc returns the description of the Directions value.
func (i Directions) Desc() string { return enums.Desc(i, _DirectionsDescMap) }

// DirectionsValues returns all possible values for the type Directions.
func DirectionsValues() []Directions { return _DirectionsValues }

// Values returns all possible values for the type Directions.
func (i Directions) Values() []enums.Enum { return enums.Values(_DirectionsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Directions) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Directions) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "Directions")
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rich

import (
        "cogentcore.org/core/text/textpos"
)

// Hyperlink represents a hyperlink within shaped text.
type Hyperlink struct {
        // Label is the text label for the link.
        Label string

        // URL is the full URL for the link.
        URL string

        // Properties are additional properties defined for the link,
        // e.g., from the parsed HTML attributes. TODO: resolve
        // Properties map[string]any

        // Range defines the starting and ending positions of the link,
        // in terms of source rune indexes.
        Range textpos.Range
}

// GetLinks gets all the links from the source.
func (tx Text) GetLinks() []Hyperlink {
        var lks []Hyperlink
        n := len(tx)
        for si := range n {
                sp := RuneToSpecial(tx[si][0])
                if sp != Link {
                        continue
                }
                lr := tx.SpecialRange(si)
                if lr.End < 0 || lr.End <= lr.Start {
                        continue
                }
                ls := tx[lr.Start:lr.End]
                s, _ := tx.Span(si)
                lk := Hyperlink{}
                lk.URL = s.URL
                sr, _ := tx.Range(lr.Start)
                _, er := tx.Range(lr.End)
                lk.Range = textpos.Range{sr, er}
                lk.Label = string(ls.Join())
                lks = append(lks, lk)
                si = lr.End
        }
        return lks
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rich

import (
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/styles/styleprops"
)

// FromProperties sets style field values based on the given property list.
func (s *Style) FromProperties(parent *Style, properties map[string]any, ctxt colors.Context) {
        for key, val := range properties {
                if len(key) == 0 {
                        continue
                }
                if key[0] == '#' || key[0] == '.' || key[0] == ':' || key[0] == '_' {
                        continue
                }
                s.FromProperty(parent, key, val, ctxt)
        }
}

// FromProperty sets style field values based on the given property key and value.
func (s *Style) FromProperty(parent *Style, key string, val any, cc colors.Context) {
        if sfunc, ok := styleFuncs[key]; ok {
                if parent != nil {
                        sfunc(s, key, val, parent, cc)
                } else {
                        sfunc(s, key, val, nil, cc)
                }
                return
        }
}

// FontSizePoints maps standard font names to standard point sizes -- we use
// dpi zoom scaling instead of rescaling "medium" font size, so generally use
// these values as-is.  smaller and larger relative scaling can move in 2pt increments
var FontSizes = map[string]float32{
        "xx-small": 6.0 / 12.0,
        "x-small":  8.0 / 12.0,
        "small":    10.0 / 12.0, // small is also "smaller"
        "smallf":   10.0 / 12.0, // smallf = small font size..
        "medium":   1,
        "large":    14.0 / 12.0,
        "x-large":  18.0 / 12.0,
        "xx-large": 24.0 / 12.0,
}

// styleFuncs are functions for styling the rich.Style object.
var styleFuncs = map[string]styleprops.Func{
        // note: text.Style handles the standard units-based font-size settings
        "font-size": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Size = parent.(*Style).Size
                        } else if init {
                                fs.Size = 1.0
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        if psz, ok := FontSizes[vt]; ok {
                                fs.Size = psz
                        }
                }
        },
        "font-family": styleprops.Enum(SansSerif,
                func(obj *Style) enums.EnumSetter { return &obj.Family }),
        "font-style": styleprops.Enum(SlantNormal,
                func(obj *Style) enums.EnumSetter { return &obj.Slant }),
        "font-weight": styleprops.Enum(Normal,
                func(obj *Style) enums.EnumSetter { return &obj.Weight }),
        "font-stretch": styleprops.Enum(StretchNormal,
                func(obj *Style) enums.EnumSetter { return &obj.Stretch }),
        "text-decoration": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.Decoration = parent.(*Style).Decoration
                        } else if init {
                                fs.Decoration = 0
                        }
                        return
                }
                switch vt := val.(type) {
                case string:
                        if vt == "none" {
                                fs.Decoration = 0
                        } else {
                                fs.Decoration.SetString(vt)
                        }
                case Decorations:
                        fs.Decoration = vt
                default:
                        iv, err := reflectx.ToInt(val)
                        if err == nil {
                                fs.Decoration = Decorations(iv)
                        } else {
                                styleprops.SetError(key, val, err)
                        }
                }
        },
        "direction": styleprops.Enum(LTR,
                func(obj *Style) enums.EnumSetter { return &obj.Direction }),
        "color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.SetFillColor(parent.(*Style).FillColor())
                        } else if init {
                                fs.SetFillColor(nil)
                        }
                        return
                }
                fs.SetFillColor(colors.ToUniform(errors.Log1(gradient.FromAny(val, cc))))
        },
        "stroke-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.SetStrokeColor(parent.(*Style).StrokeColor())
                        } else if init {
                                fs.SetStrokeColor(nil)
                        }
                        return
                }
                fs.SetStrokeColor(colors.ToUniform(errors.Log1(gradient.FromAny(val, cc))))
        },
        "background-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.SetBackground(parent.(*Style).Background())
                        } else if init {
                                fs.SetBackground(nil)
                        }
                        return
                }
                fs.SetBackground(colors.ToUniform(errors.Log1(gradient.FromAny(val, cc))))
        },
        "opacity": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        return
                }
                fv, _ := reflectx.ToFloat(val)
                if fv < 1 {
                        if fs.background != nil {
                                fs.background = colors.ApplyOpacity(fs.background, float32(fv))
                        }
                        if fs.strokeColor != nil {
                                fs.strokeColor = colors.ApplyOpacity(fs.strokeColor, float32(fv))
                        }
                        if fs.fillColor != nil {
                                fs.fillColor = colors.ApplyOpacity(fs.fillColor, float32(fv))
                        }
                }
        },
}

// SetFromHTMLTag sets the styling parameters for simple HTML style tags.
// Returns true if handled.
func (s *Style) SetFromHTMLTag(tag string) bool {
        did := false
        switch tag {
        case "b", "strong":
                s.Weight = Bold
                did = true
        case "i", "em", "var", "cite":
                s.Slant = Italic
                did = true
        case "ins":
                fallthrough
        case "u":
                s.Decoration.SetFlag(true, Underline)
                did = true
        case "s", "del", "strike":
                s.Decoration.SetFlag(true, LineThrough)
                did = true
        case "small":
                s.Size = 0.8
                did = true
        case "big":
                s.Size = 1.2
                did = true
        case "xx-small", "x-small", "smallf", "medium", "large", "x-large", "xx-large":
                s.Size = FontSizes[tag]
                did = true
        case "mark":
                s.SetBackground(colors.ToUniform(colors.Scheme.Warn.Container))
                did = true
        case "abbr", "acronym":
                s.Decoration.SetFlag(true, DottedUnderline)
                did = true
        case "tt", "kbd", "samp", "code":
                s.Family = Monospace
                s.SetBackground(colors.ToUniform(colors.Scheme.SurfaceContainer))
                did = true
        }
        return did
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rich

import (
        "strings"

        "github.com/go-text/typesetting/language"
)

func init() {
        DefaultSettings.Defaults()
}

// DefaultSettings contains the default global text settings.
// This will be updated from rich.DefaultSettings.
var DefaultSettings Settings

// FontName is a special string that provides a font chooser.
// It is aliased to [core.FontName] as well.
type FontName string

// Settings holds the global settings for rich text styling,
// including language, script, and preferred font faces for
// each category of font.
type Settings struct {

        // Language is the preferred language used for rendering text.
        Language language.Language

        // Script is the specific writing system used for rendering text.
        // todo: no idea how to set this based on language or anything else.
        Script language.Script `display:"-"`

        // SansSerif is a font without serifs, where glyphs have plain stroke endings,
        // without ornamentation. Example sans-serif fonts include Arial, Helvetica,
        // Noto Sans, Open Sans, Fira Sans, Lucida Sans, Lucida Sans Unicode, Trebuchet MS,
        // Liberation Sans, Nimbus Sans L, Roboto.
        // This can be a list of comma-separated names, tried in order.
        // "sans-serif" will be added automatically as a final backup.
        SansSerif FontName `default:"Noto Sans"`

        // Serif is a small line or stroke attached to the end of a larger stroke
        // in a letter. In serif fonts, glyphs have finishing strokes, flared or
        // tapering ends. Examples include Times New Roman, Lucida Bright,
        // Lucida Fax, Palatino, Palatino Linotype, Palladio, and URW Palladio.
        // This can be a list of comma-separated names, tried in order.
        // "serif" will be added automatically as a final backup.
        Serif FontName

        // Monospace fonts have all glyphs with he same fixed width.
        // Example monospace fonts include Roboto Mono, Fira Mono, DejaVu Sans Mono,
        // Menlo, Consolas, Liberation Mono, Monaco, and Lucida Console.
        // This can be a list of comma-separated names. serif will be added
        // automatically as a final backup.
        // This can be a list of comma-separated names, tried in order.
        // "monospace" will be added automatically as a final backup.
        Monospace FontName `default:"Roboto Mono"`

        // Cursive glyphs generally have either joining strokes or other cursive
        // characteristics beyond those of italic typefaces. The glyphs are partially
        // or completely connected, and the result looks more like handwritten pen or
        // brush writing than printed letter work. Example cursive fonts include
        // Brush Script MT, Brush Script Std, Lucida Calligraphy, Lucida Handwriting,
        // and Apple Chancery.
        // This can be a list of comma-separated names, tried in order.
        // "cursive" will be added automatically as a final backup.
        Cursive FontName

        // Fantasy fonts are primarily decorative fonts that contain playful
        // representations of characters. Example fantasy fonts include Papyrus,
        // Herculanum, Party LET, Curlz MT, and Harrington.
        // This can be a list of comma-separated names, tried in order.
        // "fantasy" will be added automatically as a final backup.
        Fantasy FontName

        // Math fonts are for displaying mathematical expressions, for example
        // superscript and subscript, brackets that cross several lines, nesting
        // expressions, and double-struck glyphs with distinct meanings.
        // This can be a list of comma-separated names, tried in order.
        // "math" will be added automatically as a final backup.
        Math FontName

        // Emoji fonts are specifically designed to render emoji.
        // This can be a list of comma-separated names, tried in order.
        // "emoji" will be added automatically as a final backup.
        Emoji FontName

        // Fangsong are a particular style of Chinese characters that are between
        // serif-style Song and cursive-style Kai forms. This style is often used
        // for government documents.
        // This can be a list of comma-separated names, tried in order.
        // "fangsong" will be added automatically as a final backup.
        Fangsong FontName
}

func (rts *Settings) Defaults() {
        rts.Language = language.DefaultLanguage()
        rts.SansSerif = "Noto Sans"
        rts.Monospace = "Roboto Mono"
}

// AddFamily adds a family specifier to the given font string,
// handling the comma properly.
func AddFamily(rts FontName, fam string) string {
        if rts == "" {
                return fam
        }
        s := string(rts)
        // if strings.Contains(s, " ") { // no! this is bad
        //         s = `"` + s + `"`
        // }
        return s + ", " + fam
}

// FamiliesToList returns a list of the families, split by comma and space removed.
func FamiliesToList(fam string) []string {
        fs := strings.Split(fam, ",")
        os := make([]string, 0, len(fs))
        for _, f := range fs {
                rts := strings.TrimSpace(f)
                if rts == "" {
                        continue
                }
                os = append(os, rts)
        }
        return os
}

// Family returns the font family specified by the given [Family] enum.
func (rts *Settings) Family(fam Family) string {
        switch fam {
        case SansSerif:
                return AddFamily(rts.SansSerif, `-apple-system, BlinkMacSystemFont, "Segoe UI", Oxygen, Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif, emoji`)
        case Serif:
                return AddFamily(rts.Serif, `serif, emoji`)
        case Monospace:
                return AddFamily(rts.Monospace, `monospace, emoji`)
        case Cursive:
                return AddFamily(rts.Cursive, `cursive, emoji`)
        case Fantasy:
                return AddFamily(rts.Fantasy, `fantasy, emoji`)
        case Math:
                return AddFamily(rts.Math, "math")
        case Emoji:
                return AddFamily(rts.Emoji, "emoji")
        case Fangsong:
                return AddFamily(rts.Fangsong, "fangsong")
        }
        return "sans-serif"
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rich

import (
        "image/color"
        "math"
)

// srune is a uint32 rune value that encodes the font styles.
// There is no attempt to pack these values into the Private Use Areas
// of unicode, because they are never encoded into the unicode directly.
// Because we have the room, we use at least 4 bits = 1 hex F for each
// element of the style property. Size and Color values are added after
// the main style rune element.

// RuneFromStyle returns the style rune that encodes the given style values.
func RuneFromStyle(s *Style) rune {
        return RuneFromDecoration(s.Decoration) | RuneFromSpecial(s.Special) | RuneFromStretch(s.Stretch) | RuneFromWeight(s.Weight) | RuneFromSlant(s.Slant) | RuneFromFamily(s.Family) | RuneFromDirection(s.Direction)
}

// RuneToStyle sets all the style values decoded from given rune.
func RuneToStyle(s *Style, r rune) {
        s.Decoration = RuneToDecoration(r)
        s.Special = RuneToSpecial(r)
        s.Stretch = RuneToStretch(r)
        s.Weight = RuneToWeight(r)
        s.Slant = RuneToSlant(r)
        s.Family = RuneToFamily(r)
        s.Direction = RuneToDirection(r)
}

// SpanLen returns the length of the starting style runes and
// following content runes for given slice of span runes.
// Does not need to decode full style, so is very efficient.
func SpanLen(s []rune) (sn int, rn int) {
        r0 := s[0]
        nc := RuneToDecoration(r0).NumColors()
        sn = 2 + nc // style + size + nc
        isLink := RuneToSpecial(r0) == Link
        if !isLink {
                rn = max(0, len(s)-sn)
                return
        }
        ln := int(s[sn]) // link len
        sn += ln + 1
        rn = max(0, len(s)-sn)
        return
}

// FromRunes sets the Style properties from the given rune encodings
// which must be the proper length including colors. Any remaining
// runes after the style runes are returned: this is the source string.
func (s *Style) FromRunes(rs []rune) []rune {
        RuneToStyle(s, rs[0])
        s.Size = math.Float32frombits(uint32(rs[1]))
        ci := 2
        if s.Decoration.HasFlag(FillColor) {
                s.fillColor = ColorFromRune(rs[ci])
                ci++
        }
        if s.Decoration.HasFlag(StrokeColor) {
                s.strokeColor = ColorFromRune(rs[ci])
                ci++
        }
        if s.Decoration.HasFlag(Background) {
                s.background = ColorFromRune(rs[ci])
                ci++
        }
        if s.Special == Link {
                ln := int(rs[ci])
                ci++
                s.URL = string(rs[ci : ci+ln])
                ci += ln
        }
        if ci < len(rs) {
                return rs[ci:]
        }
        return nil
}

// ToRunes returns the rune(s) that encode the given style
// including any additional colors beyond the style and size runes,
// and the URL for a link.
func (s *Style) ToRunes() []rune {
        r := RuneFromStyle(s)
        rs := []rune{r, rune(math.Float32bits(s.Size))}
        if s.Decoration.NumColors() == 0 {
                return rs
        }
        if s.Decoration.HasFlag(FillColor) {
                rs = append(rs, ColorToRune(s.fillColor))
        }
        if s.Decoration.HasFlag(StrokeColor) {
                rs = append(rs, ColorToRune(s.strokeColor))
        }
        if s.Decoration.HasFlag(Background) {
                rs = append(rs, ColorToRune(s.background))
        }
        if s.Special == Link {
                rs = append(rs, rune(len(s.URL)))
                rs = append(rs, []rune(s.URL)...)
        }
        return rs
}

// ColorToRune converts given color to a rune uint32 value.
func ColorToRune(c color.Color) rune {
        r, g, b, a := c.RGBA() // uint32
        r8 := r >> 8
        g8 := g >> 8
        b8 := b >> 8
        a8 := a >> 8
        return rune(r8<<24) + rune(g8<<16) + rune(b8<<8) + rune(a8)
}

// ColorFromRune converts given color from a rune uint32 value.
func ColorFromRune(r rune) color.RGBA {
        ru := uint32(r)
        r8 := uint8((ru & 0xFF000000) >> 24)
        g8 := uint8((ru & 0x00FF0000) >> 16)
        b8 := uint8((ru & 0x0000FF00) >> 8)
        a8 := uint8((ru & 0x000000FF))
        return color.RGBA{r8, g8, b8, a8}
}

const (
        DecorationStart = 0
        DecorationMask  = 0x000007FF // 11 bits reserved for deco
        SlantStart      = 11
        SlantMask       = 0x00000800 // 1 bit for slant
        SpecialStart    = 12
        SpecialMask     = 0x0000F000
        StretchStart    = 16
        StretchMask     = 0x000F0000
        WeightStart     = 20
        WeightMask      = 0x00F00000
        FamilyStart     = 24
        FamilyMask      = 0x0F000000
        DirectionStart  = 28
        DirectionMask   = 0xF0000000
)

// RuneFromDecoration returns the rune bit values for given decoration.
func RuneFromDecoration(d Decorations) rune {
        return rune(d)
}

// RuneToDecoration returns the Decoration bit values from given rune.
func RuneToDecoration(r rune) Decorations {
        return Decorations(uint32(r) & DecorationMask)
}

// RuneFromSpecial returns the rune bit values for given special.
func RuneFromSpecial(d Specials) rune {
        return rune(d << SpecialStart)
}

// RuneToSpecial returns the Specials value from given rune.
func RuneToSpecial(r rune) Specials {
        return Specials((uint32(r) & SpecialMask) >> SpecialStart)
}

// RuneFromStretch returns the rune bit values for given stretch.
func RuneFromStretch(d Stretch) rune {
        return rune(d << StretchStart)
}

// RuneToStretch returns the Stretch value from given rune.
func RuneToStretch(r rune) Stretch {
        return Stretch((uint32(r) & StretchMask) >> StretchStart)
}

// RuneFromWeight returns the rune bit values for given weight.
func RuneFromWeight(d Weights) rune {
        return rune(d << WeightStart)
}

// RuneToWeight returns the Weights value from given rune.
func RuneToWeight(r rune) Weights {
        return Weights((uint32(r) & WeightMask) >> WeightStart)
}

// RuneFromSlant returns the rune bit values for given slant.
func RuneFromSlant(d Slants) rune {
        return rune(d << SlantStart)
}

// RuneToSlant returns the Slants value from given rune.
func RuneToSlant(r rune) Slants {
        return Slants((uint32(r) & SlantMask) >> SlantStart)
}

// RuneFromFamily returns the rune bit values for given family.
func RuneFromFamily(d Family) rune {
        return rune(d << FamilyStart)
}

// RuneToFamily returns the Familys value from given rune.
func RuneToFamily(r rune) Family {
        return Family((uint32(r) & FamilyMask) >> FamilyStart)
}

// RuneFromDirection returns the rune bit values for given direction.
func RuneFromDirection(d Directions) rune {
        return rune(d << DirectionStart)
}

// RuneToDirection returns the Directions value from given rune.
func RuneToDirection(r rune) Directions {
        return Directions((uint32(r) & DirectionMask) >> DirectionStart)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rich

import (
        "fmt"
        "image/color"
        "strings"

        "cogentcore.org/core/colors"
        "github.com/go-text/typesetting/di"
)

//go:generate core generate

// IMPORTANT: enums must remain in sync with
// "github.com/go-text/typesetting/font"
// and props.go must be updated as needed.

// Style contains all of the rich text styling properties, that apply to one
// span of text. These are encoded into a uint32 rune value in [rich.Text].
// See [text.Style] and [Settings] for additional context needed for full specification.
type Style struct { //types:add -setters

        // Size is the font size multiplier relative to the standard font size
        // specified in the [text.Style].
        Size float32

        // Family indicates the generic family of typeface to use, where the
        // specific named values to use for each are provided in the [Settings],
        // or [text.Style] for [Custom].
        Family Family

        // Slant allows italic or oblique faces to be selected.
        Slant Slants

        // Weights are the degree of blackness or stroke thickness of a font.
        // This value ranges from 100.0 to 900.0, with 400.0 as normal.
        Weight Weights

        // Stretch is the width of a font as an approximate fraction of the normal width.
        // Widths range from 0.5 to 2.0 inclusive, with 1.0 as the normal width.
        Stretch Stretch

        // Special additional formatting factors that are not otherwise
        // captured by changes in font rendering properties or decorations.
        // See [Specials] for usage information: use [Text.StartSpecial]
        // and [Text.EndSpecial] to set.
        Special Specials

        // Decorations are underline, line-through, etc, as bit flags
        // that must be set using [Decorations.SetFlag].
        Decoration Decorations `set:"-"`

        // Direction is the direction to render the text.
        Direction Directions

        // fillColor is the color to use for glyph fill (i.e., the standard "ink" color).
        // Must use SetFillColor to set Decoration FillColor flag.
        // This will be encoded in a uint32 following the style rune, in rich.Text spans.
        fillColor color.Color

        // strokeColor is the color to use for glyph outline stroking.
        // Must use SetStrokeColor to set Decoration StrokeColor flag.
        // This will be encoded in a uint32 following the style rune, in rich.Text spans.
        strokeColor color.Color

        // background is the color to use for the background region.
        // Must use SetBackground to set the Decoration Background flag.
        // This will be encoded in a uint32 following the style rune, in rich.Text spans.
        background color.Color `set:"-"`

        // URL is the URL for a link element. It is encoded in runes after the style runes.
        URL string
}

func NewStyle() *Style {
        s := &Style{}
        s.Defaults()
        return s
}

// Clone returns a copy of this style.
func (s *Style) Clone() *Style {
        ns := &Style{}
        *ns = *s
        return ns
}

// NewStyleFromRunes returns a new style initialized with data from given runes,
// returning the remaining actual rune string content after style data.
func NewStyleFromRunes(rs []rune) (*Style, []rune) {
        s := NewStyle()
        c := s.FromRunes(rs)
        return s, c
}

func (s *Style) Defaults() {
        s.Size = 1
        s.Weight = Normal
        s.Stretch = StretchNormal
        s.Direction = Default
}

// InheritFields from parent
func (s *Style) InheritFields(parent *Style) {
        // fs.Color = par.Color
        s.Family = parent.Family
        s.Slant = parent.Slant
        if parent.Size != 0 {
                s.Size = parent.Size
        }
        s.Weight = parent.Weight
        s.Stretch = parent.Stretch
}

// FontFamily returns the font family name(s) based on [Style.Family] and the
// values specified in the given [Settings].
func (s *Style) FontFamily(ctx *Settings) string {
        return ctx.Family(s.Family)
}

// Family specifies the generic family of typeface to use, where the
// specific named values to use for each are provided in the Settings.
type Family int32 //enums:enum -trim-prefix Family -transform kebab

const (
        // SansSerif is a font without serifs, where glyphs have plain stroke endings,
        // without ornamentation. Example sans-serif fonts include Arial, Helvetica,
        // Open Sans, Fira Sans, Lucida Sans, Lucida Sans Unicode, Trebuchet MS,
        // Liberation Sans, and Nimbus Sans L.
        SansSerif Family = iota

        // Serif is a small line or stroke attached to the end of a larger stroke
        // in a letter. In serif fonts, glyphs have finishing strokes, flared or
        // tapering ends. Examples include Times New Roman, Lucida Bright,
        // Lucida Fax, Palatino, Palatino Linotype, Palladio, and URW Palladio.
        Serif

        // Monospace fonts have all glyphs with he same fixed width.
        // Example monospace fonts include Fira Mono, DejaVu Sans Mono,
        // Menlo, Consolas, Liberation Mono, Monaco, and Lucida Console.
        Monospace

        // Cursive glyphs generally have either joining strokes or other cursive
        // characteristics beyond those of italic typefaces. The glyphs are partially
        // or completely connected, and the result looks more like handwritten pen or
        // brush writing than printed letter work. Example cursive fonts include
        // Brush Script MT, Brush Script Std, Lucida Calligraphy, Lucida Handwriting,
        // and Apple Chancery.
        Cursive

        // Fantasy fonts are primarily decorative fonts that contain playful
        // representations of characters. Example fantasy fonts include Papyrus,
        // Herculanum, Party LET, Curlz MT, and Harrington.
        Fantasy

        //        Math fonts are for displaying mathematical expressions, for example
        // superscript and subscript, brackets that cross several lines, nesting
        // expressions, and double-struck glyphs with distinct meanings.
        Math

        // Emoji fonts are specifically designed to render emoji.
        Emoji

        // Fangsong are a particular style of Chinese characters that are between
        // serif-style Song and cursive-style Kai forms. This style is often used
        // for government documents.
        Fangsong

        // Custom is a custom font name that is specified in the [text.Style]
        // CustomFont name.
        Custom
)

// Slants (also called style) allows italic or oblique faces to be selected.
type Slants int32 //enums:enum -trim-prefix Slant -transform kebab

const (

        // A face that is neither italic not obliqued.
        SlantNormal Slants = iota

        // A form that is generally cursive in nature or slanted.
        // This groups what is usually called Italic or Oblique.
        Italic
)

// Weights are the degree of blackness or stroke thickness of a font.
// The corresponding value ranges from 100.0 to 900.0, with 400.0 as normal.
type Weights int32 //enums:enum -transform kebab

const (
        // Thin weight (100), the thinnest value.
        Thin Weights = iota

        // Extra light weight (200).
        ExtraLight

        // Light weight (300).
        Light

        // Normal (400).
        Normal

        // Medium weight (500, higher than normal).
        Medium

        // Semibold weight (600).
        Semibold

        // Bold weight (700).
        Bold

        // Extra-bold weight (800).
        ExtraBold

        // Black weight (900), the thickest value.
        Black
)

// ToFloat32 converts the weight to its numerical 100x value
func (w Weights) ToFloat32() float32 {
        return float32((w + 1) * 100)
}

func (w Weights) HTMLTag() string {
        switch w {
        case Bold:
                return "b"
        }
        return ""
}

// Stretch is the width of a font as an approximate fraction of the normal width.
// Widths range from 0.5 to 2.0 inclusive, with 1.0 as the normal width.
type Stretch int32 //enums:enum -trim-prefix Stretch -transform kebab

const (

        // Ultra-condensed width (50%), the narrowest possible.
        UltraCondensed Stretch = iota

        // Extra-condensed width (62.5%).
        ExtraCondensed

        // Condensed width (75%).
        Condensed

        // Semi-condensed width (87.5%).
        SemiCondensed

        // Normal width (100%).
        StretchNormal

        // Semi-expanded width (112.5%).
        SemiExpanded

        // Expanded width (125%).
        Expanded

        // Extra-expanded width (150%).
        ExtraExpanded

        // Ultra-expanded width (200%), the widest possible.
        UltraExpanded
)

var stretchFloatValues = []float32{0.5, 0.625, 0.75, 0.875, 1, 1.125, 1.25, 1.5, 2.0}

// ToFloat32 converts the stretch to its numerical multiplier value
func (s Stretch) ToFloat32() float32 {
        return stretchFloatValues[s]
}

// note: 11 bits reserved, 8 used

// Decorations are underline, line-through, etc, as bit flags
// that must be set using [Font.SetDecoration].
type Decorations int64 //enums:bitflag -transform kebab

const (
        // Underline indicates to place a line below text.
        Underline Decorations = iota

        // Overline indicates to place a line above text.
        Overline

        // LineThrough indicates to place a line through text.
        LineThrough

        // DottedUnderline is used for abbr tag.
        DottedUnderline

        // ParagraphStart indicates that this text is the start of a paragraph,
        // and therefore may be indented according to [text.Style] settings.
        ParagraphStart

        // FillColor means that the fill color of the glyph is set.
        // The standard font rendering uses this fill color (compare to StrokeColor).
        FillColor

        // StrokeColor means that the stroke color of the glyph is set.
        // This is normally not rendered: it looks like an outline of the glyph at
        // larger font sizes, and will make smaller font sizes look significantly thicker.
        StrokeColor

        // Background means that the background region behind the text is colored.
        // The background is not normally colored so it renders over any background.
        Background
)

// NumColors returns the number of colors used by this decoration setting.
func (d Decorations) NumColors() int {
        nc := 0
        if d.HasFlag(FillColor) {
                nc++
        }
        if d.HasFlag(StrokeColor) {
                nc++
        }
        if d.HasFlag(Background) {
                nc++
        }
        return nc
}

// Specials are special additional mutually exclusive formatting factors that are not
// otherwise captured by changes in font rendering properties or decorations.
// Each special must be terminated by an End span element, on its own, which
// pops the stack on the last special that was started.
// Use [Text.StartSpecial] and [Text.EndSpecial] to manage the specials,
// avoiding the potential for repeating the start of a given special.
type Specials int32 //enums:enum -transform kebab

const (
        // Nothing special.
        Nothing Specials = iota

        // Super starts super-scripted text.
        Super

        // Sub starts sub-scripted text.
        Sub

        // Link starts a hyperlink, which is in the URL field of the
        // style, and encoded in the runes after the style runes.
        // It also identifies this span for functional interactions
        // such as hovering and clicking. It does not specify the styling,
        // which therefore must be set in addition.
        Link

        // MathInline starts a TeX formatted math sequence, styled for
        // inclusion inline with other text.
        MathInline

        // MathDisplay starts a TeX formatted math sequence, styled as
        // a larger standalone display.
        MathDisplay

        // Quote starts an indented paragraph-level quote.
        Quote

        // todo: could add SmallCaps here?

        // End must be added to terminate the last Special started: use [Text.AddEnd].
        // The renderer maintains a stack of special elements.
        End
)

// Directions specifies the text layout direction.
type Directions int32 //enums:enum -transform kebab

const (
        // LTR is Left-to-Right text.
        LTR Directions = iota

        // RTL is Right-to-Left text.
        RTL

        // TTB is Top-to-Bottom text.
        TTB

        // BTT is Bottom-to-Top text.
        BTT

        // Default uses the [text.Style] default direction.
        Default
)

// ToGoText returns the go-text version of direction.
func (d Directions) ToGoText() di.Direction {
        return di.Direction(d)
}

// IsVertical returns true if given text is vertical.
func (d Directions) IsVertical() bool {
        return d >= TTB && d <= BTT
}

// SetDecoration sets given decoration flag(s) on.
func (s *Style) SetDecoration(deco ...Decorations) *Style {
        for _, d := range deco {
                s.Decoration.SetFlag(true, d)
        }
        return s
}

func (s *Style) FillColor() color.Color   { return s.fillColor }
func (s *Style) StrokeColor() color.Color { return s.strokeColor }
func (s *Style) Background() color.Color  { return s.background }

// SetFillColor sets the fill color to given color, setting the Decoration
// flag and the color value.
func (s *Style) SetFillColor(clr color.Color) *Style {
        s.fillColor = clr
        s.Decoration.SetFlag(clr != nil, FillColor)
        return s
}

// SetStrokeColor sets the stroke color to given color, setting the Decoration
// flag and the color value.
// This is normally not set: it looks like an outline of the glyph at
// larger font sizes, and will make smaller font sizes look significantly thicker.
func (s *Style) SetStrokeColor(clr color.Color) *Style {
        s.strokeColor = clr
        s.Decoration.SetFlag(clr != nil, StrokeColor)
        return s
}

// SetBackground sets the background color to given color, setting the Decoration
// flag and the color value.
// The background is not normally colored so it renders over any background.
func (s *Style) SetBackground(clr color.Color) *Style {
        s.background = clr
        s.Decoration.SetFlag(clr != nil, Background)
        return s
}

// SetLinkStyle sets the default hyperlink styling: primary.Base color (e.g., blue)
// and Underline.
func (s *Style) SetLinkStyle() *Style {
        s.SetFillColor(colors.ToUniform(colors.Scheme.Primary.Base))
        s.Decoration.SetFlag(true, Underline)
        return s
}

// SetLink sets the given style as a hyperlink, with given URL, and
// default link styling.
func (s *Style) SetLink(url string) *Style {
        s.URL = url
        s.Special = Link
        return s.SetLinkStyle()
}

// IsMath returns true if is a Special MathInline or MathDisplay.
func (s *Style) IsMath() bool {
        return s.Special == MathInline || s.Special == MathDisplay
}

func (s *Style) String() string {
        str := ""
        if s.Special == End {
                return "{End Special}"
        }
        if s.Size != 1 {
                str += fmt.Sprintf("%5.2fx ", s.Size)
        }
        if s.Family != SansSerif {
                str += s.Family.String() + " "
        }
        if s.Slant != SlantNormal {
                str += s.Slant.String() + " "
        }
        if s.Weight != Normal {
                str += s.Weight.String() + " "
        }
        if s.Stretch != StretchNormal {
                str += s.Stretch.String() + " "
        }
        if s.Special != Nothing {
                str += s.Special.String() + " "
                if s.Special == Link {
                        str += "[" + s.URL + "] "
                }
        }
        for d := Underline; d <= Background; d++ {
                if s.Decoration.HasFlag(d) {
                        str += d.BitIndexString() + " "
                }
        }
        return strings.TrimSpace(str)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rich

import (
        "fmt"
        "slices"
        "unicode"

        "cogentcore.org/core/text/textpos"
)

// Text is the basic rich text representation, with spans of []rune unicode characters
// that share a common set of text styling properties, which are represented
// by the first rune(s) in each span. If custom colors are used, they are encoded
// after the first style and size runes.
// This compact and efficient representation can be Join'd back into the raw
// unicode source, and indexing by rune index in the original is fast.
// It provides a GPU-compatible representation, and is the text equivalent of
// the [ppath.Path] encoding.
type Text [][]rune

// NewText returns a new [Text] starting with given style and runes string,
// which can be empty.
func NewText(s *Style, r []rune) Text {
        tx := Text{}
        tx.AddSpan(s, r)
        return tx
}

// NewPlainText returns a new [Text] starting with default style and runes string,
// which can be empty.
func NewPlainText(r []rune) Text {
        return NewText(NewStyle(), r)
}

// NumSpans returns the number of spans in this Text.
func (tx Text) NumSpans() int {
        return len(tx)
}

// Len returns the total number of runes in this Text.
func (tx Text) Len() int {
        n := 0
        for _, s := range tx {
                _, rn := SpanLen(s)
                n += rn
        }
        return n
}

// Range returns the start, end range of indexes into original source
// for given span index.
func (tx Text) Range(span int) (start, end int) {
        ci := 0
        for si, s := range tx {
                _, rn := SpanLen(s)
                if si == span {
                        return ci, ci + rn
                }
                ci += rn
        }
        return -1, -1
}

// Index returns the span index, number of style runes at start of span,
// and index into actual runes within the span after style runes,
// for the given logical index into the original source rune slice
// without spans or styling elements.
// If the logical index is invalid for the text returns -1,-1,-1.
func (tx Text) Index(li int) (span, stylen, ridx int) {
        ci := 0
        for si, s := range tx {
                sn, rn := SpanLen(s)
                if li >= ci && li < ci+rn {
                        return si, sn, sn + (li - ci)
                }
                ci += rn
        }
        return -1, -1, -1
}

// AtTry returns the rune at given logical index, as in the original
// source rune slice without any styling elements. Returns 0
// and false if index is invalid.
func (tx Text) AtTry(li int) (rune, bool) {
        ci := 0
        for _, s := range tx {
                sn, rn := SpanLen(s)
                if li >= ci && li < ci+rn {
                        return s[sn+(li-ci)], true
                }
                ci += rn
        }
        return -1, false
}

// At returns the rune at given logical index into the original
// source rune slice without any styling elements. Returns 0
// if index is invalid. See AtTry for a version that also returns a bool
// indicating whether the index is valid.
func (tx Text) At(li int) rune {
        r, _ := tx.AtTry(li)
        return r
}

// Split returns the raw rune spans without any styles.
// The rune span slices here point directly into the Text rune slices.
// See SplitCopy for a version that makes a copy instead.
func (tx Text) Split() [][]rune {
        ss := make([][]rune, 0, len(tx))
        for _, s := range tx {
                sn, _ := SpanLen(s)
                ss = append(ss, s[sn:])
        }
        return ss
}

// SplitCopy returns the raw rune spans without any styles.
// The rune span slices here are new copies; see also [Text.Split].
func (tx Text) SplitCopy() [][]rune {
        ss := make([][]rune, 0, len(tx))
        for _, s := range tx {
                sn, _ := SpanLen(s)
                ss = append(ss, slices.Clone(s[sn:]))
        }
        return ss
}

// Join returns a single slice of runes with the contents of all span runes.
func (tx Text) Join() []rune {
        ss := make([]rune, 0, tx.Len())
        for _, s := range tx {
                sn, _ := SpanLen(s)
                if sn < len(s) {
                        ss = append(ss, s[sn:]...)
                }
        }
        return ss
}

// Span returns the [Style] and []rune content for given span index.
// Returns nil if out of range.
func (tx Text) Span(si int) (*Style, []rune) {
        n := len(tx)
        if si < 0 || si >= n || len(tx[si]) == 0 {
                return nil, nil
        }
        return NewStyleFromRunes(tx[si])
}

// SetSpanStyle sets the style for given span, updating the runes to encode it.
func (tx *Text) SetSpanStyle(si int, nsty *Style) *Text {
        sty, r := tx.Span(si)
        *sty = *nsty
        nr := sty.ToRunes()
        nr = append(nr, r...)
        (*tx)[si] = nr
        return tx
}

// SetSpanRunes sets the runes for given span.
func (tx *Text) SetSpanRunes(si int, r []rune) *Text {
        sty, _ := tx.Span(si)
        nr := sty.ToRunes()
        nr = append(nr, r...)
        (*tx)[si] = nr
        return tx
}

// AddSpan adds a span to the Text using the given Style and runes.
// The Text is modified for convenience in the high-frequency use-case.
// Clone first to avoid changing the original.
func (tx *Text) AddSpan(s *Style, r []rune) *Text {
        nr := s.ToRunes()
        nr = append(nr, r...)
        *tx = append(*tx, nr)
        return tx
}

// AddSpanString adds a span to the Text using the given Style and string content.
// The Text is modified for convenience in the high-frequency use-case.
// Clone first to avoid changing the original.
func (tx *Text) AddSpanString(s *Style, r string) *Text {
        nr := s.ToRunes()
        nr = append(nr, []rune(r)...)
        *tx = append(*tx, nr)
        return tx
}

// InsertSpan inserts a span to the Text at given span index,
// using the given Style and runes.
// The Text is modified for convenience in the high-frequency use-case.
// Clone first to avoid changing the original.
func (tx *Text) InsertSpan(at int, s *Style, r []rune) *Text {
        nr := s.ToRunes()
        nr = append(nr, r...)
        *tx = slices.Insert(*tx, at, nr)
        return tx
}

// SplitSpan splits an existing span at the given logical source index,
// with the span containing that logical index truncated to contain runes
// just before the index, and a new span inserted starting at that index,
// with the remaining contents of the original containing span.
// If that logical index is already the start of a span, or the logical
// index is invalid, nothing happens. Returns the index of span,
// which will be negative if the logical index is out of range.
func (tx *Text) SplitSpan(li int) int {
        si, sn, ri := tx.Index(li)
        if si < 0 {
                return si
        }
        if sn == ri { // already the start
                return si
        }
        nr := slices.Clone((*tx)[si][:sn]) // style runes
        nr = append(nr, (*tx)[si][ri:]...)
        (*tx)[si] = (*tx)[si][:ri] // truncate
        *tx = slices.Insert(*tx, si+1, nr)
        return si + 1
}

// StartSpecial adds a Span of given Special type to the Text,
// using given style and rune text. This creates a new style
// with the special value set, to avoid accidentally repeating
// the start of new specials.
func (tx *Text) StartSpecial(s *Style, special Specials, r []rune) *Text {
        ss := *s
        ss.Special = special
        return tx.AddSpan(&ss, r)
}

// EndSpecial adds an [End] Special to the Text, to terminate the current
// Special. All [Specials] must be terminated with this empty end tag.
func (tx *Text) EndSpecial() *Text {
        s := NewStyle()
        s.Special = End
        return tx.AddSpan(s, nil)
}

// InsertEndSpecial inserts an [End] Special to the Text at given span
// index, to terminate the current Special. All [Specials] must be
// terminated with this empty end tag.
func (tx *Text) InsertEndSpecial(at int) *Text {
        s := NewStyle()
        s.Special = End
        return tx.InsertSpan(at, s, nil)
}

// SpecialRange returns the range of spans for the
// special starting at given span index. Returns -1 if span
// at given index is not a special.
func (tx Text) SpecialRange(si int) textpos.Range {
        sp := RuneToSpecial(tx[si][0])
        if sp == Nothing {
                return textpos.Range{-1, -1}
        }
        depth := 1
        n := len(tx)
        for j := si + 1; j < n; j++ {
                s := RuneToSpecial(tx[j][0])
                switch s {
                case End:
                        depth--
                        if depth == 0 {
                                return textpos.Range{si, j}
                        }
                default:
                        depth++
                }
        }
        return textpos.Range{-1, -1}
}

// AddLink adds a [Link] special with given url and label text.
// This calls StartSpecial and EndSpecial for you. If the link requires
// further formatting, use those functions separately.
func (tx *Text) AddLink(s *Style, url, label string) *Text {
        ss := *s
        ss.URL = url
        tx.StartSpecial(&ss, Link, []rune(label))
        return tx.EndSpecial()
}

// AddSuper adds a [Super] special with given text.
// This calls StartSpecial and EndSpecial for you. If the Super requires
// further formatting, use those functions separately.
func (tx *Text) AddSuper(s *Style, text string) *Text {
        tx.StartSpecial(s, Super, []rune(text))
        return tx.EndSpecial()
}

// AddSub adds a [Sub] special with given text.
// This calls StartSpecial and EndSpecial for you. If the Sub requires
// further formatting, use those functions separately.
func (tx *Text) AddSub(s *Style, text string) *Text {
        tx.StartSpecial(s, Sub, []rune(text))
        return tx.EndSpecial()
}

// AddMathInline adds a [MathInline] special with given text.
// This calls StartSpecial and EndSpecial for you. If the Math requires
// further formatting, use those functions separately.
func (tx *Text) AddMathInline(s *Style, text string) *Text {
        tx.StartSpecial(s, MathInline, []rune(text))
        return tx.EndSpecial()
}

// AddMathDisplay adds a [MathDisplay] special with given text.
// This calls StartSpecial and EndSpecial for you. If the Math requires
// further formatting, use those functions separately.
func (tx *Text) AddMathDisplay(s *Style, text string) *Text {
        tx.StartSpecial(s, MathDisplay, []rune(text))
        return tx.EndSpecial()
}

// AddRunes adds given runes to current span.
// If no existing span, then a new default one is made.
func (tx *Text) AddRunes(r []rune) *Text {
        n := len(*tx)
        if n == 0 {
                return tx.AddSpan(NewStyle(), r)
        }
        (*tx)[n-1] = append((*tx)[n-1], r...)
        return tx
}

func (tx Text) String() string {
        str := ""
        for _, rs := range tx {
                s := &Style{}
                ss := s.FromRunes(rs)
                sstr := s.String()
                str += "[" + sstr + "]: \"" + string(ss) + "\"\n"
        }
        return str
}

// Join joins multiple texts into one text. Just appends the spans.
func Join(txts ...Text) Text {
        nt := Text{}
        for _, tx := range txts {
                nt = append(nt, tx...)
        }
        return nt
}

func (tx Text) DebugDump() {
        for i := range tx {
                s, r := tx.Span(i)
                fmt.Println(i, len(tx[i]), tx[i])
                fmt.Printf("style: %#v\n", s)
                fmt.Printf("chars: %q\n", string(r))
        }
}

// Clone returns a deep copy clone of the current text, safe for subsequent
// modification without affecting this one.
func (tx Text) Clone() Text {
        ct := make(Text, len(tx))
        for i := range tx {
                ct[i] = slices.Clone(tx[i])
        }
        return ct
}

// SplitSpaces splits this text after first unicode space after non-space.
func (tx *Text) SplitSpaces() {
        txt := tx.Join()
        if len(txt) == 0 {
                return
        }
        prevSp := unicode.IsSpace(txt[0])
        for i, r := range txt {
                isSp := unicode.IsSpace(r)
                if prevSp && isSp {
                        continue
                }
                if isSp {
                        prevSp = true
                        tx.SplitSpan(i + 1) // already doesn't re-split
                } else {
                        prevSp = false
                }
        }
}

// Code generated by "core generate"; DO NOT EDIT.

package rich

import (
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/rich.Style", IDName: "style", Doc: "Style contains all of the rich text styling properties, that apply to one\nspan of text. These are encoded into a uint32 rune value in [rich.Text].\nSee [text.Style] and [Settings] for additional context needed for full specification.", Directives: []types.Directive{{Tool: "go", Directive: "generate", Args: []string{"core", "generate"}}, {Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Fields: []types.Field{{Name: "Size", Doc: "Size is the font size multiplier relative to the standard font size\nspecified in the [text.Style]."}, {Name: "Family", Doc: "Family indicates the generic family of typeface to use, where the\nspecific named values to use for each are provided in the [Settings],\nor [text.Style] for [Custom]."}, {Name: "Slant", Doc: "Slant allows italic or oblique faces to be selected."}, {Name: "Weight", Doc: "Weights are the degree of blackness or stroke thickness of a font.\nThis value ranges from 100.0 to 900.0, with 400.0 as normal."}, {Name: "Stretch", Doc: "Stretch is the width of a font as an approximate fraction of the normal width.\nWidths range from 0.5 to 2.0 inclusive, with 1.0 as the normal width."}, {Name: "Special", Doc: "Special additional formatting factors that are not otherwise\ncaptured by changes in font rendering properties or decorations.\nSee [Specials] for usage information: use [Text.StartSpecial]\nand [Text.EndSpecial] to set."}, {Name: "Decoration", Doc: "Decorations are underline, line-through, etc, as bit flags\nthat must be set using [Decorations.SetFlag]."}, {Name: "Direction", Doc: "Direction is the direction to render the text."}, {Name: "fillColor", Doc: "fillColor is the color to use for glyph fill (i.e., the standard \"ink\" color).\nMust use SetFillColor to set Decoration FillColor flag.\nThis will be encoded in a uint32 following the style rune, in rich.Text spans."}, {Name: "strokeColor", Doc: "strokeColor is the color to use for glyph outline stroking.\nMust use SetStrokeColor to set Decoration StrokeColor flag.\nThis will be encoded in a uint32 following the style rune, in rich.Text spans."}, {Name: "background", Doc: "background is the color to use for the background region.\nMust use SetBackground to set the Decoration Background flag.\nThis will be encoded in a uint32 following the style rune, in rich.Text spans."}, {Name: "URL", Doc: "URL is the URL for a link element. It is encoded in runes after the style runes."}}})

// SetSize sets the [Style.Size]:
// Size is the font size multiplier relative to the standard font size
// specified in the [text.Style].
func (t *Style) SetSize(v float32) *Style { t.Size = v; return t }

// SetFamily sets the [Style.Family]:
// Family indicates the generic family of typeface to use, where the
// specific named values to use for each are provided in the [Settings],
// or [text.Style] for [Custom].
func (t *Style) SetFamily(v Family) *Style { t.Family = v; return t }

// SetSlant sets the [Style.Slant]:
// Slant allows italic or oblique faces to be selected.
func (t *Style) SetSlant(v Slants) *Style { t.Slant = v; return t }

// SetWeight sets the [Style.Weight]:
// Weights are the degree of blackness or stroke thickness of a font.
// This value ranges from 100.0 to 900.0, with 400.0 as normal.
func (t *Style) SetWeight(v Weights) *Style { t.Weight = v; return t }

// SetStretch sets the [Style.Stretch]:
// Stretch is the width of a font as an approximate fraction of the normal width.
// Widths range from 0.5 to 2.0 inclusive, with 1.0 as the normal width.
func (t *Style) SetStretch(v Stretch) *Style { t.Stretch = v; return t }

// SetSpecial sets the [Style.Special]:
// Special additional formatting factors that are not otherwise
// captured by changes in font rendering properties or decorations.
// See [Specials] for usage information: use [Text.StartSpecial]
// and [Text.EndSpecial] to set.
func (t *Style) SetSpecial(v Specials) *Style { t.Special = v; return t }

// SetDirection sets the [Style.Direction]:
// Direction is the direction to render the text.
func (t *Style) SetDirection(v Directions) *Style { t.Direction = v; return t }

// SetURL sets the [Style.URL]:
// URL is the URL for a link element. It is encoded in runes after the style runes.
func (t *Style) SetURL(v string) *Style { t.URL = v; return t }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package runes provides a small subset of functions for rune slices that are found in the
strings and bytes standard packages. For rendering and other logic, it is best to
keep raw data in runes, and not having to convert back and forth to bytes or strings
is more efficient.

These are largely copied from the strings or bytes packages.
*/
package runes

import (
        "unicode"
        "unicode/utf8"

        "cogentcore.org/core/base/slicesx"
)

// SetFromBytes sets slice of runes from given slice of bytes,
// using efficient memory reallocation of existing slice.
// returns potentially modified slice: use assign to update.
func SetFromBytes(rs []rune, s []byte) []rune {
        n := utf8.RuneCount(s)
        rs = slicesx.SetLength(rs, n)
        i := 0
        for len(s) > 0 {
                r, l := utf8.DecodeRune(s)
                rs[i] = r
                i++
                s = s[l:]
        }
        return rs
}

const maxInt = int(^uint(0) >> 1)

// Equal reports whether a and b
// are the same length and contain the same bytes.
// A nil argument is equivalent to an empty slice.
func Equal(a, b []rune) bool {
        // Neither cmd/compile nor gccgo allocates for these string conversions.
        return string(a) == string(b)
}

// // Compare returns an integer comparing two byte slices lexicographically.
// // The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
// // A nil argument is equivalent to an empty slice.
// func Compare(a, b []rune) int {
//         return bytealg.Compare(a, b)
// }

// Count counts the number of non-overlapping instances of sep in s.
// If sep is an empty slice, Count returns 1 + the number of UTF-8-encoded code points in s.
func Count(s, sep []rune) int {
        n := 0
        for {
                i := Index(s, sep)
                if i == -1 {
                        return n
                }
                n++
                s = s[i+len(sep):]
        }
}

// Contains reports whether subslice is within b.
func Contains(b, subslice []rune) bool {
        return Index(b, subslice) != -1
}

// ContainsRune reports whether the rune is contained in the UTF-8-encoded byte slice b.
func ContainsRune(b []rune, r rune) bool {
        return Index(b, []rune{r}) >= 0
        // return IndexRune(b, r) >= 0
}

// ContainsFunc reports whether any of the UTF-8-encoded code points r within b satisfy f(r).
func ContainsFunc(b []rune, f func(rune) bool) bool {
        return IndexFunc(b, f) >= 0
}

// containsRune is a simplified version of strings.ContainsRune
// to avoid importing the strings package.
// We avoid bytes.ContainsRune to avoid allocating a temporary copy of s.
func containsRune(s string, r rune) bool {
        for _, c := range s {
                if c == r {
                        return true
                }
        }
        return false
}

// Trim returns a subslice of s by slicing off all leading and
// trailing UTF-8-encoded code points contained in cutset.
func Trim(s []rune, cutset string) []rune {
        if len(s) == 0 {
                // This is what we've historically done.
                return nil
        }
        if cutset == "" {
                return s
        }
        return TrimLeft(TrimRight(s, cutset), cutset)
}

// TrimLeft returns a subslice of s by slicing off all leading
// UTF-8-encoded code points contained in cutset.
func TrimLeft(s []rune, cutset string) []rune {
        if len(s) == 0 {
                // This is what we've historically done.
                return nil
        }
        if cutset == "" {
                return s
        }
        for len(s) > 0 {
                r := s[0]
                if !containsRune(cutset, r) {
                        break
                }
                s = s[1:]
        }
        if len(s) == 0 {
                // This is what we've historically done.
                return nil
        }
        return s
}

// TrimRight returns a subslice of s by slicing off all trailing
// UTF-8-encoded code points that are contained in cutset.
func TrimRight(s []rune, cutset string) []rune {
        if len(s) == 0 || cutset == "" {
                return s
        }
        for len(s) > 0 {
                r := s[len(s)-1]
                if !containsRune(cutset, r) {
                        break
                }
                s = s[:len(s)-1]
        }
        return s
}

// TrimSpace returns a subslice of s by slicing off all leading and
// trailing white space, as defined by Unicode.
func TrimSpace(s []rune) []rune {
        return TrimFunc(s, unicode.IsSpace)
}

// TrimLeftFunc treats s as UTF-8-encoded bytes and returns a subslice of s by slicing off
// all leading UTF-8-encoded code points c that satisfy f(c).
func TrimLeftFunc(s []rune, f func(r rune) bool) []rune {
        i := indexFunc(s, f, false)
        if i == -1 {
                return nil
        }
        return s[i:]
}

// TrimRightFunc returns a subslice of s by slicing off all trailing
// UTF-8-encoded code points c that satisfy f(c).
func TrimRightFunc(s []rune, f func(r rune) bool) []rune {
        i := lastIndexFunc(s, f, false)
        return s[0 : i+1]
}

// TrimFunc returns a subslice of s by slicing off all leading and trailing
// UTF-8-encoded code points c that satisfy f(c).
func TrimFunc(s []rune, f func(r rune) bool) []rune {
        return TrimRightFunc(TrimLeftFunc(s, f), f)
}

// TrimPrefix returns s without the provided leading prefix string.
// If s doesn't start with prefix, s is returned unchanged.
func TrimPrefix(s, prefix []rune) []rune {
        if HasPrefix(s, prefix) {
                return s[len(prefix):]
        }
        return s
}

// TrimSuffix returns s without the provided trailing suffix string.
// If s doesn't end with suffix, s is returned unchanged.
func TrimSuffix(s, suffix []rune) []rune {
        if HasSuffix(s, suffix) {
                return s[:len(s)-len(suffix)]
        }
        return s
}

// Replace returns a copy of the slice s with the first n
// non-overlapping instances of old replaced by new.
// The old string cannot be empty.
// If n < 0, there is no limit on the number of replacements.
func Replace(s, old, new []rune, n int) []rune {
        if len(old) == 0 {
                panic("runes Replace: old cannot be empty")
        }
        m := 0
        if n != 0 {
                // Compute number of replacements.
                m = Count(s, old)
        }
        if m == 0 {
                // Just return a copy.
                return append([]rune(nil), s...)
        }
        if n < 0 || m < n {
                n = m
        }

        // Apply replacements to buffer.
        t := make([]rune, len(s)+n*(len(new)-len(old)))
        w := 0
        start := 0
        for i := 0; i < n; i++ {
                j := start
                if len(old) == 0 {
                        if i > 0 {
                                j++
                        }
                } else {
                        j += Index(s[start:], old)
                }
                w += copy(t[w:], s[start:j])
                w += copy(t[w:], new)
                start = j + len(old)
        }
        w += copy(t[w:], s[start:])
        return t[0:w]
}

// ReplaceAll returns a copy of the slice s with all
// non-overlapping instances of old replaced by new.
// If old is empty, it matches at the beginning of the slice
// and after each UTF-8 sequence, yielding up to k+1 replacements
// for a k-rune slice.
func ReplaceAll(s, old, new []rune) []rune {
        return Replace(s, old, new, -1)
}

// EqualFold reports whether s and t are equal under Unicode case-folding.
// copied from strings.EqualFold
func EqualFold(s, t []rune) bool {
        for len(s) > 0 && len(t) > 0 {
                // Extract first rune from each string.
                var sr, tr rune
                sr, s = s[0], s[1:]
                tr, t = t[0], t[1:]
                // If they match, keep going; if not, return false.

                // Easy case.
                if tr == sr {
                        continue
                }

                // Make sr < tr to simplify what follows.
                if tr < sr {
                        tr, sr = sr, tr
                }
                // Fast check for ASCII.
                if tr < utf8.RuneSelf {
                        // ASCII only, sr/tr must be upper/lower case
                        if 'A' <= sr && sr <= 'Z' && tr == sr+'a'-'A' {
                                continue
                        }
                        return false
                }

                // General case. SimpleFold(x) returns the next equivalent rune > x
                // or wraps around to smaller values.
                r := unicode.SimpleFold(sr)
                for r != sr && r < tr {
                        r = unicode.SimpleFold(r)
                }
                if r == tr {
                        continue
                }
                return false
        }

        // One string is empty. Are both?
        return len(s) == len(t)
}

// Index returns the index of given rune string in the text, returning -1 if not found.
func Index(txt, find []rune) int {
        fsz := len(find)
        if fsz == 0 {
                return -1
        }
        tsz := len(txt)
        if tsz < fsz {
                return -1
        }
        mn := tsz - fsz
        for i := 0; i <= mn; i++ {
                found := true
                for j := range find {
                        if txt[i+j] != find[j] {
                                found = false
                                break
                        }
                }
                if found {
                        return i
                }
        }
        return -1
}

// IndexFold returns the index of given rune string in the text, using case folding
// (i.e., case insensitive matching).  Returns -1 if not found.
func IndexFold(txt, find []rune) int {
        fsz := len(find)
        if fsz == 0 {
                return -1
        }
        tsz := len(txt)
        if tsz < fsz {
                return -1
        }
        mn := tsz - fsz
        for i := 0; i <= mn; i++ {
                if EqualFold(txt[i:i+fsz], find) {
                        return i
                }
        }
        return -1
}

// Repeat returns a new rune slice consisting of count copies of b.
//
// It panics if count is negative or if
// the result of (len(b) * count) overflows.
func Repeat(r []rune, count int) []rune {
        if count == 0 {
                return []rune{}
        }
        // Since we cannot return an error on overflow,
        // we should panic if the repeat will generate
        // an overflow.
        // See Issue golang.org/issue/16237.
        if count < 0 {
                panic("runes: negative Repeat count")
        } else if len(r)*count/count != len(r) {
                panic("runes: Repeat count causes overflow")
        }

        nb := make([]rune, len(r)*count)
        bp := copy(nb, r)
        for bp < len(nb) {
                copy(nb[bp:], nb[:bp])
                bp *= 2
        }
        return nb
}

// Generic split: splits after each instance of sep,
// including sepSave bytes of sep in the subslices.
func genSplit(s, sep []rune, sepSave, n int) [][]rune {
        if n == 0 {
                return nil
        }
        if len(sep) == 0 {
                panic("rune split: separator cannot be empty!")
        }
        if n < 0 {
                n = Count(s, sep) + 1
        }
        if n > len(s)+1 {
                n = len(s) + 1
        }

        a := make([][]rune, n)
        n--
        i := 0
        for i < n {
                m := Index(s, sep)
                if m < 0 {
                        break
                }
                a[i] = s[: m+sepSave : m+sepSave]
                s = s[m+len(sep):]
                i++
        }
        a[i] = s
        return a[:i+1]
}

// SplitN slices s into subslices separated by sep and returns a slice of
// the subslices between those separators.
// Sep cannot be empty.
// The count determines the number of subslices to return:
//
//        n > 0: at most n subslices; the last subslice will be the unsplit remainder.
//        n == 0: the result is nil (zero subslices)
//        n < 0: all subslices
//
// To split around the first instance of a separator, see Cut.
func SplitN(s, sep []rune, n int) [][]rune { return genSplit(s, sep, 0, n) }

// SplitAfterN slices s into subslices after each instance of sep and
// returns a slice of those subslices.
// If sep is empty, SplitAfterN splits after each UTF-8 sequence.
// The count determines the number of subslices to return:
//
//        n > 0: at most n subslices; the last subslice will be the unsplit remainder.
//        n == 0: the result is nil (zero subslices)
//        n < 0: all subslices
func SplitAfterN(s, sep []rune, n int) [][]rune {
        return genSplit(s, sep, len(sep), n)
}

// Split slices s into all subslices separated by sep and returns a slice of
// the subslices between those separators.
// If sep is empty, Split splits after each UTF-8 sequence.
// It is equivalent to SplitN with a count of -1.
//
// To split around the first instance of a separator, see Cut.
func Split(s, sep []rune) [][]rune { return genSplit(s, sep, 0, -1) }

// SplitAfter slices s into all subslices after each instance of sep and
// returns a slice of those subslices.
// If sep is empty, SplitAfter splits after each UTF-8 sequence.
// It is equivalent to SplitAfterN with a count of -1.
func SplitAfter(s, sep []rune) [][]rune {
        return genSplit(s, sep, len(sep), -1)
}

var asciiSpace = [256]uint8{'\t': 1, '\n': 1, '\v': 1, '\f': 1, '\r': 1, ' ': 1}

// Fields interprets s as a sequence of UTF-8-encoded code points.
// It splits the slice s around each instance of one or more consecutive white space
// characters, as defined by unicode.IsSpace, returning a slice of subslices of s or an
// empty slice if s contains only white space.
func Fields(s []rune) [][]rune {
        return FieldsFunc(s, unicode.IsSpace)
}

// FieldsFunc interprets s as a sequence of UTF-8-encoded code points.
// It splits the slice s at each run of code points c satisfying f(c) and
// returns a slice of subslices of s. If all code points in s satisfy f(c), or
// len(s) == 0, an empty slice is returned.
//
// FieldsFunc makes no guarantees about the order in which it calls f(c)
// and assumes that f always returns the same value for a given c.
func FieldsFunc(s []rune, f func(rune) bool) [][]rune {
        // A span is used to record a slice of s of the form s[start:end].
        // The start index is inclusive and the end index is exclusive.
        type span struct {
                start int
                end   int
        }
        spans := make([]span, 0, 32)

        // Find the field start and end indices.
        // Doing this in a separate pass (rather than slicing the string s
        // and collecting the result substrings right away) is significantly
        // more efficient, possibly due to cache effects.
        start := -1 // valid span start if >= 0
        for end, rune := range s {
                if f(rune) {
                        if start >= 0 {
                                spans = append(spans, span{start, end})
                                // Set start to a negative value.
                                // Note: using -1 here consistently and reproducibly
                                // slows down this code by a several percent on amd64.
                                start = ^start
                        }
                } else {
                        if start < 0 {
                                start = end
                        }
                }
        }

        // Last field might end at EOF.
        if start >= 0 {
                spans = append(spans, span{start, len(s)})
        }

        // Create strings from recorded field indices.
        a := make([][]rune, len(spans))
        for i, span := range spans {
                a[i] = s[span.start:span.end:span.end] // last end makes it copy
        }

        return a
}

// Join concatenates the elements of s to create a new byte slice. The separator
// sep is placed between elements in the resulting slice.
func Join(s [][]rune, sep []rune) []rune {
        if len(s) == 0 {
                return []rune{}
        }
        if len(s) == 1 {
                // Just return a copy.
                return append([]rune(nil), s[0]...)
        }

        var n int
        if len(sep) > 0 {
                if len(sep) >= maxInt/(len(s)-1) {
                        panic("bytes: Join output length overflow")
                }
                n += len(sep) * (len(s) - 1)
        }
        for _, v := range s {
                if len(v) > maxInt-n {
                        panic("bytes: Join output length overflow")
                }
                n += len(v)
        }

        b := make([]rune, n)
        bp := copy(b, s[0])
        for _, v := range s[1:] {
                bp += copy(b[bp:], sep)
                bp += copy(b[bp:], v)
        }
        return b
}

// HasPrefix reports whether the byte slice s begins with prefix.
func HasPrefix(s, prefix []rune) bool {
        return len(s) >= len(prefix) && Equal(s[0:len(prefix)], prefix)
}

// HasSuffix reports whether the byte slice s ends with suffix.
func HasSuffix(s, suffix []rune) bool {
        return len(s) >= len(suffix) && Equal(s[len(s)-len(suffix):], suffix)
}

// IndexFunc interprets s as a sequence of UTF-8-encoded code points.
// It returns the byte index in s of the first Unicode
// code point satisfying f(c), or -1 if none do.
func IndexFunc(s []rune, f func(r rune) bool) int {
        return indexFunc(s, f, true)
}

// LastIndexFunc interprets s as a sequence of UTF-8-encoded code points.
// It returns the byte index in s of the last Unicode
// code point satisfying f(c), or -1 if none do.
func LastIndexFunc(s []rune, f func(r rune) bool) int {
        return lastIndexFunc(s, f, true)
}

// indexFunc is the same as IndexFunc except that if
// truth==false, the sense of the predicate function is
// inverted.
func indexFunc(s []rune, f func(r rune) bool, truth bool) int {
        for i, r := range s {
                if f(r) == truth {
                        return i
                }
        }
        return -1
}

// lastIndexFunc is the same as LastIndexFunc except that if
// truth==false, the sense of the predicate function is
// inverted.
func lastIndexFunc(s []rune, f func(r rune) bool, truth bool) int {
        for i := len(s) - 1; i >= 0; i-- {
                if f(s[i]) == truth {
                        return i
                }
        }
        return -1
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package search

import (
        "errors"
        "io/fs"
        "path/filepath"
        "regexp"
        "sort"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/core"
        "cogentcore.org/core/text/textpos"
)

// All returns list of all files under given root path, in all subdirs,
// of given language(s) that contain the given string, sorted in
// descending order by number of occurrences.
//   - ignoreCase transforms everything into lowercase.
//   - regExp uses the go regexp syntax for the find string.
//   - exclude is a list of filenames to exclude.
func All(root string, find string, ignoreCase, regExp bool, langs []fileinfo.Known, exclude ...string) ([]Results, error) {
        fsz := len(find)
        if fsz == 0 {
                return nil, nil
        }
        fb := []byte(find)
        var re *regexp.Regexp
        var err error
        if regExp {
                re, err = regexp.Compile(find)
                if err != nil {
                        return nil, err
                }
        }
        mls := make([]Results, 0)
        var errs []error
        filepath.Walk(root, func(fpath string, info fs.FileInfo, err error) error {
                if err != nil {
                        errs = append(errs, err)
                        return err
                }
                if info.IsDir() {
                        return nil
                }
                if int(info.Size()) > core.SystemSettings.BigFileSize {
                        return nil
                }
                fname := info.Name()
                skip, err := excludeFile(&exclude, fname, fpath)
                if err != nil {
                        errs = append(errs, err)
                }
                if skip {
                        return nil
                }
                fi, err := fileinfo.NewFileInfo(fpath)
                if err != nil {
                        errs = append(errs, err)
                }
                if fi.Generated {
                        return nil
                }
                if !LangCheck(fi, langs) {
                        return nil
                }
                var cnt int
                var matches []textpos.Match
                if regExp {
                        cnt, matches = FileRegexp(fpath, re)
                } else {
                        cnt, matches = File(fpath, fb, ignoreCase)
                }
                if cnt > 0 {
                        fpabs, err := filepath.Abs(fpath)
                        if err != nil {
                                errs = append(errs, err)
                        }
                        mls = append(mls, Results{fpabs, cnt, matches})
                }
                return nil
        })
        sort.Slice(mls, func(i, j int) bool {
                return mls[i].Count > mls[j].Count
        })
        return mls, errors.Join(errs...)
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package search

import (
        "bufio"
        "bytes"
        "fmt"
        "io"
        "log"
        "os"
        "regexp"
        "unicode/utf8"

        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/runes"
        "cogentcore.org/core/text/textpos"
)

// Results is used to report search results.
type Results struct {
        Filepath string
        Count    int
        Matches  []textpos.Match
}

func (r *Results) String() string {
        str := fmt.Sprintf("%s: %d", r.Filepath, r.Count)
        for _, m := range r.Matches {
                str += "\n" + m.String()
        }
        return str
}

// RuneLines looks for a string (no regexp) within lines of runes,
// with given case-sensitivity returning number of occurrences
// and specific match position list.  Column positions are in runes.
func RuneLines(src [][]rune, find []byte, ignoreCase bool) (int, []textpos.Match) {
        fr := bytes.Runes(find)
        fsz := len(fr)
        if fsz == 0 {
                return 0, nil
        }
        cnt := 0
        var matches []textpos.Match
        for ln, rn := range src {
                sz := len(rn)
                ci := 0
                for ci < sz {
                        var i int
                        if ignoreCase {
                                i = runes.IndexFold(rn[ci:], fr)
                        } else {
                                i = runes.Index(rn[ci:], fr)
                        }
                        if i < 0 {
                                break
                        }
                        i += ci
                        ci = i + fsz
                        mat := textpos.NewMatch(rn, i, ci, ln)
                        matches = append(matches, mat)
                        cnt++
                }
        }
        return cnt, matches
}

// LexItems looks for a string (no regexp),
// as entire lexically tagged items,
// with given case-sensitivity returning number of occurrences
// and specific match position list.  Column positions are in runes.
func LexItems(src [][]rune, lexs []lexer.Line, find []byte, ignoreCase bool) (int, []textpos.Match) {
        fr := bytes.Runes(find)
        fsz := len(fr)
        if fsz == 0 {
                return 0, nil
        }
        cnt := 0
        var matches []textpos.Match
        mx := min(len(src), len(lexs))
        for ln := 0; ln < mx; ln++ {
                rln := src[ln]
                lxln := lexs[ln]
                for _, lx := range lxln {
                        sz := lx.End - lx.Start
                        if sz != fsz {
                                continue
                        }
                        rn := rln[lx.Start:lx.End]
                        var i int
                        if ignoreCase {
                                i = runes.IndexFold(rn, fr)
                        } else {
                                i = runes.Index(rn, fr)
                        }
                        if i < 0 {
                                continue
                        }
                        mat := textpos.NewMatch(rln, lx.Start, lx.End, ln)
                        matches = append(matches, mat)
                        cnt++
                }
        }
        return cnt, matches
}

// Reader looks for a literal string (no regexp) from an io.Reader input stream,
// using given case-sensitivity.
// Returns number of occurrences and specific match position list.
// Column positions are in runes.
func Reader(reader io.Reader, find []byte, ignoreCase bool) (int, []textpos.Match) {
        fr := bytes.Runes(find)
        fsz := len(fr)
        if fsz == 0 {
                return 0, nil
        }
        cnt := 0
        var matches []textpos.Match
        scan := bufio.NewScanner(reader)
        ln := 0
        for scan.Scan() {
                rn := bytes.Runes(scan.Bytes()) // note: temp -- must copy -- convert to runes anyway
                sz := len(rn)
                ci := 0
                for ci < sz {
                        var i int
                        if ignoreCase {
                                i = runes.IndexFold(rn[ci:], fr)
                        } else {
                                i = runes.Index(rn[ci:], fr)
                        }
                        if i < 0 {
                                break
                        }
                        i += ci
                        ci = i + fsz
                        mat := textpos.NewMatch(rn, i, ci, ln)
                        matches = append(matches, mat)
                        cnt++
                }
                ln++
        }
        return cnt, matches
}

// File looks for a literal string (no regexp) within a file, in given
// case-sensitive way, returning number of occurrences and specific match
// position list. Column positions are in runes.
func File(filename string, find []byte, ignoreCase bool) (int, []textpos.Match) {
        fp, err := os.Open(filename)
        if err != nil {
                log.Printf("search.File: open error: %v\n", err)
                return 0, nil
        }
        defer fp.Close()
        return Reader(fp, find, ignoreCase)
}

// ReaderRegexp looks for a string using Go regexp expression,
// from an io.Reader input stream.
// Returns number of occurrences and specific match position list.
// Column positions are in runes.
func ReaderRegexp(reader io.Reader, re *regexp.Regexp) (int, []textpos.Match) {
        cnt := 0
        var matches []textpos.Match
        scan := bufio.NewScanner(reader)
        ln := 0
        for scan.Scan() {
                b := scan.Bytes() // note: temp -- must copy -- convert to runes anyway
                fi := re.FindAllIndex(b, -1)
                if fi == nil {
                        ln++
                        continue
                }
                sz := len(b)
                ri := make([]int, sz+1) // byte indexes to rune indexes
                rn := make([]rune, 0, sz)
                for i, w := 0, 0; i < sz; i += w {
                        r, wd := utf8.DecodeRune(b[i:])
                        w = wd
                        ri[i] = len(rn)
                        rn = append(rn, r)
                }
                ri[sz] = len(rn)
                for _, f := range fi {
                        st := f[0]
                        ed := f[1]
                        mat := textpos.NewMatch(rn, ri[st], ri[ed], ln)
                        matches = append(matches, mat)
                        cnt++
                }
                ln++
        }
        return cnt, matches
}

// FileRegexp looks for a string using Go regexp expression
// within a file, returning number of occurrences and specific match
// position list. Column positions are in runes.
func FileRegexp(filename string, re *regexp.Regexp) (int, []textpos.Match) {
        fp, err := os.Open(filename)
        if err != nil {
                log.Printf("search.FileRegexp: open error: %v\n", err)
                return 0, nil
        }
        defer fp.Close()
        return ReaderRegexp(fp, re)
}

// RuneLinesRegexp looks for a regexp within lines of runes,
// with given case-sensitivity returning number of occurrences
// and specific match position list. Column positions are in runes.
func RuneLinesRegexp(src [][]rune, re *regexp.Regexp) (int, []textpos.Match) {
        cnt := 0
        var matches []textpos.Match
        for ln := range src {
                // note: insane that we have to convert back and forth from bytes!
                b := []byte(string(src[ln]))
                fi := re.FindAllIndex(b, -1)
                if fi == nil {
                        continue
                }
                sz := len(b)
                ri := make([]int, sz+1) // byte indexes to rune indexes
                rn := make([]rune, 0, sz)
                for i, w := 0, 0; i < sz; i += w {
                        r, wd := utf8.DecodeRune(b[i:])
                        w = wd
                        ri[i] = len(rn)
                        rn = append(rn, r)
                }
                ri[sz] = len(rn)
                for _, f := range fi {
                        st := f[0]
                        ed := f[1]
                        mat := textpos.NewMatch(rn, ri[st], ri[ed], ln)
                        matches = append(matches, mat)
                        cnt++
                }
        }
        return cnt, matches
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package search

import (
        "errors"
        "os"
        "path/filepath"
        "regexp"
        "slices"
        "sort"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/core"
        "cogentcore.org/core/text/textpos"
)

// excludeFile does the exclude match against either file name or file path,
// removes any problematic exclude expressions from the list.
func excludeFile(exclude *[]string, fname, fpath string) (bool, error) {
        var errs []error
        for ei, ex := range *exclude {
                exp, err := filepath.Match(ex, fpath)
                if err != nil {
                        errs = append(errs, err)
                        *exclude = slices.Delete(*exclude, ei, ei+1)
                }
                if exp {
                        return true, errors.Join(errs...)
                }
                exf, _ := filepath.Match(ex, fname)
                if exf {
                        return true, errors.Join(errs...)
                }
        }
        return false, errors.Join(errs...)
}

// LangCheck checks if file matches list of target languages: true if
// matches (or no langs)
func LangCheck(fi *fileinfo.FileInfo, langs []fileinfo.Known) bool {
        if len(langs) == 0 {
                return true
        }
        if fileinfo.IsMatchList(langs, fi.Known) {
                return true
        }
        return false
}

// Paths returns list of all files in given list of paths (only: no subdirs),
// of language(s) that contain the given string, sorted in descending order
// by number of occurrences. Paths can be relative to current working directory.
// Automatically skips generated files.
//   - ignoreCase transforms everything into lowercase.
//   - regExp uses the go regexp syntax for the find string.
//   - exclude is a list of filenames to exclude: can use standard Glob patterns.
func Paths(paths []string, find string, ignoreCase, regExp bool, langs []fileinfo.Known, exclude ...string) ([]Results, error) {
        fsz := len(find)
        if fsz == 0 {
                return nil, nil
        }
        fb := []byte(find)
        var re *regexp.Regexp
        var err error
        if regExp {
                re, err = regexp.Compile(find)
                if err != nil {
                        return nil, err
                }
        }
        mls := make([]Results, 0)
        var errs []error
        for _, path := range paths {
                files, err := os.ReadDir(path)
                if err != nil {
                        errs = append(errs, err)
                        continue
                }
                for _, de := range files {
                        if de.IsDir() {
                                continue
                        }
                        fname := de.Name()
                        fpath := filepath.Join(path, fname)
                        skip, err := excludeFile(&exclude, fname, fpath)
                        if err != nil {
                                errs = append(errs, err)
                        }
                        if skip {
                                continue
                        }
                        fi, err := fileinfo.NewFileInfo(fpath)
                        if err != nil {
                                errs = append(errs, err)
                        }
                        if int(fi.Size) > core.SystemSettings.BigFileSize {
                                continue
                        }
                        if fi.Generated {
                                continue
                        }
                        if !LangCheck(fi, langs) {
                                continue
                        }
                        var cnt int
                        var matches []textpos.Match
                        if regExp {
                                cnt, matches = FileRegexp(fpath, re)
                        } else {
                                cnt, matches = File(fpath, fb, ignoreCase)
                        }
                        if cnt > 0 {
                                fpabs, err := filepath.Abs(fpath)
                                if err != nil {
                                        errs = append(errs, err)
                                }
                                mls = append(mls, Results{fpabs, cnt, matches})
                        }
                }
        }
        sort.Slice(mls, func(i, j int) bool {
                return mls[i].Count > mls[j].Count
        })
        return mls, errors.Join(errs...)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package shaped

import (
        "fmt"
        "image"
        "image/color"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/text/textpos"
        "golang.org/x/image/math/fixed"
)

// todo: split source at para boundaries and use wrap para on those.

// Lines is a list of Lines of shaped text, with an overall bounding
// box and position for the entire collection. This is the renderable
// unit of text, although it is not a [render.Item] because it lacks
// a position, and it can potentially be re-used in different positions.
type Lines struct {

        // Source is the original input source that generated this set of lines.
        // Each Line has its own set of spans that describes the Line contents.
        Source rich.Text

        // Lines are the shaped lines.
        Lines []Line

        // Offset is an optional offset to add to the position given when rendering.
        Offset math32.Vector2

        // Bounds is the bounding box for the entire set of rendered text,
        // relative to a rendering Position (and excluding any contribution
        // of Offset). Use Size() method to get the size and ToRect() to get
        // an [image.Rectangle].
        Bounds math32.Box2

        // FontSize is the [rich.Context] StandardSize from the Context used
        // at the time of shaping. Actual lines can be larger depending on font
        // styling parameters.
        FontSize float32

        // LineHeight is the line height used at the time of shaping.
        LineHeight float32

        // Truncated indicates whether any lines were truncated.
        Truncated bool

        // Direction is the default text rendering direction from the Context.
        Direction rich.Directions

        // Links holds any hyperlinks within shaped text.
        Links []rich.Hyperlink

        // Color is the default fill color to use for inking text.
        Color color.Color

        // SelectionColor is the color to use for rendering selected regions.
        SelectionColor image.Image

        // HighlightColor is the color to use for rendering highlighted regions.
        HighlightColor image.Image
}

// Line is one line of shaped text, containing multiple Runs.
// This is not an independent render target: see [Lines] (can always
// use one Line per Lines as needed).
type Line struct {

        // Source is the input source corresponding to the line contents,
        // derived from the original Lines Source. The style information for
        // each Run is embedded here.
        Source rich.Text

        // SourceRange is the range of runes in the original [Lines.Source] that
        // are represented in this line.
        SourceRange textpos.Range

        // Runs are the shaped [Run] elements.
        Runs []Run

        // Offset specifies the relative offset from the Lines Position
        // determining where to render the line in a target render image.
        // This is the baseline position (not the upper left: see Bounds for that).
        Offset math32.Vector2

        // Bounds is the bounding box for the Line of rendered text,
        // relative to the baseline rendering position (excluding any contribution
        // of Offset). This is centered at the baseline and the upper left
        // typically has a negative Y. Use Size() method to get the size
        // and ToRect() to get an [image.Rectangle]. This is based on the output
        // LineBounds, not the actual GlyphBounds.
        Bounds math32.Box2

        // Selections specifies region(s) of runes within this line that are selected,
        // and will be rendered with the [Lines.SelectionColor] background,
        // replacing any other background color that might have been specified.
        Selections []textpos.Range

        // Highlights specifies region(s) of runes within this line that are highlighted,
        // and will be rendered with the [Lines.HighlightColor] background,
        // replacing any other background color that might have been specified.
        Highlights []textpos.Range
}

func (ln *Line) String() string {
        return ln.Source.String() + fmt.Sprintf(" runs: %d\n", len(ln.Runs))
}

func (ls *Lines) String() string {
        str := ""
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                str += fmt.Sprintf("#### Line: %d\n", li)
                str += ln.String()
        }
        return str
}

// StartAtBaseline removes the offset from the first line that causes
// the lines to be rendered starting at the upper left corner, so they
// will instead be rendered starting at the baseline position.
func (ls *Lines) StartAtBaseline() {
        if len(ls.Lines) == 0 {
                return
        }
        ls.Lines[0].Offset = math32.Vector2{}
}

// SetGlyphXAdvance sets the x advance on all glyphs to given value:
// for monospaced case.
func (ls *Lines) SetGlyphXAdvance(adv fixed.Int26_6) {
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                for ri := range ln.Runs {
                        rn := ln.Runs[ri]
                        rn.SetGlyphXAdvance(adv)
                }
        }
}

// GetLinks gets the links for these lines, which are cached in Links.
func (ls *Lines) GetLinks() []rich.Hyperlink {
        if ls.Links != nil {
                return ls.Links
        }
        ls.Links = ls.Source.GetLinks()
        return ls.Links
}

// AlignXFactor aligns the lines along X axis according to alignment factor,
// as a proportion of size difference to add to offset (0.5 = center,
// 1 = right)
func (ls *Lines) AlignXFactor(fact float32) {
        wd := ls.Bounds.Size().X
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                lwd := ln.Bounds.Size().X
                if lwd < wd {
                        ln.Offset.X += fact * (wd - lwd)
                }
        }
}

// AlignX aligns the lines along X axis according to text style.
func (ls *Lines) AlignX(tsty *text.Style) {
        fact, _ := tsty.AlignFactors()
        if fact > 0 {
                ls.AlignXFactor(fact)
        }
}

// Clone returns a Clone copy of the Lines, with new Lines elements
// that still point to the same underlying Runs.
func (ls *Lines) Clone() *Lines {
        nls := &Lines{}
        *nls = *ls
        nln := len(ls.Lines)
        if nln > 0 {
                nln := make([]Line, nln)
                for i := range ls.Lines {
                        nln[i] = ls.Lines[i]
                }
                nls.Lines = nln
        }
        return nls
}

// UpdateStyle updates the Decoration, Fill and Stroke colors from the given
// rich.Text Styles for each line and given text style.
// This rich.Text must match the content of the shaped one, and differ only
// in these non-layout styles.
func (ls *Lines) UpdateStyle(tx rich.Text, tsty *text.Style) {
        ls.Source = tx
        ls.Color = tsty.Color
        for i := range ls.Lines {
                ln := &ls.Lines[i]
                ln.UpdateStyle(tx, tsty)
        }
}

// UpdateStyle updates the Decoration, Fill and Stroke colors from the current
// rich.Text Style for each run  and given text style.
// This rich.Text must match the content of the shaped one, and differ only
// in these non-layout styles.
func (ln *Line) UpdateStyle(tx rich.Text, tsty *text.Style) {
        ln.Source = tx
        for ri, rn := range ln.Runs {
                fs := ln.RunStyle(ln.Source, ri)
                rb := rn.AsBase()
                rb.SetFromStyle(fs, tsty)
        }
}

// RunStyle returns the rich text style for given run index.
func (ln *Line) RunStyle(tx rich.Text, ri int) *rich.Style {
        rn := ln.Runs[ri]
        rs := rn.Runes().Start
        si, _, _ := tx.Index(rs)
        sty, _ := tx.Span(si)
        return sty
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package shaped

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/text/textpos"
)

// SelectRegion adds the selection to given region of runes from
// the original source runes. Use SelectReset to clear first if desired.
func (ls *Lines) SelectRegion(r textpos.Range) {
        nr := ls.Source.Len()
        r = r.Intersect(textpos.Range{0, nr})
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                lr := r.Intersect(ln.SourceRange)
                if lr.Len() > 0 {
                        ln.Selections = append(ln.Selections, lr)
                }
        }
}

// SelectReset removes all existing selected regions.
func (ls *Lines) SelectReset() {
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                ln.Selections = nil
        }
}

// HighlightRegion adds the selection to given region of runes from
// the original source runes. Use HighlightReset to clear first if desired.
func (ls *Lines) HighlightRegion(r textpos.Range) {
        nr := ls.Source.Len()
        r = r.Intersect(textpos.Range{0, nr})
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                lr := r.Intersect(ln.SourceRange)
                if lr.Len() > 0 {
                        ln.Highlights = append(ln.Highlights, lr)
                }
        }
}

// HighlightReset removes all existing selected regions.
func (ls *Lines) HighlightReset() {
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                ln.Highlights = nil
        }
}

// RuneToLinePos returns the [textpos.Pos] line and character position for given rune
// index in Lines source. If ti >= source Len(), returns a position just after
// the last actual rune.
func (ls *Lines) RuneToLinePos(ti int) textpos.Pos {
        if len(ls.Lines) == 0 {
                return textpos.Pos{}
        }
        n := ls.Source.Len()
        el := len(ls.Lines) - 1
        ep := textpos.Pos{el, ls.Lines[el].SourceRange.End}
        if ti >= n {
                return ep
        }
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                if !ln.SourceRange.Contains(ti) {
                        continue
                }
                return textpos.Pos{li, ti - ln.SourceRange.Start}
        }
        return ep // shouldn't happen
}

// RuneFromLinePos returns the rune index in Lines source for given
// [textpos.Pos] line and character position. Returns Len() of source
// if it goes past that.
func (ls *Lines) RuneFromLinePos(tp textpos.Pos) int {
        if len(ls.Lines) == 0 {
                return 0
        }
        n := ls.Source.Len()
        nl := len(ls.Lines)
        if tp.Line >= nl {
                return n
        }
        ln := &ls.Lines[tp.Line]
        return ln.SourceRange.Start + tp.Char
}

// RuneAtLineDelta returns the rune index in Lines source at given
// relative vertical offset in lines from the current line for given rune.
// It uses pixel locations of glyphs and the LineHeight to find the
// rune at given vertical offset with the same horizontal position.
// If the delta goes out of range, it will return the appropriate in-range
// rune index at the closest horizontal position.
func (ls *Lines) RuneAtLineDelta(ti, lineDelta int) int {
        rp := ls.RuneBounds(ti).Center()
        tp := rp
        ld := float32(lineDelta) * ls.LineHeight // todo: should iterate over lines for different sizes..
        tp.Y = math32.Clamp(tp.Y+ld, ls.Bounds.Min.Y+2, ls.Bounds.Max.Y-2)
        return ls.RuneAtPoint(tp, math32.Vector2{})
}

// RuneBounds returns the glyph bounds for given rune index in Lines source,
// relative to the upper-left corner of the lines bounding box.
// If the index is >= the source length, it returns a box at the end of the
// rendered text (i.e., where a cursor should be to add more text).
func (ls *Lines) RuneBounds(ti int) math32.Box2 {
        n := ls.Source.Len()
        zb := math32.Box2{}
        if len(ls.Lines) == 0 {
                return zb
        }
        start := ls.Offset
        if ti >= n { // goto end
                ln := ls.Lines[len(ls.Lines)-1]
                off := start.Add(ln.Offset)
                ep := ln.Bounds.Max.Add(off)
                ep.Y = ln.Bounds.Min.Y + off.Y
                return math32.Box2{ep, ep}
        }
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                if !ln.SourceRange.Contains(ti) {
                        continue
                }
                off := start.Add(ln.Offset)
                for ri := range ln.Runs {
                        run := ln.Runs[ri]
                        rr := run.Runes()
                        if ti >= rr.End {
                                off.X += run.Advance()
                                continue
                        }
                        bb := run.RuneBounds(ti)
                        return bb.Translate(off)
                }
        }
        return zb
}

// RuneAtPoint returns the rune index in Lines source, at given rendered location,
// based on given starting location for rendering. If the point is out of the
// line bounds, the nearest point is returned (e.g., start of line based on Y coordinate).
func (ls *Lines) RuneAtPoint(pt math32.Vector2, start math32.Vector2) int {
        start.SetAdd(ls.Offset)
        lbb := ls.Bounds.Translate(start)
        if !lbb.ContainsPoint(pt) {
                // smaller bb so point will be inside stuff
                sbb := math32.Box2{lbb.Min.Add(math32.Vec2(0, 2)), lbb.Max.Sub(math32.Vec2(0, 2))}
                pt = sbb.ClampPoint(pt)
        }
        nl := len(ls.Lines)
        for li := range ls.Lines {
                ln := &ls.Lines[li]
                off := start.Add(ln.Offset)
                lbb := ln.Bounds.Translate(off)
                if !lbb.ContainsPoint(pt) {
                        if pt.Y >= lbb.Min.Y && pt.Y < lbb.Max.Y { // this is our line
                                if pt.X <= lbb.Min.X {
                                        return ln.SourceRange.Start
                                }
                                return ln.SourceRange.End
                        }
                        continue
                }
                for ri := range ln.Runs {
                        run := ln.Runs[ri]
                        rbb := run.AsBase().MaxBounds.Translate(off)
                        if !rbb.ContainsPoint(pt) {
                                off.X += run.Advance()
                                continue
                        }
                        rp := run.RuneAtPoint(ls.Source, pt, off)
                        if rp == run.Runes().End && li < nl-1 { // if not at full end, don't go past
                                rp--
                        }
                        return rp
                }
                return ln.SourceRange.End
        }
        return 0
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package shaped

import (
        "image"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/text/textpos"
        "golang.org/x/image/math/fixed"
)

// Run is a span of shaped text with the same font properties,
// with layout information to enable GUI interaction with shaped text.
type Run interface {

        // AsBase returns the base type with relevant shaped text information.
        AsBase() *RunBase

        // LineBounds returns the Line-level Bounds for given Run as rect bounding box.
        LineBounds() math32.Box2

        // Runes returns our rune range in original source using textpos.Range.
        Runes() textpos.Range

        // Advance returns the total distance to advance in going from one run to the next.
        Advance() float32

        // RuneBounds returns the maximal line-bounds level bounding box for given rune index.
        RuneBounds(ri int) math32.Box2

        // RuneAtPoint returns the rune index in Lines source, at given rendered location,
        // based on given starting location for rendering. If the point is out of the
        // line bounds, the nearest point is returned (e.g., start of line based on Y coordinate).
        RuneAtPoint(src rich.Text, pt math32.Vector2, start math32.Vector2) int

        // SetGlyphXAdvance sets the x advance on all glyphs to given value:
        // for monospaced case.
        SetGlyphXAdvance(adv fixed.Int26_6)
}

// Math holds the output of a TeX math expression.
type Math struct {
        Path *ppath.Path
        BBox math32.Box2
}

// Run is a span of text with the same font properties, with full rendering information.
type RunBase struct {

        // Font is the [text.Font] compact encoding of the font to use for rendering.
        Font text.Font

        // MaxBounds are the maximal line-level bounds for this run, suitable for region
        // rendering and mouse interaction detection.
        MaxBounds math32.Box2

        // Decoration are the decorations from the style to apply to this run.
        Decoration rich.Decorations

        // Math holds the output of Math formatting via the tex package.
        Math Math

        // FillColor is the color to use for glyph fill (i.e., the standard "ink" color).
        // Will only be non-nil if set for this run; Otherwise use default.
        FillColor image.Image

        // StrokeColor is the color to use for glyph outline stroking, if non-nil.
        StrokeColor image.Image

        // Background is the color to use for the background region, if non-nil.
        Background image.Image
}

// SetFromStyle sets the run styling parameters from given styles.
// Will also update non-Font elements, but font can only be set first time
// in the initial shaping process, otherwise the render is off.
func (run *RunBase) SetFromStyle(sty *rich.Style, tsty *text.Style) {
        run.Decoration = sty.Decoration
        if run.Font.Size == 0 {
                run.Font = *text.NewFont(sty, tsty)
        }
        if sty.Decoration.HasFlag(rich.FillColor) {
                run.FillColor = colors.Uniform(sty.FillColor())
        } else {
                run.FillColor = nil
        }
        if sty.Decoration.HasFlag(rich.StrokeColor) {
                run.StrokeColor = colors.Uniform(sty.StrokeColor())
        } else {
                run.StrokeColor = nil
        }
        if sty.Decoration.HasFlag(rich.Background) {
                run.Background = colors.Uniform(sty.Background())
        } else {
                run.Background = nil
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package shaped

import (
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/text/fonts"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/text"
        "github.com/go-text/typesetting/di"
)

//go:generate core generate

var (
        // NewShaper returns the correct type of shaper.
        NewShaper func() Shaper

        // ShapeMath is a function that returns a path representing the
        // given math expression, in TeX syntax.
        // Import _ cogentcore.org/core/text/tex to set this function
        // (incurs a significant additional memory footprint due to fonts
        // and other packages).
        ShapeMath func(expr string, fontHeight float32) (*ppath.Path, error)
)

// Shaper is a text shaping system that can shape the layout of [rich.Text],
// including line wrapping. All functions are protected by a mutex.
type Shaper interface {

        // Shape turns given input spans into [Runs] of rendered text,
        // using given context needed for complete styling.
        // The results are only valid until the next call to Shape or WrapParagraph:
        // use slices.Clone if needed longer than that.
        // This is called under a mutex lock, so it is safe for parallel use.
        Shape(tx rich.Text, tsty *text.Style, rts *rich.Settings) []Run

        // WrapLines performs line wrapping and shaping on the given rich text source,
        // using the given style information, where the [rich.Style] provides the default
        // style information reflecting the contents of the source (e.g., the default family,
        // weight, etc), for use in computing the default line height. Paragraphs are extracted
        // first using standard newline markers, assumed to coincide with separate spans in the
        // source text, and wrapped separately. For horizontal text, the Lines will render with
        // a position offset at the upper left corner of the overall bounding box of the text.
        // This is called under a mutex lock, so it is safe for parallel use.
        WrapLines(tx rich.Text, defSty *rich.Style, tsty *text.Style, rts *rich.Settings, size math32.Vector2) *Lines

        // FontFamilies returns a list of available font family names on this system.
        FontList() []fonts.Info
}

// WrapSizeEstimate is the size to use for layout during the SizeUp pass,
// for word wrap case, where the sizing actually matters,
// based on trying to fit the given number of characters into the given content size
// with given font height, and ratio of width to height.
// Ratio is used when csz is 0: 1.618 is golden, and smaller numbers to allow
// for narrower, taller text columns.
func WrapSizeEstimate(csz math32.Vector2, nChars int, ratio float32, sty *rich.Style, tsty *text.Style) math32.Vector2 {
        chars := float32(nChars)
        fht := tsty.FontHeight(sty)
        if fht == 0 {
                fht = 16
        }
        area := chars * fht * fht
        if csz.X > 0 && csz.Y > 0 {
                ratio = csz.X / csz.Y
        }
        // w = ratio * h
        // w * h = a
        // h^2 = a / r
        // h = sqrt(a / r)
        h := math32.Sqrt(area / ratio)
        h = max(fht*math32.Floor(h/fht), fht)
        w := area / h
        if w < csz.X { // must be at least this
                w = csz.X
                h = area / w
                h = max(h, csz.Y)
        }
        sz := math32.Vec2(w, h)
        return sz
}

// GoTextDirection gets the proper go-text direction value from styles.
func GoTextDirection(rdir rich.Directions, tsty *text.Style) di.Direction {
        dir := tsty.Direction
        if rdir != rich.Default {
                dir = rdir
        }
        return dir.ToGoText()
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package shapedgt

import (
        "os"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/text/fonts"
        "cogentcore.org/core/text/rich"
        "github.com/go-text/typesetting/fontscan"
)

// FontList returns the list of fonts that have been loaded.
func (sh *Shaper) FontList() []fonts.Info {
        str := errors.Log1(os.UserCacheDir())
        ft := errors.Log1(fontscan.SystemFonts(nil, str))
        fi := make([]fonts.Info, len(ft))
        for i := range ft {
                fi[i].Family = ft[i].Family
                as := ft[i].Aspect
                fi[i].Weight = rich.Weights(int(as.Weight / 100.0))
                fi[i].Slant = rich.Slants(as.Style - 1)
                // fi[i].Stretch = rich.Stretch() // not avail
                fi[i].Stretch = rich.StretchNormal
                fi[i].Font = ft[i]
        }
        return fi
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package shapedgt

import (
        "fmt"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/textpos"
        "github.com/go-text/typesetting/shaping"
        "golang.org/x/image/math/fixed"
)

// Run is a span of text with the same font properties, with full rendering information.
type Run struct {
        shaped.RunBase
        shaping.Output
}

func (run *Run) AsBase() *shaped.RunBase {
        return &run.RunBase
}

func (run *Run) Advance() float32 {
        return math32.FromFixed(run.Output.Advance)
}

// Runes returns our rune range using textpos.Range
func (run *Run) Runes() textpos.Range {
        return textpos.Range{run.Output.Runes.Offset, run.Output.Runes.Offset + run.Output.Runes.Count}
}

// GlyphBoundsBox returns the math32.Box2 version of [Run.GlyphBounds],
// providing a tight bounding box for given glyph within this run.
func (run *Run) GlyphBoundsBox(g *shaping.Glyph) math32.Box2 {
        if run.Math.Path != nil {
                return run.MaxBounds
        }
        return math32.B2FromFixed(run.GlyphBounds(g))
}

// GlyphBounds returns the tight bounding box for given glyph within this run.
func (run *Run) GlyphBounds(g *shaping.Glyph) fixed.Rectangle26_6 {
        if run.Math.Path != nil {
                return run.MaxBounds.ToFixed()
        }
        if run.Direction.IsVertical() {
                if run.Direction.IsSideways() {
                        fmt.Println("sideways")
                        return fixed.Rectangle26_6{Min: fixed.Point26_6{X: g.XBearing, Y: -g.YBearing}, Max: fixed.Point26_6{X: g.XBearing + g.Width, Y: -g.YBearing - g.Height}}
                }
                return fixed.Rectangle26_6{Min: fixed.Point26_6{X: -g.XBearing - g.Width/2, Y: g.Height - g.YOffset}, Max: fixed.Point26_6{X: g.XBearing + g.Width/2, Y: -(g.YBearing + g.Height) - g.YOffset}}
        }
        return fixed.Rectangle26_6{Min: fixed.Point26_6{X: g.XBearing, Y: -g.YBearing}, Max: fixed.Point26_6{X: g.XBearing + g.Width, Y: -g.YBearing - g.Height}}
}

// GlyphLineBoundsBox returns the math32.Box2 version of [Run.GlyphLineBounds],
// providing a line-level bounding box for given glyph within this run.
func (run *Run) GlyphLineBoundsBox(g *shaping.Glyph) math32.Box2 {
        if run.Math.Path != nil {
                return run.MaxBounds
        }
        return math32.B2FromFixed(run.GlyphLineBounds(g))
}

// GlyphLineBounds returns the line-level bounding box for given glyph within this run.
func (run *Run) GlyphLineBounds(g *shaping.Glyph) fixed.Rectangle26_6 {
        if run.Math.Path != nil {
                return run.MaxBounds.ToFixed()
        }
        rb := run.Bounds()
        if run.Direction.IsVertical() { // todo: fixme
                if run.Direction.IsSideways() {
                        fmt.Println("sideways")
                        return fixed.Rectangle26_6{Min: fixed.Point26_6{X: g.XBearing, Y: -g.YBearing}, Max: fixed.Point26_6{X: g.XBearing + g.Width, Y: -g.YBearing - g.Height}}
                }
                return fixed.Rectangle26_6{Min: fixed.Point26_6{X: -g.XBearing - g.Width/2, Y: g.Height - g.YOffset}, Max: fixed.Point26_6{X: g.XBearing + g.Width/2, Y: -(g.YBearing + g.Height) - g.YOffset}}
        }
        return fixed.Rectangle26_6{Min: fixed.Point26_6{X: g.XBearing, Y: rb.Min.Y}, Max: fixed.Point26_6{X: g.XBearing + g.Width, Y: rb.Max.Y}}
}

// LineBounds returns the LineBounds for given Run as a math32.Box2
// bounding box
func (run *Run) LineBounds() math32.Box2 {
        if run.Math.Path != nil {
                return run.MaxBounds
        }
        return math32.B2FromFixed(run.Bounds())
}

// Bounds returns the LineBounds for given Run as rect bounding box.
// See [Run.BoundsBox] for a version returning the float32 [math32.Box2].
func (run *Run) Bounds() fixed.Rectangle26_6 {
        if run.Math.Path != nil {
                return run.MaxBounds.ToFixed()
        }
        mb := run.MaxBounds
        if run.Direction.IsVertical() {
                // ascent, descent describe horizontal, advance is vertical
                // return fixed.Rectangle26_6{Min: fixed.Point26_6{X: -lb.Ascent, Y: 0},
                //         Max: fixed.Point26_6{X: -gapdec, Y: -run.Output.Advance}}
        }
        return fixed.Rectangle26_6{Min: fixed.Point26_6{X: 0, Y: mb.Min.ToFixed().Y},
                Max: fixed.Point26_6{X: run.Output.Advance, Y: mb.Max.ToFixed().Y}}
}

// RunBounds returns the Advance-based Bounds for this Run as rect bounding box,
// that reflects the total space of the run, using Ascent & Descent for font
// for the vertical dimension in horizontal text.
func (run *Run) RunBounds() fixed.Rectangle26_6 {
        if run.Math.Path != nil {
                return run.MaxBounds.ToFixed()
        }
        lb := &run.Output.LineBounds
        if run.Direction.IsVertical() {
                // ascent, descent describe horizontal, advance is vertical
                return fixed.Rectangle26_6{Min: fixed.Point26_6{X: -lb.Ascent, Y: 0},
                        Max: fixed.Point26_6{X: -lb.Descent, Y: -run.Output.Advance}}
        }
        return fixed.Rectangle26_6{Min: fixed.Point26_6{X: 0, Y: -lb.Ascent},
                Max: fixed.Point26_6{X: run.Output.Advance, Y: -lb.Descent}}
}

// GlyphsAt returns the indexs of the glyph(s) at given original source rune index.
// Empty if none found.
func (run *Run) GlyphsAt(i int) []int {
        var gis []int
        for gi := range run.Glyphs {
                g := &run.Glyphs[gi]
                if g.ClusterIndex > i {
                        break
                }
                if g.ClusterIndex == i {
                        gis = append(gis, gi)
                }
        }
        return gis
}

// FirstGlyphAt returns the index of the first glyph at or above given original
// source rune index, returns -1 if none found.
func (run *Run) FirstGlyphAt(i int) int {
        for gi := range run.Glyphs {
                g := &run.Glyphs[gi]
                if g.ClusterIndex >= i {
                        return gi
                }
        }
        return -1
}

// LastGlyphAt returns the index of the last glyph at given original source rune index,
// returns -1 if none found.
func (run *Run) LastGlyphAt(i int) int {
        ng := len(run.Glyphs)
        for gi := ng - 1; gi >= 0; gi-- {
                g := &run.Glyphs[gi]
                if g.ClusterIndex <= i {
                        return gi
                }
        }
        return -1
}

// SetGlyphXAdvance sets the x advance on all glyphs to given value:
// for monospaced case.
func (run *Run) SetGlyphXAdvance(adv fixed.Int26_6) {
        for gi := range run.Glyphs {
                g := &run.Glyphs[gi]
                g.XAdvance = adv
        }
        run.Output.Advance = adv * fixed.Int26_6(len(run.Glyphs))
}

// RuneAtPoint returns the index of the rune in the source, which contains given point,
// using the maximal glyph bounding box. Off is the offset for this run within overall
// image rendering context of point coordinates. Assumes point is already identified
// as being within the [Run.MaxBounds].
func (run *Run) RuneAtPoint(src rich.Text, pt, off math32.Vector2) int {
        // todo: vertical case!
        adv := off.X
        rr := run.Runes()
        for gi := range run.Glyphs {
                g := &run.Glyphs[gi]
                cri := g.ClusterIndex
                gadv := math32.FromFixed(g.XAdvance)
                mx := adv + gadv
                // fmt.Println(gi, cri, adv, mx, pt.X)
                if pt.X >= adv && pt.X < mx {
                        // fmt.Println("fits!")
                        return cri
                }
                adv += gadv
        }
        return rr.End
}

// RuneBounds returns the maximal line-bounds level bounding box for given rune index.
func (run *Run) RuneBounds(ri int) math32.Box2 {
        gis := run.GlyphsAt(ri)
        if len(gis) == 0 {
                fmt.Println("no glyphs")
                return (math32.Box2{})
        }
        return run.GlyphRegionBounds(gis[0], gis[len(gis)-1])
}

// GlyphRegionBounds returns the maximal line-bounds level bounding box
// between two glyphs in this run, where the st comes before the ed.
func (run *Run) GlyphRegionBounds(st, ed int) math32.Box2 {
        if run.Direction.IsVertical() {
                // todo: write me!
                return math32.Box2{}
        }
        sg := &run.Glyphs[st]
        stb := run.GlyphLineBoundsBox(sg)
        mb := run.MaxBounds
        off := float32(0)
        for gi := 0; gi < st; gi++ {
                g := &run.Glyphs[gi]
                off += math32.FromFixed(g.XAdvance)
        }
        mb.Min.X = off + stb.Min.X - 2
        for gi := st; gi <= ed; gi++ {
                g := &run.Glyphs[gi]
                gb := run.GlyphBoundsBox(g)
                mb.Max.X = off + gb.Max.X + 2
                off += math32.FromFixed(g.XAdvance)
        }
        return mb
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package shapedgt

import (
        "fmt"
        "io/fs"
        "os"
        "sync"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/text/fonts"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/text"
        "github.com/go-text/typesetting/di"
        "github.com/go-text/typesetting/font"
        "github.com/go-text/typesetting/fontscan"
        "github.com/go-text/typesetting/shaping"
        "golang.org/x/image/math/fixed"
)

// Shaper is the text shaper and wrapper, from go-text/shaping.
type Shaper struct {
        shaper   shaping.HarfbuzzShaper
        wrapper  shaping.LineWrapper
        fontMap  *fontscan.FontMap
        splitter shaping.Segmenter
        maths    map[int]*shaped.Math

        // outBuff is the output buffer to avoid excessive memory consumption.
        outBuff []shaping.Output

        sync.Mutex
}

type nilLogger struct{}

func (nl *nilLogger) Printf(format string, args ...any) {}

// NewShaper returns a new text shaper.
func NewShaper() shaped.Shaper {
        sh := &Shaper{}
        sh.fontMap = fontscan.NewFontMap(&nilLogger{})
        // TODO(text): figure out cache dir situation (especially on mobile and web)
        str, err := os.UserCacheDir()
        if errors.Log(err) != nil {
                // slog.Printf("failed resolving font cache dir: %v", err)
                // shaper.logger.Printf("skipping system font load")
        }
        // fmt.Println("cache dir:", str)
        if err := sh.fontMap.UseSystemFonts(str); err != nil {
                // note: we expect this error on js platform -- could do something exclusive here
                // under a separate build tag file..
                // errors.Log(err)
                // shaper.logger.Printf("failed loading system fonts: %v", err)
        }
        errors.Log(fonts.UseEmbeddedInMap(sh.fontMap))
        sh.shaper.SetFontCacheSize(32)
        return sh
}

// NewShaperWithFonts returns a new text shaper using
// given filesystem with fonts.
func NewShaperWithFonts(fss []fs.FS) shaped.Shaper {
        sh := &Shaper{}
        sh.fontMap = fontscan.NewFontMap(&nilLogger{})
        errors.Log(fonts.UseInMap(sh.fontMap, fss))
        sh.shaper.SetFontCacheSize(32)
        return sh
}

// FontMap returns the font map used for this shaper
func (sh *Shaper) FontMap() *fontscan.FontMap {
        return sh.fontMap
}

// Shape turns given input spans into [Runs] of rendered text,
// using given context needed for complete styling.
// The results are only valid until the next call to Shape or WrapParagraph:
// use slices.Clone if needed longer than that.
// This is called under a mutex lock, so it is safe for parallel use.
func (sh *Shaper) Shape(tx rich.Text, tsty *text.Style, rts *rich.Settings) []shaped.Run {
        sh.Lock()
        defer sh.Unlock()
        return sh.ShapeText(tx, tsty, rts, tx.Join())
}

// ShapeText shapes the spans in the given text using given style and settings,
// returning [shaped.Run] results.
// This should already have the mutex lock, and is used by shapedjs but is
// not an end-user call.
func (sh *Shaper) ShapeText(tx rich.Text, tsty *text.Style, rts *rich.Settings, txt []rune) []shaped.Run {
        outs := sh.ShapeTextOutput(tx, tsty, rts, txt)
        runs := make([]shaped.Run, len(outs))
        for i := range outs {
                run := &Run{Output: outs[i]}
                si, _, _ := tx.Index(run.Runes().Start)
                sty, _ := tx.Span(si)
                run.SetFromStyle(sty, tsty)
                if sty.IsMath() {
                        mt := sh.maths[si]
                        if mt != nil {
                                run.Math = *mt
                                run.MaxBounds = mt.BBox
                                run.Output.Advance = math32.ToFixed(mt.BBox.Size().X)
                        }
                }
                runs[i] = run
        }
        return runs
}

// ShapeTextOutput shapes the spans in the given text using given style and settings,
// returning raw go-text [shaping.Output].
// This should already have the mutex lock, and is used by shapedjs but is
// not an end-user call.
func (sh *Shaper) ShapeTextOutput(tx rich.Text, tsty *text.Style, rts *rich.Settings, txt []rune) []shaping.Output {
        if tx.Len() == 0 {
                return nil
        }
        sh.shapeMaths(tx, tsty)
        sty := rich.NewStyle()
        sh.outBuff = sh.outBuff[:0]
        for si, s := range tx {
                in := shaping.Input{}
                start, end := tx.Range(si)
                stx := sty.FromRunes(s) // sets sty, returns runes for span
                if len(stx) == 0 {
                        continue
                }
                if sty.IsMath() {
                        mt := sh.maths[si]
                        o := shaping.Output{}
                        o.Runes.Offset = start
                        o.Runes.Count = end - start
                        if mt != nil {
                                o.Advance = math32.ToFixed(mt.BBox.Size().X)
                        }
                        sh.outBuff = append(sh.outBuff, o)
                        si++ // skip the end special
                        continue
                }
                q := StyleToQuery(sty, tsty, rts)
                sh.fontMap.SetQuery(q)

                in.Text = txt
                in.RunStart = start
                in.RunEnd = end
                in.Direction = shaped.GoTextDirection(sty.Direction, tsty)
                fsz := tsty.FontHeight(sty)
                in.Size = math32.ToFixed(fsz)
                in.Script = rts.Script
                in.Language = rts.Language

                ins := sh.splitter.Split(in, sh.fontMap) // this is essential
                for _, in := range ins {
                        if in.Face == nil {
                                fmt.Println("nil face in input", len(stx), string(stx))
                                // fmt.Printf("nil face for in: %#v\n", in)
                                continue
                        }
                        o := sh.shaper.Shape(in)
                        FixOutputZeros(&o)
                        sh.outBuff = append(sh.outBuff, o)
                }
        }
        return sh.outBuff
}

// shapeMaths runs TeX on all Math specials, saving results in maths
// map indexed by the span index.
func (sh *Shaper) shapeMaths(tx rich.Text, tsty *text.Style) {
        sh.maths = make(map[int]*shaped.Math)
        if shaped.ShapeMath == nil {
                return
        }
        for si, _ := range tx {
                sty, stx := tx.Span(si)
                if sty.IsMath() {
                        mt := sh.shapeMath(sty, tsty, stx)
                        sh.maths[si] = mt // can be nil if error
                        si++              // skip past special
                }
        }
}

// shapeMath runs tex math to get path for math special
func (sh *Shaper) shapeMath(sty *rich.Style, tsty *text.Style, stx []rune) *shaped.Math {
        if shaped.ShapeMath == nil {
                return nil
        }
        mstr := string(stx)
        if sty.Special == rich.MathDisplay {
                mstr = "$" + mstr + "$"
        }
        p := errors.Log1(shaped.ShapeMath(mstr, tsty.FontHeight(sty)))
        if p != nil {
                bb := p.FastBounds()
                bb.Max.X += 5 // extra space
                return &shaped.Math{Path: p, BBox: bb}
        }
        return nil
}

// todo: do the paragraph splitting!  write fun in rich.Text

// DirectionAdvance advances given position based on given direction.
func DirectionAdvance(dir di.Direction, pos fixed.Point26_6, adv fixed.Int26_6) fixed.Point26_6 {
        if dir.IsVertical() {
                pos.Y += -adv
        } else {
                pos.X += adv
        }
        return pos
}

// StyleToQuery translates the rich.Style to go-text fontscan.Query parameters.
func StyleToQuery(sty *rich.Style, tsty *text.Style, rts *rich.Settings) fontscan.Query {
        q := fontscan.Query{}
        fam := tsty.FontFamily(sty)
        q.Families = rich.FamiliesToList(fam)
        q.Aspect = StyleToAspect(sty)
        return q
}

// StyleToAspect translates the rich.Style to go-text font.Aspect parameters.
func StyleToAspect(sty *rich.Style) font.Aspect {
        as := font.Aspect{}
        as.Style = font.Style(1 + sty.Slant)
        as.Weight = font.Weight(sty.Weight.ToFloat32())
        as.Stretch = font.Stretch(sty.Stretch.ToFloat32())
        return as
}

// FixOutputZeros fixes zero values in output, which can happen with emojis.
func FixOutputZeros(o *shaping.Output) {
        for gi := range o.Glyphs {
                g := &o.Glyphs[gi]
                if g.Width == 0 {
                        // fmt.Println(gi, g.GlyphID, "fixed width:", g.XAdvance)
                        g.Width = g.XAdvance
                }
                if g.Height == 0 {
                        // fmt.Println(gi, "fixed height:", o.Size)
                        g.Height = o.Size
                }
        }
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package shapedgt

import (
        "fmt"

        "cogentcore.org/core/math32"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/text"
        "github.com/go-text/typesetting/di"
        "github.com/go-text/typesetting/shaping"
        "golang.org/x/image/math/fixed"
)

// WrapLines performs line wrapping and shaping on the given rich text source,
// using the given style information, where the [rich.Style] provides the default
// style information reflecting the contents of the source (e.g., the default family,
// weight, etc), for use in computing the default line height. Paragraphs are extracted
// first using standard newline markers, assumed to coincide with separate spans in the
// source text, and wrapped separately. For horizontal text, the Lines will render with
// a position offset at the upper left corner of the overall bounding box of the text.
// This is called under a mutex lock, so it is safe for parallel use.
func (sh *Shaper) WrapLines(tx rich.Text, defSty *rich.Style, tsty *text.Style, rts *rich.Settings, size math32.Vector2) *shaped.Lines {
        sh.Lock()
        defer sh.Unlock()
        if tsty.FontSize.Dots == 0 {
                tsty.FontSize.Dots = 16
        }

        txt := tx.Join()
        outs := sh.ShapeTextOutput(tx, tsty, rts, txt)
        lines, truncated := sh.WrapLinesOutput(outs, txt, tx, defSty, tsty, rts, size)
        return sh.LinesBounds(lines, truncated, tx, defSty, tsty, size)
}

// This should already have the mutex lock, and is used by shapedjs but is
// not an end-user call. Returns new lines and number of truncations.
func (sh *Shaper) WrapLinesOutput(outs []shaping.Output, txt []rune, tx rich.Text, defSty *rich.Style, tsty *text.Style, rts *rich.Settings, size math32.Vector2) ([]shaping.Line, int) {

        lht := tsty.LineHeightDots(defSty)
        dir := shaped.GoTextDirection(rich.Default, tsty)
        nlines := int(math32.Floor(size.Y/lht)) * 2
        maxSize := int(size.X)
        if dir.IsVertical() {
                nlines = int(math32.Floor(size.X / lht))
                maxSize = int(size.Y)
                // fmt.Println(lht, nlines, maxSize)
        }
        // fmt.Println("lht:", lns.LineHeight, lgap, nlines)
        brk := shaping.WhenNecessary
        switch tsty.WhiteSpace {
        case text.WrapNever:
                brk = shaping.Never
        case text.WhiteSpacePre:
                maxSize = 100000
        case text.WrapAlways:
                brk = shaping.Always
        }
        if brk == shaping.Never {
                maxSize = 100000
                nlines = 1
        }
        // fmt.Println(brk, nlines, maxSize)
        cfg := shaping.WrapConfig{
                Direction:                     dir,
                TruncateAfterLines:            nlines,
                TextContinues:                 false, // todo! no effect if TruncateAfterLines is 0
                BreakPolicy:                   brk,   // or Never, Always
                DisableTrailingWhitespaceTrim: tsty.WhiteSpace.KeepWhiteSpace(),
        }
        // from gio:
        // if wc.TruncateAfterLines > 0 {
        //         if len(params.Truncator) == 0 {
        //                 params.Truncator = "…"
        //         }
        //         // We only permit a single run as the truncator, regardless of whether more were generated.
        //         // Just use the first one.
        //         wc.Truncator = s.ShapeText(params.PxPerEm, params.Locale, []rune(params.Truncator))[0]
        // }
        // todo: WrapParagraph does NOT handle vertical text! file issue.

        return sh.wrapper.WrapParagraph(cfg, maxSize, txt, shaping.NewSliceIterator(outs))
}

// This should already have the mutex lock, and is used by shapedjs but is
// not an end-user call.
func (sh *Shaper) LinesBounds(lines []shaping.Line, truncated int, tx rich.Text, defSty *rich.Style, tsty *text.Style, size math32.Vector2) *shaped.Lines {

        lht := tsty.LineHeightDots(defSty)
        lns := &shaped.Lines{Source: tx, Color: tsty.Color, SelectionColor: tsty.SelectColor, HighlightColor: tsty.HighlightColor, LineHeight: lht}
        lns.Truncated = truncated > 0

        fsz := tsty.FontHeight(defSty)
        dir := shaped.GoTextDirection(rich.Default, tsty)
        // fmt.Println(fsz, lht, lht/fsz, tsty.LineHeight)

        cspi := 0
        cspSt, cspEd := tx.Range(cspi)
        var off math32.Vector2
        for li, lno := range lines {
                // fmt.Println("line:", li, off)
                ln := shaped.Line{}
                var lsp rich.Text
                var pos fixed.Point26_6
                setFirst := false
                var maxAsc fixed.Int26_6
                maxLHt := lht
                for oi := range lno {
                        out := &lno[oi]
                        FixOutputZeros(out)
                        if !dir.IsVertical() { // todo: vertical
                                maxAsc = max(out.LineBounds.Ascent, maxAsc)
                        }
                        run := Run{Output: *out}
                        rns := run.Runes()
                        if !setFirst {
                                ln.SourceRange.Start = rns.Start
                                setFirst = true
                        }
                        ln.SourceRange.End = rns.End
                        for rns.Start >= cspEd {
                                cspi++
                                cspSt, cspEd = tx.Range(cspi)
                        }
                        sty, cr := rich.NewStyleFromRunes(tx[cspi])
                        if lns.FontSize == 0 {
                                lns.FontSize = sty.Size * fsz
                        }
                        nsp := sty.ToRunes()
                        coff := rns.Start - cspSt
                        cend := coff + rns.Len()
                        crsz := len(cr)
                        if coff >= crsz || cend > crsz {
                                // fmt.Println("out of bounds:", string(cr), crsz, coff, cend)
                                cend = min(crsz, cend)
                                coff = min(crsz, coff)
                        }
                        if cend-coff == 0 {
                                continue
                        }
                        nr := cr[coff:cend] // note: not a copy!
                        nsp = append(nsp, nr...)
                        lsp = append(lsp, nsp)
                        // fmt.Println(sty, string(nr))
                        if cend > (cspEd - cspSt) { // shouldn't happen, to combine multiple original spans
                                fmt.Println("combined original span:", cend, cspEd-cspSt, cspi, string(cr), "prev:", string(nr), "next:", string(cr[cend:]))
                        }
                        run.SetFromStyle(sty, tsty)
                        if sty.IsMath() {
                                mt := sh.maths[cspi]
                                if mt != nil {
                                        run.Math = *mt
                                        run.MaxBounds = mt.BBox
                                        bb := run.MaxBounds.Translate(math32.Vector2FromFixed(pos))
                                        ln.Bounds.ExpandByBox(bb)
                                        pos.X += math32.ToFixed(run.MaxBounds.Size().X)
                                        ysz := bb.Size().Y
                                        // fmt.Println("math ysz:", ysz, "maxAsc:", maxAsc)
                                        maxAsc = max(maxAsc, math32.ToFixed(-bb.Min.Y))
                                        maxLHt = max(maxLHt, ysz)
                                }
                        } else {
                                llht := tsty.LineHeightDots(sty)
                                maxLHt = max(maxLHt, llht)
                                bb := math32.B2FromFixed(run.RunBounds().Add(pos))
                                ln.Bounds.ExpandByBox(bb)
                                // fmt.Println("adv:", pos, run.Output.Advance, bb.Size().X)
                                pos = DirectionAdvance(run.Direction, pos, run.Output.Advance)
                        }
                        ln.Runs = append(ln.Runs, &run)
                }
                if li == 0 { // set offset for first line based on max ascent
                        if !dir.IsVertical() { // todo: vertical!
                                off.Y = math32.FromFixed(maxAsc)
                        }
                }
                ln.Source = lsp
                // offset has prior line's size built into it, but we need to also accommodate
                // any extra size in _our_ line beyond what is expected.
                ourOff := off
                // fmt.Println(ln.Bounds)
                // advance offset:
                if dir.IsVertical() {
                        lwd := ln.Bounds.Size().X
                        extra := max(lwd-lns.LineHeight, 0)
                        if dir.Progression() == di.FromTopLeft {
                                // fmt.Println("ftl lwd:", lwd, off.X)
                                off.X += lwd // ?
                                ourOff.X += extra
                        } else {
                                // fmt.Println("!ftl lwd:", lwd, off.X)
                                off.X -= lwd // ?
                                ourOff.X -= extra
                        }
                } else { // always top-down, no progression issues
                        lby := ln.Bounds.Size().Y // the result at this point is centered with this height
                        // which includes the natural line height property of the font itself.
                        lpd := 0.5 * (maxLHt - lby) // half of diff
                        if li > 0 {
                                ourOff.Y += (lpd + (maxLHt - lns.LineHeight))
                        }
                        ln.Bounds.Min.Y -= lpd
                        ln.Bounds.Max.Y += lpd
                        off.Y += maxLHt
                        // fmt.Println("lby:", lby, fsz, maxLHt, lpd, ourOff.Y)
                }
                // go back through and give every run the expanded line-level box
                for ri := range ln.Runs {
                        run := ln.Runs[ri]
                        rb := run.LineBounds()
                        if dir.IsVertical() {
                                rb.Min.X, rb.Max.X = ln.Bounds.Min.X, ln.Bounds.Max.X
                                rb.Min.Y -= 1 // ensure some overlap along direction of rendering adjacent
                                rb.Max.Y += 1
                        } else {
                                rb.Min.Y, rb.Max.Y = ln.Bounds.Min.Y, ln.Bounds.Max.Y
                                rb.Min.X -= 1
                                rb.Max.Y += 1
                        }
                        run.AsBase().MaxBounds = rb
                }
                ln.Offset = ourOff
                if tsty.WhiteSpace.HasWordWrap() && size.X > 0 && ln.Bounds.Size().X > size.X {
                        // fmt.Println("size exceeded:", ln.Bounds.Size().X, size.X)
                        ln.Bounds.Max.X -= ln.Bounds.Size().X - size.X
                }
                lns.Bounds.ExpandByBox(ln.Bounds.Translate(ln.Offset))
                lns.Lines = append(lns.Lines, ln)
        }
        if lns.Bounds.Size().Y < lht {
                lns.Bounds.Max.Y = lns.Bounds.Min.Y + lht
        }
        // fmt.Println(lns.Bounds)
        lns.AlignX(tsty)
        return lns
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !js

package shapers

import (
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/shaped/shapers/shapedgt"
)

func init() {
        shaped.NewShaper = shapedgt.NewShaper
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package spell

import (
        "strings"

        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/token"
)

// CheckLexLine returns the Lex regions for any words that are misspelled
// within given line of text with existing Lex tags -- automatically
// excludes any Code token regions (see token.IsCode).  Token is set
// to token.TextSpellErr on returned Lex's
func CheckLexLine(src []rune, tags lexer.Line) lexer.Line {
        wrds := tags.NonCodeWords(src)
        var ser lexer.Line
        for _, t := range wrds {
                wrd := string(t.Src(src))
                lwrd := lexer.FirstWordApostrophe(wrd)
                if len(lwrd) <= 2 {
                        continue
                }
                _, known := Spell.CheckWord(lwrd)
                if !known {
                        t.Token.Token = token.TextSpellErr
                        widx := strings.Index(wrd, lwrd)
                        ld := len(wrd) - len(lwrd)
                        t.Start += widx
                        t.End += widx - ld
                        t.Now()
                        ser = append(ser, t)
                }
        }
        return ser
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package spell

import (
        "io/fs"
        "os"
        "slices"
        "strings"

        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/stringsx"
        "golang.org/x/exp/maps"
)

type Dict map[string]struct{}

func (d Dict) Add(word string) {
        d[word] = struct{}{}
}

func (d Dict) Exists(word string) bool {
        _, ex := d[word]
        return ex
}

// List returns a list (slice) of words in dictionary
// in alpha-sorted order
func (d Dict) List() []string {
        wl := maps.Keys(d)
        slices.Sort(wl)
        return wl
}

// Save saves a dictionary list of words
// to a simple one-word-per-line list, in alpha order
func (d Dict) Save(fname string) error {
        wl := d.List()
        ws := strings.Join(wl, "\n")
        return os.WriteFile(fname, []byte(ws), 0666)
}

// NewDictFromList makes a new dictionary from given list
// (slice) of words
func NewDictFromList(wl []string) Dict {
        d := make(Dict, len(wl))
        for _, w := range wl {
                d.Add(w)
        }
        return d
}

// OpenDict opens a dictionary list of words
// from a simple one-word-per-line list
func OpenDict(fname string) (Dict, error) {
        dfs, fnm, err := fsx.DirFS(fname)
        if err != nil {
                return nil, err
        }
        return OpenDictFS(dfs, fnm)
}

// OpenDictFS opens a dictionary list of words
// from a simple one-word-per-line list, from given filesystem
func OpenDictFS(fsys fs.FS, filename string) (Dict, error) {
        f, err := fs.ReadFile(fsys, filename)
        if err != nil {
                return nil, err
        }
        wl := stringsx.SplitLines(string(f))
        d := NewDictFromList(wl)
        return d, nil
}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
        "fmt"
        "log/slog"

        "cogentcore.org/core/cli"
        "cogentcore.org/core/text/spell"
)

//go:generate core generate -add-types -add-funcs

// Config is the configuration information for the dict cli.
type Config struct {

        // InputA is the first input dictionary file
        InputA string `posarg:"0" required:"+"`

        // InputB is the second input dictionary file
        InputB string `posarg:"1" required:"+"`

        // Output is the output file for merge command
        Output string `cmd:"merge" posarg:"2" required:"-"`
}

func main() { //types:skip
        opts := cli.DefaultOptions("dict", "runs dictionary commands")
        cli.Run(opts, &Config{}, Compare, Merge)
}

// Compare compares two dictionaries
func Compare(c *Config) error { //cli:cmd -root
        a, err := spell.OpenDict(c.InputA)
        if err != nil {
                slog.Error(err.Error())
                return err
        }
        b, err := spell.OpenDict(c.InputB)
        if err != nil {
                slog.Error(err.Error())
                return err
        }
        fmt.Printf("In %s not in %s:\n", c.InputA, c.InputB)
        for aw := range a {
                if !b.Exists(aw) {
                        fmt.Println(aw)
                }
        }
        fmt.Printf("\n########################\nIn %s not in %s:\n", c.InputB, c.InputA)
        for bw := range b {
                if !a.Exists(bw) {
                        fmt.Println(bw)
                }
        }
        return nil
}

// Merge combines two dictionaries
func Merge(c *Config) error { //cli:cmd
        return nil
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// this code is adapted from: https://github.com/sajari/fuzzy
// https://www.sajari.com/
// Most of which seems to have been written by Hamish @sajari
// it does not have a copyright notice in the code itself but does have
// an MIT license file.
//
// key change is to ignore counts and just use a flat Dict dictionary
// list of words.

package spell

import (
        "strings"
        "sync"

        "golang.org/x/exp/maps"
)

// Model is the full data model
type Model struct {
        // list of all words, combining Base and User dictionaries
        Dict Dict

        // user dictionary of additional words
        UserDict Dict

        // words to ignore for this session
        Ignore Dict

        // map of misspelled word to potential correct spellings
        Suggest map[string][]string

        // depth of edits to include in Suggest map (2 is only sensible value)
        Depth int

        sync.RWMutex
}

// Create and initialise a new model
func NewModel() *Model {
        md := new(Model)
        return md.Init()
}

func (md *Model) Init() *Model {
        md.Suggest = make(map[string][]string)
        md.Ignore = make(Dict)
        md.Depth = 2
        return md
}

func (md *Model) SetDicts(base, user Dict) {
        md.Dict = base
        md.UserDict = user
        maps.Copy(md.Dict, md.UserDict)
        go md.addSuggestionsForWords(md.Dict.List())
}

// addSuggestionsForWords
func (md *Model) addSuggestionsForWords(terms []string) {
        md.Lock()
        // st := time.Now()
        for _, term := range terms {
                md.createSuggestKeys(term)
        }
        // fmt.Println("train took:", time.Since(st)) // about 500 msec for 32k words, 5 sec for 235k
        md.Unlock()
}

// AddWord adds a new word to user dictionary,
// and generates new suggestions for it
func (md *Model) AddWord(term string) {
        md.Lock()
        defer md.Unlock()
        if md.Dict.Exists(term) {
                return
        }
        md.UserDict.Add(term)
        md.Dict.Add(term)
        md.createSuggestKeys(term)
}

// Delete removes given word from dictionary -- undoes learning
func (md *Model) Delete(term string) {
        md.Lock()
        edits := md.EditsMulti(term, 1)
        for _, edit := range edits {
                sug := md.Suggest[edit]
                ns := len(sug)
                for i := ns - 1; i >= 0; i-- {
                        hit := sug[i]
                        if hit == term {
                                sug = append(sug[:i], sug[i+1:]...)
                        }
                }
                if len(sug) == 0 {
                        delete(md.Suggest, edit)
                } else {
                        md.Suggest[edit] = sug
                }
        }
        delete(md.Dict, term)
        md.Unlock()
}

// For a given term, create the partially deleted lookup keys
func (md *Model) createSuggestKeys(term string) {
        edits := md.EditsMulti(term, md.Depth)
        for _, edit := range edits {
                skip := false
                for _, hit := range md.Suggest[edit] {
                        if hit == term {
                                // Already know about this one
                                skip = true
                                continue
                        }
                }
                if !skip && len(edit) > 1 {
                        md.Suggest[edit] = append(md.Suggest[edit], term)
                }
        }
}

// Edits at any depth for a given term. The depth of the model is used
func (md *Model) EditsMulti(term string, depth int) []string {
        edits := Edits1(term)
        for {
                depth--
                if depth <= 0 {
                        break
                }
                for _, edit := range edits {
                        edits2 := Edits1(edit)
                        for _, edit2 := range edits2 {
                                edits = append(edits, edit2)
                        }
                }
        }
        return edits
}

type Pair struct {
        str1 string
        str2 string
}

// Edits1 creates a set of terms that are 1 char delete from the input term
func Edits1(word string) []string {

        splits := []Pair{}
        for i := 0; i <= len(word); i++ {
                splits = append(splits, Pair{word[:i], word[i:]})
        }

        total_set := []string{}
        for _, elem := range splits {

                //deletion
                if len(elem.str2) > 0 {
                        total_set = append(total_set, elem.str1+elem.str2[1:])
                } else {
                        total_set = append(total_set, elem.str1)
                }

        }

        // Special case ending in "ies" or "ys"
        if strings.HasSuffix(word, "ies") {
                total_set = append(total_set, word[:len(word)-3]+"ys")
        }
        if strings.HasSuffix(word, "ys") {
                total_set = append(total_set, word[:len(word)-2]+"ies")
        }

        return total_set
}

// For a given input term, suggest some alternatives.
// if the input is in the dictionary, it will be the only item
// returned.
func (md *Model) suggestPotential(input string) []string {
        input = strings.ToLower(input)

        // 0 - If this is a dictionary term we're all good, no need to go further
        if md.Dict.Exists(input) {
                return []string{input}
        }

        ss := make(Dict)
        var sord []string

        // 1 - See if the input matches a "suggest" key
        if sugg, ok := md.Suggest[input]; ok {
                for _, pot := range sugg {
                        if !ss.Exists(pot) {
                                sord = append(sord, pot)
                                ss.Add(pot)
                        }
                }
        }

        // 2 - See if edit1 matches input
        edits := md.EditsMulti(input, md.Depth)
        got := false
        for _, edit := range edits {
                if len(edit) > 2 && md.Dict.Exists(edit) {
                        got = true
                        if !ss.Exists(edit) {
                                sord = append(sord, edit)
                                ss.Add(edit)
                        }
                }
        }

        if got {
                return sord
        }

        // 3 - No hits on edit1 distance, look for transposes and replaces
        // Note: these are more complex, we need to check the guesses
        // more thoroughly, e.g. levals=[valves] in a raw sense, which
        // is incorrect
        for _, edit := range edits {
                if sugg, ok := md.Suggest[edit]; ok {
                        // Is this a real transpose or replace?
                        for _, pot := range sugg {
                                lev := Levenshtein(&input, &pot)
                                if lev <= md.Depth+1 { // The +1 doesn't seem to impact speed, but has greater coverage when the depth is not sufficient to make suggestions
                                        if !ss.Exists(pot) {
                                                sord = append(sord, pot)
                                                ss.Add(pot)
                                        }
                                }
                        }
                }
        }
        return sord
}

// Return the most likely corrections in order from best to worst
func (md *Model) Suggestions(input string, n int) []string {
        md.RLock()
        suggestions := md.suggestPotential(input)
        md.RUnlock()
        return suggestions
}

// Calculate the Levenshtein distance between two strings
func Levenshtein(a, b *string) int {
        la := len(*a)
        lb := len(*b)
        d := make([]int, la+1)
        var lastdiag, olddiag, temp int

        for i := 1; i <= la; i++ {
                d[i] = i
        }
        for i := 1; i <= lb; i++ {
                d[0] = i
                lastdiag = i - 1
                for j := 1; j <= la; j++ {
                        olddiag = d[j]
                        min := d[j] + 1
                        if (d[j-1] + 1) < min {
                                min = d[j-1] + 1
                        }
                        if (*a)[j-1] == (*b)[i-1] {
                                temp = 0
                        } else {
                                temp = 1
                        }
                        if (lastdiag + temp) < min {
                                min = lastdiag + temp
                        }
                        d[j] = min
                        lastdiag = olddiag
                }
        }
        return d[la]
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package spell

import (
        "embed"
        "log"
        "log/slog"
        "os"
        "strings"
        "sync"
        "time"

        "cogentcore.org/core/text/parse/lexer"
)

//go:embed dict_en_us
var embedDict embed.FS

// SaveAfterLearnIntervalSecs is number of seconds since
// dict file has been opened / saved
// above which model is saved after learning.
const SaveAfterLearnIntervalSecs = 20

// Spell is the global shared spell
var Spell *SpellData

type SpellData struct {
        // UserFile is path to user's dictionary where learned words go
        UserFile string

        model     *Model
        openTime  time.Time    // ModTime() on file
        learnTime time.Time    // last time when a Learn function was called         -- last mod to model -- zero if not mod
        mu        sync.RWMutex // we need our own mutex in case of loading a new model
}

// NewSpell opens spell data with given user dictionary file
func NewSpell(userFile string) *SpellData {
        d, err := OpenDictFS(embedDict, "dict_en_us")
        if err != nil {
                slog.Error(err.Error())
                return nil
        }
        sp := &SpellData{UserFile: userFile}
        sp.ResetLearnTime()
        sp.model = NewModel()
        sp.openTime = time.Date(2024, 06, 30, 00, 00, 00, 0, time.UTC)
        sp.OpenUser()
        sp.model.SetDicts(d, sp.model.UserDict)
        return sp
}

// modTime returns the modification time of given file path
func modTime(path string) (time.Time, error) {
        info, err := os.Stat(path)
        if err != nil {
                return time.Time{}, err
        }
        return info.ModTime(), nil
}

func (sp *SpellData) ResetLearnTime() {
        sp.learnTime = time.Time{}
}

// OpenUser opens user dictionary of words
func (sp *SpellData) OpenUser() error {
        sp.mu.Lock()
        defer sp.mu.Unlock()
        d, err := OpenDict(sp.UserFile)
        if err != nil {
                // slog.Error(err.Error())
                sp.model.UserDict = make(Dict)
                return err
        }
        // note: does not have suggestions for new words
        // future impl will not precompile suggs so it is not worth it
        sp.openTime, err = modTime(sp.UserFile)
        sp.model.UserDict = d
        return err
}

// OpenUserCheck checks if the current user dict file has been modified
// since last open time and re-opens it if so.
func (sp *SpellData) OpenUserCheck() error {
        if sp.UserFile == "" {
                return nil
        }
        sp.mu.Lock()
        defer sp.mu.Unlock()
        tm, err := modTime(sp.UserFile)
        if err != nil {
                return err
        }
        if tm.After(sp.openTime) {
                sp.OpenUser()
                sp.openTime = tm
                // log.Printf("opened newer spell file: %s\n", openTime.String())
        }
        return err
}

// SaveUser saves the user dictionary
// note: this will overwrite any existing file; be sure to have opened
// the current file before making any changes.
func (sp *SpellData) SaveUser() error {
        sp.mu.RLock()
        defer sp.mu.RUnlock()

        if sp.model == nil {
                return nil
        }
        sp.ResetLearnTime()
        err := sp.model.UserDict.Save(sp.UserFile)
        if err == nil {
                sp.openTime, err = modTime(sp.UserFile)
        } else {
                log.Printf("spell.Spell: Error saving file %q: %v\n", sp.UserFile, err)
        }
        return err
}

// SaveUserIfLearn saves the user dictionary
// if learning has occurred since last save / open.
// If no changes also checks if file has been modified and opens it if so.
func (sp *SpellData) SaveUserIfLearn() error {
        if sp == nil {
                return nil
        }
        if sp.UserFile == "" {
                return nil
        }
        if sp.learnTime.IsZero() {
                return sp.OpenUserCheck()
        }
        sp.SaveUser()
        return nil
}

// CheckWord checks a single word and returns suggestions if word is unknown.
// bool is true if word is in the dictionary, false otherwise.
func (sp *SpellData) CheckWord(word string) ([]string, bool) {
        if sp.model == nil {
                log.Println("spell.CheckWord: programmer error -- Spelling not initialized!")
                return nil, false
        }
        w := lexer.FirstWordApostrophe(word) // only lookup words
        orig := w
        w = strings.ToLower(w)

        sp.mu.RLock()
        defer sp.mu.RUnlock()
        if sp.model.Ignore.Exists(w) {
                return nil, true
        }
        suggests := sp.model.Suggestions(w, 10)
        if suggests == nil { // no sug and not known
                return nil, false
        }
        if len(suggests) == 1 && suggests[0] == w {
                return nil, true
        }
        for i, s := range suggests {
                suggests[i] = lexer.MatchCase(orig, s)
        }
        return suggests, false
}

// AddWord adds given word to the User dictionary
func (sp *SpellData) AddWord(word string) {
        if sp.learnTime.IsZero() {
                sp.OpenUserCheck() // be sure we have latest before learning!
        }
        sp.mu.Lock()
        lword := strings.ToLower(word)
        sp.model.AddWord(lword)
        sp.learnTime = time.Now()
        sint := sp.learnTime.Sub(sp.openTime) / time.Second
        sp.mu.Unlock()

        if sp.UserFile != "" && sint > SaveAfterLearnIntervalSecs {
                sp.SaveUser()
                // log.Printf("spell.LearnWord: saved updated model after %d seconds\n", sint)
        }
}

// DeleteWord removes word from dictionary, in case accidentally added
func (sp *SpellData) DeleteWord(word string) {
        if sp.learnTime.IsZero() {
                sp.OpenUserCheck() // be sure we have latest before learning!
        }

        sp.mu.Lock()
        lword := strings.ToLower(word)
        sp.model.Delete(lword)
        sp.learnTime = time.Now()
        sint := sp.learnTime.Sub(sp.openTime) / time.Second
        sp.mu.Unlock()

        if sp.UserFile != "" && sint > SaveAfterLearnIntervalSecs {
                sp.SaveUser()
        }
        log.Printf("spell.DeleteWord: %s\n", lword)
}

/*
// Complete finds possible completions based on the prefix s
func (sp *SpellData) Complete(s string) []string {
        if model == nil {
                log.Println("spell.Complete: programmer error -- Spelling not initialized!")
                OpenDefault() // backup
        }
        sp.mu.RLock()
        defer sp.mu.RUnlock()

        result, _ := model.Autocomplete(s)
        return result
}
*/

// IgnoreWord adds the word to the Ignore list
func (sp *SpellData) IgnoreWord(word string) {
        word = strings.ToLower(word)
        sp.model.Ignore.Add(word)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// note: adapted from https://github.com/tdewolff/canvas,
// Copyright (c) 2015 Taco de Wolff, under an MIT License.

package tex

import (
        "encoding/binary"
        "fmt"

        "cogentcore.org/core/paint/ppath"
)

var debug = false

type state struct {
        h, v, w, x, y, z int32
}

// DVIToPath parses a DVI file (output from TeX) and returns *ppath.Path.
// fontSizeDots specifies the actual font size in dots (actual pixels)
// for a 10pt font in the DVI system.
func DVIToPath(b []byte, fonts *dviFonts, fontSizeDots float32) (*ppath.Path, error) {
        // state
        var fnt uint32 // font index
        s := state{}
        stack := []state{}

        f := float32(1.0)             // scale factor in mm/units
        mag := uint32(1000)           // is set explicitly in preamble
        fnts := map[uint32]*dviFont{} // selected fonts for indices

        fontScale := fontSizeDots / 8         // factor for scaling font itself
        fontScaleFactor := fontSizeDots / 2.8 // factor for scaling the math

        // first position of baseline which will be the path's origin
        firstChar := true
        h0 := int32(0)
        v0 := int32(0)

        p := &ppath.Path{}
        r := &dviReader{b, 0}
        for 0 < r.len() {
                cmd := r.readByte()
                if cmd <= 127 {
                        // set_char
                        if firstChar {
                                h0, v0 = s.h, s.v
                                firstChar = false
                        }
                        c := uint32(cmd)
                        if _, ok := fnts[fnt]; !ok {
                                return nil, fmt.Errorf("bad command: font %v undefined at position %v", fnt, r.i)
                        }
                        if debug {
                                fmt.Printf("\nchar font #%d, cid: %d, rune: %s, pos: (%v,%v)\n", fnt, c, string(rune(c)), f*float32(s.h), f*float32(s.v))
                        }
                        w := int32(fnts[fnt].Draw(p, f*float32(s.h), f*float32(s.v), c, fontScale) / f)
                        s.h += w
                } else if 128 <= cmd && cmd <= 131 {
                        // set
                        if firstChar {
                                h0, v0 = s.h, s.v
                                firstChar = false
                        }
                        n := int(cmd - 127)
                        if r.len() < n {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        c := r.readUint32N(n)
                        if _, ok := fnts[fnt]; !ok {
                                return nil, fmt.Errorf("bad command: font %v undefined at position %v", fnt, r.i)
                        }
                        // fmt.Println("print:", string(rune(c)), s.v)
                        s.h += int32(fnts[fnt].Draw(p, f*float32(s.h), f*float32(s.v), c, fontScale) / f)
                } else if cmd == 132 {
                        // set_rule
                        height := r.readInt32()
                        width := r.readInt32()
                        if 0 < width && 0 < height {
                                p.MoveTo(f*float32(s.h), f*float32(s.v))
                                p.LineTo(f*float32(s.h+width), f*float32(s.v))
                                p.LineTo(f*float32(s.h+width), f*float32(s.v-height))
                                p.LineTo(f*float32(s.h), f*float32(s.v-height))
                                p.Close()
                        }
                        s.h += width
                } else if 133 <= cmd && cmd <= 136 {
                        // put
                        if firstChar {
                                h0, v0 = s.h, s.v
                                firstChar = false
                        }
                        n := int(cmd - 132)
                        if r.len() < n {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        c := r.readUint32N(n)
                        if _, ok := fnts[fnt]; !ok {
                                return nil, fmt.Errorf("bad command: font %v undefined at position %v", fnt, r.i)
                        }
                        // fmt.Println("print:", string(rune(c)), s.v)
                        fnts[fnt].Draw(p, f*float32(s.h), f*float32(s.v), c, fontScale)
                } else if cmd == 137 {
                        // put_rule
                        height := r.readInt32()
                        width := r.readInt32()
                        if 0 < width && 0 < height {
                                p.MoveTo(f*float32(s.h), f*float32(s.v))
                                p.LineTo(f*float32(s.h+width), f*float32(s.v))
                                p.LineTo(f*float32(s.h+width), f*float32(s.v-height))
                                p.LineTo(f*float32(s.h), f*float32(s.v-height))
                                p.Close()
                        }
                } else if cmd == 138 {
                        // nop
                } else if cmd == 139 {
                        // bop
                        fnt = 0
                        s = state{0, 0, 0, 0, 0, 0}
                        stack = stack[:0]
                        _ = r.readBytes(10 * 4)
                        _ = r.readUint32() // pointer
                } else if cmd == 140 {
                        // eop
                } else if cmd == 141 {
                        // push
                        stack = append(stack, s)
                } else if cmd == 142 {
                        // pop
                        if len(stack) == 0 {
                                return nil, fmt.Errorf("bad command: stack is empty at position %v", r.i)
                        }
                        s = stack[len(stack)-1]
                        stack = stack[:len(stack)-1]
                } else if 143 <= cmd && cmd <= 146 {
                        // right
                        n := int(cmd - 142)
                        if r.len() < n {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        d := r.readInt32N(n)
                        s.h += d
                } else if 147 <= cmd && cmd <= 151 {
                        // w
                        if cmd == 147 {
                                s.h += s.w
                        } else {
                                n := int(cmd - 147)
                                if r.len() < n {
                                        return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                                }
                                d := r.readInt32N(n)
                                s.w = d
                                s.h += d
                        }
                } else if 152 <= cmd && cmd <= 156 {
                        // x
                        if cmd == 152 {
                                s.h += s.x
                        } else {
                                n := int(cmd - 152)
                                if r.len() < n {
                                        return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                                }
                                d := r.readInt32N(n)
                                s.x = d
                                s.h += d
                        }
                } else if 157 <= cmd && cmd <= 160 {
                        // down
                        n := int(cmd - 156)
                        if r.len() < n {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        d := r.readInt32N(n)
                        // fmt.Println("down:", d, s.v)
                        s.v += d
                } else if 161 <= cmd && cmd <= 165 {
                        // y
                        if cmd == 161 {
                                s.v += s.y
                        } else {
                                n := int(cmd - 152)
                                if r.len() < n {
                                        return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                                }
                                d := r.readInt32N(n)
                                s.y = d
                                s.v += d
                        }
                } else if 166 <= cmd && cmd <= 170 {
                        // z
                        if cmd == 166 {
                                s.v += s.z
                                fmt.Println("z down", s.z, s.v)
                        } else {
                                n := int(cmd - 166)
                                if r.len() < n {
                                        return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                                }
                                d := r.readInt32N(n)
                                s.z = d
                                s.v += d
                        }
                } else if 171 <= cmd && cmd <= 234 {
                        // fnt_num
                        fnt = uint32(cmd - 171)
                } else if 235 <= cmd && cmd <= 242 {
                        // fnt
                        n := int(cmd - 234)
                        if r.len() < n {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        fnt = r.readUint32N(n)
                } else if 239 <= cmd && cmd <= 242 {
                        // xxx
                        n := int(cmd - 242)
                        if r.len() < n {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        k := int(r.readUint32N(n))
                        if r.len() < k {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        _ = r.readBytes(k)
                } else if 243 <= cmd && cmd <= 246 {
                        // fnt_def
                        n := int(cmd - 242)
                        if r.len() < n+14 {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        k := r.readUint32N(n)
                        _ = r.readBytes(4) // checksum
                        size := r.readUint32()
                        design := r.readUint32() // design
                        a := r.readByte()
                        l := r.readByte()
                        if r.len() < int(a+l) {
                                return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                        }
                        _ = r.readString(int(a)) // area
                        fscale := float32(mag) * float32(size) / 1000.0 / float32(design)
                        // this is 1 for 10pt font:
                        name := r.readString(int(l))
                        fnts[k] = fonts.Get(name, fscale)
                        if debug {
                                fmt.Printf("\ndefine font #:%d name: %s, size: %v, mag: %v, design: %v, scale: %v\n", k, name, size, mag, design, fscale)
                        }
                } else if cmd == 247 {
                        // pre
                        _ = r.readByte() // version
                        num := r.readUint32()
                        den := r.readUint32()
                        mag = r.readUint32()
                        f = fontScaleFactor * float32(num) / float32(den) * float32(mag) / 1000.0 / 10000.0 // in units/mm
                        // fmt.Println("num:", num, "mag:", mag, "den:", den, "f:", f)
                        n := int(r.readByte())
                        _ = r.readString(n) // comment
                } else if cmd == 248 {
                        _ = r.readUint32() // pointer to final bop
                        _ = r.readUint32() // num
                        _ = r.readUint32() // den
                        _ = r.readUint32() // mag
                        _ = r.readUint32() // largest height
                        _ = r.readUint32() // largest width
                        _ = r.readUint16() // maximum stack depth
                        _ = r.readUint16() // number of pages
                } else if cmd == 249 {
                        _ = r.readUint32() // pointer to post
                        _ = r.readByte()   // version
                        for 0 < r.len() {
                                if r.readByte() != 223 {
                                        break
                                }
                        }
                } else {
                        return nil, fmt.Errorf("bad command: %v at position %v", cmd, r.i)
                }
        }
        // fmt.Println("start offsets:", h0, v0)
        *p = p.Translate(-f*float32(h0), -f*float32(v0))
        return p, nil
}

type dviReader struct {
        b []byte
        i int
}

func (r *dviReader) len() int {
        return len(r.b) - r.i
}

func (r *dviReader) readByte() byte {
        r.i++
        return r.b[r.i-1]
}

func (r *dviReader) readUint16() uint16 {
        num := binary.BigEndian.Uint16(r.b[r.i : r.i+2])
        r.i += 2
        return num
}

func (r *dviReader) readUint32() uint32 {
        num := binary.BigEndian.Uint32(r.b[r.i : r.i+4])
        r.i += 4
        return num
}

func (r *dviReader) readInt32() int32 {
        return int32(r.readUint32())
}

func (r *dviReader) readUint32N(n int) uint32 {
        if n == 1 {
                return uint32(r.readByte())
        } else if n == 2 {
                return uint32(r.readUint16())
        } else if n == 3 {
                a := r.readByte()
                b := r.readByte()
                c := r.readByte()
                return uint32(a)<<16 | uint32(b)<<8 | uint32(c)
        } else if n == 4 {
                return r.readUint32()
        }
        r.i += n
        return 0
}

func (r *dviReader) readInt32N(n int) int32 {
        if n == 3 {
                a := r.readByte()
                b := r.readByte()
                c := r.readByte()
                if a < 128 {
                        return int32(uint32(a)<<16 | uint32(b)<<8 | uint32(c))
                }
                return int32((uint32(a)-256)<<16 | uint32(b)<<8 | uint32(c))
        }
        return int32(r.readUint32N(n))
}

func (r *dviReader) readBytes(n int) []byte {
        b := r.b[r.i : r.i+n]
        r.i += n
        return b
}

func (r *dviReader) readString(n int) string {
        return string(r.readBytes(n))
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// note: adapted from https://github.com/tdewolff/canvas,
// Copyright (c) 2015 Taco de Wolff, under an MIT License.
// and gioui: Unlicense OR MIT, Copyright (c) 2019 The Gio authors

package tex

import (
        "bytes"
        "fmt"
        "strconv"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/text/fonts"
        "github.com/go-fonts/latin-modern/lmmath"
        "github.com/go-fonts/latin-modern/lmmono10italic"
        "github.com/go-fonts/latin-modern/lmmono10regular"
        "github.com/go-fonts/latin-modern/lmmono12regular"
        "github.com/go-fonts/latin-modern/lmmono8regular"
        "github.com/go-fonts/latin-modern/lmmono9regular"
        "github.com/go-fonts/latin-modern/lmmonocaps10regular"
        "github.com/go-fonts/latin-modern/lmmonoslant10regular"
        "github.com/go-fonts/latin-modern/lmroman10bold"
        "github.com/go-fonts/latin-modern/lmroman10bolditalic"
        "github.com/go-fonts/latin-modern/lmroman10italic"
        "github.com/go-fonts/latin-modern/lmroman10regular"
        "github.com/go-fonts/latin-modern/lmroman12bold"
        "github.com/go-fonts/latin-modern/lmroman12italic"
        "github.com/go-fonts/latin-modern/lmroman12regular"
        "github.com/go-fonts/latin-modern/lmroman17regular"
        "github.com/go-fonts/latin-modern/lmroman5bold"
        "github.com/go-fonts/latin-modern/lmroman5regular"
        "github.com/go-fonts/latin-modern/lmroman6bold"
        "github.com/go-fonts/latin-modern/lmroman6regular"
        "github.com/go-fonts/latin-modern/lmroman7bold"
        "github.com/go-fonts/latin-modern/lmroman7italic"
        "github.com/go-fonts/latin-modern/lmroman7regular"
        "github.com/go-fonts/latin-modern/lmroman8bold"
        "github.com/go-fonts/latin-modern/lmroman8italic"
        "github.com/go-fonts/latin-modern/lmroman8regular"
        "github.com/go-fonts/latin-modern/lmroman9bold"
        "github.com/go-fonts/latin-modern/lmroman9italic"
        "github.com/go-fonts/latin-modern/lmroman9regular"
        "github.com/go-fonts/latin-modern/lmromancaps10regular"
        "github.com/go-fonts/latin-modern/lmromandunh10regular"
        "github.com/go-fonts/latin-modern/lmromanslant10bold"
        "github.com/go-fonts/latin-modern/lmromanslant10regular"
        "github.com/go-fonts/latin-modern/lmromanslant12regular"
        "github.com/go-fonts/latin-modern/lmromanslant17regular"
        "github.com/go-fonts/latin-modern/lmromanslant8regular"
        "github.com/go-fonts/latin-modern/lmromanslant9regular"
        "github.com/go-fonts/latin-modern/lmromanunsl10regular"
        "github.com/go-fonts/latin-modern/lmsans10bold"
        "github.com/go-fonts/latin-modern/lmsans10oblique"
        "github.com/go-fonts/latin-modern/lmsans10regular"
        "github.com/go-fonts/latin-modern/lmsans12oblique"
        "github.com/go-fonts/latin-modern/lmsans12regular"
        "github.com/go-fonts/latin-modern/lmsans17oblique"
        "github.com/go-fonts/latin-modern/lmsans17regular"
        "github.com/go-fonts/latin-modern/lmsans8oblique"
        "github.com/go-fonts/latin-modern/lmsans8regular"
        "github.com/go-fonts/latin-modern/lmsans9oblique"
        "github.com/go-fonts/latin-modern/lmsans9regular"
        "github.com/go-fonts/latin-modern/lmsansdemicond10regular"
        "github.com/go-fonts/latin-modern/lmsansquot8oblique"
        "github.com/go-fonts/latin-modern/lmsansquot8regular"
        "github.com/go-text/typesetting/font"
        "github.com/go-text/typesetting/font/opentype"
)

const mmPerPt = 25.4 / 72.0

// LMFontsLoad loads the LMFonts.
func LMFontsLoad() {
        for i := range LMFonts {
                fd := &LMFonts[i]
                errors.Log(fd.Load())
        }
}

// LMFonts are tex latin-modern fonts.
var LMFonts = []fonts.Data{
        {Family: "cmbsy", Data: lmmath.TTF},
        {Family: "cmr17", Data: lmroman17regular.TTF},
        {Family: "cmr12", Data: lmroman12regular.TTF},
        {Family: "cmr10", Data: lmroman10regular.TTF},
        {Family: "cmr9", Data: lmroman9regular.TTF},
        {Family: "cmr8", Data: lmroman8regular.TTF},
        {Family: "cmr7", Data: lmroman7regular.TTF},
        {Family: "cmr6", Data: lmroman6regular.TTF},
        {Family: "cmr5", Data: lmroman5regular.TTF},
        // cmb, cmbx
        {Family: "cmb12", Data: lmroman12bold.TTF},
        {Family: "cmb10", Data: lmroman10bold.TTF},
        {Family: "cmb9", Data: lmroman9bold.TTF},
        {Family: "cmb8", Data: lmroman8bold.TTF},
        {Family: "cmb7", Data: lmroman7bold.TTF},
        {Family: "cmb6", Data: lmroman6bold.TTF},
        {Family: "cmb5", Data: lmroman5bold.TTF},
        // cmti
        {Family: "cmti12", Data: lmroman12italic.TTF},
        {Family: "cmti10", Data: lmroman10italic.TTF},
        {Family: "cmti9", Data: lmroman9italic.TTF},
        {Family: "cmti8", Data: lmroman8italic.TTF},
        {Family: "cmti7", Data: lmroman7italic.TTF},
        // cmsl
        {Family: "cmsl17", Data: lmromanslant17regular.TTF},
        {Family: "cmsl12", Data: lmromanslant12regular.TTF},
        {Family: "cmsl10", Data: lmromanslant10regular.TTF},
        {Family: "cmsl9", Data: lmromanslant9regular.TTF},
        {Family: "cmsl8", Data: lmromanslant8regular.TTF},
        // cmbxsl
        {Family: "cmbxsl10", Data: lmromanslant10bold.TTF},
        // cmbxti, cmmib with cmapCMMI
        {Family: "cmmib10", Data: lmroman10bolditalic.TTF},
        // cmcsc
        {Family: "cmcsc10", Data: lmromancaps10regular.TTF},
        // cmdunh
        {Family: "cmdunh10", Data: lmromandunh10regular.TTF},
        // cmu
        {Family: "cmu10", Data: lmromanunsl10regular.TTF},

        // cmss
        {Family: "cmss17", Data: lmsans17regular.TTF},
        {Family: "cmss12", Data: lmsans12regular.TTF},
        {Family: "cmss10", Data: lmsans10regular.TTF},
        {Family: "cmss9", Data: lmsans9regular.TTF},
        {Family: "cmss8", Data: lmsans8regular.TTF},
        // cmssb, cmssbx
        {Family: "cmssb10", Data: lmsans10bold.TTF},
        // cmssdc
        {Family: "cmssdc10", Data: lmsansdemicond10regular.TTF},
        // cmssi
        {Family: "cmssi17", Data: lmsans17oblique.TTF},
        {Family: "cmssi12", Data: lmsans12oblique.TTF},
        {Family: "cmssi10", Data: lmsans10oblique.TTF},
        {Family: "cmssi9", Data: lmsans9oblique.TTF},
        {Family: "cmssi8", Data: lmsans8oblique.TTF},
        // cmssq
        {Family: "cmssq8", Data: lmsansquot8regular.TTF},
        // cmssqi
        {Family: "cmssqi8", Data: lmsansquot8oblique.TTF},

        // cmtt
        {Family: "cmtt12", Data: lmmono12regular.TTF},
        {Family: "cmtt10", Data: lmmono10regular.TTF},
        {Family: "cmtt9", Data: lmmono9regular.TTF},
        {Family: "cmtt8", Data: lmmono8regular.TTF},
        // cmti
        // {Family: "cmti", Data: lmmono12italic.TTF},
        {Family: "cmti10", Data: lmmono10italic.TTF},
        // {Family: "cmti", Data: lmmono9italic.TTF},
        // {Family: "cmti", Data: lmmono8italic.TTF},
        // cmtcsc
        {Family: "cmtcsc10", Data: lmmonocaps10regular.TTF},
}

//////// dviFonts

// dviFonts supports rendering of following standard DVI fonts:
//
//        cmr: Roman (5--10pt)
//        cmmi: Math Italic (5--10pt)
//        cmsy: Math Symbols (5--10pt)
//        cmex: Math Extension (10pt)
//        cmss: Sans serif (10pt)
//        cmssqi: Sans serif quote italic (8pt)
//        cmssi: Sans serif Italic (10pt)
//        cmbx: Bold Extended (10pt)
//        cmtt: Typewriter (8--10pt)
//        cmsltt: Slanted typewriter (10pt)
//        cmsl: Slanted roman (8--10pt)
//        cmti: Text italic (7--10pt)
//        cmu: Unslanted text italic (10pt)
//        cmmib: Bold math italic (10pt)
//        cmbsy: Bold math symbols (10pt)
//        cmcsc: Caps and Small caps (10pt)
//        cmssbx: Sans serif bold extended (10pt)
//        cmdunh: Dunhill style (10pt)
type dviFonts struct {
        font     map[string]*dviFont
        mathSyms *dviFont // always available as backup for any rune
}

type dviFont struct {
        face     *font.Face
        cmap     map[uint32]rune
        size     float32
        italic   bool
        ex       bool
        mathSyms *dviFont // always available as backup for any rune
}

func newFonts() *dviFonts {
        return &dviFonts{
                font: map[string]*dviFont{},
        }
}

func (fs *dviFonts) Get(name string, scale float32) *dviFont {
        i := 0
        for i < len(name) && 'a' <= name[i] && name[i] <= 'z' {
                i++
        }
        fontname := name[:i]
        fontsize := float32(10.0)
        if ifontsize, err := strconv.Atoi(name[i:]); err == nil {
                fontsize = float32(ifontsize)
        }
        // fmt.Println("font name:", fontname, fontsize, scale)

        if fs.mathSyms == nil {
                fs.mathSyms = fs.loadFont("cmsy", cmapCMSY, 10.0, scale, lmmath.TTF)
        }

        cmap := cmapCMR
        f, ok := fs.font[name]
        if !ok {
                var fontSizes map[float32][]byte
                switch fontname {
                case "cmb", "cmbx":
                        fontSizes = map[float32][]byte{
                                12.0: lmroman12bold.TTF,
                                10.0: lmroman10bold.TTF,
                                9.0:  lmroman9bold.TTF,
                                8.0:  lmroman8bold.TTF,
                                7.0:  lmroman7bold.TTF,
                                6.0:  lmroman6bold.TTF,
                                5.0:  lmroman5bold.TTF,
                        }
                case "cmbsy":
                        cmap = cmapCMSY
                        fontSizes = map[float32][]byte{
                                fontsize: lmmath.TTF,
                        }
                case "cmbxsl":
                        fontSizes = map[float32][]byte{
                                fontsize: lmromanslant10bold.TTF,
                        }
                case "cmbxti":
                        fontSizes = map[float32][]byte{
                                10.0: lmroman10bolditalic.TTF,
                        }
                case "cmcsc":
                        cmap = cmapCMTT
                        fontSizes = map[float32][]byte{
                                10.0: lmromancaps10regular.TTF,
                        }
                case "cmdunh":
                        fontSizes = map[float32][]byte{
                                10.0: lmromandunh10regular.TTF,
                        }
                case "cmex":
                        cmap = cmapCMEX
                        fontSizes = map[float32][]byte{
                                fontsize: lmmath.TTF,
                        }
                case "cmitt":
                        cmap = cmapCMTT
                        fontSizes = map[float32][]byte{
                                10.0: lmmono10italic.TTF,
                        }
                case "cmmi":
                        cmap = cmapCMMI
                        fontSizes = map[float32][]byte{
                                12.0: lmroman12italic.TTF,
                                10.0: lmroman10italic.TTF,
                                9.0:  lmroman9italic.TTF,
                                8.0:  lmroman8italic.TTF,
                                7.0:  lmroman7italic.TTF,
                        }
                case "cmmib":
                        cmap = cmapCMMI
                        fontSizes = map[float32][]byte{
                                10.0: lmroman10bolditalic.TTF,
                        }
                case "cmr":
                        fontSizes = map[float32][]byte{
                                17.0: lmroman17regular.TTF,
                                12.0: lmroman12regular.TTF,
                                10.0: lmroman10regular.TTF,
                                9.0:  lmroman9regular.TTF,
                                8.0:  lmroman8regular.TTF,
                                7.0:  lmroman7regular.TTF,
                                6.0:  lmroman6regular.TTF,
                                5.0:  lmroman5regular.TTF,
                        }
                case "cmsl":
                        fontSizes = map[float32][]byte{
                                17.0: lmromanslant17regular.TTF,
                                12.0: lmromanslant12regular.TTF,
                                10.0: lmromanslant10regular.TTF,
                                9.0:  lmromanslant9regular.TTF,
                                8.0:  lmromanslant8regular.TTF,
                        }
                case "cmsltt":
                        fontSizes = map[float32][]byte{
                                10.0: lmmonoslant10regular.TTF,
                        }
                case "cmss":
                        fontSizes = map[float32][]byte{
                                17.0: lmsans17regular.TTF,
                                12.0: lmsans12regular.TTF,
                                10.0: lmsans10regular.TTF,
                                9.0:  lmsans9regular.TTF,
                                8.0:  lmsans8regular.TTF,
                        }
                case "cmssb", "cmssbx":
                        fontSizes = map[float32][]byte{
                                10.0: lmsans10bold.TTF,
                        }
                case "cmssdc":
                        fontSizes = map[float32][]byte{
                                10.0: lmsansdemicond10regular.TTF,
                        }
                case "cmssi":
                        fontSizes = map[float32][]byte{
                                17.0: lmsans17oblique.TTF,
                                12.0: lmsans12oblique.TTF,
                                10.0: lmsans10oblique.TTF,
                                9.0:  lmsans9oblique.TTF,
                                8.0:  lmsans8oblique.TTF,
                        }
                case "cmssq":
                        fontSizes = map[float32][]byte{
                                8.0: lmsansquot8regular.TTF,
                        }
                case "cmssqi":
                        fontSizes = map[float32][]byte{
                                8.0: lmsansquot8oblique.TTF,
                        }
                case "cmsy":
                        cmap = cmapCMSY
                        fontSizes = map[float32][]byte{
                                fontsize: lmmath.TTF,
                        }
                case "cmtcsc":
                        cmap = cmapCMTT
                        fontSizes = map[float32][]byte{
                                10.0: lmmonocaps10regular.TTF,
                        }
                //case "cmtex":
                //cmap = nil
                case "cmti":
                        fontSizes = map[float32][]byte{
                                12.0: lmroman12italic.TTF,
                                10.0: lmroman10italic.TTF,
                                9.0:  lmroman9italic.TTF,
                                8.0:  lmroman8italic.TTF,
                                7.0:  lmroman7italic.TTF,
                        }
                case "cmtt":
                        cmap = cmapCMTT
                        fontSizes = map[float32][]byte{
                                12.0: lmmono12regular.TTF,
                                10.0: lmmono10regular.TTF,
                                9.0:  lmmono9regular.TTF,
                                8.0:  lmmono8regular.TTF,
                        }
                case "cmu":
                        fontSizes = map[float32][]byte{
                                10.0: lmromanunsl10regular.TTF,
                        }
                //case "cmvtt":
                //cmap = cmapCTT
                default:
                        fmt.Println("WARNING: unknown font", fontname)
                }

                // select closest matching font size
                var data []byte
                var size float32
                for isize, idata := range fontSizes {
                        if data == nil || math32.Abs(isize-fontsize) < math32.Abs(size-fontsize) {
                                data = idata
                                size = isize
                        }
                }
                f = fs.loadFont(fontname, cmap, fontsize, scale, data)
                fs.font[name] = f
        }
        return f
}

func (fs *dviFonts) loadFont(fontname string, cmap map[uint32]rune, fontsize, scale float32, data []byte) *dviFont {
        faces, err := font.ParseTTC(bytes.NewReader(data))
        if err != nil { // todo: should still work presumably?
                errors.Log(err)
        }
        face := faces[0]
        fsize := scale * fontsize
        isItalic := 0 < len(fontname) && fontname[len(fontname)-1] == 'i'
        isEx := fontname == "cmex"

        return &dviFont{face: face, cmap: cmap, size: fsize, italic: isItalic, ex: isEx, mathSyms: fs.mathSyms}
}

const (
        mag1 = 1.2
        mag2 = 1.2 * 1.2
        mag3 = 1.2 * 1.2 * 1.2
        mag4 = 1.2 * 1.2 * 1.2 * 1.2 * 1.2
        mag5 = 3.2
)

var cmexScales = map[uint32]float32{
        0x00: mag1,
        0x01: mag1,
        0x02: mag1,
        0x03: mag1,
        0x04: mag1,
        0x05: mag1,
        0x06: mag1,
        0x07: mag1,
        0x08: mag1,
        0x0A: mag1,
        0x0B: mag1,
        0x0C: mag1,
        0x0D: mag1,
        0x0E: mag1,
        0x0F: mag1,

        0x10: mag3, // (
        0x11: mag3, // )
        0x12: mag4, // (
        0x13: mag4, // )
        0x14: mag4, // [
        0x15: mag4, // ]
        0x16: mag4, // ⌊
        0x17: mag4, // ⌋
        0x18: mag4, // ⌈
        0x19: mag4, // ⌉
        0x1A: mag4, // {
        0x1B: mag4, // }
        0x1C: mag4, // 〈
        0x1D: mag4, // 〉
        0x1E: mag4, // ∕
        0x1F: mag4, // \

        0x20: mag5, // (
        0x21: mag5, // )
        0x22: mag5, // [
        0x23: mag5, // ]
        0x24: mag5, // ⌊
        0x25: mag5, // ⌋
        0x26: mag5, // ⌈
        0x27: mag5, // ⌉
        0x28: mag5, // {
        0x29: mag5, // }
        0x2A: mag5, // 〈
        0x2B: mag5, // 〉
        0x2C: mag5, // ∕
        0x2D: mag5, // \
        0x2E: mag3, // ∕
        0x2F: mag3, // \

        0x30: mag2, // ⎛
        0x31: mag2, // ⎞
        0x32: mag2, // ⌈
        0x33: mag2, // ⌉
        0x34: mag2, // ⌊
        0x35: mag2, // ⌋
        0x36: mag2, // ⎢
        0x37: mag2, // ⎥

        0x38: mag2, // ⎧ // big braces start
        0x39: mag2, // ⎫
        0x3A: mag2, // ⎩
        0x3B: mag2, // ⎭
        0x3C: mag2, // ⎨
        0x3D: mag2, // ⎬
        0x3E: mag2, // ⎪
        0x3F: mag2, // ∣ ?? unclear

        0x40: mag2, // ⎝ // big parens
        0x41: mag2, // ⎠
        0x42: mag2, // ⎜
        0x43: mag2, // ⎟
        0x44: mag2, // 〈
        0x45: mag2, // 〉
        0x47: mag2, // ⨆
        0x49: mag2, // ∮
        0x4B: mag2, // ⨀
        0x4D: mag2, // ⨁
        0x4F: mag2, // ⨂

        0x58: mag2, // ∑
        0x59: mag2, // ∏
        0x5A: mag2, // ∫
        0x5B: mag2, // ⋃
        0x5C: mag2, // ⋂
        0x5D: mag2, // ⨄
        0x5E: mag2, // ⋀
        0x5F: mag2, // ⋁

        0x61: mag2, // ∐
        0x63: mag2, // ̂
        0x64: mag4, // ̂
        0x66: mag2, // ˜
        0x67: mag4, // ˜
        0x68: mag3, // [
        0x69: mag3, // ]
        0x6B: mag2, // ⌋
        0x6C: mag2, // ⌈
        0x6D: mag2, // ⌉
        0x6E: mag3, // {
        0x6F: mag3, // }

        0x71: mag3, // √
        0x72: mag4, // √
        0x73: mag5, // √
        0x74: mag1, // ⎷
        0x75: mag1, // ⏐
        0x76: mag1, // ⌜

}

func (f *dviFont) Draw(p *ppath.Path, x, y float32, cid uint32, scale float32) float32 {
        r := f.cmap[cid]
        face := f.face
        gid, ok := face.Cmap.Lookup(r)
        if !ok {
                if f.mathSyms != nil {
                        face = f.mathSyms.face
                        gid, ok = face.Cmap.Lookup(r)
                        if !ok {
                                fmt.Println("rune not found in mathSyms:", string(r))
                        }
                } else {
                        fmt.Println("rune not found:", string(r))
                }
        }
        hadv := face.HorizontalAdvance(gid)
        // fmt.Printf("rune: 0x%0x gid: %d, r: 0x%0X\n", cid, gid, int(r))

        outline := face.GlyphData(gid).(font.GlyphOutline)
        sc := scale * f.size / float32(face.Upem())
        xsc := float32(1)
        // fmt.Println("draw scale:", sc, "f.size:", f.size, "face.Upem()", face.Upem())

        if f.ex {
                ext, _ := face.GlyphExtents(gid)
                exsc, has := cmexScales[cid]
                yb := ext.YBearing
                if has {
                        sc *= exsc
                        switch cid {
                        case 0x5A, 0x49: // \int and \oint are off in large size
                                yb += 200
                        case 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F:
                                // larger delims are too thick
                                xsc = .7
                        case 0x20, 0x21, 0x22, 0x23, 0x28, 0x29, 0x2A, 0x2B:
                                // same for even larger ones
                                xsc = .6
                        case 0x3C, 0x3D: // braces middles need shifting
                                yb += 150
                        case 0x3A, 0x3B: // braces bottom shifting
                                yb += 400
                        // below are fixes for all the square root elements
                        case 0x71:
                                x += sc * 80
                                xsc = .6
                        case 0x72:
                                x -= sc * 80
                                xsc = .6
                        case 0x73:
                                x -= sc * 80
                                xsc = .5
                        case 0x74:
                                yb += 600
                        case 0x75:
                                x += sc * 560
                        case 0x76:
                                x += sc * 400
                                yb -= 36
                        }
                }
                y += sc * yb
        }

        if f.italic {
                // angle := f.face.Post.ItalicAngle
                // angle := float32(-15) // degrees
                // x -= scale * f.size * face.LineMetric(font.XHeight) / 2.0 * math32.Tan(-angle*math.Pi/180.0)
        }

        for _, s := range outline.Segments {
                p0 := math32.Vec2(s.Args[0].X*xsc*sc+x, -s.Args[0].Y*sc+y)
                switch s.Op {
                case opentype.SegmentOpMoveTo:
                        p.MoveTo(p0.X, p0.Y)
                case opentype.SegmentOpLineTo:
                        p.LineTo(p0.X, p0.Y)
                case opentype.SegmentOpQuadTo:
                        p1 := math32.Vec2(s.Args[1].X*xsc*sc+x, -s.Args[1].Y*sc+y)
                        p.QuadTo(p0.X, p0.Y, p1.X, p1.Y)
                case opentype.SegmentOpCubeTo:
                        p1 := math32.Vec2(s.Args[1].X*xsc*sc+x, -s.Args[1].Y*sc+y)
                        p2 := math32.Vec2(s.Args[2].X*xsc*sc+x, -s.Args[2].Y*sc+y)
                        p.CubeTo(p0.X, p0.Y, p1.X, p1.Y, p2.X, p2.Y)
                }
        }
        p.Close()
        adv := sc * hadv
        // fmt.Println("hadv:", face.HorizontalAdvance(gid), "adv:", adv)
        return adv
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tex

import (
        "bytes"
        "fmt"
        "strings"
        "sync"

        "cogentcore.org/core/paint/ppath"
        "cogentcore.org/core/text/shaped"
        "star-tex.org/x/tex"
)

var (
        texEngine *tex.Engine
        texFonts  *dviFonts
        texMu     sync.Mutex

        preamble = `\nopagenumbers

\def\frac#1#2{{{#1}\over{#2}}}
`
)

func init() {
        shaped.ShapeMath = TeXMath
}

// TeXMath parses a plain TeX math expression and returns a path
// rendering that expression. This is NOT LaTeX and only \frac is defined
// as an additional math utility function, for fractions.
// To activate display math mode, add an additional $ $ surrounding the
// expression: one set of $ $ is automatically included to produce inline
// math mode rendering.
// fontSizeDots specifies the actual font size in dots (actual pixels)
// for a 10pt font in the DVI system.
func TeXMath(formula string, fontSizeDots float32) (*ppath.Path, error) {
        texMu.Lock()
        defer texMu.Unlock()

        r := strings.NewReader(fmt.Sprintf(`%s $%s$
\bye
`, preamble, formula))
        w := &bytes.Buffer{}
        stdout := &bytes.Buffer{}
        if texEngine == nil {
                texEngine = tex.New()
        }
        texEngine.Stdout = stdout
        if err := texEngine.Process(w, r); err != nil {
                fmt.Println(stdout.String())
                return nil, err
        }

        if texFonts == nil {
                texFonts = newFonts()
        }
        p, err := DVIToPath(w.Bytes(), texFonts, fontSizeDots)
        if err != nil {
                fmt.Println(stdout.String())
                return nil, err
        }
        return p, nil
}

// Code generated by "core generate"; DO NOT EDIT.

package text

import (
        "cogentcore.org/core/enums"
)

var _AlignsValues = []Aligns{0, 1, 2, 3}

// AlignsN is the highest valid value for type Aligns, plus one.
const AlignsN Aligns = 4

var _AlignsValueMap = map[string]Aligns{`start`: 0, `end`: 1, `center`: 2, `justify`: 3}

var _AlignsDescMap = map[Aligns]string{0: `Start aligns to the start (top, left) of text region.`, 1: `End aligns to the end (bottom, right) of text region.`, 2: `Center aligns to the center of text region.`, 3: `Justify spreads words to cover the entire text region.`}

var _AlignsMap = map[Aligns]string{0: `start`, 1: `end`, 2: `center`, 3: `justify`}

// String returns the string representation of this Aligns value.
func (i Aligns) String() string { return enums.String(i, _AlignsMap) }

// SetString sets the Aligns value from its string representation,
// and returns an error if the string is invalid.
func (i *Aligns) SetString(s string) error { return enums.SetString(i, s, _AlignsValueMap, "Aligns") }

// Int64 returns the Aligns value as an int64.
func (i Aligns) Int64() int64 { return int64(i) }

// SetInt64 sets the Aligns value from an int64.
func (i *Aligns) SetInt64(in int64) { *i = Aligns(in) }

// Desc returns the description of the Aligns value.
func (i Aligns) Desc() string { return enums.Desc(i, _AlignsDescMap) }

// AlignsValues returns all possible values for the type Aligns.
func AlignsValues() []Aligns { return _AlignsValues }

// Values returns all possible values for the type Aligns.
func (i Aligns) Values() []enums.Enum { return enums.Values(_AlignsValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Aligns) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Aligns) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Aligns") }

var _WhiteSpacesValues = []WhiteSpaces{0, 1, 2, 3, 4, 5}

// WhiteSpacesN is the highest valid value for type WhiteSpaces, plus one.
const WhiteSpacesN WhiteSpaces = 6

var _WhiteSpacesValueMap = map[string]WhiteSpaces{`WrapAsNeeded`: 0, `WrapAlways`: 1, `WrapSpaceOnly`: 2, `WrapNever`: 3, `Pre`: 4, `PreWrap`: 5}

var _WhiteSpacesDescMap = map[WhiteSpaces]string{0: `WrapAsNeeded means that all white space is collapsed to a single space, and text wraps at white space except if there is a long word that cannot fit on the next line, or would otherwise be truncated. To get full word wrapping to expand to all available space, you also need to set GrowWrap = true. Use the SetTextWrap convenience method to set both.`, 1: `WrapAlways is like [WrapAsNeeded] except that line wrap will always occur within words if it allows more content to fit on a line.`, 2: `WrapSpaceOnly means that line wrapping only occurs at white space, and never within words. This means that long words may then exceed the available space and will be truncated. White space is collapsed to a single space.`, 3: `WrapNever means that lines are never wrapped to fit. If there is an explicit line or paragraph break, that will still result in a new line. In general you also don't want simple non-wrapping text labels to Grow (GrowWrap = false). Use the SetTextWrap method to set both. White space is collapsed to a single space.`, 4: `WhiteSpacePre means that whitespace is preserved, including line breaks. Text will only wrap on explicit line or paragraph breaks. This acts like the <pre> tag in HTML.`, 5: `WhiteSpacePreWrap means that whitespace is preserved. Text will wrap when necessary, and on line breaks`}

var _WhiteSpacesMap = map[WhiteSpaces]string{0: `WrapAsNeeded`, 1: `WrapAlways`, 2: `WrapSpaceOnly`, 3: `WrapNever`, 4: `Pre`, 5: `PreWrap`}

// String returns the string representation of this WhiteSpaces value.
func (i WhiteSpaces) String() string { return enums.String(i, _WhiteSpacesMap) }

// SetString sets the WhiteSpaces value from its string representation,
// and returns an error if the string is invalid.
func (i *WhiteSpaces) SetString(s string) error {
        return enums.SetString(i, s, _WhiteSpacesValueMap, "WhiteSpaces")
}

// Int64 returns the WhiteSpaces value as an int64.
func (i WhiteSpaces) Int64() int64 { return int64(i) }

// SetInt64 sets the WhiteSpaces value from an int64.
func (i *WhiteSpaces) SetInt64(in int64) { *i = WhiteSpaces(in) }

// Desc returns the description of the WhiteSpaces value.
func (i WhiteSpaces) Desc() string { return enums.Desc(i, _WhiteSpacesDescMap) }

// WhiteSpacesValues returns all possible values for the type WhiteSpaces.
func WhiteSpacesValues() []WhiteSpaces { return _WhiteSpacesValues }

// Values returns all possible values for the type WhiteSpaces.
func (i WhiteSpaces) Values() []enums.Enum { return enums.Values(_WhiteSpacesValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i WhiteSpaces) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *WhiteSpaces) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "WhiteSpaces")
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package text

import (
        "cogentcore.org/core/text/rich"
)

// Font is a compact encoding of font properties, which can be used
// to reconstruct the corresponding [rich.Style] from [text.Style].
type Font struct {
        // StyleRune is the rune-compressed version of the [rich.Style] parameters.
        StyleRune rune

        // Size is the Text.Style.FontSize.Dots value of the font size,
        // multiplied by font rich.Style.Size.
        Size float32

        // Family is a nonstandard family name: if standard, then empty,
        // and value is determined by [rich.DefaultSettings] and Style.Family.
        Family string
}

func NewFont(fsty *rich.Style, tsty *Style) *Font {
        fn := &Font{StyleRune: rich.RuneFromStyle(fsty), Size: tsty.FontHeight(fsty)}
        if fsty.Family == rich.Custom {
                fn.Family = string(tsty.CustomFont)
        }
        return fn
}

// Style returns the [rich.Style] version of this Font.
func (fn *Font) Style(tsty *Style) *rich.Style {
        sty := rich.NewStyle()
        rich.RuneToStyle(sty, fn.StyleRune)
        sty.Size = fn.Size / tsty.FontSize.Dots
        return sty
}

// FontFamily returns the string value of the font Family for given [rich.Style],
// using [text.Style] CustomFont or [rich.DefaultSettings] values.
func (ts *Style) FontFamily(sty *rich.Style) string {
        if sty.Family == rich.Custom {
                return string(ts.CustomFont)
        }
        return sty.FontFamily(&rich.DefaultSettings)
}

func (fn *Font) FamilyString(tsty *Style) string {
        if fn.Family != "" {
                return fn.Family
        }
        return tsty.FontFamily(fn.Style(tsty))
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package text

import (
        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/enums"
        "cogentcore.org/core/styles/styleprops"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
)

// FromProperties sets style field values based on the given property list.
func (s *Style) FromProperties(parent *Style, properties map[string]any, ctxt colors.Context) {
        for key, val := range properties {
                if len(key) == 0 {
                        continue
                }
                if key[0] == '#' || key[0] == '.' || key[0] == ':' || key[0] == '_' {
                        continue
                }
                s.FromProperty(parent, key, val, ctxt)
        }
}

// FromProperty sets style field values based on the given property key and value.
func (s *Style) FromProperty(parent *Style, key string, val any, cc colors.Context) {
        if sfunc, ok := styleFuncs[key]; ok {
                if parent != nil {
                        sfunc(s, key, val, parent, cc)
                } else {
                        sfunc(s, key, val, nil, cc)
                }
                return
        }
}

// styleFuncs are functions for styling the text.Style object.
var styleFuncs = map[string]styleprops.Func{
        "text-align": styleprops.Enum(Start,
                func(obj *Style) enums.EnumSetter { return &obj.Align }),
        "text-vertical-align": styleprops.Enum(Start,
                func(obj *Style) enums.EnumSetter { return &obj.AlignV }),
        // note: text-style reads the font-size setting for regular units cases.
        "font-size": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.FontSize }),
        "line-height": styleprops.FloatProportion(float32(1.2),
                func(obj *Style) *float32 { return &obj.LineHeight }),
        "line-spacing": styleprops.FloatProportion(float32(1.2),
                func(obj *Style) *float32 { return &obj.LineHeight }),
        "para-spacing": styleprops.FloatProportion(float32(1.2),
                func(obj *Style) *float32 { return &obj.ParaSpacing }),
        "white-space": styleprops.Enum(WrapAsNeeded,
                func(obj *Style) enums.EnumSetter { return &obj.WhiteSpace }),
        "direction": styleprops.Enum(rich.LTR,
                func(obj *Style) enums.EnumSetter { return &obj.Direction }),
        "text-indent": styleprops.Units(units.Value{},
                func(obj *Style) *units.Value { return &obj.Indent }),
        "tab-size": styleprops.Int(int(4),
                func(obj *Style) *int { return &obj.TabSize }),
        "select-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.SelectColor = parent.(*Style).SelectColor
                        } else if init {
                                fs.SelectColor = colors.Scheme.Select.Container
                        }
                        return
                }
                fs.SelectColor = errors.Log1(gradient.FromAny(val, cc))
        },
        "highlight-color": func(obj any, key string, val any, parent any, cc colors.Context) {
                fs := obj.(*Style)
                if inh, init := styleprops.InhInit(val, parent); inh || init {
                        if inh {
                                fs.HighlightColor = parent.(*Style).HighlightColor
                        } else if init {
                                fs.HighlightColor = colors.Scheme.Warn.Container
                        }
                        return
                }
                fs.HighlightColor = errors.Log1(gradient.FromAny(val, cc))
        },
}

// ToProperties sets map[string]any properties based on non-default style values.
// properties map must be non-nil.
func (s *Style) ToProperties(sty *rich.Style, p map[string]any) {
        if s.FontSize.Unit != units.UnitDp || s.FontSize.Value != 16 || sty.Size != 1 {
                sz := s.FontSize
                sz.Value *= sty.Size
                p["font-size"] = sz.StringCSS()
        }
        if sty.Family == rich.Custom && s.CustomFont != "" {
                p["font-family"] = s.CustomFont
        }
        if sty.Slant != rich.SlantNormal {
                p["font-style"] = sty.Slant.String()
        }
        if sty.Weight != rich.Normal {
                p["font-weight"] = sty.Weight.String()
        }
        if sty.Stretch != rich.StretchNormal {
                p["font-stretch"] = sty.Stretch.String()
        }
        if sty.Decoration != 0 {
                p["text-decoration"] = sty.Decoration.String()
        }
        if s.Align != Start {
                p["text-align"] = s.Align.String()
        }
        if s.AlignV != Start {
                p["text-vertical-align"] = s.AlignV.String()
        }
        if s.LineHeight != 1.2 {
                p["line-height"] = reflectx.ToString(s.LineHeight)
        }
        if s.WhiteSpace != WrapAsNeeded {
                p["white-space"] = s.WhiteSpace.String()
        }
        if sty.Direction != rich.LTR {
                p["direction"] = s.Direction.String()
        }
        if s.TabSize != 4 {
                p["tab-size"] = reflectx.ToString(s.TabSize)
        }
        if sty.Decoration.HasFlag(rich.FillColor) {
                p["fill"] = colors.AsHex(sty.FillColor())
        } else {
                p["fill"] = colors.AsHex(s.Color)
        }
        if s.SelectColor != nil {
                p["select-color"] = colors.AsHex(colors.ToUniform(s.SelectColor))
        }
        if s.HighlightColor != nil {
                p["highlight-color"] = colors.AsHex(colors.ToUniform(s.HighlightColor))
        }
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package text

// EditorSettings contains text editor settings.
type EditorSettings struct { //types:add

        // size of a tab, in chars; also determines indent level for space indent
        TabSize int `default:"4"`

        // use spaces for indentation, otherwise tabs
        SpaceIndent bool

        // wrap lines at word boundaries; otherwise long lines scroll off the end
        WordWrap bool `default:"true"`

        // whether to show line numbers
        LineNumbers bool `default:"true"`

        // use the completion system to suggest options while typing
        Completion bool `default:"true"`

        // suggest corrections for unknown words while typing
        SpellCorrect bool `default:"true"`

        // automatically indent lines when enter, tab, }, etc pressed
        AutoIndent bool `default:"true"`

        // use emacs-style undo, where after a non-undo command, all the current undo actions are added to the undo stack, such that a subsequent undo is actually a redo
        EmacsUndo bool

        // colorize the background according to nesting depth
        DepthColor bool `default:"true"`
}

func (es *EditorSettings) Defaults() {
        es.TabSize = 4
        es.SpaceIndent = false
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package text

import (
        "image"
        "image/color"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/rich"
)

//go:generate core generate

// IMPORTANT: any changes here must be updated in props.go

// note: the go-text shaping framework does not support letter spacing
// or word spacing. These are uncommonly adjusted and not compatible with
// internationalized text in any case.

// todo: bidi override?

// Style is used for text layout styling.
// Most of these are inherited
type Style struct { //types:add

        // Align specifies how to align text along the default direction (inherited).
        // This *only* applies to the text within its containing element,
        // and is relevant only for multi-line text.
        Align Aligns

        // AlignV specifies "vertical" (orthogonal to default direction)
        // alignment of text (inherited).
        // This *only* applies to the text within its containing element:
        // if that element does not have a specified size
        // that is different from the text size, then this has *no effect*.
        AlignV Aligns

        // FontSize is the default font size. The rich text styling specifies
        // sizes relative to this value, with the normal text size factor = 1.
        // In the [styles.Style.Text] context, this is copied from [styles.Font.Size].
        FontSize units.Value

        // LineHeight is a multiplier on the default font size for spacing between lines.
        // If there are larger font elements within a line, they will be accommodated, with
        // the same amount of total spacing added above that maximum size as if it was all
        // the same height. The default of 1.3 represents standard "single spaced" text.
        LineHeight float32 `default:"1.3"`

        // ParaSpacing is the line spacing between paragraphs (inherited).
        // This will be copied from [Style.Margin] if that is non-zero,
        // or can be set directly. Like [LineHeight], this is a multiplier on
        // the default font size.
        ParaSpacing float32 `default:"1.5"`

        // WhiteSpace (not inherited) specifies how white space is processed,
        // and how lines are wrapped.  If set to WhiteSpaceNormal (default) lines are wrapped.
        // See info about interactions with Grow.X setting for this and the NoWrap case.
        WhiteSpace WhiteSpaces

        // Direction specifies the default text direction, which can be overridden if the
        // unicode text is typically written in a different direction.
        Direction rich.Directions

        // Indent specifies how much to indent the first line in a paragraph (inherited).
        Indent units.Value

        // TabSize specifies the tab size, in number of characters (inherited).
        TabSize int

        // Color is the default font fill color, used for inking fonts unless otherwise
        // specified in the [rich.Style].
        Color color.Color

        // SelectColor is the color to use for the background region of selected text (inherited).
        SelectColor image.Image

        // HighlightColor is the color to use for the background region of highlighted text (inherited).
        HighlightColor image.Image

        // CustomFont specifies the Custom font name for rich.Style.Family = Custom.
        CustomFont rich.FontName
}

func NewStyle() *Style {
        s := &Style{}
        s.Defaults()
        return s
}

func (ts *Style) Defaults() {
        ts.Align = Start
        ts.AlignV = Start
        ts.FontSize.Dp(16)
        ts.LineHeight = 1.3
        ts.ParaSpacing = 1.5
        ts.Direction = rich.LTR
        ts.TabSize = 4
        ts.Color = colors.ToUniform(colors.Scheme.OnSurface)
        ts.SelectColor = colors.Scheme.Select.Container
        ts.HighlightColor = colors.Scheme.Warn.Container
}

// ToDots runs ToDots on unit values, to compile down to raw pixels
func (ts *Style) ToDots(uc *units.Context) {
        ts.FontSize.ToDots(uc)
        ts.FontSize.Dots = math32.Round(ts.FontSize.Dots)
        ts.Indent.ToDots(uc)
}

// InheritFields from parent
func (ts *Style) InheritFields(parent *Style) {
        ts.Align = parent.Align
        ts.AlignV = parent.AlignV
        ts.LineHeight = parent.LineHeight
        ts.ParaSpacing = parent.ParaSpacing
        // ts.WhiteSpace = par.WhiteSpace // todo: we can't inherit this b/c label base default then gets overwritten
        ts.Direction = parent.Direction
        ts.Indent = parent.Indent
        ts.TabSize = parent.TabSize
        ts.SelectColor = parent.SelectColor
        ts.HighlightColor = parent.HighlightColor
}

// FontHeight returns the effective font height based on
// FontSize * [rich.Style] Size multiplier.
func (ts *Style) FontHeight(sty *rich.Style) float32 {
        return math32.Round(ts.FontSize.Dots * sty.Size)
}

// LineHeightDots returns the effective line height in dots (actual pixels)
// as FontHeight * LineHeight
func (ts *Style) LineHeightDots(sty *rich.Style) float32 {
        return math32.Ceil(ts.FontHeight(sty) * ts.LineHeight)
}

// AlignFactors gets basic text alignment factors
func (ts *Style) AlignFactors() (ax, ay float32) {
        ax = ts.Align.Factor()
        val := ts.AlignV
        switch val {
        case Start:
                ay = 0.9 // todo: need to find out actual baseline
        case Center:
                ay = 0.45 // todo: determine if font is horiz or vert..
        case End:
                ay = -0.1 // todo: need actual baseline
        }
        return
}

// Aligns has the different types of alignment and justification for
// the text.
type Aligns int32 //enums:enum -transform kebab

const (
        // Start aligns to the start (top, left) of text region.
        Start Aligns = iota

        // End aligns to the end (bottom, right) of text region.
        End

        // Center aligns to the center of text region.
        Center

        // Justify spreads words to cover the entire text region.
        Justify
)

// Factor returns the alignment factor (0, .5, 1).
func (al Aligns) Factor() float32 {
        switch al {
        case Start:
                return 0
        case Center:
                return 0.5
        case End:
                return 1
        }
        return 0
}

// WhiteSpaces determine how white space is processed and line wrapping
// occurs, either only at whitespace or within words.
type WhiteSpaces int32 //enums:enum -trim-prefix WhiteSpace

const (
        // WrapAsNeeded means that all white space is collapsed to a single
        // space, and text wraps at white space except if there is a long word
        // that cannot fit on the next line, or would otherwise be truncated.
        // To get full word wrapping to expand to all available space, you also
        // need to set GrowWrap = true. Use the SetTextWrap convenience method
        // to set both.
        WrapAsNeeded WhiteSpaces = iota

        // WrapAlways is like [WrapAsNeeded] except that line wrap will always
        // occur within words if it allows more content to fit on a line.
        WrapAlways

        // WrapSpaceOnly means that line wrapping only occurs at white space,
        // and never within words. This means that long words may then exceed
        // the available space and will be truncated. White space is collapsed
        // to a single space.
        WrapSpaceOnly

        // WrapNever means that lines are never wrapped to fit. If there is an
        // explicit line or paragraph break, that will still result in
        // a new line. In general you also don't want simple non-wrapping
        // text labels to Grow (GrowWrap = false). Use the SetTextWrap method
        // to set both. White space is collapsed to a single space.
        WrapNever

        // WhiteSpacePre means that whitespace is preserved, including line
        // breaks. Text will only wrap on explicit line or paragraph breaks.
        // This acts like the <pre> tag in HTML.
        WhiteSpacePre

        // WhiteSpacePreWrap means that whitespace is preserved.
        // Text will wrap when necessary, and on line breaks
        WhiteSpacePreWrap
)

// HasWordWrap returns true if value supports word wrap.
func (ws WhiteSpaces) HasWordWrap() bool {
        switch ws {
        case WrapNever, WhiteSpacePre:
                return false
        default:
                return true
        }
}

// KeepWhiteSpace returns true if value preserves existing whitespace.
func (ws WhiteSpaces) KeepWhiteSpace() bool {
        switch ws {
        case WhiteSpacePre, WhiteSpacePreWrap:
                return true
        default:
                return false
        }
}

// SetUnitContext sets the font-specific information in the given
// units.Context, based on the given styles. Just uses standardized
// fractions of the font size for the other less common units such as ex, ch.
func (ts *Style) SetUnitContext(uc *units.Context) {
        fsz := math32.Round(ts.FontSize.Dots)
        if fsz == 0 {
                fsz = 16
        }
        uc.SetFont(fsz)
}

// TODO(text): ?
// UnicodeBidi determines the type of bidirectional text support.
// See https://pkg.go.dev/golang.org/x/text/unicode/bidi.
// type UnicodeBidi int32 //enums:enum -trim-prefix Bidi -transform kebab
//
// const (
//         BidiNormal UnicodeBidi = iota
//         BidiEmbed
//         BidiBidiOverride
// )

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

//go:generate core generate

import (
        "image"
        "sync"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/highlighting"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/text"
        "cogentcore.org/core/text/textpos"
)

// TODO: move these into an editor settings object
var (
        // Maximum amount of clipboard history to retain
        clipboardHistoryMax = 100 // `default:"100" min:"0" max:"1000" step:"5"`
)

// Base is a widget with basic infrastructure for viewing and editing
// [lines.Lines] of monospaced text, used in [textcore.Editor] and
// terminal. There can be multiple Base widgets for each lines buffer.
//
// Use NeedsRender to drive an render update for any change that does
// not change the line-level layout of the text.
//
// All updating in the Base should be within a single goroutine,
// as it would require extensive protections throughout code otherwise.
type Base struct { //core:embedder
        core.Frame

        // Lines is the text lines content for this editor.
        Lines *lines.Lines `set:"-" json:"-" xml:"-"`

        // CursorWidth is the width of the cursor.
        // This should be set in Stylers like all other style properties.
        CursorWidth units.Value

        // LineNumberColor is the color used for the side bar containing the line numbers.
        // This should be set in Stylers like all other style properties.
        LineNumberColor image.Image

        // SelectColor is the color used for the user text selection background color.
        // This should be set in Stylers like all other style properties.
        SelectColor image.Image

        // HighlightColor is the color used for the text highlight background color (like in find).
        // This should be set in Stylers like all other style properties.
        HighlightColor image.Image

        // CursorColor is the color used for the text editor cursor bar.
        // This should be set in Stylers like all other style properties.
        CursorColor image.Image

        // AutoscrollOnInput scrolls the display to the end when Input events are received.
        AutoscrollOnInput bool

        // viewId is the unique id of the Lines view.
        viewId int

        // charSize is the render size of one character (rune).
        // Y = line height, X = total glyph advance.
        charSize math32.Vector2

        // visSizeAlloc is the Geom.Size.Alloc.Total subtracting extra space,
        // available for rendering text lines and line numbers.
        visSizeAlloc math32.Vector2

        // lastVisSizeAlloc is the last visSizeAlloc used in laying out lines.
        // It is used to trigger a new layout only when needed.
        lastVisSizeAlloc math32.Vector2

        // visSize is the height in lines and width in chars of the visible area.
        visSize image.Point

        // linesSize is the height in lines and width in chars of the Lines text area,
        // (excluding line numbers), which can be larger than the visSize.
        linesSize image.Point

        // scrollPos is the position of the scrollbar, in units of lines of text.
        // fractional scrolling is supported.
        scrollPos float32

        // hasLineNumbers indicates that this editor has line numbers
        // (per [Editor] option)
        hasLineNumbers bool

        // lineNumberOffset is the horizontal offset in chars for the start of text
        // after line numbers. This is 0 if no line numbers.
        lineNumberOffset int

        // totalSize is total size of all text, including line numbers,
        // multiplied by charSize.
        totalSize math32.Vector2

        // lineNumberDigits is the number of line number digits needed.
        lineNumberDigits int

        // CursorPos is the current cursor position.
        CursorPos textpos.Pos `set:"-" edit:"-" json:"-" xml:"-"`

        // blinkOn oscillates between on and off for blinking.
        blinkOn bool

        // cursorMu is a mutex protecting cursor rendering, shared between blink and main code.
        cursorMu sync.Mutex

        // isScrolling is true when scrolling: prevents keeping current cursor position
        // in view.
        isScrolling bool

        // cursorTarget is the target cursor position for externally set targets.
        // It ensures that the target position is visible.
        cursorTarget textpos.Pos

        // cursorColumn is the desired cursor column, where the cursor was
        // last when moved using left / right arrows.
        // It is used when doing up / down to not always go to short line columns.
        cursorColumn int

        // posHistoryIndex is the current index within PosHistory.
        posHistoryIndex int

        // selectStart is the starting point for selection, which will either
        // be the start or end of selected region depending on subsequent selection.
        selectStart textpos.Pos

        // SelectRegion is the current selection region.
        SelectRegion textpos.Region `set:"-" edit:"-" json:"-" xml:"-"`

        // previousSelectRegion is the previous selection region that was actually rendered.
        // It is needed to update the render.
        previousSelectRegion textpos.Region

        // Highlights is a slice of regions representing the highlighted
        // regions, e.g., for search results.
        Highlights []textpos.Region `set:"-" edit:"-" json:"-" xml:"-"`

        // scopelights is a slice of regions representing the highlighted
        // regions specific to scope markers.
        scopelights []textpos.Region

        // LinkHandler handles link clicks.
        // If it is nil, they are sent to the standard web URL handler.
        LinkHandler func(tl *rich.Hyperlink)

        // lineRenders are the cached rendered lines of text.
        lineRenders []renderCache

        // lineNoRenders are the cached rendered line numbers
        lineNoRenders []renderCache

        // tabRender is a shaped tab
        tabRender *shaped.Lines

        // selectMode is a boolean indicating whether to select text as the cursor moves.
        selectMode bool

        // lastWasTabAI indicates that last key was a Tab auto-indent
        lastWasTabAI bool

        // lastWasUndo indicates that last key was an undo
        lastWasUndo bool

        // targetSet indicates that the CursorTarget is set
        targetSet bool

        lastRecenter   int
        lastAutoInsert rune
        lastFilename   string
}

func (ed *Base) WidgetValue() any { return ed.Lines.Text() }

func (ed *Base) SetWidgetValue(value any) error {
        ed.Lines.SetString(reflectx.ToString(value))
        return nil
}

func (ed *Base) Init() {
        ed.Frame.Init()
        ed.Styles.Font.Family = rich.Monospace // critical
        ed.SetLines(lines.NewLines())
        ed.Styler(func(s *styles.Style) {
                s.SetAbilities(true, abilities.Activatable, abilities.Focusable, abilities.Hoverable, abilities.Slideable, abilities.DoubleClickable, abilities.TripleClickable)
                s.SetAbilities(false, abilities.ScrollableUnattended)
                ed.CursorWidth.Dp(1)
                ed.LineNumberColor = nil
                ed.SelectColor = colors.Scheme.Select.Container
                ed.HighlightColor = colors.Scheme.Warn.Container
                ed.CursorColor = colors.Scheme.Primary.Base

                s.Cursor = cursors.Text
                s.VirtualKeyboard = styles.KeyboardMultiLine
                // if core.SystemSettings.Base.WordWrap {
                //         s.Text.WhiteSpace = styles.WhiteSpacePreWrap
                // } else {
                //         s.Text.WhiteSpace = styles.WhiteSpacePre
                // }
                s.Text.LineHeight = 1.3
                s.Text.WhiteSpace = text.WrapNever
                s.Font.Family = rich.Monospace
                s.Grow.Set(1, 0)
                s.Overflow.Set(styles.OverflowAuto) // absorbs all
                s.Border.Radius = styles.BorderRadiusLarge
                s.Margin.Zero()
                s.Padding.Set(units.Em(0.5))
                s.Align.Content = styles.Start
                s.Align.Items = styles.Start
                s.Text.Align = text.Start
                s.Text.AlignV = text.Start
                s.Text.TabSize = core.SystemSettings.Editor.TabSize
                s.Color = colors.Scheme.OnSurface
                s.Min.X.Em(10)

                s.MaxBorder.Width.Set(units.Dp(2))
                s.Background = colors.Scheme.SurfaceContainerLow
                if s.IsReadOnly() {
                        s.Background = colors.Scheme.SurfaceContainer
                }
                // note: a blank background does NOT work for depth color rendering
                if s.Is(states.Focused) {
                        s.StateLayer = 0
                        s.Border.Width.Set(units.Dp(2))
                }
        })

        ed.OnClose(func(e events.Event) {
                ed.editDone()
        })
}

func (ed *Base) Destroy() {
        ed.stopCursor()
        ed.Frame.Destroy()
}

func (ed *Base) NumLines() int {
        if ed.Lines != nil {
                return ed.Lines.NumLines()
        }
        return 0
}

// editDone completes editing and copies the active edited text to the text;
// called when the return key is pressed or goes out of focus
func (ed *Base) editDone() {
        if ed.Lines != nil {
                ed.Lines.EditDone() // sends the change event
        }
        ed.clearSelected()
        ed.clearCursor()
}

// reMarkup triggers a complete re-markup of the entire text --
// can do this when needed if the markup gets off due to multi-line
// formatting issues -- via Recenter key
func (ed *Base) reMarkup() {
        if ed.Lines == nil {
                return
        }
        ed.Lines.ReMarkup()
}

// IsNotSaved returns true if buffer was changed (edited) since last Save.
func (ed *Base) IsNotSaved() bool {
        return ed.Lines != nil && ed.Lines.IsNotSaved()
}

// Clear resets all the text in the buffer for this editor.
func (ed *Base) Clear() {
        if ed.Lines == nil {
                return
        }
        ed.Lines.SetText([]byte{})
}

// resetState resets all the random state variables, when opening a new buffer etc
func (ed *Base) resetState() {
        ed.SelectReset()
        ed.Highlights = nil
        ed.scopelights = nil
        if ed.Lines == nil || ed.lastFilename != ed.Lines.Filename() { // don't reset if reopening..
                ed.CursorPos = textpos.Pos{}
        }
}

// SendInput sends the [events.Input] event, for fine-grained updates.
func (ed *Base) SendInput() {
        ed.Send(events.Input)
}

// SendClose sends the [events.Close] event, when lines buffer is closed.
func (ed *Base) SendClose() {
        ed.Send(events.Close)
}

// SetLines sets the [lines.Lines] that this is an editor of,
// creating a new view for this editor and connecting to events.
func (ed *Base) SetLines(ln *lines.Lines) *Base {
        oldln := ed.Lines
        if ed == nil || (ln != nil && oldln == ln) {
                return ed
        }
        if oldln != nil {
                oldln.DeleteView(ed.viewId)
                ed.viewId = -1
        }
        ed.Lines = ln
        ed.resetState()
        if ln != nil {
                ln.Settings.EditorSettings = core.SystemSettings.Editor
                wd := ed.linesSize.X
                if wd == 0 {
                        wd = 80
                }
                ed.viewId = ln.NewView(wd)
                ln.OnChange(ed.viewId, func(e events.Event) {
                        ed.validateCursor() // could have changed with remarkup
                        ed.NeedsRender()
                        ed.SendChange()
                })
                ln.OnInput(ed.viewId, func(e events.Event) {
                        if ed.AutoscrollOnInput {
                                ed.SetCursorTarget(textpos.PosErr) // special code to go to end
                        }
                        ed.NeedsRender()
                        ed.SendInput()
                })
                ln.OnClose(ed.viewId, func(e events.Event) {
                        ed.SetLines(nil)
                        ed.SendClose()
                })
                phl := ln.PosHistoryLen()
                if phl > 0 {
                        cp, _ := ln.PosHistoryAt(phl - 1)
                        ed.posHistoryIndex = phl - 1
                        ed.SetCursorShow(cp)
                } else {
                        ed.SetCursorShow(textpos.Pos{})
                }
        }
        ed.NeedsRender()
        return ed
}

// styleBase applies the editor styles.
func (ed *Base) styleBase() {
        if ed.NeedsRebuild() {
                highlighting.UpdateFromTheme()
                if ed.Lines != nil {
                        ed.Lines.SetHighlighting(core.AppearanceSettings.Highlighting)
                }
        }
        ed.Frame.Style()
        ed.CursorWidth.ToDots(&ed.Styles.UnitContext)
}

func (ed *Base) Style() {
        ed.styleBase()
        ed.styleSizes()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "fmt"
        "strings"

        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/complete"
        "cogentcore.org/core/text/parse/parser"
        "cogentcore.org/core/text/textpos"
)

// setCompleter sets completion functions so that completions will
// automatically be offered as the user types
func (ed *Editor) setCompleter(data any, matchFun complete.MatchFunc, editFun complete.EditFunc,
        lookupFun complete.LookupFunc) {
        if ed.Complete != nil {
                if ed.Complete.Context == data {
                        ed.Complete.MatchFunc = matchFun
                        ed.Complete.EditFunc = editFun
                        ed.Complete.LookupFunc = lookupFun
                        return
                }
                ed.deleteCompleter()
        }
        ed.Complete = core.NewComplete().SetContext(data).SetMatchFunc(matchFun).
                SetEditFunc(editFun).SetLookupFunc(lookupFun)
        ed.Complete.OnSelect(func(e events.Event) {
                ed.completeText(ed.Complete.Completion)
        })
        // todo: what about CompleteExtend event type?
        // TODO(kai/complete): clean this up and figure out what to do about Extend and only connecting once
        // note: only need to connect once..
        // tb.Complete.CompleteSig.ConnectOnly(func(dlg *core.Dialog) {
        //         tbf, _ := recv.Embed(TypeBuf).(*Buf)
        //         if sig == int64(core.CompleteSelect) {
        //                 tbf.CompleteText(data.(string)) // always use data
        //         } else if sig == int64(core.CompleteExtend) {
        //                 tbf.CompleteExtend(data.(string)) // always use data
        //         }
        // })
}

func (ed *Editor) deleteCompleter() {
        if ed.Complete == nil {
                return
        }
        ed.Complete.Cancel()
        ed.Complete = nil
}

// completeText edits the text using the string chosen from the completion menu
func (ed *Editor) completeText(s string) {
        if s == "" {
                return
        }
        // give the completer a chance to edit the completion before insert,
        // also it return a number of runes past the cursor to delete
        st := textpos.Pos{ed.Complete.SrcLn, 0}
        en := textpos.Pos{ed.Complete.SrcLn, ed.Lines.LineLen(ed.Complete.SrcLn)}
        var tbes string
        tbe := ed.Lines.Region(st, en)
        if tbe != nil {
                tbes = string(tbe.ToBytes())
        }
        c := ed.Complete.GetCompletion(s)
        pos := textpos.Pos{ed.Complete.SrcLn, ed.Complete.SrcCh}
        ced := ed.Complete.EditFunc(ed.Complete.Context, tbes, ed.Complete.SrcCh, c, ed.Complete.Seed)
        if ced.ForwardDelete > 0 {
                delEn := textpos.Pos{ed.Complete.SrcLn, ed.Complete.SrcCh + ced.ForwardDelete}
                ed.Lines.DeleteText(pos, delEn)
        }
        // now the normal completion insertion
        st = pos
        st.Char -= len(ed.Complete.Seed)
        ed.Lines.ReplaceText(st, pos, st, ced.NewText, lines.ReplaceNoMatchCase)
        ep := st
        ep.Char += len(ced.NewText) + ced.CursorAdjust
        ed.SetCursorShow(ep)
}

// offerComplete pops up a menu of possible completions
func (ed *Editor) offerComplete() {
        if ed.Complete == nil || ed.ISearch.On || ed.QReplace.On || ed.IsDisabled() {
                return
        }
        ed.Complete.Cancel()
        if !ed.Lines.Settings.Completion {
                return
        }
        if ed.Lines.InComment(ed.CursorPos) || ed.Lines.InLitString(ed.CursorPos) {
                return
        }

        ed.Complete.SrcLn = ed.CursorPos.Line
        ed.Complete.SrcCh = ed.CursorPos.Char
        st := textpos.Pos{ed.CursorPos.Line, 0}
        en := textpos.Pos{ed.CursorPos.Line, ed.CursorPos.Char}
        tbe := ed.Lines.Region(st, en)
        var s string
        if tbe != nil {
                s = string(tbe.ToBytes())
                s = strings.TrimLeft(s, " \t") // trim ' ' and '\t'
        }

        //        count := ed.Buf.ByteOffs[ed.CursorPos.Line] + ed.CursorPos.Char
        cpos := ed.charStartPos(ed.CursorPos).ToPoint() // physical location
        cpos.X += 5
        cpos.Y += 10
        ed.Complete.SrcLn = ed.CursorPos.Line
        ed.Complete.SrcCh = ed.CursorPos.Char
        ed.Complete.Show(ed, cpos, s)
}

// CancelComplete cancels any pending completion.
// Call this when new events have moved beyond any prior completion scenario.
func (ed *Editor) CancelComplete() {
        if ed.Lines == nil {
                return
        }
        if ed.Complete == nil {
                return
        }
        ed.Complete.Cancel()
}

// Lookup attempts to lookup symbol at current location, popping up a window
// if something is found.
func (ed *Editor) Lookup() { //types:add
        if ed.ISearch.On || ed.QReplace.On || ed.IsDisabled() {
                return
        }
        if ed.Complete == nil {
                return
        }
        var ln int
        var ch int
        if ed.HasSelection() {
                ln = ed.SelectRegion.Start.Line
                if ed.SelectRegion.End.Line != ln {
                        return // no multiline selections for lookup
                }
                ch = ed.SelectRegion.End.Char
        } else {
                ln = ed.CursorPos.Line
                if ed.Lines.IsWordEnd(ed.CursorPos) {
                        ch = ed.CursorPos.Char
                } else {
                        ch = ed.Lines.WordAt(ed.CursorPos).End.Char
                }
        }
        ed.Complete.SrcLn = ln
        ed.Complete.SrcCh = ch
        st := textpos.Pos{ed.CursorPos.Line, 0}
        en := textpos.Pos{ed.CursorPos.Line, ch}

        tbe := ed.Lines.Region(st, en)
        var s string
        if tbe != nil {
                s = string(tbe.ToBytes())
                s = strings.TrimLeft(s, " \t") // trim ' ' and '\t'
        }

        //        count := ed.Buf.ByteOffs[ed.CursorPos.Line] + ed.CursorPos.Char
        cpos := ed.charStartPos(ed.CursorPos).ToPoint() // physical location
        cpos.X += 5
        cpos.Y += 10
        ed.Complete.Lookup(s, ed.CursorPos.Line, ed.CursorPos.Char, ed.Scene, cpos)
}

// completeParse uses [parse] symbols and language; the string is a line of text
// up to point where user has typed.
// The data must be the *FileState from which the language type is obtained.
func completeParse(data any, text string, posLine, posChar int) (md complete.Matches) {
        sfs := data.(*parse.FileStates)
        if sfs == nil {
                // log.Printf("CompletePi: data is nil not FileStates or is nil - can't complete\n")
                return md
        }
        lp, err := parse.LanguageSupport.Properties(sfs.Known)
        if err != nil {
                // log.Printf("CompletePi: %v\n", err)
                return md
        }
        if lp.Lang == nil {
                return md
        }

        // note: must have this set to ture to allow viewing of AST
        // must set it in pi/parse directly -- so it is changed in the fileparse too
        parser.GUIActive = true // note: this is key for debugging -- runs slower but makes the tree unique

        md = lp.Lang.CompleteLine(sfs, text, textpos.Pos{posLine, posChar})
        return md
}

// completeEditParse uses the selected completion to edit the text.
func completeEditParse(data any, text string, cursorPos int, comp complete.Completion, seed string) (ed complete.Edit) {
        sfs := data.(*parse.FileStates)
        if sfs == nil {
                // log.Printf("CompleteEditPi: data is nil not FileStates or is nil - can't complete\n")
                return ed
        }
        lp, err := parse.LanguageSupport.Properties(sfs.Known)
        if err != nil {
                // log.Printf("CompleteEditPi: %v\n", err)
                return ed
        }
        if lp.Lang == nil {
                return ed
        }
        return lp.Lang.CompleteEdit(sfs, text, cursorPos, comp, seed)
}

// lookupParse uses [parse] symbols and language; the string is a line of text
// up to point where user has typed.
// The data must be the *FileState from which the language type is obtained.
func lookupParse(data any, txt string, posLine, posChar int) (ld complete.Lookup) {
        sfs := data.(*parse.FileStates)
        if sfs == nil {
                // log.Printf("LookupPi: data is nil not FileStates or is nil - can't lookup\n")
                return ld
        }
        lp, err := parse.LanguageSupport.Properties(sfs.Known)
        if err != nil {
                // log.Printf("LookupPi: %v\n", err)
                return ld
        }
        if lp.Lang == nil {
                return ld
        }

        // note: must have this set to ture to allow viewing of AST
        // must set it in pi/parse directly -- so it is changed in the fileparse too
        parser.GUIActive = true // note: this is key for debugging -- runs slower but makes the tree unique

        ld = lp.Lang.Lookup(sfs, txt, textpos.Pos{posLine, posChar})
        if len(ld.Text) > 0 {
                // todo:
                // TextDialog(nil, "Lookup: "+txt, string(ld.Text))
                return ld
        }
        if ld.Filename != "" {
                tx := lines.FileRegionBytes(ld.Filename, ld.StLine, ld.EdLine, true, 10) // comments, 10 lines back max
                prmpt := fmt.Sprintf("%v [%d:%d]", ld.Filename, ld.StLine, ld.EdLine)
                _ = tx
                _ = prmpt
                // todo:
                // TextDialog(nil, "Lookup: "+txt+": "+prmpt, string(tx))
                return ld
        }

        return ld
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "fmt"
        "image"
        "image/draw"

        "cogentcore.org/core/core"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/textpos"
)

var (
        // blinker manages cursor blinking
        blinker = core.Blinker{}

        // blinkerSpriteName is the name of the window sprite used for the cursor
        blinkerSpriteName = "textcore.Base.Cursor"
)

func init() {
        core.TheApp.AddQuitCleanFunc(blinker.QuitClean)
        blinker.Func = func() {
                w := blinker.Widget
                blinker.Unlock() // comes in locked
                if w == nil {
                        return
                }
                ed := AsBase(w)
                if !ed.StateIs(states.Focused) || !ed.IsVisible() {
                        ed.blinkOn = false
                        ed.renderCursor(false)
                } else {
                        // Need consistent test results on offscreen.
                        if core.TheApp.Platform() != system.Offscreen {
                                ed.blinkOn = !ed.blinkOn
                        }
                        ed.renderCursor(ed.blinkOn)
                }
        }
}

// startCursor starts the cursor blinking and renders it
func (ed *Base) startCursor() {
        if ed == nil || ed.This == nil {
                return
        }
        if !ed.IsVisible() {
                return
        }
        ed.blinkOn = true
        ed.renderCursor(true)
        if core.SystemSettings.CursorBlinkTime == 0 {
                return
        }
        blinker.SetWidget(ed.This.(core.Widget))
        blinker.Blink(core.SystemSettings.CursorBlinkTime)
}

// clearCursor turns off cursor and stops it from blinking
func (ed *Base) clearCursor() {
        ed.stopCursor()
        ed.renderCursor(false)
}

// stopCursor stops the cursor from blinking
func (ed *Base) stopCursor() {
        if ed == nil || ed.This == nil {
                return
        }
        blinker.ResetWidget(ed.This.(core.Widget))
}

// cursorBBox returns a bounding-box for a cursor at given position
func (ed *Base) cursorBBox(pos textpos.Pos) image.Rectangle {
        cpos := ed.charStartPos(pos)
        cbmin := cpos.SubScalar(ed.CursorWidth.Dots)
        cbmax := cpos.AddScalar(ed.CursorWidth.Dots)
        cbmax.Y += ed.charSize.Y
        curBBox := image.Rectangle{cbmin.ToPointFloor(), cbmax.ToPointCeil()}
        return curBBox
}

// renderCursor renders the cursor on or off, as a sprite that is either on or off
func (ed *Base) renderCursor(on bool) {
        if ed == nil || ed.This == nil {
                return
        }
        if ed.Scene == nil || ed.Scene.Stage == nil || ed.Scene.Stage.Main == nil {
                return
        }
        ms := ed.Scene.Stage.Main
        if !on {
                spnm := ed.cursorSpriteName()
                ms.Sprites.InactivateSprite(spnm)
                return
        }
        if !ed.IsVisible() {
                return
        }
        if !ed.posIsVisible(ed.CursorPos) {
                return
        }
        ed.cursorMu.Lock()
        defer ed.cursorMu.Unlock()

        sp := ed.cursorSprite(on)
        if sp == nil {
                return
        }
        sp.Geom.Pos = ed.charStartPos(ed.CursorPos).ToPointFloor()
}

// cursorSpriteName returns the name of the cursor sprite
func (ed *Base) cursorSpriteName() string {
        spnm := fmt.Sprintf("%v-%v", blinkerSpriteName, ed.charSize.Y)
        return spnm
}

// cursorSprite returns the sprite for the cursor, which is
// only rendered once with a vertical bar, and just activated and inactivated
// depending on render status.
func (ed *Base) cursorSprite(on bool) *core.Sprite {
        sc := ed.Scene
        if sc == nil || sc.Stage == nil || sc.Stage.Main == nil {
                return nil
        }
        ms := sc.Stage.Main
        if ms == nil {
                return nil // only MainStage has sprites
        }
        spnm := ed.cursorSpriteName()
        sp, ok := ms.Sprites.SpriteByName(spnm)
        if !ok {
                bbsz := image.Point{int(math32.Ceil(ed.CursorWidth.Dots)), int(math32.Ceil(ed.charSize.Y))}
                if bbsz.X < 2 { // at least 2
                        bbsz.X = 2
                }
                sp = core.NewSprite(spnm, bbsz, image.Point{})
                if ed.CursorColor != nil {
                        ibox := sp.Pixels.Bounds()
                        draw.Draw(sp.Pixels, ibox, ed.CursorColor, image.Point{}, draw.Src)
                        ms.Sprites.Add(sp)
                }
        }
        if on {
                ms.Sprites.ActivateSprite(sp.Name)
        } else {
                ms.Sprites.InactivateSprite(sp.Name)
        }
        return sp
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "bytes"
        "fmt"
        "log/slog"
        "os"
        "strings"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/base/stringsx"
        "cogentcore.org/core/base/vcs"
        "cogentcore.org/core/colors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
        "cogentcore.org/core/tree"
)

// DiffFiles shows the diffs between this file as the A file, and other file as B file,
// in a DiffEditorDialog
func DiffFiles(ctx core.Widget, afile, bfile string) (*DiffEditor, error) {
        ab, err := os.ReadFile(afile)
        if err != nil {
                slog.Error(err.Error())
                return nil, err
        }
        bb, err := os.ReadFile(bfile)
        if err != nil {
                slog.Error(err.Error())
                return nil, err
        }
        astr := stringsx.SplitLines(string(ab))
        bstr := stringsx.SplitLines(string(bb))
        dlg := DiffEditorDialog(ctx, "Diff File View", astr, bstr, afile, bfile, "", "")
        return dlg, nil
}

// DiffEditorDialogFromRevs opens a dialog for displaying diff between file
// at two different revisions from given repository
// if empty, defaults to: A = current HEAD, B = current WC file.
// -1, -2 etc also work as universal ways of specifying prior revisions.
func DiffEditorDialogFromRevs(ctx core.Widget, repo vcs.Repo, file string, fbuf *lines.Lines, rev_a, rev_b string) (*DiffEditor, error) {
        var astr, bstr []string
        if rev_b == "" { // default to current file
                if fbuf != nil {
                        bstr = fbuf.Strings(false)
                } else {
                        fb, err := lines.FileBytes(file)
                        if err != nil {
                                core.ErrorDialog(ctx, err)
                                return nil, err
                        }
                        bstr = lines.BytesToLineStrings(fb, false) // don't add new lines
                }
        } else {
                fb, err := repo.FileContents(file, rev_b)
                if err != nil {
                        core.ErrorDialog(ctx, err)
                        return nil, err
                }
                bstr = lines.BytesToLineStrings(fb, false) // don't add new lines
        }
        fb, err := repo.FileContents(file, rev_a)
        if err != nil {
                core.ErrorDialog(ctx, err)
                return nil, err
        }
        astr = lines.BytesToLineStrings(fb, false) // don't add new lines
        if rev_a == "" {
                rev_a = "HEAD"
        }
        return DiffEditorDialog(ctx, "DiffVcs: "+fsx.DirAndFile(file), astr, bstr, file, file, rev_a, rev_b), nil
}

// DiffEditorDialog opens a dialog for displaying diff between two files as line-strings
func DiffEditorDialog(ctx core.Widget, title string, astr, bstr []string, afile, bfile, arev, brev string) *DiffEditor {
        d := core.NewBody("Diff editor")
        d.SetTitle(title)

        de := NewDiffEditor(d)
        de.SetFileA(afile).SetFileB(bfile).SetRevisionA(arev).SetRevisionB(brev)
        de.DiffStrings(astr, bstr)
        d.AddTopBar(func(bar *core.Frame) {
                tb := core.NewToolbar(bar)
                de.toolbar = tb
                tb.Maker(de.MakeToolbar)
        })
        d.NewWindow().SetContext(ctx).SetNewWindow(true).Run()
        return de
}

// TextDialog opens a dialog for displaying text string
func TextDialog(ctx core.Widget, title, text string) *Editor {
        d := core.NewBody(title)
        ed := NewEditor(d)
        ed.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 1)
        })
        ed.Lines.SetText([]byte(text))
        d.AddBottomBar(func(bar *core.Frame) {
                core.NewButton(bar).SetText("Copy to clipboard").SetIcon(icons.ContentCopy).
                        OnClick(func(e events.Event) {
                                d.Clipboard().Write(mimedata.NewText(text))
                        })
                d.AddOK(bar)
        })
        d.RunWindowDialog(ctx)
        return ed
}

// DiffEditor presents two side-by-side [Editor]s showing the differences
// between two files (represented as lines of strings).
type DiffEditor struct {
        core.Frame

        // first file name being compared
        FileA string

        // second file name being compared
        FileB string

        // revision for first file, if relevant
        RevisionA string

        // revision for second file, if relevant
        RevisionB string

        // [lines.Lines] for A showing the aligned edit view
        linesA *lines.Lines

        // [lines.Lines] for B showing the aligned edit view
        linesB *lines.Lines

        // aligned diffs records diff for aligned lines
        alignD lines.Diffs

        // diffs applied
        diffs lines.DiffSelected

        inInputEvent bool
        toolbar      *core.Toolbar
}

func (dv *DiffEditor) Init() {
        dv.Frame.Init()
        dv.linesA = lines.NewLines()
        dv.linesB = lines.NewLines()
        dv.linesA.Settings.LineNumbers = true
        dv.linesB.Settings.LineNumbers = true

        dv.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 1)
        })

        f := func(name string, buf *lines.Lines) {
                tree.AddChildAt(dv, name, func(w *DiffTextEditor) {
                        w.SetLines(buf)
                        w.SetReadOnly(true)
                        w.Styler(func(s *styles.Style) {
                                s.Min.X.Ch(80)
                                s.Min.Y.Em(40)
                        })
                        w.On(events.Scroll, func(e events.Event) {
                                dv.syncEditors(events.Scroll, e, name)
                        })
                        w.On(events.Input, func(e events.Event) {
                                dv.syncEditors(events.Input, e, name)
                        })
                })
        }
        f("text-a", dv.linesA)
        f("text-b", dv.linesB)
}

func (dv *DiffEditor) updateToolbar() {
        if dv.toolbar == nil {
                return
        }
        dv.toolbar.Restyle()
}

// setFilenames sets the filenames and updates markup accordingly.
// Called in DiffStrings
func (dv *DiffEditor) setFilenames() {
        dv.linesA.SetFilename(dv.FileA)
        dv.linesB.SetFilename(dv.FileB)
        dv.linesA.Stat()
        dv.linesB.Stat()
}

// syncEditors synchronizes the text [Editor] scrolling and cursor positions
func (dv *DiffEditor) syncEditors(typ events.Types, e events.Event, name string) {
        tva, tvb := dv.textEditors()
        me, other := tva, tvb
        if name == "text-b" {
                me, other = tvb, tva
        }
        switch typ {
        case events.Scroll:
                other.isScrolling = true
                other.updateScroll(me.scrollPos)
        case events.Input:
                if dv.inInputEvent {
                        return
                }
                dv.inInputEvent = true
                other.SetCursorShow(me.CursorPos)
                dv.inInputEvent = false
        }
}

// nextDiff moves to next diff region
func (dv *DiffEditor) nextDiff(ab int) bool {
        tva, tvb := dv.textEditors()
        tv := tva
        if ab == 1 {
                tv = tvb
        }
        nd := len(dv.alignD)
        curLn := tv.CursorPos.Line
        di, df := dv.alignD.DiffForLine(curLn)
        if di < 0 {
                return false
        }
        for {
                di++
                if di >= nd {
                        return false
                }
                df = dv.alignD[di]
                if df.Tag != 'e' {
                        break
                }
        }
        tva.SetCursorTarget(textpos.Pos{Line: df.I1})
        tvb.SetCursorTarget(textpos.Pos{Line: df.I1})
        return true
}

// prevDiff moves to previous diff region
func (dv *DiffEditor) prevDiff(ab int) bool {
        tva, tvb := dv.textEditors()
        tv := tva
        if ab == 1 {
                tv = tvb
        }
        curLn := tv.CursorPos.Line
        di, df := dv.alignD.DiffForLine(curLn)
        if di < 0 {
                return false
        }
        for {
                di--
                if di < 0 {
                        return false
                }
                df = dv.alignD[di]
                if df.Tag != 'e' {
                        break
                }
        }
        tva.SetCursorTarget(textpos.Pos{Line: df.I1})
        tvb.SetCursorTarget(textpos.Pos{Line: df.I1})
        return true
}

// saveAs saves A or B edits into given file.
// It checks for an existing file, prompts to overwrite or not.
func (dv *DiffEditor) saveAs(ab bool, filename core.Filename) {
        if !errors.Log1(fsx.FileExists(string(filename))) {
                dv.saveFile(ab, filename)
        } else {
                d := core.NewBody("File Exists, Overwrite?")
                core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("File already exists, overwrite?  File: %v", filename))
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddCancel(bar)
                        d.AddOK(bar).OnClick(func(e events.Event) {
                                dv.saveFile(ab, filename)
                        })
                })
                d.RunDialog(dv)
        }
}

// saveFile writes A or B edits to file, with no prompting, etc
func (dv *DiffEditor) saveFile(ab bool, filename core.Filename) error {
        var txt string
        if ab {
                txt = strings.Join(dv.diffs.B.Edit, "\n")
        } else {
                txt = strings.Join(dv.diffs.A.Edit, "\n")
        }
        err := os.WriteFile(string(filename), []byte(txt), 0644)
        if err != nil {
                core.ErrorSnackbar(dv, err)
                slog.Error(err.Error())
        }
        return err
}

// saveFileA saves the current state of file A to given filename
func (dv *DiffEditor) saveFileA(fname core.Filename) { //types:add
        dv.saveAs(false, fname)
        dv.updateToolbar()
}

// saveFileB saves the current state of file B to given filename
func (dv *DiffEditor) saveFileB(fname core.Filename) { //types:add
        dv.saveAs(true, fname)
        dv.updateToolbar()
}

// DiffStrings computes differences between two lines-of-strings and displays in
// DiffEditor.
func (dv *DiffEditor) DiffStrings(astr, bstr []string) {
        dv.setFilenames()
        dv.diffs.SetStringLines(astr, bstr)

        dv.linesA.DeleteLineColor(-1)
        dv.linesB.DeleteLineColor(-1)
        del := colors.Scheme.Error.Base
        ins := colors.Scheme.Success.Base
        chg := colors.Scheme.Primary.Base

        nd := len(dv.diffs.Diffs)
        dv.alignD = make(lines.Diffs, nd)
        var ab, bb [][]byte
        absln := 0
        bspc := []byte(" ")
        for i, df := range dv.diffs.Diffs {
                switch df.Tag {
                case 'r':
                        di := df.I2 - df.I1
                        dj := df.J2 - df.J1
                        mx := max(di, dj)
                        ad := df
                        ad.I1 = absln
                        ad.I2 = absln + di
                        ad.J1 = absln
                        ad.J2 = absln + dj
                        dv.alignD[i] = ad
                        for i := 0; i < mx; i++ {
                                dv.linesA.SetLineColor(absln+i, chg)
                                dv.linesB.SetLineColor(absln+i, chg)
                                blen := 0
                                alen := 0
                                if i < di {
                                        aln := []byte(astr[df.I1+i])
                                        alen = len(aln)
                                        ab = append(ab, aln)
                                }
                                if i < dj {
                                        bln := []byte(bstr[df.J1+i])
                                        blen = len(bln)
                                        bb = append(bb, bln)
                                } else {
                                        bb = append(bb, bytes.Repeat(bspc, alen))
                                }
                                if i >= di {
                                        ab = append(ab, bytes.Repeat(bspc, blen))
                                }
                        }
                        absln += mx
                case 'd':
                        di := df.I2 - df.I1
                        ad := df
                        ad.I1 = absln
                        ad.I2 = absln + di
                        ad.J1 = absln
                        ad.J2 = absln + di
                        dv.alignD[i] = ad
                        for i := 0; i < di; i++ {
                                dv.linesA.SetLineColor(absln+i, ins)
                                dv.linesB.SetLineColor(absln+i, del)
                                aln := []byte(astr[df.I1+i])
                                alen := len(aln)
                                ab = append(ab, aln)
                                bb = append(bb, bytes.Repeat(bspc, alen))
                        }
                        absln += di
                case 'i':
                        dj := df.J2 - df.J1
                        ad := df
                        ad.I1 = absln
                        ad.I2 = absln + dj
                        ad.J1 = absln
                        ad.J2 = absln + dj
                        dv.alignD[i] = ad
                        for i := 0; i < dj; i++ {
                                dv.linesA.SetLineColor(absln+i, del)
                                dv.linesB.SetLineColor(absln+i, ins)
                                bln := []byte(bstr[df.J1+i])
                                blen := len(bln)
                                bb = append(bb, bln)
                                ab = append(ab, bytes.Repeat(bspc, blen))
                        }
                        absln += dj
                case 'e':
                        di := df.I2 - df.I1
                        ad := df
                        ad.I1 = absln
                        ad.I2 = absln + di
                        ad.J1 = absln
                        ad.J2 = absln + di
                        dv.alignD[i] = ad
                        for i := 0; i < di; i++ {
                                ab = append(ab, []byte(astr[df.I1+i]))
                                bb = append(bb, []byte(bstr[df.J1+i]))
                        }
                        absln += di
                }
        }
        dv.linesA.SetTextLines(ab) // don't copy
        dv.linesB.SetTextLines(bb) // don't copy
        dv.tagWordDiffs()
        dv.linesA.ReMarkup()
        dv.linesB.ReMarkup()
}

// tagWordDiffs goes through replace diffs and tags differences at the
// word level between the two regions.
func (dv *DiffEditor) tagWordDiffs() {
        for _, df := range dv.alignD {
                if df.Tag != 'r' {
                        continue
                }
                di := df.I2 - df.I1
                dj := df.J2 - df.J1
                mx := max(di, dj)
                stln := df.I1
                for i := 0; i < mx; i++ {
                        ln := stln + i
                        ra := dv.linesA.Line(ln)
                        rb := dv.linesB.Line(ln)
                        lna := lexer.RuneFields(ra)
                        lnb := lexer.RuneFields(rb)
                        fla := lna.RuneStrings(ra)
                        flb := lnb.RuneStrings(rb)
                        nab := max(len(fla), len(flb))
                        ldif := lines.DiffLines(fla, flb)
                        ndif := len(ldif)
                        if nab > 25 && ndif > nab/2 { // more than half of big diff -- skip
                                continue
                        }
                        for _, ld := range ldif {
                                switch ld.Tag {
                                case 'r':
                                        sla := lna[ld.I1]
                                        ela := lna[ld.I2-1]
                                        dv.linesA.AddTag(ln, sla.Start, ela.End, token.TextStyleError)
                                        slb := lnb[ld.J1]
                                        elb := lnb[ld.J2-1]
                                        dv.linesB.AddTag(ln, slb.Start, elb.End, token.TextStyleError)
                                case 'd':
                                        sla := lna[ld.I1]
                                        ela := lna[ld.I2-1]
                                        dv.linesA.AddTag(ln, sla.Start, ela.End, token.TextStyleDeleted)
                                case 'i':
                                        slb := lnb[ld.J1]
                                        elb := lnb[ld.J2-1]
                                        dv.linesB.AddTag(ln, slb.Start, elb.End, token.TextStyleDeleted)
                                }
                        }
                }
        }
}

// applyDiff applies change from the other lines to the lines for given file
// name, from diff that includes given line.
func (dv *DiffEditor) applyDiff(ab int, line int) bool {
        tva, tvb := dv.textEditors()
        tv := tva
        if ab == 1 {
                tv = tvb
        }
        if line < 0 {
                line = tv.CursorPos.Line
        }
        di, df := dv.alignD.DiffForLine(line)
        if di < 0 || df.Tag == 'e' {
                return false
        }

        if ab == 0 {
                dv.linesA.SetUndoOn(true)
                // srcLen := len(dv.BufB.Lines[df.J2])
                spos := textpos.Pos{Line: df.I1, Char: 0}
                epos := textpos.Pos{Line: df.I2, Char: 0}
                src := dv.linesB.Region(spos, epos)
                dv.linesA.DeleteText(spos, epos)
                dv.linesA.InsertTextLines(spos, src.Text) // we always just copy, is blank for delete..
                dv.diffs.BtoA(di)
        } else {
                dv.linesB.SetUndoOn(true)
                spos := textpos.Pos{Line: df.J1, Char: 0}
                epos := textpos.Pos{Line: df.J2, Char: 0}
                src := dv.linesA.Region(spos, epos)
                dv.linesB.DeleteText(spos, epos)
                dv.linesB.InsertTextLines(spos, src.Text)
                dv.diffs.AtoB(di)
        }
        dv.updateToolbar()
        return true
}

// undoDiff undoes last applied change, if any.
func (dv *DiffEditor) undoDiff(ab int) error {
        tva, tvb := dv.textEditors()
        if ab == 1 {
                if !dv.diffs.B.Undo() {
                        err := errors.New("No more edits to undo")
                        core.ErrorSnackbar(dv, err)
                        return err
                }
                tvb.undo()
        } else {
                if !dv.diffs.A.Undo() {
                        err := errors.New("No more edits to undo")
                        core.ErrorSnackbar(dv, err)
                        return err
                }
                tva.undo()
        }
        return nil
}

func (dv *DiffEditor) MakeToolbar(p *tree.Plan) {
        txta := "A: " + fsx.DirAndFile(dv.FileA)
        if dv.RevisionA != "" {
                txta += ": " + dv.RevisionA
        }
        tree.Add(p, func(w *core.Text) {
                w.SetText(txta)
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("Next").SetIcon(icons.KeyboardArrowDown).SetTooltip("move down to next diff region")
                w.OnClick(func(e events.Event) {
                        dv.nextDiff(0)
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(len(dv.alignD) <= 1, states.Disabled)
                })
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("Prev").SetIcon(icons.KeyboardArrowUp).SetTooltip("move up to previous diff region")
                w.OnClick(func(e events.Event) {
                        dv.prevDiff(0)
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(len(dv.alignD) <= 1, states.Disabled)
                })
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("A &lt;- B").SetIcon(icons.ContentCopy).SetTooltip("for current diff region, apply change from corresponding version in B, and move to next diff")
                w.OnClick(func(e events.Event) {
                        dv.applyDiff(0, -1)
                        dv.nextDiff(0)
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(len(dv.alignD) <= 1, states.Disabled)
                })
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("Undo").SetIcon(icons.Undo).SetTooltip("undo last diff apply action (A &lt;- B)")
                w.OnClick(func(e events.Event) {
                        dv.undoDiff(0)
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(!dv.linesA.IsNotSaved(), states.Disabled)
                })
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("Save").SetIcon(icons.Save).SetTooltip("save edited version of file with the given; prompts for filename")
                w.OnClick(func(e events.Event) {
                        fb := core.NewSoloFuncButton(w).SetFunc(dv.saveFileA)
                        fb.Args[0].SetValue(core.Filename(dv.FileA))
                        fb.CallFunc()
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(!dv.linesA.IsNotSaved(), states.Disabled)
                })
        })

        tree.Add(p, func(w *core.Separator) {})

        txtb := "B: " + fsx.DirAndFile(dv.FileB)
        if dv.RevisionB != "" {
                txtb += ": " + dv.RevisionB
        }
        tree.Add(p, func(w *core.Text) {
                w.SetText(txtb)
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("Next").SetIcon(icons.KeyboardArrowDown).SetTooltip("move down to next diff region")
                w.OnClick(func(e events.Event) {
                        dv.nextDiff(1)
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(len(dv.alignD) <= 1, states.Disabled)
                })
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("Prev").SetIcon(icons.KeyboardArrowUp).SetTooltip("move up to previous diff region")
                w.OnClick(func(e events.Event) {
                        dv.prevDiff(1)
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(len(dv.alignD) <= 1, states.Disabled)
                })
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("A -&gt; B").SetIcon(icons.ContentCopy).SetTooltip("for current diff region, apply change from corresponding version in A, and move to next diff")
                w.OnClick(func(e events.Event) {
                        dv.applyDiff(1, -1)
                        dv.nextDiff(1)
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(len(dv.alignD) <= 1, states.Disabled)
                })
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("Undo").SetIcon(icons.Undo).SetTooltip("undo last diff apply action (A -&gt; B)")
                w.OnClick(func(e events.Event) {
                        dv.undoDiff(1)
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(!dv.linesB.IsNotSaved(), states.Disabled)
                })
        })
        tree.Add(p, func(w *core.Button) {
                w.SetText("Save").SetIcon(icons.Save).SetTooltip("save edited version of file -- prompts for filename -- this will convert file back to its original form (removing side-by-side alignment) and end the diff editing function")
                w.OnClick(func(e events.Event) {
                        fb := core.NewSoloFuncButton(w).SetFunc(dv.saveFileB)
                        fb.Args[0].SetValue(core.Filename(dv.FileB))
                        fb.CallFunc()
                })
                w.Styler(func(s *styles.Style) {
                        s.SetState(!dv.linesB.IsNotSaved(), states.Disabled)
                })
        })
}

func (dv *DiffEditor) textEditors() (*DiffTextEditor, *DiffTextEditor) {
        av := dv.Child(0).(*DiffTextEditor)
        bv := dv.Child(1).(*DiffTextEditor)
        return av, bv
}

////////   DiffTextEditor

// DiffTextEditor supports double-click based application of edits from one
// lines to the other.
type DiffTextEditor struct {
        Editor
}

func (ed *DiffTextEditor) Init() {
        ed.Editor.Init()
        ed.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 1)
        })
        ed.OnDoubleClick(func(e events.Event) {
                pt := ed.PointToRelPos(e.Pos())
                if pt.X >= 0 && pt.X < int(ed.LineNumberPixels()) {
                        newPos := ed.PixelToCursor(pt)
                        ln := newPos.Line
                        dv := ed.diffEditor()
                        if dv != nil && ed.Lines != nil {
                                if ed.Name == "text-a" {
                                        dv.applyDiff(0, ln)
                                } else {
                                        dv.applyDiff(1, ln)
                                }
                        }
                        e.SetHandled()
                        return
                }
        })
}

func (ed *DiffTextEditor) diffEditor() *DiffEditor {
        return tree.ParentByType[*DiffEditor](ed)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "fmt"
        "unicode"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/indent"
        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/core"
        "cogentcore.org/core/cursors"
        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "cogentcore.org/core/icons"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/styles/abilities"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/parse"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/textpos"
)

// Editor is a widget for editing multiple lines of complicated text (as compared to
// [core.TextField] for a single line of simple text).  The Editor is driven by a
// [lines.Lines] buffer which contains all the text, and manages all the edits,
// sending update events out to the editors.
//
// Use NeedsRender to drive an render update for any change that does
// not change the line-level layout of the text.
//
// Multiple editors can be attached to a given buffer.  All updating in the
// Editor should be within a single goroutine, as it would require
// extensive protections throughout code otherwise.
type Editor struct { //core:embedder
        Base

        // ISearch is the interactive search data.
        ISearch ISearch `set:"-" edit:"-" json:"-" xml:"-"`

        // QReplace is the query replace data.
        QReplace QReplace `set:"-" edit:"-" json:"-" xml:"-"`

        // Complete is the functions and data for text completion.
        Complete *core.Complete `json:"-" xml:"-"`

        // spell is the functions and data for spelling correction.
        spell *spellCheck

        // curFilename is the current filename from Lines. Used to detect changed file.
        curFilename string
}

func (ed *Editor) Init() {
        ed.Base.Init()
        ed.editorSetLines(ed.Lines)
        ed.setSpell()
        ed.AddContextMenu(ed.contextMenu)
        ed.handleKeyChord()
        ed.handleMouse()
        ed.handleLinkCursor()
        ed.handleFocus()
}

// UpdateNewFile checks if there is a new file in the Lines editor and updates
// any relevant editor settings accordingly.
func (ed *Editor) UpdateNewFile() {
        ln := ed.Lines
        if ln == nil {
                ed.curFilename = ""
                ed.viewId = -1
                return
        }
        fnm := ln.Filename()
        if ed.curFilename == fnm {
                return
        }
        ed.curFilename = fnm
        if ln.FileInfo().Known != fileinfo.Unknown {
                _, ps := ln.ParseState()
                ed.setCompleter(ps, completeParse, completeEditParse, lookupParse)
        } else {
                ed.deleteCompleter()
        }
}

// SetLines sets the [lines.Lines] that this is an editor of,
// creating a new view for this editor and connecting to events.
func (ed *Editor) SetLines(ln *lines.Lines) *Editor {
        ed.Base.SetLines(ln)
        ed.editorSetLines(ln)
        return ed
}

// editorSetLines does the editor specific part of SetLines.
func (ed *Editor) editorSetLines(ln *lines.Lines) {
        if ln == nil {
                ed.curFilename = ""
                return
        }
        ln.OnChange(ed.viewId, func(e events.Event) {
                ed.UpdateNewFile()
        })
        ln.FileModPromptFunc = func() {
                FileModPrompt(ed.Scene, ln)
        }
}

// SaveAs saves the current text into given file; does an editDone first to save edits
// and checks for an existing file; if it does exist then prompts to overwrite or not.
func (ed *Editor) SaveAs(filename core.Filename) { //types:add
        ed.editDone()
        SaveAs(ed.Scene, ed.Lines, string(filename), nil)
}

// Save saves the current text into the current filename associated with this buffer.
// Do NOT use this in an OnChange event handler as it emits a Change event! Use
// [Editor.SaveQuiet] instead.
func (ed *Editor) Save() error { //types:add
        ed.editDone()
        return Save(ed.Scene, ed.Lines)
}

// SaveQuiet saves the current text into the current filename associated with this buffer.
// This version does not emit a change event, so it is safe to use
// in an OnChange event handler, unlike [Editor.Save].
func (ed *Editor) SaveQuiet() error { //types:add
        ed.clearSelected()
        ed.clearCursor()
        return Save(ed.Scene, ed.Lines)
}

// Close closes the lines viewed by this editor, prompting to save if there are changes.
// If afterFunc is non-nil, then it is called with the status of the user action.
func (ed *Editor) Close(afterFunc func(canceled bool)) bool {
        return Close(ed.Scene, ed.Lines, afterFunc)
}

func (ed *Editor) handleFocus() {
        ed.OnFocusLost(func(e events.Event) {
                if ed.IsReadOnly() {
                        ed.clearCursor()
                        return
                }
                if ed.AbilityIs(abilities.Focusable) {
                        ed.editDone()
                        ed.SetState(false, states.Focused)
                }
        })
}

func (ed *Editor) handleKeyChord() {
        ed.OnKeyChord(func(e events.Event) {
                ed.keyInput(e)
        })
}

// shiftSelect sets the selection start if the shift key is down but wasn't on the last key move.
// If the shift key has been released the select region is set to textpos.Region{}
func (ed *Editor) shiftSelect(kt events.Event) {
        hasShift := kt.HasAnyModifier(key.Shift)
        if hasShift {
                if ed.SelectRegion == (textpos.Region{}) {
                        ed.selectStart = ed.CursorPos
                }
        } else {
                ed.SelectRegion = textpos.Region{}
        }
}

// shiftSelectExtend updates the select region if the shift key is down and renders the selected lines.
// If the shift key is not down the previously selected text is rerendered to clear the highlight
func (ed *Editor) shiftSelectExtend(kt events.Event) {
        hasShift := kt.HasAnyModifier(key.Shift)
        if hasShift {
                ed.selectRegionUpdate(ed.CursorPos)
        }
}

// keyInput handles keyboard input into the text field and from the completion menu
func (ed *Editor) keyInput(e events.Event) {
        ed.isScrolling = false
        if core.DebugSettings.KeyEventTrace {
                fmt.Printf("View KeyInput: %v\n", ed.Path())
        }
        kf := keymap.Of(e.KeyChord())

        if e.IsHandled() {
                return
        }
        if ed.Lines == nil || ed.Lines.NumLines() == 0 {
                return
        }

        // cancelAll cancels search, completer, and..
        cancelAll := func() {
                ed.CancelComplete()
                ed.cancelCorrect()
                ed.iSearchCancel()
                ed.qReplaceCancel()
                ed.lastAutoInsert = 0
        }

        if kf != keymap.Recenter { // always start at centering
                ed.lastRecenter = 0
        }

        if kf != keymap.Undo && ed.lastWasUndo {
                ed.Lines.EmacsUndoSave()
                ed.lastWasUndo = false
        }

        gotTabAI := false // got auto-indent tab this time

        // first all the keys that work for both inactive and active
        switch kf {
        case keymap.MoveRight:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorForward(1)
                ed.shiftSelectExtend(e)
                ed.iSpellKeyInput(e)
        case keymap.WordRight:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorForwardWord(1)
                ed.shiftSelectExtend(e)
        case keymap.MoveLeft:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorBackward(1)
                ed.shiftSelectExtend(e)
        case keymap.WordLeft:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorBackwardWord(1)
                ed.shiftSelectExtend(e)
        case keymap.MoveUp:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorUp(1)
                ed.shiftSelectExtend(e)
                ed.iSpellKeyInput(e)
        case keymap.MoveDown:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorDown(1)
                ed.shiftSelectExtend(e)
                ed.iSpellKeyInput(e)
        case keymap.PageUp:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorPageUp(1)
                ed.shiftSelectExtend(e)
        case keymap.PageDown:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorPageDown(1)
                ed.shiftSelectExtend(e)
        case keymap.Home:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorLineStart()
                ed.shiftSelectExtend(e)
        case keymap.End:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorLineEnd()
                ed.shiftSelectExtend(e)
        case keymap.DocHome:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.CursorStartDoc()
                ed.shiftSelectExtend(e)
        case keymap.DocEnd:
                cancelAll()
                e.SetHandled()
                ed.shiftSelect(e)
                ed.cursorEndDoc()
                ed.shiftSelectExtend(e)
        case keymap.Recenter:
                cancelAll()
                e.SetHandled()
                ed.reMarkup()
                ed.cursorRecenter()
        case keymap.SelectMode:
                cancelAll()
                e.SetHandled()
                ed.selectModeToggle()
        case keymap.CancelSelect:
                ed.CancelComplete()
                e.SetHandled()
                ed.escPressed() // generic cancel
        case keymap.SelectAll:
                cancelAll()
                e.SetHandled()
                ed.selectAll()
        case keymap.Copy:
                cancelAll()
                e.SetHandled()
                ed.Copy(true) // reset
        case keymap.Search:
                e.SetHandled()
                ed.qReplaceCancel()
                ed.CancelComplete()
                ed.iSearchStart()
        case keymap.Abort:
                cancelAll()
                e.SetHandled()
                ed.escPressed()
        case keymap.Jump:
                cancelAll()
                e.SetHandled()
                ed.JumpToLinePrompt()
        case keymap.HistPrev:
                cancelAll()
                e.SetHandled()
                if ed.Lines != nil && ed.posHistoryIndex == ed.Lines.PosHistoryLen()-1 {
                        ed.savePosHistory(ed.CursorPos) // save current if end
                        ed.posHistoryIndex--
                }
                ed.CursorToHistoryPrev()
        case keymap.HistNext:
                cancelAll()
                e.SetHandled()
                ed.CursorToHistoryNext()
        case keymap.Lookup:
                cancelAll()
                e.SetHandled()
                ed.Lookup()
        }
        if ed.IsReadOnly() {
                switch {
                case kf == keymap.FocusNext: // tab
                        e.SetHandled()
                        ed.CursorNextLink(true)
                        ed.OpenLinkAt(ed.CursorPos)
                case kf == keymap.FocusPrev: // tab
                        e.SetHandled()
                        ed.CursorPrevLink(true)
                        ed.OpenLinkAt(ed.CursorPos)
                case kf == keymap.None && ed.ISearch.On:
                        if unicode.IsPrint(e.KeyRune()) && !e.HasAnyModifier(key.Control, key.Meta) {
                                ed.iSearchKeyInput(e)
                        }
                case e.KeyRune() == ' ' || kf == keymap.Accept || kf == keymap.Enter:
                        e.SetHandled()
                        ed.CursorPos = ed.Lines.MoveBackward(ed.CursorPos, 1)
                        ed.CursorNextLink(true) // todo: cursorcurlink
                        ed.OpenLinkAt(ed.CursorPos)
                }
                return
        }
        if e.IsHandled() {
                ed.lastWasTabAI = gotTabAI
                return
        }
        switch kf {
        case keymap.Replace:
                e.SetHandled()
                ed.CancelComplete()
                ed.iSearchCancel()
                ed.QReplacePrompt()
        case keymap.Backspace:
                // todo: previous item in qreplace
                if ed.ISearch.On {
                        ed.iSearchBackspace()
                } else {
                        e.SetHandled()
                        ed.cursorBackspace(1)
                        ed.iSpellKeyInput(e)
                        ed.offerComplete()
                }
        case keymap.Kill:
                cancelAll()
                e.SetHandled()
                ed.cursorKill()
        case keymap.Delete:
                cancelAll()
                e.SetHandled()
                ed.cursorDelete(1)
                ed.iSpellKeyInput(e)
        case keymap.BackspaceWord:
                cancelAll()
                e.SetHandled()
                ed.cursorBackspaceWord(1)
        case keymap.DeleteWord:
                cancelAll()
                e.SetHandled()
                ed.cursorDeleteWord(1)
        case keymap.Cut:
                cancelAll()
                e.SetHandled()
                ed.Cut()
        case keymap.Paste:
                cancelAll()
                e.SetHandled()
                ed.Paste()
        case keymap.Transpose:
                cancelAll()
                e.SetHandled()
                ed.cursorTranspose()
        case keymap.TransposeWord:
                cancelAll()
                e.SetHandled()
                ed.cursorTransposeWord()
        case keymap.PasteHist:
                cancelAll()
                e.SetHandled()
                ed.pasteHistory()
        case keymap.Accept:
                cancelAll()
                e.SetHandled()
                ed.editDone()
        case keymap.Undo:
                cancelAll()
                e.SetHandled()
                ed.undo()
                ed.lastWasUndo = true
        case keymap.Redo:
                cancelAll()
                e.SetHandled()
                ed.redo()
        case keymap.Complete:
                ed.iSearchCancel()
                e.SetHandled()
                if ed.isSpellEnabled(ed.CursorPos) {
                        ed.offerCorrect()
                } else {
                        ed.offerComplete()
                }
        case keymap.Enter:
                cancelAll()
                if !e.HasAnyModifier(key.Control, key.Meta) {
                        e.SetHandled()
                        if ed.Lines.Settings.AutoIndent {
                                lp, _ := ed.Lines.ParseState()
                                if lp != nil && lp.Lang != nil && lp.HasFlag(parse.ReAutoIndent) {
                                        // only re-indent current line for supported types
                                        tbe, _, _ := ed.Lines.AutoIndent(ed.CursorPos.Line) // reindent current line
                                        if tbe != nil {
                                                // go back to end of line!
                                                npos := textpos.Pos{Line: ed.CursorPos.Line, Char: ed.Lines.LineLen(ed.CursorPos.Line)}
                                                ed.setCursor(npos)
                                        }
                                }
                                ed.InsertAtCursor([]byte("\n"))
                                tbe, _, cpos := ed.Lines.AutoIndent(ed.CursorPos.Line)
                                if tbe != nil {
                                        ed.SetCursorShow(textpos.Pos{Line: tbe.Region.End.Line, Char: cpos})
                                }
                        } else {
                                ed.InsertAtCursor([]byte("\n"))
                        }
                        ed.iSpellKeyInput(e)
                }
                // todo: KeFunFocusPrev -- unindent
        case keymap.FocusNext: // tab
                cancelAll()
                if !e.HasAnyModifier(key.Control, key.Meta) {
                        e.SetHandled()
                        lasttab := ed.lastWasTabAI
                        if !lasttab && ed.CursorPos.Char == 0 && ed.Lines.Settings.AutoIndent {
                                _, _, cpos := ed.Lines.AutoIndent(ed.CursorPos.Line)
                                ed.CursorPos.Char = cpos
                                ed.renderCursor(true)
                                gotTabAI = true
                        } else {
                                ed.InsertAtCursor(indent.Bytes(ed.Lines.Settings.IndentChar(), 1, ed.Styles.Text.TabSize))
                        }
                        ed.NeedsRender()
                        ed.iSpellKeyInput(e)
                }
        case keymap.FocusPrev: // shift-tab
                cancelAll()
                if !e.HasAnyModifier(key.Control, key.Meta) {
                        e.SetHandled()
                        if ed.CursorPos.Char > 0 {
                                ind, _ := lexer.LineIndent(ed.Lines.Line(ed.CursorPos.Line), ed.Styles.Text.TabSize)
                                if ind > 0 {
                                        ed.Lines.IndentLine(ed.CursorPos.Line, ind-1)
                                        intxt := indent.Bytes(ed.Lines.Settings.IndentChar(), ind-1, ed.Styles.Text.TabSize)
                                        npos := textpos.Pos{Line: ed.CursorPos.Line, Char: len(intxt)}
                                        ed.SetCursorShow(npos)
                                }
                        }
                        ed.iSpellKeyInput(e)
                }
        case keymap.None:
                if unicode.IsPrint(e.KeyRune()) {
                        if !e.HasAnyModifier(key.Control, key.Meta) {
                                ed.keyInputInsertRune(e)
                        }
                }
                ed.iSpellKeyInput(e)
        }
        ed.lastWasTabAI = gotTabAI
}

// keyInputInsertBracket handle input of opening bracket-like entity
// (paren, brace, bracket)
func (ed *Editor) keyInputInsertBracket(kt events.Event) {
        pos := ed.CursorPos
        match := true
        newLine := false
        curLn := ed.Lines.Line(pos.Line)
        lnLen := len(curLn)
        lp, ps := ed.Lines.ParseState()
        if lp != nil && lp.Lang != nil {
                match, newLine = lp.Lang.AutoBracket(ps, kt.KeyRune(), pos, curLn)
        } else {
                if kt.KeyRune() == '{' {
                        if pos.Char == lnLen {
                                if lnLen == 0 || unicode.IsSpace(curLn[pos.Char-1]) {
                                        newLine = true
                                }
                                match = true
                        } else {
                                match = unicode.IsSpace(curLn[pos.Char])
                        }
                } else {
                        match = pos.Char == lnLen || unicode.IsSpace(curLn[pos.Char]) // at end or if space after
                }
        }
        if match {
                ket, _ := lexer.BracePair(kt.KeyRune())
                if newLine && ed.Lines.Settings.AutoIndent {
                        ed.InsertAtCursor([]byte(string(kt.KeyRune()) + "\n"))
                        tbe, _, cpos := ed.Lines.AutoIndent(ed.CursorPos.Line)
                        if tbe != nil {
                                pos = textpos.Pos{Line: tbe.Region.End.Line, Char: cpos}
                                ed.SetCursorShow(pos)
                        }
                        ed.InsertAtCursor([]byte("\n" + string(ket)))
                        ed.Lines.AutoIndent(ed.CursorPos.Line)
                } else {
                        ed.InsertAtCursor([]byte(string(kt.KeyRune()) + string(ket)))
                        pos.Char++
                }
                ed.lastAutoInsert = ket
        } else {
                ed.InsertAtCursor([]byte(string(kt.KeyRune())))
                pos.Char++
        }
        ed.SetCursorShow(pos)
        ed.setCursorColumn(ed.CursorPos)
}

// keyInputInsertRune handles the insertion of a typed character
func (ed *Editor) keyInputInsertRune(kt events.Event) {
        kt.SetHandled()
        if ed.ISearch.On {
                ed.CancelComplete()
                ed.iSearchKeyInput(kt)
        } else if ed.QReplace.On {
                ed.CancelComplete()
                ed.qReplaceKeyInput(kt)
        } else {
                if kt.KeyRune() == '{' || kt.KeyRune() == '(' || kt.KeyRune() == '[' {
                        ed.keyInputInsertBracket(kt)
                } else if kt.KeyRune() == '}' && ed.Lines.Settings.AutoIndent && ed.CursorPos.Char == ed.Lines.LineLen(ed.CursorPos.Line) {
                        ed.CancelComplete()
                        ed.lastAutoInsert = 0
                        ed.InsertAtCursor([]byte(string(kt.KeyRune())))
                        tbe, _, cpos := ed.Lines.AutoIndent(ed.CursorPos.Line)
                        if tbe != nil {
                                ed.SetCursorShow(textpos.Pos{Line: tbe.Region.End.Line, Char: cpos})
                        }
                } else if ed.lastAutoInsert == kt.KeyRune() { // if we type what we just inserted, just move past
                        ed.CursorPos.Char++
                        ed.SetCursorShow(ed.CursorPos)
                        ed.lastAutoInsert = 0
                } else {
                        ed.lastAutoInsert = 0
                        ed.InsertAtCursor([]byte(string(kt.KeyRune())))
                        if kt.KeyRune() == ' ' {
                                ed.CancelComplete()
                        } else {
                                ed.offerComplete()
                        }
                }
                if kt.KeyRune() == '}' || kt.KeyRune() == ')' || kt.KeyRune() == ']' {
                        cp := ed.CursorPos
                        np := cp
                        np.Char--
                        tp, found := ed.Lines.BraceMatchRune(kt.KeyRune(), np)
                        if found {
                                ed.addScopelights(np, tp)
                        }
                }
        }
}

// handleMouse handles mouse events
func (ed *Editor) handleMouse() {
        ed.OnClick(func(e events.Event) {
                ed.SetFocus()
                pt := ed.PointToRelPos(e.Pos())
                newPos := ed.PixelToCursor(pt)
                if newPos == textpos.PosErr {
                        return
                }
                switch e.MouseButton() {
                case events.Left:
                        lk, _ := ed.OpenLinkAt(newPos)
                        if lk == nil {
                                if !e.HasAnyModifier(key.Shift, key.Meta, key.Alt) {
                                        ed.SelectReset()
                                }
                                ed.setCursorFromMouse(pt, newPos, e.SelectMode())
                                ed.savePosHistory(ed.CursorPos)
                        }
                case events.Middle:
                        if !ed.IsReadOnly() {
                                ed.Paste()
                        }
                }
        })
        ed.OnDoubleClick(func(e events.Event) {
                if !ed.StateIs(states.Focused) {
                        ed.SetFocus()
                        ed.Send(events.Focus, e) // sets focused flag
                }
                e.SetHandled()
                if ed.selectWord() {
                        ed.CursorPos = ed.SelectRegion.Start
                }
                ed.NeedsRender()
        })
        ed.On(events.TripleClick, func(e events.Event) {
                if !ed.StateIs(states.Focused) {
                        ed.SetFocus()
                        ed.Send(events.Focus, e) // sets focused flag
                }
                e.SetHandled()
                sz := ed.Lines.LineLen(ed.CursorPos.Line)
                if sz > 0 {
                        ed.SelectRegion.Start.Line = ed.CursorPos.Line
                        ed.SelectRegion.Start.Char = 0
                        ed.SelectRegion.End.Line = ed.CursorPos.Line
                        ed.SelectRegion.End.Char = sz
                }
                ed.NeedsRender()
        })
        ed.On(events.Scroll, func(e events.Event) {
                ed.isScrolling = true
        })
        ed.On(events.SlideStart, func(e events.Event) {
                e.SetHandled()
                ed.SetState(true, states.Sliding)
                ed.isScrolling = true
                pt := ed.PointToRelPos(e.Pos())
                newPos := ed.PixelToCursor(pt)
                if ed.selectMode || e.SelectMode() != events.SelectOne { // extend existing select
                        ed.setCursorFromMouse(pt, newPos, e.SelectMode())
                } else {
                        ed.CursorPos = newPos
                        if !ed.selectMode {
                                ed.selectModeToggle()
                        }
                }
                ed.savePosHistory(ed.CursorPos)
        })
        ed.On(events.SlideMove, func(e events.Event) {
                e.SetHandled()
                ed.selectMode = true
                pt := ed.PointToRelPos(e.Pos())
                newPos := ed.PixelToCursor(pt)
                ed.setCursorFromMouse(pt, newPos, events.SelectOne)
        })
        ed.On(events.SlideStop, func(e events.Event) {
                e.SetHandled()
                ed.isScrolling = false
        })
}

func (ed *Editor) handleLinkCursor() {
        ed.On(events.MouseMove, func(e events.Event) {
                pt := ed.PointToRelPos(e.Pos())
                newPos := ed.PixelToCursor(pt)
                if newPos == textpos.PosErr {
                        return
                }
                lk, _ := ed.linkAt(newPos)
                if lk != nil {
                        ed.Styles.Cursor = cursors.Pointer
                } else {
                        ed.Styles.Cursor = cursors.Text
                }
        })
}

////////  Context Menu

// ShowContextMenu displays the context menu with options dependent on situation
func (ed *Editor) ShowContextMenu(e events.Event) {
        if ed.spell != nil && !ed.HasSelection() && ed.isSpellEnabled(ed.CursorPos) {
                if ed.offerCorrect() {
                        return
                }
        }
        ed.WidgetBase.ShowContextMenu(e)
}

// contextMenu builds the text editor context menu
func (ed *Editor) contextMenu(m *core.Scene) {
        core.NewButton(m).SetText("Copy").SetIcon(icons.ContentCopy).
                SetKey(keymap.Copy).SetState(!ed.HasSelection(), states.Disabled).
                OnClick(func(e events.Event) {
                        ed.Copy(true)
                })
        if !ed.IsReadOnly() {
                core.NewButton(m).SetText("Cut").SetIcon(icons.ContentCopy).
                        SetKey(keymap.Cut).SetState(!ed.HasSelection(), states.Disabled).
                        OnClick(func(e events.Event) {
                                ed.Cut()
                        })
                core.NewButton(m).SetText("Paste").SetIcon(icons.ContentPaste).
                        SetKey(keymap.Paste).SetState(ed.Clipboard().IsEmpty(), states.Disabled).
                        OnClick(func(e events.Event) {
                                ed.Paste()
                        })
                core.NewSeparator(m)
                core.NewFuncButton(m).SetFunc(ed.Save).SetIcon(icons.Save)
                core.NewFuncButton(m).SetFunc(ed.SaveAs).SetIcon(icons.SaveAs)
                core.NewFuncButton(m).SetFunc(ed.Lines.Open).SetIcon(icons.Open)
                core.NewFuncButton(m).SetFunc(ed.Lines.Revert).SetIcon(icons.Reset)
        } else {
                core.NewButton(m).SetText("Clear").SetIcon(icons.ClearAll).
                        OnClick(func(e events.Event) {
                                ed.Clear()
                        })
                if ed.Lines != nil && ed.Lines.FileInfo().Generated {
                        core.NewButton(m).SetText("Set editable").SetIcon(icons.Edit).
                                OnClick(func(e events.Event) {
                                        ed.SetReadOnly(false)
                                        ed.Lines.FileInfo().Generated = false
                                        ed.Update()
                                })
                }
        }
}

// JumpToLinePrompt jumps to given line number (minus 1) from prompt
func (ed *Editor) JumpToLinePrompt() {
        val := ""
        d := core.NewBody("Jump to line")
        core.NewText(d).SetType(core.TextSupporting).SetText("Line number to jump to")
        tf := core.NewTextField(d).SetPlaceholder("Line number")
        tf.OnChange(func(e events.Event) {
                val = tf.Text()
        })
        d.AddBottomBar(func(bar *core.Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).SetText("Jump").OnClick(func(e events.Event) {
                        val = tf.Text()
                        ln, err := reflectx.ToInt(val)
                        if err == nil {
                                ed.jumpToLine(int(ln))
                        }
                })
        })
        d.RunDialog(ed)
}

// jumpToLine jumps to given line number (minus 1)
func (ed *Editor) jumpToLine(ln int) {
        ed.SetCursorShow(textpos.Pos{Line: ln - 1})
        ed.savePosHistory(ed.CursorPos)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "fmt"
        "os"
        "time"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/base/fsx"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/text/lines"
)

// SaveAs saves the given Lines text into the given file.
// Checks for an existing file: If it does exist then prompts to overwrite or not.
// If afterFunc is non-nil, then it is called with the status of the user action.
func SaveAs(sc *core.Scene, lns *lines.Lines, filename string, afterFunc func(canceled bool)) {
        if !errors.Log1(fsx.FileExists(filename)) {
                lns.SaveFile(filename)
                if afterFunc != nil {
                        afterFunc(false)
                }
        } else {
                d := core.NewBody("File exists")
                core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("The file already exists; do you want to overwrite it?  File: %v", filename))
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddCancel(bar).OnClick(func(e events.Event) {
                                if afterFunc != nil {
                                        afterFunc(true)
                                }
                        })
                        d.AddOK(bar).OnClick(func(e events.Event) {
                                lns.SaveFile(filename)
                                if afterFunc != nil {
                                        afterFunc(false)
                                }
                        })
                })
                d.RunDialog(sc)
        }
}

// Save saves the given Lines into the current filename associated with this buffer,
// prompting if the file is changed on disk since the last save.
func Save(sc *core.Scene, lns *lines.Lines) error {
        fname := lns.Filename()
        if fname == "" {
                return errors.New("core.Editor: filename is empty for Save")
        }
        info, err := os.Stat(fname)
        if err == nil && info.ModTime() != time.Time(lns.FileInfo().ModTime) {
                d := core.NewBody("File Changed on Disk")
                core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("File has changed on disk since you opened or saved it; what do you want to do?  File: %v", fname))
                d.AddBottomBar(func(bar *core.Frame) {
                        core.NewButton(bar).SetText("Save to different file").OnClick(func(e events.Event) {
                                d.Close()
                                fd := core.NewBody("Save file as")
                                fv := core.NewFilePicker(fd).SetFilename(fname)
                                fv.OnSelect(func(e events.Event) {
                                        SaveAs(sc, lns, fv.SelectedFile(), nil)
                                })
                                fd.RunWindowDialog(sc)
                        })
                        core.NewButton(bar).SetText("Open from disk, losing changes").OnClick(func(e events.Event) {
                                d.Close()
                                lns.Revert()
                        })
                        core.NewButton(bar).SetText("Save file, overwriting").OnClick(func(e events.Event) {
                                d.Close()
                                lns.SaveFile(fname)
                        })
                })
                d.RunDialog(sc)
        }
        return lns.SaveFile(fname)
}

// Close closes the lines viewed by this editor, prompting to save if there are changes.
// If afterFunc is non-nil, then it is called with the status of the user action.
// Returns false if the file was actually not closed pending input from the user.
func Close(sc *core.Scene, lns *lines.Lines, afterFunc func(canceled bool)) bool {
        if !lns.IsNotSaved() {
                lns.Close()
                if afterFunc != nil {
                        afterFunc(false)
                }
                return true
        }
        lns.StopDelayedReMarkup()
        fname := lns.Filename()
        if fname == "" {
                d := core.NewBody("Close without saving?")
                core.NewText(d).SetType(core.TextSupporting).SetText("Do you want to save your changes (no filename for this buffer yet)?  If so, Cancel and then do Save As")
                d.AddBottomBar(func(bar *core.Frame) {
                        d.AddCancel(bar).OnClick(func(e events.Event) {
                                if afterFunc != nil {
                                        afterFunc(true)
                                }
                        })
                        d.AddOK(bar).SetText("Close without saving").OnClick(func(e events.Event) {
                                lns.ClearNotSaved()
                                lns.AutosaveDelete()
                                Close(sc, lns, afterFunc)
                        })
                })
                d.RunDialog(sc)
                return false // awaiting decisions..
        }

        d := core.NewBody("Close without saving?")
        core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("Do you want to save your changes to file: %v?", fname))
        d.AddBottomBar(func(bar *core.Frame) {
                core.NewButton(bar).SetText("Cancel").OnClick(func(e events.Event) {
                        d.Close()
                        if afterFunc != nil {
                                afterFunc(true)
                        }
                })
                core.NewButton(bar).SetText("Close without saving").OnClick(func(e events.Event) {
                        d.Close()
                        lns.ClearNotSaved()
                        lns.AutosaveDelete()
                        Close(sc, lns, afterFunc)
                })
                core.NewButton(bar).SetText("Save").OnClick(func(e events.Event) {
                        d.Close()
                        Save(sc, lns)
                        Close(sc, lns, afterFunc) // 2nd time through won't prompt
                })
        })
        d.RunDialog(sc)
        return false
}

// FileModPrompt is called when a file has been modified in the filesystem
// and it is about to be modified through an edit, in the fileModCheck function.
// The prompt determines whether the user wants to revert, overwrite, or
// save current version as a different file.
func FileModPrompt(sc *core.Scene, lns *lines.Lines) bool {
        fname := lns.Filename()
        d := core.NewBody("File changed on disk: " + fsx.DirAndFile(fname))
        core.NewText(d).SetType(core.TextSupporting).SetText(fmt.Sprintf("File has changed on disk since being opened or saved by you; what do you want to do?  If you <code>Revert from Disk</code>, you will lose any existing edits in open buffer.  If you <code>Ignore and Proceed</code>, the next save will overwrite the changed file on disk, losing any changes there.  File: %v", fname))
        d.AddBottomBar(func(bar *core.Frame) {
                core.NewButton(bar).SetText("Save as to different file").OnClick(func(e events.Event) {
                        d.Close()
                        fd := core.NewBody("Save file as")
                        fv := core.NewFilePicker(fd).SetFilename(fname)
                        fv.OnSelect(func(e events.Event) {
                                SaveAs(sc, lns, fv.SelectedFile(), nil)
                        })
                        fd.RunWindowDialog(sc)
                })
                core.NewButton(bar).SetText("Revert from disk").OnClick(func(e events.Event) {
                        d.Close()
                        lns.Revert()
                })
                core.NewButton(bar).SetText("Ignore and proceed").OnClick(func(e events.Event) {
                        d.Close()
                        lns.SetFileModOK(true)
                })
        })
        d.RunDialog(sc)
        return true
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "unicode"

        "cogentcore.org/core/base/stringsx"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/textpos"
)

// findMatches finds the matches with given search string (literal, not regex)
// and case sensitivity, updates highlights for all.  returns false if none
// found
func (ed *Editor) findMatches(find string, useCase, lexItems bool) ([]textpos.Match, bool) {
        fsz := len(find)
        if fsz == 0 {
                ed.Highlights = nil
                return nil, false
        }
        _, matches := ed.Lines.Search([]byte(find), !useCase, lexItems)
        if len(matches) == 0 {
                ed.Highlights = nil
                return matches, false
        }
        hi := make([]textpos.Region, len(matches))
        for i, m := range matches {
                hi[i] = m.Region
                if i > viewMaxFindHighlights {
                        break
                }
        }
        ed.Highlights = hi
        return matches, true
}

// matchFromPos finds the match at or after the given text position -- returns 0, false if none
func (ed *Editor) matchFromPos(matches []textpos.Match, cpos textpos.Pos) (int, bool) {
        for i, m := range matches {
                reg := ed.Lines.AdjustRegion(m.Region)
                if reg.Start == cpos || cpos.IsLess(reg.Start) {
                        return i, true
                }
        }
        return 0, false
}

// ISearch holds all the interactive search data
type ISearch struct {

        // if true, in interactive search mode
        On bool `json:"-" xml:"-"`

        // current interactive search string
        Find string `json:"-" xml:"-"`

        // pay attention to case in isearch -- triggered by typing an upper-case letter
        useCase bool

        // current search matches
        Matches []textpos.Match `json:"-" xml:"-"`

        // position within isearch matches
        pos int

        // position in search list from previous search
        prevPos int

        // starting position for search -- returns there after on cancel
        startPos textpos.Pos
}

// viewMaxFindHighlights is the maximum number of regions to highlight on find
var viewMaxFindHighlights = 1000

// PrevISearchString is the previous ISearch string
var PrevISearchString string

// iSearchMatches finds ISearch matches -- returns true if there are any
func (ed *Editor) iSearchMatches() bool {
        got := false
        ed.ISearch.Matches, got = ed.findMatches(ed.ISearch.Find, ed.ISearch.useCase, false)
        return got
}

// iSearchNextMatch finds next match after given cursor position, and highlights
// it, etc
func (ed *Editor) iSearchNextMatch(cpos textpos.Pos) bool {
        if len(ed.ISearch.Matches) == 0 {
                ed.iSearchEvent()
                return false
        }
        ed.ISearch.pos, _ = ed.matchFromPos(ed.ISearch.Matches, cpos)
        ed.iSearchSelectMatch(ed.ISearch.pos)
        return true
}

// iSearchSelectMatch selects match at given match index (e.g., ed.ISearch.Pos)
func (ed *Editor) iSearchSelectMatch(midx int) {
        nm := len(ed.ISearch.Matches)
        if midx >= nm {
                ed.iSearchEvent()
                return
        }
        m := ed.ISearch.Matches[midx]
        reg := ed.Lines.AdjustRegion(m.Region)
        pos := reg.Start
        ed.SelectRegion = reg
        ed.setCursor(pos)
        ed.savePosHistory(ed.CursorPos)
        ed.scrollCursorToCenterIfHidden()
        ed.iSearchEvent()
}

// iSearchEvent sends the signal that ISearch is updated
func (ed *Editor) iSearchEvent() {
        ed.Send(events.Input)
}

// iSearchStart is an emacs-style interactive search mode -- this is called when
// the search command itself is entered
func (ed *Editor) iSearchStart() {
        if ed.ISearch.On {
                if ed.ISearch.Find != "" { // already searching -- find next
                        sz := len(ed.ISearch.Matches)
                        if sz > 0 {
                                if ed.ISearch.pos < sz-1 {
                                        ed.ISearch.pos++
                                } else {
                                        ed.ISearch.pos = 0
                                }
                                ed.iSearchSelectMatch(ed.ISearch.pos)
                        }
                } else { // restore prev
                        if PrevISearchString != "" {
                                ed.ISearch.Find = PrevISearchString
                                ed.ISearch.useCase = lexer.HasUpperCase(ed.ISearch.Find)
                                ed.iSearchMatches()
                                ed.iSearchNextMatch(ed.CursorPos)
                                ed.ISearch.startPos = ed.CursorPos
                        }
                        // nothing..
                }
        } else {
                ed.ISearch.On = true
                ed.ISearch.Find = ""
                ed.ISearch.startPos = ed.CursorPos
                ed.ISearch.useCase = false
                ed.ISearch.Matches = nil
                ed.SelectReset()
                ed.ISearch.pos = -1
                ed.iSearchEvent()
        }
        ed.NeedsRender()
}

// iSearchKeyInput is an emacs-style interactive search mode -- this is called
// when keys are typed while in search mode
func (ed *Editor) iSearchKeyInput(kt events.Event) {
        kt.SetHandled()
        r := kt.KeyRune()
        // if ed.ISearch.Find == PrevISearchString { // undo starting point
        //         ed.ISearch.Find = ""
        // }
        if unicode.IsUpper(r) { // todo: more complex
                ed.ISearch.useCase = true
        }
        ed.ISearch.Find += string(r)
        ed.iSearchMatches()
        sz := len(ed.ISearch.Matches)
        if sz == 0 {
                ed.ISearch.pos = -1
                ed.iSearchEvent()
                return
        }
        ed.iSearchNextMatch(ed.CursorPos)
        ed.NeedsRender()
}

// iSearchBackspace gets rid of one item in search string
func (ed *Editor) iSearchBackspace() {
        if ed.ISearch.Find == PrevISearchString { // undo starting point
                ed.ISearch.Find = ""
                ed.ISearch.useCase = false
                ed.ISearch.Matches = nil
                ed.SelectReset()
                ed.ISearch.pos = -1
                ed.iSearchEvent()
                return
        }
        if len(ed.ISearch.Find) <= 1 {
                ed.SelectReset()
                ed.ISearch.Find = ""
                ed.ISearch.useCase = false
                return
        }
        ed.ISearch.Find = ed.ISearch.Find[:len(ed.ISearch.Find)-1]
        ed.iSearchMatches()
        sz := len(ed.ISearch.Matches)
        if sz == 0 {
                ed.ISearch.pos = -1
                ed.iSearchEvent()
                return
        }
        ed.iSearchNextMatch(ed.CursorPos)
        ed.NeedsRender()
}

// iSearchCancel cancels ISearch mode
func (ed *Editor) iSearchCancel() {
        if !ed.ISearch.On {
                return
        }
        if ed.ISearch.Find != "" {
                PrevISearchString = ed.ISearch.Find
        }
        ed.ISearch.prevPos = ed.ISearch.pos
        ed.ISearch.Find = ""
        ed.ISearch.useCase = false
        ed.ISearch.On = false
        ed.ISearch.pos = -1
        ed.ISearch.Matches = nil
        ed.Highlights = nil
        ed.savePosHistory(ed.CursorPos)
        ed.SelectReset()
        ed.iSearchEvent()
        ed.NeedsRender()
}

// QReplace holds all the query-replace data
type QReplace struct {

        // if true, in interactive search mode
        On bool `json:"-" xml:"-"`

        // current interactive search string
        Find string `json:"-" xml:"-"`

        // current interactive search string
        Replace string `json:"-" xml:"-"`

        // pay attention to case in isearch -- triggered by typing an upper-case letter
        useCase bool

        // search only as entire lexically tagged item boundaries -- key for replacing short local variables like i
        lexItems bool

        // current search matches
        Matches []textpos.Match `json:"-" xml:"-"`

        // position within isearch matches
        pos int `json:"-" xml:"-"`

        // starting position for search -- returns there after on cancel
        startPos textpos.Pos
}

var (
        // prevQReplaceFinds are the previous QReplace strings
        prevQReplaceFinds []string

        // prevQReplaceRepls are the previous QReplace strings
        prevQReplaceRepls []string
)

// qReplaceEvent sends the event that QReplace is updated
func (ed *Editor) qReplaceEvent() {
        ed.Send(events.Input)
}

// QReplacePrompt is an emacs-style query-replace mode -- this starts the process, prompting
// user for items to search etc
func (ed *Editor) QReplacePrompt() {
        find := ""
        if ed.HasSelection() {
                find = string(ed.Selection().ToBytes())
        }
        d := core.NewBody("Query-Replace")
        core.NewText(d).SetType(core.TextSupporting).SetText("Enter strings for find and replace, then select Query-Replace; with dialog dismissed press <b>y</b> to replace current match, <b>n</b> to skip, <b>Enter</b> or <b>q</b> to quit, <b>!</b> to replace-all remaining")
        fc := core.NewChooser(d).SetEditable(true).SetDefaultNew(true)
        fc.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 0)
                s.Min.X.Ch(80)
        })
        fc.SetStrings(prevQReplaceFinds...).SetCurrentIndex(0)
        if find != "" {
                fc.SetCurrentValue(find)
        }

        rc := core.NewChooser(d).SetEditable(true).SetDefaultNew(true)
        rc.Styler(func(s *styles.Style) {
                s.Grow.Set(1, 0)
                s.Min.X.Ch(80)
        })
        rc.SetStrings(prevQReplaceRepls...).SetCurrentIndex(0)

        lexitems := ed.QReplace.lexItems
        lxi := core.NewSwitch(d).SetText("Lexical Items").SetChecked(lexitems)
        lxi.SetTooltip("search matches entire lexically tagged items -- good for finding local variable names like 'i' and not matching everything")

        d.AddBottomBar(func(bar *core.Frame) {
                d.AddCancel(bar)
                d.AddOK(bar).SetText("Query-Replace").OnClick(func(e events.Event) {
                        var find, repl string
                        if s, ok := fc.CurrentItem.Value.(string); ok {
                                find = s
                        }
                        if s, ok := rc.CurrentItem.Value.(string); ok {
                                repl = s
                        }
                        lexItems := lxi.IsChecked()
                        ed.QReplaceStart(find, repl, lexItems)
                })
        })
        d.RunDialog(ed)
}

// QReplaceStart starts query-replace using given find, replace strings
func (ed *Editor) QReplaceStart(find, repl string, lexItems bool) {
        ed.QReplace.On = true
        ed.QReplace.Find = find
        ed.QReplace.Replace = repl
        ed.QReplace.lexItems = lexItems
        ed.QReplace.startPos = ed.CursorPos
        ed.QReplace.useCase = lexer.HasUpperCase(find)
        ed.QReplace.Matches = nil
        ed.QReplace.pos = -1

        stringsx.InsertFirstUnique(&prevQReplaceFinds, find, core.SystemSettings.SavedPathsMax)
        stringsx.InsertFirstUnique(&prevQReplaceRepls, repl, core.SystemSettings.SavedPathsMax)

        ed.qReplaceMatches()
        ed.QReplace.pos, _ = ed.matchFromPos(ed.QReplace.Matches, ed.CursorPos)
        ed.qReplaceSelectMatch(ed.QReplace.pos)
        ed.qReplaceEvent()
}

// qReplaceMatches finds QReplace matches -- returns true if there are any
func (ed *Editor) qReplaceMatches() bool {
        got := false
        ed.QReplace.Matches, got = ed.findMatches(ed.QReplace.Find, ed.QReplace.useCase, ed.QReplace.lexItems)
        return got
}

// qReplaceNextMatch finds next match using, QReplace.Pos and highlights it, etc
func (ed *Editor) qReplaceNextMatch() bool {
        nm := len(ed.QReplace.Matches)
        if nm == 0 {
                return false
        }
        ed.QReplace.pos++
        if ed.QReplace.pos >= nm {
                return false
        }
        ed.qReplaceSelectMatch(ed.QReplace.pos)
        return true
}

// qReplaceSelectMatch selects match at given match index (e.g., ed.QReplace.Pos)
func (ed *Editor) qReplaceSelectMatch(midx int) {
        nm := len(ed.QReplace.Matches)
        if midx >= nm {
                return
        }
        m := ed.QReplace.Matches[midx]
        reg := ed.Lines.AdjustRegion(m.Region)
        pos := reg.Start
        ed.SelectRegion = reg
        ed.setCursor(pos)
        ed.savePosHistory(ed.CursorPos)
        ed.scrollCursorToCenterIfHidden()
        ed.qReplaceEvent()
}

// qReplaceReplace replaces at given match index (e.g., ed.QReplace.Pos)
func (ed *Editor) qReplaceReplace(midx int) {
        nm := len(ed.QReplace.Matches)
        if midx >= nm {
                return
        }
        m := ed.QReplace.Matches[midx]
        rep := ed.QReplace.Replace
        reg := ed.Lines.AdjustRegion(m.Region)
        pos := reg.Start
        // last arg is matchCase, only if not using case to match and rep is also lower case
        matchCase := !ed.QReplace.useCase && !lexer.HasUpperCase(rep)
        ed.Lines.ReplaceText(reg.Start, reg.End, pos, rep, matchCase)
        ed.Highlights[midx] = textpos.Region{}
        ed.setCursor(pos)
        ed.savePosHistory(ed.CursorPos)
        ed.scrollCursorToCenterIfHidden()
        ed.qReplaceEvent()
}

// QReplaceReplaceAll replaces all remaining from index
func (ed *Editor) QReplaceReplaceAll(midx int) {
        nm := len(ed.QReplace.Matches)
        if midx >= nm {
                return
        }
        for mi := midx; mi < nm; mi++ {
                ed.qReplaceReplace(mi)
        }
}

// qReplaceKeyInput is an emacs-style interactive search mode -- this is called
// when keys are typed while in search mode
func (ed *Editor) qReplaceKeyInput(kt events.Event) {
        kt.SetHandled()
        switch {
        case kt.KeyRune() == 'y':
                ed.qReplaceReplace(ed.QReplace.pos)
                if !ed.qReplaceNextMatch() {
                        ed.qReplaceCancel()
                }
        case kt.KeyRune() == 'n':
                if !ed.qReplaceNextMatch() {
                        ed.qReplaceCancel()
                }
        case kt.KeyRune() == 'q' || kt.KeyChord() == "ReturnEnter":
                ed.qReplaceCancel()
        case kt.KeyRune() == '!':
                ed.QReplaceReplaceAll(ed.QReplace.pos)
                ed.qReplaceCancel()
        }
        ed.NeedsRender()
}

// qReplaceCancel cancels QReplace mode
func (ed *Editor) qReplaceCancel() {
        if !ed.QReplace.On {
                return
        }
        ed.QReplace.On = false
        ed.QReplace.pos = -1
        ed.QReplace.Matches = nil
        ed.Highlights = nil
        ed.savePosHistory(ed.CursorPos)
        ed.SelectReset()
        ed.qReplaceEvent()
        ed.NeedsRender()
}

// escPressed emitted for [keymap.Abort] or [keymap.CancelSelect];
// effect depends on state.
func (ed *Editor) escPressed() {
        switch {
        case ed.ISearch.On:
                ed.iSearchCancel()
                ed.SetCursorShow(ed.ISearch.startPos)
        case ed.QReplace.On:
                ed.qReplaceCancel()
                ed.SetCursorShow(ed.ISearch.startPos)
        case ed.HasSelection():
                ed.SelectReset()
        default:
                ed.Highlights = nil
        }
        ed.NeedsRender()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "fmt"

        "cogentcore.org/core/core"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/textpos"
)

// maxGrowLines is the maximum number of lines to grow to
// (subject to other styling constraints).
const maxGrowLines = 25

// styleSizes gets the charSize based on Style settings,
// and updates lineNumberOffset.
func (ed *Base) styleSizes() {
        ed.lineNumberDigits = max(1+int(math32.Log10(float32(ed.NumLines()))), 3)
        sty, tsty := ed.Styles.NewRichText()
        lno := true
        if ed.Lines != nil {
                lno = ed.Lines.Settings.LineNumbers
                ed.Lines.SetFontStyle(sty)
        }
        if lno {
                ed.hasLineNumbers = true
                ed.lineNumberOffset = ed.lineNumberDigits + 2
        } else {
                ed.hasLineNumbers = false
                ed.lineNumberOffset = 0
        }

        if ed.Scene == nil {
                ed.charSize.Set(16, 22)
                return
        }
        sh := ed.Scene.TextShaper()
        if sh != nil {
                lht := ed.Styles.LineHeightDots()
                tx := rich.NewText(sty, []rune{'M'})
                r := sh.Shape(tx, tsty, &rich.DefaultSettings)
                ed.charSize.X = math32.Round(r[0].Advance())
                ed.charSize.Y = lht
        }
}

// visSizeFromAlloc updates visSize based on allocated size.
func (ed *Base) visSizeFromAlloc() {
        asz := ed.Geom.Size.Alloc.Content
        sbw := math32.Ceil(ed.Styles.ScrollbarWidth.Dots)
        if ed.HasScroll[math32.Y] {
                asz.X -= sbw
        }
        if ed.HasScroll[math32.X] {
                asz.Y -= sbw
        }
        ed.visSizeAlloc = asz
        ed.visSize.Y = int(math32.Floor(float32(asz.Y) / ed.charSize.Y))
        ed.visSize.X = int(math32.Floor(float32(asz.X) / ed.charSize.X))
        // fmt.Println("vis size:", ed.visSize, "alloc:", asz, "charSize:", ed.charSize, "grow:", sty.Grow)
}

// layoutAllLines uses the visSize width to update the line wrapping
// of the Lines text, getting the total height.
func (ed *Base) layoutAllLines() {
        ed.visSizeFromAlloc()
        if ed.visSize.Y == 0 || ed.Lines == nil || ed.Lines.NumLines() == 0 {
                return
        }
        ed.lastFilename = ed.Lines.Filename()
        sty := &ed.Styles
        buf := ed.Lines
        // todo: self-lock method for this, and general better api
        buf.Highlighter.TabSize = sty.Text.TabSize

        // todo: may want to support horizontal scroll and min width
        ed.linesSize.X = ed.visSize.X - ed.lineNumberOffset // width
        buf.SetWidth(ed.viewId, ed.linesSize.X)             // inexpensive if same, does update
        ed.linesSize.Y = buf.ViewLines(ed.viewId)
        ed.totalSize.X = ed.charSize.X * float32(ed.visSize.X)
        ed.totalSize.Y = ed.charSize.Y * float32(ed.linesSize.Y)
        ed.lineRenders = make([]renderCache, ed.visSize.Y+1)
        ed.lineNoRenders = make([]renderCache, ed.visSize.Y+1)

        // ed.hasLinks = false // todo: put on lines
        ed.lastVisSizeAlloc = ed.visSizeAlloc
}

// reLayoutAllLines updates the Renders Layout given current size, if changed
func (ed *Base) reLayoutAllLines() {
        ed.visSizeFromAlloc()
        if ed.visSize.Y == 0 || ed.Lines == nil || ed.Lines.NumLines() == 0 {
                return
        }
        if ed.lastVisSizeAlloc == ed.visSizeAlloc {
                return
        }
        ed.layoutAllLines()
}

// note: Layout reverts to basic Widget behavior for layout if no kids, like us..

// sizeToLines sets the Actual.Content size based on number of lines of text,
// subject to maxGrowLines, for the non-grow case.
func (ed *Base) sizeToLines() {
        if ed.Styles.Grow.Y > 0 {
                return
        }
        nln := ed.Lines.ViewLines(ed.viewId)
        // if ed.linesSize.Y > 0 { // we have already been through layout
        //         nln = ed.linesSize.Y
        // }
        nln = min(maxGrowLines, nln)
        maxh := float32(nln) * ed.charSize.Y
        sz := &ed.Geom.Size
        ty := styles.ClampMin(styles.ClampMax(maxh, sz.Max.Y), sz.Min.Y)
        sz.Actual.Content.Y = ty
        sz.Actual.Total.Y = sz.Actual.Content.Y + sz.Space.Y
        if core.DebugSettings.LayoutTrace {
                fmt.Println(ed, "textcore.Base sizeToLines targ:", ty, "nln:", nln, "Actual:", sz.Actual.Content)
        }
}

func (ed *Base) SizeUp() {
        ed.Frame.SizeUp() // sets Actual size based on styles
        if ed.Lines == nil || ed.Lines.NumLines() == 0 {
                return
        }
        ed.sizeToLines()
}

func (ed *Base) SizeDown(iter int) bool {
        if iter == 0 {
                if ed.NeedsRebuild() && ed.Lines != nil {
                        ed.Lines.ReMarkup()
                }
                ed.layoutAllLines()
        } else {
                ed.reLayoutAllLines()
        }
        ed.sizeToLines()
        redo := ed.Frame.SizeDown(iter)
        chg := ed.ManageOverflow(iter, true)
        if !ed.HasScroll[math32.Y] {
                ed.scrollPos = 0
        }
        return redo || chg
}

func (ed *Base) SizeFinal() {
        ed.Frame.SizeFinal()
        ed.reLayoutAllLines()
}

func (ed *Base) Position() {
        ed.Frame.Position()
        ed.ConfigScrolls()
}

func (ed *Base) ApplyScenePos() {
        ed.Frame.ApplyScenePos()
        ed.PositionScrolls()
}

func (ed *Base) ScrollValues(d math32.Dims) (maxSize, visSize, visPct float32) {
        if d == math32.X {
                return ed.Frame.ScrollValues(d)
        }
        maxSize = float32(max(ed.linesSize.Y, 1)) * ed.charSize.Y
        visSize = float32(ed.visSize.Y) * ed.charSize.Y
        visPct = visSize / maxSize
        // fmt.Println("scroll values:", maxSize, visSize, visPct)
        return
}

func (ed *Base) ScrollChanged(d math32.Dims, sb *core.Slider) {
        ed.isScrolling = true
        if d == math32.X {
                ed.Frame.ScrollChanged(d, sb)
                return
        }
        ed.scrollPos = sb.Value / ed.charSize.Y
        ed.lineRenders = make([]renderCache, ed.visSize.Y+1)
        ed.lineNoRenders = make([]renderCache, ed.visSize.Y+1)
        ed.NeedsRender()
}

func (ed *Base) SetScrollParams(d math32.Dims, sb *core.Slider) {
        if d == math32.X {
                ed.Frame.SetScrollParams(d, sb)
                return
        }
        sb.Min = 0
        sb.Step = 1
        if ed.visSize.Y > 0 {
                sb.PageStep = float32(ed.visSize.Y) * ed.charSize.Y
        }
}

// updateScroll sets the scroll position to given value, in lines.
// calls a NeedsRender if changed.
func (ed *Base) updateScroll(pos float32) bool {
        if !ed.HasScroll[math32.Y] || ed.Scrolls[math32.Y] == nil {
                return false
        }
        if pos < 0 {
                pos = 0
        }
        ed.scrollPos = pos
        ppos := pos * ed.charSize.Y
        sb := ed.Scrolls[math32.Y]
        if sb.Value != ppos {
                ed.isScrolling = true
                sb.SetValue(ppos)
                ed.NeedsRender()
                return true
        }
        return false
}

////////    Scrolling -- Vertical

// scrollLineToTop positions scroll so that the line of given source position
// is at the top (to the extent possible).
func (ed *Base) scrollLineToTop(pos textpos.Pos) bool {
        vp := ed.Lines.PosToView(ed.viewId, pos)
        return ed.updateScroll(float32(vp.Line))
}

// scrollCursorToTop positions scroll so the cursor line is at the top.
func (ed *Base) scrollCursorToTop() bool {
        return ed.scrollLineToTop(ed.CursorPos)
}

// scrollLineToBottom positions scroll so that the line of given source position
// is at the bottom (to the extent possible).
func (ed *Base) scrollLineToBottom(pos textpos.Pos) bool {
        vp := ed.Lines.PosToView(ed.viewId, pos)
        return ed.updateScroll(float32(vp.Line - ed.visSize.Y + 1))
}

// scrollCursorToBottom positions scroll so cursor line is at the bottom.
func (ed *Base) scrollCursorToBottom() bool {
        return ed.scrollLineToBottom(ed.CursorPos)
}

// scrollLineToCenter positions scroll so that the line of given source position
// is at the center (to the extent possible).
func (ed *Base) scrollLineToCenter(pos textpos.Pos) bool {
        vp := ed.Lines.PosToView(ed.viewId, pos)
        return ed.updateScroll(float32(max(vp.Line-ed.visSize.Y/2, 0)))
}

func (ed *Base) scrollCursorToCenter() bool {
        return ed.scrollLineToCenter(ed.CursorPos)
}

func (ed *Base) scrollCursorToTarget() {
        // fmt.Println(ed, "to target:", ed.CursorTarg)
        ed.targetSet = false
        if ed.cursorTarget == textpos.PosErr {
                ed.cursorEndDoc()
                return
        }
        ed.CursorPos = ed.cursorTarget
        ed.scrollCursorToCenter()
}

// scrollToCenterIfHidden checks if the given position is not in view,
// and scrolls to center if so. returns false if in view already.
func (ed *Base) scrollToCenterIfHidden(pos textpos.Pos) bool {
        if ed.Lines == nil {
                return false
        }
        vp := ed.Lines.PosToView(ed.viewId, pos)
        spos := ed.Geom.ContentBBox.Min.X + int(ed.LineNumberPixels())
        epos := ed.Geom.ContentBBox.Max.X
        csp := ed.charStartPos(pos).ToPoint()
        if vp.Line >= int(ed.scrollPos) && vp.Line < int(ed.scrollPos)+ed.visSize.Y {
                if csp.X >= spos && csp.X < epos {
                        return false
                }
        } else {
                ed.scrollLineToCenter(pos)
        }
        if csp.X < spos {
                ed.scrollCursorToRight()
        } else if csp.X > epos {
                // ed.scrollCursorToLeft()
        }
        return true
}

// scrollCursorToCenterIfHidden checks if the cursor position is not in view,
// and scrolls to center if so. returns false if in view already.
func (ed *Base) scrollCursorToCenterIfHidden() bool {
        return ed.scrollToCenterIfHidden(ed.CursorPos)
}

////////    Scrolling -- Horizontal

// scrollToRight tells any parent scroll layout to scroll to get given
// horizontal coordinate at right of view to extent possible -- returns true
// if scrolled
func (ed *Base) scrollToRight(pos int) bool {
        return ed.ScrollDimToEnd(math32.X, pos)
}

// scrollCursorToRight tells any parent scroll layout to scroll to get cursor
// at right of view to extent possible -- returns true if scrolled.
func (ed *Base) scrollCursorToRight() bool {
        curBBox := ed.cursorBBox(ed.CursorPos)
        return ed.scrollToRight(curBBox.Max.X)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "cogentcore.org/core/system"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/textpos"
)

// openLink opens given link, using the LinkHandler if non-nil,
// or the default system.TheApp.OpenURL() which will open a browser.
func (ed *Base) openLink(tl *rich.Hyperlink) {
        if ed.LinkHandler != nil {
                ed.LinkHandler(tl)
        } else {
                system.TheApp.OpenURL(tl.URL)
        }
}

// linkAt returns hyperlink at given source position, if one exists there,
// otherwise returns nil.
func (ed *Base) linkAt(pos textpos.Pos) (*rich.Hyperlink, int) {
        lk := ed.Lines.LinkAt(pos)
        if lk == nil {
                return nil, -1
        }
        return lk, pos.Line
}

// OpenLinkAt opens a link at given cursor position, if one exists there.
// returns the link if found, else nil. Also highlights the selected link.
func (ed *Base) OpenLinkAt(pos textpos.Pos) (*rich.Hyperlink, int) {
        tl, ln := ed.linkAt(pos)
        if tl == nil {
                return nil, -1
        }
        ed.HighlightsReset()
        reg := ed.highlightLink(tl, ln)
        ed.SetCursorShow(reg.Start)
        ed.openLink(tl)
        return tl, pos.Line
}

// highlightLink highlights given hyperlink
func (ed *Base) highlightLink(lk *rich.Hyperlink, ln int) textpos.Region {
        reg := textpos.NewRegion(ln, lk.Range.Start, ln, lk.Range.End)
        ed.HighlightRegion(reg)
        return reg
}

// CursorNextLink moves cursor to next link. wraparound wraps around to top of
// buffer if none found -- returns true if found
func (ed *Base) CursorNextLink(wraparound bool) bool {
        if ed.NumLines() == 0 {
                return false
        }
        ed.validateCursor()
        nl, ln := ed.Lines.NextLink(ed.CursorPos)
        if nl == nil {
                if !wraparound {
                        return false
                }
                nl, ln = ed.Lines.NextLink(textpos.Pos{}) // wraparound
                if nl == nil {
                        return false
                }
        }
        ed.HighlightsReset()
        reg := ed.highlightLink(nl, ln)
        ed.SetCursorTarget(reg.Start)
        ed.savePosHistory(reg.Start)
        ed.NeedsRender()
        return true
}

// CursorPrevLink moves cursor to next link. wraparound wraps around to bottom of
// buffer if none found -- returns true if found
func (ed *Base) CursorPrevLink(wraparound bool) bool {
        if ed.NumLines() == 0 {
                return false
        }
        ed.validateCursor()
        nl, ln := ed.Lines.PrevLink(ed.CursorPos)
        if nl == nil {
                if !wraparound {
                        return false
                }
                nl, ln = ed.Lines.PrevLink(ed.Lines.EndPos()) // wraparound
                if nl == nil {
                        return false
                }
        }
        ed.HighlightsReset()
        reg := ed.highlightLink(nl, ln)
        ed.SetCursorTarget(reg.Start)
        ed.savePosHistory(reg.Start)
        ed.NeedsRender()
        return true
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "image"

        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/text/textpos"
)

// validateCursor sets current cursor to a valid cursor position
func (ed *Base) validateCursor() textpos.Pos {
        if ed.Lines != nil {
                ed.CursorPos = ed.Lines.ValidPos(ed.CursorPos)
        } else {
                ed.CursorPos = textpos.Pos{}
        }
        return ed.CursorPos
}

// setCursor sets a new cursor position, enforcing it in range.
// This is the main final pathway for all cursor movement.
func (ed *Base) setCursor(pos textpos.Pos) {
        if ed.Lines == nil {
                ed.CursorPos = textpos.PosZero
                return
        }
        ed.scopelightsReset()
        ed.CursorPos = ed.Lines.ValidPos(pos)
        bm, has := ed.Lines.BraceMatch(pos)
        if has {
                ed.addScopelights(pos, bm)
                ed.NeedsRender()
        }
}

// SetCursorShow sets a new cursor position, enforcing it in range, and shows
// the cursor (scroll to if hidden, render)
func (ed *Base) SetCursorShow(pos textpos.Pos) {
        ed.setCursor(pos)
        ed.scrollCursorToCenterIfHidden()
        ed.renderCursor(true)
}

// SetCursorTarget sets a new cursor target position, ensures that it is visible.
// Setting the textpos.PosErr value causes it to go the end of doc, the position
// of which may not be known at the time the target is set.
func (ed *Base) SetCursorTarget(pos textpos.Pos) {
        ed.isScrolling = false
        ed.targetSet = true
        ed.cursorTarget = pos
        if pos == textpos.PosErr {
                ed.cursorEndDoc()
                return
        }
        ed.SetCursorShow(pos)
        // fmt.Println(ed, "set target:", ed.CursorTarg)
}

// savePosHistory saves the cursor position in history stack of cursor positions.
// Tracks across views. Returns false if position was on same line as last one saved.
func (ed *Base) savePosHistory(pos textpos.Pos) bool {
        if ed.Lines == nil {
                return false
        }
        did := ed.Lines.PosHistorySave(pos)
        if did {
                ed.posHistoryIndex = ed.Lines.PosHistoryLen() - 1
        }
        return did
}

// CursorToHistoryPrev moves cursor to previous position on history list.
// returns true if moved
func (ed *Base) CursorToHistoryPrev() bool {
        if ed.Lines == nil {
                ed.CursorPos = textpos.Pos{}
                return false
        }
        sz := ed.Lines.PosHistoryLen()
        if sz == 0 {
                return false
        }
        if ed.posHistoryIndex < 0 {
                ed.posHistoryIndex = 0
                return false
        }
        ed.posHistoryIndex = min(sz-1, ed.posHistoryIndex)
        pos, _ := ed.Lines.PosHistoryAt(ed.posHistoryIndex)
        ed.CursorPos = ed.Lines.ValidPos(pos)
        if ed.posHistoryIndex > 0 {
                ed.posHistoryIndex--
        }
        ed.scrollCursorToCenterIfHidden()
        ed.renderCursor(true)
        ed.SendInput()
        return true
}

// CursorToHistoryNext moves cursor to previous position on history list --
// returns true if moved
func (ed *Base) CursorToHistoryNext() bool {
        if ed.Lines == nil {
                ed.CursorPos = textpos.Pos{}
                return false
        }
        sz := ed.Lines.PosHistoryLen()
        if sz == 0 {
                return false
        }
        ed.posHistoryIndex++
        if ed.posHistoryIndex >= sz-1 {
                ed.posHistoryIndex = sz - 1
        }
        pos, _ := ed.Lines.PosHistoryAt(ed.posHistoryIndex)
        ed.CursorPos = ed.Lines.ValidPos(pos)
        ed.scrollCursorToCenterIfHidden()
        ed.renderCursor(true)
        ed.SendInput()
        return true
}

// setCursorColumn sets the current target cursor column (cursorColumn) to that
// of the given position
func (ed *Base) setCursorColumn(pos textpos.Pos) {
        if ed.Lines == nil {
                return
        }
        vpos := ed.Lines.PosToView(ed.viewId, pos)
        ed.cursorColumn = vpos.Char
}

////////  cursor moving

// cursorSelect updates selection based on cursor movements, given starting
// cursor position and ed.CursorPos is current
func (ed *Base) cursorSelect(org textpos.Pos) {
        if !ed.selectMode {
                return
        }
        ed.selectRegionUpdate(ed.CursorPos)
}

// cursorSelectShow does SetCursorShow, cursorSelect, and NeedsRender.
// This is typically called for move actions.
func (ed *Base) cursorSelectShow(org textpos.Pos) {
        ed.SetCursorShow(ed.CursorPos)
        ed.cursorSelect(org)
        ed.SendInput()
        ed.NeedsRender()
}

// cursorForward moves the cursor forward
func (ed *Base) cursorForward(steps int) {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.MoveForward(org, steps)
        ed.setCursorColumn(ed.CursorPos)
        ed.cursorSelectShow(org)
}

// cursorForwardWord moves the cursor forward by words
func (ed *Base) cursorForwardWord(steps int) {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.MoveForwardWord(org, steps)
        ed.setCursorColumn(ed.CursorPos)
        ed.cursorSelectShow(org)
}

// cursorBackward moves the cursor backward
func (ed *Base) cursorBackward(steps int) {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.MoveBackward(org, steps)
        ed.setCursorColumn(ed.CursorPos)
        ed.cursorSelectShow(org)
}

// cursorBackwardWord moves the cursor backward by words
func (ed *Base) cursorBackwardWord(steps int) {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.MoveBackwardWord(org, steps)
        ed.setCursorColumn(ed.CursorPos)
        ed.cursorSelectShow(org)
}

// cursorDown moves the cursor down line(s)
func (ed *Base) cursorDown(steps int) {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.MoveDown(ed.viewId, org, steps, ed.cursorColumn)
        ed.cursorSelectShow(org)
}

// cursorPageDown moves the cursor down page(s), where a page is defined
// dynamically as just moving the cursor off the screen
func (ed *Base) cursorPageDown(steps int) {
        org := ed.validateCursor()
        vp := ed.Lines.PosToView(ed.viewId, ed.CursorPos)
        cpr := max(0, vp.Line-int(ed.scrollPos))
        nln := max(1, ed.visSize.Y-cpr)
        for range steps {
                ed.CursorPos = ed.Lines.MoveDown(ed.viewId, ed.CursorPos, nln, ed.cursorColumn)
        }
        ed.setCursor(ed.CursorPos)
        ed.scrollCursorToTop()
        ed.renderCursor(true)
        ed.cursorSelect(org)
        ed.SendInput()
        ed.NeedsRender()
}

// cursorUp moves the cursor up line(s)
func (ed *Base) cursorUp(steps int) {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.MoveUp(ed.viewId, org, steps, ed.cursorColumn)
        ed.cursorSelectShow(org)
}

// cursorPageUp moves the cursor up page(s), where a page is defined
// dynamically as just moving the cursor off the screen
func (ed *Base) cursorPageUp(steps int) {
        org := ed.validateCursor()
        vp := ed.Lines.PosToView(ed.viewId, ed.CursorPos)
        cpr := max(0, vp.Line-int(ed.scrollPos))
        nln := max(1, cpr)
        for range steps {
                ed.CursorPos = ed.Lines.MoveUp(ed.viewId, ed.CursorPos, nln, ed.cursorColumn)
        }
        ed.setCursor(ed.CursorPos)
        ed.scrollCursorToBottom()
        ed.renderCursor(true)
        ed.cursorSelect(org)
        ed.SendInput()
        ed.NeedsRender()
}

// cursorRecenter re-centers the view around the cursor position, toggling
// between putting cursor in middle, top, and bottom of view
func (ed *Base) cursorRecenter() {
        ed.validateCursor()
        ed.savePosHistory(ed.CursorPos)
        cur := (ed.lastRecenter + 1) % 3
        switch cur {
        case 0:
                ed.scrollCursorToBottom()
        case 1:
                ed.scrollCursorToCenter()
        case 2:
                ed.scrollCursorToTop()
        }
        ed.lastRecenter = cur
}

// cursorLineStart moves the cursor to the start of the line, updating selection
// if select mode is active
func (ed *Base) cursorLineStart() {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.MoveLineStart(ed.viewId, org)
        ed.cursorColumn = 0
        ed.scrollCursorToRight()
        ed.cursorSelectShow(org)
}

// CursorStartDoc moves the cursor to the start of the text, updating selection
// if select mode is active
func (ed *Base) CursorStartDoc() {
        org := ed.validateCursor()
        ed.CursorPos.Line = 0
        ed.CursorPos.Char = 0
        ed.cursorColumn = 0
        ed.scrollCursorToTop()
        ed.cursorSelectShow(org)
}

// cursorLineEnd moves the cursor to the end of the text
func (ed *Base) cursorLineEnd() {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.MoveLineEnd(ed.viewId, org)
        ed.setCursorColumn(ed.CursorPos)
        ed.scrollCursorToRight()
        ed.cursorSelectShow(org)
}

// cursorEndDoc moves the cursor to the end of the text, updating selection if
// select mode is active
func (ed *Base) cursorEndDoc() {
        org := ed.validateCursor()
        ed.CursorPos = ed.Lines.EndPos()
        ed.setCursorColumn(ed.CursorPos)
        ed.scrollCursorToBottom()
        ed.cursorSelectShow(org)
}

// todo: ctrl+backspace = delete word
// shift+arrow = select
// uparrow = start / down = end

// cursorBackspace deletes character(s) immediately before cursor
func (ed *Base) cursorBackspace(steps int) {
        org := ed.validateCursor()
        if ed.HasSelection() {
                org = ed.SelectRegion.Start
                ed.deleteSelection()
                ed.SetCursorShow(org)
                return
        }
        // note: no update b/c signal from buf will drive update
        ed.cursorBackward(steps)
        ed.scrollCursorToCenterIfHidden()
        ed.renderCursor(true)
        ed.Lines.DeleteText(ed.CursorPos, org)
        ed.NeedsRender()
}

// cursorDelete deletes character(s) immediately after the cursor
func (ed *Base) cursorDelete(steps int) {
        org := ed.validateCursor()
        if ed.HasSelection() {
                ed.deleteSelection()
                return
        }
        // note: no update b/c signal from buf will drive update
        ed.cursorForward(steps)
        ed.Lines.DeleteText(org, ed.CursorPos)
        ed.SetCursorShow(org)
        ed.NeedsRender()
}

// cursorBackspaceWord deletes words(s) immediately before cursor
func (ed *Base) cursorBackspaceWord(steps int) {
        org := ed.validateCursor()
        if ed.HasSelection() {
                ed.deleteSelection()
                ed.SetCursorShow(org)
                return
        }
        ed.cursorBackwardWord(steps)
        ed.scrollCursorToCenterIfHidden()
        ed.renderCursor(true)
        ed.Lines.DeleteText(ed.CursorPos, org)
        ed.NeedsRender()
}

// cursorDeleteWord deletes word(s) immediately after the cursor
func (ed *Base) cursorDeleteWord(steps int) {
        org := ed.validateCursor()
        if ed.HasSelection() {
                ed.deleteSelection()
                return
        }
        ed.cursorForwardWord(steps)
        ed.Lines.DeleteText(org, ed.CursorPos)
        ed.SetCursorShow(org)
        ed.NeedsRender()
}

// cursorKill deletes text from cursor to end of text.
// if line is empty, deletes the line.
func (ed *Base) cursorKill() {
        org := ed.validateCursor()
        llen := ed.Lines.LineLen(ed.CursorPos.Line)
        if ed.CursorPos.Char == llen { // at end
                ed.cursorForward(1)
        } else {
                ed.cursorLineEnd()
        }
        ed.Lines.DeleteText(org, ed.CursorPos)
        ed.SetCursorShow(org)
        ed.NeedsRender()
}

// cursorTranspose swaps the character at the cursor with the one before it.
func (ed *Base) cursorTranspose() {
        ed.validateCursor()
        pos := ed.CursorPos
        if pos.Char == 0 {
                return
        }
        ed.Lines.TransposeChar(ed.viewId, pos)
        // ed.SetCursorShow(pos)
        ed.NeedsRender()
}

// cursorTranspose swaps the character at the cursor with the one before it
func (ed *Base) cursorTransposeWord() {
        // todo:
}

// setCursorFromMouse sets cursor position from mouse mouse action -- handles
// the selection updating etc.
func (ed *Base) setCursorFromMouse(pt image.Point, newPos textpos.Pos, selMode events.SelectModes) {
        oldPos := ed.CursorPos
        if newPos == oldPos || newPos == textpos.PosErr {
                return
        }
        //        fmt.Printf("set cursor fm mouse: %v\n", newPos)
        defer ed.NeedsRender()

        if !ed.selectMode && selMode == events.ExtendContinuous {
                if ed.SelectRegion == (textpos.Region{}) {
                        ed.selectStart = ed.CursorPos
                }
                ed.setCursor(newPos)
                ed.selectRegionUpdate(ed.CursorPos)
                ed.renderCursor(true)
                return
        }

        ed.setCursor(newPos)
        if ed.selectMode || selMode != events.SelectOne {
                if !ed.selectMode && selMode != events.SelectOne {
                        ed.selectMode = true
                        ed.selectStart = newPos
                        ed.selectRegionUpdate(ed.CursorPos)
                }
                if !ed.StateIs(states.Sliding) && selMode == events.SelectOne {
                        ln := ed.CursorPos.Line
                        ch := ed.CursorPos.Char
                        if ln != ed.SelectRegion.Start.Line || ch < ed.SelectRegion.Start.Char || ch > ed.SelectRegion.End.Char {
                                ed.SelectReset()
                        }
                } else {
                        ed.selectRegionUpdate(ed.CursorPos)
                }
                if ed.StateIs(states.Sliding) {
                        scPos := math32.FromPoint(pt) // already relative to editor
                        ed.AutoScroll(scPos)
                } else {
                        ed.scrollCursorToCenterIfHidden()
                }
        } else if ed.HasSelection() {
                ln := ed.CursorPos.Line
                ch := ed.CursorPos.Char
                if ln != ed.SelectRegion.Start.Line || ch < ed.SelectRegion.Start.Char || ch > ed.SelectRegion.End.Char {
                        ed.SelectReset()
                }
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "bufio"
        "io"
        "sync"
        "time"

        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/rich"
)

// OutputBufferMarkupFunc is a function that returns a marked-up version
// of a given line of output text. It is essential that it not add any
// new text, just splits into spans with different styles.
type OutputBufferMarkupFunc func(buf *lines.Lines, line []rune) rich.Text

// OutputBuffer is a buffer that records the output from an [io.Reader] using
// [bufio.Scanner]. It is optimized to combine fast chunks of output into
// large blocks of updating. It also supports an arbitrary markup function
// that operates on each line of output text.
type OutputBuffer struct { //types:add -setters

        // the output that we are reading from, as an io.Reader
        Output io.Reader

        // the [lines.Lines] that we output to
        Lines *lines.Lines

        // how much time to wait while batching output (default: 200ms)
        Batch time.Duration

        // MarkupFunc is an optional markup function that adds html tags to given line
        // of output. It is essential that it not add any new text, just splits into spans
        // with different styles.
        MarkupFunc OutputBufferMarkupFunc

        // current buffered output raw lines, which are not yet sent to the Buffer
        bufferedLines [][]rune

        // current buffered output markup lines, which are not yet sent to the Buffer
        bufferedMarkup []rich.Text

        // time when last output was sent to buffer
        lastOutput time.Time

        // time.AfterFunc that is started after new input is received and not
        // immediately output. Ensures that it will get output if no further burst happens.
        afterTimer *time.Timer

        // mutex protecting updates
        sync.Mutex
}

// MonitorOutput monitors the output and updates the [Buffer].
func (ob *OutputBuffer) MonitorOutput() {
        if ob.Batch == 0 {
                ob.Batch = 200 * time.Millisecond
        }
        sty := ob.Lines.FontStyle()
        ob.bufferedLines = make([][]rune, 0, 100)
        ob.bufferedMarkup = make([]rich.Text, 0, 100)
        outscan := bufio.NewScanner(ob.Output) // line at a time
        for outscan.Scan() {
                ob.Lock()
                b := outscan.Bytes()
                rln := []rune(string(b))

                if ob.afterTimer != nil {
                        ob.afterTimer.Stop()
                        ob.afterTimer = nil
                }
                ob.bufferedLines = append(ob.bufferedLines, rln)
                if ob.MarkupFunc != nil {
                        mup := ob.MarkupFunc(ob.Lines, rln)
                        ob.bufferedMarkup = append(ob.bufferedMarkup, mup)
                } else {
                        mup := rich.NewText(sty, rln)
                        ob.bufferedMarkup = append(ob.bufferedMarkup, mup)
                }
                lag := time.Since(ob.lastOutput)
                if lag > ob.Batch {
                        ob.lastOutput = time.Now()
                        ob.outputToBuffer()
                } else {
                        ob.afterTimer = time.AfterFunc(ob.Batch*2, func() {
                                ob.Lock()
                                ob.lastOutput = time.Now()
                                ob.outputToBuffer()
                                ob.afterTimer = nil
                                ob.Unlock()
                        })
                }
                ob.Unlock()
        }
        ob.Lock()
        ob.outputToBuffer()
        ob.Unlock()
}

// outputToBuffer sends the current output to Buffer.
// MUST be called under mutex protection
func (ob *OutputBuffer) outputToBuffer() {
        if len(ob.bufferedLines) == 0 {
                return
        }
        ob.Lines.SetUndoOn(false)
        ob.Lines.AppendTextMarkup(ob.bufferedLines, ob.bufferedMarkup)
        ob.bufferedLines = make([][]rune, 0, 100)
        ob.bufferedMarkup = make([]rich.Text, 0, 100)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "fmt"
        "image"
        "image/color"
        "slices"

        "cogentcore.org/core/colors"
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/colors/matcolor"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/paint/render"
        "cogentcore.org/core/styles/sides"
        "cogentcore.org/core/styles/states"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/text/shaped"
        "cogentcore.org/core/text/textpos"
)

func (ed *Base) reLayout() {
        if ed.Lines == nil {
                return
        }
        prevLines := ed.linesSize.Y
        lns := ed.Lines.ViewLines(ed.viewId)
        if lns == prevLines {
                return
        }
        ed.layoutAllLines()
        chg := ed.ManageOverflow(1, true)
        if ed.Styles.Grow.Y == 0 && lns < maxGrowLines || prevLines < maxGrowLines {
                chg = prevLines != ed.linesSize.Y || chg
        }
        if chg {
                // fmt.Println(chg, lns, prevLines, ed.visSize.Y, ed.linesSize.Y)
                ed.NeedsLayout()
                if !ed.HasScroll[math32.Y] {
                        ed.scrollPos = 0
                }
        }
}

func (ed *Base) RenderWidget() {
        if ed.StartRender() {
                ed.reLayout()
                if ed.targetSet {
                        ed.scrollCursorToTarget()
                }
                if !ed.isScrolling {
                        ed.scrollCursorToCenterIfHidden()
                }
                ed.PositionScrolls()
                ed.renderLines()
                if ed.StateIs(states.Focused) {
                        ed.startCursor()
                } else {
                        ed.stopCursor()
                }
                ed.RenderChildren()
                ed.RenderScrolls()
                ed.EndRender()
        } else {
                ed.stopCursor()
        }
}

// renderBBox is the bounding box for the text render area (ContentBBox)
func (ed *Base) renderBBox() image.Rectangle {
        return ed.Geom.ContentBBox
}

// renderLineStartEnd returns the starting and ending (inclusive) lines to render
// based on the scroll position. Also returns the starting upper left position
// for rendering the first line.
func (ed *Base) renderLineStartEnd() (stln, edln int, spos math32.Vector2) {
        spos = ed.Geom.Pos.Content
        stln = int(math32.Floor(ed.scrollPos))
        spos.Y += (float32(stln) - ed.scrollPos) * ed.charSize.Y
        edln = min(ed.linesSize.Y-1, stln+ed.visSize.Y)
        return
}

// posIsVisible returns true if given position is visible,
// in terms of the vertical lines in view.
func (ed *Base) posIsVisible(pos textpos.Pos) bool {
        if ed.Lines == nil {
                return false
        }
        vpos := ed.Lines.PosToView(ed.viewId, pos)
        sp := int(math32.Floor(ed.scrollPos))
        return vpos.Line >= sp && vpos.Line <= sp+ed.visSize.Y
}

// renderLines renders the visible lines and line numbers.
func (ed *Base) renderLines() {
        ed.RenderStandardBox()
        if ed.Lines == nil {
                return
        }
        bb := ed.renderBBox()
        stln, edln, spos := ed.renderLineStartEnd()
        pc := &ed.Scene.Painter
        pc.PushContext(nil, render.NewBoundsRect(bb, sides.NewFloats()))

        if ed.hasLineNumbers {
                ed.renderLineNumbersBox()
                li := 0
                lastln := -1
                for ln := stln; ln <= edln; ln++ {
                        sp := ed.Lines.PosFromView(ed.viewId, textpos.Pos{Line: ln})
                        if sp.Char == 0 && sp.Line != lastln { // Char=0 is start of source line
                                // but also get 0 for out-of-range..
                                ed.renderLineNumber(spos, li, sp.Line)
                                lastln = sp.Line
                        }
                        li++
                }
        }

        ed.renderDepthBackground(spos, stln, edln)
        if ed.hasLineNumbers {
                tbb := bb
                tbb.Min.X += int(ed.LineNumberPixels())
                pc.PushContext(nil, render.NewBoundsRect(tbb, sides.NewFloats()))
        }

        buf := ed.Lines
        rpos := spos
        rpos.X += ed.LineNumberPixels()
        vsel := buf.RegionToView(ed.viewId, ed.SelectRegion)
        rtoview := func(rs []textpos.Region) []textpos.Region {
                if len(rs) == 0 {
                        return nil
                }
                hlts := make([]textpos.Region, 0, len(rs))
                for _, reg := range rs {
                        reg := ed.Lines.AdjustRegion(reg)
                        if !reg.IsNil() {
                                hlts = append(hlts, buf.RegionToView(ed.viewId, reg))
                        }
                }
                return hlts
        }
        hlts := rtoview(ed.Highlights)
        slts := rtoview(ed.scopelights)
        hlts = append(hlts, slts...)
        buf.Lock()
        li := 0
        for ln := stln; ln <= edln; ln++ {
                ed.renderLine(li, ln, rpos, vsel, hlts)
                rpos.Y += ed.charSize.Y
                li++
        }
        buf.Unlock()
        if ed.hasLineNumbers {
                pc.PopContext()
        }
        pc.PopContext()
}

type renderCache struct {
        tx  []rune
        lns *shaped.Lines
}

// renderLine renders given line, dealing with tab stops etc
func (ed *Base) renderLine(li, ln int, rpos math32.Vector2, vsel textpos.Region, hlts []textpos.Region) {
        buf := ed.Lines
        sh := ed.Scene.TextShaper()
        pc := &ed.Scene.Painter
        sz := ed.charSize
        sz.X *= float32(ed.linesSize.X)
        vlr := buf.ViewLineRegionLocked(ed.viewId, ln)
        vseli := vlr.Intersect(vsel, ed.linesSize.X)
        tx := buf.ViewMarkupLine(ed.viewId, ln)
        ctx := &rich.DefaultSettings
        ts := ed.Lines.Settings.TabSize
        indent := 0
        sty, tsty := ed.Styles.NewRichText()

        shapeTab := func(stx rich.Text, ssz math32.Vector2) *shaped.Lines {
                if ed.tabRender != nil {
                        return ed.tabRender.Clone()
                }
                lns := sh.WrapLines(stx, sty, tsty, ctx, ssz)
                ed.tabRender = lns
                return lns
        }
        shapeSpan := func(stx rich.Text, ssz math32.Vector2) *shaped.Lines {
                txt := stx.Join()
                rc := ed.lineRenders[li]
                if rc.lns != nil && slices.Compare(rc.tx, txt) == 0 {
                        return rc.lns
                }
                lns := sh.WrapLines(stx, sty, tsty, ctx, ssz)
                ed.lineRenders[li] = renderCache{tx: txt, lns: lns}
                return lns
        }

        rendSpan := func(lns *shaped.Lines, pos math32.Vector2, coff int) {
                lns.SelectReset()
                lns.HighlightReset()
                lns.SetGlyphXAdvance(math32.ToFixed(ed.charSize.X))
                if !vseli.IsNil() {
                        lns.SelectRegion(textpos.Range{Start: vseli.Start.Char - coff, End: vseli.End.Char - coff})
                }
                for _, hlrg := range hlts {
                        hlsi := vlr.Intersect(hlrg, ed.linesSize.X)
                        if !hlsi.IsNil() {
                                lns.HighlightRegion(textpos.Range{Start: hlsi.Start.Char - coff, End: hlsi.End.Char - coff})
                        }
                }
                pc.DrawText(lns, pos)
        }

        for si := range tx { // tabs encoded as single chars at start
                sn, rn := rich.SpanLen(tx[si])
                if rn == 1 && tx[si][sn] == '\t' {
                        lpos := rpos
                        ic := float32(ts*indent) * ed.charSize.X
                        lpos.X += ic
                        lsz := sz
                        lsz.X -= ic
                        rendSpan(shapeTab(tx[si:si+1], lsz), lpos, indent)
                        indent++
                } else {
                        break
                }
        }
        rtx := tx[indent:]
        lpos := rpos
        ic := float32(ts*indent) * ed.charSize.X
        lpos.X += ic
        lsz := sz
        lsz.X -= ic
        hasTab := false
        for si := range rtx {
                sn, rn := rich.SpanLen(tx[si])
                if rn > 0 && tx[si][sn] == '\t' {
                        hasTab = true
                        break
                }
        }
        if !hasTab {
                rendSpan(shapeSpan(rtx, lsz), lpos, indent)
                return
        }
        coff := indent
        cc := ts * indent
        scc := cc
        for si := range rtx {
                sn, rn := rich.SpanLen(rtx[si])
                if rn == 0 {
                        continue
                }
                spos := lpos
                spos.X += float32(cc-scc) * ed.charSize.X
                if rtx[si][sn] != '\t' {
                        ssz := ed.charSize.Mul(math32.Vec2(float32(rn), 1))
                        rendSpan(shapeSpan(rtx[si:si+1], ssz), spos, coff)
                        cc += rn
                        coff += rn
                        continue
                }
                for range rn {
                        tcc := ((cc / 8) + 1) * 8
                        spos.X += float32(tcc-cc) * ed.charSize.X
                        cc = tcc
                        rendSpan(shapeTab(rtx[si:si+1], ed.charSize), spos, coff)
                        coff++
                }
        }
}

// renderLineNumbersBox renders the background for the line numbers in the LineNumberColor
func (ed *Base) renderLineNumbersBox() {
        if !ed.hasLineNumbers {
                return
        }
        pc := &ed.Scene.Painter
        bb := ed.renderBBox()
        spos := math32.FromPoint(bb.Min)
        epos := math32.FromPoint(bb.Max)
        epos.X = spos.X + ed.LineNumberPixels()

        sz := epos.Sub(spos)
        pc.Fill.Color = ed.LineNumberColor
        pc.RoundedRectangleSides(spos.X, spos.Y, sz.X, sz.Y, ed.Styles.Border.Radius.Dots())
        pc.Draw()
}

// renderLineNumber renders given line number at given li index.
func (ed *Base) renderLineNumber(pos math32.Vector2, li, ln int) {
        if !ed.hasLineNumbers || ed.Lines == nil {
                return
        }
        pos.Y += float32(li) * ed.charSize.Y

        pc := &ed.Scene.Painter
        sh := ed.Scene.TextShaper()
        sty, tsty := ed.Styles.NewRichText()

        sty.SetBackground(nil)
        lfmt := fmt.Sprintf("%d", ed.lineNumberDigits)
        lfmt = "%" + lfmt + "d"
        lnstr := fmt.Sprintf(lfmt, ln+1)

        if ed.CursorPos.Line == ln {
                sty.SetFillColor(colors.ToUniform(colors.Scheme.Primary.Base))
                sty.Weight = rich.Bold
        } else {
                sty.SetFillColor(colors.ToUniform(colors.Scheme.OnSurfaceVariant))
        }
        sz := ed.charSize
        sz.X *= float32(ed.lineNumberOffset)
        var lns *shaped.Lines
        rc := ed.lineNoRenders[li]
        tx := rich.NewText(sty, []rune(lnstr))
        if rc.lns != nil && slices.Compare(rc.tx, tx[0]) == 0 { // captures styling
                lns = rc.lns
        } else {
                lns = sh.WrapLines(tx, sty, tsty, &rich.DefaultSettings, sz)
                ed.lineNoRenders[li] = renderCache{tx: tx[0], lns: lns}
        }
        pc.DrawText(lns, pos)

        // render circle
        lineColor, has := ed.Lines.LineColor(ln)
        if has {
                pos.X += float32(ed.lineNumberDigits) * ed.charSize.X
                r := 0.7 * ed.charSize.X
                center := pos.AddScalar(r)
                center.Y += 0.3 * ed.charSize.Y
                center.X += 0.3 * ed.charSize.X
                pc.Fill.Color = lineColor
                pc.Circle(center.X, center.Y, r)
                pc.Draw()
        }
}

func (ed *Base) LineNumberPixels() float32 {
        return float32(ed.lineNumberOffset) * ed.charSize.X
}

// TODO: make viewDepthColors HCT based?

// viewDepthColors are changes in color values from default background for different
// depths. For dark mode, these are increments, for light mode they are decrements.
var viewDepthColors = []color.RGBA{
        {0, 0, 0, 0},
        {4, 4, 0, 0},
        {8, 8, 0, 0},
        {4, 8, 0, 0},
        {0, 8, 4, 0},
        {0, 8, 8, 0},
        {0, 4, 8, 0},
        {4, 0, 8, 0},
        {4, 0, 4, 0},
}

// renderDepthBackground renders the depth background color.
func (ed *Base) renderDepthBackground(pos math32.Vector2, stln, edln int) {
        if !ed.Lines.Settings.DepthColor || ed.IsDisabled() || !ed.StateIs(states.Focused) {
                return
        }
        pos.X += ed.LineNumberPixels()
        buf := ed.Lines
        bbmax := float32(ed.Geom.ContentBBox.Max.X)
        pc := &ed.Scene.Painter
        sty := &ed.Styles
        isDark := matcolor.SchemeIsDark
        nclrs := len(viewDepthColors)
        for ln := stln; ln <= edln; ln++ {
                sp := ed.Lines.PosFromView(ed.viewId, textpos.Pos{Line: ln})
                depth := buf.LineLexDepth(sp.Line)
                if depth <= 0 {
                        continue
                }
                var vdc color.RGBA
                if isDark { // reverse order too
                        vdc = viewDepthColors[(nclrs-1)-(depth%nclrs)]
                } else {
                        vdc = viewDepthColors[depth%nclrs]
                }
                bg := gradient.Apply(sty.Background, func(c color.Color) color.Color {
                        if isDark { // reverse order too
                                return colors.Add(c, vdc)
                        }
                        return colors.Sub(c, vdc)
                })
                spos := pos
                spos.Y += float32(ln-stln) * ed.charSize.Y
                epos := spos
                epos.Y += ed.charSize.Y
                epos.X = bbmax
                pc.FillBox(spos, epos.Sub(spos), bg)
        }
}

// PixelToCursor finds the cursor position that corresponds to the given pixel
// location (e.g., from mouse click), in widget-relative coordinates.
func (ed *Base) PixelToCursor(pt image.Point) textpos.Pos {
        if ed.Lines == nil {
                return textpos.PosErr
        }
        stln, _, spos := ed.renderLineStartEnd()
        ptf := math32.FromPoint(pt)
        ptf.X += ed.Geom.Pos.Content.X
        ptf.Y -= (spos.Y - ed.Geom.Pos.Content.Y) // fractional bit
        cp := ptf.Div(ed.charSize)
        if cp.Y < 0 {
                return textpos.PosErr
        }
        vln := stln + int(math32.Floor(cp.Y))
        vpos := textpos.Pos{Line: vln, Char: 0}
        srcp := ed.Lines.PosFromView(ed.viewId, vpos)
        stp := ed.charStartPos(srcp)
        if ptf.X < stp.X {
                return srcp
        }
        scc := srcp.Char
        hc := 0.5 * ed.charSize.X
        vll := ed.Lines.ViewLineLen(ed.viewId, vln)
        for cc := range vll {
                srcp.Char = scc + cc
                edp := ed.charStartPos(textpos.Pos{Line: srcp.Line, Char: scc + cc + 1})
                if ptf.X >= stp.X-hc && ptf.X < edp.X-hc {
                        return srcp
                }
                stp = edp
        }
        srcp.Char = scc + vll
        return srcp
}

// charStartPos returns the starting (top left) render coords for the
// given source text position.
func (ed *Base) charStartPos(pos textpos.Pos) math32.Vector2 {
        if ed.Lines == nil {
                return math32.Vector2{}
        }
        vpos := ed.Lines.PosToView(ed.viewId, pos)
        spos := ed.Geom.Pos.Content
        spos.X += ed.LineNumberPixels() - ed.Geom.Scroll.X
        spos.Y += (float32(vpos.Line) - ed.scrollPos) * ed.charSize.Y
        tx := ed.Lines.ViewMarkupLine(ed.viewId, vpos.Line)
        ts := ed.Lines.Settings.TabSize
        indent := 0
        for si := range tx { // tabs encoded as single chars at start
                sn, rn := rich.SpanLen(tx[si])
                if rn == 1 && tx[si][sn] == '\t' {
                        if vpos.Char == si {
                                spos.X += float32(indent*ts) * ed.charSize.X
                                return spos
                        }
                        indent++
                } else {
                        break
                }
        }
        rtx := tx[indent:]
        lpos := spos
        lpos.X += float32(ts*indent) * ed.charSize.X
        coff := indent
        cc := ts * indent
        scc := cc
        for si := range rtx {
                sn, rn := rich.SpanLen(rtx[si])
                if rn == 0 {
                        continue
                }
                spos := lpos
                spos.X += float32(cc-scc) * ed.charSize.X
                if rtx[si][sn] != '\t' {
                        rc := vpos.Char - coff
                        if rc >= 0 && rc < rn {
                                spos.X += float32(rc) * ed.charSize.X
                                return spos
                        }
                        cc += rn
                        coff += rn
                        continue
                }
                for ri := range rn {
                        if ri == vpos.Char-coff {
                                return spos
                        }
                        tcc := ((cc / 8) + 1) * 8
                        cc = tcc
                        coff++
                }
        }
        spos = lpos
        spos.X += float32(cc-scc) * ed.charSize.X
        return spos
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/core"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/textpos"
)

//////// Regions

// HighlightRegion adds a new highlighted region. Use HighlightsReset to
// clear any existing prior to this if only one region desired.
func (ed *Base) HighlightRegion(reg textpos.Region) {
        ed.Highlights = append(ed.Highlights, reg)
        ed.NeedsRender()
}

// HighlightsReset resets the list of all highlighted regions.
func (ed *Base) HighlightsReset() {
        if len(ed.Highlights) == 0 {
                return
        }
        ed.Highlights = ed.Highlights[:0]
        ed.NeedsRender()
}

// scopelightsReset clears the scopelights slice of all regions.
// does needsrender if actually reset.
func (ed *Base) scopelightsReset() {
        if len(ed.scopelights) == 0 {
                return
        }
        sl := make([]textpos.Region, len(ed.scopelights))
        copy(sl, ed.scopelights)
        ed.scopelights = ed.scopelights[:0]
        ed.NeedsRender()
}

func (ed *Base) addScopelights(st, end textpos.Pos) {
        ed.scopelights = append(ed.scopelights, textpos.NewRegionPos(st, textpos.Pos{st.Line, st.Char + 1}))
        ed.scopelights = append(ed.scopelights, textpos.NewRegionPos(end, textpos.Pos{end.Line, end.Char + 1}))
}

//////// Selection

// clearSelected resets both the global selected flag and any current selection
func (ed *Base) clearSelected() {
        // ed.WidgetBase.ClearSelected()
        ed.SelectReset()
}

// HasSelection returns whether there is a selected region of text
func (ed *Base) HasSelection() bool {
        return ed.SelectRegion.Start.IsLess(ed.SelectRegion.End)
}

// validateSelection ensures that the selection region is still valid.
func (ed *Base) validateSelection() {
        ed.SelectRegion.Start = ed.Lines.ValidPos(ed.SelectRegion.Start)
        ed.SelectRegion.End = ed.Lines.ValidPos(ed.SelectRegion.End)
}

// Selection returns the currently selected text as a textpos.Edit, which
// captures start, end, and full lines in between -- nil if no selection
func (ed *Base) Selection() *textpos.Edit {
        if ed.HasSelection() {
                ed.validateSelection()
                return ed.Lines.Region(ed.SelectRegion.Start, ed.SelectRegion.End)
        }
        return nil
}

// selectModeToggle toggles the SelectMode, updating selection with cursor movement
func (ed *Base) selectModeToggle() {
        if ed.selectMode {
                ed.selectMode = false
        } else {
                ed.selectMode = true
                ed.selectStart = ed.CursorPos
                ed.selectRegionUpdate(ed.CursorPos)
        }
        ed.savePosHistory(ed.CursorPos)
}

// selectRegionUpdate updates current select region based on given cursor position
// relative to SelectStart position
func (ed *Base) selectRegionUpdate(pos textpos.Pos) {
        if pos.IsLess(ed.selectStart) {
                ed.SelectRegion.Start = pos
                ed.SelectRegion.End = ed.selectStart
        } else {
                ed.SelectRegion.Start = ed.selectStart
                ed.SelectRegion.End = pos
        }
}

// selectAll selects all the text
func (ed *Base) selectAll() {
        ed.SelectRegion.Start = textpos.PosZero
        ed.SelectRegion.End = ed.Lines.EndPos()
        ed.NeedsRender()
}

// selectWord selects the word (whitespace, punctuation delimited) that the cursor is on.
// returns true if word selected
func (ed *Base) selectWord() bool {
        if ed.Lines == nil {
                return false
        }
        reg := ed.Lines.WordAt(ed.CursorPos)
        ed.SelectRegion = reg
        ed.selectStart = ed.SelectRegion.Start
        return true
}

// SelectReset resets the selection
func (ed *Base) SelectReset() {
        ed.selectMode = false
        if !ed.HasSelection() {
                return
        }
        ed.SelectRegion = textpos.Region{}
        ed.previousSelectRegion = textpos.Region{}
}

////////    Undo / Redo

// undo undoes previous action
func (ed *Base) undo() {
        tbes := ed.Lines.Undo()
        if tbes != nil {
                tbe := tbes[len(tbes)-1]
                if tbe.Delete { // now an insert
                        ed.SetCursorShow(tbe.Region.End)
                } else {
                        ed.SetCursorShow(tbe.Region.Start)
                }
        } else {
                ed.SendInput() // updates status..
                ed.scrollCursorToCenterIfHidden()
        }
        ed.savePosHistory(ed.CursorPos)
        ed.NeedsRender()
}

// redo redoes previously undone action
func (ed *Base) redo() {
        tbes := ed.Lines.Redo()
        if tbes != nil {
                tbe := tbes[len(tbes)-1]
                if tbe.Delete {
                        ed.SetCursorShow(tbe.Region.Start)
                } else {
                        ed.SetCursorShow(tbe.Region.End)
                }
        } else {
                ed.scrollCursorToCenterIfHidden()
        }
        ed.savePosHistory(ed.CursorPos)
        ed.NeedsRender()
}

////////    Cut / Copy / Paste

// editorClipboardHistory is the [Base] clipboard history; everything that has been copied
var editorClipboardHistory [][]byte

// addBaseClipboardHistory adds the given clipboard bytes to top of history stack
func addBaseClipboardHistory(clip []byte) {
        max := clipboardHistoryMax
        if editorClipboardHistory == nil {
                editorClipboardHistory = make([][]byte, 0, max)
        }

        ch := &editorClipboardHistory

        sz := len(*ch)
        if sz > max {
                *ch = (*ch)[:max]
        }
        if sz >= max {
                copy((*ch)[1:max], (*ch)[0:max-1])
                (*ch)[0] = clip
        } else {
                *ch = append(*ch, nil)
                if sz > 0 {
                        copy((*ch)[1:], (*ch)[0:sz])
                }
                (*ch)[0] = clip
        }
}

// editorClipHistoryChooserLength is the max length of clip history to show in chooser
var editorClipHistoryChooserLength = 40

// editorClipHistoryChooserList returns a string slice of length-limited clip history, for chooser
func editorClipHistoryChooserList() []string {
        cl := make([]string, len(editorClipboardHistory))
        for i, hc := range editorClipboardHistory {
                szl := len(hc)
                if szl > editorClipHistoryChooserLength {
                        cl[i] = string(hc[:editorClipHistoryChooserLength])
                } else {
                        cl[i] = string(hc)
                }
        }
        return cl
}

// pasteHistory presents a chooser of clip history items, pastes into text if selected
func (ed *Base) pasteHistory() {
        if editorClipboardHistory == nil {
                return
        }
        cl := editorClipHistoryChooserList()
        m := core.NewMenuFromStrings(cl, "", func(idx int) {
                clip := editorClipboardHistory[idx]
                if clip != nil {
                        ed.Clipboard().Write(mimedata.NewTextBytes(clip))
                        ed.InsertAtCursor(clip)
                        ed.savePosHistory(ed.CursorPos)
                        ed.NeedsRender()
                }
        })
        core.NewMenuStage(m, ed, ed.cursorBBox(ed.CursorPos).Min).Run()
}

// Cut cuts any selected text and adds it to the clipboard, also returns cut text
func (ed *Base) Cut() *textpos.Edit {
        if !ed.HasSelection() {
                return nil
        }
        ed.validateSelection()
        org := ed.SelectRegion.Start
        cut := ed.deleteSelection()
        if cut != nil {
                cb := cut.ToBytes()
                ed.Clipboard().Write(mimedata.NewTextBytes(cb))
                addBaseClipboardHistory(cb)
        }
        ed.SetCursorShow(org)
        ed.savePosHistory(ed.CursorPos)
        ed.NeedsRender()
        return cut
}

// deleteSelection deletes any selected text, without adding to clipboard --
// returns text deleted as textpos.Edit (nil if none)
func (ed *Base) deleteSelection() *textpos.Edit {
        ed.validateSelection()
        tbe := ed.Lines.DeleteText(ed.SelectRegion.Start, ed.SelectRegion.End)
        ed.SelectReset()
        return tbe
}

// Copy copies any selected text to the clipboard, and returns that text,
// optionally resetting the current selection
func (ed *Base) Copy(reset bool) *textpos.Edit {
        tbe := ed.Selection()
        if tbe == nil {
                return nil
        }
        cb := tbe.ToBytes()
        addBaseClipboardHistory(cb)
        ed.Clipboard().Write(mimedata.NewTextBytes(cb))
        if reset {
                ed.SelectReset()
        }
        ed.savePosHistory(ed.CursorPos)
        ed.NeedsRender()
        return tbe
}

// Paste inserts text from the clipboard at current cursor position
func (ed *Base) Paste() {
        data := ed.Clipboard().Read([]string{fileinfo.TextPlain})
        if data != nil {
                ed.InsertAtCursor(data.TypeData(fileinfo.TextPlain))
                ed.savePosHistory(ed.CursorPos)
        }
        ed.NeedsRender()
}

// InsertAtCursor inserts given text at current cursor position
func (ed *Base) InsertAtCursor(txt []byte) {
        if ed.HasSelection() {
                tbe := ed.deleteSelection()
                ed.CursorPos = tbe.AdjustPos(ed.CursorPos, textpos.AdjustPosDelStart) // move to start if in reg
        }
        cp := ed.validateCursor()
        tbe := ed.Lines.InsertText(cp, []rune(string(txt)))
        if tbe == nil {
                return
        }
        pos := tbe.Region.End
        if len(txt) == 1 && txt[0] == '\n' {
                pos.Char = 0 // sometimes it doesn't go to the start..
        }
        ed.SetCursorShow(pos)
        ed.setCursorColumn(ed.CursorPos)
        ed.NeedsRender()
}

////////  Rectangular regions

// editorClipboardRect is the internal clipboard for Rect rectangle-based
// regions -- the raw text is posted on the system clipboard but the
// rect information is in a special format.
var editorClipboardRect *textpos.Edit

// CutRect cuts rectangle defined by selected text (upper left to lower right)
// and adds it to the clipboard, also returns cut lines.
func (ed *Base) CutRect() *textpos.Edit {
        if !ed.HasSelection() {
                return nil
        }
        ed.validateSelection()
        npos := textpos.Pos{Line: ed.SelectRegion.End.Line, Char: ed.SelectRegion.Start.Char}
        cut := ed.Lines.DeleteTextRect(ed.SelectRegion.Start, ed.SelectRegion.End)
        if cut != nil {
                cb := cut.ToBytes()
                ed.Clipboard().Write(mimedata.NewTextBytes(cb))
                editorClipboardRect = cut
        }
        ed.SetCursorShow(npos)
        ed.savePosHistory(ed.CursorPos)
        ed.NeedsRender()
        return cut
}

// CopyRect copies any selected text to the clipboard, and returns that text,
// optionally resetting the current selection
func (ed *Base) CopyRect(reset bool) *textpos.Edit {
        ed.validateSelection()
        tbe := ed.Lines.RegionRect(ed.SelectRegion.Start, ed.SelectRegion.End)
        if tbe == nil {
                return nil
        }
        cb := tbe.ToBytes()
        ed.Clipboard().Write(mimedata.NewTextBytes(cb))
        editorClipboardRect = tbe
        if reset {
                ed.SelectReset()
        }
        ed.savePosHistory(ed.CursorPos)
        ed.NeedsRender()
        return tbe
}

// PasteRect inserts text from the clipboard at current cursor position
func (ed *Base) PasteRect() {
        if editorClipboardRect == nil {
                return
        }
        ce := editorClipboardRect.Clone()
        nl := ce.Region.End.Line - ce.Region.Start.Line
        nch := ce.Region.End.Char - ce.Region.Start.Char
        ce.Region.Start.Line = ed.CursorPos.Line
        ce.Region.End.Line = ed.CursorPos.Line + nl
        ce.Region.Start.Char = ed.CursorPos.Char
        ce.Region.End.Char = ed.CursorPos.Char + nch
        tbe := ed.Lines.InsertTextRect(ce)

        pos := tbe.Region.End
        ed.SetCursorShow(pos)
        ed.setCursorColumn(ed.CursorPos)
        ed.savePosHistory(ed.CursorPos)
        ed.NeedsRender()
}

// ReCaseSelection changes the case of the currently selected lines.
// Returns the new text; empty if nothing selected.
func (ed *Base) ReCaseSelection(c strcase.Cases) string {
        if !ed.HasSelection() {
                return ""
        }
        sel := ed.Selection()
        nstr := strcase.To(string(sel.ToBytes()), c)
        ed.Lines.ReplaceText(sel.Region.Start, sel.Region.End, sel.Region.Start, nstr, lines.ReplaceNoMatchCase)
        return nstr
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "strings"
        "unicode"

        "cogentcore.org/core/base/fileinfo"
        "cogentcore.org/core/events"
        "cogentcore.org/core/keymap"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/parse/lexer"
        "cogentcore.org/core/text/spell"
        "cogentcore.org/core/text/textpos"
        "cogentcore.org/core/text/token"
)

// iSpellKeyInput locates the word to spell check based on cursor position and
// the key input, then passes the text region to SpellCheck
func (ed *Editor) iSpellKeyInput(kt events.Event) {
        if !ed.isSpellEnabled(ed.CursorPos) {
                return
        }
        isDoc := ed.Lines.FileInfo().Cat == fileinfo.Doc
        tp := ed.CursorPos
        kf := keymap.Of(kt.KeyChord())
        switch kf {
        case keymap.MoveUp:
                if isDoc {
                        ed.spellCheckLineTag(tp.Line)
                }
        case keymap.MoveDown:
                if isDoc {
                        ed.spellCheckLineTag(tp.Line)
                }
        case keymap.MoveRight:
                if ed.Lines.IsWordEnd(tp) {
                        reg := ed.Lines.WordBefore(tp)
                        ed.spellCheck(reg)
                        break
                }
                if tp.Char == 0 { // end of line
                        tp.Line--
                        if tp.Line < 0 {
                                tp.Line = 0
                        }
                        if isDoc {
                                ed.spellCheckLineTag(tp.Line) // redo prior line
                        }
                        tp.Char = ed.Lines.LineLen(tp.Line)
                        reg := ed.Lines.WordBefore(tp)
                        ed.spellCheck(reg)
                        break
                }
                txt := ed.Lines.Line(tp.Line)
                var r rune
                atend := false
                if tp.Char >= len(txt) {
                        atend = true
                        tp.Char++
                } else {
                        r = txt[tp.Char]
                }
                if atend || textpos.IsWordBreak(r, rune(-1)) {
                        tp.Char-- // we are one past the end of word
                        if tp.Char < 0 {
                                tp.Char = 0
                        }
                        reg := ed.Lines.WordBefore(tp)
                        ed.spellCheck(reg)
                }
        case keymap.Enter:
                tp.Line--
                if tp.Line < 0 {
                        tp.Line = 0
                }
                if isDoc {
                        ed.spellCheckLineTag(tp.Line) // redo prior line
                }
                tp.Char = ed.Lines.LineLen(tp.Line)
                reg := ed.Lines.WordBefore(tp)
                ed.spellCheck(reg)
        case keymap.FocusNext:
                tp.Char-- // we are one past the end of word
                if tp.Char < 0 {
                        tp.Char = 0
                }
                reg := ed.Lines.WordBefore(tp)
                ed.spellCheck(reg)
        case keymap.Backspace, keymap.Delete:
                if ed.Lines.IsWordMiddle(ed.CursorPos) {
                        reg := ed.Lines.WordAt(ed.CursorPos)
                        ed.spellCheck(ed.Lines.Region(reg.Start, reg.End))
                } else {
                        reg := ed.Lines.WordBefore(tp)
                        ed.spellCheck(reg)
                }
        case keymap.None:
                if unicode.IsSpace(kt.KeyRune()) || unicode.IsPunct(kt.KeyRune()) && kt.KeyRune() != '\'' { // contractions!
                        tp.Char-- // we are one past the end of word
                        if tp.Char < 0 {
                                tp.Char = 0
                        }
                        reg := ed.Lines.WordBefore(tp)
                        ed.spellCheck(reg)
                } else {
                        if ed.Lines.IsWordMiddle(ed.CursorPos) {
                                reg := ed.Lines.WordAt(ed.CursorPos)
                                ed.spellCheck(ed.Lines.Region(reg.Start, reg.End))
                        }
                }
        }
}

// spellCheck offers spelling corrections if we are at a word break or other word termination
// and the word before the break is unknown -- returns true if misspelled word found
func (ed *Editor) spellCheck(reg *textpos.Edit) bool {
        if ed.spell == nil {
                return false
        }
        wb := string(reg.ToBytes())
        lwb := lexer.FirstWordApostrophe(wb) // only lookup words
        if len(lwb) <= 2 {
                return false
        }
        widx := strings.Index(wb, lwb) // adjust region for actual part looking up
        ld := len(wb) - len(lwb)
        reg.Region.Start.Char += widx
        reg.Region.End.Char += widx - ld

        sugs, knwn := ed.spell.checkWord(lwb)
        if knwn {
                ed.Lines.RemoveTag(reg.Region.Start, token.TextSpellErr)
                return false
        }
        // fmt.Printf("spell err: %s\n", wb)
        ed.spell.setWord(wb, sugs, reg.Region.Start.Line, reg.Region.Start.Char)
        ed.Lines.RemoveTag(reg.Region.Start, token.TextSpellErr)
        ed.Lines.AddTagEdit(reg, token.TextSpellErr)
        return true
}

// offerCorrect pops up a menu of possible spelling corrections for word at
// current CursorPos. If no misspelling there or not in spellcorrect mode
// returns false
func (ed *Editor) offerCorrect() bool {
        if ed.spell == nil || ed.ISearch.On || ed.QReplace.On || ed.IsDisabled() {
                return false
        }
        sel := ed.SelectRegion
        if !ed.selectWord() {
                ed.SelectRegion = sel
                return false
        }
        tbe := ed.Selection()
        if tbe == nil {
                ed.SelectRegion = sel
                return false
        }
        ed.SelectRegion = sel
        wb := string(tbe.ToBytes())
        wbn := strings.TrimLeft(wb, " \t")
        if len(wb) != len(wbn) {
                return false // SelectWord captures leading whitespace - don't offer if there is leading whitespace
        }
        sugs, knwn := ed.spell.checkWord(wb)
        if knwn && !ed.spell.isLastLearned(wb) {
                return false
        }
        ed.spell.setWord(wb, sugs, tbe.Region.Start.Line, tbe.Region.Start.Char)

        cpos := ed.charStartPos(ed.CursorPos).ToPoint() // physical location
        cpos.X += 5
        cpos.Y += 10
        ed.spell.show(wb, ed.Scene, cpos)
        return true
}

// cancelCorrect cancels any pending spell correction.
// Call this when new events have moved beyond any prior correction scenario.
func (ed *Editor) cancelCorrect() {
        if ed.spell == nil || ed.ISearch.On || ed.QReplace.On {
                return
        }
        if !ed.Lines.Settings.SpellCorrect {
                return
        }
        ed.spell.cancel()
}

// isSpellEnabled returns true if spelling correction is enabled,
// taking into account given position in text if it is relevant for cases
// where it is only conditionally enabled
func (ed *Editor) isSpellEnabled(pos textpos.Pos) bool {
        if ed.spell == nil || !ed.Lines.Settings.SpellCorrect {
                return false
        }
        switch ed.Lines.FileInfo().Cat {
        case fileinfo.Doc: // not in code!
                return !ed.Lines.InTokenCode(pos)
        case fileinfo.Code:
                return ed.Lines.InComment(pos) || ed.Lines.InLitString(pos)
        default:
                return false
        }
}

// setSpell sets spell correct functions so that spell correct will
// automatically be offered as the user types
func (ed *Editor) setSpell() {
        if ed.spell != nil {
                return
        }
        initSpell()
        ed.spell = newSpell()
        ed.spell.onSelect(func(e events.Event) {
                ed.correctText(ed.spell.correction)
        })
}

// correctText edits the text using the string chosen from the correction menu
func (ed *Editor) correctText(s string) {
        st := textpos.Pos{ed.spell.srcLn, ed.spell.srcCh} // start of word
        ed.Lines.RemoveTag(st, token.TextSpellErr)
        oend := st
        oend.Char += len(ed.spell.word)
        ed.Lines.ReplaceText(st, oend, st, s, lines.ReplaceNoMatchCase)
        ep := st
        ep.Char += len(s)
        ed.SetCursorShow(ep)
}

// SpellCheckLineErrors runs spell check on given line, and returns Lex tags
// with token.TextSpellErr for any misspelled words
func (ed *Editor) SpellCheckLineErrors(ln int) lexer.Line {
        if !ed.Lines.IsValidLine(ln) {
                return nil
        }
        return spell.CheckLexLine(ed.Lines.Line(ln), ed.Lines.HiTags(ln))
}

// spellCheckLineTag runs spell check on given line, and sets Tags for any
// misspelled words and updates markup for that line.
func (ed *Editor) spellCheckLineTag(ln int) {
        if !ed.Lines.IsValidLine(ln) {
                return
        }
        ser := ed.SpellCheckLineErrors(ln)
        ntgs := ed.Lines.AdjustedTags(ln)
        ntgs.DeleteToken(token.TextSpellErr)
        for _, t := range ser {
                ntgs.AddSort(t)
        }
        ed.Lines.SetTags(ln, ntgs)
        ed.Lines.MarkupLines(ln, ln)
        ed.Lines.StartDelayedReMarkup()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

// TODO: consider moving back to core or somewhere else based on the
// result of https://github.com/cogentcore/core/issues/711

import (
        "image"
        "log/slog"
        "path/filepath"
        "strings"
        "sync"

        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/text/spell"
)

// initSpell ensures that the [spell.Spell] spell checker is set up.
func initSpell() error {
        if core.TheApp.Platform().IsMobile() { // todo: too slow -- fix with aspell
                return nil
        }
        if spell.Spell != nil {
                return nil
        }
        pdir := core.TheApp.CogentCoreDataDir()
        openpath := filepath.Join(pdir, "user_dict_en_us")
        spell.Spell = spell.NewSpell(openpath)
        return nil
}

// spellCheck has all the texteditor spell check state
type spellCheck struct {
        // line number in source that spelling is operating on, if relevant
        srcLn int

        // character position in source that spelling is operating on (start of word to be corrected)
        srcCh int

        // list of suggested corrections
        suggest []string

        // word being checked
        word string

        // last word learned -- can be undone -- stored in lowercase format
        lastLearned string

        // the user's correction selection
        correction string

        // the event listeners for the spell (it sends Select events)
        listeners events.Listeners

        // stage is the popup [core.Stage] associated with the [spellState]
        stage *core.Stage

        showMu sync.Mutex
}

// newSpell returns a new [spellState]
func newSpell() *spellCheck {
        initSpell()
        return &spellCheck{}
}

// checkWord checks the model to determine if the word is known,
// bool is true if known, false otherwise. If not known,
// returns suggestions for close matching words.
func (sp *spellCheck) checkWord(word string) ([]string, bool) {
        if spell.Spell == nil {
                return nil, false
        }
        return spell.Spell.CheckWord(word)
}

// setWord sets the word to spell and other associated info
func (sp *spellCheck) setWord(word string, sugs []string, srcLn, srcCh int) *spellCheck {
        sp.word = word
        sp.suggest = sugs
        sp.srcLn = srcLn
        sp.srcCh = srcCh
        return sp
}

// show is the main call for listing spelling corrections.
// Calls ShowNow which builds the correction popup menu
// Similar to completion.show but does not use a timer
// Displays popup immediately for any unknown word
func (sp *spellCheck) show(text string, ctx core.Widget, pos image.Point) {
        if sp.stage != nil {
                sp.cancel()
        }
        sp.showNow(text, ctx, pos)
}

// showNow actually builds the correction popup menu
func (sp *spellCheck) showNow(word string, ctx core.Widget, pos image.Point) {
        if sp.stage != nil {
                sp.cancel()
        }
        sp.showMu.Lock()
        defer sp.showMu.Unlock()

        sc := core.NewScene(ctx.AsTree().Name + "-spell")
        core.StyleMenuScene(sc)
        sp.stage = core.NewPopupStage(core.CompleterStage, sc, ctx).SetPos(pos)

        if sp.isLastLearned(word) {
                core.NewButton(sc).SetText("unlearn").SetTooltip("unlearn the last learned word").
                        OnClick(func(e events.Event) {
                                sp.cancel()
                                sp.unLearnLast()
                        })
        } else {
                count := len(sp.suggest)
                if count == 1 && sp.suggest[0] == word {
                        return
                }
                if count == 0 {
                        core.NewButton(sc).SetText("no suggestion")
                } else {
                        for i := 0; i < count; i++ {
                                text := sp.suggest[i]
                                core.NewButton(sc).SetText(text).OnClick(func(e events.Event) {
                                        sp.cancel()
                                        sp.spell(text)
                                })
                        }
                }
                core.NewSeparator(sc)
                core.NewButton(sc).SetText("learn").OnClick(func(e events.Event) {
                        sp.cancel()
                        sp.learnWord()
                })
                core.NewButton(sc).SetText("ignore").OnClick(func(e events.Event) {
                        sp.cancel()
                        sp.ignoreWord()
                })
        }
        if sc.NumChildren() > 0 {
                sc.Events.SetStartFocus(sc.Child(0).(core.Widget))
        }
        sp.stage.Run()
}

// spell sends a Select event to Listeners indicating that the user has made a
// selection from the list of possible corrections
func (sp *spellCheck) spell(s string) {
        sp.cancel()
        sp.correction = s
        sp.listeners.Call(&events.Base{Typ: events.Select})
}

// onSelect registers given listener function for Select events on Value.
// This is the primary notification event for all Complete elements.
func (sp *spellCheck) onSelect(fun func(e events.Event)) {
        sp.on(events.Select, fun)
}

// on adds an event listener function for the given event type
func (sp *spellCheck) on(etype events.Types, fun func(e events.Event)) {
        sp.listeners.Add(etype, fun)
}

// learnWord gets the misspelled/unknown word and passes to learnWord
func (sp *spellCheck) learnWord() {
        sp.lastLearned = strings.ToLower(sp.word)
        spell.Spell.AddWord(sp.word)
}

// isLastLearned returns true if given word was the last one learned
func (sp *spellCheck) isLastLearned(wrd string) bool {
        lword := strings.ToLower(wrd)
        return lword == sp.lastLearned
}

// unLearnLast unlearns the last learned word -- in case accidental
func (sp *spellCheck) unLearnLast() {
        if sp.lastLearned == "" {
                slog.Error("spell.UnLearnLast: no last learned word")
                return
        }
        lword := sp.lastLearned
        sp.lastLearned = ""
        spell.Spell.DeleteWord(lword)
}

// ignoreWord adds the word to the ignore list
func (sp *spellCheck) ignoreWord() {
        spell.Spell.IgnoreWord(sp.word)
}

// cancel cancels any pending spell correction.
// call when new events nullify prior correction.
// returns true if canceled
func (sp *spellCheck) cancel() bool {
        if sp.stage == nil {
                return false
        }
        st := sp.stage
        sp.stage = nil
        st.ClosePopup()
        return true
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textcore

import (
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/tree"
)

// TwinEditors presents two side-by-side [Editor]s in [core.Splits]
// that scroll in sync with each other.
type TwinEditors struct {
        core.Splits

        // [Buffer] for A
        BufferA *lines.Lines `json:"-" xml:"-"`

        // [Buffer] for B
        BufferB *lines.Lines `json:"-" xml:"-"`

        inInputEvent bool
}

func (te *TwinEditors) Init() {
        te.Splits.Init()
        te.BufferA = lines.NewLines()
        te.BufferB = lines.NewLines()

        f := func(name string, buf *lines.Lines) {
                tree.AddChildAt(te, name, func(w *Editor) {
                        w.SetLines(buf)
                        w.Styler(func(s *styles.Style) {
                                s.Min.X.Ch(80)
                                s.Min.Y.Em(40)
                        })
                        w.On(events.Scroll, func(e events.Event) {
                                te.syncEditors(events.Scroll, e, name)
                        })
                        w.On(events.Input, func(e events.Event) {
                                te.syncEditors(events.Input, e, name)
                        })
                })
        }
        f("text-a", te.BufferA)
        f("text-b", te.BufferB)
}

// SetFiles sets the files for each [Buffer].
func (te *TwinEditors) SetFiles(fileA, fileB string) {
        te.BufferA.SetFilename(fileA)
        te.BufferA.Stat() // update markup
        te.BufferB.SetFilename(fileB)
        te.BufferB.Stat() // update markup
}

// syncEditors synchronizes the [Editor] scrolling and cursor positions
func (te *TwinEditors) syncEditors(typ events.Types, e events.Event, name string) {
        tva, tvb := te.Editors()
        me, other := tva, tvb
        if name == "text-b" {
                me, other = tvb, tva
        }
        switch typ {
        case events.Scroll:
                other.updateScroll(me.scrollPos)
        case events.Input:
                if te.inInputEvent {
                        return
                }
                te.inInputEvent = true
                other.SetCursorShow(me.CursorPos)
                te.inInputEvent = false
        }
}

// Editors returns the two text [Editor]s.
func (te *TwinEditors) Editors() (*Editor, *Editor) {
        ae := te.Child(0).(*Editor)
        be := te.Child(1).(*Editor)
        return ae, be
}

// Code generated by "core generate"; DO NOT EDIT.

package textcore

import (
        "image"
        "io"
        "time"

        "cogentcore.org/core/core"
        "cogentcore.org/core/styles/units"
        "cogentcore.org/core/text/lines"
        "cogentcore.org/core/text/rich"
        "cogentcore.org/core/tree"
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/textcore.Base", IDName: "base", Doc: "Base is a widget with basic infrastructure for viewing and editing\n[lines.Lines] of monospaced text, used in [textcore.Editor] and\nterminal. There can be multiple Base widgets for each lines buffer.\n\nUse NeedsRender to drive an render update for any change that does\nnot change the line-level layout of the text.\n\nAll updating in the Base should be within a single goroutine,\nas it would require extensive protections throughout code otherwise.", Directives: []types.Directive{{Tool: "core", Directive: "embedder"}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "Lines", Doc: "Lines is the text lines content for this editor."}, {Name: "CursorWidth", Doc: "CursorWidth is the width of the cursor.\nThis should be set in Stylers like all other style properties."}, {Name: "LineNumberColor", Doc: "LineNumberColor is the color used for the side bar containing the line numbers.\nThis should be set in Stylers like all other style properties."}, {Name: "SelectColor", Doc: "SelectColor is the color used for the user text selection background color.\nThis should be set in Stylers like all other style properties."}, {Name: "HighlightColor", Doc: "HighlightColor is the color used for the text highlight background color (like in find).\nThis should be set in Stylers like all other style properties."}, {Name: "CursorColor", Doc: "CursorColor is the color used for the text editor cursor bar.\nThis should be set in Stylers like all other style properties."}, {Name: "AutoscrollOnInput", Doc: "AutoscrollOnInput scrolls the display to the end when Input events are received."}, {Name: "viewId", Doc: "viewId is the unique id of the Lines view."}, {Name: "charSize", Doc: "charSize is the render size of one character (rune).\nY = line height, X = total glyph advance."}, {Name: "visSizeAlloc", Doc: "visSizeAlloc is the Geom.Size.Alloc.Total subtracting extra space,\navailable for rendering text lines and line numbers."}, {Name: "lastVisSizeAlloc", Doc: "lastVisSizeAlloc is the last visSizeAlloc used in laying out lines.\nIt is used to trigger a new layout only when needed."}, {Name: "visSize", Doc: "visSize is the height in lines and width in chars of the visible area."}, {Name: "linesSize", Doc: "linesSize is the height in lines and width in chars of the Lines text area,\n(excluding line numbers), which can be larger than the visSize."}, {Name: "scrollPos", Doc: "scrollPos is the position of the scrollbar, in units of lines of text.\nfractional scrolling is supported."}, {Name: "hasLineNumbers", Doc: "hasLineNumbers indicates that this editor has line numbers\n(per [Editor] option)"}, {Name: "lineNumberOffset", Doc: "lineNumberOffset is the horizontal offset in chars for the start of text\nafter line numbers. This is 0 if no line numbers."}, {Name: "totalSize", Doc: "totalSize is total size of all text, including line numbers,\nmultiplied by charSize."}, {Name: "lineNumberDigits", Doc: "lineNumberDigits is the number of line number digits needed."}, {Name: "CursorPos", Doc: "CursorPos is the current cursor position."}, {Name: "blinkOn", Doc: "blinkOn oscillates between on and off for blinking."}, {Name: "cursorMu", Doc: "cursorMu is a mutex protecting cursor rendering, shared between blink and main code."}, {Name: "isScrolling", Doc: "isScrolling is true when scrolling: prevents keeping current cursor position\nin view."}, {Name: "cursorTarget", Doc: "cursorTarget is the target cursor position for externally set targets.\nIt ensures that the target position is visible."}, {Name: "cursorColumn", Doc: "cursorColumn is the desired cursor column, where the cursor was\nlast when moved using left / right arrows.\nIt is used when doing up / down to not always go to short line columns."}, {Name: "posHistoryIndex", Doc: "posHistoryIndex is the current index within PosHistory."}, {Name: "selectStart", Doc: "selectStart is the starting point for selection, which will either\nbe the start or end of selected region depending on subsequent selection."}, {Name: "SelectRegion", Doc: "SelectRegion is the current selection region."}, {Name: "previousSelectRegion", Doc: "previousSelectRegion is the previous selection region that was actually rendered.\nIt is needed to update the render."}, {Name: "Highlights", Doc: "Highlights is a slice of regions representing the highlighted\nregions, e.g., for search results."}, {Name: "scopelights", Doc: "scopelights is a slice of regions representing the highlighted\nregions specific to scope markers."}, {Name: "LinkHandler", Doc: "LinkHandler handles link clicks.\nIf it is nil, they are sent to the standard web URL handler."}, {Name: "lineRenders", Doc: "lineRenders are the cached rendered lines of text."}, {Name: "lineNoRenders", Doc: "lineNoRenders are the cached rendered line numbers"}, {Name: "tabRender", Doc: "tabRender is a shaped tab"}, {Name: "selectMode", Doc: "selectMode is a boolean indicating whether to select text as the cursor moves."}, {Name: "lastWasTabAI", Doc: "lastWasTabAI indicates that last key was a Tab auto-indent"}, {Name: "lastWasUndo", Doc: "lastWasUndo indicates that last key was an undo"}, {Name: "targetSet", Doc: "targetSet indicates that the CursorTarget is set"}, {Name: "lastRecenter"}, {Name: "lastAutoInsert"}, {Name: "lastFilename"}}})

// NewBase returns a new [Base] with the given optional parent:
// Base is a widget with basic infrastructure for viewing and editing
// [lines.Lines] of monospaced text, used in [textcore.Editor] and
// terminal. There can be multiple Base widgets for each lines buffer.
//
// Use NeedsRender to drive an render update for any change that does
// not change the line-level layout of the text.
//
// All updating in the Base should be within a single goroutine,
// as it would require extensive protections throughout code otherwise.
func NewBase(parent ...tree.Node) *Base { return tree.New[Base](parent...) }

// BaseEmbedder is an interface that all types that embed Base satisfy
type BaseEmbedder interface {
        AsBase() *Base
}

// AsBase returns the given value as a value of type Base if the type
// of the given value embeds Base, or nil otherwise
func AsBase(n tree.Node) *Base {
        if t, ok := n.(BaseEmbedder); ok {
                return t.AsBase()
        }
        return nil
}

// AsBase satisfies the [BaseEmbedder] interface
func (t *Base) AsBase() *Base { return t }

// SetCursorWidth sets the [Base.CursorWidth]:
// CursorWidth is the width of the cursor.
// This should be set in Stylers like all other style properties.
func (t *Base) SetCursorWidth(v units.Value) *Base { t.CursorWidth = v; return t }

// SetLineNumberColor sets the [Base.LineNumberColor]:
// LineNumberColor is the color used for the side bar containing the line numbers.
// This should be set in Stylers like all other style properties.
func (t *Base) SetLineNumberColor(v image.Image) *Base { t.LineNumberColor = v; return t }

// SetSelectColor sets the [Base.SelectColor]:
// SelectColor is the color used for the user text selection background color.
// This should be set in Stylers like all other style properties.
func (t *Base) SetSelectColor(v image.Image) *Base { t.SelectColor = v; return t }

// SetHighlightColor sets the [Base.HighlightColor]:
// HighlightColor is the color used for the text highlight background color (like in find).
// This should be set in Stylers like all other style properties.
func (t *Base) SetHighlightColor(v image.Image) *Base { t.HighlightColor = v; return t }

// SetCursorColor sets the [Base.CursorColor]:
// CursorColor is the color used for the text editor cursor bar.
// This should be set in Stylers like all other style properties.
func (t *Base) SetCursorColor(v image.Image) *Base { t.CursorColor = v; return t }

// SetAutoscrollOnInput sets the [Base.AutoscrollOnInput]:
// AutoscrollOnInput scrolls the display to the end when Input events are received.
func (t *Base) SetAutoscrollOnInput(v bool) *Base { t.AutoscrollOnInput = v; return t }

// SetLinkHandler sets the [Base.LinkHandler]:
// LinkHandler handles link clicks.
// If it is nil, they are sent to the standard web URL handler.
func (t *Base) SetLinkHandler(v func(tl *rich.Hyperlink)) *Base { t.LinkHandler = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/textcore.DiffEditor", IDName: "diff-editor", Doc: "DiffEditor presents two side-by-side [Editor]s showing the differences\nbetween two files (represented as lines of strings).", Methods: []types.Method{{Name: "saveFileA", Doc: "saveFileA saves the current state of file A to given filename", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"fname"}}, {Name: "saveFileB", Doc: "saveFileB saves the current state of file B to given filename", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"fname"}}}, Embeds: []types.Field{{Name: "Frame"}}, Fields: []types.Field{{Name: "FileA", Doc: "first file name being compared"}, {Name: "FileB", Doc: "second file name being compared"}, {Name: "RevisionA", Doc: "revision for first file, if relevant"}, {Name: "RevisionB", Doc: "revision for second file, if relevant"}, {Name: "linesA", Doc: "[lines.Lines] for A showing the aligned edit view"}, {Name: "linesB", Doc: "[lines.Lines] for B showing the aligned edit view"}, {Name: "alignD", Doc: "aligned diffs records diff for aligned lines"}, {Name: "diffs", Doc: "diffs applied"}, {Name: "inInputEvent"}, {Name: "toolbar"}}})

// NewDiffEditor returns a new [DiffEditor] with the given optional parent:
// DiffEditor presents two side-by-side [Editor]s showing the differences
// between two files (represented as lines of strings).
func NewDiffEditor(parent ...tree.Node) *DiffEditor { return tree.New[DiffEditor](parent...) }

// SetFileA sets the [DiffEditor.FileA]:
// first file name being compared
func (t *DiffEditor) SetFileA(v string) *DiffEditor { t.FileA = v; return t }

// SetFileB sets the [DiffEditor.FileB]:
// second file name being compared
func (t *DiffEditor) SetFileB(v string) *DiffEditor { t.FileB = v; return t }

// SetRevisionA sets the [DiffEditor.RevisionA]:
// revision for first file, if relevant
func (t *DiffEditor) SetRevisionA(v string) *DiffEditor { t.RevisionA = v; return t }

// SetRevisionB sets the [DiffEditor.RevisionB]:
// revision for second file, if relevant
func (t *DiffEditor) SetRevisionB(v string) *DiffEditor { t.RevisionB = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/textcore.DiffTextEditor", IDName: "diff-text-editor", Doc: "DiffTextEditor supports double-click based application of edits from one\nlines to the other.", Embeds: []types.Field{{Name: "Editor"}}})

// NewDiffTextEditor returns a new [DiffTextEditor] with the given optional parent:
// DiffTextEditor supports double-click based application of edits from one
// lines to the other.
func NewDiffTextEditor(parent ...tree.Node) *DiffTextEditor {
        return tree.New[DiffTextEditor](parent...)
}

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/textcore.Editor", IDName: "editor", Doc: "Editor is a widget for editing multiple lines of complicated text (as compared to\n[core.TextField] for a single line of simple text).  The Editor is driven by a\n[lines.Lines] buffer which contains all the text, and manages all the edits,\nsending update events out to the editors.\n\nUse NeedsRender to drive an render update for any change that does\nnot change the line-level layout of the text.\n\nMultiple editors can be attached to a given buffer.  All updating in the\nEditor should be within a single goroutine, as it would require\nextensive protections throughout code otherwise.", Directives: []types.Directive{{Tool: "core", Directive: "embedder"}}, Methods: []types.Method{{Name: "Lookup", Doc: "Lookup attempts to lookup symbol at current location, popping up a window\nif something is found.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}}, {Name: "SaveAs", Doc: "SaveAs saves the current text into given file; does an editDone first to save edits\nand checks for an existing file; if it does exist then prompts to overwrite or not.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Args: []string{"filename"}}, {Name: "Save", Doc: "Save saves the current text into the current filename associated with this buffer.\nDo NOT use this in an OnChange event handler as it emits a Change event! Use\n[Editor.SaveQuiet] instead.", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Returns: []string{"error"}}, {Name: "SaveQuiet", Doc: "SaveQuiet saves the current text into the current filename associated with this buffer.\nThis version does not emit a change event, so it is safe to use\nin an OnChange event handler, unlike [Editor.Save].", Directives: []types.Directive{{Tool: "types", Directive: "add"}}, Returns: []string{"error"}}}, Embeds: []types.Field{{Name: "Base"}}, Fields: []types.Field{{Name: "ISearch", Doc: "ISearch is the interactive search data."}, {Name: "QReplace", Doc: "QReplace is the query replace data."}, {Name: "Complete", Doc: "Complete is the functions and data for text completion."}, {Name: "spell", Doc: "spell is the functions and data for spelling correction."}, {Name: "curFilename", Doc: "curFilename is the current filename from Lines. Used to detect changed file."}}})

// NewEditor returns a new [Editor] with the given optional parent:
// Editor is a widget for editing multiple lines of complicated text (as compared to
// [core.TextField] for a single line of simple text).  The Editor is driven by a
// [lines.Lines] buffer which contains all the text, and manages all the edits,
// sending update events out to the editors.
//
// Use NeedsRender to drive an render update for any change that does
// not change the line-level layout of the text.
//
// Multiple editors can be attached to a given buffer.  All updating in the
// Editor should be within a single goroutine, as it would require
// extensive protections throughout code otherwise.
func NewEditor(parent ...tree.Node) *Editor { return tree.New[Editor](parent...) }

// EditorEmbedder is an interface that all types that embed Editor satisfy
type EditorEmbedder interface {
        AsEditor() *Editor
}

// AsEditor returns the given value as a value of type Editor if the type
// of the given value embeds Editor, or nil otherwise
func AsEditor(n tree.Node) *Editor {
        if t, ok := n.(EditorEmbedder); ok {
                return t.AsEditor()
        }
        return nil
}

// AsEditor satisfies the [EditorEmbedder] interface
func (t *Editor) AsEditor() *Editor { return t }

// SetComplete sets the [Editor.Complete]:
// Complete is the functions and data for text completion.
func (t *Editor) SetComplete(v *core.Complete) *Editor { t.Complete = v; return t }

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/textcore.OutputBuffer", IDName: "output-buffer", Doc: "OutputBuffer is a buffer that records the output from an [io.Reader] using\n[bufio.Scanner]. It is optimized to combine fast chunks of output into\nlarge blocks of updating. It also supports an arbitrary markup function\nthat operates on each line of output text.", Directives: []types.Directive{{Tool: "types", Directive: "add", Args: []string{"-setters"}}}, Embeds: []types.Field{{Name: "Mutex", Doc: "mutex protecting updates"}}, Fields: []types.Field{{Name: "Output", Doc: "the output that we are reading from, as an io.Reader"}, {Name: "Lines", Doc: "the [lines.Lines] that we output to"}, {Name: "Batch", Doc: "how much time to wait while batching output (default: 200ms)"}, {Name: "MarkupFunc", Doc: "MarkupFunc is an optional markup function that adds html tags to given line\nof output. It is essential that it not add any new text, just splits into spans\nwith different styles."}, {Name: "bufferedLines", Doc: "current buffered output raw lines, which are not yet sent to the Buffer"}, {Name: "bufferedMarkup", Doc: "current buffered output markup lines, which are not yet sent to the Buffer"}, {Name: "lastOutput", Doc: "time when last output was sent to buffer"}, {Name: "afterTimer", Doc: "time.AfterFunc that is started after new input is received and not\nimmediately output. Ensures that it will get output if no further burst happens."}}})

// SetOutput sets the [OutputBuffer.Output]:
// the output that we are reading from, as an io.Reader
func (t *OutputBuffer) SetOutput(v io.Reader) *OutputBuffer { t.Output = v; return t }

// SetLines sets the [OutputBuffer.Lines]:
// the [lines.Lines] that we output to
func (t *OutputBuffer) SetLines(v *lines.Lines) *OutputBuffer { t.Lines = v; return t }

// SetBatch sets the [OutputBuffer.Batch]:
// how much time to wait while batching output (default: 200ms)
func (t *OutputBuffer) SetBatch(v time.Duration) *OutputBuffer { t.Batch = v; return t }

// SetMarkupFunc sets the [OutputBuffer.MarkupFunc]:
// MarkupFunc is an optional markup function that adds html tags to given line
// of output. It is essential that it not add any new text, just splits into spans
// with different styles.
func (t *OutputBuffer) SetMarkupFunc(v OutputBufferMarkupFunc) *OutputBuffer {
        t.MarkupFunc = v
        return t
}

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/text/textcore.TwinEditors", IDName: "twin-editors", Doc: "TwinEditors presents two side-by-side [Editor]s in [core.Splits]\nthat scroll in sync with each other.", Embeds: []types.Field{{Name: "Splits"}}, Fields: []types.Field{{Name: "BufferA", Doc: "[Buffer] for A"}, {Name: "BufferB", Doc: "[Buffer] for B"}, {Name: "inInputEvent"}}})

// NewTwinEditors returns a new [TwinEditors] with the given optional parent:
// TwinEditors presents two side-by-side [Editor]s in [core.Splits]
// that scroll in sync with each other.
func NewTwinEditors(parent ...tree.Node) *TwinEditors { return tree.New[TwinEditors](parent...) }

// SetBufferA sets the [TwinEditors.BufferA]:
// [Buffer] for A
func (t *TwinEditors) SetBufferA(v *lines.Lines) *TwinEditors { t.BufferA = v; return t }

// SetBufferB sets the [TwinEditors.BufferB]:
// [Buffer] for B
func (t *TwinEditors) SetBufferB(v *lines.Lines) *TwinEditors { t.BufferB = v; return t }

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textpos

//go:generate core generate

import (
        "fmt"
        "slices"
        "time"

        "cogentcore.org/core/text/runes"
)

// Edit describes an edit action to line-based text, operating on
// a [Region] of the text.
// Actions are only deletions and insertions (a change is a sequence
// of each, given normal editing processes).
type Edit struct {

        // Region for the edit, specifying the region to delete, or the size
        // of the region to insert, corresponding to the Text.
        // Also contains the Time stamp for this edit.
        Region Region

        // Text deleted or inserted, in rune lines. For Rect this is the
        // spanning character distance per line, times number of lines.
        Text [][]rune

        // Group is the optional grouping number, for grouping edits in Undo for example.
        Group int

        // Delete indicates a deletion, otherwise an insertion.
        Delete bool

        // Rect is a rectangular region with upper left corner = Region.Start
        // and lower right corner = Region.End.
        // Otherwise it is for the full continuous region.
        Rect bool
}

// NewEditFromRunes returns a 0-based edit from given runes.
func NewEditFromRunes(text []rune) *Edit {
        if len(text) == 0 {
                return &Edit{}
        }
        lns := runes.Split(text, []rune("\n"))
        nl := len(lns)
        ec := len(lns[nl-1])
        ed := &Edit{}
        ed.Region = NewRegion(0, 0, nl-1, ec)
        ed.Text = lns
        return ed
}

// ToBytes returns the Text of this edit record to a byte string, with
// newlines at end of each line -- nil if Text is empty
func (te *Edit) ToBytes() []byte {
        if te == nil {
                return nil
        }
        sz := len(te.Text)
        if sz == 0 {
                return nil
        }
        if sz == 1 {
                return []byte(string(te.Text[0]))
        }
        tsz := 0
        for i := range te.Text {
                tsz += len(te.Text[i]) + 10 // don't bother converting to runes, just extra slack
        }
        b := make([]byte, 0, tsz)
        for i := range te.Text {
                b = append(b, []byte(string(te.Text[i]))...)
                if i < sz-1 {
                        b = append(b, '\n')
                }
        }
        return b
}

// AdjustPos adjusts the given text position as a function of the edit.
// If the position was within a deleted region of text, del determines
// what is returned.
func (te *Edit) AdjustPos(pos Pos, del AdjustPosDel) Pos {
        if te == nil {
                return pos
        }
        if pos.IsLess(te.Region.Start) || pos == te.Region.Start {
                return pos
        }
        dl := te.Region.End.Line - te.Region.Start.Line
        if pos.Line > te.Region.End.Line {
                if te.Delete {
                        pos.Line -= dl
                } else {
                        pos.Line += dl
                }
                return pos
        }
        if te.Delete {
                if pos.Line < te.Region.End.Line || pos.Char < te.Region.End.Char {
                        switch del {
                        case AdjustPosDelStart:
                                return te.Region.Start
                        case AdjustPosDelEnd:
                                return te.Region.End
                        case AdjustPosDelErr:
                                return PosErr
                        }
                }
                // this means pos.Line == te.Region.End.Line, Ch >= end
                if dl == 0 {
                        pos.Char -= (te.Region.End.Char - te.Region.Start.Char)
                } else {
                        pos.Char -= te.Region.End.Char
                }
        } else {
                if dl == 0 {
                        pos.Char += (te.Region.End.Char - te.Region.Start.Char)
                } else {
                        pos.Line += dl
                }
        }
        return pos
}

// AdjustPosDel determines what to do with positions within deleted region
type AdjustPosDel int32 //enums:enum

// these are options for what to do with positions within deleted region
// for the AdjustPos function
const (
        // AdjustPosDelErr means return a PosErr when in deleted region.
        AdjustPosDelErr AdjustPosDel = iota

        // AdjustPosDelStart means return start of deleted region.
        AdjustPosDelStart

        // AdjustPosDelEnd means return end of deleted region.
        AdjustPosDelEnd
)

// Clone returns a clone of the edit record.
func (te *Edit) Clone() *Edit {
        rc := &Edit{}
        rc.Copy(te)
        return rc
}

// Copy copies from other Edit, making a clone of the source text.
func (te *Edit) Copy(cp *Edit) {
        *te = *cp
        nl := len(cp.Text)
        if nl == 0 {
                te.Text = nil
                return
        }
        te.Text = make([][]rune, nl)
        for i, r := range cp.Text {
                te.Text[i] = slices.Clone(r)
        }
}

// AdjustPosIfAfterTime checks the time stamp and IfAfterTime,
// it adjusts the given text position as a function of the edit
// del determines what to do with positions within a deleted region
// either move to start or end of the region, or return an error.
func (te *Edit) AdjustPosIfAfterTime(pos Pos, t time.Time, del AdjustPosDel) Pos {
        if te == nil {
                return pos
        }
        if te.Region.IsAfterTime(t) {
                return te.AdjustPos(pos, del)
        }
        return pos
}

// AdjustRegion adjusts the given text region as a function of the edit, including
// checking that the timestamp on the region is after the edit time, if
// the region has a valid Time stamp (otherwise always does adjustment).
// If the starting position is within a deleted region, it is moved to the
// end of the deleted region, and if the ending position was within a deleted
// region, it is moved to the start.
func (te *Edit) AdjustRegion(reg Region) Region {
        if te == nil {
                return reg
        }
        if !reg.Time.IsZero() && !te.Region.IsAfterTime(reg.Time.Time()) {
                return reg
        }
        reg.Start = te.AdjustPos(reg.Start, AdjustPosDelEnd)
        reg.End = te.AdjustPos(reg.End, AdjustPosDelStart)
        if reg.IsNil() {
                return Region{}
        }
        return reg
}

func (te *Edit) String() string {
        str := te.Region.String()
        if te.Rect {
                str += " [Rect]"
        }
        if te.Delete {
                str += " [Delete]"
        }
        str += fmt.Sprintf(" Gp: %d\n", te.Group)
        for li := range te.Text {
                str += fmt.Sprintf("%d\t%s\n", li, string(te.Text[li]))
        }
        return str
}

// Code generated by "core generate"; DO NOT EDIT.

package textpos

import (
        "cogentcore.org/core/enums"
)

var _AdjustPosDelValues = []AdjustPosDel{0, 1, 2}

// AdjustPosDelN is the highest valid value for type AdjustPosDel, plus one.
const AdjustPosDelN AdjustPosDel = 3

var _AdjustPosDelValueMap = map[string]AdjustPosDel{`AdjustPosDelErr`: 0, `AdjustPosDelStart`: 1, `AdjustPosDelEnd`: 2}

var _AdjustPosDelDescMap = map[AdjustPosDel]string{0: `AdjustPosDelErr means return a PosErr when in deleted region.`, 1: `AdjustPosDelStart means return start of deleted region.`, 2: `AdjustPosDelEnd means return end of deleted region.`}

var _AdjustPosDelMap = map[AdjustPosDel]string{0: `AdjustPosDelErr`, 1: `AdjustPosDelStart`, 2: `AdjustPosDelEnd`}

// String returns the string representation of this AdjustPosDel value.
func (i AdjustPosDel) String() string { return enums.String(i, _AdjustPosDelMap) }

// SetString sets the AdjustPosDel value from its string representation,
// and returns an error if the string is invalid.
func (i *AdjustPosDel) SetString(s string) error {
        return enums.SetString(i, s, _AdjustPosDelValueMap, "AdjustPosDel")
}

// Int64 returns the AdjustPosDel value as an int64.
func (i AdjustPosDel) Int64() int64 { return int64(i) }

// SetInt64 sets the AdjustPosDel value from an int64.
func (i *AdjustPosDel) SetInt64(in int64) { *i = AdjustPosDel(in) }

// Desc returns the description of the AdjustPosDel value.
func (i AdjustPosDel) Desc() string { return enums.Desc(i, _AdjustPosDelDescMap) }

// AdjustPosDelValues returns all possible values for the type AdjustPosDel.
func AdjustPosDelValues() []AdjustPosDel { return _AdjustPosDelValues }

// Values returns all possible values for the type AdjustPosDel.
func (i AdjustPosDel) Values() []enums.Enum { return enums.Values(_AdjustPosDelValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i AdjustPosDel) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *AdjustPosDel) UnmarshalText(text []byte) error {
        return enums.UnmarshalText(i, text, "AdjustPosDel")
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textpos

// Match records one match for search within file, positions in runes.
type Match struct {

        // Region of the match. Column positions are in runes.
        Region Region

        // Text surrounding the match, at most MatchContext on either side
        // (within a single line).
        Text []rune

        // TextMatch has the Range within the Text where the match is.
        TextMatch Range
}

func (m *Match) String() string {
        return m.Region.String() + ": " + string(m.Text)
}

// MatchContext is how much text to include on either side of the match.
var MatchContext = 30

// NewMatch returns a new Match entry for given rune line with match starting
// at st and ending before ed, on given line
func NewMatch(rn []rune, st, ed, ln int) Match {
        sz := len(rn)
        reg := NewRegion(ln, st, ln, ed)
        cist := max(st-MatchContext, 0)
        cied := min(ed+MatchContext, sz)
        sctx := rn[cist:st]
        fstr := rn[st:ed]
        ectx := rn[ed:cied]
        tlen := len(sctx) + len(fstr) + len(ectx)
        txt := make([]rune, tlen)
        copy(txt, sctx)
        ti := st - cist
        copy(txt[ti:], fstr)
        ti += len(fstr)
        copy(txt[ti:], ectx)
        return Match{Region: reg, Text: txt, TextMatch: Range{Start: len(sctx), End: len(sctx) + len(fstr)}}
}

const (
        // IgnoreCase is passed to search functions to indicate case should be ignored
        IgnoreCase = true

        // UseCase is passed to search functions to indicate case is relevant
        UseCase = false
)

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textpos

import (
        "fmt"
        "strings"
)

// Pos is a text position in terms of line and character index within a line,
// using 0-based line numbers, which are converted to 1 base for the String()
// representation. Char positions are always in runes, and can also
// be used for other units such as tokens, spans, or runs.
type Pos struct {
        Line int
        Char int
}

// AddLine returns a Pos with Line number added.
func (ps Pos) AddLine(ln int) Pos {
        ps.Line += ln
        return ps
}

// AddChar returns a Pos with Char number added.
func (ps Pos) AddChar(ch int) Pos {
        ps.Char += ch
        return ps
}

// String satisfies the fmt.Stringer interferace
func (ps Pos) String() string {
        s := fmt.Sprintf("%d", ps.Line+1)
        if ps.Char != 0 {
                s += fmt.Sprintf(":%d", ps.Char)
        }
        return s
}

var (
        // PosErr represents an error text position (-1 for both line and char)
        // used as a return value for cases where error positions are possible.
        PosErr = Pos{-1, -1}

        PosZero = Pos{}
)

// IsLess returns true if receiver position is less than given comparison.
func (ps Pos) IsLess(cmp Pos) bool {
        switch {
        case ps.Line < cmp.Line:
                return true
        case ps.Line == cmp.Line:
                return ps.Char < cmp.Char
        default:
                return false
        }
}

// FromString decodes text position from a string representation of form:
// [#]LxxCxx. Used in e.g., URL links. Returns true if successful.
func (ps *Pos) FromString(link string) bool {
        link = strings.TrimPrefix(link, "#")
        lidx := strings.Index(link, "L")
        cidx := strings.Index(link, "C")

        switch {
        case lidx >= 0 && cidx >= 0:
                fmt.Sscanf(link, "L%dC%d", &ps.Line, &ps.Char)
                ps.Line-- // link is 1-based, we use 0-based
                ps.Char-- // ditto
        case lidx >= 0:
                fmt.Sscanf(link, "L%d", &ps.Line)
                ps.Line-- // link is 1-based, we use 0-based
        case cidx >= 0:
                fmt.Sscanf(link, "C%d", &ps.Char)
                ps.Char--
        default:
                // todo: could support other formats
                return false
        }
        return true
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textpos

// Range defines a range with a start and end index, where end is typically
// exclusive, as in standard slice indexing and for loop conventions.
type Range struct {
        // St is the starting index of the range.
        Start int

        // Ed is the ending index of the range.
        End int
}

// Len returns the length of the range: End - Start.
func (r Range) Len() int {
        return r.End - r.Start
}

// Contains returns true if range contains given index.
func (r Range) Contains(i int) bool {
        return i >= r.Start && i < r.End
}

// Intersect returns the intersection of two ranges.
// If they do not overlap, then the Start and End will be -1
func (r Range) Intersect(o Range) Range {
        o.Start = max(o.Start, r.Start)
        o.End = min(o.End, r.End)
        if o.Len() <= 0 {
                return Range{-1, -1}
        }
        return o
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textpos

import (
        "fmt"
        "strings"
        "time"

        "cogentcore.org/core/base/nptime"
)

var RegionZero = Region{}

// Region is a contiguous region within a source file with lines of rune chars,
// defined by start and end [Pos] positions.
// End.Char position is _exclusive_ so the last char is the one before End.Char.
// End.Line position is _inclusive_, so the last line is End.Line.
// There is a Time stamp for when the region was created as valid positions
// into the lines source, which is critical for tracking edits in live documents.
type Region struct {
        // Start is the starting position of region.
        Start Pos

        // End is the ending position of region.
        // Char position is _exclusive_ so the last char is the one before End.Char.
        // Line position is _inclusive_, so the last line is End.Line.
        End Pos

        // Time when region was set: needed for updating locations in the text based
        // on time stamp (using efficient non-pointer time).
        Time nptime.Time
}

// NewRegion creates a new text region using separate line and char
// values for start and end. Sets timestamp to now.
func NewRegion(stLn, stCh, edLn, edCh int) Region {
        tr := Region{Start: Pos{Line: stLn, Char: stCh}, End: Pos{Line: edLn, Char: edCh}}
        tr.TimeNow()
        return tr
}

// NewRegionPos creates a new text region using position values.
// Sets timestamp to now.
func NewRegionPos(st, ed Pos) Region {
        tr := Region{Start: st, End: ed}
        tr.TimeNow()
        return tr
}

// NewRegionLen makes a new Region from a starting point and a length
// along same line. Sets timestamp to now.
func NewRegionLen(start Pos, len int) Region {
        tr := Region{Start: start}
        tr.End = start
        tr.End.Char += len
        tr.TimeNow()
        return tr
}

// IsNil checks if the region is empty, because the start is after or equal to the end.
func (tr Region) IsNil() bool {
        return !tr.Start.IsLess(tr.End)
}

// Contains returns true if region contains given position.
func (tr Region) Contains(ps Pos) bool {
        return ps.IsLess(tr.End) && (tr.Start == ps || tr.Start.IsLess(ps))
}

// ContainsLine returns true if line is within region
func (tr Region) ContainsLine(ln int) bool {
        return tr.Start.Line >= ln && ln <= tr.End.Line
}

// NumLines is the number of lines in this region, based on inclusive end line.
func (tr Region) NumLines() int {
        return 1 + (tr.End.Line - tr.Start.Line)
}

// Intersect returns the intersection of this region with given
// other region, where the other region is assumed to be the larger,
// constraining region, within which you are fitting the receiver region.
// Char level start / end are only constrained if on same Start / End line.
// The given endChar value is used for the end of an interior line.
func (tr Region) Intersect(or Region, endChar int) Region {
        switch {
        case tr.Start.Line < or.Start.Line:
                tr.Start = or.Start
        case tr.Start.Line == or.Start.Line:
                tr.Start.Char = max(tr.Start.Char, or.Start.Char)
        case tr.Start.Line < or.End.Line:
                tr.Start.Char = 0
        case tr.Start.Line == or.End.Line:
                tr.Start.Char = min(tr.Start.Char, or.End.Char-1)
        default:
                return Region{} // not in bounds
        }
        if tr.End.Line == tr.Start.Line { // keep valid
                tr.End.Char = max(tr.End.Char, tr.Start.Char)
        }
        switch {
        case tr.End.Line < or.End.Line:
                tr.End.Char = endChar
        case tr.End.Line == or.End.Line:
                tr.End.Char = min(tr.End.Char, or.End.Char)
        }
        return tr
}

// ShiftLines returns a new Region with the start and End lines
// shifted by given number of lines.
func (tr Region) ShiftLines(ln int) Region {
        tr.Start.Line += ln
        tr.End.Line += ln
        return tr
}

// MoveToLine returns a new Region with the Start line
// set to given line.
func (tr Region) MoveToLine(ln int) Region {
        nl := tr.NumLines()
        tr.Start.Line = 0
        tr.End.Line = nl - 1
        return tr
}

////////  Time

// TimeNow grabs the current time as the edit time.
func (tr *Region) TimeNow() {
        tr.Time.Now()
}

// IsAfterTime reports if this region's time stamp is after given time value
// if region Time stamp has not been set, it always returns true
func (tr *Region) IsAfterTime(t time.Time) bool {
        if tr.Time.IsZero() {
                return true
        }
        return tr.Time.Time().After(t)
}

// Ago returns how long ago this Region's time stamp is relative
// to given time.
func (tr *Region) Ago(t time.Time) time.Duration {
        return t.Sub(tr.Time.Time())
}

// Age returns the time interval from [time.Now]
func (tr *Region) Age() time.Duration {
        return tr.Ago(time.Now())
}

// Since returns the time interval between
// this Region's time stamp and that of the given earlier region's stamp.
func (tr *Region) Since(earlier *Region) time.Duration {
        return earlier.Ago(tr.Time.Time())
}

// FromStringURL decodes text region from a string representation of form:
// [#]LxxCxx-LxxCxx. Used in e.g., URL links. returns true if successful
func (tr *Region) FromStringURL(link string) bool {
        link = strings.TrimPrefix(link, "#")
        fmt.Sscanf(link, "L%dC%d-L%dC%d", &tr.Start.Line, &tr.Start.Char, &tr.End.Line, &tr.End.Char)
        return true
}

func (tr *Region) String() string {
        return fmt.Sprintf("[%s - %s]", tr.Start, tr.End)
}

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textpos

import "unicode"

// RuneIsWordBreak returns true if given rune counts as a word break
// for the purposes of selecting words.
func RuneIsWordBreak(r rune) bool {
        return unicode.IsSpace(r) || unicode.IsSymbol(r) || unicode.IsPunct(r)
}

// IsWordBreak defines what counts as a word break for the purposes of selecting words.
// r1 is the rune in question, r2 is the rune past r1 in the direction you are moving.
// Pass -1 for r2 if there is no rune past r1.
func IsWordBreak(r1, r2 rune) bool {
        if r2 == -1 {
                return RuneIsWordBreak(r1)
        }
        if unicode.IsSpace(r1) || unicode.IsSymbol(r1) {
                return true
        }
        if unicode.IsPunct(r1) && r1 != rune('\'') {
                return true
        }
        if unicode.IsPunct(r1) && r1 == rune('\'') {
                return unicode.IsSpace(r2) || unicode.IsSymbol(r2) || unicode.IsPunct(r2)
        }
        return false
}

// WordAt returns the range for a word within given text starting at given
// position index. If the current position is a word break then go to next
// break after the first non-break.
func WordAt(txt []rune, pos int) Range {
        var rg Range
        sz := len(txt)
        if sz == 0 {
                return rg
        }
        if pos < 0 {
                pos = 0
        }
        if pos >= sz {
                pos = sz - 1
        }
        rg.Start = pos
        if !RuneIsWordBreak(txt[rg.Start]) {
                for rg.Start > 0 {
                        if RuneIsWordBreak(txt[rg.Start-1]) {
                                break
                        }
                        rg.Start--
                }
                rg.End = pos + 1
                for rg.End < sz {
                        if RuneIsWordBreak(txt[rg.End]) {
                                break
                        }
                        rg.End++
                }
                return rg
        }
        // keep the space start -- go to next space..
        rg.End = pos + 1
        for rg.End < sz {
                if !RuneIsWordBreak(txt[rg.End]) {
                        break
                }
                rg.End++
        }
        for rg.End < sz {
                if RuneIsWordBreak(txt[rg.End]) {
                        break
                }
                rg.End++
        }
        return rg
}

// ForwardWord moves position index forward by words, for given
// number of steps. Returns the number of steps actually moved,
// given the amount of text available.
func ForwardWord(txt []rune, pos, steps int) (wpos, nstep int) {
        sz := len(txt)
        if sz == 0 {
                return 0, 0
        }
        if pos >= sz-1 {
                return sz - 1, 0
        }
        if pos < 0 {
                pos = 0
        }
        for range steps {
                if pos == sz-1 {
                        break
                }
                ch := pos
                for ch < sz-1 { // if on a wb, go past
                        if !IsWordBreak(txt[ch], txt[ch+1]) {
                                break
                        }
                        ch++
                }
                for ch < sz-1 { // now go to next wb
                        if IsWordBreak(txt[ch], txt[ch+1]) {
                                break
                        }
                        ch++
                }
                pos = ch
                nstep++
        }
        return pos, nstep
}

// BackwardWord moves position index backward by words, for given
// number of steps. Returns the number of steps actually moved,
// given the amount of text available.
func BackwardWord(txt []rune, pos, steps int) (wpos, nstep int) {
        sz := len(txt)
        if sz == 0 {
                return 0, 0
        }
        if pos <= 0 {
                return 0, 0
        }
        if pos >= sz {
                pos = sz - 1
        }
        for range steps {
                if pos == 0 {
                        break
                }
                ch := pos
                for ch > 0 { // if on a wb, go past
                        if !IsWordBreak(txt[ch], txt[ch-1]) {
                                break
                        }
                        ch--
                }
                for ch > 0 { // now go to next wb
                        if IsWordBreak(txt[ch], txt[ch-1]) {
                                break
                        }
                        ch--
                }
                pos = ch
                nstep++
        }
        return pos, nstep
}

// Code generated by "core generate"; DO NOT EDIT.

package token

import (
        "cogentcore.org/core/enums"
)

var _TokensValues = []Tokens{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176}

// TokensN is the highest valid value for type Tokens, plus one.
const TokensN Tokens = 177

var _TokensValueMap = map[string]Tokens{`None`: 0, `Error`: 1, `EOF`: 2, `EOL`: 3, `EOS`: 4, `Background`: 5, `Keyword`: 6, `KeywordConstant`: 7, `KeywordDeclaration`: 8, `KeywordNamespace`: 9, `KeywordPseudo`: 10, `KeywordReserved`: 11, `KeywordType`: 12, `Name`: 13, `NameBuiltin`: 14, `NameBuiltinPseudo`: 15, `NameOther`: 16, `NamePseudo`: 17, `NameType`: 18, `NameClass`: 19, `NameStruct`: 20, `NameField`: 21, `NameInterface`: 22, `NameConstant`: 23, `NameEnum`: 24, `NameEnumMember`: 25, `NameArray`: 26, `NameMap`: 27, `NameObject`: 28, `NameTypeParam`: 29, `NameFunction`: 30, `NameDecorator`: 31, `NameFunctionMagic`: 32, `NameMethod`: 33, `NameOperator`: 34, `NameConstructor`: 35, `NameException`: 36, `NameLabel`: 37, `NameEvent`: 38, `NameScope`: 39, `NameNamespace`: 40, `NameModule`: 41, `NamePackage`: 42, `NameLibrary`: 43, `NameVar`: 44, `NameVarAnonymous`: 45, `NameVarClass`: 46, `NameVarGlobal`: 47, `NameVarInstance`: 48, `NameVarMagic`: 49, `NameVarParam`: 50, `NameValue`: 51, `NameTag`: 52, `NameProperty`: 53, `NameAttribute`: 54, `NameEntity`: 55, `Literal`: 56, `LiteralDate`: 57, `LiteralOther`: 58, `LiteralBool`: 59, `LitStr`: 60, `LitStrAffix`: 61, `LitStrAtom`: 62, `LitStrBacktick`: 63, `LitStrBoolean`: 64, `LitStrChar`: 65, `LitStrDelimiter`: 66, `LitStrDoc`: 67, `LitStrDouble`: 68, `LitStrEscape`: 69, `LitStrHeredoc`: 70, `LitStrInterpol`: 71, `LitStrName`: 72, `LitStrOther`: 73, `LitStrRegex`: 74, `LitStrSingle`: 75, `LitStrSymbol`: 76, `LitStrFile`: 77, `LitNum`: 78, `LitNumBin`: 79, `LitNumFloat`: 80, `LitNumHex`: 81, `LitNumInteger`: 82, `LitNumIntegerLong`: 83, `LitNumOct`: 84, `LitNumImag`: 85, `Operator`: 86, `OperatorWord`: 87, `OpMath`: 88, `OpMathAdd`: 89, `OpMathSub`: 90, `OpMathMul`: 91, `OpMathDiv`: 92, `OpMathRem`: 93, `OpBit`: 94, `OpBitAnd`: 95, `OpBitOr`: 96, `OpBitNot`: 97, `OpBitXor`: 98, `OpBitShiftLeft`: 99, `OpBitShiftRight`: 100, `OpBitAndNot`: 101, `OpAsgn`: 102, `OpAsgnAssign`: 103, `OpAsgnInc`: 104, `OpAsgnDec`: 105, `OpAsgnArrow`: 106, `OpAsgnDefine`: 107, `OpMathAsgn`: 108, `OpMathAsgnAdd`: 109, `OpMathAsgnSub`: 110, `OpMathAsgnMul`: 111, `OpMathAsgnDiv`: 112, `OpMathAsgnRem`: 113, `OpBitAsgn`: 114, `OpBitAsgnAnd`: 115, `OpBitAsgnOr`: 116, `OpBitAsgnXor`: 117, `OpBitAsgnShiftLeft`: 118, `OpBitAsgnShiftRight`: 119, `OpBitAsgnAndNot`: 120, `OpLog`: 121, `OpLogAnd`: 122, `OpLogOr`: 123, `OpLogNot`: 124, `OpRel`: 125, `OpRelEqual`: 126, `OpRelNotEqual`: 127, `OpRelLess`: 128, `OpRelGreater`: 129, `OpRelLtEq`: 130, `OpRelGtEq`: 131, `OpList`: 132, `OpListEllipsis`: 133, `Punctuation`: 134, `PunctGp`: 135, `PunctGpLParen`: 136, `PunctGpRParen`: 137, `PunctGpLBrack`: 138, `PunctGpRBrack`: 139, `PunctGpLBrace`: 140, `PunctGpRBrace`: 141, `PunctSep`: 142, `PunctSepComma`: 143, `PunctSepPeriod`: 144, `PunctSepSemicolon`: 145, `PunctSepColon`: 146, `PunctStr`: 147, `PunctStrDblQuote`: 148, `PunctStrQuote`: 149, `PunctStrBacktick`: 150, `PunctStrEsc`: 151, `Comment`: 152, `CommentHashbang`: 153, `CommentMultiline`: 154, `CommentSingle`: 155, `CommentSpecial`: 156, `CommentPreproc`: 157, `CommentPreprocFile`: 158, `Text`: 159, `TextWhitespace`: 160, `TextSymbol`: 161, `TextPunctuation`: 162, `TextSpellErr`: 163, `TextStyle`: 164, `TextStyleDeleted`: 165, `TextStyleEmph`: 166, `TextStyleError`: 167, `TextStyleHeading`: 168, `TextStyleInserted`: 169, `TextStyleOutput`: 170, `TextStylePrompt`: 171, `TextStyleStrong`: 172, `TextStyleSubheading`: 173, `TextStyleTraceback`: 174, `TextStyleUnderline`: 175, `TextStyleLink`: 176}

var _TokensDescMap = map[Tokens]string{0: `None is the nil token value -- for non-terminal cases or TBD`, 1: `Error is an input that could not be tokenized due to syntax error etc`, 2: `EOF is end of file`, 3: `EOL is end of line (typically implicit -- used for rule matching)`, 4: `EOS is end of statement -- a key meta-token -- in C it is ;, in Go it is either ; or EOL`, 5: `Background is for syntax highlight styles based on these tokens`, 6: `Cat: Keywords (actual keyword is just the string)`, 7: ``, 8: ``, 9: ``, 10: ``, 11: ``, 12: ``, 13: `Cat: Names.`, 14: ``, 15: ``, 16: ``, 17: ``, 18: `SubCat: Type names`, 19: ``, 20: ``, 21: ``, 22: ``, 23: ``, 24: ``, 25: ``, 26: ``, 27: ``, 28: ``, 29: ``, 30: `SubCat: Function names`, 31: ``, 32: ``, 33: ``, 34: ``, 35: ``, 36: ``, 37: ``, 38: ``, 39: `SubCat: Scoping names`, 40: ``, 41: ``, 42: ``, 43: ``, 44: `SubCat: NameVar -- variable names`, 45: ``, 46: ``, 47: ``, 48: ``, 49: ``, 50: ``, 51: `SubCat: Value -- data-like elements`, 52: ``, 53: ``, 54: ``, 55: ``, 56: `Cat: Literals.`, 57: ``, 58: ``, 59: ``, 60: `SubCat: Literal Strings.`, 61: ``, 62: ``, 63: ``, 64: ``, 65: ``, 66: ``, 67: ``, 68: ``, 69: ``, 70: ``, 71: ``, 72: ``, 73: ``, 74: ``, 75: ``, 76: ``, 77: ``, 78: `SubCat: Literal Numbers.`, 79: ``, 80: ``, 81: ``, 82: ``, 83: ``, 84: ``, 85: ``, 86: `Cat: Operators.`, 87: ``, 88: `SubCat: Math operators`, 89: ``, 90: ``, 91: ``, 92: ``, 93: ``, 94: `SubCat: Bitwise operators`, 95: ``, 96: ``, 97: ``, 98: ``, 99: ``, 100: ``, 101: ``, 102: `SubCat: Assign operators`, 103: ``, 104: ``, 105: ``, 106: ``, 107: ``, 108: `SubCat: Math Assign operators`, 109: ``, 110: ``, 111: ``, 112: ``, 113: ``, 114: `SubCat: Bitwise Assign operators`, 115: ``, 116: ``, 117: ``, 118: ``, 119: ``, 120: ``, 121: `SubCat: Logical operators`, 122: ``, 123: ``, 124: ``, 125: `SubCat: Relational operators`, 126: ``, 127: ``, 128: ``, 129: ``, 130: ``, 131: ``, 132: `SubCat: List operators`, 133: ``, 134: `Cat: Punctuation.`, 135: `SubCat: Grouping punctuation`, 136: ``, 137: ``, 138: ``, 139: ``, 140: ``, 141: ``, 142: `SubCat: Separator punctuation`, 143: ``, 144: ``, 145: ``, 146: ``, 147: `SubCat: String punctuation`, 148: ``, 149: ``, 150: ``, 151: ``, 152: `Cat: Comments.`, 153: ``, 154: ``, 155: ``, 156: ``, 157: `SubCat: Preprocessor "comments".`, 158: ``, 159: `Cat: Text.`, 160: ``, 161: ``, 162: ``, 163: ``, 164: `SubCat: TextStyle (corresponds to Generic in chroma / pygments) todo: look in font deco for more`, 165: ``, 166: ``, 167: ``, 168: ``, 169: ``, 170: ``, 171: ``, 172: ``, 173: ``, 174: ``, 175: ``, 176: ``}

var _TokensMap = map[Tokens]string{0: `None`, 1: `Error`, 2: `EOF`, 3: `EOL`, 4: `EOS`, 5: `Background`, 6: `Keyword`, 7: `KeywordConstant`, 8: `KeywordDeclaration`, 9: `KeywordNamespace`, 10: `KeywordPseudo`, 11: `KeywordReserved`, 12: `KeywordType`, 13: `Name`, 14: `NameBuiltin`, 15: `NameBuiltinPseudo`, 16: `NameOther`, 17: `NamePseudo`, 18: `NameType`, 19: `NameClass`, 20: `NameStruct`, 21: `NameField`, 22: `NameInterface`, 23: `NameConstant`, 24: `NameEnum`, 25: `NameEnumMember`, 26: `NameArray`, 27: `NameMap`, 28: `NameObject`, 29: `NameTypeParam`, 30: `NameFunction`, 31: `NameDecorator`, 32: `NameFunctionMagic`, 33: `NameMethod`, 34: `NameOperator`, 35: `NameConstructor`, 36: `NameException`, 37: `NameLabel`, 38: `NameEvent`, 39: `NameScope`, 40: `NameNamespace`, 41: `NameModule`, 42: `NamePackage`, 43: `NameLibrary`, 44: `NameVar`, 45: `NameVarAnonymous`, 46: `NameVarClass`, 47: `NameVarGlobal`, 48: `NameVarInstance`, 49: `NameVarMagic`, 50: `NameVarParam`, 51: `NameValue`, 52: `NameTag`, 53: `NameProperty`, 54: `NameAttribute`, 55: `NameEntity`, 56: `Literal`, 57: `LiteralDate`, 58: `LiteralOther`, 59: `LiteralBool`, 60: `LitStr`, 61: `LitStrAffix`, 62: `LitStrAtom`, 63: `LitStrBacktick`, 64: `LitStrBoolean`, 65: `LitStrChar`, 66: `LitStrDelimiter`, 67: `LitStrDoc`, 68: `LitStrDouble`, 69: `LitStrEscape`, 70: `LitStrHeredoc`, 71: `LitStrInterpol`, 72: `LitStrName`, 73: `LitStrOther`, 74: `LitStrRegex`, 75: `LitStrSingle`, 76: `LitStrSymbol`, 77: `LitStrFile`, 78: `LitNum`, 79: `LitNumBin`, 80: `LitNumFloat`, 81: `LitNumHex`, 82: `LitNumInteger`, 83: `LitNumIntegerLong`, 84: `LitNumOct`, 85: `LitNumImag`, 86: `Operator`, 87: `OperatorWord`, 88: `OpMath`, 89: `OpMathAdd`, 90: `OpMathSub`, 91: `OpMathMul`, 92: `OpMathDiv`, 93: `OpMathRem`, 94: `OpBit`, 95: `OpBitAnd`, 96: `OpBitOr`, 97: `OpBitNot`, 98: `OpBitXor`, 99: `OpBitShiftLeft`, 100: `OpBitShiftRight`, 101: `OpBitAndNot`, 102: `OpAsgn`, 103: `OpAsgnAssign`, 104: `OpAsgnInc`, 105: `OpAsgnDec`, 106: `OpAsgnArrow`, 107: `OpAsgnDefine`, 108: `OpMathAsgn`, 109: `OpMathAsgnAdd`, 110: `OpMathAsgnSub`, 111: `OpMathAsgnMul`, 112: `OpMathAsgnDiv`, 113: `OpMathAsgnRem`, 114: `OpBitAsgn`, 115: `OpBitAsgnAnd`, 116: `OpBitAsgnOr`, 117: `OpBitAsgnXor`, 118: `OpBitAsgnShiftLeft`, 119: `OpBitAsgnShiftRight`, 120: `OpBitAsgnAndNot`, 121: `OpLog`, 122: `OpLogAnd`, 123: `OpLogOr`, 124: `OpLogNot`, 125: `OpRel`, 126: `OpRelEqual`, 127: `OpRelNotEqual`, 128: `OpRelLess`, 129: `OpRelGreater`, 130: `OpRelLtEq`, 131: `OpRelGtEq`, 132: `OpList`, 133: `OpListEllipsis`, 134: `Punctuation`, 135: `PunctGp`, 136: `PunctGpLParen`, 137: `PunctGpRParen`, 138: `PunctGpLBrack`, 139: `PunctGpRBrack`, 140: `PunctGpLBrace`, 141: `PunctGpRBrace`, 142: `PunctSep`, 143: `PunctSepComma`, 144: `PunctSepPeriod`, 145: `PunctSepSemicolon`, 146: `PunctSepColon`, 147: `PunctStr`, 148: `PunctStrDblQuote`, 149: `PunctStrQuote`, 150: `PunctStrBacktick`, 151: `PunctStrEsc`, 152: `Comment`, 153: `CommentHashbang`, 154: `CommentMultiline`, 155: `CommentSingle`, 156: `CommentSpecial`, 157: `CommentPreproc`, 158: `CommentPreprocFile`, 159: `Text`, 160: `TextWhitespace`, 161: `TextSymbol`, 162: `TextPunctuation`, 163: `TextSpellErr`, 164: `TextStyle`, 165: `TextStyleDeleted`, 166: `TextStyleEmph`, 167: `TextStyleError`, 168: `TextStyleHeading`, 169: `TextStyleInserted`, 170: `TextStyleOutput`, 171: `TextStylePrompt`, 172: `TextStyleStrong`, 173: `TextStyleSubheading`, 174: `TextStyleTraceback`, 175: `TextStyleUnderline`, 176: `TextStyleLink`}

// String returns the string representation of this Tokens value.
func (i Tokens) String() string { return enums.String(i, _TokensMap) }

// SetString sets the Tokens value from its string representation,
// and returns an error if the string is invalid.
func (i *Tokens) SetString(s string) error { return enums.SetString(i, s, _TokensValueMap, "Tokens") }

// Int64 returns the Tokens value as an int64.
func (i Tokens) Int64() int64 { return int64(i) }

// SetInt64 sets the Tokens value from an int64.
func (i *Tokens) SetInt64(in int64) { *i = Tokens(in) }

// Desc returns the description of the Tokens value.
func (i Tokens) Desc() string { return enums.Desc(i, _TokensDescMap) }

// TokensValues returns all possible values for the type Tokens.
func TokensValues() []Tokens { return _TokensValues }

// Values returns all possible values for the type Tokens.
func (i Tokens) Values() []enums.Enum { return enums.Values(_TokensValues) }

// MarshalText implements the [encoding.TextMarshaler] interface.
func (i Tokens) MarshalText() ([]byte, error) { return []byte(i.String()), nil }

// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
func (i *Tokens) UnmarshalText(text []byte) error { return enums.UnmarshalText(i, text, "Tokens") }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package token defines a complete set of all lexical tokens for any kind of
// language!  It is based on the alecthomas/chroma / pygments lexical tokens
// plus all the more detailed tokens needed for actually parsing languages
package token

//go:generate core generate

import (
        "fmt"

        "cogentcore.org/core/icons"
)

// Tokens is a complete set of lexical tokens that encompasses all programming and text
// markup languages.  It includes everything in alecthomas/chroma (pygments) and
// everything needed for Go, C, C++, Python, etc.
//
// There are categories and sub-categories, and methods to get those from a given
// element.  The first category is 'None'.
//
// See http://pygments.org/docs/tokens/ for more docs on the different categories
//
// Anything missing should be added via a pull request etc
type Tokens int32 //enums:enum

// CatMap is the map into the category level for each token
var CatMap map[Tokens]Tokens

// SubCatMap is the map into the sub-category level for each token
var SubCatMap map[Tokens]Tokens

func init() {
        InitCatMap()
        InitSubCatMap()
}

// Cat returns the category that a given token lives in, using CatMap
func (tk Tokens) Cat() Tokens {
        return CatMap[tk]
}

// SubCat returns the sub-category that a given token lives in, using SubCatMap
func (tk Tokens) SubCat() Tokens {
        return SubCatMap[tk]
}

// IsCat returns true if this is a category-level token
func (tk Tokens) IsCat() bool {
        return tk.Cat() == tk
}

// IsSubCat returns true if this is a sub-category-level token
func (tk Tokens) IsSubCat() bool {
        return tk.SubCat() == tk
}

// InCat returns true if this is in same category as given token
func (tk Tokens) InCat(other Tokens) bool {
        return tk.Cat() == other.Cat()
}

// InCat returns true if this is in same sub-category as given token
func (tk Tokens) InSubCat(other Tokens) bool {
        return tk.SubCat() == other.SubCat()
}

// IsCode returns true if this token is in Keyword, Name, Operator, or Punctuation categs.
// these are recognized code (program) elements that can usefully be distinguished from
// other forms of raw text (e.g., for spell checking)
func (tk Tokens) IsCode() bool {
        return tk.InCat(Keyword) || tk.InCat(Name) || tk.InCat(Operator) || tk.InCat(Punctuation)
}

// IsKeyword returns true if this in the Keyword category
func (tk Tokens) IsKeyword() bool {
        return tk.Cat() == Keyword
}

// Parent returns the closest parent-level of this token (subcat or cat)
func (tk Tokens) Parent() Tokens {
        if tk.IsSubCat() {
                return tk.Cat()
        }
        return tk.SubCat()
}

// Match returns true if the two tokens match, in a category / subcategory sensitive manner:
// if receiver token is a category, then it matches other token if it is the same category
// and likewise for subcategory
func (tk Tokens) Match(otk Tokens) bool {
        if tk == otk {
                return true
        }
        if tk.IsCat() && otk.Cat() == tk {
                return true
        }
        return tk.IsSubCat() && otk.SubCat() == tk
}

// IsPunctGpLeft returns true if token is a PunctGpL token -- left paren, brace, bracket
func (tk Tokens) IsPunctGpLeft() bool {
        return (tk == PunctGpLParen || tk == PunctGpLBrack || tk == PunctGpLBrace)
}

// IsPunctGpRight returns true if token is a PunctGpR token -- right paren, brace, bracket
func (tk Tokens) IsPunctGpRight() bool {
        return (tk == PunctGpRParen || tk == PunctGpRBrack || tk == PunctGpRBrace)
}

// PunctGpMatch returns the matching token for given PunctGp token
func (tk Tokens) PunctGpMatch() Tokens {
        switch tk {
        case PunctGpLParen:
                return PunctGpRParen
        case PunctGpRParen:
                return PunctGpLParen
        case PunctGpLBrack:
                return PunctGpRBrack
        case PunctGpRBrack:
                return PunctGpLBrack
        case PunctGpLBrace:
                return PunctGpRBrace
        case PunctGpRBrace:
                return PunctGpLBrace
        }
        return None
}

// IsAmbigUnaryOp returns true if this token is an operator that could either be
// a Unary or Binary operator -- need special matching for this.
// includes * and & which are used for address operations in C-like languages
func (tk Tokens) IsAmbigUnaryOp() bool {
        return (tk == OpMathSub || tk == OpMathMul || tk == OpBitAnd || tk == OpMathAdd || tk == OpBitXor)
}

// IsUnaryOp returns true if this token is an operator that is typically used as
// a Unary operator: - + & * ! ^ ! <-
func (tk Tokens) IsUnaryOp() bool {
        return (tk == OpMathSub || tk == OpMathMul || tk == OpBitAnd || tk == OpMathAdd ||
                tk == OpBitXor || tk == OpLogNot || tk == OpAsgnArrow)
}

// CombineRepeats are token types where repeated tokens of the same type should
// be combined together -- literals, comments, text
func (tk Tokens) CombineRepeats() bool {
        cat := tk.Cat()
        return (cat == Literal || cat == Comment || cat == Text || cat == Name)
}

// StyleName returns the abbreviated 2-3 letter style name of the tag
func (tk Tokens) StyleName() string {
        return Names[tk]
}

// ClassName returns the . prefixed CSS classname of the tag style
// for styling, a CSS property should exist with this name
func (tk Tokens) ClassName() string {
        return "." + tk.StyleName()
}

/////////////////////////////////////////////////////////////////////////////
//  KeyToken -- keyword + token

// KeyToken combines a token and an optional keyword name for Keyword token types
// if Tok is in Keyword category, then Key string can be used to check for same keyword.
// Also has a Depth for matching against a particular nesting depth
type KeyToken struct {
        Token Tokens
        Key   string
        Depth int
}

var KeyTokenZero = KeyToken{}

func (kt KeyToken) String() string {
        ds := ""
        if kt.Depth != 0 {
                ds = fmt.Sprintf("+%d:", kt.Depth)
        }
        if kt.Key != "" {
                return ds + kt.Token.String() + ": " + kt.Key
        }
        return ds + kt.Token.String()
}

// Equal compares equality of two tokens including keywords if token is in Keyword category.
// See also Match for version that uses category / subcategory matching
func (kt KeyToken) Equal(okt KeyToken) bool {
        if kt.Token.IsKeyword() && kt.Key != "" {
                return kt.Token == okt.Token && kt.Key == okt.Key
        }
        return kt.Token == okt.Token
}

// Match compares equality of two tokens including keywords if token is in Keyword category.
// returns true if the two tokens match, in a category / subcategory sensitive manner:
// if receiver token is a category, then it matches other token if it is the same category
// and likewise for subcategory
func (kt KeyToken) Match(okt KeyToken) bool {
        if kt.Token.IsKeyword() && kt.Key != "" {
                return kt.Token.Match(okt.Token) && kt.Key == okt.Key
        }
        return kt.Token.Match(okt.Token)
}

// MatchDepth compares equality of two tokens including depth -- see Match for other matching
// criteria
func (kt KeyToken) MatchDepth(okt KeyToken) bool {
        if kt.Depth != okt.Depth {
                return false
        }
        return kt.Match(okt)
}

// StringKey encodes token into a string for optimized string-based map key lookup
func (kt KeyToken) StringKey() string {
        tstr := string([]byte{byte(kt.Token)})
        if kt.Token.IsKeyword() {
                return tstr + kt.Key
        }
        return tstr
}

// KeyTokenList is a list (slice) of KeyTokens
type KeyTokenList []KeyToken

// Match returns true if given keytoken matches any of the items on the list
func (kl KeyTokenList) Match(okt KeyToken) bool {
        for _, kt := range kl {
                if kt.Match(okt) {
                        return true
                }
        }
        return false
}

// Icon returns the appropriate icon for the type of lexical item this is.
func (tk Tokens) Icon() icons.Icon {
        switch {
        case tk.SubCat() == NameVar:
                return icons.Variable
        case tk == NameConstant || tk == NameEnum || tk == NameEnumMember:
                return icons.Constant
        case tk == NameField:
                return icons.Field
        case tk.SubCat() == NameType:
                return icons.Type
        case tk == NameMethod:
                return icons.Method
        case tk.SubCat() == NameFunction:
                return icons.Function
        }
        return ""
}

/////////////////////////////////////////////////////////////////////////////
//  Tokens

// The list of tokens
const (
        // None is the nil token value -- for non-terminal cases or TBD
        None Tokens = iota

        // Error is an input that could not be tokenized due to syntax error etc
        Error

        // EOF is end of file
        EOF

        // EOL is end of line (typically implicit -- used for rule matching)
        EOL

        // EOS is end of statement -- a key meta-token -- in C it is ;, in Go it is either ; or EOL
        EOS

        // Background is for syntax highlight styles based on these tokens
        Background

        // Cat: Keywords (actual keyword is just the string)
        Keyword
        KeywordConstant
        KeywordDeclaration
        KeywordNamespace // incl package, import
        KeywordPseudo
        KeywordReserved
        KeywordType

        // Cat: Names.
        Name
        NameBuiltin       // e.g., true, false -- builtin values..
        NameBuiltinPseudo // e.g., this, self
        NameOther
        NamePseudo

        // SubCat: Type names
        NameType
        NameClass
        NameStruct
        NameField
        NameInterface
        NameConstant
        NameEnum
        NameEnumMember
        NameArray // includes slice etc
        NameMap
        NameObject
        NameTypeParam // for generics, templates

        // SubCat: Function names
        NameFunction
        NameDecorator     // function-like wrappers in python
        NameFunctionMagic // e.g., __init__ in python
        NameMethod
        NameOperator
        NameConstructor // includes destructor..
        NameException
        NameLabel // e.g., goto label
        NameEvent // for LSP -- not really sure what it is..

        // SubCat: Scoping names
        NameScope
        NameNamespace
        NameModule
        NamePackage
        NameLibrary

        // SubCat: NameVar -- variable names
        NameVar
        NameVarAnonymous
        NameVarClass
        NameVarGlobal
        NameVarInstance
        NameVarMagic
        NameVarParam

        // SubCat: Value -- data-like elements
        NameValue
        NameTag // e.g., HTML tag
        NameProperty
        NameAttribute // e.g., HTML attr
        NameEntity    // special entities. (e.g. &nbsp; in HTML).  seems like other..

        // Cat: Literals.
        Literal
        LiteralDate
        LiteralOther
        LiteralBool

        // SubCat: Literal Strings.
        LitStr
        LitStrAffix // unicode specifiers etc
        LitStrAtom
        LitStrBacktick
        LitStrBoolean
        LitStrChar
        LitStrDelimiter
        LitStrDoc // doc-specific strings where syntactically noted
        LitStrDouble
        LitStrEscape   // esc sequences within strings
        LitStrHeredoc  // in ruby, perl
        LitStrInterpol // interpolated parts of strings in #{foo} in Ruby
        LitStrName
        LitStrOther
        LitStrRegex
        LitStrSingle
        LitStrSymbol
        LitStrFile // filename

        // SubCat: Literal Numbers.
        LitNum
        LitNumBin
        LitNumFloat
        LitNumHex
        LitNumInteger
        LitNumIntegerLong
        LitNumOct
        LitNumImag

        // Cat: Operators.
        Operator
        OperatorWord

        // SubCat: Math operators
        OpMath
        OpMathAdd // +
        OpMathSub // -
        OpMathMul // *
        OpMathDiv // /
        OpMathRem // %

        // SubCat: Bitwise operators
        OpBit
        OpBitAnd        // &
        OpBitOr         // |
        OpBitNot        // ~
        OpBitXor        // ^
        OpBitShiftLeft  // <<
        OpBitShiftRight // >>
        OpBitAndNot     // &^

        // SubCat: Assign operators
        OpAsgn
        OpAsgnAssign // =
        OpAsgnInc    // ++
        OpAsgnDec    // --
        OpAsgnArrow  // <-
        OpAsgnDefine // :=

        // SubCat: Math Assign operators
        OpMathAsgn
        OpMathAsgnAdd // +=
        OpMathAsgnSub // -=
        OpMathAsgnMul // *=
        OpMathAsgnDiv // /=
        OpMathAsgnRem // %=

        // SubCat: Bitwise Assign operators
        OpBitAsgn
        OpBitAsgnAnd        // &=
        OpBitAsgnOr         // |=
        OpBitAsgnXor        // ^=
        OpBitAsgnShiftLeft  // <<=
        OpBitAsgnShiftRight // >>=
        OpBitAsgnAndNot     // &^=

        // SubCat: Logical operators
        OpLog
        OpLogAnd // &&
        OpLogOr  // ||
        OpLogNot // !

        // SubCat: Relational operators
        OpRel
        OpRelEqual    // ==
        OpRelNotEqual // !=
        OpRelLess     // <
        OpRelGreater  // >
        OpRelLtEq     // <=
        OpRelGtEq     // >=

        // SubCat: List operators
        OpList
        OpListEllipsis // ...

        // Cat: Punctuation.
        Punctuation

        // SubCat: Grouping punctuation
        PunctGp
        PunctGpLParen // (
        PunctGpRParen // )
        PunctGpLBrack // [
        PunctGpRBrack // ]
        PunctGpLBrace // {
        PunctGpRBrace // }

        // SubCat: Separator punctuation
        PunctSep
        PunctSepComma     // ,
        PunctSepPeriod    // .
        PunctSepSemicolon // ;
        PunctSepColon     // :

        // SubCat: String punctuation
        PunctStr
        PunctStrDblQuote // "
        PunctStrQuote    // '
        PunctStrBacktick // `
        PunctStrEsc      // \

        // Cat: Comments.
        Comment
        CommentHashbang
        CommentMultiline
        CommentSingle
        CommentSpecial

        // SubCat: Preprocessor "comments".
        CommentPreproc
        CommentPreprocFile

        // Cat: Text.
        Text
        TextWhitespace
        TextSymbol
        TextPunctuation
        TextSpellErr

        // SubCat: TextStyle (corresponds to Generic in chroma / pygments) todo: look in font deco for more
        TextStyle
        TextStyleDeleted // strike-through
        TextStyleEmph    // italics
        TextStyleError
        TextStyleHeading
        TextStyleInserted
        TextStyleOutput
        TextStylePrompt
        TextStyleStrong // bold
        TextStyleSubheading
        TextStyleTraceback
        TextStyleUnderline
        TextStyleLink
)

// Categories
var Cats = []Tokens{
        None,
        Keyword,
        Name,
        Literal,
        Operator,
        Punctuation,
        Comment,
        Text,
        TokensN,
}

// Sub-Categories
var SubCats = []Tokens{
        None,
        Keyword,
        Name,
        NameType,
        NameFunction,
        NameScope,
        NameVar,
        NameValue,
        Literal,
        LitStr,
        LitNum,
        Operator,
        OpMath,
        OpBit,
        OpAsgn,
        OpMathAsgn,
        OpBitAsgn,
        OpLog,
        OpRel,
        OpList,
        Punctuation,
        PunctGp,
        PunctSep,
        PunctStr,
        Comment,
        CommentPreproc,
        Text,
        TextStyle,
        TokensN,
}

// InitCatMap initializes the CatMap
func InitCatMap() {
        if CatMap != nil {
                return
        }
        CatMap = make(map[Tokens]Tokens, TokensN)
        for tk := None; tk < TokensN; tk++ {
                for c := 1; c < len(Cats); c++ {
                        if tk < Cats[c] {
                                CatMap[tk] = Cats[c-1]
                                break
                        }
                }
        }
}

// InitSubCatMap initializes the SubCatMap
func InitSubCatMap() {
        if SubCatMap != nil {
                return
        }
        SubCatMap = make(map[Tokens]Tokens, TokensN)
        for tk := None; tk < TokensN; tk++ {
                for c := 1; c < len(SubCats); c++ {
                        if tk < SubCats[c] {
                                SubCatMap[tk] = SubCats[c-1]
                                break
                        }
                }
        }
}

// OpPunctMap provides a lookup of operators and punctuation tokens by their usual
// string representation
var OpPunctMap = map[string]Tokens{
        "+": OpMathAdd,
        "-": OpMathSub,
        "*": OpMathMul,
        "/": OpMathDiv,
        "%": OpMathRem,

        "&":  OpBitAnd,
        "|":  OpBitOr,
        "~":  OpBitNot,
        "^":  OpBitXor,
        "<<": OpBitShiftLeft,
        ">>": OpBitShiftRight,
        "&^": OpBitAndNot,

        "=":  OpAsgnAssign,
        "++": OpAsgnInc,
        "--": OpAsgnDec,
        "<-": OpAsgnArrow,
        ":=": OpAsgnDefine,

        "+=": OpMathAsgnAdd,
        "-=": OpMathAsgnSub,
        "*=": OpMathAsgnMul,
        "/=": OpMathAsgnDiv,
        "%=": OpMathAsgnRem,

        "&=":  OpBitAsgnAnd,
        "|=":  OpBitAsgnOr,
        "^=":  OpBitAsgnXor,
        "<<=": OpBitAsgnShiftLeft,
        ">>=": OpBitAsgnShiftRight,
        "&^=": OpBitAsgnAndNot,

        "&&": OpLogAnd,
        "||": OpLogOr,
        "!":  OpLogNot,

        "==": OpRelEqual,
        "!=": OpRelNotEqual,
        "<":  OpRelLess,
        ">":  OpRelGreater,
        "<=": OpRelLtEq,
        ">=": OpRelGtEq,

        "...": OpListEllipsis,

        "(": PunctGpLParen,
        ")": PunctGpRParen,
        "[": PunctGpLBrack,
        "]": PunctGpRBrack,
        "{": PunctGpLBrace,
        "}": PunctGpRBrace,

        ",": PunctSepComma,
        ".": PunctSepPeriod,
        ";": PunctSepSemicolon,
        ":": PunctSepColon,

        "\"": PunctStrDblQuote,
        "'":  PunctStrQuote,
        "`":  PunctStrBacktick,
        "\\": PunctStrEsc,
}

// Names are the short tag names for each token, used e.g., for syntax highlighting
// These are based on alecthomas/chroma / pygments
var Names = map[Tokens]string{
        None:       "",
        Error:      "err",
        EOF:        "EOF",
        EOL:        "EOL",
        EOS:        "EOS",
        Background: "bg",

        Keyword:            "k",
        KeywordConstant:    "kc",
        KeywordDeclaration: "kd",
        KeywordNamespace:   "kn",
        KeywordPseudo:      "kp",
        KeywordReserved:    "kr",
        KeywordType:        "kt",

        Name:              "n",
        NameBuiltin:       "nb",
        NameBuiltinPseudo: "bp",
        NameOther:         "nx",
        NamePseudo:        "pu",

        NameType:       "nt",
        NameClass:      "nc",
        NameStruct:     "ns",
        NameField:      "nfl",
        NameInterface:  "nti",
        NameConstant:   "no",
        NameEnum:       "nen",
        NameEnumMember: "nem",
        NameArray:      "nr",
        NameMap:        "nm",
        NameObject:     "nj",
        NameTypeParam:  "ntp",

        NameFunction:      "nf",
        NameDecorator:     "nd",
        NameFunctionMagic: "fm",
        NameMethod:        "mt",
        NameOperator:      "np",
        NameConstructor:   "cr",
        NameException:     "ne",
        NameLabel:         "nl",
        NameEvent:         "ev",

        NameScope:     "nsc",
        NameNamespace: "nn",
        NameModule:    "md",
        NamePackage:   "pk",
        NameLibrary:   "lb",

        NameVar:          "nv",
        NameVarAnonymous: "ay",
        NameVarClass:     "vc",
        NameVarGlobal:    "vg",
        NameVarInstance:  "vi",
        NameVarMagic:     "vm",
        NameVarParam:     "vp",

        NameValue:     "vl",
        NameTag:       "ng",
        NameProperty:  "py",
        NameAttribute: "na",
        NameEntity:    "ni",

        Literal:      "l",
        LiteralDate:  "ld",
        LiteralOther: "lo",
        LiteralBool:  "bo",

        LitStr:          "s",
        LitStrAffix:     "sa",
        LitStrAtom:      "st",
        LitStrBacktick:  "sb",
        LitStrBoolean:   "so",
        LitStrChar:      "sc",
        LitStrDelimiter: "dl",
        LitStrDoc:       "sd",
        LitStrDouble:    "s2",
        LitStrEscape:    "se",
        LitStrHeredoc:   "sh",
        LitStrInterpol:  "si",
        LitStrName:      "sn",
        LitStrOther:     "sx",
        LitStrRegex:     "sr",
        LitStrSingle:    "s1",
        LitStrSymbol:    "ss",
        LitStrFile:      "fl",

        LitNum:            "m",
        LitNumBin:         "mb",
        LitNumFloat:       "mf",
        LitNumHex:         "mh",
        LitNumInteger:     "mi",
        LitNumIntegerLong: "il",
        LitNumOct:         "mo",
        LitNumImag:        "mj",

        Operator:     "o",
        OperatorWord: "ow",

        // don't really need these -- only have at sub-categ level
        OpMath:     "om",
        OpBit:      "ob",
        OpAsgn:     "oa",
        OpMathAsgn: "pa",
        OpBitAsgn:  "ba",
        OpLog:      "ol",
        OpRel:      "or",
        OpList:     "oi",

        Punctuation: "p",
        PunctGp:     "pg",
        PunctSep:    "ps",
        PunctStr:    "pr",

        Comment:          "c",
        CommentHashbang:  "ch",
        CommentMultiline: "cm",
        CommentSingle:    "c1",
        CommentSpecial:   "cs",

        CommentPreproc:     "cp",
        CommentPreprocFile: "cpf",

        Text:            "",
        TextWhitespace:  "w",
        TextSymbol:      "ts",
        TextPunctuation: "tp",
        TextSpellErr:    "te",

        TextStyle:           "g",
        TextStyleDeleted:    "gd",
        TextStyleEmph:       "ge",
        TextStyleError:      "gr",
        TextStyleHeading:    "gh",
        TextStyleInserted:   "gi",
        TextStyleOutput:     "go",
        TextStylePrompt:     "gp",
        TextStyleStrong:     "gs",
        TextStyleSubheading: "gu",
        TextStyleTraceback:  "gt",
        TextStyleUnderline:  "gl",
        TextStyleLink:       "ga",
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tree

import (
        "reflect"
        "slices"
        "strconv"
        "sync/atomic"

        "cogentcore.org/core/base/slicesx"
        "cogentcore.org/core/types"
)

// admin.go has infrastructure code outside of the [Node] interface.

// New returns a new node of the given type with the given optional parent.
// If the name is unspecified, it defaults to the ID (kebab-case) name of
// the type, plus the [Node.NumLifetimeChildren] of the parent.
func New[T NodeValue](parent ...Node) *T { //yaegi:add
        n := new(T)
        ni := any(n).(Node)
        InitNode(ni)
        if len(parent) == 0 {
                ni.AsTree().SetName(ni.AsTree().NodeType().IDName)
                return n
        }
        p := parent[0]
        p.AsTree().Children = append(p.AsTree().Children, ni)
        SetParent(ni, p)
        return n
}

// NewOfType returns a new node of the given [types.Type] with the given optional parent.
// If the name is unspecified, it defaults to the ID (kebab-case) name of
// the type, plus the [Node.NumLifetimeChildren] of the parent.
func NewOfType(typ *types.Type, parent ...Node) Node {
        if len(parent) == 0 {
                n := newOfType(typ)
                InitNode(n)
                n.AsTree().SetName(n.AsTree().NodeType().IDName)
                return n
        }
        return parent[0].AsTree().NewChild(typ)
}

// InitNode initializes the node. It should not be called by end-user code.
// It must be exported since it is referenced in generic functions included in yaegi.
func InitNode(n Node) {
        nb := n.AsTree()
        if nb.This != n {
                nb.This = n
                nb.This.Init()
        }
}

// SetParent sets the parent of the given node to the given parent node.
// This is only for nodes with no existing parent; see [MoveToParent] to
// move nodes that already have a parent. It does not add the node to the
// parent's list of children; see [Node.AddChild] for a version that does.
// It automatically gets the [Node.This] of the parent.
func SetParent(child Node, parent Node) {
        nb := child.AsTree()
        nb.Parent = parent.AsTree().This
        setUniqueName(child, false)
        child.AsTree().This.OnAdd()
        if oca := nb.Parent.AsTree().OnChildAdded; oca != nil {
                oca(child)
        }
}

// MoveToParent removes the given node from its current parent
// and adds it as a child of the given new parent.
// The old and new parents can be in different trees (or not).
func MoveToParent(child Node, parent Node) {
        oldParent := child.AsTree().Parent
        if oldParent != nil {
                idx := IndexOf(oldParent.AsTree().Children, child)
                if idx >= 0 {
                        oldParent.AsTree().Children = slices.Delete(oldParent.AsTree().Children, idx, idx+1)
                }
        }
        parent.AsTree().AddChild(child)
}

// ParentByType returns the first parent of the given node that is
// of the given type, if any such node exists.
func ParentByType[T Node](n Node) T {
        if IsRoot(n) {
                var z T
                return z
        }
        if p, ok := n.AsTree().Parent.(T); ok {
                return p
        }
        return ParentByType[T](n.AsTree().Parent)
}

// ChildByType returns the first child of the given node that is
// of the given type, if any such node exists.
func ChildByType[T Node](n Node, startIndex ...int) T {
        nb := n.AsTree()
        idx := slicesx.Search(nb.Children, func(ch Node) bool {
                _, ok := ch.(T)
                return ok
        }, startIndex...)
        ch := nb.Child(idx)
        if ch == nil {
                var z T
                return z
        }
        return ch.(T)
}

// IsNil returns true if the Node interface is nil, or the underlying
// This pointer is nil, which happens when the node is deleted.
func IsNil(n Node) bool {
        return n == nil || n.AsTree().This == nil
}

// IsRoot returns whether the given node is the root node in its tree.
func IsRoot(n Node) bool {
        return n.AsTree().Parent == nil
}

// Root returns the root node of the given node's tree.
func Root(n Node) Node {
        if IsRoot(n) {
                return n
        }
        return Root(n.AsTree().Parent)
}

// nodeType is the [reflect.Type] of [Node].
var nodeType = reflect.TypeFor[Node]()

// IsNode returns whether the given type or a pointer to it
// implements the [Node] interface.
func IsNode(typ reflect.Type) bool {
        if typ == nil {
                return false
        }
        return typ.Implements(nodeType) || reflect.PointerTo(typ).Implements(nodeType)
}

// newOfType returns a new instance of the given [Node] type.
func newOfType(typ *types.Type) Node {
        return reflect.New(reflect.TypeOf(typ.Instance).Elem()).Interface().(Node)
}

// SetUniqueName sets the name of the node to be unique, using
// the number of lifetime children of the parent node as a unique
// identifier. If the node already has a name, it adds the unique id
// to it. Otherwise, it uses the type name of the node plus the unique id.
func SetUniqueName(n Node) {
        setUniqueName(n, true)
}

// setUniqueName is the implementation of [SetUniqueName] that takes whether
// to add the unique id to the name even if it is already set.
func setUniqueName(n Node, addIfSet bool) {
        nb := n.AsTree()
        pn := nb.Parent
        if pn == nil {
                return
        }
        c := atomic.AddUint64(&pn.AsTree().numLifetimeChildren, 1)
        id := "-" + strconv.FormatUint(c-1, 10) // must subtract 1 so we start at 0
        if nb.Name == "" {
                nb.SetName(nb.NodeType().IDName + id)
        } else if addIfSet {
                nb.SetName(nb.Name + id)
        }
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tree

import (
        "bytes"
        "encoding/json"
        "fmt"
        "reflect"
        "slices"
        "strconv"
        "strings"

        "cogentcore.org/core/base/reflectx"
        "cogentcore.org/core/types"
)

// MarshalJSON marshals the node by injecting the [Node.NodeType] as a nodeType
// field and the [NodeBase.NumChildren] as a numChildren field at the start of
// the standard JSON encoding output.
func (n *NodeBase) MarshalJSON() ([]byte, error) {
        // the non pointer value does not implement MarshalJSON, so it will not result in infinite recursion
        b, err := json.Marshal(reflectx.Underlying(reflect.ValueOf(n.This)).Interface())
        if err != nil {
                return b, err
        }
        data := `"nodeType":"` + n.NodeType().Name + `",`
        if n.NumChildren() > 0 {
                data += `"numChildren":` + strconv.Itoa(n.NumChildren()) + ","
        }
        b = slices.Insert(b, 1, []byte(data)...)
        return b, nil
}

// unmarshalTypeCache is a cache of [reflect.Type] values used
// for unmarshalling in [NodeBase.UnmarshalJSON]. This cache has
// a noticeable performance benefit of around 1.2x in
// [BenchmarkNodeUnmarshalJSON], a benefit that should only increase
// for larger trees.
var unmarshalTypeCache = map[string]reflect.Type{}

// UnmarshalJSON unmarshals the node by extracting the nodeType and numChildren fields
// added by [NodeBase.MarshalJSON] and then updating the node to the correct type and
// creating the correct number of children. Note that this method can not update the type
// of the node if it has no parent; to load a root node from JSON and have it be of the
// correct type, see the [UnmarshalRootJSON] function. If the type of the node is changed
// by this function, the node pointer will no longer be valid, and the node must be fetched
// again through the children of its parent. You do not need to call [UnmarshalRootJSON]
// or worry about pointers changing if this node is already of the correct type.
func (n *NodeBase) UnmarshalJSON(b []byte) error {
        typeStart := bytes.Index(b, []byte(`":`)) + 3
        typeEnd := bytes.Index(b, []byte(`",`))
        typeName := string(b[typeStart:typeEnd])
        // we may end up with an extraneous quote / space at the start
        typeName = strings.TrimPrefix(strings.TrimSpace(typeName), `"`)
        typ := types.TypeByName(typeName)
        if typ == nil {
                return fmt.Errorf("tree.NodeBase.UnmarshalJSON: type %q not found", typeName)
        }

        // if our type does not match, we must replace our This to make it match
        if n.NodeType() != typ {
                parent := n.Parent
                index := n.IndexInParent()
                if index >= 0 {
                        n.Delete()
                        n.This = NewOfType(typ)
                        parent.AsTree().InsertChild(n.This, index)
                        n = n.This.AsTree() // our NodeBase pointer is now different
                }
        }

        // We must delete any existing children first.
        n.DeleteChildren()

        remainder := b[typeEnd+2:]
        numStart := bytes.Index(remainder, []byte(`"numChildren":`))
        if numStart >= 0 { // numChildren may not be specified if it is 0
                numStart += 14 // start of actual number bytes
                numEnd := bytes.Index(remainder, []byte(`,`))
                numString := string(remainder[numStart:numEnd])
                // we may end up with extraneous space at the start
                numString = strings.TrimSpace(numString)
                numChildren, err := strconv.Atoi(numString)
                if err != nil {
                        return err
                }
                // We make placeholder NodeBase children that will be replaced
                // with children of the correct type during their UnmarshalJSON.
                for range numChildren {
                        New[NodeBase](n)
                }
        }

        uv := reflectx.UnderlyingPointer(reflect.ValueOf(n.This))
        rtyp := unmarshalTypeCache[typeName]
        if rtyp == nil {
                // We must create a new type that has the exact same fields as the original type
                // so that we can unmarshal into it without having infinite recursion on the
                // UnmarshalJSON method. This works because [reflect.StructOf] does not promote
                // methods on embedded fields, meaning that the UnmarshalJSON method on the NodeBase
                // is not carried over and thus is not called, avoiding infinite recursion.
                uvt := uv.Type().Elem()
                fields := make([]reflect.StructField, uvt.NumField())
                for i := range fields {
                        fields[i] = uvt.Field(i)
                }
                nt := reflect.StructOf(fields)
                rtyp = reflect.PointerTo(nt)
                unmarshalTypeCache[typeName] = rtyp
        }
        // We can directly convert because our new struct type has the exact same fields.
        uvi := uv.Convert(rtyp).Interface()
        err := json.Unmarshal(b, uvi)
        if err != nil {
                return err
        }
        return nil
}

// UnmarshalRootJSON loads the given JSON to produce a new root node of
// the correct type with all properties and children loaded. If you have
// a root node that you know is already of the correct type, you can just
// call [NodeBase.UnmarshalJSON] on it instead.
func UnmarshalRootJSON(b []byte) (Node, error) {
        // we must make a temporary parent so that the type of the node can be updated
        parent := New[NodeBase]()
        // this NodeBase type is just temporary and will be fixed by [NodeBase.UnmarshalJSON]
        nb := New[NodeBase](parent)
        err := nb.UnmarshalJSON(b)
        if err != nil {
                return nil, err
        }
        // the node must be fetched from the parent's children since the pointer may have changed
        n := parent.Child(0)
        // we must safely remove the node from its temporary parent
        n.AsTree().Parent = nil
        parent.Children = nil
        parent.Destroy()
        return n, nil
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package tree provides a powerful and extensible tree system,
// centered on the core [Node] interface.
package tree

//go:generate core generate
//go:generate core generate ./testdata

import (
        "cogentcore.org/core/base/plan"
)

// Node is an interface that all tree nodes satisfy. The core functionality
// of a tree node is defined on [NodeBase], and all higher-level tree types
// must embed it. This interface only contains the tree functionality that
// higher-level tree types may need to override. You can call [Node.AsTree]
// to get the [NodeBase] of a Node and access the core tree functionality.
// All values that implement [Node] are pointer values; see [NodeValue]
// for an interface for non-pointer values.
type Node interface {

        // AsTree returns the [NodeBase] of this Node. Most core
        // tree functionality is implemented on [NodeBase].
        AsTree() *NodeBase

        // Init is called when the node is first initialized.
        // It is called before the node is added to the tree,
        // so it will not have any parents or siblings.
        // It will be called only once in the lifetime of the node.
        // It does nothing by default, but it can be implemented
        // by higher-level types that want to do something.
        // It is the main place that initialization steps should
        // be done, like adding Stylers, Makers, and event handlers
        // to widgets in Cogent Core.
        Init()

        // OnAdd is called when the node is added to a parent.
        // It will be called only once in the lifetime of the node,
        // unless the node is moved. It will not be called on root
        // nodes, as they are never added to a parent.
        // It does nothing by default, but it can be implemented
        // by higher-level types that want to do something.
        OnAdd()

        // Destroy recursively deletes and destroys the node, all of its children,
        // and all of its children's children, etc. Node types can implement this
        // to do additional necessary destruction; if they do, they should call
        // [NodeBase.Destroy] at the end of their implementation.
        Destroy()

        // NodeWalkDown is a method that nodes can implement to traverse additional nodes
        // like widget parts during [NodeBase.WalkDown]. It is called with the function passed
        // to [Node.WalkDown] after the function is called with the node itself.
        NodeWalkDown(fun func(n Node) bool)

        // CopyFieldsFrom copies the fields of the node from the given node.
        // By default, it is [NodeBase.CopyFieldsFrom], which automatically does
        // a deep copy of all of the fields of the node that do not a have a
        // `copier:"-"` struct tag. Node types should only implement a custom
        // CopyFieldsFrom method when they have fields that need special copying
        // logic that can not be automatically handled. All custom CopyFieldsFrom
        // methods should call [NodeBase.CopyFieldsFrom] first and then only do manual
        // handling of specific fields that can not be automatically copied. See
        // [cogentcore.org/core/core.WidgetBase.CopyFieldsFrom] for an example of a
        // custom CopyFieldsFrom method.
        CopyFieldsFrom(from Node)

        // This is necessary for tree planning to work.
        plan.Namer
}

// NodeValue is an interface that all non-pointer tree nodes satisfy.
// Pointer tree nodes satisfy [Node], not NodeValue. NodeValue and [Node]
// are mutually exclusive; a [Node] cannot be a NodeValue and vice versa.
// However, a pointer to a NodeValue type is guaranteed to be a [Node],
// and a non-pointer version of a [Node] type is guaranteed to be a NodeValue.
type NodeValue interface {

        // NodeValue should only be implemented by [NodeBase],
        // and it should not be called. It must be exported due
        // to a nuance with the way that [reflect.StructOf] works,
        // which results in panics with embedded structs that have
        // unexported non-pointer methods.
        NodeValue()
}

// NodeValue implements [NodeValue]. It should not be called.
func (nb NodeBase) NodeValue() {}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tree

import (
        "log/slog"
        "maps"
        "reflect"
        "slices"
        "strconv"
        "strings"

        "github.com/jinzhu/copier"

        "cogentcore.org/core/base/elide"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/base/tiered"
        "cogentcore.org/core/types"
)

// NodeBase implements the [Node] interface and provides the core functionality
// for the Cogent Core tree system. You must use NodeBase as an embedded struct
// in all higher-level tree types.
//
// All nodes must be properly initialized by using one of [New], [NodeBase.NewChild],
// [NodeBase.AddChild], [NodeBase.InsertChild], [NodeBase.Clone], [Update], or [Plan].
// This ensures that the [NodeBase.This] field is set correctly and the [Node.Init]
// method is called.
//
// All nodes support JSON marshalling and unmarshalling through the standard [encoding/json]
// interfaces, so you can use the standard functions for loading and saving trees. However,
// if you want to load a root node of the correct type from JSON, you need to use the
// [UnmarshalRootJSON] function.
//
// All node types must be added to the Cogent Core type registry via typegen,
// so you must add a go:generate line that runs `core generate` to any packages
// you write that have new node types defined.
type NodeBase struct {

        // Name is the name of this node, which is typically unique relative to other children of
        // the same parent. It can be used for finding and serializing nodes. If not otherwise set,
        // it defaults to the ID (kebab-case) name of the node type combined with the total number
        // of children that have ever been added to the node's parent.
        Name string `copier:"-"`

        // This is the value of this Node as its true underlying type. This allows methods
        // defined on base types to call methods defined on higher-level types, which
        // is necessary for various parts of tree and widget functionality. This is set
        // to nil when the node is deleted.
        This Node `copier:"-" json:"-" xml:"-" display:"-" set:"-"`

        // Parent is the parent of this node, which is set automatically when this node is
        // added as a child of a parent. To change the parent of a node, use [MoveToParent];
        // you should typically not set this field directly. Nodes can only have one parent
        // at a time.
        Parent Node `copier:"-" json:"-" xml:"-" display:"-" set:"-"`

        // Children is the list of children of this node. All of them are set to have this node
        // as their parent. You can directly modify this list, but you should typically use the
        // various NodeBase child helper functions when applicable so that everything is updated
        // properly, such as when deleting children.
        Children []Node `table:"-" copier:"-" set:"-" json:",omitempty"`

        // Properties is a property map for arbitrary key-value properties.
        // When possible, use typed fields on a new type embedding NodeBase instead of this.
        // You should typically use the [NodeBase.SetProperty], [NodeBase.Property], and
        // [NodeBase.DeleteProperty] methods for modifying and accessing properties.
        Properties map[string]any `table:"-" xml:"-" copier:"-" set:"-" json:",omitempty"`

        // Updaters is a tiered set of functions called in sequential descending (reverse) order
        // in [NodeBase.RunUpdaters] to update the node. You can use [NodeBase.Updater],
        // [NodeBase.FirstUpdater], or [NodeBase.FinalUpdater] to add one. This typically
        // typically contains [NodeBase.UpdateFromMake] at the start of the normal list.
        Updaters tiered.Tiered[[]func()] `table:"-" copier:"-" json:"-" xml:"-" set:"-" edit:"-" display:"add-fields"`

        // Makers is a tiered set of functions called in sequential ascending order
        // in [NodeBase.Make] to make the plan for how the node's children should
        // be configured. You can use [NodeBase.Maker], [NodeBase.FirstMaker], or
        // [NodeBase.FinalMaker] to add one.
        Makers tiered.Tiered[[]func(p *Plan)] `table:"-" copier:"-" json:"-" xml:"-" set:"-" edit:"-" display:"add-fields"`

        // OnChildAdded is called when a node is added as a direct child of this node.
        // When a node is added to a parent, it calls [Node.OnAdd] on itself and then
        // this function on its parent if it is non-nil.
        OnChildAdded func(n Node) `table:"-" copier:"-" json:"-" xml:"-" edit:"-"`

        // numLifetimeChildren is the number of children that have ever been added to this
        // node, which is used for automatic unique naming.
        numLifetimeChildren uint64

        // index is the last value of our index, which is used as a starting point for
        // finding us in our parent next time. It is not guaranteed to be accurate;
        // use the [NodeBase.IndexInParent] method.
        index int

        // depth is the depth of the node while using [NodeBase.WalkDownBreadth].
        depth int
}

// String implements the [fmt.Stringer] interface by returning the path of the node.
func (n *NodeBase) String() string {
        if n == nil || n.This == nil {
                return "nil"
        }
        return elide.Middle(n.Path(), 38)
}

// AsTree returns the [NodeBase] for this Node.
func (n *NodeBase) AsTree() *NodeBase {
        return n
}

// PlanName implements [plan.Namer].
func (n *NodeBase) PlanName() string {
        return n.Name
}

// NodeType returns the [types.Type] of this node.
// If there is no [types.Type] registered for this node already,
// it registers one and then returns it.
func (n *NodeBase) NodeType() *types.Type {
        if t := types.TypeByValue(n.This); t != nil {
                if t.Instance == nil {
                        t.Instance = n.NewInstance()
                }
                return t
        }
        name := types.TypeNameValue(n.This)
        li := strings.LastIndex(name, ".")
        return types.AddType(&types.Type{
                Name:     name,
                IDName:   strcase.ToKebab(name[li+1:]),
                Instance: n.NewInstance(),
        })
}

// NewInstance returns a new instance of this node type.
func (n *NodeBase) NewInstance() Node {
        return reflect.New(reflect.TypeOf(n.This).Elem()).Interface().(Node)
}

// Parents:

// IndexInParent returns our index within our parent node. It caches the
// last value and uses that for an optimized search so subsequent calls
// are typically quite fast. Returns -1 if we don't have a parent.
func (n *NodeBase) IndexInParent() int {
        if n.Parent == nil {
                return -1
        }
        idx := IndexOf(n.Parent.AsTree().Children, n.This, n.index) // very fast if index is close
        n.index = idx
        return idx
}

// ParentLevel finds a given potential parent node recursively up the
// hierarchy, returning the level above the current node that the parent was
// found, and -1 if not found.
func (n *NodeBase) ParentLevel(parent Node) int {
        parLev := -1
        level := 0
        n.WalkUpParent(func(k Node) bool {
                if k == parent {
                        parLev = level
                        return Break
                }
                level++
                return Continue
        })
        return parLev
}

// ParentByName finds first parent recursively up hierarchy that matches
// the given name. It returns nil if not found.
func (n *NodeBase) ParentByName(name string) Node {
        if IsRoot(n) {
                return nil
        }
        if n.Parent.AsTree().Name == name {
                return n.Parent
        }
        return n.Parent.AsTree().ParentByName(name)
}

// Children:

// HasChildren returns whether this node has any children.
func (n *NodeBase) HasChildren() bool {
        return len(n.Children) > 0
}

// NumChildren returns the number of children this node has.
func (n *NodeBase) NumChildren() int {
        return len(n.Children)
}

// Child returns the child of this node at the given index and returns nil if
// the index is out of range.
func (n *NodeBase) Child(i int) Node {
        if i >= len(n.Children) || i < 0 {
                return nil
        }
        return n.Children[i]
}

// ChildByName returns the first child that has the given name, and nil
// if no such element is found. startIndex arg allows for optimized
// bidirectional find if you have an idea where it might be, which
// can be a key speedup for large lists. If no value is specified for
// startIndex, it starts in the middle, which is a good default.
func (n *NodeBase) ChildByName(name string, startIndex ...int) Node {
        return n.Child(IndexByName(n.Children, name, startIndex...))
}

// Paths:

// TODO: is this the best way to escape paths?

// EscapePathName returns a name that replaces any / with \\
func EscapePathName(name string) string {
        return strings.ReplaceAll(name, "/", `\\`)
}

// UnescapePathName returns a name that replaces any \\ with /
func UnescapePathName(name string) string {
        return strings.ReplaceAll(name, `\\`, "/")
}

// Path returns the path to this node from the tree root,
// using [Node.Name]s separated by / delimeters. Any
// existing / characters in names are escaped to \\
func (n *NodeBase) Path() string {
        if n.Parent != nil {
                return n.Parent.AsTree().Path() + "/" + EscapePathName(n.Name)
        }
        return "/" + EscapePathName(n.Name)
}

// PathFrom returns the path to this node from the given parent node,
// using [Node.Name]s separated by / delimeters. Any
// existing / characters in names are escaped to \\
//
// The paths that it returns exclude the
// name of the parent and the leading slash; for example, in the tree
// a/b/c/d/e, the result of d.PathFrom(b) would be c/d. PathFrom
// automatically gets the [NodeBase.This] version of the given parent,
// so a base type can be passed in without manually accessing [NodeBase.This].
func (n *NodeBase) PathFrom(parent Node) string {
        if n.This == parent {
                return ""
        }
        // critical to get `This`
        parent = parent.AsTree().This
        // we bail a level below the parent so it isn't in the path
        if n.Parent == nil || n.Parent == parent {
                return EscapePathName(n.Name)
        }
        ppath := n.Parent.AsTree().PathFrom(parent)
        return ppath + "/" + EscapePathName(n.Name)

}

// FindPath returns the node at the given path from this node.
// FindPath only works correctly when names are unique.
// The given path must be consistent with the format produced
// by [NodeBase.PathFrom]. There is also support for index-based
// access (ie: [0] for the first child) for cases where indexes
// are more useful than names. It returns nil if no node is found
// at the given path.
func (n *NodeBase) FindPath(path string) Node {
        curn := n.This
        pels := strings.Split(strings.Trim(strings.TrimSpace(path), "\""), "/")
        for _, pe := range pels {
                if len(pe) == 0 {
                        continue
                }
                idx := findPathChild(curn, UnescapePathName(pe))
                if idx < 0 {
                        return nil
                }
                curn = curn.AsTree().Children[idx]
        }
        return curn
}

// findPathChild finds the child with the given string representation in [NodeBase.FindPath].
func findPathChild(n Node, child string) int {
        if child[0] == '[' && child[len(child)-1] == ']' {
                idx, err := strconv.Atoi(child[1 : len(child)-1])
                if err != nil {
                        return idx
                }
                if idx < 0 { // from end
                        idx = len(n.AsTree().Children) + idx
                }
                return idx
        }
        return IndexByName(n.AsTree().Children, child)
}

// Adding and Inserting Children:

// AddChild adds given child at end of children list.
// The kid node is assumed to not be on another tree (see [MoveToParent])
// and the existing name should be unique among children.
func (n *NodeBase) AddChild(kid Node) {
        InitNode(kid)
        n.Children = append(n.Children, kid)
        SetParent(kid, n) // key to set new parent before deleting: indicates move instead of delete
}

// NewChild creates a new child of the given type and adds it at the end
// of the list of children. The name defaults to the ID (kebab-case) name
// of the type, plus the [Node.NumLifetimeChildren] of the parent.
func (n *NodeBase) NewChild(typ *types.Type) Node {
        kid := newOfType(typ)
        InitNode(kid)
        n.Children = append(n.Children, kid)
        SetParent(kid, n)
        return kid
}

// InsertChild adds given child at position in children list.
// The kid node is assumed to not be on another tree (see [MoveToParent])
// and the existing name should be unique among children.
func (n *NodeBase) InsertChild(kid Node, index int) {
        InitNode(kid)
        n.Children = slices.Insert(n.Children, index, kid)
        SetParent(kid, n)
}

// Deleting Children:

// DeleteChildAt deletes child at the given index. It returns false
// if there is no child at the given index.
func (n *NodeBase) DeleteChildAt(index int) bool {
        child := n.Child(index)
        if child == nil {
                return false
        }
        n.Children = slices.Delete(n.Children, index, index+1)
        child.Destroy()
        return true
}

// DeleteChild deletes the given child node, returning false if
// it can not find it.
func (n *NodeBase) DeleteChild(child Node) bool {
        if child == nil {
                return false
        }
        idx := IndexOf(n.Children, child)
        if idx < 0 {
                return false
        }
        return n.DeleteChildAt(idx)
}

// DeleteChildByName deletes child node by name, returning false
// if it can not find it.
func (n *NodeBase) DeleteChildByName(name string) bool {
        idx := IndexByName(n.Children, name)
        if idx < 0 {
                return false
        }
        return n.DeleteChildAt(idx)
}

// DeleteChildren deletes all children nodes.
func (n *NodeBase) DeleteChildren() {
        kids := n.Children
        n.Children = n.Children[:0] // preserves capacity of list
        for _, kid := range kids {
                if kid == nil {
                        continue
                }
                kid.Destroy()
        }
}

// Delete deletes this node from its parent's children list
// and then destroys itself.
func (n *NodeBase) Delete() {
        if n.Parent == nil {
                n.This.Destroy()
        } else {
                n.Parent.AsTree().DeleteChild(n.This)
        }
}

// Destroy recursively deletes and destroys the node, all of its children,
// and all of its children's children, etc.
func (n *NodeBase) Destroy() {
        if n.This == nil { // already destroyed
                return
        }
        n.DeleteChildren()
        n.This = nil
}

// Property Storage:

// SetProperty sets given the given property to the given value.
func (n *NodeBase) SetProperty(key string, value any) {
        if n.Properties == nil {
                n.Properties = map[string]any{}
        }
        n.Properties[key] = value
}

// Property returns the property value for the given key.
// It returns nil if it doesn't exist.
func (n *NodeBase) Property(key string) any {
        return n.Properties[key]
}

// DeleteProperty deletes the property with the given key.
func (n *NodeBase) DeleteProperty(key string) {
        if n.Properties == nil {
                return
        }
        delete(n.Properties, key)
}

// Tree Walking:

const (
        // Continue = true can be returned from tree iteration functions to continue
        // processing down the tree, as compared to Break = false which stops this branch.
        Continue = true

        // Break = false can be returned from tree iteration functions to stop processing
        // this branch of the tree.
        Break = false
)

// WalkUp calls the given function on the node and all of its parents,
// sequentially in the current goroutine (generally necessary for going up,
// which is typically quite fast anyway). It stops walking if the function
// returns [Break] and keeps walking if it returns [Continue]. It returns
// whether walking was finished (false if it was aborted with [Break]).
func (n *NodeBase) WalkUp(fun func(n Node) bool) bool {
        cur := n.This
        for {
                if !fun(cur) { // false return means stop
                        return false
                }
                parent := cur.AsTree().Parent
                if parent == nil || parent == cur { // prevent loops
                        return true
                }
                cur = parent
        }
}

// WalkUpParent calls the given function on all of the node's parents (but not
// the node itself), sequentially in the current goroutine (generally necessary
// for going up, which is typically quite fast anyway). It stops walking if the
// function returns [Break] and keeps walking if it returns [Continue]. It returns
// whether walking was finished (false if it was aborted with [Break]).
func (n *NodeBase) WalkUpParent(fun func(n Node) bool) bool {
        if IsRoot(n) {
                return true
        }
        cur := n.Parent
        for {
                if !fun(cur) { // false return means stop
                        return false
                }
                parent := cur.AsTree().Parent
                if parent == nil || parent == cur { // prevent loops
                        return true
                }
                cur = parent
        }
}

// WalkDown strategy: https://stackoverflow.com/questions/5278580/non-recursive-depth-first-search-algorithm

// WalkDown calls the given function on the node and all of its children
// in a depth-first manner over all of the children, sequentially in the
// current goroutine. It stops walking the current branch of the tree if
// the function returns [Break] and keeps walking if it returns [Continue].
// It is non-recursive and safe for concurrent calling. The [Node.NodeWalkDown]
// method is called for every node after the given function, which enables nodes
// to also traverse additional nodes, like widget parts.
func (n *NodeBase) WalkDown(fun func(n Node) bool) {
        if n.This == nil {
                return
        }
        tm := map[Node]int{} // traversal map
        start := n.This
        cur := start
        tm[cur] = -1
outer:
        for {
                cb := cur.AsTree()
                // fun can destroy the node, so we have to check for nil before and after.
                // A false return from fun indicates to stop.
                if cb.This != nil && fun(cur) && cb.This != nil {
                        cb.This.NodeWalkDown(fun)
                        if cb.HasChildren() {
                                tm[cur] = 0 // 0 for no fields
                                nxt := cb.Child(0)
                                if nxt != nil && nxt.AsTree().This != nil {
                                        cur = nxt.AsTree().This
                                        tm[cur] = -1
                                        continue
                                }
                        }
                } else {
                        tm[cur] = cb.NumChildren()
                }
                // if we get here, we're in the ascent branch -- move to the right and then up
                for {
                        cb := cur.AsTree() // may have changed, so must get again
                        curChild := tm[cur]
                        if (curChild + 1) < cb.NumChildren() {
                                curChild++
                                tm[cur] = curChild
                                nxt := cb.Child(curChild)
                                if nxt != nil && nxt.AsTree().This != nil {
                                        cur = nxt.AsTree().This
                                        tm[cur] = -1
                                        continue outer
                                }
                                continue
                        }
                        delete(tm, cur)
                        // couldn't go right, move up..
                        if cur == start {
                                break outer // done!
                        }
                        parent := cb.Parent
                        if parent == nil || parent == cur { // shouldn't happen, but does..
                                // fmt.Printf("nil / cur parent %v\n", par)
                                break outer
                        }
                        cur = parent
                }
        }
}

// NodeWalkDown is a placeholder implementation of [Node.NodeWalkDown]
// that does nothing.
func (n *NodeBase) NodeWalkDown(fun func(n Node) bool) {}

// WalkDownPost iterates in a depth-first manner over the children, calling
// shouldContinue on each node to test if processing should proceed (if it returns
// [Break] then that branch of the tree is not further processed),
// and then calls the given function after all of a node's children
// have been iterated over. In effect, this means that the given function
// is called for deeper nodes first. This uses node state information to manage
// the traversal and is very fast, but can only be called by one goroutine at a
// time, so you should use a Mutex if there is a chance of multiple threads
// running at the same time. The nodes are processed in the current goroutine.
func (n *NodeBase) WalkDownPost(shouldContinue func(n Node) bool, fun func(n Node) bool) {
        if n.This == nil {
                return
        }
        tm := map[Node]int{} // traversal map
        start := n.This
        cur := start
        tm[cur] = -1
outer:
        for {
                cb := cur.AsTree()
                if cb.This != nil && shouldContinue(cur) { // false return means stop
                        if cb.HasChildren() {
                                tm[cur] = 0 // 0 for no fields
                                nxt := cb.Child(0)
                                if nxt != nil && nxt.AsTree().This != nil {
                                        cur = nxt.AsTree().This
                                        tm[cur] = -1
                                        continue
                                }
                        }
                } else {
                        tm[cur] = cb.NumChildren()
                }
                // if we get here, we're in the ascent branch -- move to the right and then up
                for {
                        cb := cur.AsTree() // may have changed, so must get again
                        curChild := tm[cur]
                        if (curChild + 1) < cb.NumChildren() {
                                curChild++
                                tm[cur] = curChild
                                nxt := cb.Child(curChild)
                                if nxt != nil && nxt.AsTree().This != nil {
                                        cur = nxt.AsTree().This
                                        tm[cur] = -1
                                        continue outer
                                }
                                continue
                        }
                        fun(cur) // now we call the function, last..
                        // couldn't go right, move up..
                        delete(tm, cur)
                        if cur == start {
                                break outer // done!
                        }
                        parent := cb.Parent
                        if parent == nil || parent == cur { // shouldn't happen
                                break outer
                        }
                        cur = parent
                }
        }
}

// Note: it does not appear that there is a good
// recursive breadth-first-search strategy:
// https://herringtondarkholme.github.io/2014/02/17/generator/
// https://stackoverflow.com/questions/2549541/performing-breadth-first-search-recursively/2549825#2549825

// WalkDownBreadth calls the given function on the node and all of its children
// in breadth-first order. It stops walking the current branch of the tree if the
// function returns [Break] and keeps walking if it returns [Continue]. It is
// non-recursive, but not safe for concurrent calling.
func (n *NodeBase) WalkDownBreadth(fun func(n Node) bool) {
        start := n.This

        level := 0
        start.AsTree().depth = level
        queue := make([]Node, 1)
        queue[0] = start

        for {
                if len(queue) == 0 {
                        break
                }
                cur := queue[0]
                depth := cur.AsTree().depth
                queue = queue[1:]

                if cur.AsTree().This != nil && fun(cur) { // false return means don't proceed
                        for _, cn := range cur.AsTree().Children {
                                if cn != nil && cn.AsTree().This != nil {
                                        cn.AsTree().depth = depth + 1
                                        queue = append(queue, cn)
                                }
                        }
                }
        }
}

// Deep Copy:

// note: we use the copy from direction (instead of copy to), as the receiver
// is modified whereas the from is not and assignment is typically in the same
// direction.

// CopyFrom copies the data and children of the given node to this node.
// It is essential that the source node has unique names. It is very efficient
// by using the [Node.ConfigChildren] method which attempts to preserve any
// existing nodes in the destination if they have the same name and type, so a
// copy from a source to a target that only differ minimally will be
// minimally destructive. Only copying to the same type is supported.
// The struct field tag copier:"-" can be added for any fields that
// should not be copied. Also, unexported fields are not copied.
// See [Node.CopyFieldsFrom] for more information on field copying.
func (n *NodeBase) CopyFrom(from Node) {
        if from == nil {
                slog.Error("tree.NodeBase.CopyFrom: nil source", "destinationNode", n)
                return
        }
        copyFrom(n.This, from)
}

// copyFrom is the implementation of [NodeBase.CopyFrom].
func copyFrom(to, from Node) {
        tot := to.AsTree()
        fromt := from.AsTree()
        fc := fromt.Children
        if len(fc) == 0 {
                tot.DeleteChildren()
        } else {
                p := make(TypePlan, len(fc))
                for i, c := range fc {
                        p[i].Type = c.AsTree().NodeType()
                        p[i].Name = c.AsTree().Name
                }
                UpdateSlice(&tot.Children, to, p)
        }

        if fromt.Properties != nil {
                if tot.Properties == nil {
                        tot.Properties = map[string]any{}
                }
                maps.Copy(tot.Properties, fromt.Properties)
        }

        tot.This.CopyFieldsFrom(from)
        for i, kid := range tot.Children {
                fmk := fromt.Child(i)
                copyFrom(kid, fmk)
        }
}

// Clone creates and returns a deep copy of the tree from this node down.
// Any pointers within the cloned tree will correctly point within the new
// cloned tree (see [Node.CopyFrom] for more information).
func (n *NodeBase) Clone() Node {
        nc := n.NewInstance()
        InitNode(nc)
        nc.AsTree().SetName(n.Name)
        nc.AsTree().CopyFrom(n.This)
        return nc
}

// CopyFieldsFrom copies the fields of the node from the given node.
// By default, it is [NodeBase.CopyFieldsFrom], which automatically does
// a deep copy of all of the fields of the node that do not a have a
// `copier:"-"` struct tag. Node types should only implement a custom
// CopyFieldsFrom method when they have fields that need special copying
// logic that can not be automatically handled. All custom CopyFieldsFrom
// methods should call [NodeBase.CopyFieldsFrom] first and then only do manual
// handling of specific fields that can not be automatically copied. See
// [cogentcore.org/core/core.WidgetBase.CopyFieldsFrom] for an example of a
// custom CopyFieldsFrom method.
func (n *NodeBase) CopyFieldsFrom(from Node) {
        err := copier.CopyWithOption(n.This, from.AsTree().This, copier.Option{CaseSensitive: true, DeepCopy: true})
        if err != nil {
                slog.Error("tree.NodeBase.CopyFieldsFrom", "err", err)
        }
}

// Event methods:

// Init is a placeholder implementation of
// [Node.Init] that does nothing.
func (n *NodeBase) Init() {}

// OnAdd is a placeholder implementation of
// [Node.OnAdd] that does nothing.
func (n *NodeBase) OnAdd() {}

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tree

import (
        "log/slog"
        "path/filepath"
        "runtime"
        "strconv"
        "strings"

        "cogentcore.org/core/base/plan"
        "cogentcore.org/core/base/profile"
)

// Plan represents a plan for how the children of a [Node] should be configured.
// A Plan instance is passed to [NodeBase.Makers], which are responsible for
// configuring it. To add a child item to a plan, use [Add], [AddAt], or [AddNew].
// To add a child item maker to a [Node], use [AddChild] or [AddChildAt]. To extend
// an existing child item, use [AddInit] or [AddChildInit].
type Plan struct {

        // Children are the [PlanItem]s for the children.
        Children []*PlanItem

        // EnforceEmpty is whether an empty plan results in the removal
        // of all children of the parent. If there are [NodeBase.Makers]
        // defined then this is true by default; otherwise it is false.
        EnforceEmpty bool
}

// PlanItem represents a plan for how a child [Node] should be constructed and initialized.
// See [Plan] for more information.
type PlanItem struct {

        // Name is the name of the planned node.
        Name string

        // New returns a new node of the correct type for this child.
        New func() Node

        // Init is a slice of functions that are called once in sequential ascending order
        // after [PlanItem.New] to initialize the node for the first time.
        Init []func(n Node)
}

// Updater adds a new function to [NodeBase.Updaters.Normal], which are called in sequential
// descending (reverse) order in [NodeBase.RunUpdaters] to update the node.
func (nb *NodeBase) Updater(updater func()) {
        nb.Updaters.Normal = append(nb.Updaters.Normal, updater)
}

// FirstUpdater adds a new function to [NodeBase.Updaters.First], which are called in sequential
// descending (reverse) order in [NodeBase.RunUpdaters] to update the node.
func (nb *NodeBase) FirstUpdater(updater func()) {
        nb.Updaters.First = append(nb.Updaters.First, updater)
}

// FinalUpdater adds a new function to [NodeBase.Updaters.Final], which are called in sequential
// descending (reverse) order in [NodeBase.RunUpdaters] to update the node.
func (nb *NodeBase) FinalUpdater(updater func()) {
        nb.Updaters.Final = append(nb.Updaters.Final, updater)
}

// Maker adds a new function to [NodeBase.Makers.Normal], which are called in sequential
// ascending order in [NodeBase.Make] to make the plan for how the node's children
// should be configured.
func (nb *NodeBase) Maker(maker func(p *Plan)) {
        nb.Makers.Normal = append(nb.Makers.Normal, maker)
}

// FirstMaker adds a new function to [NodeBase.Makers.First], which are called in sequential
// ascending order in [NodeBase.Make] to make the plan for how the node's children
// should be configured.
func (nb *NodeBase) FirstMaker(maker func(p *Plan)) {
        nb.Makers.First = append(nb.Makers.First, maker)
}

// FinalMaker adds a new function to [NodeBase.Makers.Final], which are called in sequential
// ascending order in [NodeBase.Make] to make the plan for how the node's children
// should be configured.
func (nb *NodeBase) FinalMaker(maker func(p *Plan)) {
        nb.Makers.Final = append(nb.Makers.Final, maker)
}

// Make makes a plan for how the node's children should be structured.
// It does this by running [NodeBase.Makers] in sequential ascending order.
func (nb *NodeBase) Make(p *Plan) {
        // only enforce empty if makers exist
        if len(nb.Makers.First) > 0 || len(nb.Makers.Normal) > 0 || len(nb.Makers.Final) > 0 {
                p.EnforceEmpty = true
        }
        nb.Makers.Do(func(makers []func(p *Plan)) {
                for _, maker := range makers {
                        maker(p)
                }
        })
}

// UpdateFromMake updates the node using [NodeBase.Make].
func (nb *NodeBase) UpdateFromMake() {
        p := &Plan{}
        nb.Make(p)
        p.Update(nb)
}

// RunUpdaters runs the [NodeBase.Updaters] in sequential descending (reverse) order.
// It is called in [cogentcore.org/core/core.WidgetBase.UpdateWidget] and other places
// such as in xyz to update the node.
func (nb *NodeBase) RunUpdaters() {
        nb.Updaters.Do(func(updaters []func()) {
                for i := len(updaters) - 1; i >= 0; i-- {
                        updaters[i]()
                }
        })
}

// Add adds a new [PlanItem] to the given [Plan] for a [Node] with
// the given function to initialize the node. The node is
// guaranteed to be added to its parent before the init function
// is called. The name of the node is automatically generated based
// on the file and line number of the calling function.
func Add[T NodeValue](p *Plan, init func(w *T)) { //yaegi:add
        AddAt(p, AutoPlanName(2), init)
}

// AutoPlanName returns the dir-filename of [runtime.Caller](level),
// with all / . replaced to -, which is suitable as a unique name
// for a [PlanItem.Name].
func AutoPlanName(level int) string {
        _, file, line, _ := runtime.Caller(level)
        name := filepath.Base(file)
        dir := filepath.Base(filepath.Dir(file))
        path := dir + "-" + name
        path = strings.ReplaceAll(strings.ReplaceAll(path, "/", "-"), ".", "-") + "-" + strconv.Itoa(line)
        return path
}

// AddAt adds a new [PlanItem] to the given [Plan] for a [Node] with
// the given name and function to initialize the node. The node
// is guaranteed to be added to its parent before the init function
// is called.
func AddAt[T NodeValue](p *Plan, name string, init func(w *T)) { //yaegi:add
        p.Add(name, func() Node {
                return any(New[T]()).(Node)
        }, func(n Node) {
                init(any(n).(*T))
        })
}

// AddNew adds a new [PlanItem] to the given [Plan] for a [Node] with
// the given name, function for constructing the node, and function
// for initializing the node. The node is guaranteed to be added
// to its parent before the init function is called.
// It should only be called instead of [Add] and [AddAt] when the node
// must be made new, like when using [cogentcore.org/core/core.NewValue].
func AddNew[T Node](p *Plan, name string, new func() T, init func(w T)) { //yaegi:add
        p.Add(name, func() Node {
                return new()
        }, func(n Node) {
                init(n.(T))
        })
}

// AddInit adds a new function for initializing the [Node] with the given name
// in the given [Plan]. The node must already exist in the plan; this is for
// extending an existing [PlanItem], not adding a new one. The node is guaranteed to
// be added to its parent before the init function is called. The init functions are
// called in sequential ascending order.
func AddInit[T NodeValue](p *Plan, name string, init func(w *T)) { //yaegi:add
        for _, child := range p.Children {
                if child.Name == name {
                        child.Init = append(child.Init, func(n Node) {
                                init(any(n).(*T))
                        })
                        return
                }
        }
        slog.Error("AddInit: child not found", "name", name)
}

// AddChild adds a new [NodeBase.Maker] to the the given parent [Node] that
// adds a [PlanItem] with the given init function using [Add]. In other words,
// this adds a maker that will add a child to the given parent.
func AddChild[T NodeValue](parent Node, init func(w *T)) { //yaegi:add
        name := AutoPlanName(2) // must get here to get correct name
        parent.AsTree().Maker(func(p *Plan) {
                AddAt(p, name, init)
        })
}

// AddChildAt adds a new [NodeBase.Maker] to the the given parent [Node] that
// adds a [PlanItem] with the given name and init function using [AddAt]. In other
// words, this adds a maker that will add a child to the given parent.
func AddChildAt[T NodeValue](parent Node, name string, init func(w *T)) { //yaegi:add
        parent.AsTree().Maker(func(p *Plan) {
                AddAt(p, name, init)
        })
}

// AddChildInit adds a new [NodeBase.Maker] to the the given parent [Node] that
// adds a new function for initializing the node with the given name
// in the given [Plan]. The node must already exist in the plan; this is for
// extending an existing [PlanItem], not adding a new one. The node is guaranteed
// to be added to its parent before the init function is called. The init functions are
// called in sequential ascending order.
func AddChildInit[T NodeValue](parent Node, name string, init func(w *T)) { //yaegi:add
        parent.AsTree().Maker(func(p *Plan) {
                AddInit(p, name, init)
        })
}

// Add adds a new [PlanItem] with the given name and functions to the [Plan].
// It should typically not be called by end-user code; see the generic
// [Add], [AddAt], [AddNew], [AddChild], [AddChildAt], [AddInit], and [AddChildInit]
// functions instead.
func (p *Plan) Add(name string, new func() Node, init func(w Node)) {
        p.Children = append(p.Children, &PlanItem{Name: name, New: new, Init: []func(n Node){init}})
}

// Update updates the children of the given [Node] in accordance with the [Plan].
func (p *Plan) Update(n Node) {
        if len(p.Children) == 0 && !p.EnforceEmpty {
                return
        }
        pr := profile.Start("plan.Update")
        plan.Update(&n.AsTree().Children, len(p.Children),
                func(i int) string {
                        return p.Children[i].Name
                }, func(name string, i int) Node {
                        item := p.Children[i]
                        child := item.New()
                        child.AsTree().SetName(item.Name)
                        return child
                }, func(child Node, i int) {
                        SetParent(child, n)
                        for _, f := range p.Children[i].Init {
                                f(child)
                        }
                }, func(child Node) {
                        child.Destroy()
                },
        )
        pr.End()
}

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tree

import (
        "cogentcore.org/core/base/slicesx"
)

// IndexOf returns the index of the given node in the given slice,
// or -1 if it is not found. The optional startIndex argument
// allows for optimized bidirectional searching if you have a guess
// at where the node might be, which can be a key speedup for large
// slices. If no value is specified for startIndex, it starts in the
// middle, which is a good default.
func IndexOf(slice []Node, child Node, startIndex ...int) int {
        return slicesx.Search(slice, func(e Node) bool { return e == child }, startIndex...)
}

// IndexByName returns the index of the first element in the given slice that
// has the given name, or -1 if none is found. See [IndexOf] for info on startIndex.
func IndexByName(slice []Node, name string, startIndex ...int) int {
        return slicesx.Search(slice, func(ch Node) bool { return ch.AsTree().Name == name }, startIndex...)
}

// Code generated by "core generate"; DO NOT EDIT.

package tree

import (
        "cogentcore.org/core/types"
)

var _ = types.AddType(&types.Type{Name: "cogentcore.org/core/tree.NodeBase", IDName: "node-base", Doc: "NodeBase implements the [Node] interface and provides the core functionality\nfor the Cogent Core tree system. You must use NodeBase as an embedded struct\nin all higher-level tree types.\n\nAll nodes must be properly initialized by using one of [New], [NodeBase.NewChild],\n[NodeBase.AddChild], [NodeBase.InsertChild], [NodeBase.Clone], [Update], or [Plan].\nThis ensures that the [NodeBase.This] field is set correctly and the [Node.Init]\nmethod is called.\n\nAll nodes support JSON marshalling and unmarshalling through the standard [encoding/json]\ninterfaces, so you can use the standard functions for loading and saving trees. However,\nif you want to load a root node of the correct type from JSON, you need to use the\n[UnmarshalRootJSON] function.\n\nAll node types must be added to the Cogent Core type registry via typegen,\nso you must add a go:generate line that runs `core generate` to any packages\nyou write that have new node types defined.", Fields: []types.Field{{Name: "Name", Doc: "Name is the name of this node, which is typically unique relative to other children of\nthe same parent. It can be used for finding and serializing nodes. If not otherwise set,\nit defaults to the ID (kebab-case) name of the node type combined with the total number\nof children that have ever been added to the node's parent."}, {Name: "This", Doc: "This is the value of this Node as its true underlying type. This allows methods\ndefined on base types to call methods defined on higher-level types, which\nis necessary for various parts of tree and widget functionality. This is set\nto nil when the node is deleted."}, {Name: "Parent", Doc: "Parent is the parent of this node, which is set automatically when this node is\nadded as a child of a parent. To change the parent of a node, use [MoveToParent];\nyou should typically not set this field directly. Nodes can only have one parent\nat a time."}, {Name: "Children", Doc: "Children is the list of children of this node. All of them are set to have this node\nas their parent. You can directly modify this list, but you should typically use the\nvarious NodeBase child helper functions when applicable so that everything is updated\nproperly, such as when deleting children."}, {Name: "Properties", Doc: "Properties is a property map for arbitrary key-value properties.\nWhen possible, use typed fields on a new type embedding NodeBase instead of this.\nYou should typically use the [NodeBase.SetProperty], [NodeBase.Property], and\n[NodeBase.DeleteProperty] methods for modifying and accessing properties."}, {Name: "Updaters", Doc: "Updaters is a tiered set of functions called in sequential descending (reverse) order\nin [NodeBase.RunUpdaters] to update the node. You can use [NodeBase.Updater],\n[NodeBase.FirstUpdater], or [NodeBase.FinalUpdater] to add one. This typically\ntypically contains [NodeBase.UpdateFromMake] at the start of the normal list."}, {Name: "Makers", Doc: "Makers is a tiered set of functions called in sequential ascending order\nin [NodeBase.Make] to make the plan for how the node's children should\nbe configured. You can use [NodeBase.Maker], [NodeBase.FirstMaker], or\n[NodeBase.FinalMaker] to add one."}, {Name: "OnChildAdded", Doc: "OnChildAdded is called when a node is added as a direct child of this node.\nWhen a node is added to a parent, it calls [Node.OnAdd] on itself and then\nthis function on its parent if it is non-nil."}, {Name: "numLifetimeChildren", Doc: "numLifetimeChildren is the number of children that have ever been added to this\nnode, which is used for automatic unique naming."}, {Name: "index", Doc: "index is the last value of our index, which is used as a starting point for\nfinding us in our parent next time. It is not guaranteed to be accurate;\nuse the [NodeBase.IndexInParent] method."}, {Name: "depth", Doc: "depth is the depth of the node while using [NodeBase.WalkDownBreadth]."}}})

// NewNodeBase returns a new [NodeBase] with the given optional parent:
// NodeBase implements the [Node] interface and provides the core functionality
// for the Cogent Core tree system. You must use NodeBase as an embedded struct
// in all higher-level tree types.
//
// All nodes must be properly initialized by using one of [New], [NodeBase.NewChild],
// [NodeBase.AddChild], [NodeBase.InsertChild], [NodeBase.Clone], [Update], or [Plan].
// This ensures that the [NodeBase.This] field is set correctly and the [Node.Init]
// method is called.
//
// All nodes support JSON marshalling and unmarshalling through the standard [encoding/json]
// interfaces, so you can use the standard functions for loading and saving trees. However,
// if you want to load a root node of the correct type from JSON, you need to use the
// [UnmarshalRootJSON] function.
//
// All node types must be added to the Cogent Core type registry via typegen,
// so you must add a go:generate line that runs `core generate` to any packages
// you write that have new node types defined.
func NewNodeBase(parent ...Node) *NodeBase { return New[NodeBase](parent...) }

// SetName sets the [NodeBase.Name]:
// Name is the name of this node, which is typically unique relative to other children of
// the same parent. It can be used for finding and serializing nodes. If not otherwise set,
// it defaults to the ID (kebab-case) name of the node type combined with the total number
// of children that have ever been added to the node's parent.
func (t *NodeBase) SetName(v string) *NodeBase { t.Name = v; return t }

// SetOnChildAdded sets the [NodeBase.OnChildAdded]:
// OnChildAdded is called when a node is added as a direct child of this node.
// When a node is added to a parent, it calls [Node.OnAdd] on itself and then
// this function on its parent if it is non-nil.
func (t *NodeBase) SetOnChildAdded(v func(n Node)) *NodeBase { t.OnChildAdded = v; return t }

// Copyright (c) 2018, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package tree

import (
        "cogentcore.org/core/base/plan"
        "cogentcore.org/core/types"
)

// TypePlan is a plan for the organization of a list of tree nodes,
// specified by the Type of element at a given index, with a given name.
// It is used in [Update] and [UpdateSlice] to actually update the items
// according to the plan.
type TypePlan []TypePlanItem

// TypePlanItem holds a type and a name, for specifying the [TypePlan].
type TypePlanItem struct {
        Type *types.Type
        Name string
}

// Add adds a new [TypePlanItem] with the given type and name.
func (t *TypePlan) Add(typ *types.Type, name string) {
        *t = append(*t, TypePlanItem{typ, name})
}

// UpdateSlice ensures that the given slice contains the elements
// according to the [TypePlan], specified by unique element names.
// The given Node is set as the parent of the created nodes.
// It returns whether any changes were made.
func UpdateSlice(slice *[]Node, parent Node, p TypePlan) bool {
        return plan.Update(slice, len(p),
                func(i int) string { return p[i].Name },
                func(name string, i int) Node {
                        n := newOfType(p[i].Type)
                        n.AsTree().SetName(name)
                        InitNode(n)
                        return n
                }, func(child Node, i int) {
                        if parent != nil {
                                SetParent(child, parent)
                        }
                },
                func(child Node) {
                        child.Destroy()
                },
        )
}

// Update ensures that the children of the given [Node] contain the elements
// according to the [TypePlan], specified by unique element names.
// It returns whether any changes were made.
func Update(n Node, p TypePlan) bool {
        return UpdateSlice(&n.AsTree().Children, n, p)
}

// Copyright (c) 2020, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
This file provides basic tree walking functions for iterative traversal
of the tree in up / down directions.  As compared to the Node walk methods,
these are for more dynamic, piecemeal processing.
*/

package tree

// Last returns the last node in the tree.
func Last(n Node) Node {
        n = lastChild(n)
        last := n
        n.AsTree().WalkDown(func(k Node) bool {
                last = k
                return Continue
        })
        return last
}

// lastChild returns the last child under the given node,
// or the node itself if it has no children.
func lastChild(n Node) Node {
        nb := n.AsTree()
        if nb.HasChildren() {
                return lastChild(nb.Child(nb.NumChildren() - 1))
        }
        return n
}

// Previous returns the previous node in the tree,
// or nil if this is the root node.
func Previous(n Node) Node {
        nb := n.AsTree()
        if nb.Parent == nil {
                return nil
        }
        myidx := n.AsTree().IndexInParent()
        if myidx > 0 {
                nn := nb.Parent.AsTree().Child(myidx - 1)
                return lastChild(nn)
        }
        return nb.Parent
}

// Next returns next node in the tree,
// or nil if this is the last node.
func Next(n Node) Node {
        if !n.AsTree().HasChildren() {
                return NextSibling(n)
        }
        return n.AsTree().Child(0)
}

// NextSibling returns the next sibling of this node,
// or nil if it has none.
func NextSibling(n Node) Node {
        nb := n.AsTree()
        if nb.Parent == nil {
                return nil
        }
        myidx := n.AsTree().IndexInParent()
        if myidx >= 0 && myidx < nb.Parent.AsTree().NumChildren()-1 {
                return nb.Parent.AsTree().Child(myidx + 1)
        }
        return NextSibling(nb.Parent)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Command typgen provides the generation of type information for
// Go types, methods, and functions.
package main

import (
        "cogentcore.org/core/cli"
        "cogentcore.org/core/types/typegen"
)

func main() {
        opts := cli.DefaultOptions("typegen", "Typegen provides the generation of type information for Go types, methods, and functions.")
        cli.Run(opts, &typegen.Config{}, typegen.Generate)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types

import (
        "strings"
)

// Directive represents a comment directive in the format:
//
//        //tool:directive args...
type Directive struct {
        Tool      string
        Directive string
        Args      []string
}

// String returns a string representation of the directive
// in the format:
//
//        //tool:directive args...
func (d Directive) String() string {
        return "//" + d.Tool + ":" + d.Directive + " " + strings.Join(d.Args, " ")
}

func (d Directive) GoString() string { return StructGoString(d) }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types

import (
        "reflect"

        "cogentcore.org/core/base/reflectx"
)

// Field represents a field or embed in a struct.
type Field struct {

        // Name is the name of the field (eg: Icon)
        Name string

        // Doc has all of the comment documentation
        // info as one string with directives removed.
        Doc string
}

func (f Field) GoString() string { return StructGoString(f) }

// GetField recursively attempts to extract the [Field]
// with the given name from the given struct [reflect.Value],
// by searching through all of the embeds if it can not find
// it directly in the struct.
func GetField(val reflect.Value, field string) *Field {
        val = reflectx.NonPointerValue(val)
        if !val.IsValid() {
                return nil
        }
        typ := TypeByName(TypeName(val.Type()))
        // if we are not in the type registry, there is nothing that we can do
        if typ == nil {
                return nil
        }
        for _, f := range typ.Fields {
                if f.Name == field {
                        // we have successfully gotten the field
                        return &f
                }
        }
        // otherwise, we go through all of the embeds and call
        // GetField recursively on them
        for _, e := range typ.Embeds {
                rf := val.FieldByName(e.Name)
                f := GetField(rf, field)
                // we have successfully gotten the field
                if f != nil {
                        return f
                }
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types

// Func represents a global function.
type Func struct {
        // Name is the fully qualified name of the function
        // (eg: cogentcore.org/core/core.NewButton)
        Name string

        // Doc has all of the comment documentation
        // info as one string with directives removed.
        Doc string

        // Directives are the parsed comment directives
        Directives []Directive

        // Args are the names of the arguments to the function
        Args []string

        // Returns are the names of the return values of the function
        Returns []string

        // ID is the unique function ID number
        ID uint64
}

func (f Func) GoString() string { return StructGoString(f) }

// Method represents a method.
type Method struct {
        // Name is the name of the method (eg: NewChild)
        Name string

        // Doc has all of the comment documentation
        // info as one string with directives removed.
        Doc string

        // Directives are the parsed comment directives
        Directives []Directive

        // Args are the names of the arguments to the function
        Args []string

        // Returns are the names of the return values of the function
        Returns []string
}

func (m Method) GoString() string { return StructGoString(m) }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types

import (
        "fmt"
        "log/slog"
        "reflect"
        "runtime"
        "sync/atomic"
)

var (
        // Funcs records all types (i.e., a type registry)
        // key is long type name: package_url.Func, e.g., cogentcore.org/core/core.Button
        Funcs = map[string]*Func{}

        // FuncIDCounter is an atomically incremented uint64 used
        // for assigning new [Func.ID] numbers
        FuncIDCounter uint64
)

// FuncByName returns a Func by name (package_url.Type, e.g., cogentcore.org/core/core.Button),
func FuncByName(nm string) *Func {
        fi, ok := Funcs[nm]
        if !ok {
                return nil
        }
        return fi
}

// FuncByNameTry returns a Func by name (package_url.Type, e.g., cogentcore.org/core/core.Button),
// or error if not found
func FuncByNameTry(nm string) (*Func, error) {
        fi, ok := Funcs[nm]
        if !ok {
                return nil, fmt.Errorf("func %q not found", nm)
        }
        return fi, nil
}

// FuncInfo returns function info for given function.
func FuncInfo(f any) *Func {
        return FuncByName(FuncName(f))
}

// FuncInfoTry returns function info for given function.
func FuncInfoTry(f any) (*Func, error) {
        return FuncByNameTry(FuncName(f))
}

// AddFunc adds a constructed [Func] to the registry
// and returns it. This sets the ID.
func AddFunc(fun *Func) *Func {
        if _, has := Funcs[fun.Name]; has {
                slog.Debug("types.AddFunc: Func already exists", "Func.Name", fun.Name)
                return fun
        }
        fun.ID = atomic.AddUint64(&FuncIDCounter, 1)
        Funcs[fun.Name] = fun
        return fun
}

// FuncName returns the fully package-qualified name of given function
// This is guaranteed to be unique and used for the Funcs registry.
func FuncName(f any) string {
        return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package types

import (
        "fmt"
        "reflect"
        "strings"
)

// Type represents a type.
type Type struct {
        // Name is the fully package-path-qualified name of the type
        // (eg: cogentcore.org/core/core.Button).
        Name string

        // IDName is the short, package-unqualified, kebab-case name of
        // the type that is suitable for use in an ID (eg: button).
        IDName string

        // Doc has all of the comment documentation
        // info as one string with directives removed.
        Doc string

        // Directives has the parsed comment directives.
        Directives []Directive

        // Methods of the type, which are available for all types.
        Methods []Method

        // Embedded fields of struct types.
        Embeds []Field

        // Fields of struct types.
        Fields []Field

        // Instance is an instance of a non-nil pointer to the type,
        // which is set by [For] and other external functions such that
        // a [Type] can be used to make new instances of the type by
        // reflection. It is not set by typegen.
        Instance any

        // ID is the unique type ID number set by [AddType].
        ID uint64
}

func (tp *Type) String() string {
        return tp.Name
}

// ShortName returns the short name of the type (package.Type)
func (tp *Type) ShortName() string {
        li := strings.LastIndex(tp.Name, "/")
        return tp.Name[li+1:]
}

func (tp *Type) Label() string {
        return tp.ShortName()
}

// ReflectType returns the [reflect.Type] for this type, using [Type.Instance].
func (tp *Type) ReflectType() reflect.Type {
        if tp.Instance == nil {
                return nil
        }
        return reflect.TypeOf(tp.Instance).Elem()
}

// StructGoString creates a GoString for the given struct,
// omitting any zero values.
func StructGoString(str any) string {
        s := reflect.ValueOf(str)
        typ := s.Type()
        strs := []string{}
        for i := 0; i < s.NumField(); i++ {
                f := s.Field(i)
                if f.IsZero() {
                        continue
                }
                nm := typ.Field(i).Name
                strs = append(strs, fmt.Sprintf("%s: %#v", nm, f))

        }
        return "{" + strings.Join(strs, ", ") + "}"
}

func (tp Type) GoString() string { return StructGoString(tp) }

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package typegen

import (
        "reflect"
        "strings"
        "text/template"
        "unicode"

        "cogentcore.org/core/types"
)

// TypeTmpl is the template for [types.Type] declarations.
// It takes a [*Type] as its value.
var TypeTmpl = template.Must(template.New("Type").
        Funcs(template.FuncMap{
                "TypesTypeOf": TypesTypeOf,
        }).Parse(
        `
        var _ = types.AddType(&types.Type
                {{- $typ := TypesTypeOf . -}}
                {{- printf "%#v" $typ -}}
        )
        `))

// TypesTypeOf converts the given [*Type] to a [*types.Type].
func TypesTypeOf(typ *Type) *types.Type {
        cp := typ.Type
        res := &cp
        res.Fields = typ.Fields.Fields
        res.Embeds = typ.Embeds.Fields
        return res
}

// FuncTmpl is the template for [types.Func] declarations.
// It takes a [*types.Func] as its value.
var FuncTmpl = template.Must(template.New("Func").Parse(
        `
        var _ = types.AddFunc(&types.Func
                {{- printf "%#v" . -}}
        )
        `))

// SetterMethodsTmpl is the template for setter methods for a type.
// It takes a [*Type] as its value.
var SetterMethodsTmpl = template.Must(template.New("SetterMethods").
        Funcs(template.FuncMap{
                "SetterFields": SetterFields,
                "SetterType":   SetterType,
                "DocToComment": DocToComment,
        }).Parse(
        `
        {{$typ := .}}
        {{range (SetterFields .)}}
        // Set{{.Name}} sets the [{{$typ.LocalName}}.{{.Name}}] {{- if ne .Doc ""}}:{{end}}
        {{DocToComment .Doc}}
        func (t *{{$typ.LocalName}}) Set{{.Name}}(v {{SetterType . $typ}}) *{{$typ.LocalName}} { t.{{.Name}} = v; return t }
        {{end}}
`))

// SetterFields returns all of the exported fields and embedded fields of the given type
// that don't have a `set:"-"` struct tag.
func SetterFields(typ *Type) []types.Field {
        res := []types.Field{}
        for _, f := range typ.Fields.Fields {
                // we do not generate setters for unexported fields
                if unicode.IsLower([]rune(f.Name)[0]) {
                        continue
                }
                // unspecified indicates to add a set method; only "-" means no set
                hasSetter := reflect.StructTag(typ.Fields.Tags[f.Name]).Get("set") != "-"
                if hasSetter {
                        res = append(res, f)
                }
        }
        return res
}

// SetterType returns the setter type name for the given field in the context of the
// given type. It converts slices to variadic arguments.
func SetterType(f types.Field, typ *Type) string {
        lt := typ.Fields.LocalTypes[f.Name]
        if strings.HasPrefix(lt, "[]") {
                return "..." + strings.TrimPrefix(lt, "[]")
        }
        return lt
}

// DocToComment converts the given doc string to an appropriate comment string.
func DocToComment(doc string) string {
        return "// " + strings.ReplaceAll(doc, "\n", "\n// ")
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package typgen provides the generation of type information for
// Go types, methods, and functions.
package typegen

//go:generate core generate

import (
        "fmt"

        "cogentcore.org/core/base/generate"
        "golang.org/x/tools/go/packages"
)

// ParsePackages parses the package(s) located in the configuration source directory.
func ParsePackages(cfg *Config) ([]*packages.Package, error) {
        pcfg := &packages.Config{
                Mode: PackageModes(cfg),
                // TODO: Need to think about types and functions in test files. Maybe write typegen_test.go
                // in a separate pass? For later.
                Tests: false,
        }
        pkgs, err := generate.Load(pcfg, cfg.Dir)
        if err != nil {
                return nil, fmt.Errorf("typegen: Generate: error parsing package: %w", err)
        }
        return pkgs, err
}

// Generate generates typegen type info, using the
// configuration information, loading the packages from the
// configuration source directory, and writing the result
// to the configuration output file.
//
// It is a simple entry point to typegen that does all
// of the steps; for more specific functionality, create
// a new [Generator] with [NewGenerator] and call methods on it.
//
//cli:cmd -root
func Generate(cfg *Config) error { //types:add
        pkgs, err := ParsePackages(cfg)
        if err != nil {
                return err
        }
        return GeneratePkgs(cfg, pkgs)
}

// GeneratePkgs generates enum methods using
// the given configuration object and packages parsed
// from the configuration source directory,
// and writes the result to the config output file.
// It is a simple entry point to typegen that does all
// of the steps; for more specific functionality, create
// a new [Generator] with [NewGenerator] and call methods on it.
func GeneratePkgs(cfg *Config, pkgs []*packages.Package) error {
        g := NewGenerator(cfg, pkgs)
        for _, pkg := range g.Pkgs {
                g.Pkg = pkg
                g.Buf.Reset()
                err := g.Find()
                if err != nil {
                        return fmt.Errorf("typegen: Generate: error finding types for package %q: %w", pkg.Name, err)
                }
                g.PrintHeader()
                has, err := g.Generate()
                if !has {
                        continue
                }
                if err != nil {
                        return fmt.Errorf("typegen: Generate: error generating code for package %q: %w", pkg.Name, err)
                }
                err = g.Write()
                if err != nil {
                        return fmt.Errorf("typegen: Generate: error writing code for package %q: %w", pkg.Name, err)
                }
        }
        return nil
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package typegen

import (
        "bytes"
        "fmt"
        "go/ast"
        "go/types"
        "maps"
        "os"
        "slices"
        "strings"
        "text/template"

        "log/slog"

        "cogentcore.org/core/base/generate"
        "cogentcore.org/core/base/ordmap"
        "cogentcore.org/core/base/strcase"
        "cogentcore.org/core/cli"
        ctypes "cogentcore.org/core/types"
        "golang.org/x/tools/go/packages"
)

// Generator holds the state of the generator.
// It is primarily used to buffer the output.
type Generator struct {
        Config     *Config                              // The configuration information
        Buf        bytes.Buffer                         // The accumulated output.
        Pkgs       []*packages.Package                  // The packages we are scanning.
        Pkg        *packages.Package                    // The packages we are currently on.
        File       *ast.File                            // The file we are currently on.
        Cmap       ast.CommentMap                       // The comment map for the file we are currently on.
        Types      []*Type                              // The types
        Methods    ordmap.Map[string, []ctypes.Method]  // The methods, keyed by the the full package name of the type of the receiver
        Funcs      ordmap.Map[string, ctypes.Func]      // The functions
        Interfaces ordmap.Map[string, *types.Interface] // The cached interfaces, created from [Config.InterfaceConfigs]
}

// NewGenerator returns a new generator with the
// given configuration information and parsed packages.
func NewGenerator(config *Config, pkgs []*packages.Package) *Generator {
        return &Generator{Config: config, Pkgs: pkgs}
}

// PackageModes returns the package load modes needed for typegen,
// based on the given config information.
func PackageModes(cfg *Config) packages.LoadMode {
        res := packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedTypesInfo
        // we only need deps if we are checking for interface impls
        if cfg.InterfaceConfigs.Len() > 0 {
                res |= packages.NeedDeps
        }
        return res
}

// Printf prints the formatted string to the
// accumulated output in [Generator.Buf]
func (g *Generator) Printf(format string, args ...any) {
        fmt.Fprintf(&g.Buf, format, args...)
}

// PrintHeader prints the header and package clause
// to the accumulated output
func (g *Generator) PrintHeader() {
        // we need a manual import of types and ordmap because they are
        // external, but goimports will handle everything else
        generate.PrintHeader(&g.Buf, g.Pkg.Name, "cogentcore.org/core/types", "cogentcore.org/core/base/ordmap")
}

// Find goes through all of the types, functions, variables,
// and constants in the package, finds those marked with types:add,
// and adds them to [Generator.Types] and [Generator.Funcs]
func (g *Generator) Find() error {
        err := g.GetInterfaces()
        if err != nil {
                return err
        }
        g.Types = []*Type{}
        err = generate.Inspect(g.Pkg, g.Inspect, "enumgen.go", "typegen.go")
        if err != nil {
                return fmt.Errorf("error while inspecting: %w", err)
        }
        return nil
}

// GetInterfaces sets [Generator.Interfaces] based on
// [Generator.Config.InterfaceConfigs]. It should typically not
// be called by end-user code.
func (g *Generator) GetInterfaces() error {
        if g.Config.InterfaceConfigs.Len() == 0 {
                return nil
        }
        for _, typ := range g.Pkg.TypesInfo.Types {
                nm := typ.Type.String()
                if _, ok := g.Config.InterfaceConfigs.ValueByKeyTry(nm); ok {
                        utyp := typ.Type.Underlying()
                        iface, ok := utyp.(*types.Interface)
                        if !ok {
                                return fmt.Errorf("invalid InterfaceConfigs value: type %q is not a *types.Interface but a %T (type value %v)", nm, utyp, utyp)
                        }
                        g.Interfaces.Add(nm, iface)
                }
        }
        return nil
}

// AllowedEnumTypes are the types that can be used for enums
// that are not bit flags (bit flags can only be int64s).
// It is stored as a map for quick and convenient access.
var AllowedEnumTypes = map[string]bool{"int": true, "int64": true, "int32": true, "int16": true, "int8": true, "uint": true, "uint64": true, "uint32": true, "uint16": true, "uint8": true}

// Inspect looks at the given AST node and adds it
// to [Generator.Types] if it is marked with an appropriate
// comment directive. It returns whether the AST inspector should
// continue, and an error if there is one. It should only
// be called in [ast.Inspect].
func (g *Generator) Inspect(n ast.Node) (bool, error) {
        switch v := n.(type) {
        case *ast.File:
                g.File = v
                g.Cmap = ast.NewCommentMap(g.Pkg.Fset, v, v.Comments)
        case *ast.GenDecl:
                return g.InspectGenDecl(v)
        case *ast.FuncDecl:
                return g.InspectFuncDecl(v)
        }
        return true, nil
}

// InspectGenDecl is the implementation of [Generator.Inspect]
// for [ast.GenDecl] nodes.
func (g *Generator) InspectGenDecl(gd *ast.GenDecl) (bool, error) {
        doc := strings.TrimSuffix(gd.Doc.Text(), "\n")
        for _, spec := range gd.Specs {
                ts, ok := spec.(*ast.TypeSpec)
                if !ok {
                        return true, nil
                }
                cfg := &Config{}
                *cfg = *g.Config

                if cfg.InterfaceConfigs.Len() > 0 {
                        typ := g.Pkg.TypesInfo.Defs[ts.Name].Type()
                        if !types.IsInterface(typ) {
                                for _, kv := range cfg.InterfaceConfigs.Order {
                                        in := kv.Key
                                        ic := kv.Value
                                        iface := g.Interfaces.ValueByKey(in)
                                        if iface == nil {
                                                slog.Info("missing interface object", "interface", in)
                                                continue
                                        }
                                        if !types.Implements(typ, iface) && !types.Implements(types.NewPointer(typ), iface) { // either base type or pointer can implement
                                                continue
                                        }
                                        *cfg = *ic
                                }
                        }
                }

                // By default, we use the comments on the GenDecl, as that
                // is where they are normally stored. However, when there
                // are comments on the type spec itself, that means we are
                // probably in a type block, and thus we must use the comments
                // on the type spec itself.
                commentNode := ast.Node(gd)
                if ts.Doc != nil || ts.Comment != nil {
                        commentNode = ts
                }
                if ts.Doc != nil {
                        doc = strings.TrimSuffix(ts.Doc.Text(), "\n")
                }

                dirs, hasAdd, hasSkip, err := g.LoadFromNodeComments(cfg, commentNode)
                if err != nil {
                        return false, err
                }
                if (!hasAdd && !cfg.AddTypes) || hasSkip { // we must be told to add or we will not add
                        return true, nil
                }

                typ := &Type{
                        Type: ctypes.Type{
                                Name:       FullName(g.Pkg, ts.Name.Name),
                                IDName:     strcase.ToKebab(ts.Name.Name),
                                Doc:        doc,
                                Directives: dirs,
                        },
                        LocalName: ts.Name.Name,
                        AST:       ts,
                        Pkg:       g.Pkg.Name,
                        Config:    cfg,
                }
                if st, ok := ts.Type.(*ast.StructType); ok && st.Fields != nil {
                        emblist := &ast.FieldList{}
                        delOff := 0
                        for i := range len(st.Fields.List) {
                                i -= delOff
                                field := st.Fields.List[i]
                                // if we have no names, we are embed, so add to embeds and remove from fields
                                if len(field.Names) == 0 {
                                        emblist.List = append(emblist.List, field)
                                        st.Fields.List = slices.Delete(st.Fields.List, i, i+1)
                                        delOff++
                                }
                        }

                        embeds, err := g.GetFields(emblist, cfg)
                        if err != nil {
                                return false, err
                        }
                        typ.Embeds = embeds

                        fields, err := g.GetFields(st.Fields, cfg)
                        if err != nil {
                                return false, err
                        }
                        typ.Fields = fields
                }
                if in, ok := ts.Type.(*ast.InterfaceType); ok {
                        prev := g.Config.AddMethods
                        // the only point of an interface is the methods,
                        // so we add them by default
                        g.Config.AddMethods = true
                        for _, m := range in.Methods.List {
                                if f, ok := m.Type.(*ast.FuncType); ok {
                                        // add in any line comments
                                        if m.Doc == nil {
                                                m.Doc = m.Comment
                                        } else if m.Comment != nil {
                                                m.Doc.List = append(m.Doc.List, m.Comment.List...)
                                        }
                                        g.InspectFuncDecl(&ast.FuncDecl{
                                                Doc:  m.Doc,
                                                Recv: &ast.FieldList{List: []*ast.Field{{Type: ts.Name}}},
                                                Name: m.Names[0],
                                                Type: f,
                                        })
                                }
                        }
                        g.Config.AddMethods = prev
                }
                g.Types = append(g.Types, typ)
        }
        return true, nil
}

// LocalTypeNameQualifier returns a [types.Qualifier] similar to that
// returned by [types.RelativeTo], but using the package name instead
// of the package path so that it can be used in code.
func LocalTypeNameQualifier(pkg *types.Package) types.Qualifier {
        if pkg == nil {
                return nil
        }
        return func(other *types.Package) string {
                if pkg == other {
                        return "" // same package; unqualified
                }
                return other.Name()
        }
}

// InspectFuncDecl is the implementation of [Generator.Inspect]
// for [ast.FuncDecl] nodes.
func (g *Generator) InspectFuncDecl(fd *ast.FuncDecl) (bool, error) {
        cfg := &Config{}
        *cfg = *g.Config
        dirs, hasAdd, hasSkip, err := g.LoadFromNodeComments(cfg, fd)
        if err != nil {
                return false, err
        }
        doc := strings.TrimSuffix(fd.Doc.Text(), "\n")

        if fd.Recv == nil {
                if (!hasAdd && !cfg.AddFuncs) || hasSkip { // we must be told to add or we will not add
                        return true, nil
                }
                fun := ctypes.Func{
                        Name:       FullName(g.Pkg, fd.Name.Name),
                        Doc:        doc,
                        Directives: dirs,
                }
                args, err := g.GetFields(fd.Type.Params, cfg)
                if err != nil {
                        return false, fmt.Errorf("error getting function args: %w", err)
                }
                for _, arg := range args.Fields {
                        fun.Args = append(fun.Args, arg.Name)
                }
                rets, err := g.GetFields(fd.Type.Results, cfg)
                if err != nil {
                        return false, fmt.Errorf("error getting function return values: %w", err)
                }
                for _, ret := range rets.Fields {
                        fun.Returns = append(fun.Returns, ret.Name)
                }
                g.Funcs.Add(fun.Name, fun)
        } else {
                if (!hasAdd && !cfg.AddMethods) || hasSkip { // we must be told to add or we will not add
                        return true, nil
                }
                method := ctypes.Method{
                        Name:       fd.Name.Name,
                        Doc:        doc,
                        Directives: dirs,
                }
                args, err := g.GetFields(fd.Type.Params, cfg)
                if err != nil {
                        return false, fmt.Errorf("error getting method args: %w", err)
                }
                for _, arg := range args.Fields {
                        method.Args = append(method.Args, arg.Name)
                }
                rets, err := g.GetFields(fd.Type.Results, cfg)
                if err != nil {
                        return false, fmt.Errorf("error getting method return values: %w", err)
                }
                for _, ret := range rets.Fields {
                        method.Returns = append(method.Returns, ret.Name)
                }

                typ := fd.Recv.List[0].Type
                // get rid of any pointer receiver
                tnm := strings.TrimPrefix(types.ExprString(typ), "*")
                typnm := FullName(g.Pkg, tnm)
                g.Methods.Add(typnm, append(g.Methods.ValueByKey(typnm), method))
        }

        return true, nil
}

// FullName returns the fully qualified name of an identifier
// in the given package with the given name.
func FullName(pkg *packages.Package, name string) string {
        // idents in main packages are just "main.IdentName"
        if pkg.Name == "main" {
                return "main." + name
        }
        return pkg.PkgPath + "." + name
}

// GetFields creates and returns a new [ctypes.Fields] object
// from the given [ast.FieldList], in the context of the
// given surrounding config. If the given field list is
// nil, GetFields still returns an empty but valid
// [ctypes.Fields] value and no error.
func (g *Generator) GetFields(list *ast.FieldList, cfg *Config) (Fields, error) {
        res := Fields{LocalTypes: map[string]string{}, Tags: map[string]string{}}
        if list == nil {
                return res, nil
        }
        for _, field := range list.List {
                ltn := types.ExprString(field.Type)
                ftyp := g.Pkg.TypesInfo.TypeOf(field.Type)
                tn := ftyp.String()

                switch ftyp.(type) {
                case *types.Slice, *types.Array, *types.Map:
                default:
                        // if the type is not a slice, array, or map, we get the name of the type
                        // before anything involving square brackets so that generic types don't confuse it
                        tn, _, _ = strings.Cut(tn, "[")
                        tn, _, _ = strings.Cut(tn, "]")
                }

                name := ""
                if len(field.Names) == 1 {
                        name = field.Names[0].Name
                } else if len(field.Names) == 0 {
                        // if we have no name, fall back on type name
                        name = tn
                        // we must get rid of any package name, as field
                        // names never have package names
                        li := strings.LastIndex(name, ".")
                        if li >= 0 {
                                name = name[li+1:] // need to get rid of .
                        }
                } else {
                        // if we have more than one name, that typically indicates
                        // type-omitted arguments (eg: "func(x, y float32)"), so
                        // we handle all of the names seperately here and then continue.
                        for _, nm := range field.Names {
                                nfield := *field
                                nfield.Names = []*ast.Ident{nm}
                                nlist := &ast.FieldList{List: []*ast.Field{&nfield}}
                                nfields, err := g.GetFields(nlist, cfg)
                                if err != nil {
                                        return res, err
                                }
                                res.Fields = append(res.Fields, nfields.Fields...)
                                maps.Copy(res.LocalTypes, nfields.LocalTypes)
                                maps.Copy(res.Tags, nfields.Tags)
                        }
                        continue
                }
                fo := ctypes.Field{
                        Name: name,
                        Doc:  strings.TrimSuffix(field.Doc.Text(), "\n"),
                }
                res.Fields = append(res.Fields, fo)

                res.LocalTypes[name] = ltn

                tag := ""
                if field.Tag != nil {
                        // need to get rid of leading and trailing backquotes
                        tag = strings.TrimPrefix(strings.TrimSuffix(field.Tag.Value, "`"), "`")
                }
                res.Tags[name] = tag
        }
        return res, nil
}

// LoadFromNodeComments is a helper function that calls [LoadFromComments] with the correctly
// filtered comment map comments of the given node.
func (g *Generator) LoadFromNodeComments(cfg *Config, n ast.Node) (dirs []ctypes.Directive, hasAdd bool, hasSkip bool, err error) {
        cs := g.Cmap.Filter(n).Comments()
        tf := g.Pkg.Fset.File(g.File.FileStart)
        np := tf.Line(n.Pos())
        keep := []*ast.CommentGroup{}
        for _, c := range cs {
                // if the comment's line is after ours, we ignore it, as it is likely associated with something else
                if tf.Line(c.Pos()) > np {
                        continue
                }
                keep = append(keep, c)
        }
        return LoadFromComments(cfg, keep...)
}

// LoadFromComments is a helper function that combines the results of [LoadFromComment]
// for the given comment groups.
func LoadFromComments(cfg *Config, c ...*ast.CommentGroup) (dirs []ctypes.Directive, hasAdd bool, hasSkip bool, err error) {
        for _, cg := range c {
                cdirs, cadd, cskip, err := LoadFromComment(cg, cfg)
                if err != nil {
                        return nil, false, false, err
                }
                dirs = append(dirs, cdirs...)
                hasAdd = hasAdd || cadd
                hasSkip = hasSkip || cskip
        }
        return
}

// LoadFromComment processes the given comment group, setting the
// values of the given config object based on any types directives
// in the comment group, and returning all directives found, whether
// there was a types:add directive, and any error. If the given
// documentation is nil, LoadFromComment still returns an empty but valid
// [ctypes.Directives] value, false, and no error.
func LoadFromComment(c *ast.CommentGroup, cfg *Config) (dirs []ctypes.Directive, hasAdd bool, hasSkip bool, err error) {
        if c == nil {
                return
        }
        for _, c := range c.List {
                dir, err := cli.ParseDirective(c.Text)
                if err != nil {
                        return nil, false, false, fmt.Errorf("error parsing comment directive from %q: %w", c.Text, err)
                }
                if dir == nil {
                        continue
                }
                if dir.Tool == "types" && dir.Directive == "add" {
                        hasAdd = true
                }
                if dir.Tool == "types" {
                        if dir.Directive == "skip" {
                                hasSkip = true
                        }
                        if dir.Directive == "add" || dir.Directive == "skip" {
                                leftovers, err := cli.SetFromArgs(cfg, dir.Args, cli.ErrNotFound)
                                if err != nil {
                                        return nil, false, false, fmt.Errorf("error setting config info from comment directive args: %w (from directive %q)", err, c.Text)
                                }
                                if len(leftovers) > 0 {
                                        return nil, false, false, fmt.Errorf("expected 0 positional arguments but got %d (list: %v) (from directive %q)", len(leftovers), leftovers, c.Text)
                                }
                        } else {
                                return nil, false, false, fmt.Errorf("unrecognized types directive %q (from %q)", dir.Directive, c.Text)
                        }
                }
                dirs = append(dirs, *dir)
        }
        return dirs, hasAdd, hasSkip, nil
}

// Generate produces the code for the types
// stored in [Generator.Types] and stores them in
// [Generator.Buf]. It returns whether there were
// any types to generate methods for, and
// any error that occurred.
func (g *Generator) Generate() (bool, error) {
        if len(g.Types) == 0 && g.Funcs.Len() == 0 {
                return false, nil
        }
        for _, typ := range g.Types {
                typ.Methods = append(typ.Methods, g.Methods.ValueByKey(typ.Name)...)
                g.ExecTmpl(TypeTmpl, typ)
                for _, tmpl := range typ.Config.Templates {
                        g.ExecTmpl(tmpl, typ)
                }
                if typ.Config.Setters {
                        g.ExecTmpl(SetterMethodsTmpl, typ)
                }
        }
        for _, fun := range g.Funcs.Order {
                g.ExecTmpl(FuncTmpl, fun.Value)
        }
        return true, nil
}

// ExecTmpl executes the given template with the given data and
// writes the result to [Generator.Buf]. It fatally logs any error.
// All typegen templates take a [*Type] or [*ctypes.Func] as their data.
func (g *Generator) ExecTmpl(t *template.Template, data any) {
        err := t.Execute(&g.Buf, data)
        if err != nil {
                slog.Error("programmer error: internal error: error executing template", "err", err)
                os.Exit(1)
        }
}

// Write formats the data in the the Generator's buffer
// ([Generator.Buf]) and writes it to the file specified by
// [Generator.Config.Output].
func (g *Generator) Write() error {
        return generate.Write(generate.Filepath(g.Pkg, g.Config.Output), g.Buf.Bytes(), nil)
}

// Copyright (c) 2023, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package types provides type information for Go types, methods,
// and functions.
package types

import (
        "cmp"
        "reflect"
        "slices"
        "strings"
        "sync/atomic"

        "cogentcore.org/core/base/reflectx"
)

var (
        // Types is a type registry, initialized to contain all builtin types. New types
        // can be added with [AddType]. The key is the long type name: package/path.Type,
        // e.g., cogentcore.org/core/core.Button.
        Types = map[string]*Type{}

        // typeIDCounter is an atomically incremented uint64 used
        // for assigning new [Type.ID] numbers.
        typeIDCounter uint64
)

func init() {
        addBuiltin[bool]("bool")
        addBuiltin[complex64]("complex64")
        addBuiltin[complex128]("complex128")
        addBuiltin[float32]("float32")
        addBuiltin[float64]("float64")
        addBuiltin[int]("int")
        addBuiltin[int64]("int8")
        addBuiltin[int16]("int16")
        addBuiltin[int32]("int32")
        addBuiltin[int64]("int64")
        addBuiltin[string]("string")
        addBuiltin[uint]("uint")
        addBuiltin[uint8]("uint8")
        addBuiltin[uint16]("uint16")
        addBuiltin[uint32]("uint32")
        addBuiltin[uint64]("uint64")
        addBuiltin[uint64]("uintptr")
}

// addBuiltin adds the given builtin type with the given name to the type registry.
func addBuiltin[T any](name string) {
        var v T
        AddType(&Type{Name: name, IDName: name, Instance: v})
}

// TypeByName returns a Type by name (package/path.Type, e.g., cogentcore.org/core/core.Button),
func TypeByName(name string) *Type {
        return Types[name]
}

// TypeByValue returns the [Type] of the given value
func TypeByValue(v any) *Type {
        return TypeByName(TypeNameValue(v))
}

// TypeByReflectType returns the [Type] of the given reflect type
func TypeByReflectType(typ reflect.Type) *Type {
        return TypeByName(TypeName(typ))
}

// For returns the [Type] of the generic type parameter,
// setting its [Type.Instance] to a new(T) if it is nil.
func For[T any]() *Type {
        var v T
        t := TypeByValue(v)
        if t != nil && t.Instance == nil {
                t.Instance = new(T)
        }
        return t
}

// AddType adds a constructed [Type] to the registry
// and returns it. This sets the ID.
func AddType(typ *Type) *Type {
        typ.ID = atomic.AddUint64(&typeIDCounter, 1)
        Types[typ.Name] = typ
        return typ
}

// TypeName returns the long, full package-path qualified type name.
// This is guaranteed to be unique and used for the Types registry.
func TypeName(typ reflect.Type) string {
        return reflectx.LongTypeName(typ)
}

// TypeNameValue returns the long, full package-path qualified type name
// of the given Go value. Automatically finds the non-pointer base type.
// This is guaranteed to be unique and used for the Types registry.
func TypeNameValue(v any) string {
        typ := reflectx.Underlying(reflect.ValueOf(v)).Type()
        return TypeName(typ)
}

// BuiltinTypes returns all of the builtin types in the type registry.
func BuiltinTypes() []*Type {
        res := []*Type{}
        for _, t := range Types {
                if !strings.Contains(t.Name, ".") {
                        res = append(res, t)
                }
        }
        slices.SortFunc(res, func(a, b *Type) int {
                return cmp.Compare(a.Name, b.Name)
        })
        return res
}

// GetDoc gets the documentation for the given value with the given parent struct, field, and label.
// The value, parent value, and field may be nil/invalid. GetDoc uses the given label to format
// the documentation with [FormatDoc] before returning it.
func GetDoc(value, parent reflect.Value, field reflect.StructField, label string) (string, bool) {
        // if we are not part of a struct, we just get the documentation for our type
        if !parent.IsValid() {
                if !value.IsValid() {
                        return "", false
                }
                rtyp := reflectx.NonPointerType(value.Type())
                typ := TypeByName(TypeName(rtyp))
                if typ == nil {
                        return "", false
                }
                return FormatDoc(typ.Doc, rtyp.Name(), label), true
        }

        // otherwise, we get our field documentation in our parent
        f := GetField(parent, field.Name)
        if f != nil {
                return FormatDoc(f.Doc, field.Name, label), true
        }
        // if we aren't in the type registry, we fall back on struct tag
        doc, ok := field.Tag.Lookup("doc")
        if !ok {
                return "", false
        }
        return FormatDoc(doc, field.Name, label), true
}

// FormatDoc formats the given Go documentation string for an identifier with the given
// CamelCase name and intended label. It replaces the name with the label and cleans
// up trailing punctuation.
func FormatDoc(doc, name, label string) string {
        doc = strings.ReplaceAll(doc, name, label)

        // if we only have one period, get rid of it if it is at the end
        if strings.Count(doc, ".") == 1 {
                doc = strings.TrimSuffix(doc, ".")
        }
        return doc
}

// Copyright (c) 2021, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package undo package provides a generic undo / redo functionality based on `[]string`
representations of any kind of state representation (typically JSON dump of the 'document'
state). It stores the compact diffs from one state change to the next, with raw copies saved
at infrequent intervals to tradeoff cost of computing diffs.

In addition state (which is optional on any given step), a description of the action
and arbitrary string-encoded data can be saved with each record.  Thus, for cases
where the state doesn't change, you can just save some data about the action sufficient
to undo / redo it.

A new record must be saved of the state just *before* an action takes place
and the nature of the action taken.

Thus, undoing the action restores the state to that prior state.

Redoing the action means restoring the state *after* the action.

This means that the first Undo action must save the current state
before doing the undo.

The Index is always on the last state saved, which will then be the one
that would be undone for an undo action.
*/
package undo

import (
        "log"
        "strings"
        "sync"

        "cogentcore.org/core/text/lines"
)

// DefaultRawInterval is interval for saving raw state -- need to do this
// at some interval to prevent having it take too long to compute patches
// from all the diffs.
var DefaultRawInterval = 50

// Record is one undo record, associated with one action that changed state from one to next.
// The state saved in this record is the state *before* the action took place.
// The state is either saved as a Raw value or as a diff Patch to the previous state.
type Record struct {

        // description of this action, for user to see
        Action string

        // action data, encoded however you want -- some undo records can just be about this action data that can be interpreted to Undo / Redo a non-state-changing action
        Data string

        // if present, then direct save of full state -- do this at intervals to speed up computing prior states
        Raw []string

        // patch to get from previous record to this one
        Patch lines.Patch

        // this record is an UndoSave, when Undo first called from end of stack
        UndoSave bool
}

// Init sets the action and data in a record -- overwriting any prior values
func (rc *Record) Init(action, data string) {
        rc.Action = action
        rc.Data = data
        rc.Patch = nil
        rc.Raw = nil
        rc.UndoSave = false
}

// Stack is the undo stack manager that manages the undo and redo process.
type Stack struct {

        // current index in the undo records -- this is the record that will be undone if user hits undo
        Index int

        // the list of saved state / action records
        Records []*Record

        // interval for saving raw data -- need to do this at some interval to prevent having it take too long to compute patches from all the diffs.
        RawInterval int

        // mutex that protects updates -- we do diff computation as a separate goroutine so it is instant from perspective of UI
        Mu sync.Mutex
}

// RecState returns the state for given index, reconstructing from diffs
// as needed.  Must be called under lock.
func (us *Stack) RecState(idx int) []string {
        stidx := 0
        var cdt []string
        for i := idx; i >= 0; i-- {
                r := us.Records[i]
                if r.Raw != nil {
                        stidx = i
                        cdt = r.Raw
                        break
                }
        }
        for i := stidx + 1; i <= idx; i++ {
                r := us.Records[i]
                if r.Patch != nil {
                        cdt = r.Patch.Apply(cdt)
                }
        }
        return cdt
}

// Save saves a new action as next action to be undone, with given action
// data and current full state of the system (either of which are optional).
// The state must be available for saving -- we do not copy in case we save the
// full raw copy.
func (us *Stack) Save(action, data string, state []string) {
        us.Mu.Lock() // we start lock
        if us.Records == nil {
                if us.RawInterval == 0 {
                        us.RawInterval = DefaultRawInterval
                }
                us.Records = make([]*Record, 1)
                us.Index = 0
                nr := &Record{Action: action, Data: data, Raw: state}
                us.Records[0] = nr
                us.Mu.Unlock()
                return
        }
        // recs will be [old..., Index] after this
        us.Index++
        var nr *Record
        if len(us.Records) > us.Index {
                us.Records = us.Records[:us.Index+1]
                nr = us.Records[us.Index]
        } else if len(us.Records) == us.Index {
                nr = &Record{}
                us.Records = append(us.Records, nr)
        } else {
                log.Printf("undo.Stack error: index: %d > len(um.Recs): %d\n", us.Index, len(us.Records))
                us.Index = len(us.Records)
                nr = &Record{}
                us.Records = append(us.Records, nr)
        }
        nr.Init(action, data)
        if state == nil {
                us.Mu.Unlock()
                return
        }
        go us.SaveState(nr, us.Index, state) // fork off save -- it will unlock when done
        // now we return straight away, with lock still held
}

// MustSaveUndoStart returns true if the current state must be saved as the start of
// the first Undo action when at the end of the stack.  If this returns true, then
// call SaveUndoStart.  It sets a special flag on the record.
func (us *Stack) MustSaveUndoStart() bool {
        return us.Index == len(us.Records)-1
}

// SaveUndoStart saves the current state -- call if MustSaveUndoStart is true.
// Sets a special flag for this record, and action, data are empty.
// Does NOT increment the index, so next undo is still as expected.
func (us *Stack) SaveUndoStart(state []string) {
        us.Mu.Lock()
        nr := &Record{UndoSave: true}
        us.Records = append(us.Records, nr)
        us.SaveState(nr, us.Index+1, state) // do it now because we need to immediately do Undo, does unlock
}

// SaveReplace replaces the current Undo record with new state,
// instead of creating a new record.  This is useful for when
// you have a stream of the same type of manipulations
// and just want to save the last (it is better to handle that case
// up front as saving the state can be relatively expensive, but
// in some cases it is not possible).
func (us *Stack) SaveReplace(action, data string, state []string) {
        us.Mu.Lock()
        nr := us.Records[us.Index]
        go us.SaveState(nr, us.Index, state)
}

// SaveState saves given record of state at given index
func (us *Stack) SaveState(nr *Record, idx int, state []string) {
        if idx%us.RawInterval == 0 {
                nr.Raw = state
                us.Mu.Unlock()
                return
        }
        prv := us.RecState(idx - 1)
        dif := lines.DiffLines(prv, state)
        nr.Patch = dif.ToPatch(state)
        us.Mu.Unlock()
}

// HasUndoAvail returns true if there is at least one undo record available.
// This does NOT get the lock -- may rarely be inaccurate but is used for
// gui enabling so not such a big deal.
func (us *Stack) HasUndoAvail() bool {
        return us.Index >= 0
}

// HasRedoAvail returns true if there is at least one redo record available.
// This does NOT get the lock -- may rarely be inaccurate but is used for
// GUI enabling so not such a big deal.
func (us *Stack) HasRedoAvail() bool {
        return us.Index < len(us.Records)-2
}

// Undo returns the action, action data, and state at the current index
// and decrements the index to the previous record.
// This state is the state just prior to the action.
// If already at the start (Index = -1) then returns empty everything
// Before calling, first check MustSaveUndoStart() -- if false, then you need
// to call SaveUndoStart() so that the state just before Undoing can be redone!
func (us *Stack) Undo() (action, data string, state []string) {
        us.Mu.Lock()
        if us.Index < 0 || us.Index >= len(us.Records) {
                us.Mu.Unlock()
                return
        }
        rec := us.Records[us.Index]
        action = rec.Action
        data = rec.Data
        state = us.RecState(us.Index)
        us.Index--
        us.Mu.Unlock()
        return
}

// UndoTo returns the action, action data, and state at the given index
// and decrements the index to the previous record.
// If idx is out of range then returns empty everything
func (us *Stack) UndoTo(idx int) (action, data string, state []string) {
        us.Mu.Lock()
        if idx < 0 || idx >= len(us.Records) {
                us.Mu.Unlock()
                return
        }
        rec := us.Records[idx]
        action = rec.Action
        data = rec.Data
        state = us.RecState(idx)
        us.Index = idx - 1
        us.Mu.Unlock()
        return
}

// Redo returns the action, data at the *next* index, and the state at the
// index *after that*.
// returning nil if already at end of saved records.
func (us *Stack) Redo() (action, data string, state []string) {
        us.Mu.Lock()
        if us.Index >= len(us.Records)-2 {
                us.Mu.Unlock()
                return
        }
        us.Index++
        rec := us.Records[us.Index] // action being redone is this one
        action = rec.Action
        data = rec.Data
        state = us.RecState(us.Index + 1) // state is the one *after* it
        us.Mu.Unlock()
        return
}

// RedoTo returns the action, action data, and state at the given index,
// returning nil if already at end of saved records.
func (us *Stack) RedoTo(idx int) (action, data string, state []string) {
        us.Mu.Lock()
        if idx >= len(us.Records)-1 || idx <= 0 {
                us.Mu.Unlock()
                return
        }
        us.Index = idx
        rec := us.Records[idx]
        action = rec.Action
        data = rec.Data
        state = us.RecState(idx + 1)
        us.Mu.Unlock()
        return
}

// Reset resets the undo state
func (us *Stack) Reset() {
        us.Mu.Lock()
        us.Records = nil
        us.Index = 0
        us.Mu.Unlock()
}

// UndoList returns the list actions in order from the most recent back in time
// suitable for a menu of actions to undo.
func (us *Stack) UndoList() []string {
        al := make([]string, us.Index)
        for i := us.Index; i >= 0; i-- {
                al[us.Index-i] = us.Records[i].Action
        }
        return al
}

// RedoList returns the list actions in order from the current forward to end
// suitable for a menu of actions to redo
func (us *Stack) RedoList() []string {
        nl := len(us.Records)
        if us.Index >= nl-2 {
                return nil
        }
        st := us.Index + 1
        n := (nl - 1) - st
        al := make([]string, n)
        for i := st; i < nl-1; i++ {
                al[i-st] = us.Records[i].Action
        }
        return al
}

// MemUsed reports the amount of memory used for record
func (rc *Record) MemUsed() int {
        mem := 0
        if rc.Raw != nil {
                for _, s := range rc.Raw {
                        mem += len(s)
                }
        } else {
                for _, pr := range rc.Patch {
                        for _, s := range pr.Blines {
                                mem += len(s)
                        }
                }
        }
        return mem
}

// MemStats reports the memory usage statistics.
// if details is true, each record is reported.
func (us *Stack) MemStats(details bool) string {
        sb := strings.Builder{}
        // TODO(kai): add this back once we figure out how to do core.FileSize
        /*
                sum := 0
                for i, r := range um.Recs {
                        mem := r.MemUsed()
                        sum += mem
                        if details {
                                sb.WriteString(fmt.Sprintf("%d\t%s\tmem:%s\n", i, r.Action, core.FileSize(mem).String()))
                        }
                }
                sb.WriteString(fmt.Sprintf("Total: %s\n", core.FileSize(sum).String()))
        */
        return sb.String()
}

// Code generated by 'yaegi extract cogentcore.org/core/base/errors'. DO NOT EDIT.

package basesymbols

import (
        "cogentcore.org/core/base/errors"
        "github.com/cogentcore/yaegi/interp"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/base/errors/errors"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "As":             reflect.ValueOf(errors.As),
                "CallerInfo":     reflect.ValueOf(errors.CallerInfo),
                "ErrUnsupported": reflect.ValueOf(&errors.ErrUnsupported).Elem(),
                "Is":             reflect.ValueOf(errors.Is),
                "Join":           reflect.ValueOf(errors.Join),
                "Log":            reflect.ValueOf(errors.Log),
                "Log1":           reflect.ValueOf(interp.GenericFunc("func Log1[T any](v T, err error) T { //yaegi:add\n\tif err != nil {\n\t\tslog.Error(err.Error() + \" | \" + CallerInfo())\n\t}\n\treturn v\n}")),
                "Must":           reflect.ValueOf(errors.Must),
                "New":            reflect.ValueOf(errors.New),
                "Unwrap":         reflect.ValueOf(errors.Unwrap),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/base/fileinfo'. DO NOT EDIT.

package basesymbols

import (
        "cogentcore.org/core/base/fileinfo"
        "go/constant"
        "go/token"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/base/fileinfo/fileinfo"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Aac":                 reflect.ValueOf(fileinfo.Aac),
                "Ada":                 reflect.ValueOf(fileinfo.Ada),
                "Any":                 reflect.ValueOf(fileinfo.Any),
                "AnyArchive":          reflect.ValueOf(fileinfo.AnyArchive),
                "AnyAudio":            reflect.ValueOf(fileinfo.AnyAudio),
                "AnyBackup":           reflect.ValueOf(fileinfo.AnyBackup),
                "AnyBin":              reflect.ValueOf(fileinfo.AnyBin),
                "AnyCode":             reflect.ValueOf(fileinfo.AnyCode),
                "AnyData":             reflect.ValueOf(fileinfo.AnyData),
                "AnyDoc":              reflect.ValueOf(fileinfo.AnyDoc),
                "AnyExe":              reflect.ValueOf(fileinfo.AnyExe),
                "AnyFolder":           reflect.ValueOf(fileinfo.AnyFolder),
                "AnyFont":             reflect.ValueOf(fileinfo.AnyFont),
                "AnyImage":            reflect.ValueOf(fileinfo.AnyImage),
                "AnyKnown":            reflect.ValueOf(fileinfo.AnyKnown),
                "AnyModel":            reflect.ValueOf(fileinfo.AnyModel),
                "AnySheet":            reflect.ValueOf(fileinfo.AnySheet),
                "AnyText":             reflect.ValueOf(fileinfo.AnyText),
                "AnyVideo":            reflect.ValueOf(fileinfo.AnyVideo),
                "Archive":             reflect.ValueOf(fileinfo.Archive),
                "Audio":               reflect.ValueOf(fileinfo.Audio),
                "AvailableMimes":      reflect.ValueOf(&fileinfo.AvailableMimes).Elem(),
                "Avi":                 reflect.ValueOf(fileinfo.Avi),
                "BZip":                reflect.ValueOf(fileinfo.BZip),
                "Backup":              reflect.ValueOf(fileinfo.Backup),
                "Bash":                reflect.ValueOf(fileinfo.Bash),
                "BibTeX":              reflect.ValueOf(fileinfo.BibTeX),
                "Bin":                 reflect.ValueOf(fileinfo.Bin),
                "Bmp":                 reflect.ValueOf(fileinfo.Bmp),
                "C":                   reflect.ValueOf(fileinfo.C),
                "CSharp":              reflect.ValueOf(fileinfo.CSharp),
                "CategoriesN":         reflect.ValueOf(fileinfo.CategoriesN),
                "CategoriesValues":    reflect.ValueOf(fileinfo.CategoriesValues),
                "CategoryFromMime":    reflect.ValueOf(fileinfo.CategoryFromMime),
                "Code":                reflect.ValueOf(fileinfo.Code),
                "Color":               reflect.ValueOf(fileinfo.Color),
                "Cosh":                reflect.ValueOf(fileinfo.Cosh),
                "Csh":                 reflect.ValueOf(fileinfo.Csh),
                "Css":                 reflect.ValueOf(fileinfo.Css),
                "Csv":                 reflect.ValueOf(fileinfo.Csv),
                "CustomMimes":         reflect.ValueOf(&fileinfo.CustomMimes).Elem(),
                "D":                   reflect.ValueOf(fileinfo.D),
                "Data":                reflect.ValueOf(fileinfo.Data),
                "DataCsv":             reflect.ValueOf(constant.MakeFromLiteral("\"text/csv\"", token.STRING, 0)),
                "DataJson":            reflect.ValueOf(constant.MakeFromLiteral("\"application/json\"", token.STRING, 0)),
                "DataXml":             reflect.ValueOf(constant.MakeFromLiteral("\"application/xml\"", token.STRING, 0)),
                "Diff":                reflect.ValueOf(fileinfo.Diff),
                "Dmg":                 reflect.ValueOf(fileinfo.Dmg),
                "Doc":                 reflect.ValueOf(fileinfo.Doc),
                "EBook":               reflect.ValueOf(fileinfo.EBook),
                "EPub":                reflect.ValueOf(fileinfo.EPub),
                "Eiffel":              reflect.ValueOf(fileinfo.Eiffel),
                "Erlang":              reflect.ValueOf(fileinfo.Erlang),
                "Exe":                 reflect.ValueOf(fileinfo.Exe),
                "ExtKnown":            reflect.ValueOf(fileinfo.ExtKnown),
                "ExtMimeMap":          reflect.ValueOf(&fileinfo.ExtMimeMap).Elem(),
                "FSharp":              reflect.ValueOf(fileinfo.FSharp),
                "Filenames":           reflect.ValueOf(fileinfo.Filenames),
                "Flac":                reflect.ValueOf(fileinfo.Flac),
                "Folder":              reflect.ValueOf(fileinfo.Folder),
                "Font":                reflect.ValueOf(fileinfo.Font),
                "Forth":               reflect.ValueOf(fileinfo.Forth),
                "Fortran":             reflect.ValueOf(fileinfo.Fortran),
                "GZip":                reflect.ValueOf(fileinfo.GZip),
                "Gif":                 reflect.ValueOf(fileinfo.Gif),
                "Gimp":                reflect.ValueOf(fileinfo.Gimp),
                "Go":                  reflect.ValueOf(fileinfo.Go),
                "Goal":                reflect.ValueOf(fileinfo.Goal),
                "GraphVis":            reflect.ValueOf(fileinfo.GraphVis),
                "Haskell":             reflect.ValueOf(fileinfo.Haskell),
                "Heic":                reflect.ValueOf(fileinfo.Heic),
                "Heif":                reflect.ValueOf(fileinfo.Heif),
                "Html":                reflect.ValueOf(fileinfo.Html),
                "ICal":                reflect.ValueOf(fileinfo.ICal),
                "Icons":               reflect.ValueOf(&fileinfo.Icons).Elem(),
                "Image":               reflect.ValueOf(fileinfo.Image),
                "Ini":                 reflect.ValueOf(fileinfo.Ini),
                "IsGeneratedFile":     reflect.ValueOf(fileinfo.IsGeneratedFile),
                "IsMatch":             reflect.ValueOf(fileinfo.IsMatch),
                "IsMatchList":         reflect.ValueOf(fileinfo.IsMatchList),
                "Java":                reflect.ValueOf(fileinfo.Java),
                "JavaScript":          reflect.ValueOf(fileinfo.JavaScript),
                "Jpeg":                reflect.ValueOf(fileinfo.Jpeg),
                "Json":                reflect.ValueOf(fileinfo.Json),
                "KnownByName":         reflect.ValueOf(fileinfo.KnownByName),
                "KnownFromFile":       reflect.ValueOf(fileinfo.KnownFromFile),
                "KnownMimes":          reflect.ValueOf(&fileinfo.KnownMimes).Elem(),
                "KnownN":              reflect.ValueOf(fileinfo.KnownN),
                "KnownValues":         reflect.ValueOf(fileinfo.KnownValues),
                "Lisp":                reflect.ValueOf(fileinfo.Lisp),
                "Lua":                 reflect.ValueOf(fileinfo.Lua),
                "MSExcel":             reflect.ValueOf(fileinfo.MSExcel),
                "MSPowerpoint":        reflect.ValueOf(fileinfo.MSPowerpoint),
                "MSWord":              reflect.ValueOf(fileinfo.MSWord),
                "Makefile":            reflect.ValueOf(fileinfo.Makefile),
                "Markdown":            reflect.ValueOf(fileinfo.Markdown),
                "Mathematica":         reflect.ValueOf(fileinfo.Mathematica),
                "Matlab":              reflect.ValueOf(fileinfo.Matlab),
                "MergeAvailableMimes": reflect.ValueOf(fileinfo.MergeAvailableMimes),
                "Midi":                reflect.ValueOf(fileinfo.Midi),
                "MimeFromFile":        reflect.ValueOf(fileinfo.MimeFromFile),
                "MimeFromKnown":       reflect.ValueOf(fileinfo.MimeFromKnown),
                "MimeKnown":           reflect.ValueOf(fileinfo.MimeKnown),
                "MimeNoChar":          reflect.ValueOf(fileinfo.MimeNoChar),
                "MimeString":          reflect.ValueOf(fileinfo.MimeString),
                "MimeSub":             reflect.ValueOf(fileinfo.MimeSub),
                "MimeTop":             reflect.ValueOf(fileinfo.MimeTop),
                "Model":               reflect.ValueOf(fileinfo.Model),
                "Mov":                 reflect.ValueOf(fileinfo.Mov),
                "Mp3":                 reflect.ValueOf(fileinfo.Mp3),
                "Mp4":                 reflect.ValueOf(fileinfo.Mp4),
                "Mpeg":                reflect.ValueOf(fileinfo.Mpeg),
                "Multipart":           reflect.ValueOf(fileinfo.Multipart),
                "NewFileInfo":         reflect.ValueOf(fileinfo.NewFileInfo),
                "NewFileInfoType":     reflect.ValueOf(fileinfo.NewFileInfoType),
                "Number":              reflect.ValueOf(fileinfo.Number),
                "OCaml":               reflect.ValueOf(fileinfo.OCaml),
                "Obj":                 reflect.ValueOf(fileinfo.Obj),
                "ObjC":                reflect.ValueOf(fileinfo.ObjC),
                "Ogg":                 reflect.ValueOf(fileinfo.Ogg),
                "Ogv":                 reflect.ValueOf(fileinfo.Ogv),
                "OpenPres":            reflect.ValueOf(fileinfo.OpenPres),
                "OpenSheet":           reflect.ValueOf(fileinfo.OpenSheet),
                "OpenText":            reflect.ValueOf(fileinfo.OpenText),
                "Pascal":              reflect.ValueOf(fileinfo.Pascal),
                "Pbm":                 reflect.ValueOf(fileinfo.Pbm),
                "Pdf":                 reflect.ValueOf(fileinfo.Pdf),
                "Perl":                reflect.ValueOf(fileinfo.Perl),
                "Pgm":                 reflect.ValueOf(fileinfo.Pgm),
                "Php":                 reflect.ValueOf(fileinfo.Php),
                "PlainText":           reflect.ValueOf(fileinfo.PlainText),
                "Png":                 reflect.ValueOf(fileinfo.Png),
                "Pnm":                 reflect.ValueOf(fileinfo.Pnm),
                "Postscript":          reflect.ValueOf(fileinfo.Postscript),
                "Ppm":                 reflect.ValueOf(fileinfo.Ppm),
                "Prolog":              reflect.ValueOf(fileinfo.Prolog),
                "Protobuf":            reflect.ValueOf(fileinfo.Protobuf),
                "Python":              reflect.ValueOf(fileinfo.Python),
                "R":                   reflect.ValueOf(fileinfo.R),
                "Rtf":                 reflect.ValueOf(fileinfo.Rtf),
                "Ruby":                reflect.ValueOf(fileinfo.Ruby),
                "Rust":                reflect.ValueOf(fileinfo.Rust),
                "SQL":                 reflect.ValueOf(fileinfo.SQL),
                "Scala":               reflect.ValueOf(fileinfo.Scala),
                "SevenZ":              reflect.ValueOf(fileinfo.SevenZ),
                "Shar":                reflect.ValueOf(fileinfo.Shar),
                "Sheet":               reflect.ValueOf(fileinfo.Sheet),
                "StandardMimes":       reflect.ValueOf(&fileinfo.StandardMimes).Elem(),
                "String":              reflect.ValueOf(fileinfo.String),
                "Svg":                 reflect.ValueOf(fileinfo.Svg),
                "Table":               reflect.ValueOf(fileinfo.Table),
                "Tar":                 reflect.ValueOf(fileinfo.Tar),
                "Tcl":                 reflect.ValueOf(fileinfo.Tcl),
                "TeX":                 reflect.ValueOf(fileinfo.TeX),
                "Tensor":              reflect.ValueOf(fileinfo.Tensor),
                "Texinfo":             reflect.ValueOf(fileinfo.Texinfo),
                "Text":                reflect.ValueOf(fileinfo.Text),
                "TextPlain":           reflect.ValueOf(constant.MakeFromLiteral("\"text/plain\"", token.STRING, 0)),
                "Tiff":                reflect.ValueOf(fileinfo.Tiff),
                "Toml":                reflect.ValueOf(fileinfo.Toml),
                "Trash":               reflect.ValueOf(fileinfo.Trash),
                "Troff":               reflect.ValueOf(fileinfo.Troff),
                "TrueType":            reflect.ValueOf(fileinfo.TrueType),
                "Tsv":                 reflect.ValueOf(fileinfo.Tsv),
                "Unknown":             reflect.ValueOf(fileinfo.Unknown),
                "UnknownCategory":     reflect.ValueOf(fileinfo.UnknownCategory),
                "Uri":                 reflect.ValueOf(fileinfo.Uri),
                "VCal":                reflect.ValueOf(fileinfo.VCal),
                "VCard":               reflect.ValueOf(fileinfo.VCard),
                "Video":               reflect.ValueOf(fileinfo.Video),
                "Vrml":                reflect.ValueOf(fileinfo.Vrml),
                "Wav":                 reflect.ValueOf(fileinfo.Wav),
                "WebOpenFont":         reflect.ValueOf(fileinfo.WebOpenFont),
                "Wmv":                 reflect.ValueOf(fileinfo.Wmv),
                "X3d":                 reflect.ValueOf(fileinfo.X3d),
                "Xbm":                 reflect.ValueOf(fileinfo.Xbm),
                "Xml":                 reflect.ValueOf(fileinfo.Xml),
                "Xpm":                 reflect.ValueOf(fileinfo.Xpm),
                "Xz":                  reflect.ValueOf(fileinfo.Xz),
                "Yaml":                reflect.ValueOf(fileinfo.Yaml),
                "Zip":                 reflect.ValueOf(fileinfo.Zip),

                // type definitions
                "Categories": reflect.ValueOf((*fileinfo.Categories)(nil)),
                "FileInfo":   reflect.ValueOf((*fileinfo.FileInfo)(nil)),
                "Known":      reflect.ValueOf((*fileinfo.Known)(nil)),
                "MimeType":   reflect.ValueOf((*fileinfo.MimeType)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/base/fsx'. DO NOT EDIT.

package basesymbols

import (
        "cogentcore.org/core/base/fsx"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/base/fsx/fsx"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "CopyFile":         reflect.ValueOf(fsx.CopyFile),
                "DirAndFile":       reflect.ValueOf(fsx.DirAndFile),
                "DirFS":            reflect.ValueOf(fsx.DirFS),
                "Dirs":             reflect.ValueOf(fsx.Dirs),
                "ExtSplit":         reflect.ValueOf(fsx.ExtSplit),
                "FileExists":       reflect.ValueOf(fsx.FileExists),
                "FileExistsFS":     reflect.ValueOf(fsx.FileExistsFS),
                "Filenames":        reflect.ValueOf(fsx.Filenames),
                "Files":            reflect.ValueOf(fsx.Files),
                "FindFilesOnPaths": reflect.ValueOf(fsx.FindFilesOnPaths),
                "GoSrcDir":         reflect.ValueOf(fsx.GoSrcDir),
                "HasFile":          reflect.ValueOf(fsx.HasFile),
                "LatestMod":        reflect.ValueOf(fsx.LatestMod),
                "RelativeFilePath": reflect.ValueOf(fsx.RelativeFilePath),
                "SplitRootPathFS":  reflect.ValueOf(fsx.SplitRootPathFS),
                "Sub":              reflect.ValueOf(fsx.Sub),

                // type definitions
                "Filename": reflect.ValueOf((*fsx.Filename)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/base/labels'. DO NOT EDIT.

package basesymbols

import (
        "cogentcore.org/core/base/labels"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/base/labels/labels"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "FriendlyMapLabel":    reflect.ValueOf(labels.FriendlyMapLabel),
                "FriendlySliceLabel":  reflect.ValueOf(labels.FriendlySliceLabel),
                "FriendlyStructLabel": reflect.ValueOf(labels.FriendlyStructLabel),
                "FriendlyTypeName":    reflect.ValueOf(labels.FriendlyTypeName),
                "ToLabel":             reflect.ValueOf(labels.ToLabel),
                "ToLabeler":           reflect.ValueOf(labels.ToLabeler),

                // type definitions
                "Labeler":      reflect.ValueOf((*labels.Labeler)(nil)),
                "SliceLabeler": reflect.ValueOf((*labels.SliceLabeler)(nil)),

                // interface wrapper definitions
                "_Labeler":      reflect.ValueOf((*_cogentcore_org_core_base_labels_Labeler)(nil)),
                "_SliceLabeler": reflect.ValueOf((*_cogentcore_org_core_base_labels_SliceLabeler)(nil)),
        }
}

// _cogentcore_org_core_base_labels_Labeler is an interface wrapper for Labeler type
type _cogentcore_org_core_base_labels_Labeler struct {
        IValue interface{}
        WLabel func() string
}

func (W _cogentcore_org_core_base_labels_Labeler) Label() string { return W.WLabel() }

// _cogentcore_org_core_base_labels_SliceLabeler is an interface wrapper for SliceLabeler type
type _cogentcore_org_core_base_labels_SliceLabeler struct {
        IValue     interface{}
        WElemLabel func(idx int) string
}

func (W _cogentcore_org_core_base_labels_SliceLabeler) ElemLabel(idx int) string {
        return W.WElemLabel(idx)
}

// Code generated by 'yaegi extract cogentcore.org/core/base/num'. DO NOT EDIT.

package basesymbols

import (
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/base/num/num"] = map[string]reflect.Value{}
}

// Code generated by 'yaegi extract cogentcore.org/core/base/reflectx'. DO NOT EDIT.

package basesymbols

import (
        "cogentcore.org/core/base/reflectx"
        "image/color"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/base/reflectx/reflectx"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "CloneToType":        reflect.ValueOf(reflectx.CloneToType),
                "CopyFields":         reflect.ValueOf(reflectx.CopyFields),
                "CopyMapRobust":      reflect.ValueOf(reflectx.CopyMapRobust),
                "CopySliceRobust":    reflect.ValueOf(reflectx.CopySliceRobust),
                "FieldByPath":        reflect.ValueOf(reflectx.FieldByPath),
                "FormatDefault":      reflect.ValueOf(reflectx.FormatDefault),
                "IsNil":              reflect.ValueOf(reflectx.IsNil),
                "KindIsBasic":        reflect.ValueOf(reflectx.KindIsBasic),
                "KindIsFloat":        reflect.ValueOf(reflectx.KindIsFloat),
                "KindIsInt":          reflect.ValueOf(reflectx.KindIsInt),
                "KindIsNumber":       reflect.ValueOf(reflectx.KindIsNumber),
                "LongTypeName":       reflect.ValueOf(reflectx.LongTypeName),
                "MapAdd":             reflect.ValueOf(reflectx.MapAdd),
                "MapDelete":          reflect.ValueOf(reflectx.MapDelete),
                "MapDeleteAll":       reflect.ValueOf(reflectx.MapDeleteAll),
                "MapKeyType":         reflect.ValueOf(reflectx.MapKeyType),
                "MapSort":            reflect.ValueOf(reflectx.MapSort),
                "MapValueSort":       reflect.ValueOf(reflectx.MapValueSort),
                "MapValueType":       reflect.ValueOf(reflectx.MapValueType),
                "NonDefaultFields":   reflect.ValueOf(reflectx.NonDefaultFields),
                "NonNilNew":          reflect.ValueOf(reflectx.NonNilNew),
                "NonPointerType":     reflect.ValueOf(reflectx.NonPointerType),
                "NonPointerValue":    reflect.ValueOf(reflectx.NonPointerValue),
                "NumAllFields":       reflect.ValueOf(reflectx.NumAllFields),
                "OnePointerValue":    reflect.ValueOf(reflectx.OnePointerValue),
                "PointerValue":       reflect.ValueOf(reflectx.PointerValue),
                "SetFieldsFromMap":   reflect.ValueOf(reflectx.SetFieldsFromMap),
                "SetFromDefaultTag":  reflect.ValueOf(reflectx.SetFromDefaultTag),
                "SetFromDefaultTags": reflect.ValueOf(reflectx.SetFromDefaultTags),
                "SetMapRobust":       reflect.ValueOf(reflectx.SetMapRobust),
                "SetRobust":          reflect.ValueOf(reflectx.SetRobust),
                "ShortTypeName":      reflect.ValueOf(reflectx.ShortTypeName),
                "SliceDeleteAt":      reflect.ValueOf(reflectx.SliceDeleteAt),
                "SliceElementType":   reflect.ValueOf(reflectx.SliceElementType),
                "SliceElementValue":  reflect.ValueOf(reflectx.SliceElementValue),
                "SliceNewAt":         reflect.ValueOf(reflectx.SliceNewAt),
                "SliceSort":          reflect.ValueOf(reflectx.SliceSort),
                "StringJSON":         reflect.ValueOf(reflectx.StringJSON),
                "StructSliceSort":    reflect.ValueOf(reflectx.StructSliceSort),
                "StructTags":         reflect.ValueOf(reflectx.StructTags),
                "ToBool":             reflect.ValueOf(reflectx.ToBool),
                "ToFloat":            reflect.ValueOf(reflectx.ToFloat),
                "ToFloat32":          reflect.ValueOf(reflectx.ToFloat32),
                "ToInt":              reflect.ValueOf(reflectx.ToInt),
                "ToString":           reflect.ValueOf(reflectx.ToString),
                "ToStringPrec":       reflect.ValueOf(reflectx.ToStringPrec),
                "Underlying":         reflect.ValueOf(reflectx.Underlying),
                "UnderlyingPointer":  reflect.ValueOf(reflectx.UnderlyingPointer),
                "ValueIsDefault":     reflect.ValueOf(reflectx.ValueIsDefault),
                "ValueSliceSort":     reflect.ValueOf(reflectx.ValueSliceSort),
                "WalkFields":         reflect.ValueOf(reflectx.WalkFields),

                // type definitions
                "SetAnyer":    reflect.ValueOf((*reflectx.SetAnyer)(nil)),
                "SetColorer":  reflect.ValueOf((*reflectx.SetColorer)(nil)),
                "SetStringer": reflect.ValueOf((*reflectx.SetStringer)(nil)),
                "ShouldSaver": reflect.ValueOf((*reflectx.ShouldSaver)(nil)),

                // interface wrapper definitions
                "_SetAnyer":    reflect.ValueOf((*_cogentcore_org_core_base_reflectx_SetAnyer)(nil)),
                "_SetColorer":  reflect.ValueOf((*_cogentcore_org_core_base_reflectx_SetColorer)(nil)),
                "_SetStringer": reflect.ValueOf((*_cogentcore_org_core_base_reflectx_SetStringer)(nil)),
                "_ShouldSaver": reflect.ValueOf((*_cogentcore_org_core_base_reflectx_ShouldSaver)(nil)),
        }
}

// _cogentcore_org_core_base_reflectx_SetAnyer is an interface wrapper for SetAnyer type
type _cogentcore_org_core_base_reflectx_SetAnyer struct {
        IValue  interface{}
        WSetAny func(v any) error
}

func (W _cogentcore_org_core_base_reflectx_SetAnyer) SetAny(v any) error { return W.WSetAny(v) }

// _cogentcore_org_core_base_reflectx_SetColorer is an interface wrapper for SetColorer type
type _cogentcore_org_core_base_reflectx_SetColorer struct {
        IValue    interface{}
        WSetColor func(c color.Color)
}

func (W _cogentcore_org_core_base_reflectx_SetColorer) SetColor(c color.Color) { W.WSetColor(c) }

// _cogentcore_org_core_base_reflectx_SetStringer is an interface wrapper for SetStringer type
type _cogentcore_org_core_base_reflectx_SetStringer struct {
        IValue     interface{}
        WSetString func(s string) error
}

func (W _cogentcore_org_core_base_reflectx_SetStringer) SetString(s string) error {
        return W.WSetString(s)
}

// _cogentcore_org_core_base_reflectx_ShouldSaver is an interface wrapper for ShouldSaver type
type _cogentcore_org_core_base_reflectx_ShouldSaver struct {
        IValue      interface{}
        WShouldSave func() bool
}

func (W _cogentcore_org_core_base_reflectx_ShouldSaver) ShouldSave() bool { return W.WShouldSave() }

// Code generated by 'yaegi extract cogentcore.org/core/base/strcase'. DO NOT EDIT.

package basesymbols

import (
        "cogentcore.org/core/base/strcase"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/base/strcase/strcase"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "CamelCase":        reflect.ValueOf(strcase.CamelCase),
                "CasesN":           reflect.ValueOf(strcase.CasesN),
                "CasesValues":      reflect.ValueOf(strcase.CasesValues),
                "FormatList":       reflect.ValueOf(strcase.FormatList),
                "KEBABCase":        reflect.ValueOf(strcase.KEBABCase),
                "KebabCase":        reflect.ValueOf(strcase.KebabCase),
                "LowerCamelCase":   reflect.ValueOf(strcase.LowerCamelCase),
                "LowerCase":        reflect.ValueOf(strcase.LowerCase),
                "Noop":             reflect.ValueOf(strcase.Noop),
                "SNAKECase":        reflect.ValueOf(strcase.SNAKECase),
                "SentenceCase":     reflect.ValueOf(strcase.SentenceCase),
                "Skip":             reflect.ValueOf(strcase.Skip),
                "SkipSplit":        reflect.ValueOf(strcase.SkipSplit),
                "SnakeCase":        reflect.ValueOf(strcase.SnakeCase),
                "Split":            reflect.ValueOf(strcase.Split),
                "TitleCase":        reflect.ValueOf(strcase.TitleCase),
                "To":               reflect.ValueOf(strcase.To),
                "ToCamel":          reflect.ValueOf(strcase.ToCamel),
                "ToKEBAB":          reflect.ValueOf(strcase.ToKEBAB),
                "ToKebab":          reflect.ValueOf(strcase.ToKebab),
                "ToLowerCamel":     reflect.ValueOf(strcase.ToLowerCamel),
                "ToSNAKE":          reflect.ValueOf(strcase.ToSNAKE),
                "ToSentence":       reflect.ValueOf(strcase.ToSentence),
                "ToSnake":          reflect.ValueOf(strcase.ToSnake),
                "ToTitle":          reflect.ValueOf(strcase.ToTitle),
                "ToWordCase":       reflect.ValueOf(strcase.ToWordCase),
                "UpperCase":        reflect.ValueOf(strcase.UpperCase),
                "WordCamelCase":    reflect.ValueOf(strcase.WordCamelCase),
                "WordCasesN":       reflect.ValueOf(strcase.WordCasesN),
                "WordCasesValues":  reflect.ValueOf(strcase.WordCasesValues),
                "WordLowerCase":    reflect.ValueOf(strcase.WordLowerCase),
                "WordOriginal":     reflect.ValueOf(strcase.WordOriginal),
                "WordSentenceCase": reflect.ValueOf(strcase.WordSentenceCase),
                "WordTitleCase":    reflect.ValueOf(strcase.WordTitleCase),
                "WordUpperCase":    reflect.ValueOf(strcase.WordUpperCase),

                // type definitions
                "Cases":       reflect.ValueOf((*strcase.Cases)(nil)),
                "SplitAction": reflect.ValueOf((*strcase.SplitAction)(nil)),
                "WordCases":   reflect.ValueOf((*strcase.WordCases)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/math32'. DO NOT EDIT.

package basesymbols

import (
        "cogentcore.org/core/math32"
        "go/constant"
        "go/token"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/math32/math32"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Abs":                      reflect.ValueOf(math32.Abs),
                "Acos":                     reflect.ValueOf(math32.Acos),
                "Acosh":                    reflect.ValueOf(math32.Acosh),
                "Asin":                     reflect.ValueOf(math32.Asin),
                "Asinh":                    reflect.ValueOf(math32.Asinh),
                "Atan":                     reflect.ValueOf(math32.Atan),
                "Atan2":                    reflect.ValueOf(math32.Atan2),
                "Atanh":                    reflect.ValueOf(math32.Atanh),
                "B2":                       reflect.ValueOf(math32.B2),
                "B2Empty":                  reflect.ValueOf(math32.B2Empty),
                "B2FromFixed":              reflect.ValueOf(math32.B2FromFixed),
                "B2FromRect":               reflect.ValueOf(math32.B2FromRect),
                "B3":                       reflect.ValueOf(math32.B3),
                "B3Empty":                  reflect.ValueOf(math32.B3Empty),
                "BarycoordFromPoint":       reflect.ValueOf(math32.BarycoordFromPoint),
                "Cbrt":                     reflect.ValueOf(math32.Cbrt),
                "Ceil":                     reflect.ValueOf(math32.Ceil),
                "ContainsPoint":            reflect.ValueOf(math32.ContainsPoint),
                "CopyFloat32s":             reflect.ValueOf(math32.CopyFloat32s),
                "CopyFloat64s":             reflect.ValueOf(math32.CopyFloat64s),
                "Copysign":                 reflect.ValueOf(math32.Copysign),
                "Cos":                      reflect.ValueOf(math32.Cos),
                "Cosh":                     reflect.ValueOf(math32.Cosh),
                "DegToRad":                 reflect.ValueOf(math32.DegToRad),
                "DegToRadFactor":           reflect.ValueOf(constant.MakeFromLiteral("0.0174532925199432957692369076848861271344287188854172545609719143893343406766598654219872641535175884721781352014070117566218413351995865581278454486637752166873317868068496601374750554214188014157116413116455078125", token.FLOAT, 0)),
                "Dim":                      reflect.ValueOf(math32.Dim),
                "DimsN":                    reflect.ValueOf(math32.DimsN),
                "DimsValues":               reflect.ValueOf(math32.DimsValues),
                "E":                        reflect.ValueOf(constant.MakeFromLiteral("2.71828182845904523536028747135266249775724709369995957496696762566337824315673231520670375558666729784504486779277967997696994772644702281675346915668215131895555530285035761295375777990557253360748291015625", token.FLOAT, 0)),
                "Erf":                      reflect.ValueOf(math32.Erf),
                "Erfc":                     reflect.ValueOf(math32.Erfc),
                "Erfcinv":                  reflect.ValueOf(math32.Erfcinv),
                "Erfinv":                   reflect.ValueOf(math32.Erfinv),
                "Exp":                      reflect.ValueOf(math32.Exp),
                "Exp2":                     reflect.ValueOf(math32.Exp2),
                "Expm1":                    reflect.ValueOf(math32.Expm1),
                "FMA":                      reflect.ValueOf(math32.FMA),
                "FastExp":                  reflect.ValueOf(math32.FastExp),
                "FitGeomInWindow":          reflect.ValueOf(math32.FitGeomInWindow),
                "Floor":                    reflect.ValueOf(math32.Floor),
                "Frexp":                    reflect.ValueOf(math32.Frexp),
                "FromFixed":                reflect.ValueOf(math32.FromFixed),
                "FromPoint":                reflect.ValueOf(math32.FromPoint),
                "Gamma":                    reflect.ValueOf(math32.Gamma),
                "Hypot":                    reflect.ValueOf(math32.Hypot),
                "Identity2":                reflect.ValueOf(math32.Identity2),
                "Identity3":                reflect.ValueOf(math32.Identity3),
                "Identity4":                reflect.ValueOf(math32.Identity4),
                "Ilogb":                    reflect.ValueOf(math32.Ilogb),
                "Inf":                      reflect.ValueOf(math32.Inf),
                "Infinity":                 reflect.ValueOf(&math32.Infinity).Elem(),
                "IntMultiple":              reflect.ValueOf(math32.IntMultiple),
                "IntMultipleGE":            reflect.ValueOf(math32.IntMultipleGE),
                "IsInf":                    reflect.ValueOf(math32.IsInf),
                "IsNaN":                    reflect.ValueOf(math32.IsNaN),
                "J0":                       reflect.ValueOf(math32.J0),
                "J1":                       reflect.ValueOf(math32.J1),
                "Jn":                       reflect.ValueOf(math32.Jn),
                "Ldexp":                    reflect.ValueOf(math32.Ldexp),
                "Lerp":                     reflect.ValueOf(math32.Lerp),
                "Lgamma":                   reflect.ValueOf(math32.Lgamma),
                "Ln10":                     reflect.ValueOf(constant.MakeFromLiteral("2.30258509299404568401799145468436420760110148862877297603332784146804725494827975466552490443295866962642372461496758838959542646932914211937012833592062802600362869664962772731087170541286468505859375", token.FLOAT, 0)),
                "Ln2":                      reflect.ValueOf(constant.MakeFromLiteral("0.6931471805599453094172321214581765680755001343602552541206800092715999496201383079363438206637927920954189307729314303884387720696314608777673678644642390655170150035209453154294578780536539852619171142578125", token.FLOAT, 0)),
                "Log":                      reflect.ValueOf(math32.Log),
                "Log10":                    reflect.ValueOf(math32.Log10),
                "Log10E":                   reflect.ValueOf(constant.MakeFromLiteral("0.43429448190325182765112891891660508229439700580366656611445378416636798190620320263064286300825210972160277489744884502676719847561509639618196799746596688688378591625127711495224502868950366973876953125", token.FLOAT, 0)),
                "Log1p":                    reflect.ValueOf(math32.Log1p),
                "Log2":                     reflect.ValueOf(math32.Log2),
                "Log2E":                    reflect.ValueOf(constant.MakeFromLiteral("1.44269504088896340735992468100189213742664595415298593413544940772066427768997545329060870636212628972710992130324953463427359402479619301286929040235571747101382214539290471666532766903401352465152740478515625", token.FLOAT, 0)),
                "Logb":                     reflect.ValueOf(math32.Logb),
                "Matrix3FromMatrix2":       reflect.ValueOf(math32.Matrix3FromMatrix2),
                "Matrix3FromMatrix4":       reflect.ValueOf(math32.Matrix3FromMatrix4),
                "Matrix3Rotate2D":          reflect.ValueOf(math32.Matrix3Rotate2D),
                "Matrix3Scale2D":           reflect.ValueOf(math32.Matrix3Scale2D),
                "Matrix3Translate2D":       reflect.ValueOf(math32.Matrix3Translate2D),
                "Max":                      reflect.ValueOf(math32.Max),
                "MaxFloat32":               reflect.ValueOf(constant.MakeFromLiteral("340282346638528859811704183484516925440", token.FLOAT, 0)),
                "MaxPos":                   reflect.ValueOf(math32.MaxPos),
                "Min":                      reflect.ValueOf(math32.Min),
                "MinPos":                   reflect.ValueOf(math32.MinPos),
                "Mod":                      reflect.ValueOf(math32.Mod),
                "Modf":                     reflect.ValueOf(math32.Modf),
                "NaN":                      reflect.ValueOf(math32.NaN),
                "NewArrayF32":              reflect.ValueOf(math32.NewArrayF32),
                "NewArrayU32":              reflect.ValueOf(math32.NewArrayU32),
                "NewEulerAnglesFromMatrix": reflect.ValueOf(math32.NewEulerAnglesFromMatrix),
                "NewFrustum":               reflect.ValueOf(math32.NewFrustum),
                "NewFrustumFromMatrix":     reflect.ValueOf(math32.NewFrustumFromMatrix),
                "NewLine2":                 reflect.ValueOf(math32.NewLine2),
                "NewLine3":                 reflect.ValueOf(math32.NewLine3),
                "NewLookAt":                reflect.ValueOf(math32.NewLookAt),
                "NewPlane":                 reflect.ValueOf(math32.NewPlane),
                "NewQuat":                  reflect.ValueOf(math32.NewQuat),
                "NewQuatAxisAngle":         reflect.ValueOf(math32.NewQuatAxisAngle),
                "NewQuatEuler":             reflect.ValueOf(math32.NewQuatEuler),
                "NewRay":                   reflect.ValueOf(math32.NewRay),
                "NewSphere":                reflect.ValueOf(math32.NewSphere),
                "NewTriangle":              reflect.ValueOf(math32.NewTriangle),
                "NewVector3Color":          reflect.ValueOf(math32.NewVector3Color),
                "NewVector4Color":          reflect.ValueOf(math32.NewVector4Color),
                "Nextafter":                reflect.ValueOf(math32.Nextafter),
                "Normal":                   reflect.ValueOf(math32.Normal),
                "OtherDim":                 reflect.ValueOf(math32.OtherDim),
                "ParseAngle32":             reflect.ValueOf(math32.ParseAngle32),
                "ParseFloat32":             reflect.ValueOf(math32.ParseFloat32),
                "Phi":                      reflect.ValueOf(constant.MakeFromLiteral("1.6180339887498948482045868343656381177203091798057628621354486119746080982153796619881086049305501566952211682590824739205931370737029882996587050475921915678674035433959321750307935872115194797515869140625", token.FLOAT, 0)),
                "Pi":                       reflect.ValueOf(constant.MakeFromLiteral("3.141592653589793238462643383279502884197169399375105820974944594789982923695635954704435713335896673485663389728754819466702315787113662862838515639906529162340867271374644786874341662041842937469482421875", token.FLOAT, 0)),
                "PointDim":                 reflect.ValueOf(math32.PointDim),
                "PointsCheckN":             reflect.ValueOf(math32.PointsCheckN),
                "Pow":                      reflect.ValueOf(math32.Pow),
                "Pow10":                    reflect.ValueOf(math32.Pow10),
                "RadToDeg":                 reflect.ValueOf(math32.RadToDeg),
                "RadToDegFactor":           reflect.ValueOf(constant.MakeFromLiteral("57.295779513082320876798154814105170332405472466564321549160243902428585054360559672397261399470815487380868161395148776362013889310162423528726959840779630006155203887467652901221981665003113448619842529296875", token.FLOAT, 0)),
                "ReadPoints":               reflect.ValueOf(math32.ReadPoints),
                "RectFromPosSizeMax":       reflect.ValueOf(math32.RectFromPosSizeMax),
                "RectFromPosSizeMin":       reflect.ValueOf(math32.RectFromPosSizeMin),
                "RectInNotEmpty":           reflect.ValueOf(math32.RectInNotEmpty),
                "Remainder":                reflect.ValueOf(math32.Remainder),
                "Rotate2D":                 reflect.ValueOf(math32.Rotate2D),
                "Rotate2DAround":           reflect.ValueOf(math32.Rotate2DAround),
                "Round":                    reflect.ValueOf(math32.Round),
                "RoundToEven":              reflect.ValueOf(math32.RoundToEven),
                "SRGBFromLinear":           reflect.ValueOf(math32.SRGBFromLinear),
                "SRGBToLinear":             reflect.ValueOf(math32.SRGBToLinear),
                "Scale2D":                  reflect.ValueOf(math32.Scale2D),
                "SetPointDim":              reflect.ValueOf(math32.SetPointDim),
                "Shear2D":                  reflect.ValueOf(math32.Shear2D),
                "Sign":                     reflect.ValueOf(math32.Sign),
                "Signbit":                  reflect.ValueOf(math32.Signbit),
                "Sin":                      reflect.ValueOf(math32.Sin),
                "Sincos":                   reflect.ValueOf(math32.Sincos),
                "Sinh":                     reflect.ValueOf(math32.Sinh),
                "Skew2D":                   reflect.ValueOf(math32.Skew2D),
                "SmallestNonzeroFloat32":   reflect.ValueOf(constant.MakeFromLiteral("1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158203125e-45", token.FLOAT, 0)),
                "Sqrt":                     reflect.ValueOf(math32.Sqrt),
                "Sqrt2":                    reflect.ValueOf(constant.MakeFromLiteral("1.414213562373095048801688724209698078569671875376948073176679739576083351575381440094441524123797447886801949755143139115339040409162552642832693297721230919563348109313505318596071447245776653289794921875", token.FLOAT, 0)),
                "SqrtE":                    reflect.ValueOf(constant.MakeFromLiteral("1.64872127070012814684865078781416357165377610071014801157507931167328763229187870850146925823776361770041160388013884200789716007979526823569827080974091691342077871211546646890155898290686309337615966796875", token.FLOAT, 0)),
                "SqrtPhi":                  reflect.ValueOf(constant.MakeFromLiteral("1.2720196495140689642524224617374914917156080418400962486166403754616080542166459302584536396369727769747312116100875915825863540562126478288118732191412003988041797518382391984914647764526307582855224609375", token.FLOAT, 0)),
                "SqrtPi":                   reflect.ValueOf(constant.MakeFromLiteral("1.772453850905516027298167483341145182797549456122387128213807789740599698370237052541269446184448945647349951047154197675245574635259260134350885938555625028620527962319730619356050738133490085601806640625", token.FLOAT, 0)),
                "Tan":                      reflect.ValueOf(math32.Tan),
                "Tanh":                     reflect.ValueOf(math32.Tanh),
                "ToFixed":                  reflect.ValueOf(math32.ToFixed),
                "ToFixedPoint":             reflect.ValueOf(math32.ToFixedPoint),
                "Translate2D":              reflect.ValueOf(math32.Translate2D),
                "Trunc":                    reflect.ValueOf(math32.Trunc),
                "Truncate":                 reflect.ValueOf(math32.Truncate),
                "Truncate64":               reflect.ValueOf(math32.Truncate64),
                "Vec2":                     reflect.ValueOf(math32.Vec2),
                "Vec2i":                    reflect.ValueOf(math32.Vec2i),
                "Vec3":                     reflect.ValueOf(math32.Vec3),
                "Vec3i":                    reflect.ValueOf(math32.Vec3i),
                "Vec4":                     reflect.ValueOf(math32.Vec4),
                "Vector2FromFixed":         reflect.ValueOf(math32.Vector2FromFixed),
                "Vector2Polar":             reflect.ValueOf(math32.Vector2Polar),
                "Vector2Scalar":            reflect.ValueOf(math32.Vector2Scalar),
                "Vector2iScalar":           reflect.ValueOf(math32.Vector2iScalar),
                "Vector3FromVector4":       reflect.ValueOf(math32.Vector3FromVector4),
                "Vector3Scalar":            reflect.ValueOf(math32.Vector3Scalar),
                "Vector3iScalar":           reflect.ValueOf(math32.Vector3iScalar),
                "Vector4FromVector3":       reflect.ValueOf(math32.Vector4FromVector3),
                "Vector4Scalar":            reflect.ValueOf(math32.Vector4Scalar),
                "W":                        reflect.ValueOf(math32.W),
                "X":                        reflect.ValueOf(math32.X),
                "Y":                        reflect.ValueOf(math32.Y),
                "Y0":                       reflect.ValueOf(math32.Y0),
                "Y1":                       reflect.ValueOf(math32.Y1),
                "Yn":                       reflect.ValueOf(math32.Yn),
                "Z":                        reflect.ValueOf(math32.Z),

                // type definitions
                "ArrayF32":  reflect.ValueOf((*math32.ArrayF32)(nil)),
                "ArrayU32":  reflect.ValueOf((*math32.ArrayU32)(nil)),
                "Box2":      reflect.ValueOf((*math32.Box2)(nil)),
                "Box3":      reflect.ValueOf((*math32.Box3)(nil)),
                "Dims":      reflect.ValueOf((*math32.Dims)(nil)),
                "Frustum":   reflect.ValueOf((*math32.Frustum)(nil)),
                "Geom2DInt": reflect.ValueOf((*math32.Geom2DInt)(nil)),
                "Line2":     reflect.ValueOf((*math32.Line2)(nil)),
                "Line3":     reflect.ValueOf((*math32.Line3)(nil)),
                "Matrix2":   reflect.ValueOf((*math32.Matrix2)(nil)),
                "Matrix3":   reflect.ValueOf((*math32.Matrix3)(nil)),
                "Matrix4":   reflect.ValueOf((*math32.Matrix4)(nil)),
                "Plane":     reflect.ValueOf((*math32.Plane)(nil)),
                "Quat":      reflect.ValueOf((*math32.Quat)(nil)),
                "Ray":       reflect.ValueOf((*math32.Ray)(nil)),
                "Sphere":    reflect.ValueOf((*math32.Sphere)(nil)),
                "Triangle":  reflect.ValueOf((*math32.Triangle)(nil)),
                "Vector2":   reflect.ValueOf((*math32.Vector2)(nil)),
                "Vector2i":  reflect.ValueOf((*math32.Vector2i)(nil)),
                "Vector3":   reflect.ValueOf((*math32.Vector3)(nil)),
                "Vector3i":  reflect.ValueOf((*math32.Vector3i)(nil)),
                "Vector4":   reflect.ValueOf((*math32.Vector4)(nil)),
        }
}

// Code generated by 'yaegi extract fmt'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package basesymbols

import (
        "fmt"
        "reflect"
)

func init() {
        Symbols["fmt/fmt"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Append":       reflect.ValueOf(fmt.Append),
                "Appendf":      reflect.ValueOf(fmt.Appendf),
                "Appendln":     reflect.ValueOf(fmt.Appendln),
                "Errorf":       reflect.ValueOf(fmt.Errorf),
                "FormatString": reflect.ValueOf(fmt.FormatString),
                "Fprint":       reflect.ValueOf(fmt.Fprint),
                "Fprintf":      reflect.ValueOf(fmt.Fprintf),
                "Fprintln":     reflect.ValueOf(fmt.Fprintln),
                "Fscan":        reflect.ValueOf(fmt.Fscan),
                "Fscanf":       reflect.ValueOf(fmt.Fscanf),
                "Fscanln":      reflect.ValueOf(fmt.Fscanln),
                "Print":        reflect.ValueOf(fmt.Print),
                "Printf":       reflect.ValueOf(fmt.Printf),
                "Println":      reflect.ValueOf(fmt.Println),
                "Scan":         reflect.ValueOf(fmt.Scan),
                "Scanf":        reflect.ValueOf(fmt.Scanf),
                "Scanln":       reflect.ValueOf(fmt.Scanln),
                "Sprint":       reflect.ValueOf(fmt.Sprint),
                "Sprintf":      reflect.ValueOf(fmt.Sprintf),
                "Sprintln":     reflect.ValueOf(fmt.Sprintln),
                "Sscan":        reflect.ValueOf(fmt.Sscan),
                "Sscanf":       reflect.ValueOf(fmt.Sscanf),
                "Sscanln":      reflect.ValueOf(fmt.Sscanln),

                // type definitions
                "Formatter":  reflect.ValueOf((*fmt.Formatter)(nil)),
                "GoStringer": reflect.ValueOf((*fmt.GoStringer)(nil)),
                "ScanState":  reflect.ValueOf((*fmt.ScanState)(nil)),
                "Scanner":    reflect.ValueOf((*fmt.Scanner)(nil)),
                "State":      reflect.ValueOf((*fmt.State)(nil)),
                "Stringer":   reflect.ValueOf((*fmt.Stringer)(nil)),

                // interface wrapper definitions
                "_Formatter":  reflect.ValueOf((*_fmt_Formatter)(nil)),
                "_GoStringer": reflect.ValueOf((*_fmt_GoStringer)(nil)),
                "_ScanState":  reflect.ValueOf((*_fmt_ScanState)(nil)),
                "_Scanner":    reflect.ValueOf((*_fmt_Scanner)(nil)),
                "_State":      reflect.ValueOf((*_fmt_State)(nil)),
                "_Stringer":   reflect.ValueOf((*_fmt_Stringer)(nil)),
        }
}

// _fmt_Formatter is an interface wrapper for Formatter type
type _fmt_Formatter struct {
        IValue  interface{}
        WFormat func(f fmt.State, verb rune)
}

func (W _fmt_Formatter) Format(f fmt.State, verb rune) { W.WFormat(f, verb) }

// _fmt_GoStringer is an interface wrapper for GoStringer type
type _fmt_GoStringer struct {
        IValue    interface{}
        WGoString func() string
}

func (W _fmt_GoStringer) GoString() string { return W.WGoString() }

// _fmt_ScanState is an interface wrapper for ScanState type
type _fmt_ScanState struct {
        IValue      interface{}
        WRead       func(buf []byte) (n int, err error)
        WReadRune   func() (r rune, size int, err error)
        WSkipSpace  func()
        WToken      func(skipSpace bool, f func(rune) bool) (token []byte, err error)
        WUnreadRune func() error
        WWidth      func() (wid int, ok bool)
}

func (W _fmt_ScanState) Read(buf []byte) (n int, err error)      { return W.WRead(buf) }
func (W _fmt_ScanState) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
func (W _fmt_ScanState) SkipSpace()                              { W.WSkipSpace() }
func (W _fmt_ScanState) Token(skipSpace bool, f func(rune) bool) (token []byte, err error) {
        return W.WToken(skipSpace, f)
}
func (W _fmt_ScanState) UnreadRune() error         { return W.WUnreadRune() }
func (W _fmt_ScanState) Width() (wid int, ok bool) { return W.WWidth() }

// _fmt_Scanner is an interface wrapper for Scanner type
type _fmt_Scanner struct {
        IValue interface{}
        WScan  func(state fmt.ScanState, verb rune) error
}

func (W _fmt_Scanner) Scan(state fmt.ScanState, verb rune) error { return W.WScan(state, verb) }

// _fmt_State is an interface wrapper for State type
type _fmt_State struct {
        IValue     interface{}
        WFlag      func(c int) bool
        WPrecision func() (prec int, ok bool)
        WWidth     func() (wid int, ok bool)
        WWrite     func(b []byte) (n int, err error)
}

func (W _fmt_State) Flag(c int) bool                   { return W.WFlag(c) }
func (W _fmt_State) Precision() (prec int, ok bool)    { return W.WPrecision() }
func (W _fmt_State) Width() (wid int, ok bool)         { return W.WWidth() }
func (W _fmt_State) Write(b []byte) (n int, err error) { return W.WWrite(b) }

// _fmt_Stringer is an interface wrapper for Stringer type
type _fmt_Stringer struct {
        IValue  interface{}
        WString func() string
}

func (W _fmt_Stringer) String() string {
        if W.WString == nil {
                return ""
        }
        return W.WString()
}

// Code generated by 'yaegi extract log/slog'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package basesymbols

import (
        "context"
        "go/constant"
        "go/token"
        "log/slog"
        "reflect"
)

func init() {
        Symbols["log/slog/slog"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Any":               reflect.ValueOf(slog.Any),
                "AnyValue":          reflect.ValueOf(slog.AnyValue),
                "Bool":              reflect.ValueOf(slog.Bool),
                "BoolValue":         reflect.ValueOf(slog.BoolValue),
                "Debug":             reflect.ValueOf(slog.Debug),
                "DebugContext":      reflect.ValueOf(slog.DebugContext),
                "Default":           reflect.ValueOf(slog.Default),
                "Duration":          reflect.ValueOf(slog.Duration),
                "DurationValue":     reflect.ValueOf(slog.DurationValue),
                "Error":             reflect.ValueOf(slog.Error),
                "ErrorContext":      reflect.ValueOf(slog.ErrorContext),
                "Float64":           reflect.ValueOf(slog.Float64),
                "Float64Value":      reflect.ValueOf(slog.Float64Value),
                "Group":             reflect.ValueOf(slog.Group),
                "GroupValue":        reflect.ValueOf(slog.GroupValue),
                "Info":              reflect.ValueOf(slog.Info),
                "InfoContext":       reflect.ValueOf(slog.InfoContext),
                "Int":               reflect.ValueOf(slog.Int),
                "Int64":             reflect.ValueOf(slog.Int64),
                "Int64Value":        reflect.ValueOf(slog.Int64Value),
                "IntValue":          reflect.ValueOf(slog.IntValue),
                "KindAny":           reflect.ValueOf(slog.KindAny),
                "KindBool":          reflect.ValueOf(slog.KindBool),
                "KindDuration":      reflect.ValueOf(slog.KindDuration),
                "KindFloat64":       reflect.ValueOf(slog.KindFloat64),
                "KindGroup":         reflect.ValueOf(slog.KindGroup),
                "KindInt64":         reflect.ValueOf(slog.KindInt64),
                "KindLogValuer":     reflect.ValueOf(slog.KindLogValuer),
                "KindString":        reflect.ValueOf(slog.KindString),
                "KindTime":          reflect.ValueOf(slog.KindTime),
                "KindUint64":        reflect.ValueOf(slog.KindUint64),
                "LevelDebug":        reflect.ValueOf(slog.LevelDebug),
                "LevelError":        reflect.ValueOf(slog.LevelError),
                "LevelInfo":         reflect.ValueOf(slog.LevelInfo),
                "LevelKey":          reflect.ValueOf(constant.MakeFromLiteral("\"level\"", token.STRING, 0)),
                "LevelWarn":         reflect.ValueOf(slog.LevelWarn),
                "Log":               reflect.ValueOf(slog.Log),
                "LogAttrs":          reflect.ValueOf(slog.LogAttrs),
                "MessageKey":        reflect.ValueOf(constant.MakeFromLiteral("\"msg\"", token.STRING, 0)),
                "New":               reflect.ValueOf(slog.New),
                "NewJSONHandler":    reflect.ValueOf(slog.NewJSONHandler),
                "NewLogLogger":      reflect.ValueOf(slog.NewLogLogger),
                "NewRecord":         reflect.ValueOf(slog.NewRecord),
                "NewTextHandler":    reflect.ValueOf(slog.NewTextHandler),
                "SetDefault":        reflect.ValueOf(slog.SetDefault),
                "SetLogLoggerLevel": reflect.ValueOf(slog.SetLogLoggerLevel),
                "SourceKey":         reflect.ValueOf(constant.MakeFromLiteral("\"source\"", token.STRING, 0)),
                "String":            reflect.ValueOf(slog.String),
                "StringValue":       reflect.ValueOf(slog.StringValue),
                "Time":              reflect.ValueOf(slog.Time),
                "TimeKey":           reflect.ValueOf(constant.MakeFromLiteral("\"time\"", token.STRING, 0)),
                "TimeValue":         reflect.ValueOf(slog.TimeValue),
                "Uint64":            reflect.ValueOf(slog.Uint64),
                "Uint64Value":       reflect.ValueOf(slog.Uint64Value),
                "Warn":              reflect.ValueOf(slog.Warn),
                "WarnContext":       reflect.ValueOf(slog.WarnContext),
                "With":              reflect.ValueOf(slog.With),

                // type definitions
                "Attr":           reflect.ValueOf((*slog.Attr)(nil)),
                "Handler":        reflect.ValueOf((*slog.Handler)(nil)),
                "HandlerOptions": reflect.ValueOf((*slog.HandlerOptions)(nil)),
                "JSONHandler":    reflect.ValueOf((*slog.JSONHandler)(nil)),
                "Kind":           reflect.ValueOf((*slog.Kind)(nil)),
                "Level":          reflect.ValueOf((*slog.Level)(nil)),
                "LevelVar":       reflect.ValueOf((*slog.LevelVar)(nil)),
                "Leveler":        reflect.ValueOf((*slog.Leveler)(nil)),
                "LogValuer":      reflect.ValueOf((*slog.LogValuer)(nil)),
                "Logger":         reflect.ValueOf((*slog.Logger)(nil)),
                "Record":         reflect.ValueOf((*slog.Record)(nil)),
                "Source":         reflect.ValueOf((*slog.Source)(nil)),
                "TextHandler":    reflect.ValueOf((*slog.TextHandler)(nil)),
                "Value":          reflect.ValueOf((*slog.Value)(nil)),

                // interface wrapper definitions
                "_Handler":   reflect.ValueOf((*_log_slog_Handler)(nil)),
                "_Leveler":   reflect.ValueOf((*_log_slog_Leveler)(nil)),
                "_LogValuer": reflect.ValueOf((*_log_slog_LogValuer)(nil)),
        }
}

// _log_slog_Handler is an interface wrapper for Handler type
type _log_slog_Handler struct {
        IValue     interface{}
        WEnabled   func(a0 context.Context, a1 slog.Level) bool
        WHandle    func(a0 context.Context, a1 slog.Record) error
        WWithAttrs func(attrs []slog.Attr) slog.Handler
        WWithGroup func(name string) slog.Handler
}

func (W _log_slog_Handler) Enabled(a0 context.Context, a1 slog.Level) bool  { return W.WEnabled(a0, a1) }
func (W _log_slog_Handler) Handle(a0 context.Context, a1 slog.Record) error { return W.WHandle(a0, a1) }
func (W _log_slog_Handler) WithAttrs(attrs []slog.Attr) slog.Handler        { return W.WWithAttrs(attrs) }
func (W _log_slog_Handler) WithGroup(name string) slog.Handler              { return W.WWithGroup(name) }

// _log_slog_Leveler is an interface wrapper for Leveler type
type _log_slog_Leveler struct {
        IValue interface{}
        WLevel func() slog.Level
}

func (W _log_slog_Leveler) Level() slog.Level { return W.WLevel() }

// _log_slog_LogValuer is an interface wrapper for LogValuer type
type _log_slog_LogValuer struct {
        IValue    interface{}
        WLogValue func() slog.Value
}

func (W _log_slog_LogValuer) LogValue() slog.Value { return W.WLogValue() }

// Code generated by 'yaegi extract math'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package basesymbols

import (
        "go/constant"
        "go/token"
        "math"
        "reflect"
)

func init() {
        Symbols["math/math"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Abs":                    reflect.ValueOf(math.Abs),
                "Acos":                   reflect.ValueOf(math.Acos),
                "Acosh":                  reflect.ValueOf(math.Acosh),
                "Asin":                   reflect.ValueOf(math.Asin),
                "Asinh":                  reflect.ValueOf(math.Asinh),
                "Atan":                   reflect.ValueOf(math.Atan),
                "Atan2":                  reflect.ValueOf(math.Atan2),
                "Atanh":                  reflect.ValueOf(math.Atanh),
                "Cbrt":                   reflect.ValueOf(math.Cbrt),
                "Ceil":                   reflect.ValueOf(math.Ceil),
                "Copysign":               reflect.ValueOf(math.Copysign),
                "Cos":                    reflect.ValueOf(math.Cos),
                "Cosh":                   reflect.ValueOf(math.Cosh),
                "Dim":                    reflect.ValueOf(math.Dim),
                "E":                      reflect.ValueOf(constant.MakeFromLiteral("2.71828182845904523536028747135266249775724709369995957496696762566337824315673231520670375558666729784504486779277967997696994772644702281675346915668215131895555530285035761295375777990557253360748291015625", token.FLOAT, 0)),
                "Erf":                    reflect.ValueOf(math.Erf),
                "Erfc":                   reflect.ValueOf(math.Erfc),
                "Erfcinv":                reflect.ValueOf(math.Erfcinv),
                "Erfinv":                 reflect.ValueOf(math.Erfinv),
                "Exp":                    reflect.ValueOf(math.Exp),
                "Exp2":                   reflect.ValueOf(math.Exp2),
                "Expm1":                  reflect.ValueOf(math.Expm1),
                "FMA":                    reflect.ValueOf(math.FMA),
                "Float32bits":            reflect.ValueOf(math.Float32bits),
                "Float32frombits":        reflect.ValueOf(math.Float32frombits),
                "Float64bits":            reflect.ValueOf(math.Float64bits),
                "Float64frombits":        reflect.ValueOf(math.Float64frombits),
                "Floor":                  reflect.ValueOf(math.Floor),
                "Frexp":                  reflect.ValueOf(math.Frexp),
                "Gamma":                  reflect.ValueOf(math.Gamma),
                "Hypot":                  reflect.ValueOf(math.Hypot),
                "Ilogb":                  reflect.ValueOf(math.Ilogb),
                "Inf":                    reflect.ValueOf(math.Inf),
                "IsInf":                  reflect.ValueOf(math.IsInf),
                "IsNaN":                  reflect.ValueOf(math.IsNaN),
                "J0":                     reflect.ValueOf(math.J0),
                "J1":                     reflect.ValueOf(math.J1),
                "Jn":                     reflect.ValueOf(math.Jn),
                "Ldexp":                  reflect.ValueOf(math.Ldexp),
                "Lgamma":                 reflect.ValueOf(math.Lgamma),
                "Ln10":                   reflect.ValueOf(constant.MakeFromLiteral("2.30258509299404568401799145468436420760110148862877297603332784146804725494827975466552490443295866962642372461496758838959542646932914211937012833592062802600362869664962772731087170541286468505859375", token.FLOAT, 0)),
                "Ln2":                    reflect.ValueOf(constant.MakeFromLiteral("0.6931471805599453094172321214581765680755001343602552541206800092715999496201383079363438206637927920954189307729314303884387720696314608777673678644642390655170150035209453154294578780536539852619171142578125", token.FLOAT, 0)),
                "Log":                    reflect.ValueOf(math.Log),
                "Log10":                  reflect.ValueOf(math.Log10),
                "Log10E":                 reflect.ValueOf(constant.MakeFromLiteral("0.43429448190325182765112891891660508229439700580366656611445378416636798190620320263064286300825210972160277489744884502676719847561509639618196799746596688688378591625127711495224502868950366973876953125", token.FLOAT, 0)),
                "Log1p":                  reflect.ValueOf(math.Log1p),
                "Log2":                   reflect.ValueOf(math.Log2),
                "Log2E":                  reflect.ValueOf(constant.MakeFromLiteral("1.44269504088896340735992468100189213742664595415298593413544940772066427768997545329060870636212628972710992130324953463427359402479619301286929040235571747101382214539290471666532766903401352465152740478515625", token.FLOAT, 0)),
                "Logb":                   reflect.ValueOf(math.Logb),
                "Max":                    reflect.ValueOf(math.Max),
                "MaxFloat32":             reflect.ValueOf(constant.MakeFromLiteral("340282346638528859811704183484516925440", token.FLOAT, 0)),
                "MaxFloat64":             reflect.ValueOf(constant.MakeFromLiteral("179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368", token.FLOAT, 0)),
                "MaxInt":                 reflect.ValueOf(constant.MakeFromLiteral("9223372036854775807", token.INT, 0)),
                "MaxInt16":               reflect.ValueOf(constant.MakeFromLiteral("32767", token.INT, 0)),
                "MaxInt32":               reflect.ValueOf(constant.MakeFromLiteral("2147483647", token.INT, 0)),
                "MaxInt64":               reflect.ValueOf(constant.MakeFromLiteral("9223372036854775807", token.INT, 0)),
                "MaxInt8":                reflect.ValueOf(constant.MakeFromLiteral("127", token.INT, 0)),
                "MaxUint":                reflect.ValueOf(constant.MakeFromLiteral("18446744073709551615", token.INT, 0)),
                "MaxUint16":              reflect.ValueOf(constant.MakeFromLiteral("65535", token.INT, 0)),
                "MaxUint32":              reflect.ValueOf(constant.MakeFromLiteral("4294967295", token.INT, 0)),
                "MaxUint64":              reflect.ValueOf(constant.MakeFromLiteral("18446744073709551615", token.INT, 0)),
                "MaxUint8":               reflect.ValueOf(constant.MakeFromLiteral("255", token.INT, 0)),
                "Min":                    reflect.ValueOf(math.Min),
                "MinInt":                 reflect.ValueOf(constant.MakeFromLiteral("-9223372036854775808", token.INT, 0)),
                "MinInt16":               reflect.ValueOf(constant.MakeFromLiteral("-32768", token.INT, 0)),
                "MinInt32":               reflect.ValueOf(constant.MakeFromLiteral("-2147483648", token.INT, 0)),
                "MinInt64":               reflect.ValueOf(constant.MakeFromLiteral("-9223372036854775808", token.INT, 0)),
                "MinInt8":                reflect.ValueOf(constant.MakeFromLiteral("-128", token.INT, 0)),
                "Mod":                    reflect.ValueOf(math.Mod),
                "Modf":                   reflect.ValueOf(math.Modf),
                "NaN":                    reflect.ValueOf(math.NaN),
                "Nextafter":              reflect.ValueOf(math.Nextafter),
                "Nextafter32":            reflect.ValueOf(math.Nextafter32),
                "Phi":                    reflect.ValueOf(constant.MakeFromLiteral("1.6180339887498948482045868343656381177203091798057628621354486119746080982153796619881086049305501566952211682590824739205931370737029882996587050475921915678674035433959321750307935872115194797515869140625", token.FLOAT, 0)),
                "Pi":                     reflect.ValueOf(constant.MakeFromLiteral("3.141592653589793238462643383279502884197169399375105820974944594789982923695635954704435713335896673485663389728754819466702315787113662862838515639906529162340867271374644786874341662041842937469482421875", token.FLOAT, 0)),
                "Pow":                    reflect.ValueOf(math.Pow),
                "Pow10":                  reflect.ValueOf(math.Pow10),
                "Remainder":              reflect.ValueOf(math.Remainder),
                "Round":                  reflect.ValueOf(math.Round),
                "RoundToEven":            reflect.ValueOf(math.RoundToEven),
                "Signbit":                reflect.ValueOf(math.Signbit),
                "Sin":                    reflect.ValueOf(math.Sin),
                "Sincos":                 reflect.ValueOf(math.Sincos),
                "Sinh":                   reflect.ValueOf(math.Sinh),
                "SmallestNonzeroFloat32": reflect.ValueOf(constant.MakeFromLiteral("1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158203125e-45", token.FLOAT, 0)),
                "SmallestNonzeroFloat64": reflect.ValueOf(constant.MakeFromLiteral("4.940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625e-324", token.FLOAT, 0)),
                "Sqrt":                   reflect.ValueOf(math.Sqrt),
                "Sqrt2":                  reflect.ValueOf(constant.MakeFromLiteral("1.414213562373095048801688724209698078569671875376948073176679739576083351575381440094441524123797447886801949755143139115339040409162552642832693297721230919563348109313505318596071447245776653289794921875", token.FLOAT, 0)),
                "SqrtE":                  reflect.ValueOf(constant.MakeFromLiteral("1.64872127070012814684865078781416357165377610071014801157507931167328763229187870850146925823776361770041160388013884200789716007979526823569827080974091691342077871211546646890155898290686309337615966796875", token.FLOAT, 0)),
                "SqrtPhi":                reflect.ValueOf(constant.MakeFromLiteral("1.2720196495140689642524224617374914917156080418400962486166403754616080542166459302584536396369727769747312116100875915825863540562126478288118732191412003988041797518382391984914647764526307582855224609375", token.FLOAT, 0)),
                "SqrtPi":                 reflect.ValueOf(constant.MakeFromLiteral("1.772453850905516027298167483341145182797549456122387128213807789740599698370237052541269446184448945647349951047154197675245574635259260134350885938555625028620527962319730619356050738133490085601806640625", token.FLOAT, 0)),
                "Tan":                    reflect.ValueOf(math.Tan),
                "Tanh":                   reflect.ValueOf(math.Tanh),
                "Trunc":                  reflect.ValueOf(math.Trunc),
                "Y0":                     reflect.ValueOf(math.Y0),
                "Y1":                     reflect.ValueOf(math.Y1),
                "Yn":                     reflect.ValueOf(math.Yn),
        }
}

// Code generated by 'yaegi extract path/filepath'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package basesymbols

import (
        "go/constant"
        "go/token"
        "path/filepath"
        "reflect"
)

func init() {
        Symbols["path/filepath/filepath"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Abs":           reflect.ValueOf(filepath.Abs),
                "Base":          reflect.ValueOf(filepath.Base),
                "Clean":         reflect.ValueOf(filepath.Clean),
                "Dir":           reflect.ValueOf(filepath.Dir),
                "ErrBadPattern": reflect.ValueOf(&filepath.ErrBadPattern).Elem(),
                "EvalSymlinks":  reflect.ValueOf(filepath.EvalSymlinks),
                "Ext":           reflect.ValueOf(filepath.Ext),
                "FromSlash":     reflect.ValueOf(filepath.FromSlash),
                "Glob":          reflect.ValueOf(filepath.Glob),
                "HasPrefix":     reflect.ValueOf(filepath.HasPrefix),
                "IsAbs":         reflect.ValueOf(filepath.IsAbs),
                "IsLocal":       reflect.ValueOf(filepath.IsLocal),
                "Join":          reflect.ValueOf(filepath.Join),
                "ListSeparator": reflect.ValueOf(constant.MakeFromLiteral("58", token.INT, 0)),
                "Localize":      reflect.ValueOf(filepath.Localize),
                "Match":         reflect.ValueOf(filepath.Match),
                "Rel":           reflect.ValueOf(filepath.Rel),
                "Separator":     reflect.ValueOf(constant.MakeFromLiteral("47", token.INT, 0)),
                "SkipAll":       reflect.ValueOf(&filepath.SkipAll).Elem(),
                "SkipDir":       reflect.ValueOf(&filepath.SkipDir).Elem(),
                "Split":         reflect.ValueOf(filepath.Split),
                "SplitList":     reflect.ValueOf(filepath.SplitList),
                "ToSlash":       reflect.ValueOf(filepath.ToSlash),
                "VolumeName":    reflect.ValueOf(filepath.VolumeName),
                "Walk":          reflect.ValueOf(filepath.Walk),
                "WalkDir":       reflect.ValueOf(filepath.WalkDir),

                // type definitions
                "WalkFunc": reflect.ValueOf((*filepath.WalkFunc)(nil)),
        }
}

// Code generated by 'yaegi extract reflect'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package basesymbols

import (
        "reflect"
)

func init() {
        Symbols["reflect/reflect"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Append":          reflect.ValueOf(reflect.Append),
                "AppendSlice":     reflect.ValueOf(reflect.AppendSlice),
                "Array":           reflect.ValueOf(reflect.Array),
                "ArrayOf":         reflect.ValueOf(reflect.ArrayOf),
                "Bool":            reflect.ValueOf(reflect.Bool),
                "BothDir":         reflect.ValueOf(reflect.BothDir),
                "Chan":            reflect.ValueOf(reflect.Chan),
                "ChanOf":          reflect.ValueOf(reflect.ChanOf),
                "Complex128":      reflect.ValueOf(reflect.Complex128),
                "Complex64":       reflect.ValueOf(reflect.Complex64),
                "Copy":            reflect.ValueOf(reflect.Copy),
                "DeepEqual":       reflect.ValueOf(reflect.DeepEqual),
                "Float32":         reflect.ValueOf(reflect.Float32),
                "Float64":         reflect.ValueOf(reflect.Float64),
                "Func":            reflect.ValueOf(reflect.Func),
                "FuncOf":          reflect.ValueOf(reflect.FuncOf),
                "Indirect":        reflect.ValueOf(reflect.Indirect),
                "Int":             reflect.ValueOf(reflect.Int),
                "Int16":           reflect.ValueOf(reflect.Int16),
                "Int32":           reflect.ValueOf(reflect.Int32),
                "Int64":           reflect.ValueOf(reflect.Int64),
                "Int8":            reflect.ValueOf(reflect.Int8),
                "Interface":       reflect.ValueOf(reflect.Interface),
                "Invalid":         reflect.ValueOf(reflect.Invalid),
                "MakeChan":        reflect.ValueOf(reflect.MakeChan),
                "MakeFunc":        reflect.ValueOf(reflect.MakeFunc),
                "MakeMap":         reflect.ValueOf(reflect.MakeMap),
                "MakeMapWithSize": reflect.ValueOf(reflect.MakeMapWithSize),
                "MakeSlice":       reflect.ValueOf(reflect.MakeSlice),
                "Map":             reflect.ValueOf(reflect.Map),
                "MapOf":           reflect.ValueOf(reflect.MapOf),
                "New":             reflect.ValueOf(reflect.New),
                "NewAt":           reflect.ValueOf(reflect.NewAt),
                "Pointer":         reflect.ValueOf(reflect.Pointer),
                "PointerTo":       reflect.ValueOf(reflect.PointerTo),
                "Ptr":             reflect.ValueOf(reflect.Ptr),
                "PtrTo":           reflect.ValueOf(reflect.PtrTo),
                "RecvDir":         reflect.ValueOf(reflect.RecvDir),
                "Select":          reflect.ValueOf(reflect.Select),
                "SelectDefault":   reflect.ValueOf(reflect.SelectDefault),
                "SelectRecv":      reflect.ValueOf(reflect.SelectRecv),
                "SelectSend":      reflect.ValueOf(reflect.SelectSend),
                "SendDir":         reflect.ValueOf(reflect.SendDir),
                "Slice":           reflect.ValueOf(reflect.Slice),
                "SliceAt":         reflect.ValueOf(reflect.SliceAt),
                "SliceOf":         reflect.ValueOf(reflect.SliceOf),
                "String":          reflect.ValueOf(reflect.String),
                "Struct":          reflect.ValueOf(reflect.Struct),
                "StructOf":        reflect.ValueOf(reflect.StructOf),
                "Swapper":         reflect.ValueOf(reflect.Swapper),
                "TypeOf":          reflect.ValueOf(reflect.TypeOf),
                "Uint":            reflect.ValueOf(reflect.Uint),
                "Uint16":          reflect.ValueOf(reflect.Uint16),
                "Uint32":          reflect.ValueOf(reflect.Uint32),
                "Uint64":          reflect.ValueOf(reflect.Uint64),
                "Uint8":           reflect.ValueOf(reflect.Uint8),
                "Uintptr":         reflect.ValueOf(reflect.Uintptr),
                "UnsafePointer":   reflect.ValueOf(reflect.UnsafePointer),
                "ValueOf":         reflect.ValueOf(reflect.ValueOf),
                "VisibleFields":   reflect.ValueOf(reflect.VisibleFields),
                "Zero":            reflect.ValueOf(reflect.Zero),

                // type definitions
                "ChanDir":      reflect.ValueOf((*reflect.ChanDir)(nil)),
                "Kind":         reflect.ValueOf((*reflect.Kind)(nil)),
                "MapIter":      reflect.ValueOf((*reflect.MapIter)(nil)),
                "Method":       reflect.ValueOf((*reflect.Method)(nil)),
                "SelectCase":   reflect.ValueOf((*reflect.SelectCase)(nil)),
                "SelectDir":    reflect.ValueOf((*reflect.SelectDir)(nil)),
                "SliceHeader":  reflect.ValueOf((*reflect.SliceHeader)(nil)),
                "StringHeader": reflect.ValueOf((*reflect.StringHeader)(nil)),
                "StructField":  reflect.ValueOf((*reflect.StructField)(nil)),
                "StructTag":    reflect.ValueOf((*reflect.StructTag)(nil)),
                "Type":         reflect.ValueOf((*reflect.Type)(nil)),
                "Value":        reflect.ValueOf((*reflect.Value)(nil)),
                "ValueError":   reflect.ValueOf((*reflect.ValueError)(nil)),

                // interface wrapper definitions
                "_Type": reflect.ValueOf((*_reflect_Type)(nil)),
        }
}

// _reflect_Type is an interface wrapper for Type type
type _reflect_Type struct {
        IValue           interface{}
        WAlign           func() int
        WAssignableTo    func(u reflect.Type) bool
        WBits            func() int
        WCanSeq          func() bool
        WCanSeq2         func() bool
        WChanDir         func() reflect.ChanDir
        WComparable      func() bool
        WConvertibleTo   func(u reflect.Type) bool
        WElem            func() reflect.Type
        WField           func(i int) reflect.StructField
        WFieldAlign      func() int
        WFieldByIndex    func(index []int) reflect.StructField
        WFieldByName     func(name string) (reflect.StructField, bool)
        WFieldByNameFunc func(match func(string) bool) (reflect.StructField, bool)
        WImplements      func(u reflect.Type) bool
        WIn              func(i int) reflect.Type
        WIsVariadic      func() bool
        WKey             func() reflect.Type
        WKind            func() reflect.Kind
        WLen             func() int
        WMethod          func(a0 int) reflect.Method
        WMethodByName    func(a0 string) (reflect.Method, bool)
        WName            func() string
        WNumField        func() int
        WNumIn           func() int
        WNumMethod       func() int
        WNumOut          func() int
        WOut             func(i int) reflect.Type
        WOverflowComplex func(x complex128) bool
        WOverflowFloat   func(x float64) bool
        WOverflowInt     func(x int64) bool
        WOverflowUint    func(x uint64) bool
        WPkgPath         func() string
        WSize            func() uintptr
        WString          func() string
}

func (W _reflect_Type) Align() int                                   { return W.WAlign() }
func (W _reflect_Type) AssignableTo(u reflect.Type) bool             { return W.WAssignableTo(u) }
func (W _reflect_Type) Bits() int                                    { return W.WBits() }
func (W _reflect_Type) CanSeq() bool                                 { return W.WCanSeq() }
func (W _reflect_Type) CanSeq2() bool                                { return W.WCanSeq2() }
func (W _reflect_Type) ChanDir() reflect.ChanDir                     { return W.WChanDir() }
func (W _reflect_Type) Comparable() bool                             { return W.WComparable() }
func (W _reflect_Type) ConvertibleTo(u reflect.Type) bool            { return W.WConvertibleTo(u) }
func (W _reflect_Type) Elem() reflect.Type                           { return W.WElem() }
func (W _reflect_Type) Field(i int) reflect.StructField              { return W.WField(i) }
func (W _reflect_Type) FieldAlign() int                              { return W.WFieldAlign() }
func (W _reflect_Type) FieldByIndex(index []int) reflect.StructField { return W.WFieldByIndex(index) }
func (W _reflect_Type) FieldByName(name string) (reflect.StructField, bool) {
        return W.WFieldByName(name)
}
func (W _reflect_Type) FieldByNameFunc(match func(string) bool) (reflect.StructField, bool) {
        return W.WFieldByNameFunc(match)
}
func (W _reflect_Type) Implements(u reflect.Type) bool                { return W.WImplements(u) }
func (W _reflect_Type) In(i int) reflect.Type                         { return W.WIn(i) }
func (W _reflect_Type) IsVariadic() bool                              { return W.WIsVariadic() }
func (W _reflect_Type) Key() reflect.Type                             { return W.WKey() }
func (W _reflect_Type) Kind() reflect.Kind                            { return W.WKind() }
func (W _reflect_Type) Len() int                                      { return W.WLen() }
func (W _reflect_Type) Method(a0 int) reflect.Method                  { return W.WMethod(a0) }
func (W _reflect_Type) MethodByName(a0 string) (reflect.Method, bool) { return W.WMethodByName(a0) }
func (W _reflect_Type) Name() string                                  { return W.WName() }
func (W _reflect_Type) NumField() int                                 { return W.WNumField() }
func (W _reflect_Type) NumIn() int                                    { return W.WNumIn() }
func (W _reflect_Type) NumMethod() int                                { return W.WNumMethod() }
func (W _reflect_Type) NumOut() int                                   { return W.WNumOut() }
func (W _reflect_Type) Out(i int) reflect.Type                        { return W.WOut(i) }
func (W _reflect_Type) OverflowComplex(x complex128) bool             { return W.WOverflowComplex(x) }
func (W _reflect_Type) OverflowFloat(x float64) bool                  { return W.WOverflowFloat(x) }
func (W _reflect_Type) OverflowInt(x int64) bool                      { return W.WOverflowInt(x) }
func (W _reflect_Type) OverflowUint(x uint64) bool                    { return W.WOverflowUint(x) }
func (W _reflect_Type) PkgPath() string                               { return W.WPkgPath() }
func (W _reflect_Type) Size() uintptr                                 { return W.WSize() }
func (W _reflect_Type) String() string {
        if W.WString == nil {
                return ""
        }
        return W.WString()
}

// Code generated by 'yaegi extract strconv'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package basesymbols

import (
        "go/constant"
        "go/token"
        "reflect"
        "strconv"
)

func init() {
        Symbols["strconv/strconv"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AppendBool":               reflect.ValueOf(strconv.AppendBool),
                "AppendFloat":              reflect.ValueOf(strconv.AppendFloat),
                "AppendInt":                reflect.ValueOf(strconv.AppendInt),
                "AppendQuote":              reflect.ValueOf(strconv.AppendQuote),
                "AppendQuoteRune":          reflect.ValueOf(strconv.AppendQuoteRune),
                "AppendQuoteRuneToASCII":   reflect.ValueOf(strconv.AppendQuoteRuneToASCII),
                "AppendQuoteRuneToGraphic": reflect.ValueOf(strconv.AppendQuoteRuneToGraphic),
                "AppendQuoteToASCII":       reflect.ValueOf(strconv.AppendQuoteToASCII),
                "AppendQuoteToGraphic":     reflect.ValueOf(strconv.AppendQuoteToGraphic),
                "AppendUint":               reflect.ValueOf(strconv.AppendUint),
                "Atoi":                     reflect.ValueOf(strconv.Atoi),
                "CanBackquote":             reflect.ValueOf(strconv.CanBackquote),
                "ErrRange":                 reflect.ValueOf(&strconv.ErrRange).Elem(),
                "ErrSyntax":                reflect.ValueOf(&strconv.ErrSyntax).Elem(),
                "FormatBool":               reflect.ValueOf(strconv.FormatBool),
                "FormatComplex":            reflect.ValueOf(strconv.FormatComplex),
                "FormatFloat":              reflect.ValueOf(strconv.FormatFloat),
                "FormatInt":                reflect.ValueOf(strconv.FormatInt),
                "FormatUint":               reflect.ValueOf(strconv.FormatUint),
                "IntSize":                  reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
                "IsGraphic":                reflect.ValueOf(strconv.IsGraphic),
                "IsPrint":                  reflect.ValueOf(strconv.IsPrint),
                "Itoa":                     reflect.ValueOf(strconv.Itoa),
                "ParseBool":                reflect.ValueOf(strconv.ParseBool),
                "ParseComplex":             reflect.ValueOf(strconv.ParseComplex),
                "ParseFloat":               reflect.ValueOf(strconv.ParseFloat),
                "ParseInt":                 reflect.ValueOf(strconv.ParseInt),
                "ParseUint":                reflect.ValueOf(strconv.ParseUint),
                "Quote":                    reflect.ValueOf(strconv.Quote),
                "QuoteRune":                reflect.ValueOf(strconv.QuoteRune),
                "QuoteRuneToASCII":         reflect.ValueOf(strconv.QuoteRuneToASCII),
                "QuoteRuneToGraphic":       reflect.ValueOf(strconv.QuoteRuneToGraphic),
                "QuoteToASCII":             reflect.ValueOf(strconv.QuoteToASCII),
                "QuoteToGraphic":           reflect.ValueOf(strconv.QuoteToGraphic),
                "QuotedPrefix":             reflect.ValueOf(strconv.QuotedPrefix),
                "Unquote":                  reflect.ValueOf(strconv.Unquote),
                "UnquoteChar":              reflect.ValueOf(strconv.UnquoteChar),

                // type definitions
                "NumError": reflect.ValueOf((*strconv.NumError)(nil)),
        }
}

// Code generated by 'yaegi extract strings'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package basesymbols

import (
        "reflect"
        "strings"
)

func init() {
        Symbols["strings/strings"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Clone":          reflect.ValueOf(strings.Clone),
                "Compare":        reflect.ValueOf(strings.Compare),
                "Contains":       reflect.ValueOf(strings.Contains),
                "ContainsAny":    reflect.ValueOf(strings.ContainsAny),
                "ContainsFunc":   reflect.ValueOf(strings.ContainsFunc),
                "ContainsRune":   reflect.ValueOf(strings.ContainsRune),
                "Count":          reflect.ValueOf(strings.Count),
                "Cut":            reflect.ValueOf(strings.Cut),
                "CutPrefix":      reflect.ValueOf(strings.CutPrefix),
                "CutSuffix":      reflect.ValueOf(strings.CutSuffix),
                "EqualFold":      reflect.ValueOf(strings.EqualFold),
                "Fields":         reflect.ValueOf(strings.Fields),
                "FieldsFunc":     reflect.ValueOf(strings.FieldsFunc),
                "HasPrefix":      reflect.ValueOf(strings.HasPrefix),
                "HasSuffix":      reflect.ValueOf(strings.HasSuffix),
                "Index":          reflect.ValueOf(strings.Index),
                "IndexAny":       reflect.ValueOf(strings.IndexAny),
                "IndexByte":      reflect.ValueOf(strings.IndexByte),
                "IndexFunc":      reflect.ValueOf(strings.IndexFunc),
                "IndexRune":      reflect.ValueOf(strings.IndexRune),
                "Join":           reflect.ValueOf(strings.Join),
                "LastIndex":      reflect.ValueOf(strings.LastIndex),
                "LastIndexAny":   reflect.ValueOf(strings.LastIndexAny),
                "LastIndexByte":  reflect.ValueOf(strings.LastIndexByte),
                "LastIndexFunc":  reflect.ValueOf(strings.LastIndexFunc),
                "Map":            reflect.ValueOf(strings.Map),
                "NewReader":      reflect.ValueOf(strings.NewReader),
                "NewReplacer":    reflect.ValueOf(strings.NewReplacer),
                "Repeat":         reflect.ValueOf(strings.Repeat),
                "Replace":        reflect.ValueOf(strings.Replace),
                "ReplaceAll":     reflect.ValueOf(strings.ReplaceAll),
                "Split":          reflect.ValueOf(strings.Split),
                "SplitAfter":     reflect.ValueOf(strings.SplitAfter),
                "SplitAfterN":    reflect.ValueOf(strings.SplitAfterN),
                "SplitN":         reflect.ValueOf(strings.SplitN),
                "Title":          reflect.ValueOf(strings.Title),
                "ToLower":        reflect.ValueOf(strings.ToLower),
                "ToLowerSpecial": reflect.ValueOf(strings.ToLowerSpecial),
                "ToTitle":        reflect.ValueOf(strings.ToTitle),
                "ToTitleSpecial": reflect.ValueOf(strings.ToTitleSpecial),
                "ToUpper":        reflect.ValueOf(strings.ToUpper),
                "ToUpperSpecial": reflect.ValueOf(strings.ToUpperSpecial),
                "ToValidUTF8":    reflect.ValueOf(strings.ToValidUTF8),
                "Trim":           reflect.ValueOf(strings.Trim),
                "TrimFunc":       reflect.ValueOf(strings.TrimFunc),
                "TrimLeft":       reflect.ValueOf(strings.TrimLeft),
                "TrimLeftFunc":   reflect.ValueOf(strings.TrimLeftFunc),
                "TrimPrefix":     reflect.ValueOf(strings.TrimPrefix),
                "TrimRight":      reflect.ValueOf(strings.TrimRight),
                "TrimRightFunc":  reflect.ValueOf(strings.TrimRightFunc),
                "TrimSpace":      reflect.ValueOf(strings.TrimSpace),
                "TrimSuffix":     reflect.ValueOf(strings.TrimSuffix),

                // type definitions
                "Builder":  reflect.ValueOf((*strings.Builder)(nil)),
                "Reader":   reflect.ValueOf((*strings.Reader)(nil)),
                "Replacer": reflect.ValueOf((*strings.Replacer)(nil)),
        }
}

// Code generated by 'yaegi extract time'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package basesymbols

import (
        "go/constant"
        "go/token"
        "reflect"
        "time"
)

func init() {
        Symbols["time/time"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "ANSIC":                  reflect.ValueOf(constant.MakeFromLiteral("\"Mon Jan _2 15:04:05 2006\"", token.STRING, 0)),
                "After":                  reflect.ValueOf(time.After),
                "AfterFunc":              reflect.ValueOf(time.AfterFunc),
                "April":                  reflect.ValueOf(time.April),
                "August":                 reflect.ValueOf(time.August),
                "Date":                   reflect.ValueOf(time.Date),
                "DateOnly":               reflect.ValueOf(constant.MakeFromLiteral("\"2006-01-02\"", token.STRING, 0)),
                "DateTime":               reflect.ValueOf(constant.MakeFromLiteral("\"2006-01-02 15:04:05\"", token.STRING, 0)),
                "December":               reflect.ValueOf(time.December),
                "February":               reflect.ValueOf(time.February),
                "FixedZone":              reflect.ValueOf(time.FixedZone),
                "Friday":                 reflect.ValueOf(time.Friday),
                "Hour":                   reflect.ValueOf(time.Hour),
                "January":                reflect.ValueOf(time.January),
                "July":                   reflect.ValueOf(time.July),
                "June":                   reflect.ValueOf(time.June),
                "Kitchen":                reflect.ValueOf(constant.MakeFromLiteral("\"3:04PM\"", token.STRING, 0)),
                "Layout":                 reflect.ValueOf(constant.MakeFromLiteral("\"01/02 03:04:05PM '06 -0700\"", token.STRING, 0)),
                "LoadLocation":           reflect.ValueOf(time.LoadLocation),
                "LoadLocationFromTZData": reflect.ValueOf(time.LoadLocationFromTZData),
                "Local":                  reflect.ValueOf(&time.Local).Elem(),
                "March":                  reflect.ValueOf(time.March),
                "May":                    reflect.ValueOf(time.May),
                "Microsecond":            reflect.ValueOf(time.Microsecond),
                "Millisecond":            reflect.ValueOf(time.Millisecond),
                "Minute":                 reflect.ValueOf(time.Minute),
                "Monday":                 reflect.ValueOf(time.Monday),
                "Nanosecond":             reflect.ValueOf(time.Nanosecond),
                "NewTicker":              reflect.ValueOf(time.NewTicker),
                "NewTimer":               reflect.ValueOf(time.NewTimer),
                "November":               reflect.ValueOf(time.November),
                "Now":                    reflect.ValueOf(time.Now),
                "October":                reflect.ValueOf(time.October),
                "Parse":                  reflect.ValueOf(time.Parse),
                "ParseDuration":          reflect.ValueOf(time.ParseDuration),
                "ParseInLocation":        reflect.ValueOf(time.ParseInLocation),
                "RFC1123":                reflect.ValueOf(constant.MakeFromLiteral("\"Mon, 02 Jan 2006 15:04:05 MST\"", token.STRING, 0)),
                "RFC1123Z":               reflect.ValueOf(constant.MakeFromLiteral("\"Mon, 02 Jan 2006 15:04:05 -0700\"", token.STRING, 0)),
                "RFC3339":                reflect.ValueOf(constant.MakeFromLiteral("\"2006-01-02T15:04:05Z07:00\"", token.STRING, 0)),
                "RFC3339Nano":            reflect.ValueOf(constant.MakeFromLiteral("\"2006-01-02T15:04:05.999999999Z07:00\"", token.STRING, 0)),
                "RFC822":                 reflect.ValueOf(constant.MakeFromLiteral("\"02 Jan 06 15:04 MST\"", token.STRING, 0)),
                "RFC822Z":                reflect.ValueOf(constant.MakeFromLiteral("\"02 Jan 06 15:04 -0700\"", token.STRING, 0)),
                "RFC850":                 reflect.ValueOf(constant.MakeFromLiteral("\"Monday, 02-Jan-06 15:04:05 MST\"", token.STRING, 0)),
                "RubyDate":               reflect.ValueOf(constant.MakeFromLiteral("\"Mon Jan 02 15:04:05 -0700 2006\"", token.STRING, 0)),
                "Saturday":               reflect.ValueOf(time.Saturday),
                "Second":                 reflect.ValueOf(time.Second),
                "September":              reflect.ValueOf(time.September),
                "Since":                  reflect.ValueOf(time.Since),
                "Sleep":                  reflect.ValueOf(time.Sleep),
                "Stamp":                  reflect.ValueOf(constant.MakeFromLiteral("\"Jan _2 15:04:05\"", token.STRING, 0)),
                "StampMicro":             reflect.ValueOf(constant.MakeFromLiteral("\"Jan _2 15:04:05.000000\"", token.STRING, 0)),
                "StampMilli":             reflect.ValueOf(constant.MakeFromLiteral("\"Jan _2 15:04:05.000\"", token.STRING, 0)),
                "StampNano":              reflect.ValueOf(constant.MakeFromLiteral("\"Jan _2 15:04:05.000000000\"", token.STRING, 0)),
                "Sunday":                 reflect.ValueOf(time.Sunday),
                "Thursday":               reflect.ValueOf(time.Thursday),
                "Tick":                   reflect.ValueOf(time.Tick),
                "TimeOnly":               reflect.ValueOf(constant.MakeFromLiteral("\"15:04:05\"", token.STRING, 0)),
                "Tuesday":                reflect.ValueOf(time.Tuesday),
                "UTC":                    reflect.ValueOf(&time.UTC).Elem(),
                "Unix":                   reflect.ValueOf(time.Unix),
                "UnixDate":               reflect.ValueOf(constant.MakeFromLiteral("\"Mon Jan _2 15:04:05 MST 2006\"", token.STRING, 0)),
                "UnixMicro":              reflect.ValueOf(time.UnixMicro),
                "UnixMilli":              reflect.ValueOf(time.UnixMilli),
                "Until":                  reflect.ValueOf(time.Until),
                "Wednesday":              reflect.ValueOf(time.Wednesday),

                // type definitions
                "Duration":   reflect.ValueOf((*time.Duration)(nil)),
                "Location":   reflect.ValueOf((*time.Location)(nil)),
                "Month":      reflect.ValueOf((*time.Month)(nil)),
                "ParseError": reflect.ValueOf((*time.ParseError)(nil)),
                "Ticker":     reflect.ValueOf((*time.Ticker)(nil)),
                "Time":       reflect.ValueOf((*time.Time)(nil)),
                "Timer":      reflect.ValueOf((*time.Timer)(nil)),
                "Weekday":    reflect.ValueOf((*time.Weekday)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/base/iox/imagex'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/base/iox/imagex"
        "image"
        "image/color"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/base/iox/imagex/imagex"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AsRGBA":           reflect.ValueOf(imagex.AsRGBA),
                "Assert":           reflect.ValueOf(imagex.Assert),
                "BMP":              reflect.ValueOf(imagex.BMP),
                "Base64SplitLines": reflect.ValueOf(imagex.Base64SplitLines),
                "CloneAsRGBA":      reflect.ValueOf(imagex.CloneAsRGBA),
                "CompareColors":    reflect.ValueOf(imagex.CompareColors),
                "CompareUint8":     reflect.ValueOf(imagex.CompareUint8),
                "DiffImage":        reflect.ValueOf(imagex.DiffImage),
                "ExtToFormat":      reflect.ValueOf(imagex.ExtToFormat),
                "FormatsN":         reflect.ValueOf(imagex.FormatsN),
                "FormatsValues":    reflect.ValueOf(imagex.FormatsValues),
                "FromBase64":       reflect.ValueOf(imagex.FromBase64),
                "FromBase64JPG":    reflect.ValueOf(imagex.FromBase64JPG),
                "FromBase64PNG":    reflect.ValueOf(imagex.FromBase64PNG),
                "GIF":              reflect.ValueOf(imagex.GIF),
                "JPEG":             reflect.ValueOf(imagex.JPEG),
                "None":             reflect.ValueOf(imagex.None),
                "Open":             reflect.ValueOf(imagex.Open),
                "OpenFS":           reflect.ValueOf(imagex.OpenFS),
                "PNG":              reflect.ValueOf(imagex.PNG),
                "Read":             reflect.ValueOf(imagex.Read),
                "Save":             reflect.ValueOf(imagex.Save),
                "TIFF":             reflect.ValueOf(imagex.TIFF),
                "ToBase64JPG":      reflect.ValueOf(imagex.ToBase64JPG),
                "ToBase64PNG":      reflect.ValueOf(imagex.ToBase64PNG),
                "Unwrap":           reflect.ValueOf(imagex.Unwrap),
                "Update":           reflect.ValueOf(imagex.Update),
                "UpdateTestImages": reflect.ValueOf(&imagex.UpdateTestImages).Elem(),
                "WebP":             reflect.ValueOf(imagex.WebP),
                "WrapJS":           reflect.ValueOf(imagex.WrapJS),
                "Write":            reflect.ValueOf(imagex.Write),

                // type definitions
                "Formats":  reflect.ValueOf((*imagex.Formats)(nil)),
                "TestingT": reflect.ValueOf((*imagex.TestingT)(nil)),
                "Wrapped":  reflect.ValueOf((*imagex.Wrapped)(nil)),

                // interface wrapper definitions
                "_TestingT": reflect.ValueOf((*_cogentcore_org_core_base_iox_imagex_TestingT)(nil)),
                "_Wrapped":  reflect.ValueOf((*_cogentcore_org_core_base_iox_imagex_Wrapped)(nil)),
        }
}

// _cogentcore_org_core_base_iox_imagex_TestingT is an interface wrapper for TestingT type
type _cogentcore_org_core_base_iox_imagex_TestingT struct {
        IValue  interface{}
        WErrorf func(format string, args ...any)
}

func (W _cogentcore_org_core_base_iox_imagex_TestingT) Errorf(format string, args ...any) {
        W.WErrorf(format, args...)
}

// _cogentcore_org_core_base_iox_imagex_Wrapped is an interface wrapper for Wrapped type
type _cogentcore_org_core_base_iox_imagex_Wrapped struct {
        IValue      interface{}
        WAt         func(x int, y int) color.Color
        WBounds     func() image.Rectangle
        WColorModel func() color.Model
        WUnderlying func() image.Image
        WUpdate     func()
}

func (W _cogentcore_org_core_base_iox_imagex_Wrapped) At(x int, y int) color.Color {
        return W.WAt(x, y)
}
func (W _cogentcore_org_core_base_iox_imagex_Wrapped) Bounds() image.Rectangle { return W.WBounds() }
func (W _cogentcore_org_core_base_iox_imagex_Wrapped) ColorModel() color.Model {
        return W.WColorModel()
}
func (W _cogentcore_org_core_base_iox_imagex_Wrapped) Underlying() image.Image {
        return W.WUnderlying()
}
func (W _cogentcore_org_core_base_iox_imagex_Wrapped) Update() { W.WUpdate() }

// Code generated by 'yaegi extract cogentcore.org/core/colors/gradient'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/colors/gradient"
        "cogentcore.org/core/math32"
        "image"
        "image/color"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/colors/gradient/gradient"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Apply":             reflect.ValueOf(gradient.Apply),
                "ApplyOpacity":      reflect.ValueOf(gradient.ApplyOpacity),
                "Cache":             reflect.ValueOf(&gradient.Cache).Elem(),
                "CopyFrom":          reflect.ValueOf(gradient.CopyFrom),
                "CopyOf":            reflect.ValueOf(gradient.CopyOf),
                "FromAny":           reflect.ValueOf(gradient.FromAny),
                "FromString":        reflect.ValueOf(gradient.FromString),
                "NewApplier":        reflect.ValueOf(gradient.NewApplier),
                "NewBase":           reflect.ValueOf(gradient.NewBase),
                "NewLinear":         reflect.ValueOf(gradient.NewLinear),
                "NewRadial":         reflect.ValueOf(gradient.NewRadial),
                "ObjectBoundingBox": reflect.ValueOf(gradient.ObjectBoundingBox),
                "Pad":               reflect.ValueOf(gradient.Pad),
                "ReadXML":           reflect.ValueOf(gradient.ReadXML),
                "Reflect":           reflect.ValueOf(gradient.Reflect),
                "Repeat":            reflect.ValueOf(gradient.Repeat),
                "SpreadsN":          reflect.ValueOf(gradient.SpreadsN),
                "SpreadsValues":     reflect.ValueOf(gradient.SpreadsValues),
                "UnitsN":            reflect.ValueOf(gradient.UnitsN),
                "UnitsValues":       reflect.ValueOf(gradient.UnitsValues),
                "UnmarshalXML":      reflect.ValueOf(gradient.UnmarshalXML),
                "UserSpaceOnUse":    reflect.ValueOf(gradient.UserSpaceOnUse),
                "XMLAttr":           reflect.ValueOf(gradient.XMLAttr),

                // type definitions
                "Applier":    reflect.ValueOf((*gradient.Applier)(nil)),
                "ApplyFunc":  reflect.ValueOf((*gradient.ApplyFunc)(nil)),
                "ApplyFuncs": reflect.ValueOf((*gradient.ApplyFuncs)(nil)),
                "Base":       reflect.ValueOf((*gradient.Base)(nil)),
                "Gradient":   reflect.ValueOf((*gradient.Gradient)(nil)),
                "Linear":     reflect.ValueOf((*gradient.Linear)(nil)),
                "Radial":     reflect.ValueOf((*gradient.Radial)(nil)),
                "Spreads":    reflect.ValueOf((*gradient.Spreads)(nil)),
                "Stop":       reflect.ValueOf((*gradient.Stop)(nil)),
                "Units":      reflect.ValueOf((*gradient.Units)(nil)),

                // interface wrapper definitions
                "_Gradient": reflect.ValueOf((*_cogentcore_org_core_colors_gradient_Gradient)(nil)),
        }
}

// _cogentcore_org_core_colors_gradient_Gradient is an interface wrapper for Gradient type
type _cogentcore_org_core_colors_gradient_Gradient struct {
        IValue      interface{}
        WAsBase     func() *gradient.Base
        WAt         func(x int, y int) color.Color
        WBounds     func() image.Rectangle
        WColorModel func() color.Model
        WUpdate     func(opacity float32, box math32.Box2, objTransform math32.Matrix2)
}

func (W _cogentcore_org_core_colors_gradient_Gradient) AsBase() *gradient.Base { return W.WAsBase() }
func (W _cogentcore_org_core_colors_gradient_Gradient) At(x int, y int) color.Color {
        return W.WAt(x, y)
}
func (W _cogentcore_org_core_colors_gradient_Gradient) Bounds() image.Rectangle { return W.WBounds() }
func (W _cogentcore_org_core_colors_gradient_Gradient) ColorModel() color.Model {
        return W.WColorModel()
}
func (W _cogentcore_org_core_colors_gradient_Gradient) Update(opacity float32, box math32.Box2, objTransform math32.Matrix2) {
        W.WUpdate(opacity, box, objTransform)
}

// Code generated by 'yaegi extract cogentcore.org/core/colors'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/colors"
        "image"
        "image/color"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/colors/colors"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Add":                  reflect.ValueOf(colors.Add),
                "Aliceblue":            reflect.ValueOf(&colors.Aliceblue).Elem(),
                "AlphaBlend":           reflect.ValueOf(colors.AlphaBlend),
                "Antiquewhite":         reflect.ValueOf(&colors.Antiquewhite).Elem(),
                "ApplyOpacity":         reflect.ValueOf(colors.ApplyOpacity),
                "ApplyOpacityNRGBA":    reflect.ValueOf(colors.ApplyOpacityNRGBA),
                "Aqua":                 reflect.ValueOf(&colors.Aqua).Elem(),
                "Aquamarine":           reflect.ValueOf(&colors.Aquamarine).Elem(),
                "AsHex":                reflect.ValueOf(colors.AsHex),
                "AsRGBA":               reflect.ValueOf(colors.AsRGBA),
                "AsString":             reflect.ValueOf(colors.AsString),
                "Azure":                reflect.ValueOf(&colors.Azure).Elem(),
                "BaseContext":          reflect.ValueOf(colors.BaseContext),
                "Beige":                reflect.ValueOf(&colors.Beige).Elem(),
                "Bisque":               reflect.ValueOf(&colors.Bisque).Elem(),
                "Black":                reflect.ValueOf(&colors.Black).Elem(),
                "Blanchedalmond":       reflect.ValueOf(&colors.Blanchedalmond).Elem(),
                "Blend":                reflect.ValueOf(colors.Blend),
                "BlendRGB":             reflect.ValueOf(colors.BlendRGB),
                "BlendTypesN":          reflect.ValueOf(colors.BlendTypesN),
                "BlendTypesValues":     reflect.ValueOf(colors.BlendTypesValues),
                "Blue":                 reflect.ValueOf(&colors.Blue).Elem(),
                "Blueviolet":           reflect.ValueOf(&colors.Blueviolet).Elem(),
                "Brown":                reflect.ValueOf(&colors.Brown).Elem(),
                "Burlywood":            reflect.ValueOf(&colors.Burlywood).Elem(),
                "CAM16":                reflect.ValueOf(colors.CAM16),
                "Cadetblue":            reflect.ValueOf(&colors.Cadetblue).Elem(),
                "Chartreuse":           reflect.ValueOf(&colors.Chartreuse).Elem(),
                "Chocolate":            reflect.ValueOf(&colors.Chocolate).Elem(),
                "Clearer":              reflect.ValueOf(colors.Clearer),
                "Coral":                reflect.ValueOf(&colors.Coral).Elem(),
                "Cornflowerblue":       reflect.ValueOf(&colors.Cornflowerblue).Elem(),
                "Cornsilk":             reflect.ValueOf(&colors.Cornsilk).Elem(),
                "Crimson":              reflect.ValueOf(&colors.Crimson).Elem(),
                "Cyan":                 reflect.ValueOf(&colors.Cyan).Elem(),
                "Darkblue":             reflect.ValueOf(&colors.Darkblue).Elem(),
                "Darkcyan":             reflect.ValueOf(&colors.Darkcyan).Elem(),
                "Darkgoldenrod":        reflect.ValueOf(&colors.Darkgoldenrod).Elem(),
                "Darkgray":             reflect.ValueOf(&colors.Darkgray).Elem(),
                "Darkgreen":            reflect.ValueOf(&colors.Darkgreen).Elem(),
                "Darkgrey":             reflect.ValueOf(&colors.Darkgrey).Elem(),
                "Darkkhaki":            reflect.ValueOf(&colors.Darkkhaki).Elem(),
                "Darkmagenta":          reflect.ValueOf(&colors.Darkmagenta).Elem(),
                "Darkolivegreen":       reflect.ValueOf(&colors.Darkolivegreen).Elem(),
                "Darkorange":           reflect.ValueOf(&colors.Darkorange).Elem(),
                "Darkorchid":           reflect.ValueOf(&colors.Darkorchid).Elem(),
                "Darkred":              reflect.ValueOf(&colors.Darkred).Elem(),
                "Darksalmon":           reflect.ValueOf(&colors.Darksalmon).Elem(),
                "Darkseagreen":         reflect.ValueOf(&colors.Darkseagreen).Elem(),
                "Darkslateblue":        reflect.ValueOf(&colors.Darkslateblue).Elem(),
                "Darkslategray":        reflect.ValueOf(&colors.Darkslategray).Elem(),
                "Darkslategrey":        reflect.ValueOf(&colors.Darkslategrey).Elem(),
                "Darkturquoise":        reflect.ValueOf(&colors.Darkturquoise).Elem(),
                "Darkviolet":           reflect.ValueOf(&colors.Darkviolet).Elem(),
                "Deeppink":             reflect.ValueOf(&colors.Deeppink).Elem(),
                "Deepskyblue":          reflect.ValueOf(&colors.Deepskyblue).Elem(),
                "Dimgray":              reflect.ValueOf(&colors.Dimgray).Elem(),
                "Dimgrey":              reflect.ValueOf(&colors.Dimgrey).Elem(),
                "Dodgerblue":           reflect.ValueOf(&colors.Dodgerblue).Elem(),
                "Firebrick":            reflect.ValueOf(&colors.Firebrick).Elem(),
                "Floralwhite":          reflect.ValueOf(&colors.Floralwhite).Elem(),
                "Forestgreen":          reflect.ValueOf(&colors.Forestgreen).Elem(),
                "FromAny":              reflect.ValueOf(colors.FromAny),
                "FromFloat32":          reflect.ValueOf(colors.FromFloat32),
                "FromFloat64":          reflect.ValueOf(colors.FromFloat64),
                "FromHex":              reflect.ValueOf(colors.FromHex),
                "FromNRGBA":            reflect.ValueOf(colors.FromNRGBA),
                "FromNRGBAF32":         reflect.ValueOf(colors.FromNRGBAF32),
                "FromName":             reflect.ValueOf(colors.FromName),
                "FromRGB":              reflect.ValueOf(colors.FromRGB),
                "FromRGBAF32":          reflect.ValueOf(colors.FromRGBAF32),
                "FromString":           reflect.ValueOf(colors.FromString),
                "Fuchsia":              reflect.ValueOf(&colors.Fuchsia).Elem(),
                "Gainsboro":            reflect.ValueOf(&colors.Gainsboro).Elem(),
                "Ghostwhite":           reflect.ValueOf(&colors.Ghostwhite).Elem(),
                "Gold":                 reflect.ValueOf(&colors.Gold).Elem(),
                "Goldenrod":            reflect.ValueOf(&colors.Goldenrod).Elem(),
                "Gray":                 reflect.ValueOf(&colors.Gray).Elem(),
                "Green":                reflect.ValueOf(&colors.Green).Elem(),
                "Greenyellow":          reflect.ValueOf(&colors.Greenyellow).Elem(),
                "Grey":                 reflect.ValueOf(&colors.Grey).Elem(),
                "HCT":                  reflect.ValueOf(colors.HCT),
                "Honeydew":             reflect.ValueOf(&colors.Honeydew).Elem(),
                "Hotpink":              reflect.ValueOf(&colors.Hotpink).Elem(),
                "Indianred":            reflect.ValueOf(&colors.Indianred).Elem(),
                "Indigo":               reflect.ValueOf(&colors.Indigo).Elem(),
                "Inverse":              reflect.ValueOf(colors.Inverse),
                "IsNil":                reflect.ValueOf(colors.IsNil),
                "Ivory":                reflect.ValueOf(&colors.Ivory).Elem(),
                "Khaki":                reflect.ValueOf(&colors.Khaki).Elem(),
                "Lavender":             reflect.ValueOf(&colors.Lavender).Elem(),
                "Lavenderblush":        reflect.ValueOf(&colors.Lavenderblush).Elem(),
                "Lawngreen":            reflect.ValueOf(&colors.Lawngreen).Elem(),
                "Lemonchiffon":         reflect.ValueOf(&colors.Lemonchiffon).Elem(),
                "Lightblue":            reflect.ValueOf(&colors.Lightblue).Elem(),
                "Lightcoral":           reflect.ValueOf(&colors.Lightcoral).Elem(),
                "Lightcyan":            reflect.ValueOf(&colors.Lightcyan).Elem(),
                "Lightgoldenrodyellow": reflect.ValueOf(&colors.Lightgoldenrodyellow).Elem(),
                "Lightgray":            reflect.ValueOf(&colors.Lightgray).Elem(),
                "Lightgreen":           reflect.ValueOf(&colors.Lightgreen).Elem(),
                "Lightgrey":            reflect.ValueOf(&colors.Lightgrey).Elem(),
                "Lightpink":            reflect.ValueOf(&colors.Lightpink).Elem(),
                "Lightsalmon":          reflect.ValueOf(&colors.Lightsalmon).Elem(),
                "Lightseagreen":        reflect.ValueOf(&colors.Lightseagreen).Elem(),
                "Lightskyblue":         reflect.ValueOf(&colors.Lightskyblue).Elem(),
                "Lightslategray":       reflect.ValueOf(&colors.Lightslategray).Elem(),
                "Lightslategrey":       reflect.ValueOf(&colors.Lightslategrey).Elem(),
                "Lightsteelblue":       reflect.ValueOf(&colors.Lightsteelblue).Elem(),
                "Lightyellow":          reflect.ValueOf(&colors.Lightyellow).Elem(),
                "Lime":                 reflect.ValueOf(&colors.Lime).Elem(),
                "Limegreen":            reflect.ValueOf(&colors.Limegreen).Elem(),
                "Linen":                reflect.ValueOf(&colors.Linen).Elem(),
                "Magenta":              reflect.ValueOf(&colors.Magenta).Elem(),
                "Map":                  reflect.ValueOf(&colors.Map).Elem(),
                "Maroon":               reflect.ValueOf(&colors.Maroon).Elem(),
                "Mediumaquamarine":     reflect.ValueOf(&colors.Mediumaquamarine).Elem(),
                "Mediumblue":           reflect.ValueOf(&colors.Mediumblue).Elem(),
                "Mediumorchid":         reflect.ValueOf(&colors.Mediumorchid).Elem(),
                "Mediumpurple":         reflect.ValueOf(&colors.Mediumpurple).Elem(),
                "Mediumseagreen":       reflect.ValueOf(&colors.Mediumseagreen).Elem(),
                "Mediumslateblue":      reflect.ValueOf(&colors.Mediumslateblue).Elem(),
                "Mediumspringgreen":    reflect.ValueOf(&colors.Mediumspringgreen).Elem(),
                "Mediumturquoise":      reflect.ValueOf(&colors.Mediumturquoise).Elem(),
                "Mediumvioletred":      reflect.ValueOf(&colors.Mediumvioletred).Elem(),
                "Midnightblue":         reflect.ValueOf(&colors.Midnightblue).Elem(),
                "Mintcream":            reflect.ValueOf(&colors.Mintcream).Elem(),
                "Mistyrose":            reflect.ValueOf(&colors.Mistyrose).Elem(),
                "Moccasin":             reflect.ValueOf(&colors.Moccasin).Elem(),
                "NRGBAF32Model":        reflect.ValueOf(&colors.NRGBAF32Model).Elem(),
                "Names":                reflect.ValueOf(&colors.Names).Elem(),
                "Navajowhite":          reflect.ValueOf(&colors.Navajowhite).Elem(),
                "Navy":                 reflect.ValueOf(&colors.Navy).Elem(),
                "Oldlace":              reflect.ValueOf(&colors.Oldlace).Elem(),
                "Olive":                reflect.ValueOf(&colors.Olive).Elem(),
                "Olivedrab":            reflect.ValueOf(&colors.Olivedrab).Elem(),
                "Opaquer":              reflect.ValueOf(colors.Opaquer),
                "Orange":               reflect.ValueOf(&colors.Orange).Elem(),
                "Orangered":            reflect.ValueOf(&colors.Orangered).Elem(),
                "Orchid":               reflect.ValueOf(&colors.Orchid).Elem(),
                "Palegoldenrod":        reflect.ValueOf(&colors.Palegoldenrod).Elem(),
                "Palegreen":            reflect.ValueOf(&colors.Palegreen).Elem(),
                "Palette":              reflect.ValueOf(&colors.Palette).Elem(),
                "Paleturquoise":        reflect.ValueOf(&colors.Paleturquoise).Elem(),
                "Palevioletred":        reflect.ValueOf(&colors.Palevioletred).Elem(),
                "Papayawhip":           reflect.ValueOf(&colors.Papayawhip).Elem(),
                "Pattern":              reflect.ValueOf(colors.Pattern),
                "Peachpuff":            reflect.ValueOf(&colors.Peachpuff).Elem(),
                "Peru":                 reflect.ValueOf(&colors.Peru).Elem(),
                "Pink":                 reflect.ValueOf(&colors.Pink).Elem(),
                "Plum":                 reflect.ValueOf(&colors.Plum).Elem(),
                "Powderblue":           reflect.ValueOf(&colors.Powderblue).Elem(),
                "Purple":               reflect.ValueOf(&colors.Purple).Elem(),
                "RGB":                  reflect.ValueOf(colors.RGB),
                "RGBAF32Model":         reflect.ValueOf(&colors.RGBAF32Model).Elem(),
                "Rebeccapurple":        reflect.ValueOf(&colors.Rebeccapurple).Elem(),
                "Red":                  reflect.ValueOf(&colors.Red).Elem(),
                "Rosybrown":            reflect.ValueOf(&colors.Rosybrown).Elem(),
                "Royalblue":            reflect.ValueOf(&colors.Royalblue).Elem(),
                "Saddlebrown":          reflect.ValueOf(&colors.Saddlebrown).Elem(),
                "Salmon":               reflect.ValueOf(&colors.Salmon).Elem(),
                "Sandybrown":           reflect.ValueOf(&colors.Sandybrown).Elem(),
                "Scheme":               reflect.ValueOf(&colors.Scheme).Elem(),
                "Schemes":              reflect.ValueOf(&colors.Schemes).Elem(),
                "Seagreen":             reflect.ValueOf(&colors.Seagreen).Elem(),
                "Seashell":             reflect.ValueOf(&colors.Seashell).Elem(),
                "SetScheme":            reflect.ValueOf(colors.SetScheme),
                "SetSchemes":           reflect.ValueOf(colors.SetSchemes),
                "SetSchemesFromKey":    reflect.ValueOf(colors.SetSchemesFromKey),
                "Sienna":               reflect.ValueOf(&colors.Sienna).Elem(),
                "Silver":               reflect.ValueOf(&colors.Silver).Elem(),
                "Skyblue":              reflect.ValueOf(&colors.Skyblue).Elem(),
                "Slateblue":            reflect.ValueOf(&colors.Slateblue).Elem(),
                "Slategray":            reflect.ValueOf(&colors.Slategray).Elem(),
                "Slategrey":            reflect.ValueOf(&colors.Slategrey).Elem(),
                "Snow":                 reflect.ValueOf(&colors.Snow).Elem(),
                "Spaced":               reflect.ValueOf(colors.Spaced),
                "Springgreen":          reflect.ValueOf(&colors.Springgreen).Elem(),
                "Steelblue":            reflect.ValueOf(&colors.Steelblue).Elem(),
                "Sub":                  reflect.ValueOf(colors.Sub),
                "Tan":                  reflect.ValueOf(&colors.Tan).Elem(),
                "Teal":                 reflect.ValueOf(&colors.Teal).Elem(),
                "Thistle":              reflect.ValueOf(&colors.Thistle).Elem(),
                "ToBase":               reflect.ValueOf(colors.ToBase),
                "ToContainer":          reflect.ValueOf(colors.ToContainer),
                "ToFloat32":            reflect.ValueOf(colors.ToFloat32),
                "ToFloat64":            reflect.ValueOf(colors.ToFloat64),
                "ToOn":                 reflect.ValueOf(colors.ToOn),
                "ToOnContainer":        reflect.ValueOf(colors.ToOnContainer),
                "ToUniform":            reflect.ValueOf(colors.ToUniform),
                "Tomato":               reflect.ValueOf(&colors.Tomato).Elem(),
                "Transparent":          reflect.ValueOf(&colors.Transparent).Elem(),
                "Turquoise":            reflect.ValueOf(&colors.Turquoise).Elem(),
                "Uniform":              reflect.ValueOf(colors.Uniform),
                "Violet":               reflect.ValueOf(&colors.Violet).Elem(),
                "Wheat":                reflect.ValueOf(&colors.Wheat).Elem(),
                "White":                reflect.ValueOf(&colors.White).Elem(),
                "Whitesmoke":           reflect.ValueOf(&colors.Whitesmoke).Elem(),
                "WithA":                reflect.ValueOf(colors.WithA),
                "WithAF32":             reflect.ValueOf(colors.WithAF32),
                "WithB":                reflect.ValueOf(colors.WithB),
                "WithG":                reflect.ValueOf(colors.WithG),
                "WithR":                reflect.ValueOf(colors.WithR),
                "Yellow":               reflect.ValueOf(&colors.Yellow).Elem(),
                "Yellowgreen":          reflect.ValueOf(&colors.Yellowgreen).Elem(),

                // type definitions
                "BlendTypes": reflect.ValueOf((*colors.BlendTypes)(nil)),
                "Context":    reflect.ValueOf((*colors.Context)(nil)),
                "NRGBAF32":   reflect.ValueOf((*colors.NRGBAF32)(nil)),
                "RGBAF32":    reflect.ValueOf((*colors.RGBAF32)(nil)),

                // interface wrapper definitions
                "_Context": reflect.ValueOf((*_cogentcore_org_core_colors_Context)(nil)),
        }
}

// _cogentcore_org_core_colors_Context is an interface wrapper for Context type
type _cogentcore_org_core_colors_Context struct {
        IValue      interface{}
        WBase       func() color.RGBA
        WImageByURL func(url string) image.Image
}

func (W _cogentcore_org_core_colors_Context) Base() color.RGBA { return W.WBase() }
func (W _cogentcore_org_core_colors_Context) ImageByURL(url string) image.Image {
        return W.WImageByURL(url)
}

// Code generated by 'yaegi extract cogentcore.org/core/content'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/content"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/content/content"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "NewContent": reflect.ValueOf(content.NewContent),

                // type definitions
                "Content": reflect.ValueOf((*content.Content)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/core'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/math32"
        "cogentcore.org/core/styles"
        "cogentcore.org/core/system/composer"
        "cogentcore.org/core/tree"
        "github.com/cogentcore/yaegi/interp"
        "go/constant"
        "go/token"
        "image"
        "image/draw"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/core/core"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AllRenderWindows":              reflect.ValueOf(&core.AllRenderWindows).Elem(),
                "AllSettings":                   reflect.ValueOf(&core.AllSettings).Elem(),
                "AppAbout":                      reflect.ValueOf(&core.AppAbout).Elem(),
                "AppColor":                      reflect.ValueOf(&core.AppColor).Elem(),
                "AppIcon":                       reflect.ValueOf(&core.AppIcon).Elem(),
                "AppearanceSettings":            reflect.ValueOf(&core.AppearanceSettings).Elem(),
                "AsButton":                      reflect.ValueOf(core.AsButton),
                "AsFrame":                       reflect.ValueOf(core.AsFrame),
                "AsTextField":                   reflect.ValueOf(core.AsTextField),
                "AsTree":                        reflect.ValueOf(core.AsTree),
                "AsWidget":                      reflect.ValueOf(core.AsWidget),
                "Bind":                          reflect.ValueOf(interp.GenericFunc("func Bind[T Value](value any, vw T, tags ...string) T { //yaegi:add\n\t// TODO: make tags be reflect.StructTag once yaegi is fixed to work with that\n\twb := vw.AsWidget()\n\talreadyBound := wb.ValueUpdate != nil\n\twb.ValueUpdate = func() {\n\t\tif vws, ok := any(vw).(ValueSetter); ok {\n\t\t\tErrorSnackbar(vw, vws.SetWidgetValue(value))\n\t\t} else {\n\t\t\tErrorSnackbar(vw, reflectx.SetRobust(vw.WidgetValue(), value))\n\t\t}\n\t}\n\twb.ValueOnChange = func() {\n\t\tErrorSnackbar(vw, reflectx.SetRobust(value, vw.WidgetValue()))\n\t}\n\tif alreadyBound {\n\t\tResetWidgetValue(vw)\n\t}\n\twb.ValueTitle = labels.FriendlyTypeName(reflectx.NonPointerType(reflect.TypeOf(value)))\n\tif ob, ok := any(vw).(OnBinder); ok {\n\t\ttag := reflect.StructTag(\"\")\n\t\tif len(tags) > 0 {\n\t\t\ttag = reflect.StructTag(tags[0])\n\t\t}\n\t\tob.OnBind(value, tag)\n\t}\n\twb.ValueUpdate() // we update it with the initial value immediately\n\treturn vw\n}")),
                "ButtonAction":                  reflect.ValueOf(core.ButtonAction),
                "ButtonElevated":                reflect.ValueOf(core.ButtonElevated),
                "ButtonFilled":                  reflect.ValueOf(core.ButtonFilled),
                "ButtonMenu":                    reflect.ValueOf(core.ButtonMenu),
                "ButtonOutlined":                reflect.ValueOf(core.ButtonOutlined),
                "ButtonText":                    reflect.ValueOf(core.ButtonText),
                "ButtonTonal":                   reflect.ValueOf(core.ButtonTonal),
                "ButtonTypesN":                  reflect.ValueOf(core.ButtonTypesN),
                "ButtonTypesValues":             reflect.ValueOf(core.ButtonTypesValues),
                "CallFunc":                      reflect.ValueOf(core.CallFunc),
                "ChooserFilled":                 reflect.ValueOf(core.ChooserFilled),
                "ChooserOutlined":               reflect.ValueOf(core.ChooserOutlined),
                "ChooserTypesN":                 reflect.ValueOf(core.ChooserTypesN),
                "ChooserTypesValues":            reflect.ValueOf(core.ChooserTypesValues),
                "CompleteEditText":              reflect.ValueOf(core.CompleteEditText),
                "CompleterStage":                reflect.ValueOf(core.CompleterStage),
                "ConstantSpacing":               reflect.ValueOf(core.ConstantSpacing),
                "DebugSettings":                 reflect.ValueOf(&core.DebugSettings).Elem(),
                "DeviceSettings":                reflect.ValueOf(&core.DeviceSettings).Elem(),
                "DialogStage":                   reflect.ValueOf(core.DialogStage),
                "ErrorDialog":                   reflect.ValueOf(core.ErrorDialog),
                "ErrorSnackbar":                 reflect.ValueOf(core.ErrorSnackbar),
                "ExternalParent":                reflect.ValueOf(&core.ExternalParent).Elem(),
                "FilePickerDirOnlyFilter":       reflect.ValueOf(core.FilePickerDirOnlyFilter),
                "FilePickerExtensionOnlyFilter": reflect.ValueOf(core.FilePickerExtensionOnlyFilter),
                "ForceAppColor":                 reflect.ValueOf(&core.ForceAppColor).Elem(),
                "FunctionalTabs":                reflect.ValueOf(core.FunctionalTabs),
                "HighlightingEditor":            reflect.ValueOf(core.HighlightingEditor),
                "InitValueButton":               reflect.ValueOf(core.InitValueButton),
                "InspectorWindow":               reflect.ValueOf(core.InspectorWindow),
                "LayoutPassesN":                 reflect.ValueOf(core.LayoutPassesN),
                "LayoutPassesValues":            reflect.ValueOf(core.LayoutPassesValues),
                "ListColProperty":               reflect.ValueOf(constant.MakeFromLiteral("\"ls-col\"", token.STRING, 0)),
                "ListRowProperty":               reflect.ValueOf(constant.MakeFromLiteral("\"ls-row\"", token.STRING, 0)),
                "LoadAllSettings":               reflect.ValueOf(core.LoadAllSettings),
                "MenuStage":                     reflect.ValueOf(core.MenuStage),
                "MessageDialog":                 reflect.ValueOf(core.MessageDialog),
                "MessageSnackbar":               reflect.ValueOf(core.MessageSnackbar),
                "MeterCircle":                   reflect.ValueOf(core.MeterCircle),
                "MeterLinear":                   reflect.ValueOf(core.MeterLinear),
                "MeterSemicircle":               reflect.ValueOf(core.MeterSemicircle),
                "MeterTypesN":                   reflect.ValueOf(core.MeterTypesN),
                "MeterTypesValues":              reflect.ValueOf(core.MeterTypesValues),
                "NavigationAuto":                reflect.ValueOf(core.NavigationAuto),
                "NavigationBar":                 reflect.ValueOf(core.NavigationBar),
                "NavigationDrawer":              reflect.ValueOf(core.NavigationDrawer),
                "NewBody":                       reflect.ValueOf(core.NewBody),
                "NewButton":                     reflect.ValueOf(core.NewButton),
                "NewCanvas":                     reflect.ValueOf(core.NewCanvas),
                "NewChooser":                    reflect.ValueOf(core.NewChooser),
                "NewCollapser":                  reflect.ValueOf(core.NewCollapser),
                "NewColorButton":                reflect.ValueOf(core.NewColorButton),
                "NewColorMapButton":             reflect.ValueOf(core.NewColorMapButton),
                "NewColorPicker":                reflect.ValueOf(core.NewColorPicker),
                "NewComplete":                   reflect.ValueOf(core.NewComplete),
                "NewDatePicker":                 reflect.ValueOf(core.NewDatePicker),
                "NewDurationInput":              reflect.ValueOf(core.NewDurationInput),
                "NewFileButton":                 reflect.ValueOf(core.NewFileButton),
                "NewFilePicker":                 reflect.ValueOf(core.NewFilePicker),
                "NewFontButton":                 reflect.ValueOf(core.NewFontButton),
                "NewForm":                       reflect.ValueOf(core.NewForm),
                "NewFormButton":                 reflect.ValueOf(core.NewFormButton),
                "NewFrame":                      reflect.ValueOf(core.NewFrame),
                "NewFuncButton":                 reflect.ValueOf(core.NewFuncButton),
                "NewHandle":                     reflect.ValueOf(core.NewHandle),
                "NewHighlightingButton":         reflect.ValueOf(core.NewHighlightingButton),
                "NewIcon":                       reflect.ValueOf(core.NewIcon),
                "NewIconButton":                 reflect.ValueOf(core.NewIconButton),
                "NewImage":                      reflect.ValueOf(core.NewImage),
                "NewInlineList":                 reflect.ValueOf(core.NewInlineList),
                "NewInspector":                  reflect.ValueOf(core.NewInspector),
                "NewKeyChordButton":             reflect.ValueOf(core.NewKeyChordButton),
                "NewKeyMapButton":               reflect.ValueOf(core.NewKeyMapButton),
                "NewKeyedList":                  reflect.ValueOf(core.NewKeyedList),
                "NewKeyedListButton":            reflect.ValueOf(core.NewKeyedListButton),
                "NewList":                       reflect.ValueOf(core.NewList),
                "NewListButton":                 reflect.ValueOf(core.NewListButton),
                "NewMenu":                       reflect.ValueOf(core.NewMenu),
                "NewMenuFromStrings":            reflect.ValueOf(core.NewMenuFromStrings),
                "NewMenuStage":                  reflect.ValueOf(core.NewMenuStage),
                "NewMeter":                      reflect.ValueOf(core.NewMeter),
                "NewPages":                      reflect.ValueOf(core.NewPages),
                "NewPopupStage":                 reflect.ValueOf(core.NewPopupStage),
                "NewSVG":                        reflect.ValueOf(core.NewSVG),
                "NewScene":                      reflect.ValueOf(core.NewScene),
                "NewSeparator":                  reflect.ValueOf(core.NewSeparator),
                "NewSlider":                     reflect.ValueOf(core.NewSlider),
                "NewSoloFuncButton":             reflect.ValueOf(core.NewSoloFuncButton),
                "NewSpace":                      reflect.ValueOf(core.NewSpace),
                "NewSpinner":                    reflect.ValueOf(core.NewSpinner),
                "NewSplits":                     reflect.ValueOf(core.NewSplits),
                "NewSprite":                     reflect.ValueOf(core.NewSprite),
                "NewStretch":                    reflect.ValueOf(core.NewStretch),
                "NewSwitch":                     reflect.ValueOf(core.NewSwitch),
                "NewSwitches":                   reflect.ValueOf(core.NewSwitches),
                "NewTable":                      reflect.ValueOf(core.NewTable),
                "NewTabs":                       reflect.ValueOf(core.NewTabs),
                "NewText":                       reflect.ValueOf(core.NewText),
                "NewTextField":                  reflect.ValueOf(core.NewTextField),
                "NewTimeInput":                  reflect.ValueOf(core.NewTimeInput),
                "NewTimePicker":                 reflect.ValueOf(core.NewTimePicker),
                "NewToolbar":                    reflect.ValueOf(core.NewToolbar),
                "NewTree":                       reflect.ValueOf(core.NewTree),
                "NewTreeButton":                 reflect.ValueOf(core.NewTreeButton),
                "NewTypeChooser":                reflect.ValueOf(core.NewTypeChooser),
                "NewValue":                      reflect.ValueOf(core.NewValue),
                "NewWidgetBase":                 reflect.ValueOf(core.NewWidgetBase),
                "NoSentenceCaseFor":             reflect.ValueOf(&core.NoSentenceCaseFor).Elem(),
                "ProfileToggle":                 reflect.ValueOf(core.ProfileToggle),
                "RecycleDialog":                 reflect.ValueOf(core.RecycleDialog),
                "RecycleMainWindow":             reflect.ValueOf(core.RecycleMainWindow),
                "ResetWidgetValue":              reflect.ValueOf(core.ResetWidgetValue),
                "SaveSettings":                  reflect.ValueOf(core.SaveSettings),
                "SceneSource":                   reflect.ValueOf(core.SceneSource),
                "ScrimSource":                   reflect.ValueOf(core.ScrimSource),
                "SettingsEditor":                reflect.ValueOf(core.SettingsEditor),
                "SettingsWindow":                reflect.ValueOf(core.SettingsWindow),
                "SizeClassesN":                  reflect.ValueOf(core.SizeClassesN),
                "SizeClassesValues":             reflect.ValueOf(core.SizeClassesValues),
                "SizeCompact":                   reflect.ValueOf(core.SizeCompact),
                "SizeDownPass":                  reflect.ValueOf(core.SizeDownPass),
                "SizeExpanded":                  reflect.ValueOf(core.SizeExpanded),
                "SizeFinalPass":                 reflect.ValueOf(core.SizeFinalPass),
                "SizeMedium":                    reflect.ValueOf(core.SizeMedium),
                "SizeUpPass":                    reflect.ValueOf(core.SizeUpPass),
                "SliderScrollbar":               reflect.ValueOf(core.SliderScrollbar),
                "SliderSlider":                  reflect.ValueOf(core.SliderSlider),
                "SliderTypesN":                  reflect.ValueOf(core.SliderTypesN),
                "SliderTypesValues":             reflect.ValueOf(core.SliderTypesValues),
                "SnackbarStage":                 reflect.ValueOf(core.SnackbarStage),
                "SplitsTilesN":                  reflect.ValueOf(core.SplitsTilesN),
                "SplitsTilesValues":             reflect.ValueOf(core.SplitsTilesValues),
                "SpritesSource":                 reflect.ValueOf(core.SpritesSource),
                "StageTypesN":                   reflect.ValueOf(core.StageTypesN),
                "StageTypesValues":              reflect.ValueOf(core.StageTypesValues),
                "StandardTabs":                  reflect.ValueOf(core.StandardTabs),
                "StyleMenuScene":                reflect.ValueOf(core.StyleMenuScene),
                "SwitchCheckbox":                reflect.ValueOf(core.SwitchCheckbox),
                "SwitchChip":                    reflect.ValueOf(core.SwitchChip),
                "SwitchRadioButton":             reflect.ValueOf(core.SwitchRadioButton),
                "SwitchSegmentedButton":         reflect.ValueOf(core.SwitchSegmentedButton),
                "SwitchSwitch":                  reflect.ValueOf(core.SwitchSwitch),
                "SwitchTypesN":                  reflect.ValueOf(core.SwitchTypesN),
                "SwitchTypesValues":             reflect.ValueOf(core.SwitchTypesValues),
                "SystemSettings":                reflect.ValueOf(&core.SystemSettings).Elem(),
                "TabTypesN":                     reflect.ValueOf(core.TabTypesN),
                "TabTypesValues":                reflect.ValueOf(core.TabTypesValues),
                "TextBodyLarge":                 reflect.ValueOf(core.TextBodyLarge),
                "TextBodyMedium":                reflect.ValueOf(core.TextBodyMedium),
                "TextBodySmall":                 reflect.ValueOf(core.TextBodySmall),
                "TextDisplayLarge":              reflect.ValueOf(core.TextDisplayLarge),
                "TextDisplayMedium":             reflect.ValueOf(core.TextDisplayMedium),
                "TextDisplaySmall":              reflect.ValueOf(core.TextDisplaySmall),
                "TextFieldFilled":               reflect.ValueOf(core.TextFieldFilled),
                "TextFieldOutlined":             reflect.ValueOf(core.TextFieldOutlined),
                "TextFieldTypesN":               reflect.ValueOf(core.TextFieldTypesN),
                "TextFieldTypesValues":          reflect.ValueOf(core.TextFieldTypesValues),
                "TextHeadlineLarge":             reflect.ValueOf(core.TextHeadlineLarge),
                "TextHeadlineMedium":            reflect.ValueOf(core.TextHeadlineMedium),
                "TextHeadlineSmall":             reflect.ValueOf(core.TextHeadlineSmall),
                "TextLabelLarge":                reflect.ValueOf(core.TextLabelLarge),
                "TextLabelMedium":               reflect.ValueOf(core.TextLabelMedium),
                "TextLabelSmall":                reflect.ValueOf(core.TextLabelSmall),
                "TextSupporting":                reflect.ValueOf(core.TextSupporting),
                "TextTitleLarge":                reflect.ValueOf(core.TextTitleLarge),
                "TextTitleMedium":               reflect.ValueOf(core.TextTitleMedium),
                "TextTitleSmall":                reflect.ValueOf(core.TextTitleSmall),
                "TextTypesN":                    reflect.ValueOf(core.TextTypesN),
                "TextTypesValues":               reflect.ValueOf(core.TextTypesValues),
                "TheApp":                        reflect.ValueOf(&core.TheApp).Elem(),
                "ThemeAuto":                     reflect.ValueOf(core.ThemeAuto),
                "ThemeDark":                     reflect.ValueOf(core.ThemeDark),
                "ThemeLight":                    reflect.ValueOf(core.ThemeLight),
                "ThemesN":                       reflect.ValueOf(core.ThemesN),
                "ThemesValues":                  reflect.ValueOf(core.ThemesValues),
                "TileFirstLong":                 reflect.ValueOf(core.TileFirstLong),
                "TilePlus":                      reflect.ValueOf(core.TilePlus),
                "TileSecondLong":                reflect.ValueOf(core.TileSecondLong),
                "TileSpan":                      reflect.ValueOf(core.TileSpan),
                "TileSplit":                     reflect.ValueOf(core.TileSplit),
                "ToHTML":                        reflect.ValueOf(core.ToHTML),
                "ToolbarStyles":                 reflect.ValueOf(core.ToolbarStyles),
                "TooltipStage":                  reflect.ValueOf(core.TooltipStage),
                "UpdateAll":                     reflect.ValueOf(core.UpdateAll),
                "UpdateSettings":                reflect.ValueOf(core.UpdateSettings),
                "ValueTypes":                    reflect.ValueOf(&core.ValueTypes).Elem(),
                "Wait":                          reflect.ValueOf(core.Wait),
                "WindowStage":                   reflect.ValueOf(core.WindowStage),

                // type definitions
                "Animation":              reflect.ValueOf((*core.Animation)(nil)),
                "App":                    reflect.ValueOf((*core.App)(nil)),
                "AppearanceSettingsData": reflect.ValueOf((*core.AppearanceSettingsData)(nil)),
                "BarFuncs":               reflect.ValueOf((*core.BarFuncs)(nil)),
                "Blinker":                reflect.ValueOf((*core.Blinker)(nil)),
                "Body":                   reflect.ValueOf((*core.Body)(nil)),
                "Button":                 reflect.ValueOf((*core.Button)(nil)),
                "ButtonEmbedder":         reflect.ValueOf((*core.ButtonEmbedder)(nil)),
                "ButtonTypes":            reflect.ValueOf((*core.ButtonTypes)(nil)),
                "Canvas":                 reflect.ValueOf((*core.Canvas)(nil)),
                "Chooser":                reflect.ValueOf((*core.Chooser)(nil)),
                "ChooserItem":            reflect.ValueOf((*core.ChooserItem)(nil)),
                "ChooserTypes":           reflect.ValueOf((*core.ChooserTypes)(nil)),
                "Collapser":              reflect.ValueOf((*core.Collapser)(nil)),
                "ColorButton":            reflect.ValueOf((*core.ColorButton)(nil)),
                "ColorMapButton":         reflect.ValueOf((*core.ColorMapButton)(nil)),
                "ColorMapName":           reflect.ValueOf((*core.ColorMapName)(nil)),
                "ColorPicker":            reflect.ValueOf((*core.ColorPicker)(nil)),
                "Complete":               reflect.ValueOf((*core.Complete)(nil)),
                "DatePicker":             reflect.ValueOf((*core.DatePicker)(nil)),
                "DebugSettingsData":      reflect.ValueOf((*core.DebugSettingsData)(nil)),
                "DeviceSettingsData":     reflect.ValueOf((*core.DeviceSettingsData)(nil)),
                "DurationInput":          reflect.ValueOf((*core.DurationInput)(nil)),
                "Events":                 reflect.ValueOf((*core.Events)(nil)),
                "FileButton":             reflect.ValueOf((*core.FileButton)(nil)),
                "FilePaths":              reflect.ValueOf((*core.FilePaths)(nil)),
                "FilePicker":             reflect.ValueOf((*core.FilePicker)(nil)),
                "FilePickerFilterer":     reflect.ValueOf((*core.FilePickerFilterer)(nil)),
                "Filename":               reflect.ValueOf((*core.Filename)(nil)),
                "FontButton":             reflect.ValueOf((*core.FontButton)(nil)),
                "FontName":               reflect.ValueOf((*core.FontName)(nil)),
                "Form":                   reflect.ValueOf((*core.Form)(nil)),
                "FormButton":             reflect.ValueOf((*core.FormButton)(nil)),
                "Frame":                  reflect.ValueOf((*core.Frame)(nil)),
                "FuncArg":                reflect.ValueOf((*core.FuncArg)(nil)),
                "FuncButton":             reflect.ValueOf((*core.FuncButton)(nil)),
                "Handle":                 reflect.ValueOf((*core.Handle)(nil)),
                "HighlightingButton":     reflect.ValueOf((*core.HighlightingButton)(nil)),
                "HighlightingName":       reflect.ValueOf((*core.HighlightingName)(nil)),
                "Icon":                   reflect.ValueOf((*core.Icon)(nil)),
                "IconButton":             reflect.ValueOf((*core.IconButton)(nil)),
                "Image":                  reflect.ValueOf((*core.Image)(nil)),
                "InlineList":             reflect.ValueOf((*core.InlineList)(nil)),
                "Inspector":              reflect.ValueOf((*core.Inspector)(nil)),
                "KeyChordButton":         reflect.ValueOf((*core.KeyChordButton)(nil)),
                "KeyMapButton":           reflect.ValueOf((*core.KeyMapButton)(nil)),
                "KeyedList":              reflect.ValueOf((*core.KeyedList)(nil)),
                "KeyedListButton":        reflect.ValueOf((*core.KeyedListButton)(nil)),
                "LayoutPasses":           reflect.ValueOf((*core.LayoutPasses)(nil)),
                "Layouter":               reflect.ValueOf((*core.Layouter)(nil)),
                "List":                   reflect.ValueOf((*core.List)(nil)),
                "ListBase":               reflect.ValueOf((*core.ListBase)(nil)),
                "ListButton":             reflect.ValueOf((*core.ListButton)(nil)),
                "ListGrid":               reflect.ValueOf((*core.ListGrid)(nil)),
                "ListStyler":             reflect.ValueOf((*core.ListStyler)(nil)),
                "Lister":                 reflect.ValueOf((*core.Lister)(nil)),
                "MenuSearcher":           reflect.ValueOf((*core.MenuSearcher)(nil)),
                "Meter":                  reflect.ValueOf((*core.Meter)(nil)),
                "MeterTypes":             reflect.ValueOf((*core.MeterTypes)(nil)),
                "OnBinder":               reflect.ValueOf((*core.OnBinder)(nil)),
                "Pages":                  reflect.ValueOf((*core.Pages)(nil)),
                "SVG":                    reflect.ValueOf((*core.SVG)(nil)),
                "Scene":                  reflect.ValueOf((*core.Scene)(nil)),
                "ScreenSettings":         reflect.ValueOf((*core.ScreenSettings)(nil)),
                "Separator":              reflect.ValueOf((*core.Separator)(nil)),
                "Settings":               reflect.ValueOf((*core.Settings)(nil)),
                "SettingsBase":           reflect.ValueOf((*core.SettingsBase)(nil)),
                "SettingsOpener":         reflect.ValueOf((*core.SettingsOpener)(nil)),
                "SettingsSaver":          reflect.ValueOf((*core.SettingsSaver)(nil)),
                "ShouldDisplayer":        reflect.ValueOf((*core.ShouldDisplayer)(nil)),
                "SizeClasses":            reflect.ValueOf((*core.SizeClasses)(nil)),
                "Slider":                 reflect.ValueOf((*core.Slider)(nil)),
                "SliderTypes":            reflect.ValueOf((*core.SliderTypes)(nil)),
                "Space":                  reflect.ValueOf((*core.Space)(nil)),
                "Spinner":                reflect.ValueOf((*core.Spinner)(nil)),
                "Splits":                 reflect.ValueOf((*core.Splits)(nil)),
                "SplitsTiles":            reflect.ValueOf((*core.SplitsTiles)(nil)),
                "Sprite":                 reflect.ValueOf((*core.Sprite)(nil)),
                "Sprites":                reflect.ValueOf((*core.Sprites)(nil)),
                "Stage":                  reflect.ValueOf((*core.Stage)(nil)),
                "StageTypes":             reflect.ValueOf((*core.StageTypes)(nil)),
                "Stretch":                reflect.ValueOf((*core.Stretch)(nil)),
                "Switch":                 reflect.ValueOf((*core.Switch)(nil)),
                "SwitchItem":             reflect.ValueOf((*core.SwitchItem)(nil)),
                "SwitchTypes":            reflect.ValueOf((*core.SwitchTypes)(nil)),
                "Switches":               reflect.ValueOf((*core.Switches)(nil)),
                "SystemSettingsData":     reflect.ValueOf((*core.SystemSettingsData)(nil)),
                "Tab":                    reflect.ValueOf((*core.Tab)(nil)),
                "TabTypes":               reflect.ValueOf((*core.TabTypes)(nil)),
                "Tabber":                 reflect.ValueOf((*core.Tabber)(nil)),
                "Table":                  reflect.ValueOf((*core.Table)(nil)),
                "TableStyler":            reflect.ValueOf((*core.TableStyler)(nil)),
                "Tabs":                   reflect.ValueOf((*core.Tabs)(nil)),
                "Text":                   reflect.ValueOf((*core.Text)(nil)),
                "TextField":              reflect.ValueOf((*core.TextField)(nil)),
                "TextFieldEmbedder":      reflect.ValueOf((*core.TextFieldEmbedder)(nil)),
                "TextFieldTypes":         reflect.ValueOf((*core.TextFieldTypes)(nil)),
                "TextTypes":              reflect.ValueOf((*core.TextTypes)(nil)),
                "Themes":                 reflect.ValueOf((*core.Themes)(nil)),
                "TimeInput":              reflect.ValueOf((*core.TimeInput)(nil)),
                "TimePicker":             reflect.ValueOf((*core.TimePicker)(nil)),
                "Toolbar":                reflect.ValueOf((*core.Toolbar)(nil)),
                "ToolbarMaker":           reflect.ValueOf((*core.ToolbarMaker)(nil)),
                "Tree":                   reflect.ValueOf((*core.Tree)(nil)),
                "TreeButton":             reflect.ValueOf((*core.TreeButton)(nil)),
                "Treer":                  reflect.ValueOf((*core.Treer)(nil)),
                "TypeChooser":            reflect.ValueOf((*core.TypeChooser)(nil)),
                "User":                   reflect.ValueOf((*core.User)(nil)),
                "Validator":              reflect.ValueOf((*core.Validator)(nil)),
                "Value":                  reflect.ValueOf((*core.Value)(nil)),
                "ValueSetter":            reflect.ValueOf((*core.ValueSetter)(nil)),
                "Valuer":                 reflect.ValueOf((*core.Valuer)(nil)),
                "Widget":                 reflect.ValueOf((*core.Widget)(nil)),
                "WidgetBase":             reflect.ValueOf((*core.WidgetBase)(nil)),

                // interface wrapper definitions
                "_ButtonEmbedder":    reflect.ValueOf((*_cogentcore_org_core_core_ButtonEmbedder)(nil)),
                "_Layouter":          reflect.ValueOf((*_cogentcore_org_core_core_Layouter)(nil)),
                "_Lister":            reflect.ValueOf((*_cogentcore_org_core_core_Lister)(nil)),
                "_MenuSearcher":      reflect.ValueOf((*_cogentcore_org_core_core_MenuSearcher)(nil)),
                "_OnBinder":          reflect.ValueOf((*_cogentcore_org_core_core_OnBinder)(nil)),
                "_Settings":          reflect.ValueOf((*_cogentcore_org_core_core_Settings)(nil)),
                "_SettingsOpener":    reflect.ValueOf((*_cogentcore_org_core_core_SettingsOpener)(nil)),
                "_SettingsSaver":     reflect.ValueOf((*_cogentcore_org_core_core_SettingsSaver)(nil)),
                "_ShouldDisplayer":   reflect.ValueOf((*_cogentcore_org_core_core_ShouldDisplayer)(nil)),
                "_Tabber":            reflect.ValueOf((*_cogentcore_org_core_core_Tabber)(nil)),
                "_TextFieldEmbedder": reflect.ValueOf((*_cogentcore_org_core_core_TextFieldEmbedder)(nil)),
                "_ToolbarMaker":      reflect.ValueOf((*_cogentcore_org_core_core_ToolbarMaker)(nil)),
                "_Treer":             reflect.ValueOf((*_cogentcore_org_core_core_Treer)(nil)),
                "_Validator":         reflect.ValueOf((*_cogentcore_org_core_core_Validator)(nil)),
                "_Value":             reflect.ValueOf((*_cogentcore_org_core_core_Value)(nil)),
                "_ValueSetter":       reflect.ValueOf((*_cogentcore_org_core_core_ValueSetter)(nil)),
                "_Valuer":            reflect.ValueOf((*_cogentcore_org_core_core_Valuer)(nil)),
                "_Widget":            reflect.ValueOf((*_cogentcore_org_core_core_Widget)(nil)),
        }
}

// _cogentcore_org_core_core_ButtonEmbedder is an interface wrapper for ButtonEmbedder type
type _cogentcore_org_core_core_ButtonEmbedder struct {
        IValue    interface{}
        WAsButton func() *core.Button
}

func (W _cogentcore_org_core_core_ButtonEmbedder) AsButton() *core.Button { return W.WAsButton() }

// _cogentcore_org_core_core_Layouter is an interface wrapper for Layouter type
type _cogentcore_org_core_core_Layouter struct {
        IValue             interface{}
        WApplyScenePos     func()
        WAsFrame           func() *core.Frame
        WAsTree            func() *tree.NodeBase
        WAsWidget          func() *core.WidgetBase
        WChildBackground   func(child core.Widget) image.Image
        WContextMenuPos    func(e events.Event) image.Point
        WCopyFieldsFrom    func(from tree.Node)
        WDestroy           func()
        WInit              func()
        WLayoutSpace       func()
        WManageOverflow    func(iter int, updateSize bool) bool
        WNodeWalkDown      func(fun func(n tree.Node) bool)
        WOnAdd             func()
        WPlanName          func() string
        WPosition          func()
        WRender            func()
        WRenderSource      func(op draw.Op) composer.Source
        WRenderWidget      func()
        WScrollChanged     func(d math32.Dims, sb *core.Slider)
        WScrollGeom        func(d math32.Dims) (pos math32.Vector2, sz math32.Vector2)
        WScrollValues      func(d math32.Dims) (maxSize float32, visSize float32, visPct float32)
        WSetScrollParams   func(d math32.Dims, sb *core.Slider)
        WShowContextMenu   func(e events.Event)
        WSizeDown          func(iter int) bool
        WSizeDownSetAllocs func(iter int)
        WSizeFinal         func()
        WSizeFromChildren  func(iter int, pass core.LayoutPasses) math32.Vector2
        WSizeUp            func()
        WStyle             func()
        WWidgetTooltip     func(pos image.Point) (string, image.Point)
}

func (W _cogentcore_org_core_core_Layouter) ApplyScenePos()             { W.WApplyScenePos() }
func (W _cogentcore_org_core_core_Layouter) AsFrame() *core.Frame       { return W.WAsFrame() }
func (W _cogentcore_org_core_core_Layouter) AsTree() *tree.NodeBase     { return W.WAsTree() }
func (W _cogentcore_org_core_core_Layouter) AsWidget() *core.WidgetBase { return W.WAsWidget() }
func (W _cogentcore_org_core_core_Layouter) ChildBackground(child core.Widget) image.Image {
        return W.WChildBackground(child)
}
func (W _cogentcore_org_core_core_Layouter) ContextMenuPos(e events.Event) image.Point {
        return W.WContextMenuPos(e)
}
func (W _cogentcore_org_core_core_Layouter) CopyFieldsFrom(from tree.Node) { W.WCopyFieldsFrom(from) }
func (W _cogentcore_org_core_core_Layouter) Destroy()                      { W.WDestroy() }
func (W _cogentcore_org_core_core_Layouter) Init()                         { W.WInit() }
func (W _cogentcore_org_core_core_Layouter) LayoutSpace()                  { W.WLayoutSpace() }
func (W _cogentcore_org_core_core_Layouter) ManageOverflow(iter int, updateSize bool) bool {
        return W.WManageOverflow(iter, updateSize)
}
func (W _cogentcore_org_core_core_Layouter) NodeWalkDown(fun func(n tree.Node) bool) {
        W.WNodeWalkDown(fun)
}
func (W _cogentcore_org_core_core_Layouter) OnAdd()           { W.WOnAdd() }
func (W _cogentcore_org_core_core_Layouter) PlanName() string { return W.WPlanName() }
func (W _cogentcore_org_core_core_Layouter) Position()        { W.WPosition() }
func (W _cogentcore_org_core_core_Layouter) Render()          { W.WRender() }
func (W _cogentcore_org_core_core_Layouter) RenderSource(op draw.Op) composer.Source {
        return W.WRenderSource(op)
}
func (W _cogentcore_org_core_core_Layouter) RenderWidget() { W.WRenderWidget() }
func (W _cogentcore_org_core_core_Layouter) ScrollChanged(d math32.Dims, sb *core.Slider) {
        W.WScrollChanged(d, sb)
}
func (W _cogentcore_org_core_core_Layouter) ScrollGeom(d math32.Dims) (pos math32.Vector2, sz math32.Vector2) {
        return W.WScrollGeom(d)
}
func (W _cogentcore_org_core_core_Layouter) ScrollValues(d math32.Dims) (maxSize float32, visSize float32, visPct float32) {
        return W.WScrollValues(d)
}
func (W _cogentcore_org_core_core_Layouter) SetScrollParams(d math32.Dims, sb *core.Slider) {
        W.WSetScrollParams(d, sb)
}
func (W _cogentcore_org_core_core_Layouter) ShowContextMenu(e events.Event) { W.WShowContextMenu(e) }
func (W _cogentcore_org_core_core_Layouter) SizeDown(iter int) bool         { return W.WSizeDown(iter) }
func (W _cogentcore_org_core_core_Layouter) SizeDownSetAllocs(iter int)     { W.WSizeDownSetAllocs(iter) }
func (W _cogentcore_org_core_core_Layouter) SizeFinal()                     { W.WSizeFinal() }
func (W _cogentcore_org_core_core_Layouter) SizeFromChildren(iter int, pass core.LayoutPasses) math32.Vector2 {
        return W.WSizeFromChildren(iter, pass)
}
func (W _cogentcore_org_core_core_Layouter) SizeUp() { W.WSizeUp() }
func (W _cogentcore_org_core_core_Layouter) Style()  { W.WStyle() }
func (W _cogentcore_org_core_core_Layouter) WidgetTooltip(pos image.Point) (string, image.Point) {
        return W.WWidgetTooltip(pos)
}

// _cogentcore_org_core_core_Lister is an interface wrapper for Lister type
type _cogentcore_org_core_core_Lister struct {
        IValue            interface{}
        WAsListBase       func() *core.ListBase
        WAsTree           func() *tree.NodeBase
        WCopyFieldsFrom   func(from tree.Node)
        WCopySelectToMime func() mimedata.Mimes
        WDeleteAt         func(idx int)
        WDestroy          func()
        WHasStyler        func() bool
        WInit             func()
        WMakeRow          func(p *tree.Plan, i int)
        WMimeDataType     func() string
        WNewAt            func(idx int)
        WNodeWalkDown     func(fun func(n tree.Node) bool)
        WOnAdd            func()
        WPasteAssign      func(md mimedata.Mimes, idx int)
        WPasteAtIndex     func(md mimedata.Mimes, idx int)
        WPlanName         func() string
        WRowGrabFocus     func(row int) *core.WidgetBase
        WRowWidgetNs      func() (nWidgPerRow int, idxOff int)
        WSliceIndex       func(i int) (si int, vi int, invis bool)
        WStyleRow         func(w core.Widget, idx int, fidx int)
        WStyleValue       func(w core.Widget, s *styles.Style, row int, col int)
        WUpdateMaxWidths  func()
        WUpdateSliceSize  func() int
}

func (W _cogentcore_org_core_core_Lister) AsListBase() *core.ListBase    { return W.WAsListBase() }
func (W _cogentcore_org_core_core_Lister) AsTree() *tree.NodeBase        { return W.WAsTree() }
func (W _cogentcore_org_core_core_Lister) CopyFieldsFrom(from tree.Node) { W.WCopyFieldsFrom(from) }
func (W _cogentcore_org_core_core_Lister) CopySelectToMime() mimedata.Mimes {
        return W.WCopySelectToMime()
}
func (W _cogentcore_org_core_core_Lister) DeleteAt(idx int)            { W.WDeleteAt(idx) }
func (W _cogentcore_org_core_core_Lister) Destroy()                    { W.WDestroy() }
func (W _cogentcore_org_core_core_Lister) HasStyler() bool             { return W.WHasStyler() }
func (W _cogentcore_org_core_core_Lister) Init()                       { W.WInit() }
func (W _cogentcore_org_core_core_Lister) MakeRow(p *tree.Plan, i int) { W.WMakeRow(p, i) }
func (W _cogentcore_org_core_core_Lister) MimeDataType() string        { return W.WMimeDataType() }
func (W _cogentcore_org_core_core_Lister) NewAt(idx int)               { W.WNewAt(idx) }
func (W _cogentcore_org_core_core_Lister) NodeWalkDown(fun func(n tree.Node) bool) {
        W.WNodeWalkDown(fun)
}
func (W _cogentcore_org_core_core_Lister) OnAdd() { W.WOnAdd() }
func (W _cogentcore_org_core_core_Lister) PasteAssign(md mimedata.Mimes, idx int) {
        W.WPasteAssign(md, idx)
}
func (W _cogentcore_org_core_core_Lister) PasteAtIndex(md mimedata.Mimes, idx int) {
        W.WPasteAtIndex(md, idx)
}
func (W _cogentcore_org_core_core_Lister) PlanName() string { return W.WPlanName() }
func (W _cogentcore_org_core_core_Lister) RowGrabFocus(row int) *core.WidgetBase {
        return W.WRowGrabFocus(row)
}
func (W _cogentcore_org_core_core_Lister) RowWidgetNs() (nWidgPerRow int, idxOff int) {
        return W.WRowWidgetNs()
}
func (W _cogentcore_org_core_core_Lister) SliceIndex(i int) (si int, vi int, invis bool) {
        return W.WSliceIndex(i)
}
func (W _cogentcore_org_core_core_Lister) StyleRow(w core.Widget, idx int, fidx int) {
        W.WStyleRow(w, idx, fidx)
}
func (W _cogentcore_org_core_core_Lister) StyleValue(w core.Widget, s *styles.Style, row int, col int) {
        W.WStyleValue(w, s, row, col)
}
func (W _cogentcore_org_core_core_Lister) UpdateMaxWidths()     { W.WUpdateMaxWidths() }
func (W _cogentcore_org_core_core_Lister) UpdateSliceSize() int { return W.WUpdateSliceSize() }

// _cogentcore_org_core_core_MenuSearcher is an interface wrapper for MenuSearcher type
type _cogentcore_org_core_core_MenuSearcher struct {
        IValue      interface{}
        WMenuSearch func(items *[]core.ChooserItem)
}

func (W _cogentcore_org_core_core_MenuSearcher) MenuSearch(items *[]core.ChooserItem) {
        W.WMenuSearch(items)
}

// _cogentcore_org_core_core_OnBinder is an interface wrapper for OnBinder type
type _cogentcore_org_core_core_OnBinder struct {
        IValue  interface{}
        WOnBind func(value any, tags reflect.StructTag)
}

func (W _cogentcore_org_core_core_OnBinder) OnBind(value any, tags reflect.StructTag) {
        W.WOnBind(value, tags)
}

// _cogentcore_org_core_core_Settings is an interface wrapper for Settings type
type _cogentcore_org_core_core_Settings struct {
        IValue       interface{}
        WApply       func()
        WDefaults    func()
        WFilename    func() string
        WLabel       func() string
        WMakeToolbar func(p *tree.Plan)
}

func (W _cogentcore_org_core_core_Settings) Apply()                   { W.WApply() }
func (W _cogentcore_org_core_core_Settings) Defaults()                { W.WDefaults() }
func (W _cogentcore_org_core_core_Settings) Filename() string         { return W.WFilename() }
func (W _cogentcore_org_core_core_Settings) Label() string            { return W.WLabel() }
func (W _cogentcore_org_core_core_Settings) MakeToolbar(p *tree.Plan) { W.WMakeToolbar(p) }

// _cogentcore_org_core_core_SettingsOpener is an interface wrapper for SettingsOpener type
type _cogentcore_org_core_core_SettingsOpener struct {
        IValue       interface{}
        WApply       func()
        WDefaults    func()
        WFilename    func() string
        WLabel       func() string
        WMakeToolbar func(p *tree.Plan)
        WOpen        func() error
}

func (W _cogentcore_org_core_core_SettingsOpener) Apply()                   { W.WApply() }
func (W _cogentcore_org_core_core_SettingsOpener) Defaults()                { W.WDefaults() }
func (W _cogentcore_org_core_core_SettingsOpener) Filename() string         { return W.WFilename() }
func (W _cogentcore_org_core_core_SettingsOpener) Label() string            { return W.WLabel() }
func (W _cogentcore_org_core_core_SettingsOpener) MakeToolbar(p *tree.Plan) { W.WMakeToolbar(p) }
func (W _cogentcore_org_core_core_SettingsOpener) Open() error              { return W.WOpen() }

// _cogentcore_org_core_core_SettingsSaver is an interface wrapper for SettingsSaver type
type _cogentcore_org_core_core_SettingsSaver struct {
        IValue       interface{}
        WApply       func()
        WDefaults    func()
        WFilename    func() string
        WLabel       func() string
        WMakeToolbar func(p *tree.Plan)
        WSave        func() error
}

func (W _cogentcore_org_core_core_SettingsSaver) Apply()                   { W.WApply() }
func (W _cogentcore_org_core_core_SettingsSaver) Defaults()                { W.WDefaults() }
func (W _cogentcore_org_core_core_SettingsSaver) Filename() string         { return W.WFilename() }
func (W _cogentcore_org_core_core_SettingsSaver) Label() string            { return W.WLabel() }
func (W _cogentcore_org_core_core_SettingsSaver) MakeToolbar(p *tree.Plan) { W.WMakeToolbar(p) }
func (W _cogentcore_org_core_core_SettingsSaver) Save() error              { return W.WSave() }

// _cogentcore_org_core_core_ShouldDisplayer is an interface wrapper for ShouldDisplayer type
type _cogentcore_org_core_core_ShouldDisplayer struct {
        IValue         interface{}
        WShouldDisplay func(field string) bool
}

func (W _cogentcore_org_core_core_ShouldDisplayer) ShouldDisplay(field string) bool {
        return W.WShouldDisplay(field)
}

// _cogentcore_org_core_core_Tabber is an interface wrapper for Tabber type
type _cogentcore_org_core_core_Tabber struct {
        IValue      interface{}
        WAsCoreTabs func() *core.Tabs
}

func (W _cogentcore_org_core_core_Tabber) AsCoreTabs() *core.Tabs { return W.WAsCoreTabs() }

// _cogentcore_org_core_core_TextFieldEmbedder is an interface wrapper for TextFieldEmbedder type
type _cogentcore_org_core_core_TextFieldEmbedder struct {
        IValue       interface{}
        WAsTextField func() *core.TextField
}

func (W _cogentcore_org_core_core_TextFieldEmbedder) AsTextField() *core.TextField {
        return W.WAsTextField()
}

// _cogentcore_org_core_core_ToolbarMaker is an interface wrapper for ToolbarMaker type
type _cogentcore_org_core_core_ToolbarMaker struct {
        IValue       interface{}
        WMakeToolbar func(p *tree.Plan)
}

func (W _cogentcore_org_core_core_ToolbarMaker) MakeToolbar(p *tree.Plan) { W.WMakeToolbar(p) }

// _cogentcore_org_core_core_Treer is an interface wrapper for Treer type
type _cogentcore_org_core_core_Treer struct {
        IValue            interface{}
        WApplyScenePos    func()
        WAsCoreTree       func() *core.Tree
        WAsTree           func() *tree.NodeBase
        WAsWidget         func() *core.WidgetBase
        WCanOpen          func() bool
        WChildBackground  func(child core.Widget) image.Image
        WContextMenuPos   func(e events.Event) image.Point
        WCopy             func()
        WCopyFieldsFrom   func(from tree.Node)
        WCut              func()
        WDestroy          func()
        WDragDrop         func(e events.Event)
        WDropDeleteSource func(e events.Event)
        WInit             func()
        WMimeData         func(md *mimedata.Mimes)
        WNodeWalkDown     func(fun func(n tree.Node) bool)
        WOnAdd            func()
        WOnClose          func()
        WOnOpen           func()
        WPaste            func()
        WPlanName         func() string
        WPosition         func()
        WRender           func()
        WRenderSource     func(op draw.Op) composer.Source
        WRenderWidget     func()
        WShowContextMenu  func(e events.Event)
        WSizeDown         func(iter int) bool
        WSizeFinal        func()
        WSizeUp           func()
        WStyle            func()
        WWidgetTooltip    func(pos image.Point) (string, image.Point)
}

func (W _cogentcore_org_core_core_Treer) ApplyScenePos()             { W.WApplyScenePos() }
func (W _cogentcore_org_core_core_Treer) AsCoreTree() *core.Tree     { return W.WAsCoreTree() }
func (W _cogentcore_org_core_core_Treer) AsTree() *tree.NodeBase     { return W.WAsTree() }
func (W _cogentcore_org_core_core_Treer) AsWidget() *core.WidgetBase { return W.WAsWidget() }
func (W _cogentcore_org_core_core_Treer) CanOpen() bool              { return W.WCanOpen() }
func (W _cogentcore_org_core_core_Treer) ChildBackground(child core.Widget) image.Image {
        return W.WChildBackground(child)
}
func (W _cogentcore_org_core_core_Treer) ContextMenuPos(e events.Event) image.Point {
        return W.WContextMenuPos(e)
}
func (W _cogentcore_org_core_core_Treer) Copy()                           { W.WCopy() }
func (W _cogentcore_org_core_core_Treer) CopyFieldsFrom(from tree.Node)   { W.WCopyFieldsFrom(from) }
func (W _cogentcore_org_core_core_Treer) Cut()                            { W.WCut() }
func (W _cogentcore_org_core_core_Treer) Destroy()                        { W.WDestroy() }
func (W _cogentcore_org_core_core_Treer) DragDrop(e events.Event)         { W.WDragDrop(e) }
func (W _cogentcore_org_core_core_Treer) DropDeleteSource(e events.Event) { W.WDropDeleteSource(e) }
func (W _cogentcore_org_core_core_Treer) Init()                           { W.WInit() }
func (W _cogentcore_org_core_core_Treer) MimeData(md *mimedata.Mimes)     { W.WMimeData(md) }
func (W _cogentcore_org_core_core_Treer) NodeWalkDown(fun func(n tree.Node) bool) {
        W.WNodeWalkDown(fun)
}
func (W _cogentcore_org_core_core_Treer) OnAdd()           { W.WOnAdd() }
func (W _cogentcore_org_core_core_Treer) OnClose()         { W.WOnClose() }
func (W _cogentcore_org_core_core_Treer) OnOpen()          { W.WOnOpen() }
func (W _cogentcore_org_core_core_Treer) Paste()           { W.WPaste() }
func (W _cogentcore_org_core_core_Treer) PlanName() string { return W.WPlanName() }
func (W _cogentcore_org_core_core_Treer) Position()        { W.WPosition() }
func (W _cogentcore_org_core_core_Treer) Render()          { W.WRender() }
func (W _cogentcore_org_core_core_Treer) RenderSource(op draw.Op) composer.Source {
        return W.WRenderSource(op)
}
func (W _cogentcore_org_core_core_Treer) RenderWidget()                  { W.WRenderWidget() }
func (W _cogentcore_org_core_core_Treer) ShowContextMenu(e events.Event) { W.WShowContextMenu(e) }
func (W _cogentcore_org_core_core_Treer) SizeDown(iter int) bool         { return W.WSizeDown(iter) }
func (W _cogentcore_org_core_core_Treer) SizeFinal()                     { W.WSizeFinal() }
func (W _cogentcore_org_core_core_Treer) SizeUp()                        { W.WSizeUp() }
func (W _cogentcore_org_core_core_Treer) Style()                         { W.WStyle() }
func (W _cogentcore_org_core_core_Treer) WidgetTooltip(pos image.Point) (string, image.Point) {
        return W.WWidgetTooltip(pos)
}

// _cogentcore_org_core_core_Validator is an interface wrapper for Validator type
type _cogentcore_org_core_core_Validator struct {
        IValue    interface{}
        WValidate func() error
}

func (W _cogentcore_org_core_core_Validator) Validate() error { return W.WValidate() }

// _cogentcore_org_core_core_Value is an interface wrapper for Value type
type _cogentcore_org_core_core_Value struct {
        IValue           interface{}
        WApplyScenePos   func()
        WAsTree          func() *tree.NodeBase
        WAsWidget        func() *core.WidgetBase
        WChildBackground func(child core.Widget) image.Image
        WContextMenuPos  func(e events.Event) image.Point
        WCopyFieldsFrom  func(from tree.Node)
        WDestroy         func()
        WInit            func()
        WNodeWalkDown    func(fun func(n tree.Node) bool)
        WOnAdd           func()
        WPlanName        func() string
        WPosition        func()
        WRender          func()
        WRenderSource    func(op draw.Op) composer.Source
        WRenderWidget    func()
        WShowContextMenu func(e events.Event)
        WSizeDown        func(iter int) bool
        WSizeFinal       func()
        WSizeUp          func()
        WStyle           func()
        WWidgetTooltip   func(pos image.Point) (string, image.Point)
        WWidgetValue     func() any
}

func (W _cogentcore_org_core_core_Value) ApplyScenePos()             { W.WApplyScenePos() }
func (W _cogentcore_org_core_core_Value) AsTree() *tree.NodeBase     { return W.WAsTree() }
func (W _cogentcore_org_core_core_Value) AsWidget() *core.WidgetBase { return W.WAsWidget() }
func (W _cogentcore_org_core_core_Value) ChildBackground(child core.Widget) image.Image {
        return W.WChildBackground(child)
}
func (W _cogentcore_org_core_core_Value) ContextMenuPos(e events.Event) image.Point {
        return W.WContextMenuPos(e)
}
func (W _cogentcore_org_core_core_Value) CopyFieldsFrom(from tree.Node) { W.WCopyFieldsFrom(from) }
func (W _cogentcore_org_core_core_Value) Destroy()                      { W.WDestroy() }
func (W _cogentcore_org_core_core_Value) Init()                         { W.WInit() }
func (W _cogentcore_org_core_core_Value) NodeWalkDown(fun func(n tree.Node) bool) {
        W.WNodeWalkDown(fun)
}
func (W _cogentcore_org_core_core_Value) OnAdd()           { W.WOnAdd() }
func (W _cogentcore_org_core_core_Value) PlanName() string { return W.WPlanName() }
func (W _cogentcore_org_core_core_Value) Position()        { W.WPosition() }
func (W _cogentcore_org_core_core_Value) Render()          { W.WRender() }
func (W _cogentcore_org_core_core_Value) RenderSource(op draw.Op) composer.Source {
        return W.WRenderSource(op)
}
func (W _cogentcore_org_core_core_Value) RenderWidget()                  { W.WRenderWidget() }
func (W _cogentcore_org_core_core_Value) ShowContextMenu(e events.Event) { W.WShowContextMenu(e) }
func (W _cogentcore_org_core_core_Value) SizeDown(iter int) bool         { return W.WSizeDown(iter) }
func (W _cogentcore_org_core_core_Value) SizeFinal()                     { W.WSizeFinal() }
func (W _cogentcore_org_core_core_Value) SizeUp()                        { W.WSizeUp() }
func (W _cogentcore_org_core_core_Value) Style()                         { W.WStyle() }
func (W _cogentcore_org_core_core_Value) WidgetTooltip(pos image.Point) (string, image.Point) {
        return W.WWidgetTooltip(pos)
}
func (W _cogentcore_org_core_core_Value) WidgetValue() any { return W.WWidgetValue() }

// _cogentcore_org_core_core_ValueSetter is an interface wrapper for ValueSetter type
type _cogentcore_org_core_core_ValueSetter struct {
        IValue          interface{}
        WSetWidgetValue func(value any) error
}

func (W _cogentcore_org_core_core_ValueSetter) SetWidgetValue(value any) error {
        return W.WSetWidgetValue(value)
}

// _cogentcore_org_core_core_Valuer is an interface wrapper for Valuer type
type _cogentcore_org_core_core_Valuer struct {
        IValue interface{}
        WValue func() core.Value
}

func (W _cogentcore_org_core_core_Valuer) Value() core.Value { return W.WValue() }

// _cogentcore_org_core_core_Widget is an interface wrapper for Widget type
type _cogentcore_org_core_core_Widget struct {
        IValue           interface{}
        WApplyScenePos   func()
        WAsTree          func() *tree.NodeBase
        WAsWidget        func() *core.WidgetBase
        WChildBackground func(child core.Widget) image.Image
        WContextMenuPos  func(e events.Event) image.Point
        WCopyFieldsFrom  func(from tree.Node)
        WDestroy         func()
        WInit            func()
        WNodeWalkDown    func(fun func(n tree.Node) bool)
        WOnAdd           func()
        WPlanName        func() string
        WPosition        func()
        WRender          func()
        WRenderSource    func(op draw.Op) composer.Source
        WRenderWidget    func()
        WShowContextMenu func(e events.Event)
        WSizeDown        func(iter int) bool
        WSizeFinal       func()
        WSizeUp          func()
        WStyle           func()
        WWidgetTooltip   func(pos image.Point) (string, image.Point)
}

func (W _cogentcore_org_core_core_Widget) ApplyScenePos()             { W.WApplyScenePos() }
func (W _cogentcore_org_core_core_Widget) AsTree() *tree.NodeBase     { return W.WAsTree() }
func (W _cogentcore_org_core_core_Widget) AsWidget() *core.WidgetBase { return W.WAsWidget() }
func (W _cogentcore_org_core_core_Widget) ChildBackground(child core.Widget) image.Image {
        return W.WChildBackground(child)
}
func (W _cogentcore_org_core_core_Widget) ContextMenuPos(e events.Event) image.Point {
        return W.WContextMenuPos(e)
}
func (W _cogentcore_org_core_core_Widget) CopyFieldsFrom(from tree.Node) { W.WCopyFieldsFrom(from) }
func (W _cogentcore_org_core_core_Widget) Destroy()                      { W.WDestroy() }
func (W _cogentcore_org_core_core_Widget) Init()                         { W.WInit() }
func (W _cogentcore_org_core_core_Widget) NodeWalkDown(fun func(n tree.Node) bool) {
        W.WNodeWalkDown(fun)
}
func (W _cogentcore_org_core_core_Widget) OnAdd()           { W.WOnAdd() }
func (W _cogentcore_org_core_core_Widget) PlanName() string { return W.WPlanName() }
func (W _cogentcore_org_core_core_Widget) Position()        { W.WPosition() }
func (W _cogentcore_org_core_core_Widget) Render()          { W.WRender() }
func (W _cogentcore_org_core_core_Widget) RenderSource(op draw.Op) composer.Source {
        return W.WRenderSource(op)
}
func (W _cogentcore_org_core_core_Widget) RenderWidget()                  { W.WRenderWidget() }
func (W _cogentcore_org_core_core_Widget) ShowContextMenu(e events.Event) { W.WShowContextMenu(e) }
func (W _cogentcore_org_core_core_Widget) SizeDown(iter int) bool         { return W.WSizeDown(iter) }
func (W _cogentcore_org_core_core_Widget) SizeFinal()                     { W.WSizeFinal() }
func (W _cogentcore_org_core_core_Widget) SizeUp()                        { W.WSizeUp() }
func (W _cogentcore_org_core_core_Widget) Style()                         { W.WStyle() }
func (W _cogentcore_org_core_core_Widget) WidgetTooltip(pos image.Point) (string, image.Point) {
        return W.WWidgetTooltip(pos)
}

// Code generated by 'yaegi extract cogentcore.org/core/events'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/enums"
        "cogentcore.org/core/events"
        "cogentcore.org/core/events/key"
        "image"
        "reflect"
        "time"
)

func init() {
        Symbols["cogentcore.org/core/events/events"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Attend":                reflect.ValueOf(events.Attend),
                "AttendLost":            reflect.ValueOf(events.AttendLost),
                "ButtonsN":              reflect.ValueOf(events.ButtonsN),
                "ButtonsValues":         reflect.ValueOf(events.ButtonsValues),
                "Change":                reflect.ValueOf(events.Change),
                "Click":                 reflect.ValueOf(events.Click),
                "Close":                 reflect.ValueOf(events.Close),
                "ContextMenu":           reflect.ValueOf(events.ContextMenu),
                "Custom":                reflect.ValueOf(events.Custom),
                "DefaultModBits":        reflect.ValueOf(events.DefaultModBits),
                "DoubleClick":           reflect.ValueOf(events.DoubleClick),
                "DragEnter":             reflect.ValueOf(events.DragEnter),
                "DragLeave":             reflect.ValueOf(events.DragLeave),
                "DragMove":              reflect.ValueOf(events.DragMove),
                "DragStart":             reflect.ValueOf(events.DragStart),
                "Drop":                  reflect.ValueOf(events.Drop),
                "DropCopy":              reflect.ValueOf(events.DropCopy),
                "DropDeleteSource":      reflect.ValueOf(events.DropDeleteSource),
                "DropIgnore":            reflect.ValueOf(events.DropIgnore),
                "DropLink":              reflect.ValueOf(events.DropLink),
                "DropModsN":             reflect.ValueOf(events.DropModsN),
                "DropModsValues":        reflect.ValueOf(events.DropModsValues),
                "DropMove":              reflect.ValueOf(events.DropMove),
                "EventFlagsN":           reflect.ValueOf(events.EventFlagsN),
                "EventFlagsValues":      reflect.ValueOf(events.EventFlagsValues),
                "ExtendContinuous":      reflect.ValueOf(events.ExtendContinuous),
                "ExtendOne":             reflect.ValueOf(events.ExtendOne),
                "Focus":                 reflect.ValueOf(events.Focus),
                "FocusLost":             reflect.ValueOf(events.FocusLost),
                "Handled":               reflect.ValueOf(events.Handled),
                "Input":                 reflect.ValueOf(events.Input),
                "KeyChord":              reflect.ValueOf(events.KeyChord),
                "KeyDown":               reflect.ValueOf(events.KeyDown),
                "KeyUp":                 reflect.ValueOf(events.KeyUp),
                "Left":                  reflect.ValueOf(events.Left),
                "LongHoverEnd":          reflect.ValueOf(events.LongHoverEnd),
                "LongHoverStart":        reflect.ValueOf(events.LongHoverStart),
                "LongPressEnd":          reflect.ValueOf(events.LongPressEnd),
                "LongPressStart":        reflect.ValueOf(events.LongPressStart),
                "Magnify":               reflect.ValueOf(events.Magnify),
                "Middle":                reflect.ValueOf(events.Middle),
                "MouseDown":             reflect.ValueOf(events.MouseDown),
                "MouseDrag":             reflect.ValueOf(events.MouseDrag),
                "MouseEnter":            reflect.ValueOf(events.MouseEnter),
                "MouseLeave":            reflect.ValueOf(events.MouseLeave),
                "MouseMove":             reflect.ValueOf(events.MouseMove),
                "MouseUp":               reflect.ValueOf(events.MouseUp),
                "NewDragDrop":           reflect.ValueOf(events.NewDragDrop),
                "NewExternalDrop":       reflect.ValueOf(events.NewExternalDrop),
                "NewKey":                reflect.ValueOf(events.NewKey),
                "NewMagnify":            reflect.ValueOf(events.NewMagnify),
                "NewMouse":              reflect.ValueOf(events.NewMouse),
                "NewMouseDrag":          reflect.ValueOf(events.NewMouseDrag),
                "NewMouseMove":          reflect.ValueOf(events.NewMouseMove),
                "NewOSEvent":            reflect.ValueOf(events.NewOSEvent),
                "NewOSFiles":            reflect.ValueOf(events.NewOSFiles),
                "NewScroll":             reflect.ValueOf(events.NewScroll),
                "NewTouch":              reflect.ValueOf(events.NewTouch),
                "NewWindow":             reflect.ValueOf(events.NewWindow),
                "NewWindowPaint":        reflect.ValueOf(events.NewWindowPaint),
                "NewWindowResize":       reflect.ValueOf(events.NewWindowResize),
                "NoButton":              reflect.ValueOf(events.NoButton),
                "NoDropMod":             reflect.ValueOf(events.NoDropMod),
                "NoSelect":              reflect.ValueOf(events.NoSelect),
                "NoWinAction":           reflect.ValueOf(events.NoWinAction),
                "OS":                    reflect.ValueOf(events.OS),
                "OSOpenFiles":           reflect.ValueOf(events.OSOpenFiles),
                "Right":                 reflect.ValueOf(events.Right),
                "Rotate":                reflect.ValueOf(events.Rotate),
                "ScreenUpdate":          reflect.ValueOf(events.ScreenUpdate),
                "Scroll":                reflect.ValueOf(events.Scroll),
                "ScrollWheelSpeed":      reflect.ValueOf(&events.ScrollWheelSpeed).Elem(),
                "Select":                reflect.ValueOf(events.Select),
                "SelectModeBits":        reflect.ValueOf(events.SelectModeBits),
                "SelectModesN":          reflect.ValueOf(events.SelectModesN),
                "SelectModesValues":     reflect.ValueOf(events.SelectModesValues),
                "SelectOne":             reflect.ValueOf(events.SelectOne),
                "SelectQuiet":           reflect.ValueOf(events.SelectQuiet),
                "Show":                  reflect.ValueOf(events.Show),
                "SlideMove":             reflect.ValueOf(events.SlideMove),
                "SlideStart":            reflect.ValueOf(events.SlideStart),
                "SlideStop":             reflect.ValueOf(events.SlideStop),
                "TouchEnd":              reflect.ValueOf(events.TouchEnd),
                "TouchMove":             reflect.ValueOf(events.TouchMove),
                "TouchStart":            reflect.ValueOf(events.TouchStart),
                "TraceEventCompression": reflect.ValueOf(&events.TraceEventCompression).Elem(),
                "TraceWindowPaint":      reflect.ValueOf(&events.TraceWindowPaint).Elem(),
                "TripleClick":           reflect.ValueOf(events.TripleClick),
                "TypesN":                reflect.ValueOf(events.TypesN),
                "TypesValues":           reflect.ValueOf(events.TypesValues),
                "Unique":                reflect.ValueOf(events.Unique),
                "UnknownType":           reflect.ValueOf(events.UnknownType),
                "Unselect":              reflect.ValueOf(events.Unselect),
                "UnselectQuiet":         reflect.ValueOf(events.UnselectQuiet),
                "WinActionsN":           reflect.ValueOf(events.WinActionsN),
                "WinActionsValues":      reflect.ValueOf(events.WinActionsValues),
                "WinClose":              reflect.ValueOf(events.WinClose),
                "WinFocus":              reflect.ValueOf(events.WinFocus),
                "WinFocusLost":          reflect.ValueOf(events.WinFocusLost),
                "WinMinimize":           reflect.ValueOf(events.WinMinimize),
                "WinMove":               reflect.ValueOf(events.WinMove),
                "WinShow":               reflect.ValueOf(events.WinShow),
                "Window":                reflect.ValueOf(events.Window),
                "WindowPaint":           reflect.ValueOf(events.WindowPaint),
                "WindowResize":          reflect.ValueOf(events.WindowResize),

                // type definitions
                "Base":         reflect.ValueOf((*events.Base)(nil)),
                "Buttons":      reflect.ValueOf((*events.Buttons)(nil)),
                "CustomEvent":  reflect.ValueOf((*events.CustomEvent)(nil)),
                "Deque":        reflect.ValueOf((*events.Deque)(nil)),
                "DragDrop":     reflect.ValueOf((*events.DragDrop)(nil)),
                "DropMods":     reflect.ValueOf((*events.DropMods)(nil)),
                "Event":        reflect.ValueOf((*events.Event)(nil)),
                "EventFlags":   reflect.ValueOf((*events.EventFlags)(nil)),
                "Key":          reflect.ValueOf((*events.Key)(nil)),
                "Listeners":    reflect.ValueOf((*events.Listeners)(nil)),
                "Mouse":        reflect.ValueOf((*events.Mouse)(nil)),
                "MouseScroll":  reflect.ValueOf((*events.MouseScroll)(nil)),
                "OSEvent":      reflect.ValueOf((*events.OSEvent)(nil)),
                "OSFiles":      reflect.ValueOf((*events.OSFiles)(nil)),
                "SelectModes":  reflect.ValueOf((*events.SelectModes)(nil)),
                "Sequence":     reflect.ValueOf((*events.Sequence)(nil)),
                "Source":       reflect.ValueOf((*events.Source)(nil)),
                "SourceState":  reflect.ValueOf((*events.SourceState)(nil)),
                "Touch":        reflect.ValueOf((*events.Touch)(nil)),
                "TouchMagnify": reflect.ValueOf((*events.TouchMagnify)(nil)),
                "Types":        reflect.ValueOf((*events.Types)(nil)),
                "WinActions":   reflect.ValueOf((*events.WinActions)(nil)),
                "WindowEvent":  reflect.ValueOf((*events.WindowEvent)(nil)),

                // interface wrapper definitions
                "_Event": reflect.ValueOf((*_cogentcore_org_core_events_Event)(nil)),
        }
}

// _cogentcore_org_core_events_Event is an interface wrapper for Event type
type _cogentcore_org_core_events_Event struct {
        IValue           interface{}
        WAsBase          func() *events.Base
        WClearHandled    func()
        WClone           func() events.Event
        WHasAllModifiers func(mods ...enums.BitFlag) bool
        WHasAnyModifier  func(mods ...enums.BitFlag) bool
        WHasPos          func() bool
        WInit            func()
        WIsHandled       func() bool
        WIsSame          func(oth events.Event) bool
        WIsUnique        func() bool
        WKeyChord        func() key.Chord
        WKeyCode         func() key.Codes
        WKeyRune         func() rune
        WLocalOff        func() image.Point
        WModifiers       func() key.Modifiers
        WMouseButton     func() events.Buttons
        WNeedsFocus      func() bool
        WNewFromClone    func(typ events.Types) events.Event
        WPos             func() image.Point
        WPrevDelta       func() image.Point
        WPrevPos         func() image.Point
        WPrevTime        func() time.Time
        WSelectMode      func() events.SelectModes
        WSetHandled      func()
        WSetLocalOff     func(off image.Point)
        WSetTime         func()
        WSincePrev       func() time.Duration
        WSinceStart      func() time.Duration
        WStartDelta      func() image.Point
        WStartPos        func() image.Point
        WStartTime       func() time.Time
        WString          func() string
        WTime            func() time.Time
        WType            func() events.Types
        WWindowPos       func() image.Point
        WWindowPrevPos   func() image.Point
        WWindowStartPos  func() image.Point
}

func (W _cogentcore_org_core_events_Event) AsBase() *events.Base { return W.WAsBase() }
func (W _cogentcore_org_core_events_Event) ClearHandled()        { W.WClearHandled() }
func (W _cogentcore_org_core_events_Event) Clone() events.Event  { return W.WClone() }
func (W _cogentcore_org_core_events_Event) HasAllModifiers(mods ...enums.BitFlag) bool {
        return W.WHasAllModifiers(mods...)
}
func (W _cogentcore_org_core_events_Event) HasAnyModifier(mods ...enums.BitFlag) bool {
        return W.WHasAnyModifier(mods...)
}
func (W _cogentcore_org_core_events_Event) HasPos() bool                 { return W.WHasPos() }
func (W _cogentcore_org_core_events_Event) Init()                        { W.WInit() }
func (W _cogentcore_org_core_events_Event) IsHandled() bool              { return W.WIsHandled() }
func (W _cogentcore_org_core_events_Event) IsSame(oth events.Event) bool { return W.WIsSame(oth) }
func (W _cogentcore_org_core_events_Event) IsUnique() bool               { return W.WIsUnique() }
func (W _cogentcore_org_core_events_Event) KeyChord() key.Chord          { return W.WKeyChord() }
func (W _cogentcore_org_core_events_Event) KeyCode() key.Codes           { return W.WKeyCode() }
func (W _cogentcore_org_core_events_Event) KeyRune() rune                { return W.WKeyRune() }
func (W _cogentcore_org_core_events_Event) LocalOff() image.Point        { return W.WLocalOff() }
func (W _cogentcore_org_core_events_Event) Modifiers() key.Modifiers     { return W.WModifiers() }
func (W _cogentcore_org_core_events_Event) MouseButton() events.Buttons  { return W.WMouseButton() }
func (W _cogentcore_org_core_events_Event) NeedsFocus() bool             { return W.WNeedsFocus() }
func (W _cogentcore_org_core_events_Event) NewFromClone(typ events.Types) events.Event {
        return W.WNewFromClone(typ)
}
func (W _cogentcore_org_core_events_Event) Pos() image.Point               { return W.WPos() }
func (W _cogentcore_org_core_events_Event) PrevDelta() image.Point         { return W.WPrevDelta() }
func (W _cogentcore_org_core_events_Event) PrevPos() image.Point           { return W.WPrevPos() }
func (W _cogentcore_org_core_events_Event) PrevTime() time.Time            { return W.WPrevTime() }
func (W _cogentcore_org_core_events_Event) SelectMode() events.SelectModes { return W.WSelectMode() }
func (W _cogentcore_org_core_events_Event) SetHandled()                    { W.WSetHandled() }
func (W _cogentcore_org_core_events_Event) SetLocalOff(off image.Point)    { W.WSetLocalOff(off) }
func (W _cogentcore_org_core_events_Event) SetTime()                       { W.WSetTime() }
func (W _cogentcore_org_core_events_Event) SincePrev() time.Duration       { return W.WSincePrev() }
func (W _cogentcore_org_core_events_Event) SinceStart() time.Duration      { return W.WSinceStart() }
func (W _cogentcore_org_core_events_Event) StartDelta() image.Point        { return W.WStartDelta() }
func (W _cogentcore_org_core_events_Event) StartPos() image.Point          { return W.WStartPos() }
func (W _cogentcore_org_core_events_Event) StartTime() time.Time           { return W.WStartTime() }
func (W _cogentcore_org_core_events_Event) String() string {
        if W.WString == nil {
                return ""
        }
        return W.WString()
}
func (W _cogentcore_org_core_events_Event) Time() time.Time             { return W.WTime() }
func (W _cogentcore_org_core_events_Event) Type() events.Types          { return W.WType() }
func (W _cogentcore_org_core_events_Event) WindowPos() image.Point      { return W.WWindowPos() }
func (W _cogentcore_org_core_events_Event) WindowPrevPos() image.Point  { return W.WWindowPrevPos() }
func (W _cogentcore_org_core_events_Event) WindowStartPos() image.Point { return W.WWindowStartPos() }

// Code generated by 'yaegi extract cogentcore.org/core/filetree'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/base/fileinfo/mimedata"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/filetree"
        "cogentcore.org/core/system/composer"
        "cogentcore.org/core/tree"
        "image"
        "image/draw"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/filetree/filetree"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AsNode":            reflect.ValueOf(filetree.AsNode),
                "AsTree":            reflect.ValueOf(filetree.AsTree),
                "NewNode":           reflect.ValueOf(filetree.NewNode),
                "NewTree":           reflect.ValueOf(filetree.NewTree),
                "NewVCSLog":         reflect.ValueOf(filetree.NewVCSLog),
                "NodeHighlighting":  reflect.ValueOf(&filetree.NodeHighlighting).Elem(),
                "NodeNameCountSort": reflect.ValueOf(filetree.NodeNameCountSort),

                // type definitions
                "DirFlagMap":    reflect.ValueOf((*filetree.DirFlagMap)(nil)),
                "Filer":         reflect.ValueOf((*filetree.Filer)(nil)),
                "Node":          reflect.ValueOf((*filetree.Node)(nil)),
                "NodeEmbedder":  reflect.ValueOf((*filetree.NodeEmbedder)(nil)),
                "NodeNameCount": reflect.ValueOf((*filetree.NodeNameCount)(nil)),
                "Tree":          reflect.ValueOf((*filetree.Tree)(nil)),
                "Treer":         reflect.ValueOf((*filetree.Treer)(nil)),
                "VCSLog":        reflect.ValueOf((*filetree.VCSLog)(nil)),

                // interface wrapper definitions
                "_Filer":        reflect.ValueOf((*_cogentcore_org_core_filetree_Filer)(nil)),
                "_NodeEmbedder": reflect.ValueOf((*_cogentcore_org_core_filetree_NodeEmbedder)(nil)),
                "_Treer":        reflect.ValueOf((*_cogentcore_org_core_filetree_Treer)(nil)),
        }
}

// _cogentcore_org_core_filetree_Filer is an interface wrapper for Filer type
type _cogentcore_org_core_filetree_Filer struct {
        IValue            interface{}
        WApplyScenePos    func()
        WAsCoreTree       func() *core.Tree
        WAsFileNode       func() *filetree.Node
        WAsTree           func() *tree.NodeBase
        WAsWidget         func() *core.WidgetBase
        WCanOpen          func() bool
        WChildBackground  func(child core.Widget) image.Image
        WContextMenuPos   func(e events.Event) image.Point
        WCopy             func()
        WCopyFieldsFrom   func(from tree.Node)
        WCut              func()
        WDeleteFiles      func()
        WDestroy          func()
        WDragDrop         func(e events.Event)
        WDropDeleteSource func(e events.Event)
        WGetFileInfo      func() error
        WInit             func()
        WMimeData         func(md *mimedata.Mimes)
        WNodeWalkDown     func(fun func(n tree.Node) bool)
        WOnAdd            func()
        WOnClose          func()
        WOnOpen           func()
        WOpenFile         func() error
        WPaste            func()
        WPlanName         func() string
        WPosition         func()
        WRenameFiles      func()
        WRender           func()
        WRenderSource     func(op draw.Op) composer.Source
        WRenderWidget     func()
        WShowContextMenu  func(e events.Event)
        WSizeDown         func(iter int) bool
        WSizeFinal        func()
        WSizeUp           func()
        WStyle            func()
        WWidgetTooltip    func(pos image.Point) (string, image.Point)
}

func (W _cogentcore_org_core_filetree_Filer) ApplyScenePos()             { W.WApplyScenePos() }
func (W _cogentcore_org_core_filetree_Filer) AsCoreTree() *core.Tree     { return W.WAsCoreTree() }
func (W _cogentcore_org_core_filetree_Filer) AsFileNode() *filetree.Node { return W.WAsFileNode() }
func (W _cogentcore_org_core_filetree_Filer) AsTree() *tree.NodeBase     { return W.WAsTree() }
func (W _cogentcore_org_core_filetree_Filer) AsWidget() *core.WidgetBase { return W.WAsWidget() }
func (W _cogentcore_org_core_filetree_Filer) CanOpen() bool              { return W.WCanOpen() }
func (W _cogentcore_org_core_filetree_Filer) ChildBackground(child core.Widget) image.Image {
        return W.WChildBackground(child)
}
func (W _cogentcore_org_core_filetree_Filer) ContextMenuPos(e events.Event) image.Point {
        return W.WContextMenuPos(e)
}
func (W _cogentcore_org_core_filetree_Filer) Copy()                           { W.WCopy() }
func (W _cogentcore_org_core_filetree_Filer) CopyFieldsFrom(from tree.Node)   { W.WCopyFieldsFrom(from) }
func (W _cogentcore_org_core_filetree_Filer) Cut()                            { W.WCut() }
func (W _cogentcore_org_core_filetree_Filer) DeleteFiles()                    { W.WDeleteFiles() }
func (W _cogentcore_org_core_filetree_Filer) Destroy()                        { W.WDestroy() }
func (W _cogentcore_org_core_filetree_Filer) DragDrop(e events.Event)         { W.WDragDrop(e) }
func (W _cogentcore_org_core_filetree_Filer) DropDeleteSource(e events.Event) { W.WDropDeleteSource(e) }
func (W _cogentcore_org_core_filetree_Filer) GetFileInfo() error              { return W.WGetFileInfo() }
func (W _cogentcore_org_core_filetree_Filer) Init()                           { W.WInit() }
func (W _cogentcore_org_core_filetree_Filer) MimeData(md *mimedata.Mimes)     { W.WMimeData(md) }
func (W _cogentcore_org_core_filetree_Filer) NodeWalkDown(fun func(n tree.Node) bool) {
        W.WNodeWalkDown(fun)
}
func (W _cogentcore_org_core_filetree_Filer) OnAdd()           { W.WOnAdd() }
func (W _cogentcore_org_core_filetree_Filer) OnClose()         { W.WOnClose() }
func (W _cogentcore_org_core_filetree_Filer) OnOpen()          { W.WOnOpen() }
func (W _cogentcore_org_core_filetree_Filer) OpenFile() error  { return W.WOpenFile() }
func (W _cogentcore_org_core_filetree_Filer) Paste()           { W.WPaste() }
func (W _cogentcore_org_core_filetree_Filer) PlanName() string { return W.WPlanName() }
func (W _cogentcore_org_core_filetree_Filer) Position()        { W.WPosition() }
func (W _cogentcore_org_core_filetree_Filer) RenameFiles()     { W.WRenameFiles() }
func (W _cogentcore_org_core_filetree_Filer) Render()          { W.WRender() }
func (W _cogentcore_org_core_filetree_Filer) RenderSource(op draw.Op) composer.Source {
        return W.WRenderSource(op)
}
func (W _cogentcore_org_core_filetree_Filer) RenderWidget()                  { W.WRenderWidget() }
func (W _cogentcore_org_core_filetree_Filer) ShowContextMenu(e events.Event) { W.WShowContextMenu(e) }
func (W _cogentcore_org_core_filetree_Filer) SizeDown(iter int) bool         { return W.WSizeDown(iter) }
func (W _cogentcore_org_core_filetree_Filer) SizeFinal()                     { W.WSizeFinal() }
func (W _cogentcore_org_core_filetree_Filer) SizeUp()                        { W.WSizeUp() }
func (W _cogentcore_org_core_filetree_Filer) Style()                         { W.WStyle() }
func (W _cogentcore_org_core_filetree_Filer) WidgetTooltip(pos image.Point) (string, image.Point) {
        return W.WWidgetTooltip(pos)
}

// _cogentcore_org_core_filetree_NodeEmbedder is an interface wrapper for NodeEmbedder type
type _cogentcore_org_core_filetree_NodeEmbedder struct {
        IValue  interface{}
        WAsNode func() *filetree.Node
}

func (W _cogentcore_org_core_filetree_NodeEmbedder) AsNode() *filetree.Node { return W.WAsNode() }

// _cogentcore_org_core_filetree_Treer is an interface wrapper for Treer type
type _cogentcore_org_core_filetree_Treer struct {
        IValue      interface{}
        WAsFileTree func() *filetree.Tree
}

func (W _cogentcore_org_core_filetree_Treer) AsFileTree() *filetree.Tree { return W.WAsFileTree() }

// Code generated by 'yaegi extract cogentcore.org/core/htmlcore'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/htmlcore"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/htmlcore/htmlcore"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "BindTextEditor": reflect.ValueOf(&htmlcore.BindTextEditor).Elem(),
                "ExtractText":    reflect.ValueOf(htmlcore.ExtractText),
                "Get":            reflect.ValueOf(htmlcore.Get),
                "GetAttr":        reflect.ValueOf(htmlcore.GetAttr),
                "GetURLFromFS":   reflect.ValueOf(htmlcore.GetURLFromFS),
                "GoDocWikilink":  reflect.ValueOf(htmlcore.GoDocWikilink),
                "HasAttr":        reflect.ValueOf(htmlcore.HasAttr),
                "MDGetAttr":      reflect.ValueOf(htmlcore.MDGetAttr),
                "MDSetAttr":      reflect.ValueOf(htmlcore.MDSetAttr),
                "NewContext":     reflect.ValueOf(htmlcore.NewContext),
                "ReadHTML":       reflect.ValueOf(htmlcore.ReadHTML),
                "ReadHTMLString": reflect.ValueOf(htmlcore.ReadHTMLString),
                "ReadMD":         reflect.ValueOf(htmlcore.ReadMD),
                "ReadMDString":   reflect.ValueOf(htmlcore.ReadMDString),

                // type definitions
                "Context":         reflect.ValueOf((*htmlcore.Context)(nil)),
                "WikilinkHandler": reflect.ValueOf((*htmlcore.WikilinkHandler)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/keymap'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/keymap"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/keymap/keymap"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Abort":            reflect.ValueOf(keymap.Abort),
                "Accept":           reflect.ValueOf(keymap.Accept),
                "ActiveMap":        reflect.ValueOf(&keymap.ActiveMap).Elem(),
                "ActiveMapName":    reflect.ValueOf(&keymap.ActiveMapName).Elem(),
                "AvailableMaps":    reflect.ValueOf(&keymap.AvailableMaps).Elem(),
                "Backspace":        reflect.ValueOf(keymap.Backspace),
                "BackspaceWord":    reflect.ValueOf(keymap.BackspaceWord),
                "CancelSelect":     reflect.ValueOf(keymap.CancelSelect),
                "CloseAlt1":        reflect.ValueOf(keymap.CloseAlt1),
                "CloseAlt2":        reflect.ValueOf(keymap.CloseAlt2),
                "Complete":         reflect.ValueOf(keymap.Complete),
                "Copy":             reflect.ValueOf(keymap.Copy),
                "Cut":              reflect.ValueOf(keymap.Cut),
                "DefaultMap":       reflect.ValueOf(&keymap.DefaultMap).Elem(),
                "Delete":           reflect.ValueOf(keymap.Delete),
                "DeleteWord":       reflect.ValueOf(keymap.DeleteWord),
                "DocEnd":           reflect.ValueOf(keymap.DocEnd),
                "DocHome":          reflect.ValueOf(keymap.DocHome),
                "Duplicate":        reflect.ValueOf(keymap.Duplicate),
                "End":              reflect.ValueOf(keymap.End),
                "Enter":            reflect.ValueOf(keymap.Enter),
                "Find":             reflect.ValueOf(keymap.Find),
                "FocusNext":        reflect.ValueOf(keymap.FocusNext),
                "FocusPrev":        reflect.ValueOf(keymap.FocusPrev),
                "FunctionsN":       reflect.ValueOf(keymap.FunctionsN),
                "FunctionsValues":  reflect.ValueOf(keymap.FunctionsValues),
                "HistNext":         reflect.ValueOf(keymap.HistNext),
                "HistPrev":         reflect.ValueOf(keymap.HistPrev),
                "Home":             reflect.ValueOf(keymap.Home),
                "Insert":           reflect.ValueOf(keymap.Insert),
                "InsertAfter":      reflect.ValueOf(keymap.InsertAfter),
                "Jump":             reflect.ValueOf(keymap.Jump),
                "Kill":             reflect.ValueOf(keymap.Kill),
                "Lookup":           reflect.ValueOf(keymap.Lookup),
                "Menu":             reflect.ValueOf(keymap.Menu),
                "MoveDown":         reflect.ValueOf(keymap.MoveDown),
                "MoveLeft":         reflect.ValueOf(keymap.MoveLeft),
                "MoveRight":        reflect.ValueOf(keymap.MoveRight),
                "MoveUp":           reflect.ValueOf(keymap.MoveUp),
                "MultiA":           reflect.ValueOf(keymap.MultiA),
                "MultiB":           reflect.ValueOf(keymap.MultiB),
                "New":              reflect.ValueOf(keymap.New),
                "NewAlt1":          reflect.ValueOf(keymap.NewAlt1),
                "NewAlt2":          reflect.ValueOf(keymap.NewAlt2),
                "None":             reflect.ValueOf(keymap.None),
                "Of":               reflect.ValueOf(keymap.Of),
                "Open":             reflect.ValueOf(keymap.Open),
                "OpenAlt1":         reflect.ValueOf(keymap.OpenAlt1),
                "OpenAlt2":         reflect.ValueOf(keymap.OpenAlt2),
                "PageDown":         reflect.ValueOf(keymap.PageDown),
                "PageUp":           reflect.ValueOf(keymap.PageUp),
                "Paste":            reflect.ValueOf(keymap.Paste),
                "PasteHist":        reflect.ValueOf(keymap.PasteHist),
                "Recenter":         reflect.ValueOf(keymap.Recenter),
                "Redo":             reflect.ValueOf(keymap.Redo),
                "Refresh":          reflect.ValueOf(keymap.Refresh),
                "Replace":          reflect.ValueOf(keymap.Replace),
                "Save":             reflect.ValueOf(keymap.Save),
                "SaveAlt":          reflect.ValueOf(keymap.SaveAlt),
                "SaveAs":           reflect.ValueOf(keymap.SaveAs),
                "Search":           reflect.ValueOf(keymap.Search),
                "SelectAll":        reflect.ValueOf(keymap.SelectAll),
                "SelectMode":       reflect.ValueOf(keymap.SelectMode),
                "SetActiveMap":     reflect.ValueOf(keymap.SetActiveMap),
                "SetActiveMapName": reflect.ValueOf(keymap.SetActiveMapName),
                "StandardMaps":     reflect.ValueOf(&keymap.StandardMaps).Elem(),
                "Transpose":        reflect.ValueOf(keymap.Transpose),
                "TransposeWord":    reflect.ValueOf(keymap.TransposeWord),
                "Undo":             reflect.ValueOf(keymap.Undo),
                "WinClose":         reflect.ValueOf(keymap.WinClose),
                "WinFocusNext":     reflect.ValueOf(keymap.WinFocusNext),
                "WinSnapshot":      reflect.ValueOf(keymap.WinSnapshot),
                "WordLeft":         reflect.ValueOf(keymap.WordLeft),
                "WordRight":        reflect.ValueOf(keymap.WordRight),
                "ZoomIn":           reflect.ValueOf(keymap.ZoomIn),
                "ZoomOut":          reflect.ValueOf(keymap.ZoomOut),

                // type definitions
                "Functions": reflect.ValueOf((*keymap.Functions)(nil)),
                "Map":       reflect.ValueOf((*keymap.Map)(nil)),
                "MapItem":   reflect.ValueOf((*keymap.MapItem)(nil)),
                "MapName":   reflect.ValueOf((*keymap.MapName)(nil)),
                "Maps":      reflect.ValueOf((*keymap.Maps)(nil)),
                "MapsItem":  reflect.ValueOf((*keymap.MapsItem)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/paint'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/paint"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/paint/paint"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "ClampBorderRadius": reflect.ValueOf(paint.ClampBorderRadius),
                "EdgeBlurFactors":   reflect.ValueOf(paint.EdgeBlurFactors),
                "NewImageRenderer":  reflect.ValueOf(&paint.NewImageRenderer).Elem(),
                "NewPainter":        reflect.ValueOf(paint.NewPainter),
                "NewSVGRenderer":    reflect.ValueOf(&paint.NewSVGRenderer).Elem(),
                "NewSourceRenderer": reflect.ValueOf(&paint.NewSourceRenderer).Elem(),
                "RenderToImage":     reflect.ValueOf(paint.RenderToImage),
                "RenderToSVG":       reflect.ValueOf(paint.RenderToSVG),

                // type definitions
                "Painter": reflect.ValueOf((*paint.Painter)(nil)),
                "State":   reflect.ValueOf((*paint.State)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/styles/abilities'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/styles/abilities"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/styles/abilities/abilities"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AbilitiesN":           reflect.ValueOf(abilities.AbilitiesN),
                "AbilitiesValues":      reflect.ValueOf(abilities.AbilitiesValues),
                "Activatable":          reflect.ValueOf(abilities.Activatable),
                "Checkable":            reflect.ValueOf(abilities.Checkable),
                "Clickable":            reflect.ValueOf(abilities.Clickable),
                "DoubleClickable":      reflect.ValueOf(abilities.DoubleClickable),
                "Draggable":            reflect.ValueOf(abilities.Draggable),
                "Droppable":            reflect.ValueOf(abilities.Droppable),
                "Focusable":            reflect.ValueOf(abilities.Focusable),
                "Hoverable":            reflect.ValueOf(abilities.Hoverable),
                "LongHoverable":        reflect.ValueOf(abilities.LongHoverable),
                "LongPressable":        reflect.ValueOf(abilities.LongPressable),
                "Pressable":            reflect.ValueOf(&abilities.Pressable).Elem(),
                "RepeatClickable":      reflect.ValueOf(abilities.RepeatClickable),
                "Scrollable":           reflect.ValueOf(abilities.Scrollable),
                "ScrollableUnattended": reflect.ValueOf(abilities.ScrollableUnattended),
                "Selectable":           reflect.ValueOf(abilities.Selectable),
                "Slideable":            reflect.ValueOf(abilities.Slideable),
                "TripleClickable":      reflect.ValueOf(abilities.TripleClickable),

                // type definitions
                "Abilities": reflect.ValueOf((*abilities.Abilities)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/styles/states'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/styles/states"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/styles/states/states"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Active":        reflect.ValueOf(states.Active),
                "Attended":      reflect.ValueOf(states.Attended),
                "Checked":       reflect.ValueOf(states.Checked),
                "Disabled":      reflect.ValueOf(states.Disabled),
                "DragHovered":   reflect.ValueOf(states.DragHovered),
                "Dragging":      reflect.ValueOf(states.Dragging),
                "Focused":       reflect.ValueOf(states.Focused),
                "Hovered":       reflect.ValueOf(states.Hovered),
                "Indeterminate": reflect.ValueOf(states.Indeterminate),
                "Invisible":     reflect.ValueOf(states.Invisible),
                "LongHovered":   reflect.ValueOf(states.LongHovered),
                "LongPressed":   reflect.ValueOf(states.LongPressed),
                "ReadOnly":      reflect.ValueOf(states.ReadOnly),
                "Selected":      reflect.ValueOf(states.Selected),
                "Sliding":       reflect.ValueOf(states.Sliding),
                "StatesN":       reflect.ValueOf(states.StatesN),
                "StatesValues":  reflect.ValueOf(states.StatesValues),

                // type definitions
                "States": reflect.ValueOf((*states.States)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/styles/units'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/styles/units"
        "go/constant"
        "go/token"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/styles/units/units"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Ch":            reflect.ValueOf(units.Ch),
                "Cm":            reflect.ValueOf(units.Cm),
                "CmPerInch":     reflect.ValueOf(constant.MakeFromLiteral("2.539999999999999999965305530480463858111761510372161865234375", token.FLOAT, 0)),
                "Custom":        reflect.ValueOf(units.Custom),
                "Dot":           reflect.ValueOf(units.Dot),
                "Dp":            reflect.ValueOf(units.Dp),
                "DpPerInch":     reflect.ValueOf(constant.MakeFromLiteral("160", token.INT, 0)),
                "Eh":            reflect.ValueOf(units.Eh),
                "Em":            reflect.ValueOf(units.Em),
                "Ew":            reflect.ValueOf(units.Ew),
                "Ex":            reflect.ValueOf(units.Ex),
                "In":            reflect.ValueOf(units.In),
                "Mm":            reflect.ValueOf(units.Mm),
                "MmPerInch":     reflect.ValueOf(constant.MakeFromLiteral("25.39999999999999999965305530480463858111761510372161865234375", token.FLOAT, 0)),
                "New":           reflect.ValueOf(units.New),
                "Pc":            reflect.ValueOf(units.Pc),
                "PcPerInch":     reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
                "Ph":            reflect.ValueOf(units.Ph),
                "Pt":            reflect.ValueOf(units.Pt),
                "PtPerInch":     reflect.ValueOf(constant.MakeFromLiteral("72", token.INT, 0)),
                "Pw":            reflect.ValueOf(units.Pw),
                "Px":            reflect.ValueOf(units.Px),
                "PxPerInch":     reflect.ValueOf(constant.MakeFromLiteral("96", token.INT, 0)),
                "Q":             reflect.ValueOf(units.Q),
                "Rem":           reflect.ValueOf(units.Rem),
                "StringToValue": reflect.ValueOf(units.StringToValue),
                "UnitCh":        reflect.ValueOf(units.UnitCh),
                "UnitCm":        reflect.ValueOf(units.UnitCm),
                "UnitDot":       reflect.ValueOf(units.UnitDot),
                "UnitDp":        reflect.ValueOf(units.UnitDp),
                "UnitEh":        reflect.ValueOf(units.UnitEh),
                "UnitEm":        reflect.ValueOf(units.UnitEm),
                "UnitEw":        reflect.ValueOf(units.UnitEw),
                "UnitEx":        reflect.ValueOf(units.UnitEx),
                "UnitIn":        reflect.ValueOf(units.UnitIn),
                "UnitMm":        reflect.ValueOf(units.UnitMm),
                "UnitPc":        reflect.ValueOf(units.UnitPc),
                "UnitPh":        reflect.ValueOf(units.UnitPh),
                "UnitPt":        reflect.ValueOf(units.UnitPt),
                "UnitPw":        reflect.ValueOf(units.UnitPw),
                "UnitPx":        reflect.ValueOf(units.UnitPx),
                "UnitQ":         reflect.ValueOf(units.UnitQ),
                "UnitRem":       reflect.ValueOf(units.UnitRem),
                "UnitVh":        reflect.ValueOf(units.UnitVh),
                "UnitVmax":      reflect.ValueOf(units.UnitVmax),
                "UnitVmin":      reflect.ValueOf(units.UnitVmin),
                "UnitVw":        reflect.ValueOf(units.UnitVw),
                "UnitsN":        reflect.ValueOf(units.UnitsN),
                "UnitsValues":   reflect.ValueOf(units.UnitsValues),
                "Vh":            reflect.ValueOf(units.Vh),
                "Vmax":          reflect.ValueOf(units.Vmax),
                "Vmin":          reflect.ValueOf(units.Vmin),
                "Vw":            reflect.ValueOf(units.Vw),
                "Zero":          reflect.ValueOf(units.Zero),

                // type definitions
                "Context": reflect.ValueOf((*units.Context)(nil)),
                "Units":   reflect.ValueOf((*units.Units)(nil)),
                "Value":   reflect.ValueOf((*units.Value)(nil)),
                "XY":      reflect.ValueOf((*units.XY)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/styles'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/styles"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/styles/styles"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AlignFactor":               reflect.ValueOf(styles.AlignFactor),
                "AlignPos":                  reflect.ValueOf(styles.AlignPos),
                "AlignsN":                   reflect.ValueOf(styles.AlignsN),
                "AlignsValues":              reflect.ValueOf(styles.AlignsValues),
                "Auto":                      reflect.ValueOf(styles.Auto),
                "Baseline":                  reflect.ValueOf(styles.Baseline),
                "BorderDashed":              reflect.ValueOf(styles.BorderDashed),
                "BorderDotted":              reflect.ValueOf(styles.BorderDotted),
                "BorderDouble":              reflect.ValueOf(styles.BorderDouble),
                "BorderGroove":              reflect.ValueOf(styles.BorderGroove),
                "BorderInset":               reflect.ValueOf(styles.BorderInset),
                "BorderNone":                reflect.ValueOf(styles.BorderNone),
                "BorderOutset":              reflect.ValueOf(styles.BorderOutset),
                "BorderRadiusExtraLarge":    reflect.ValueOf(&styles.BorderRadiusExtraLarge).Elem(),
                "BorderRadiusExtraLargeTop": reflect.ValueOf(&styles.BorderRadiusExtraLargeTop).Elem(),
                "BorderRadiusExtraSmall":    reflect.ValueOf(&styles.BorderRadiusExtraSmall).Elem(),
                "BorderRadiusExtraSmallTop": reflect.ValueOf(&styles.BorderRadiusExtraSmallTop).Elem(),
                "BorderRadiusFull":          reflect.ValueOf(&styles.BorderRadiusFull).Elem(),
                "BorderRadiusLarge":         reflect.ValueOf(&styles.BorderRadiusLarge).Elem(),
                "BorderRadiusLargeEnd":      reflect.ValueOf(&styles.BorderRadiusLargeEnd).Elem(),
                "BorderRadiusLargeTop":      reflect.ValueOf(&styles.BorderRadiusLargeTop).Elem(),
                "BorderRadiusMedium":        reflect.ValueOf(&styles.BorderRadiusMedium).Elem(),
                "BorderRadiusSmall":         reflect.ValueOf(&styles.BorderRadiusSmall).Elem(),
                "BorderRidge":               reflect.ValueOf(styles.BorderRidge),
                "BorderSolid":               reflect.ValueOf(styles.BorderSolid),
                "BorderStylesN":             reflect.ValueOf(styles.BorderStylesN),
                "BorderStylesValues":        reflect.ValueOf(styles.BorderStylesValues),
                "BoxShadow0":                reflect.ValueOf(styles.BoxShadow0),
                "BoxShadow1":                reflect.ValueOf(styles.BoxShadow1),
                "BoxShadow2":                reflect.ValueOf(styles.BoxShadow2),
                "BoxShadow3":                reflect.ValueOf(styles.BoxShadow3),
                "BoxShadow4":                reflect.ValueOf(styles.BoxShadow4),
                "BoxShadow5":                reflect.ValueOf(styles.BoxShadow5),
                "BoxShadowMargin":           reflect.ValueOf(styles.BoxShadowMargin),
                "Center":                    reflect.ValueOf(styles.Center),
                "ClampMax":                  reflect.ValueOf(styles.ClampMax),
                "ClampMaxVector":            reflect.ValueOf(styles.ClampMaxVector),
                "ClampMin":                  reflect.ValueOf(styles.ClampMin),
                "ClampMinVector":            reflect.ValueOf(styles.ClampMinVector),
                "Column":                    reflect.ValueOf(styles.Column),
                "Custom":                    reflect.ValueOf(styles.Custom),
                "DefaultScrollbarWidth":     reflect.ValueOf(&styles.DefaultScrollbarWidth).Elem(),
                "DirectionsN":               reflect.ValueOf(styles.DirectionsN),
                "DirectionsValues":          reflect.ValueOf(styles.DirectionsValues),
                "DisplayNone":               reflect.ValueOf(styles.DisplayNone),
                "DisplaysN":                 reflect.ValueOf(styles.DisplaysN),
                "DisplaysValues":            reflect.ValueOf(styles.DisplaysValues),
                "End":                       reflect.ValueOf(styles.End),
                "FitContain":                reflect.ValueOf(styles.FitContain),
                "FitCover":                  reflect.ValueOf(styles.FitCover),
                "FitFill":                   reflect.ValueOf(styles.FitFill),
                "FitNone":                   reflect.ValueOf(styles.FitNone),
                "FitScaleDown":              reflect.ValueOf(styles.FitScaleDown),
                "Flex":                      reflect.ValueOf(styles.Flex),
                "FontSizePoints":            reflect.ValueOf(&styles.FontSizePoints).Elem(),
                "Grid":                      reflect.ValueOf(styles.Grid),
                "ItemAlign":                 reflect.ValueOf(styles.ItemAlign),
                "KeyboardEmail":             reflect.ValueOf(styles.KeyboardEmail),
                "KeyboardMultiLine":         reflect.ValueOf(styles.KeyboardMultiLine),
                "KeyboardNone":              reflect.ValueOf(styles.KeyboardNone),
                "KeyboardNumber":            reflect.ValueOf(styles.KeyboardNumber),
                "KeyboardPassword":          reflect.ValueOf(styles.KeyboardPassword),
                "KeyboardPhone":             reflect.ValueOf(styles.KeyboardPhone),
                "KeyboardSingleLine":        reflect.ValueOf(styles.KeyboardSingleLine),
                "KeyboardURL":               reflect.ValueOf(styles.KeyboardURL),
                "NewPaint":                  reflect.ValueOf(styles.NewPaint),
                "NewPaintWithContext":       reflect.ValueOf(styles.NewPaintWithContext),
                "NewStyle":                  reflect.ValueOf(styles.NewStyle),
                "ObjectFitsN":               reflect.ValueOf(styles.ObjectFitsN),
                "ObjectFitsValues":          reflect.ValueOf(styles.ObjectFitsValues),
                "ObjectSizeFromFit":         reflect.ValueOf(styles.ObjectSizeFromFit),
                "OverflowAuto":              reflect.ValueOf(styles.OverflowAuto),
                "OverflowHidden":            reflect.ValueOf(styles.OverflowHidden),
                "OverflowScroll":            reflect.ValueOf(styles.OverflowScroll),
                "OverflowVisible":           reflect.ValueOf(styles.OverflowVisible),
                "OverflowsN":                reflect.ValueOf(styles.OverflowsN),
                "OverflowsValues":           reflect.ValueOf(styles.OverflowsValues),
                "Row":                       reflect.ValueOf(styles.Row),
                "SetClampMax":               reflect.ValueOf(styles.SetClampMax),
                "SetClampMaxVector":         reflect.ValueOf(styles.SetClampMaxVector),
                "SetClampMin":               reflect.ValueOf(styles.SetClampMin),
                "SetClampMinVector":         reflect.ValueOf(styles.SetClampMinVector),
                "SpaceAround":               reflect.ValueOf(styles.SpaceAround),
                "SpaceBetween":              reflect.ValueOf(styles.SpaceBetween),
                "SpaceEvenly":               reflect.ValueOf(styles.SpaceEvenly),
                "Stacked":                   reflect.ValueOf(styles.Stacked),
                "Start":                     reflect.ValueOf(styles.Start),
                "StyleDefault":              reflect.ValueOf(&styles.StyleDefault).Elem(),
                "SubProperties":             reflect.ValueOf(styles.SubProperties),
                "ToCSS":                     reflect.ValueOf(styles.ToCSS),
                "VirtualKeyboardsN":         reflect.ValueOf(styles.VirtualKeyboardsN),
                "VirtualKeyboardsValues":    reflect.ValueOf(styles.VirtualKeyboardsValues),

                // type definitions
                "AlignSet":         reflect.ValueOf((*styles.AlignSet)(nil)),
                "Aligns":           reflect.ValueOf((*styles.Aligns)(nil)),
                "Border":           reflect.ValueOf((*styles.Border)(nil)),
                "BorderStyles":     reflect.ValueOf((*styles.BorderStyles)(nil)),
                "Directions":       reflect.ValueOf((*styles.Directions)(nil)),
                "Displays":         reflect.ValueOf((*styles.Displays)(nil)),
                "Fill":             reflect.ValueOf((*styles.Fill)(nil)),
                "Font":             reflect.ValueOf((*styles.Font)(nil)),
                "ObjectFits":       reflect.ValueOf((*styles.ObjectFits)(nil)),
                "Overflows":        reflect.ValueOf((*styles.Overflows)(nil)),
                "Paint":            reflect.ValueOf((*styles.Paint)(nil)),
                "Path":             reflect.ValueOf((*styles.Path)(nil)),
                "Shadow":           reflect.ValueOf((*styles.Shadow)(nil)),
                "Stroke":           reflect.ValueOf((*styles.Stroke)(nil)),
                "Style":            reflect.ValueOf((*styles.Style)(nil)),
                "Text":             reflect.ValueOf((*styles.Text)(nil)),
                "VirtualKeyboards": reflect.ValueOf((*styles.VirtualKeyboards)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/text/lines'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/text/lines"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/text/lines/lines"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "ApplyOneDiff":           reflect.ValueOf(lines.ApplyOneDiff),
                "BytesToLineStrings":     reflect.ValueOf(lines.BytesToLineStrings),
                "CountWordsLines":        reflect.ValueOf(lines.CountWordsLines),
                "CountWordsLinesRegion":  reflect.ValueOf(lines.CountWordsLinesRegion),
                "DiffLines":              reflect.ValueOf(lines.DiffLines),
                "DiffLinesUnified":       reflect.ValueOf(lines.DiffLinesUnified),
                "DiffOpReverse":          reflect.ValueOf(lines.DiffOpReverse),
                "DiffOpString":           reflect.ValueOf(lines.DiffOpString),
                "FileBytes":              reflect.ValueOf(lines.FileBytes),
                "FileRegionBytes":        reflect.ValueOf(lines.FileRegionBytes),
                "KnownComments":          reflect.ValueOf(lines.KnownComments),
                "NewDiffSelected":        reflect.ValueOf(lines.NewDiffSelected),
                "NewLines":               reflect.ValueOf(lines.NewLines),
                "NewLinesFromBytes":      reflect.ValueOf(lines.NewLinesFromBytes),
                "NextSpace":              reflect.ValueOf(lines.NextSpace),
                "PreCommentStart":        reflect.ValueOf(lines.PreCommentStart),
                "ReplaceMatchCase":       reflect.ValueOf(lines.ReplaceMatchCase),
                "ReplaceNoMatchCase":     reflect.ValueOf(lines.ReplaceNoMatchCase),
                "StringLinesToByteLines": reflect.ValueOf(lines.StringLinesToByteLines),
                "UndoGroupDelay":         reflect.ValueOf(&lines.UndoGroupDelay).Elem(),
                "UndoTrace":              reflect.ValueOf(&lines.UndoTrace).Elem(),

                // type definitions
                "DiffSelectData": reflect.ValueOf((*lines.DiffSelectData)(nil)),
                "DiffSelected":   reflect.ValueOf((*lines.DiffSelected)(nil)),
                "Diffs":          reflect.ValueOf((*lines.Diffs)(nil)),
                "Lines":          reflect.ValueOf((*lines.Lines)(nil)),
                "Patch":          reflect.ValueOf((*lines.Patch)(nil)),
                "PatchRec":       reflect.ValueOf((*lines.PatchRec)(nil)),
                "Settings":       reflect.ValueOf((*lines.Settings)(nil)),
                "Undo":           reflect.ValueOf((*lines.Undo)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/text/rich'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/text/rich"
        "go/constant"
        "go/token"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/text/rich/rich"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AddFamily":          reflect.ValueOf(rich.AddFamily),
                "BTT":                reflect.ValueOf(rich.BTT),
                "Background":         reflect.ValueOf(rich.Background),
                "Black":              reflect.ValueOf(rich.Black),
                "Bold":               reflect.ValueOf(rich.Bold),
                "ColorFromRune":      reflect.ValueOf(rich.ColorFromRune),
                "ColorToRune":        reflect.ValueOf(rich.ColorToRune),
                "Condensed":          reflect.ValueOf(rich.Condensed),
                "Cursive":            reflect.ValueOf(rich.Cursive),
                "Custom":             reflect.ValueOf(rich.Custom),
                "DecorationMask":     reflect.ValueOf(constant.MakeFromLiteral("2047", token.INT, 0)),
                "DecorationStart":    reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
                "DecorationsN":       reflect.ValueOf(rich.DecorationsN),
                "DecorationsValues":  reflect.ValueOf(rich.DecorationsValues),
                "Default":            reflect.ValueOf(rich.Default),
                "DefaultSettings":    reflect.ValueOf(&rich.DefaultSettings).Elem(),
                "DirectionMask":      reflect.ValueOf(constant.MakeFromLiteral("4026531840", token.INT, 0)),
                "DirectionStart":     reflect.ValueOf(constant.MakeFromLiteral("28", token.INT, 0)),
                "DirectionsN":        reflect.ValueOf(rich.DirectionsN),
                "DirectionsValues":   reflect.ValueOf(rich.DirectionsValues),
                "DottedUnderline":    reflect.ValueOf(rich.DottedUnderline),
                "Emoji":              reflect.ValueOf(rich.Emoji),
                "End":                reflect.ValueOf(rich.End),
                "Expanded":           reflect.ValueOf(rich.Expanded),
                "ExtraBold":          reflect.ValueOf(rich.ExtraBold),
                "ExtraCondensed":     reflect.ValueOf(rich.ExtraCondensed),
                "ExtraExpanded":      reflect.ValueOf(rich.ExtraExpanded),
                "ExtraLight":         reflect.ValueOf(rich.ExtraLight),
                "FamiliesToList":     reflect.ValueOf(rich.FamiliesToList),
                "FamilyMask":         reflect.ValueOf(constant.MakeFromLiteral("251658240", token.INT, 0)),
                "FamilyN":            reflect.ValueOf(rich.FamilyN),
                "FamilyStart":        reflect.ValueOf(constant.MakeFromLiteral("24", token.INT, 0)),
                "FamilyValues":       reflect.ValueOf(rich.FamilyValues),
                "Fangsong":           reflect.ValueOf(rich.Fangsong),
                "Fantasy":            reflect.ValueOf(rich.Fantasy),
                "FillColor":          reflect.ValueOf(rich.FillColor),
                "FontSizes":          reflect.ValueOf(&rich.FontSizes).Elem(),
                "Italic":             reflect.ValueOf(rich.Italic),
                "Join":               reflect.ValueOf(rich.Join),
                "LTR":                reflect.ValueOf(rich.LTR),
                "Light":              reflect.ValueOf(rich.Light),
                "LineThrough":        reflect.ValueOf(rich.LineThrough),
                "Link":               reflect.ValueOf(rich.Link),
                "Math":               reflect.ValueOf(rich.Math),
                "MathDisplay":        reflect.ValueOf(rich.MathDisplay),
                "MathInline":         reflect.ValueOf(rich.MathInline),
                "Medium":             reflect.ValueOf(rich.Medium),
                "Monospace":          reflect.ValueOf(rich.Monospace),
                "NewPlainText":       reflect.ValueOf(rich.NewPlainText),
                "NewStyle":           reflect.ValueOf(rich.NewStyle),
                "NewStyleFromRunes":  reflect.ValueOf(rich.NewStyleFromRunes),
                "NewText":            reflect.ValueOf(rich.NewText),
                "Normal":             reflect.ValueOf(rich.Normal),
                "Nothing":            reflect.ValueOf(rich.Nothing),
                "Overline":           reflect.ValueOf(rich.Overline),
                "ParagraphStart":     reflect.ValueOf(rich.ParagraphStart),
                "Quote":              reflect.ValueOf(rich.Quote),
                "RTL":                reflect.ValueOf(rich.RTL),
                "RuneFromDecoration": reflect.ValueOf(rich.RuneFromDecoration),
                "RuneFromDirection":  reflect.ValueOf(rich.RuneFromDirection),
                "RuneFromFamily":     reflect.ValueOf(rich.RuneFromFamily),
                "RuneFromSlant":      reflect.ValueOf(rich.RuneFromSlant),
                "RuneFromSpecial":    reflect.ValueOf(rich.RuneFromSpecial),
                "RuneFromStretch":    reflect.ValueOf(rich.RuneFromStretch),
                "RuneFromStyle":      reflect.ValueOf(rich.RuneFromStyle),
                "RuneFromWeight":     reflect.ValueOf(rich.RuneFromWeight),
                "RuneToDecoration":   reflect.ValueOf(rich.RuneToDecoration),
                "RuneToDirection":    reflect.ValueOf(rich.RuneToDirection),
                "RuneToFamily":       reflect.ValueOf(rich.RuneToFamily),
                "RuneToSlant":        reflect.ValueOf(rich.RuneToSlant),
                "RuneToSpecial":      reflect.ValueOf(rich.RuneToSpecial),
                "RuneToStretch":      reflect.ValueOf(rich.RuneToStretch),
                "RuneToStyle":        reflect.ValueOf(rich.RuneToStyle),
                "RuneToWeight":       reflect.ValueOf(rich.RuneToWeight),
                "SansSerif":          reflect.ValueOf(rich.SansSerif),
                "SemiCondensed":      reflect.ValueOf(rich.SemiCondensed),
                "SemiExpanded":       reflect.ValueOf(rich.SemiExpanded),
                "Semibold":           reflect.ValueOf(rich.Semibold),
                "Serif":              reflect.ValueOf(rich.Serif),
                "SlantMask":          reflect.ValueOf(constant.MakeFromLiteral("2048", token.INT, 0)),
                "SlantNormal":        reflect.ValueOf(rich.SlantNormal),
                "SlantStart":         reflect.ValueOf(constant.MakeFromLiteral("11", token.INT, 0)),
                "SlantsN":            reflect.ValueOf(rich.SlantsN),
                "SlantsValues":       reflect.ValueOf(rich.SlantsValues),
                "SpanLen":            reflect.ValueOf(rich.SpanLen),
                "SpecialMask":        reflect.ValueOf(constant.MakeFromLiteral("61440", token.INT, 0)),
                "SpecialStart":       reflect.ValueOf(constant.MakeFromLiteral("12", token.INT, 0)),
                "SpecialsN":          reflect.ValueOf(rich.SpecialsN),
                "SpecialsValues":     reflect.ValueOf(rich.SpecialsValues),
                "StretchMask":        reflect.ValueOf(constant.MakeFromLiteral("983040", token.INT, 0)),
                "StretchN":           reflect.ValueOf(rich.StretchN),
                "StretchNormal":      reflect.ValueOf(rich.StretchNormal),
                "StretchStart":       reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
                "StretchValues":      reflect.ValueOf(rich.StretchValues),
                "StrokeColor":        reflect.ValueOf(rich.StrokeColor),
                "Sub":                reflect.ValueOf(rich.Sub),
                "Super":              reflect.ValueOf(rich.Super),
                "TTB":                reflect.ValueOf(rich.TTB),
                "Thin":               reflect.ValueOf(rich.Thin),
                "UltraCondensed":     reflect.ValueOf(rich.UltraCondensed),
                "UltraExpanded":      reflect.ValueOf(rich.UltraExpanded),
                "Underline":          reflect.ValueOf(rich.Underline),
                "WeightMask":         reflect.ValueOf(constant.MakeFromLiteral("15728640", token.INT, 0)),
                "WeightStart":        reflect.ValueOf(constant.MakeFromLiteral("20", token.INT, 0)),
                "WeightsN":           reflect.ValueOf(rich.WeightsN),
                "WeightsValues":      reflect.ValueOf(rich.WeightsValues),

                // type definitions
                "Decorations": reflect.ValueOf((*rich.Decorations)(nil)),
                "Directions":  reflect.ValueOf((*rich.Directions)(nil)),
                "Family":      reflect.ValueOf((*rich.Family)(nil)),
                "FontName":    reflect.ValueOf((*rich.FontName)(nil)),
                "Hyperlink":   reflect.ValueOf((*rich.Hyperlink)(nil)),
                "Settings":    reflect.ValueOf((*rich.Settings)(nil)),
                "Slants":      reflect.ValueOf((*rich.Slants)(nil)),
                "Specials":    reflect.ValueOf((*rich.Specials)(nil)),
                "Stretch":     reflect.ValueOf((*rich.Stretch)(nil)),
                "Style":       reflect.ValueOf((*rich.Style)(nil)),
                "Text":        reflect.ValueOf((*rich.Text)(nil)),
                "Weights":     reflect.ValueOf((*rich.Weights)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/text/text'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/text/text"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/text/text/text"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AlignsN":           reflect.ValueOf(text.AlignsN),
                "AlignsValues":      reflect.ValueOf(text.AlignsValues),
                "Center":            reflect.ValueOf(text.Center),
                "End":               reflect.ValueOf(text.End),
                "Justify":           reflect.ValueOf(text.Justify),
                "NewFont":           reflect.ValueOf(text.NewFont),
                "NewStyle":          reflect.ValueOf(text.NewStyle),
                "Start":             reflect.ValueOf(text.Start),
                "WhiteSpacePre":     reflect.ValueOf(text.WhiteSpacePre),
                "WhiteSpacePreWrap": reflect.ValueOf(text.WhiteSpacePreWrap),
                "WhiteSpacesN":      reflect.ValueOf(text.WhiteSpacesN),
                "WhiteSpacesValues": reflect.ValueOf(text.WhiteSpacesValues),
                "WrapAlways":        reflect.ValueOf(text.WrapAlways),
                "WrapAsNeeded":      reflect.ValueOf(text.WrapAsNeeded),
                "WrapNever":         reflect.ValueOf(text.WrapNever),
                "WrapSpaceOnly":     reflect.ValueOf(text.WrapSpaceOnly),

                // type definitions
                "Aligns":         reflect.ValueOf((*text.Aligns)(nil)),
                "EditorSettings": reflect.ValueOf((*text.EditorSettings)(nil)),
                "Font":           reflect.ValueOf((*text.Font)(nil)),
                "Style":          reflect.ValueOf((*text.Style)(nil)),
                "WhiteSpaces":    reflect.ValueOf((*text.WhiteSpaces)(nil)),
        }
}

// Code generated by 'yaegi extract cogentcore.org/core/text/textcore'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/text/textcore"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/text/textcore/textcore"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "AsBase":                   reflect.ValueOf(textcore.AsBase),
                "AsEditor":                 reflect.ValueOf(textcore.AsEditor),
                "Close":                    reflect.ValueOf(textcore.Close),
                "DiffEditorDialog":         reflect.ValueOf(textcore.DiffEditorDialog),
                "DiffEditorDialogFromRevs": reflect.ValueOf(textcore.DiffEditorDialogFromRevs),
                "DiffFiles":                reflect.ValueOf(textcore.DiffFiles),
                "FileModPrompt":            reflect.ValueOf(textcore.FileModPrompt),
                "NewBase":                  reflect.ValueOf(textcore.NewBase),
                "NewDiffEditor":            reflect.ValueOf(textcore.NewDiffEditor),
                "NewDiffTextEditor":        reflect.ValueOf(textcore.NewDiffTextEditor),
                "NewEditor":                reflect.ValueOf(textcore.NewEditor),
                "NewTwinEditors":           reflect.ValueOf(textcore.NewTwinEditors),
                "PrevISearchString":        reflect.ValueOf(&textcore.PrevISearchString).Elem(),
                "Save":                     reflect.ValueOf(textcore.Save),
                "SaveAs":                   reflect.ValueOf(textcore.SaveAs),
                "TextDialog":               reflect.ValueOf(textcore.TextDialog),

                // type definitions
                "Base":                   reflect.ValueOf((*textcore.Base)(nil)),
                "BaseEmbedder":           reflect.ValueOf((*textcore.BaseEmbedder)(nil)),
                "DiffEditor":             reflect.ValueOf((*textcore.DiffEditor)(nil)),
                "DiffTextEditor":         reflect.ValueOf((*textcore.DiffTextEditor)(nil)),
                "Editor":                 reflect.ValueOf((*textcore.Editor)(nil)),
                "EditorEmbedder":         reflect.ValueOf((*textcore.EditorEmbedder)(nil)),
                "ISearch":                reflect.ValueOf((*textcore.ISearch)(nil)),
                "OutputBuffer":           reflect.ValueOf((*textcore.OutputBuffer)(nil)),
                "OutputBufferMarkupFunc": reflect.ValueOf((*textcore.OutputBufferMarkupFunc)(nil)),
                "QReplace":               reflect.ValueOf((*textcore.QReplace)(nil)),
                "TwinEditors":            reflect.ValueOf((*textcore.TwinEditors)(nil)),

                // interface wrapper definitions
                "_BaseEmbedder":   reflect.ValueOf((*_cogentcore_org_core_text_textcore_BaseEmbedder)(nil)),
                "_EditorEmbedder": reflect.ValueOf((*_cogentcore_org_core_text_textcore_EditorEmbedder)(nil)),
        }
}

// _cogentcore_org_core_text_textcore_BaseEmbedder is an interface wrapper for BaseEmbedder type
type _cogentcore_org_core_text_textcore_BaseEmbedder struct {
        IValue  interface{}
        WAsBase func() *textcore.Base
}

func (W _cogentcore_org_core_text_textcore_BaseEmbedder) AsBase() *textcore.Base { return W.WAsBase() }

// _cogentcore_org_core_text_textcore_EditorEmbedder is an interface wrapper for EditorEmbedder type
type _cogentcore_org_core_text_textcore_EditorEmbedder struct {
        IValue    interface{}
        WAsEditor func() *textcore.Editor
}

func (W _cogentcore_org_core_text_textcore_EditorEmbedder) AsEditor() *textcore.Editor {
        return W.WAsEditor()
}

// Code generated by 'yaegi extract cogentcore.org/core/tree'. DO NOT EDIT.

package coresymbols

import (
        "cogentcore.org/core/tree"
        "github.com/cogentcore/yaegi/interp"
        "reflect"
)

func init() {
        Symbols["cogentcore.org/core/tree/tree"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Add":               reflect.ValueOf(interp.GenericFunc("func Add[T NodeValue](p *Plan, init func(w *T)) { //yaegi:add\n\tAddAt(p, AutoPlanName(2), init)\n}")),
                "AddAt":             reflect.ValueOf(interp.GenericFunc("func AddAt[T NodeValue](p *Plan, name string, init func(w *T)) { //yaegi:add\n\tp.Add(name, func() Node {\n\t\treturn any(New[T]()).(Node)\n\t}, func(n Node) {\n\t\tinit(any(n).(*T))\n\t})\n}")),
                "AddChild":          reflect.ValueOf(interp.GenericFunc("func AddChild[T NodeValue](parent Node, init func(w *T)) { //yaegi:add\n\tname := AutoPlanName(2) // must get here to get correct name\n\tparent.AsTree().Maker(func(p *Plan) {\n\t\tAddAt(p, name, init)\n\t})\n}")),
                "AddChildAt":        reflect.ValueOf(interp.GenericFunc("func AddChildAt[T NodeValue](parent Node, name string, init func(w *T)) { //yaegi:add\n\tparent.AsTree().Maker(func(p *Plan) {\n\t\tAddAt(p, name, init)\n\t})\n}")),
                "AddChildInit":      reflect.ValueOf(interp.GenericFunc("func AddChildInit[T NodeValue](parent Node, name string, init func(w *T)) { //yaegi:add\n\tparent.AsTree().Maker(func(p *Plan) {\n\t\tAddInit(p, name, init)\n\t})\n}")),
                "AddInit":           reflect.ValueOf(interp.GenericFunc("func AddInit[T NodeValue](p *Plan, name string, init func(w *T)) { //yaegi:add\n\tfor _, child := range p.Children {\n\t\tif child.Name == name {\n\t\t\tchild.Init = append(child.Init, func(n Node) {\n\t\t\t\tinit(any(n).(*T))\n\t\t\t})\n\t\t\treturn\n\t\t}\n\t}\n\tslog.Error(\"AddInit: child not found\", \"name\", name)\n}")),
                "AddNew":            reflect.ValueOf(interp.GenericFunc("func AddNew[T Node](p *Plan, name string, new func() T, init func(w T)) { //yaegi:add\n\tp.Add(name, func() Node {\n\t\treturn new()\n\t}, func(n Node) {\n\t\tinit(n.(T))\n\t})\n}")),
                "AutoPlanName":      reflect.ValueOf(tree.AutoPlanName),
                "Break":             reflect.ValueOf(tree.Break),
                "Continue":          reflect.ValueOf(tree.Continue),
                "EscapePathName":    reflect.ValueOf(tree.EscapePathName),
                "IndexByName":       reflect.ValueOf(tree.IndexByName),
                "IndexOf":           reflect.ValueOf(tree.IndexOf),
                "InitNode":          reflect.ValueOf(tree.InitNode),
                "IsNil":             reflect.ValueOf(tree.IsNil),
                "IsNode":            reflect.ValueOf(tree.IsNode),
                "IsRoot":            reflect.ValueOf(tree.IsRoot),
                "Last":              reflect.ValueOf(tree.Last),
                "MoveToParent":      reflect.ValueOf(tree.MoveToParent),
                "New":               reflect.ValueOf(interp.GenericFunc("func New[T NodeValue](parent ...Node) *T { //yaegi:add\n\tn := new(T)\n\tni := any(n).(Node)\n\tInitNode(ni)\n\tif len(parent) == 0 {\n\t\tni.AsTree().SetName(ni.AsTree().NodeType().IDName)\n\t\treturn n\n\t}\n\tp := parent[0]\n\tp.AsTree().Children = append(p.AsTree().Children, ni)\n\tSetParent(ni, p)\n\treturn n\n}")),
                "NewNodeBase":       reflect.ValueOf(tree.NewNodeBase),
                "NewOfType":         reflect.ValueOf(tree.NewOfType),
                "Next":              reflect.ValueOf(tree.Next),
                "NextSibling":       reflect.ValueOf(tree.NextSibling),
                "Previous":          reflect.ValueOf(tree.Previous),
                "Root":              reflect.ValueOf(tree.Root),
                "SetParent":         reflect.ValueOf(tree.SetParent),
                "SetUniqueName":     reflect.ValueOf(tree.SetUniqueName),
                "UnescapePathName":  reflect.ValueOf(tree.UnescapePathName),
                "UnmarshalRootJSON": reflect.ValueOf(tree.UnmarshalRootJSON),
                "Update":            reflect.ValueOf(tree.Update),
                "UpdateSlice":       reflect.ValueOf(tree.UpdateSlice),

                // type definitions
                "Node":         reflect.ValueOf((*tree.Node)(nil)),
                "NodeBase":     reflect.ValueOf((*tree.NodeBase)(nil)),
                "NodeValue":    reflect.ValueOf((*tree.NodeValue)(nil)),
                "Plan":         reflect.ValueOf((*tree.Plan)(nil)),
                "PlanItem":     reflect.ValueOf((*tree.PlanItem)(nil)),
                "TypePlan":     reflect.ValueOf((*tree.TypePlan)(nil)),
                "TypePlanItem": reflect.ValueOf((*tree.TypePlanItem)(nil)),

                // interface wrapper definitions
                "_Node":      reflect.ValueOf((*_cogentcore_org_core_tree_Node)(nil)),
                "_NodeValue": reflect.ValueOf((*_cogentcore_org_core_tree_NodeValue)(nil)),
        }
}

// _cogentcore_org_core_tree_Node is an interface wrapper for Node type
type _cogentcore_org_core_tree_Node struct {
        IValue          interface{}
        WAsTree         func() *tree.NodeBase
        WCopyFieldsFrom func(from tree.Node)
        WDestroy        func()
        WInit           func()
        WNodeWalkDown   func(fun func(n tree.Node) bool)
        WOnAdd          func()
        WPlanName       func() string
}

func (W _cogentcore_org_core_tree_Node) AsTree() *tree.NodeBase        { return W.WAsTree() }
func (W _cogentcore_org_core_tree_Node) CopyFieldsFrom(from tree.Node) { W.WCopyFieldsFrom(from) }
func (W _cogentcore_org_core_tree_Node) Destroy()                      { W.WDestroy() }
func (W _cogentcore_org_core_tree_Node) Init()                         { W.WInit() }
func (W _cogentcore_org_core_tree_Node) NodeWalkDown(fun func(n tree.Node) bool) {
        W.WNodeWalkDown(fun)
}
func (W _cogentcore_org_core_tree_Node) OnAdd()           { W.WOnAdd() }
func (W _cogentcore_org_core_tree_Node) PlanName() string { return W.WPlanName() }

// _cogentcore_org_core_tree_NodeValue is an interface wrapper for NodeValue type
type _cogentcore_org_core_tree_NodeValue struct {
        IValue     interface{}
        WNodeValue func()
}

func (W _cogentcore_org_core_tree_NodeValue) NodeValue() { W.WNodeValue() }

// Copyright (c) 2025, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package coresymbols

import (
        "reflect"

        . "cogentcore.org/core/icons"
)

// iconsList is a subset of icons to include in the yaegi symbols.
// It is based on the icons used in the core docs.
var iconsList = map[string]Icon{"Download": Download, "Share": Share, "Send": Send, "Computer": Computer, "Smartphone": Smartphone, "Sort": Sort, "Home": Home, "HomeFill": HomeFill, "DeployedCodeFill": DeployedCodeFill, "Close": Close, "Explore": Explore, "History": History, "Euro": Euro, "OpenInNew": OpenInNew, "Add": Add}

func init() {
        m := map[string]reflect.Value{}
        for name, icon := range iconsList {
                m[name] = reflect.ValueOf(icon)
        }
        Symbols["cogentcore.org/core/icons/icons"] = m
}

// Code generated by 'yaegi extract image/color'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package coresymbols

import (
        "image/color"
        "reflect"
)

func init() {
        Symbols["image/color/color"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Alpha16Model": reflect.ValueOf(&color.Alpha16Model).Elem(),
                "AlphaModel":   reflect.ValueOf(&color.AlphaModel).Elem(),
                "Black":        reflect.ValueOf(&color.Black).Elem(),
                "CMYKModel":    reflect.ValueOf(&color.CMYKModel).Elem(),
                "CMYKToRGB":    reflect.ValueOf(color.CMYKToRGB),
                "Gray16Model":  reflect.ValueOf(&color.Gray16Model).Elem(),
                "GrayModel":    reflect.ValueOf(&color.GrayModel).Elem(),
                "ModelFunc":    reflect.ValueOf(color.ModelFunc),
                "NRGBA64Model": reflect.ValueOf(&color.NRGBA64Model).Elem(),
                "NRGBAModel":   reflect.ValueOf(&color.NRGBAModel).Elem(),
                "NYCbCrAModel": reflect.ValueOf(&color.NYCbCrAModel).Elem(),
                "Opaque":       reflect.ValueOf(&color.Opaque).Elem(),
                "RGBA64Model":  reflect.ValueOf(&color.RGBA64Model).Elem(),
                "RGBAModel":    reflect.ValueOf(&color.RGBAModel).Elem(),
                "RGBToCMYK":    reflect.ValueOf(color.RGBToCMYK),
                "RGBToYCbCr":   reflect.ValueOf(color.RGBToYCbCr),
                "Transparent":  reflect.ValueOf(&color.Transparent).Elem(),
                "White":        reflect.ValueOf(&color.White).Elem(),
                "YCbCrModel":   reflect.ValueOf(&color.YCbCrModel).Elem(),
                "YCbCrToRGB":   reflect.ValueOf(color.YCbCrToRGB),

                // type definitions
                "Alpha":   reflect.ValueOf((*color.Alpha)(nil)),
                "Alpha16": reflect.ValueOf((*color.Alpha16)(nil)),
                "CMYK":    reflect.ValueOf((*color.CMYK)(nil)),
                "Color":   reflect.ValueOf((*color.Color)(nil)),
                "Gray":    reflect.ValueOf((*color.Gray)(nil)),
                "Gray16":  reflect.ValueOf((*color.Gray16)(nil)),
                "Model":   reflect.ValueOf((*color.Model)(nil)),
                "NRGBA":   reflect.ValueOf((*color.NRGBA)(nil)),
                "NRGBA64": reflect.ValueOf((*color.NRGBA64)(nil)),
                "NYCbCrA": reflect.ValueOf((*color.NYCbCrA)(nil)),
                "Palette": reflect.ValueOf((*color.Palette)(nil)),
                "RGBA":    reflect.ValueOf((*color.RGBA)(nil)),
                "RGBA64":  reflect.ValueOf((*color.RGBA64)(nil)),
                "YCbCr":   reflect.ValueOf((*color.YCbCr)(nil)),

                // interface wrapper definitions
                "_Color": reflect.ValueOf((*_image_color_Color)(nil)),
                "_Model": reflect.ValueOf((*_image_color_Model)(nil)),
        }
}

// _image_color_Color is an interface wrapper for Color type
type _image_color_Color struct {
        IValue interface{}
        WRGBA  func() (r uint32, g uint32, b uint32, a uint32)
}

func (W _image_color_Color) RGBA() (r uint32, g uint32, b uint32, a uint32) { return W.WRGBA() }

// _image_color_Model is an interface wrapper for Model type
type _image_color_Model struct {
        IValue   interface{}
        WConvert func(c color.Color) color.Color
}

func (W _image_color_Model) Convert(c color.Color) color.Color { return W.WConvert(c) }

// Code generated by 'yaegi extract image/draw'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package coresymbols

import (
        "image"
        "image/color"
        "image/draw"
        "reflect"
)

func init() {
        Symbols["image/draw/draw"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Draw":           reflect.ValueOf(draw.Draw),
                "DrawMask":       reflect.ValueOf(draw.DrawMask),
                "FloydSteinberg": reflect.ValueOf(&draw.FloydSteinberg).Elem(),
                "Over":           reflect.ValueOf(draw.Over),
                "Src":            reflect.ValueOf(draw.Src),

                // type definitions
                "Drawer":      reflect.ValueOf((*draw.Drawer)(nil)),
                "Image":       reflect.ValueOf((*draw.Image)(nil)),
                "Op":          reflect.ValueOf((*draw.Op)(nil)),
                "Quantizer":   reflect.ValueOf((*draw.Quantizer)(nil)),
                "RGBA64Image": reflect.ValueOf((*draw.RGBA64Image)(nil)),

                // interface wrapper definitions
                "_Drawer":      reflect.ValueOf((*_image_draw_Drawer)(nil)),
                "_Image":       reflect.ValueOf((*_image_draw_Image)(nil)),
                "_Quantizer":   reflect.ValueOf((*_image_draw_Quantizer)(nil)),
                "_RGBA64Image": reflect.ValueOf((*_image_draw_RGBA64Image)(nil)),
        }
}

// _image_draw_Drawer is an interface wrapper for Drawer type
type _image_draw_Drawer struct {
        IValue interface{}
        WDraw  func(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)
}

func (W _image_draw_Drawer) Draw(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point) {
        W.WDraw(dst, r, src, sp)
}

// _image_draw_Image is an interface wrapper for Image type
type _image_draw_Image struct {
        IValue      interface{}
        WAt         func(x int, y int) color.Color
        WBounds     func() image.Rectangle
        WColorModel func() color.Model
        WSet        func(x int, y int, c color.Color)
}

func (W _image_draw_Image) At(x int, y int) color.Color     { return W.WAt(x, y) }
func (W _image_draw_Image) Bounds() image.Rectangle         { return W.WBounds() }
func (W _image_draw_Image) ColorModel() color.Model         { return W.WColorModel() }
func (W _image_draw_Image) Set(x int, y int, c color.Color) { W.WSet(x, y, c) }

// _image_draw_Quantizer is an interface wrapper for Quantizer type
type _image_draw_Quantizer struct {
        IValue    interface{}
        WQuantize func(p color.Palette, m image.Image) color.Palette
}

func (W _image_draw_Quantizer) Quantize(p color.Palette, m image.Image) color.Palette {
        return W.WQuantize(p, m)
}

// _image_draw_RGBA64Image is an interface wrapper for RGBA64Image type
type _image_draw_RGBA64Image struct {
        IValue      interface{}
        WAt         func(x int, y int) color.Color
        WBounds     func() image.Rectangle
        WColorModel func() color.Model
        WRGBA64At   func(x int, y int) color.RGBA64
        WSet        func(x int, y int, c color.Color)
        WSetRGBA64  func(x int, y int, c color.RGBA64)
}

func (W _image_draw_RGBA64Image) At(x int, y int) color.Color            { return W.WAt(x, y) }
func (W _image_draw_RGBA64Image) Bounds() image.Rectangle                { return W.WBounds() }
func (W _image_draw_RGBA64Image) ColorModel() color.Model                { return W.WColorModel() }
func (W _image_draw_RGBA64Image) RGBA64At(x int, y int) color.RGBA64     { return W.WRGBA64At(x, y) }
func (W _image_draw_RGBA64Image) Set(x int, y int, c color.Color)        { W.WSet(x, y, c) }
func (W _image_draw_RGBA64Image) SetRGBA64(x int, y int, c color.RGBA64) { W.WSetRGBA64(x, y, c) }

// Code generated by 'yaegi extract image'. DO NOT EDIT.

//go:build go1.22
// +build go1.22

package coresymbols

import (
        "image"
        "image/color"
        "reflect"
)

func init() {
        Symbols["image/image"] = map[string]reflect.Value{
                // function, constant and variable definitions
                "Black":                  reflect.ValueOf(&image.Black).Elem(),
                "Decode":                 reflect.ValueOf(image.Decode),
                "DecodeConfig":           reflect.ValueOf(image.DecodeConfig),
                "ErrFormat":              reflect.ValueOf(&image.ErrFormat).Elem(),
                "NewAlpha":               reflect.ValueOf(image.NewAlpha),
                "NewAlpha16":             reflect.ValueOf(image.NewAlpha16),
                "NewCMYK":                reflect.ValueOf(image.NewCMYK),
                "NewGray":                reflect.ValueOf(image.NewGray),
                "NewGray16":              reflect.ValueOf(image.NewGray16),
                "NewNRGBA":               reflect.ValueOf(image.NewNRGBA),
                "NewNRGBA64":             reflect.ValueOf(image.NewNRGBA64),
                "NewNYCbCrA":             reflect.ValueOf(image.NewNYCbCrA),
                "NewPaletted":            reflect.ValueOf(image.NewPaletted),
                "NewRGBA":                reflect.ValueOf(image.NewRGBA),
                "NewRGBA64":              reflect.ValueOf(image.NewRGBA64),
                "NewUniform":             reflect.ValueOf(image.NewUniform),
                "NewYCbCr":               reflect.ValueOf(image.NewYCbCr),
                "Opaque":                 reflect.ValueOf(&image.Opaque).Elem(),
                "Pt":                     reflect.ValueOf(image.Pt),
                "Rect":                   reflect.ValueOf(image.Rect),
                "RegisterFormat":         reflect.ValueOf(image.RegisterFormat),
                "Transparent":            reflect.ValueOf(&image.Transparent).Elem(),
                "White":                  reflect.ValueOf(&image.White).Elem(),
                "YCbCrSubsampleRatio410": reflect.ValueOf(image.YCbCrSubsampleRatio410),
                "YCbCrSubsampleRatio411": reflect.ValueOf(image.YCbCrSubsampleRatio411),
                "YCbCrSubsampleRatio420": reflect.ValueOf(image.YCbCrSubsampleRatio420),
                "YCbCrSubsampleRatio422": reflect.ValueOf(image.YCbCrSubsampleRatio422),
                "YCbCrSubsampleRatio440": reflect.ValueOf(image.YCbCrSubsampleRatio440),
                "YCbCrSubsampleRatio444": reflect.ValueOf(image.YCbCrSubsampleRatio444),
                "ZP":                     reflect.ValueOf(&image.ZP).Elem(),
                "ZR":                     reflect.ValueOf(&image.ZR).Elem(),

                // type definitions
                "Alpha":               reflect.ValueOf((*image.Alpha)(nil)),
                "Alpha16":             reflect.ValueOf((*image.Alpha16)(nil)),
                "CMYK":                reflect.ValueOf((*image.CMYK)(nil)),
                "Config":              reflect.ValueOf((*image.Config)(nil)),
                "Gray":                reflect.ValueOf((*image.Gray)(nil)),
                "Gray16":              reflect.ValueOf((*image.Gray16)(nil)),
                "Image":               reflect.ValueOf((*image.Image)(nil)),
                "NRGBA":               reflect.ValueOf((*image.NRGBA)(nil)),
                "NRGBA64":             reflect.ValueOf((*image.NRGBA64)(nil)),
                "NYCbCrA":             reflect.ValueOf((*image.NYCbCrA)(nil)),
                "Paletted":            reflect.ValueOf((*image.Paletted)(nil)),
                "PalettedImage":       reflect.ValueOf((*image.PalettedImage)(nil)),
                "Point":               reflect.ValueOf((*image.Point)(nil)),
                "RGBA":                reflect.ValueOf((*image.RGBA)(nil)),
                "RGBA64":              reflect.ValueOf((*image.RGBA64)(nil)),
                "RGBA64Image":         reflect.ValueOf((*image.RGBA64Image)(nil)),
                "Rectangle":           reflect.ValueOf((*image.Rectangle)(nil)),
                "Uniform":             reflect.ValueOf((*image.Uniform)(nil)),
                "YCbCr":               reflect.ValueOf((*image.YCbCr)(nil)),
                "YCbCrSubsampleRatio": reflect.ValueOf((*image.YCbCrSubsampleRatio)(nil)),

                // interface wrapper definitions
                "_Image":         reflect.ValueOf((*_image_Image)(nil)),
                "_PalettedImage": reflect.ValueOf((*_image_PalettedImage)(nil)),
                "_RGBA64Image":   reflect.ValueOf((*_image_RGBA64Image)(nil)),
        }
}

// _image_Image is an interface wrapper for Image type
type _image_Image struct {
        IValue      interface{}
        WAt         func(x int, y int) color.Color
        WBounds     func() image.Rectangle
        WColorModel func() color.Model
}

func (W _image_Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_Image) Bounds() image.Rectangle     { return W.WBounds() }
func (W _image_Image) ColorModel() color.Model     { return W.WColorModel() }

// _image_PalettedImage is an interface wrapper for PalettedImage type
type _image_PalettedImage struct {
        IValue        interface{}
        WAt           func(x int, y int) color.Color
        WBounds       func() image.Rectangle
        WColorIndexAt func(x int, y int) uint8
        WColorModel   func() color.Model
}

func (W _image_PalettedImage) At(x int, y int) color.Color     { return W.WAt(x, y) }
func (W _image_PalettedImage) Bounds() image.Rectangle         { return W.WBounds() }
func (W _image_PalettedImage) ColorIndexAt(x int, y int) uint8 { return W.WColorIndexAt(x, y) }
func (W _image_PalettedImage) ColorModel() color.Model         { return W.WColorModel() }

// _image_RGBA64Image is an interface wrapper for RGBA64Image type
type _image_RGBA64Image struct {
        IValue      interface{}
        WAt         func(x int, y int) color.Color
        WBounds     func() image.Rectangle
        WColorModel func() color.Model
        WRGBA64At   func(x int, y int) color.RGBA64
}

func (W _image_RGBA64Image) At(x int, y int) color.Color        { return W.WAt(x, y) }
func (W _image_RGBA64Image) Bounds() image.Rectangle            { return W.WBounds() }
func (W _image_RGBA64Image) ColorModel() color.Model            { return W.WColorModel() }
func (W _image_RGBA64Image) RGBA64At(x int, y int) color.RGBA64 { return W.WRGBA64At(x, y) }

// Copyright (c) 2024, Cogent Core. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package yaegicore provides functions connecting
// https://github.com/cogentcore/yaegi to Cogent Core.
package yaegicore

import (
        "fmt"
        "reflect"
        "strings"
        "sync/atomic"

        "cogentcore.org/core/base/errors"
        "cogentcore.org/core/core"
        "cogentcore.org/core/events"
        "cogentcore.org/core/htmlcore"
        "cogentcore.org/core/text/textcore"
        "cogentcore.org/core/yaegicore/basesymbols"
        "cogentcore.org/core/yaegicore/coresymbols"
        "github.com/cogentcore/yaegi/interp"
)

// Interpreters is a map from language names (such as "Go") to functions that create a
// new [Interpreter] for that language. The base implementation is just [interp.Interpreter]
// for Go, but other packages can extend this. See the [Interpreter] interface for more information.
var Interpreters = map[string]func(options interp.Options) Interpreter{
        "Go": func(options interp.Options) Interpreter {
                return interp.New(options)
        },
}

// Interpreter is an interface that represents the functionality provided by an interpreter
// compatible with yaegicore. The base implementation is just [interp.Interpreter], but other
// packages such as yaegilab in Cogent Lab provide their own implementations with other languages
// such as Cogent Goal. See [Interpreters].
type Interpreter interface {

        // Use imports the given symbols into the interpreter.
        Use(values interp.Exports) error

        // ImportUsed imports the used symbols into the interpreter
        // and does any extra necessary configuration steps.
        ImportUsed()

        // Eval evaluates the given code in the interpreter.
        Eval(src string) (res reflect.Value, err error)
}

var autoPlanNameCounter uint64

func init() {
        htmlcore.BindTextEditor = BindTextEditor
        coresymbols.Symbols["."] = map[string]reflect.Value{} // make "." available for use
        basesymbols.Symbols["."] = map[string]reflect.Value{} // make "." available for use
}

var currentGoalInterpreter Interpreter

// interpreterParent is used to store the parent widget ("b") for the interpreter.
// It exists (as a double pointer) such that it can be updated after-the-fact, such
// as in Cogent Lab/Goal where interpreters are re-used across multiple text editors,
// wherein the parent widget must be remotely controllable with a double pointer to
// keep the parent widget up-to-date.
var interpreterParent = new(*core.Frame)

// getInterpreter returns a new interpreter for the given language,
// or [currentGoalInterpreter] if the language is "Goal" and it is non-nil.
func getInterpreter(language string) (in Interpreter, new bool, err error) {
        if language == "Goal" && currentGoalInterpreter != nil {
                return currentGoalInterpreter, false, nil
        }

        f := Interpreters[language]
        if f == nil {
                return nil, false, fmt.Errorf("no entry in yaegicore.Interpreters for language %q", language)
        }
        in = f(interp.Options{})

        if language == "Goal" {
                currentGoalInterpreter = in
        }
        return in, true, nil
}

// BindTextEditor binds the given text editor to a yaegi interpreter
// such that the contents of the text editor are interpreted as code
// of the given language, which is run in the context of the given parent widget.
// It is used as the default value of [htmlcore.BindTextEditor].
func BindTextEditor(ed *textcore.Editor, parent *core.Frame, language string) {
        oc := func() {
                in, new, err := getInterpreter(language)
                if err != nil {
                        core.ErrorSnackbar(ed, err)
                        return
                }
                core.ExternalParent = parent
                *interpreterParent = parent
                coresymbols.Symbols["."]["b"] = reflect.ValueOf(interpreterParent).Elem()
                // the normal AutoPlanName cannot be used because the stack trace in yaegi is not helpful
                coresymbols.Symbols["cogentcore.org/core/tree/tree"]["AutoPlanName"] = reflect.ValueOf(func(int) string {
                        return fmt.Sprintf("yaegi-%v", atomic.AddUint64(&autoPlanNameCounter, 1))
                })
                if new {
                        errors.Log(in.Use(basesymbols.Symbols))
                        errors.Log(in.Use(coresymbols.Symbols))
                        in.ImportUsed()
                }

                parent.DeleteChildren()
                str := ed.Lines.String()
                // all Go code must be in a function for declarations to be handled correctly
                if language == "Go" && !strings.Contains(str, "func main()") {
                        str = "func main() {\n" + str + "\n}"
                }
                _, err = in.Eval(str)
                if err != nil {
                        core.ErrorSnackbar(ed, err, fmt.Sprintf("Error interpreting %s code", language))
                        return
                }
                parent.Update()
        }
        ed.OnChange(func(e events.Event) { oc() })
        oc()
}