mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-16 13:08:25 +00:00
154 lines
3.9 KiB
Go
154 lines
3.9 KiB
Go
// License: GPLv3 Copyright: 2026, Kovid Goyal, <kovid at kovidgoyal.net>
|
|
|
|
package resize_window
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/kovidgoyal/kitty/tools/utils"
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
type strategy_settings struct {
|
|
Modifier string `json:"modifier"`
|
|
Fraction string `json:"fraction"`
|
|
}
|
|
|
|
type resize_settings struct {
|
|
Version int `json:"version"`
|
|
Strategy string `json:"strategy"`
|
|
Strategies map[string]strategy_settings `json:"strategies"`
|
|
}
|
|
|
|
func default_settings() resize_settings {
|
|
return resize_settings{Version: 1, Strategy: "window", Strategies: map[string]strategy_settings{
|
|
"window": {Modifier: "alt", Fraction: "1/3"},
|
|
"edge": {Modifier: "alt", Fraction: "1/3"},
|
|
}}
|
|
}
|
|
|
|
func (s *resize_settings) preferences(strategy string) strategy_settings {
|
|
if p, ok := s.Strategies[strategy]; ok {
|
|
return p
|
|
}
|
|
return default_settings().Strategies[strategy]
|
|
}
|
|
|
|
func (s *resize_settings) normalize() error {
|
|
defaults := default_settings()
|
|
if s.Version == 0 {
|
|
s.Version = 1
|
|
}
|
|
if s.Version != 1 {
|
|
return fmt.Errorf("unsupported resize settings version: %d", s.Version)
|
|
}
|
|
if s.Strategy == "" {
|
|
s.Strategy = defaults.Strategy
|
|
}
|
|
if s.Strategy != "window" && s.Strategy != "edge" {
|
|
return fmt.Errorf("unknown resize strategy: %q", s.Strategy)
|
|
}
|
|
if s.Strategies == nil {
|
|
s.Strategies = make(map[string]strategy_settings)
|
|
}
|
|
for name, fallback := range defaults.Strategies {
|
|
p := s.Strategies[name]
|
|
if p.Modifier == "" {
|
|
p.Modifier = fallback.Modifier
|
|
}
|
|
if p.Modifier != "alt" && p.Modifier != "shift" {
|
|
return fmt.Errorf("invalid %s modifier: %q", name, p.Modifier)
|
|
}
|
|
p.Fraction = strings.TrimSpace(p.Fraction)
|
|
if p.Fraction == "" {
|
|
p.Fraction = fallback.Fraction
|
|
}
|
|
if _, err := parse_fraction(p.Fraction); err != nil {
|
|
return fmt.Errorf("invalid %s fraction: %w", name, err)
|
|
}
|
|
s.Strategies[name] = p
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func load_settings(path string) (resize_settings, error) {
|
|
s := default_settings()
|
|
raw, err := os.ReadFile(path)
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return s, nil
|
|
}
|
|
if err != nil {
|
|
return s, err
|
|
}
|
|
if err := json.Unmarshal(raw, &s); err != nil {
|
|
return default_settings(), err
|
|
}
|
|
if err := s.normalize(); err != nil {
|
|
return default_settings(), err
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func settings_for_invocation(path string, opts *Options, seen map[string]bool) (resize_settings, error) {
|
|
s, err := load_settings(path)
|
|
if seen["Strategy"] {
|
|
s.Strategy = opts.Strategy
|
|
}
|
|
if seen["Fraction"] {
|
|
p := s.preferences(s.Strategy)
|
|
p.Fraction = opts.Fraction
|
|
s.Strategies[s.Strategy] = p
|
|
}
|
|
return s, err
|
|
}
|
|
|
|
// Merge one changed field with the latest saved settings. Separate resize
|
|
// windows must not overwrite each other's strategy preferences.
|
|
func update_settings(path, strategy, field, value string) (resize_settings, error) {
|
|
if strategy != "window" && strategy != "edge" {
|
|
return resize_settings{}, fmt.Errorf("unknown resize strategy: %q", strategy)
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
|
|
return resize_settings{}, err
|
|
}
|
|
lock, err := os.OpenFile(path+".lock", os.O_CREATE|os.O_RDWR, 0o600)
|
|
if err != nil {
|
|
return resize_settings{}, err
|
|
}
|
|
defer lock.Close()
|
|
if err := unix.Flock(int(lock.Fd()), unix.LOCK_EX); err != nil {
|
|
return resize_settings{}, err
|
|
}
|
|
defer unix.Flock(int(lock.Fd()), unix.LOCK_UN)
|
|
s, err := load_settings(path)
|
|
if err != nil {
|
|
return s, err
|
|
}
|
|
p := s.preferences(strategy)
|
|
switch field {
|
|
case "strategy":
|
|
s.Strategy = strategy
|
|
case "modifier":
|
|
p.Modifier = value
|
|
case "fraction":
|
|
p.Fraction = value
|
|
default:
|
|
return s, fmt.Errorf("unknown resize setting: %q", field)
|
|
}
|
|
s.Strategies[strategy] = p
|
|
if err := s.normalize(); err != nil {
|
|
return s, err
|
|
}
|
|
raw, err := json.MarshalIndent(s, "", " ")
|
|
if err != nil {
|
|
return s, err
|
|
}
|
|
raw = append(raw, '\n')
|
|
return s, utils.AtomicWriteFile(path, bytes.NewReader(raw), 0o600)
|
|
}
|