mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-18 22:22:22 +00:00
New color_scheme_dark, color_scheme_light and color_scheme_no_preference options. When any of them is set, the ssh kitten sends the color schemes for all three system color schemes to kitty, which applies the one matching the current system color scheme and switches between them when the system color scheme changes. color_scheme is used for modes without a specific color scheme. The colors are applied in a new session color layer, above the colors of the window and below colors set by programs. They are associated with the color stack entry pushed by the ssh kitten and are removed when it is popped, so nested sessions work and the colors are restored on exit. Configs that only use color_scheme continue to use escape codes exactly as before, as does the kitten when running inside tmux. Fixes #10724
1010 lines
32 KiB
Go
1010 lines
32 KiB
Go
// License: GPLv3 Copyright: 2023, Kovid Goyal, <kovid at kovidgoyal.net>
|
|
|
|
package themes
|
|
|
|
import (
|
|
"archive/zip"
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"maps"
|
|
"net/http"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"regexp"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/kovidgoyal/kitty/tools/cli"
|
|
"github.com/kovidgoyal/kitty/tools/config"
|
|
"github.com/kovidgoyal/kitty/tools/tui/loop"
|
|
"github.com/kovidgoyal/kitty/tools/tui/subseq"
|
|
"github.com/kovidgoyal/kitty/tools/utils"
|
|
"github.com/kovidgoyal/kitty/tools/utils/style"
|
|
)
|
|
|
|
var _ = fmt.Print
|
|
|
|
var AllColorSettingNames = map[string]bool{ // {{{
|
|
// generated by gen-config.py do not edit
|
|
// ALL_COLORS_START
|
|
"active_border_color": true,
|
|
"active_tab_background": true,
|
|
"active_tab_foreground": true,
|
|
"background": true,
|
|
"bell_border_color": true,
|
|
"color0": true,
|
|
"color1": true,
|
|
"color10": true,
|
|
"color100": true,
|
|
"color101": true,
|
|
"color102": true,
|
|
"color103": true,
|
|
"color104": true,
|
|
"color105": true,
|
|
"color106": true,
|
|
"color107": true,
|
|
"color108": true,
|
|
"color109": true,
|
|
"color11": true,
|
|
"color110": true,
|
|
"color111": true,
|
|
"color112": true,
|
|
"color113": true,
|
|
"color114": true,
|
|
"color115": true,
|
|
"color116": true,
|
|
"color117": true,
|
|
"color118": true,
|
|
"color119": true,
|
|
"color12": true,
|
|
"color120": true,
|
|
"color121": true,
|
|
"color122": true,
|
|
"color123": true,
|
|
"color124": true,
|
|
"color125": true,
|
|
"color126": true,
|
|
"color127": true,
|
|
"color128": true,
|
|
"color129": true,
|
|
"color13": true,
|
|
"color130": true,
|
|
"color131": true,
|
|
"color132": true,
|
|
"color133": true,
|
|
"color134": true,
|
|
"color135": true,
|
|
"color136": true,
|
|
"color137": true,
|
|
"color138": true,
|
|
"color139": true,
|
|
"color14": true,
|
|
"color140": true,
|
|
"color141": true,
|
|
"color142": true,
|
|
"color143": true,
|
|
"color144": true,
|
|
"color145": true,
|
|
"color146": true,
|
|
"color147": true,
|
|
"color148": true,
|
|
"color149": true,
|
|
"color15": true,
|
|
"color150": true,
|
|
"color151": true,
|
|
"color152": true,
|
|
"color153": true,
|
|
"color154": true,
|
|
"color155": true,
|
|
"color156": true,
|
|
"color157": true,
|
|
"color158": true,
|
|
"color159": true,
|
|
"color16": true,
|
|
"color160": true,
|
|
"color161": true,
|
|
"color162": true,
|
|
"color163": true,
|
|
"color164": true,
|
|
"color165": true,
|
|
"color166": true,
|
|
"color167": true,
|
|
"color168": true,
|
|
"color169": true,
|
|
"color17": true,
|
|
"color170": true,
|
|
"color171": true,
|
|
"color172": true,
|
|
"color173": true,
|
|
"color174": true,
|
|
"color175": true,
|
|
"color176": true,
|
|
"color177": true,
|
|
"color178": true,
|
|
"color179": true,
|
|
"color18": true,
|
|
"color180": true,
|
|
"color181": true,
|
|
"color182": true,
|
|
"color183": true,
|
|
"color184": true,
|
|
"color185": true,
|
|
"color186": true,
|
|
"color187": true,
|
|
"color188": true,
|
|
"color189": true,
|
|
"color19": true,
|
|
"color190": true,
|
|
"color191": true,
|
|
"color192": true,
|
|
"color193": true,
|
|
"color194": true,
|
|
"color195": true,
|
|
"color196": true,
|
|
"color197": true,
|
|
"color198": true,
|
|
"color199": true,
|
|
"color2": true,
|
|
"color20": true,
|
|
"color200": true,
|
|
"color201": true,
|
|
"color202": true,
|
|
"color203": true,
|
|
"color204": true,
|
|
"color205": true,
|
|
"color206": true,
|
|
"color207": true,
|
|
"color208": true,
|
|
"color209": true,
|
|
"color21": true,
|
|
"color210": true,
|
|
"color211": true,
|
|
"color212": true,
|
|
"color213": true,
|
|
"color214": true,
|
|
"color215": true,
|
|
"color216": true,
|
|
"color217": true,
|
|
"color218": true,
|
|
"color219": true,
|
|
"color22": true,
|
|
"color220": true,
|
|
"color221": true,
|
|
"color222": true,
|
|
"color223": true,
|
|
"color224": true,
|
|
"color225": true,
|
|
"color226": true,
|
|
"color227": true,
|
|
"color228": true,
|
|
"color229": true,
|
|
"color23": true,
|
|
"color230": true,
|
|
"color231": true,
|
|
"color232": true,
|
|
"color233": true,
|
|
"color234": true,
|
|
"color235": true,
|
|
"color236": true,
|
|
"color237": true,
|
|
"color238": true,
|
|
"color239": true,
|
|
"color24": true,
|
|
"color240": true,
|
|
"color241": true,
|
|
"color242": true,
|
|
"color243": true,
|
|
"color244": true,
|
|
"color245": true,
|
|
"color246": true,
|
|
"color247": true,
|
|
"color248": true,
|
|
"color249": true,
|
|
"color25": true,
|
|
"color250": true,
|
|
"color251": true,
|
|
"color252": true,
|
|
"color253": true,
|
|
"color254": true,
|
|
"color255": true,
|
|
"color26": true,
|
|
"color27": true,
|
|
"color28": true,
|
|
"color29": true,
|
|
"color3": true,
|
|
"color30": true,
|
|
"color31": true,
|
|
"color32": true,
|
|
"color33": true,
|
|
"color34": true,
|
|
"color35": true,
|
|
"color36": true,
|
|
"color37": true,
|
|
"color38": true,
|
|
"color39": true,
|
|
"color4": true,
|
|
"color40": true,
|
|
"color41": true,
|
|
"color42": true,
|
|
"color43": true,
|
|
"color44": true,
|
|
"color45": true,
|
|
"color46": true,
|
|
"color47": true,
|
|
"color48": true,
|
|
"color49": true,
|
|
"color5": true,
|
|
"color50": true,
|
|
"color51": true,
|
|
"color52": true,
|
|
"color53": true,
|
|
"color54": true,
|
|
"color55": true,
|
|
"color56": true,
|
|
"color57": true,
|
|
"color58": true,
|
|
"color59": true,
|
|
"color6": true,
|
|
"color60": true,
|
|
"color61": true,
|
|
"color62": true,
|
|
"color63": true,
|
|
"color64": true,
|
|
"color65": true,
|
|
"color66": true,
|
|
"color67": true,
|
|
"color68": true,
|
|
"color69": true,
|
|
"color7": true,
|
|
"color70": true,
|
|
"color71": true,
|
|
"color72": true,
|
|
"color73": true,
|
|
"color74": true,
|
|
"color75": true,
|
|
"color76": true,
|
|
"color77": true,
|
|
"color78": true,
|
|
"color79": true,
|
|
"color8": true,
|
|
"color80": true,
|
|
"color81": true,
|
|
"color82": true,
|
|
"color83": true,
|
|
"color84": true,
|
|
"color85": true,
|
|
"color86": true,
|
|
"color87": true,
|
|
"color88": true,
|
|
"color89": true,
|
|
"color9": true,
|
|
"color90": true,
|
|
"color91": true,
|
|
"color92": true,
|
|
"color93": true,
|
|
"color94": true,
|
|
"color95": true,
|
|
"color96": true,
|
|
"color97": true,
|
|
"color98": true,
|
|
"color99": true,
|
|
"cursor": true,
|
|
"cursor_text_color": true,
|
|
"cursor_trail_color": true,
|
|
"foreground": true,
|
|
"inactive_border_color": true,
|
|
"inactive_tab_background": true,
|
|
"inactive_tab_foreground": true,
|
|
"macos_titlebar_color": true,
|
|
"mark1_background": true,
|
|
"mark1_foreground": true,
|
|
"mark2_background": true,
|
|
"mark2_foreground": true,
|
|
"mark3_background": true,
|
|
"mark3_foreground": true,
|
|
"scrollbar_handle_color": true,
|
|
"scrollbar_track_color": true,
|
|
"selection_background": true,
|
|
"selection_foreground": true,
|
|
"tab_bar_background": true,
|
|
"tab_bar_margin_color": true,
|
|
"url_color": true,
|
|
"visual_bell_color": true,
|
|
"wayland_titlebar_color": true,
|
|
"window_title_bar_active_background": true,
|
|
"window_title_bar_active_foreground": true,
|
|
"window_title_bar_inactive_background": true,
|
|
"window_title_bar_inactive_foreground": true, // ALL_COLORS_END
|
|
} // }}}
|
|
|
|
type JSONMetadata struct {
|
|
Etag string `json:"etag"`
|
|
Timestamp string `json:"timestamp"`
|
|
}
|
|
|
|
var ErrNoCacheFound = errors.New("No cache found and max cache age is negative")
|
|
|
|
func set_comment_in_zip_file(path string, comment string) error {
|
|
src, err := zip.OpenReader(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer src.Close()
|
|
buf := bytes.Buffer{}
|
|
dest := zip.NewWriter(&buf)
|
|
if err = dest.SetComment(comment); err != nil {
|
|
return err
|
|
}
|
|
for _, sf := range src.File {
|
|
err = dest.Copy(sf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
dest.Close()
|
|
return utils.AtomicUpdateFile(path, bytes.NewReader(buf.Bytes()), 0o644)
|
|
}
|
|
|
|
func fetch_cached(name, url, cache_path string, max_cache_age time.Duration) (string, error) {
|
|
cache_path = filepath.Join(cache_path, name+".zip")
|
|
zf, err := zip.OpenReader(cache_path)
|
|
if err != nil && !errors.Is(err, fs.ErrNotExist) {
|
|
return "", err
|
|
}
|
|
|
|
var jm JSONMetadata
|
|
if err == nil {
|
|
defer zf.Close()
|
|
if err = json.Unmarshal(utils.UnsafeStringToBytes(zf.Comment), &jm); err == nil {
|
|
if max_cache_age < 0 {
|
|
return cache_path, nil
|
|
}
|
|
cache_age, err := utils.ISO8601Parse(jm.Timestamp)
|
|
if err == nil {
|
|
if time.Now().Before(cache_age.Add(max_cache_age)) {
|
|
return cache_path, nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if max_cache_age < 0 {
|
|
return "", ErrNoCacheFound
|
|
}
|
|
req, err := http.NewRequest(http.MethodGet, url, nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if jm.Etag != "" {
|
|
req.Header.Add("If-None-Match", jm.Etag)
|
|
}
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return "", fmt.Errorf("Failed to download %s with error: %w", url, err)
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
if resp.StatusCode == http.StatusNotModified {
|
|
jm.Timestamp = utils.ISO8601Format(time.Now())
|
|
comment, _ := json.Marshal(jm)
|
|
err = set_comment_in_zip_file(cache_path, utils.UnsafeBytesToString(comment))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return cache_path, nil
|
|
}
|
|
return "", fmt.Errorf("Failed to download %s with HTTP error: %s", url, resp.Status)
|
|
}
|
|
var tf, tf2 *os.File
|
|
tf, err = os.CreateTemp(filepath.Dir(cache_path), name+".temp-*")
|
|
if err == nil {
|
|
tf2, err = os.CreateTemp(filepath.Dir(cache_path), name+".temp-*")
|
|
}
|
|
defer func() {
|
|
if tf != nil {
|
|
tf.Close()
|
|
os.Remove(tf.Name())
|
|
tf = nil
|
|
}
|
|
if tf2 != nil {
|
|
tf2.Close()
|
|
os.Remove(tf2.Name())
|
|
tf2 = nil
|
|
}
|
|
}()
|
|
if err != nil {
|
|
return "", fmt.Errorf("Failed to create temp file in %s with error: %w", filepath.Dir(cache_path), err)
|
|
}
|
|
_, err = io.Copy(tf, resp.Body)
|
|
if err != nil {
|
|
return "", fmt.Errorf("Failed to download %s with error: %w", url, err)
|
|
}
|
|
r, err := zip.OpenReader(tf.Name())
|
|
if err != nil {
|
|
return "", fmt.Errorf("Failed to open downloaded zip file with error: %w", err)
|
|
}
|
|
defer r.Close()
|
|
w := zip.NewWriter(tf2)
|
|
jm.Etag = resp.Header.Get("ETag")
|
|
jm.Timestamp = utils.ISO8601Format(time.Now())
|
|
comment, _ := json.Marshal(jm)
|
|
if err = w.SetComment(utils.UnsafeBytesToString(comment)); err != nil {
|
|
return "", err
|
|
}
|
|
for _, file := range r.File {
|
|
err = w.Copy(file)
|
|
if err != nil {
|
|
return "", fmt.Errorf("Failed to copy zip file from source to destination archive")
|
|
}
|
|
}
|
|
err = w.Close()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
tf2.Close()
|
|
err = os.Rename(tf2.Name(), cache_path)
|
|
if err != nil {
|
|
return "", fmt.Errorf("Failed to atomic rename temp file to %s with error: %w", cache_path, err)
|
|
}
|
|
tf2 = nil
|
|
return cache_path, nil
|
|
}
|
|
|
|
func FetchCached(max_cache_age time.Duration) (string, error) {
|
|
return fetch_cached("kitty-themes", "https://codeload.github.com/kovidgoyal/kitty-themes/zip/master", utils.CacheDir(), max_cache_age)
|
|
}
|
|
|
|
type ThemeMetadata struct {
|
|
Name string `json:"name"`
|
|
Filepath string `json:"file"`
|
|
Is_dark bool `json:"is_dark"`
|
|
Num_settings int `json:"num_settings"`
|
|
Blurb string `json:"blurb"`
|
|
License string `json:"license"`
|
|
Upstream string `json:"upstream"`
|
|
Author string `json:"author"`
|
|
}
|
|
|
|
func ParseThemeMetadata(path string) (*ThemeMetadata, map[string]string, error) {
|
|
var in_metadata, in_blurb, finished_metadata bool
|
|
ans := ThemeMetadata{Is_dark: true} // the default background in kitty is dark
|
|
settings := map[string]string{}
|
|
|
|
read_is_dark := func(key, val string) (err error) {
|
|
settings[key] = val
|
|
if key == "background" {
|
|
if val != "" {
|
|
bg, err := style.ParseColor(val)
|
|
if err == nil {
|
|
ans.Is_dark = utils.Max(bg.Red, bg.Green, bg.Blue) < 115
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
read_metadata := func(line string) (err error) {
|
|
is_block := strings.HasPrefix(line, "## ")
|
|
if in_metadata && !is_block {
|
|
finished_metadata = true
|
|
}
|
|
if finished_metadata {
|
|
return
|
|
}
|
|
if !in_metadata && is_block {
|
|
in_metadata = true
|
|
}
|
|
if !in_metadata {
|
|
return
|
|
}
|
|
line = line[3:]
|
|
if in_blurb {
|
|
ans.Blurb += " " + line
|
|
return
|
|
}
|
|
key, val, found := strings.Cut(line, ":")
|
|
if !found {
|
|
return
|
|
}
|
|
key = strings.TrimSpace(strings.ToLower(key))
|
|
val = strings.TrimSpace(val)
|
|
switch key {
|
|
case "name":
|
|
if val != "The name of the theme (if not present, derived from filename)" {
|
|
ans.Name = val
|
|
}
|
|
case "author":
|
|
ans.Author = val
|
|
case "upstream":
|
|
ans.Upstream = val
|
|
case "blurb":
|
|
ans.Blurb = val
|
|
in_blurb = true
|
|
case "license":
|
|
ans.License = val
|
|
}
|
|
return
|
|
}
|
|
cp := config.ConfigParser{LineHandler: read_is_dark, CommentsHandler: read_metadata}
|
|
err := cp.ParseFiles(path)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
ans.Num_settings = len(settings)
|
|
return &ans, settings, nil
|
|
}
|
|
|
|
type Theme struct {
|
|
metadata *ThemeMetadata
|
|
|
|
code string
|
|
settings map[string]string
|
|
zip_reader *zip.File
|
|
is_user_defined bool
|
|
path_for_user_defined_theme string
|
|
}
|
|
|
|
func (self *Theme) Name() string { return self.metadata.Name }
|
|
func (self *Theme) Author() string { return self.metadata.Author }
|
|
func (self *Theme) Blurb() string { return self.metadata.Blurb }
|
|
func (self *Theme) IsDark() bool { return self.metadata.Is_dark }
|
|
func (self *Theme) IsUserDefined() bool { return self.is_user_defined }
|
|
|
|
func (self *Theme) load_code() (string, error) {
|
|
if self.zip_reader != nil {
|
|
f, err := self.zip_reader.Open()
|
|
self.zip_reader = nil
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer f.Close()
|
|
data, err := io.ReadAll(f)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
self.code = utils.UnsafeBytesToString(data)
|
|
}
|
|
if self.is_user_defined && self.path_for_user_defined_theme != "" && self.code == "" {
|
|
raw, err := os.ReadFile(self.path_for_user_defined_theme)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
self.code = utils.UnsafeBytesToString(raw)
|
|
}
|
|
return self.code, nil
|
|
}
|
|
|
|
func (self *Theme) Code() (string, error) {
|
|
return self.load_code()
|
|
}
|
|
|
|
func (self *Theme) SaveInDir(dirpath string) (err error) {
|
|
path := filepath.Join(dirpath, self.Name()+".conf")
|
|
code, err := self.Code()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return utils.AtomicUpdateFile(path, bytes.NewReader(utils.UnsafeStringToBytes(code)), 0o644)
|
|
}
|
|
|
|
func (self *Theme) SaveInFile(config_dir, config_file_name string) (err error) {
|
|
_ = os.MkdirAll(config_dir, 0o755)
|
|
path := filepath.Join(config_dir, config_file_name)
|
|
code, err := self.Code()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return utils.AtomicUpdateFile(path, bytes.NewReader(utils.UnsafeStringToBytes(code)), 0o644)
|
|
}
|
|
|
|
func (self *Theme) SaveInConf(config_dir, reload_in, config_file_name string) (err error) {
|
|
if err = self.SaveInFile(config_dir, `current-theme.conf`); err != nil {
|
|
return err
|
|
}
|
|
confpath := config_file_name
|
|
if !filepath.IsAbs(config_file_name) {
|
|
confpath = filepath.Join(config_dir, config_file_name)
|
|
}
|
|
patcher := config.Patcher{Write_backup: true}
|
|
if _, err = patcher.Patch(
|
|
confpath, "KITTY_THEME", fmt.Sprintf("# %s\ninclude current-theme.conf", self.metadata.Name),
|
|
utils.Keys(AllColorSettingNames)...); err != nil {
|
|
return
|
|
}
|
|
switch reload_in {
|
|
case "parent":
|
|
config.ReloadConfigInKitty(true)
|
|
case "all":
|
|
config.ReloadConfigInKitty(false)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (self *Theme) Settings() (map[string]string, error) {
|
|
if self.zip_reader != nil {
|
|
code, err := self.load_code()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
self.settings = make(map[string]string, 64)
|
|
scanner := utils.NewLineScanner(code)
|
|
for scanner.Scan() {
|
|
line := strings.TrimSpace(scanner.Text())
|
|
if line != "" && line[0] != '#' {
|
|
key, val, found := strings.Cut(line, " ")
|
|
if found {
|
|
self.settings[key] = val
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return self.settings, nil
|
|
}
|
|
|
|
func (self *Theme) AsEscapeCodes() (string, error) {
|
|
settings, err := self.Settings()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return ColorSettingsAsEscapeCodes(settings), nil
|
|
}
|
|
|
|
// A default color, such as foreground or background, set by a color theme
|
|
type ThemeDefaultColor struct {
|
|
Name string
|
|
Num loop.DefaultColor
|
|
// nil means the color is reset to its configured value
|
|
Value *style.RGBA
|
|
}
|
|
|
|
// The colors set by a color theme, with defaults for colors the theme does
|
|
// not specify
|
|
type ThemeColors struct {
|
|
Defaults []ThemeDefaultColor
|
|
Palette [256]style.RGBA
|
|
// Palette colors that the terminal should generate based on its
|
|
// palette_generate setting, the value in Palette is the fixed palette color
|
|
// for terminals that don't support generating colors
|
|
Generated [256]bool
|
|
}
|
|
|
|
func ResolveColorSettings(settings map[string]string) (ans ThemeColors) {
|
|
default_color := func(name, defval string, num loop.DefaultColor) {
|
|
dc := ThemeDefaultColor{Name: name, Num: num}
|
|
val, found := settings[name]
|
|
if !found {
|
|
val = defval
|
|
}
|
|
if val != "" {
|
|
if rgba, err := style.ParseColor(val); err == nil {
|
|
dc.Value = &rgba
|
|
}
|
|
}
|
|
ans.Defaults = append(ans.Defaults, dc)
|
|
}
|
|
default_color("foreground", style.DefaultColors.Foreground, loop.FOREGROUND)
|
|
default_color("background", style.DefaultColors.Background, loop.BACKGROUND)
|
|
default_color("cursor", style.DefaultColors.Cursor, loop.CURSOR)
|
|
default_color("selection_background", style.DefaultColors.SelectionBg, loop.SELECTION_BG)
|
|
default_color("selection_foreground", style.DefaultColors.SelectionFg, loop.SELECTION_FG)
|
|
|
|
for i := range 256 {
|
|
if val := settings["color"+strconv.Itoa(i)]; val != "" {
|
|
if rgba, err := style.ParseColor(val); err == nil {
|
|
ans.Palette[i] = rgba
|
|
continue
|
|
}
|
|
}
|
|
c := style.ColorTable[i]
|
|
if c == style.NullColorValue {
|
|
c = style.FixedColorTable[i]
|
|
ans.Generated[i] = true
|
|
}
|
|
ans.Palette[i].FromRGB(c)
|
|
}
|
|
return
|
|
}
|
|
|
|
func ColorSettingsAsEscapeCodes(settings map[string]string) string {
|
|
colors := ResolveColorSettings(settings)
|
|
w := strings.Builder{}
|
|
w.Grow(4096)
|
|
|
|
for _, dc := range colors.Defaults {
|
|
w.WriteString("\033]")
|
|
if dc.Value != nil {
|
|
w.WriteString(strconv.Itoa(int(dc.Num)))
|
|
w.WriteByte(';')
|
|
w.WriteString(dc.Value.AsRGBSharp())
|
|
} else {
|
|
w.WriteByte('1')
|
|
w.WriteString(strconv.Itoa(int(dc.Num)))
|
|
}
|
|
w.WriteString("\033\\")
|
|
}
|
|
|
|
unset := make([]int, 0, 256)
|
|
w.WriteString("\033]4")
|
|
for i, rgba := range colors.Palette {
|
|
w.WriteByte(';')
|
|
w.WriteString(strconv.Itoa(i))
|
|
w.WriteByte(';')
|
|
// Use the fixed palette for terminals that don't support OSC 21
|
|
w.WriteString(rgba.AsRGBSharp())
|
|
if colors.Generated[i] {
|
|
unset = append(unset, i)
|
|
}
|
|
}
|
|
w.WriteString("\033\\")
|
|
if len(unset) > 0 {
|
|
// Have kitty fill in unset colors based on its palette_generate setting
|
|
w.WriteString("\033]21")
|
|
for _, i := range unset {
|
|
w.WriteByte(';')
|
|
w.WriteString(strconv.Itoa(i))
|
|
w.WriteByte('=')
|
|
}
|
|
w.WriteString("\033\\")
|
|
}
|
|
return w.String()
|
|
}
|
|
|
|
// The same colors as set by ColorSettingsAsEscapeCodes as a map of kitty
|
|
// color names to 0xRRGGBB values. Colors that are reset to their configured
|
|
// values are not present and colors that kitty should generate are nil.
|
|
func ColorSettingsAsSpec(settings map[string]string) map[string]any {
|
|
colors := ResolveColorSettings(settings)
|
|
ans := make(map[string]any, len(colors.Defaults)+len(colors.Palette))
|
|
for _, dc := range colors.Defaults {
|
|
if dc.Value != nil {
|
|
ans[dc.Name] = dc.Value.AsRGB()
|
|
}
|
|
}
|
|
for i, rgba := range colors.Palette {
|
|
key := "color" + strconv.Itoa(i)
|
|
if colors.Generated[i] {
|
|
ans[key] = nil
|
|
} else {
|
|
ans[key] = rgba.AsRGB()
|
|
}
|
|
}
|
|
return ans
|
|
}
|
|
|
|
type Themes struct {
|
|
name_map map[string]*Theme
|
|
index_map []string
|
|
}
|
|
|
|
func (self *Themes) Copy() *Themes {
|
|
ans := &Themes{name_map: make(map[string]*Theme, len(self.name_map)), index_map: slices.Clone(self.index_map)}
|
|
maps.Copy(ans.name_map, self.name_map)
|
|
return ans
|
|
}
|
|
|
|
var camel_case_pat = sync.OnceValue(func() *regexp.Regexp {
|
|
return regexp.MustCompile(`([a-z])([A-Z])`)
|
|
})
|
|
|
|
func ThemeNameFromFileName(fname string) string {
|
|
fname = fname[:len(fname)-len(path.Ext(fname))]
|
|
fname = strings.ReplaceAll(fname, "_", " ")
|
|
fname = camel_case_pat().ReplaceAllString(fname, "$1 $2")
|
|
return strings.Join(utils.Map(strings.Title, strings.Split(fname, " ")), " ")
|
|
}
|
|
|
|
func (self *Themes) Len() int { return len(self.name_map) }
|
|
func (self *Themes) At(x int) *Theme {
|
|
if x >= len(self.index_map) || x < 0 {
|
|
return nil
|
|
}
|
|
return self.name_map[self.index_map[x]]
|
|
}
|
|
func (self *Themes) Names() []string { return self.index_map }
|
|
|
|
func (self *Themes) create_index_map() {
|
|
self.index_map = utils.Keys(self.name_map)
|
|
self.index_map = utils.StableSortWithKey(self.index_map, strings.ToLower)
|
|
}
|
|
|
|
func (self *Themes) Filtered(is_ok func(*Theme) bool) *Themes {
|
|
themes := utils.Filter(utils.Values(self.name_map), is_ok)
|
|
ans := Themes{name_map: make(map[string]*Theme, len(themes))}
|
|
for _, theme := range themes {
|
|
ans.name_map[theme.metadata.Name] = theme
|
|
}
|
|
ans.create_index_map()
|
|
return &ans
|
|
}
|
|
|
|
func (self *Themes) AddFromFile(path string) (*Theme, error) {
|
|
m, conf, err := ParseThemeMetadata(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if m.Name == "" {
|
|
m.Name = ThemeNameFromFileName(filepath.Base(path))
|
|
}
|
|
t := Theme{metadata: m, is_user_defined: true, settings: conf, path_for_user_defined_theme: path}
|
|
self.name_map[m.Name] = &t
|
|
return &t, nil
|
|
|
|
}
|
|
|
|
func (self *Themes) add_from_dir(dirpath string) error {
|
|
entries, err := os.ReadDir(dirpath)
|
|
if err != nil {
|
|
if errors.Is(err, fs.ErrNotExist) {
|
|
err = nil
|
|
}
|
|
return err
|
|
}
|
|
for _, e := range entries {
|
|
if !e.IsDir() && strings.HasSuffix(e.Name(), ".conf") {
|
|
path := filepath.Join(dirpath, e.Name())
|
|
// ignore files if they are the STDOUT of the current processes
|
|
// allows using kitten theme --dump-theme name > ~/.config/kitty/themes/name.conf
|
|
if utils.Samefile(path, os.Stdout) {
|
|
continue
|
|
}
|
|
if _, err = self.AddFromFile(path); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (self *Themes) add_from_zip_file(zippath string) (io.Closer, error) {
|
|
r, err := zip.OpenReader(zippath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
name_map := make(map[string]*zip.File, len(r.File))
|
|
var themes []*ThemeMetadata
|
|
theme_dir := ""
|
|
for _, file := range r.File {
|
|
name_map[file.Name] = file
|
|
if path.Base(file.Name) == "themes.json" {
|
|
theme_dir = path.Dir(file.Name)
|
|
fr, err := file.Open()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Error while opening %s from the ZIP file: %w", file.Name, err)
|
|
}
|
|
defer fr.Close()
|
|
raw, err := io.ReadAll(fr)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Error while reading %s from the ZIP file: %w", file.Name, err)
|
|
}
|
|
err = json.Unmarshal(raw, &themes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Error while decoding %s: %w", file.Name, err)
|
|
}
|
|
}
|
|
}
|
|
if theme_dir == "" {
|
|
return nil, fmt.Errorf("No themes.json found in ZIP file")
|
|
}
|
|
for _, theme := range themes {
|
|
key := path.Join(theme_dir, theme.Filepath)
|
|
f := name_map[key]
|
|
if f != nil {
|
|
t := Theme{metadata: theme, zip_reader: f}
|
|
self.name_map[theme.Name] = &t
|
|
}
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func (self *Themes) ThemeByName(name string) *Theme {
|
|
ans := self.name_map[name]
|
|
if ans == nil {
|
|
q := strings.ToLower(name)
|
|
for k, t := range self.name_map {
|
|
if strings.ToLower(k) == q {
|
|
return t
|
|
}
|
|
}
|
|
}
|
|
return ans
|
|
}
|
|
|
|
func match(expression string, items []string) []*subseq.Match {
|
|
matches := subseq.ScoreItems(expression, items, subseq.Options{Level1: " "})
|
|
matches = utils.StableSort(matches, func(a, b *subseq.Match) int {
|
|
if b.Score < a.Score {
|
|
return -1
|
|
}
|
|
if b.Score > a.Score {
|
|
return 1
|
|
}
|
|
return 0
|
|
})
|
|
return matches
|
|
}
|
|
|
|
const (
|
|
MARK_BEFORE = "\033[33m"
|
|
MARK_AFTER = "\033[39m"
|
|
)
|
|
|
|
func (self *Themes) ApplySearch(expression string, marks ...string) []string {
|
|
mark_before, mark_after := MARK_BEFORE, MARK_AFTER
|
|
if len(marks) == 2 {
|
|
mark_before, mark_after = marks[0], marks[1]
|
|
}
|
|
results := utils.Filter(match(expression, self.index_map), func(x *subseq.Match) bool { return x.Score > 0 })
|
|
name_map := make(map[string]*Theme, len(results))
|
|
for _, m := range results {
|
|
name_map[m.Text] = self.name_map[m.Text]
|
|
}
|
|
self.name_map = name_map
|
|
self.index_map = self.index_map[:0]
|
|
ans := make([]string, 0, len(results))
|
|
for _, m := range results {
|
|
text := m.Text
|
|
positions := m.Positions
|
|
for i := len(positions) - 1; i >= 0; i-- {
|
|
p := positions[i]
|
|
text = text[:p] + mark_before + text[p:p+1] + mark_after + text[p+1:]
|
|
}
|
|
ans = append(ans, text)
|
|
self.index_map = append(self.index_map, m.Text)
|
|
}
|
|
return ans
|
|
}
|
|
|
|
func LoadThemes(cache_age time.Duration) (ans *Themes, closer io.Closer, err error) {
|
|
zip_path, err := FetchCached(cache_age)
|
|
ans = &Themes{name_map: make(map[string]*Theme)}
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if closer, err = ans.add_from_zip_file(zip_path); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if err = ans.add_from_dir(filepath.Join(utils.ConfigDir(), "themes")); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
ans.create_index_map()
|
|
return ans, closer, nil
|
|
}
|
|
|
|
func ThemeFromFile(path string) (*Theme, error) {
|
|
ans := &Themes{name_map: make(map[string]*Theme)}
|
|
return ans.AddFromFile(path)
|
|
}
|
|
|
|
func GetThemeNames(cache_age time.Duration) (ans []string, err error) {
|
|
themes, closer, err := LoadThemes(cache_age)
|
|
if err != nil {
|
|
if errors.Is(err, ErrNoCacheFound) {
|
|
return []string{"Default"}, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
defer closer.Close()
|
|
for name := range themes.name_map {
|
|
ans = append(ans, name)
|
|
}
|
|
return
|
|
}
|
|
|
|
func CompleteThemes(completions *cli.Completions, word string, arg_num int) {
|
|
names, err := GetThemeNames(-1)
|
|
if err == nil {
|
|
mg := completions.AddMatchGroup("Themes")
|
|
for _, theme_name := range names {
|
|
theme_name = strings.TrimSpace(theme_name)
|
|
if theme_name != "" && strings.HasPrefix(theme_name, word) {
|
|
mg.AddMatch(theme_name)
|
|
}
|
|
}
|
|
}
|
|
}
|