yonluandClaude Opus 5
4471db3aef
Phases 2 and 3 of plan 009, plus the parts of phase 1 that could not
land before them. Nothing in the tree imports wails/v2 any more; all
three lint and test configurations are green and `go build .` produces
a running binary.
The point of the migration is one file. backend/events/emit.go probed
ctx.Value("events") — a v2-*private* context key — to decide whether
emitting was safe, because runtime.EventsEmit called log.Fatalf on a
context without the runtime and took the process down with it. v3's
emit takes no context, so that is now application.Get() == nil. D1
held: events.Emit keeps its ctx as the WithSink test seam, and all 45
call sites and 7 test files are untouched.
The bootstrap splits into application.New + Window.NewWithOptions +
Run. Ten bound services implement ServiceStartup instead of being
handed a context by hand from OnStartup, which also stops ten
SetContext methods being exported as bindings. jobs.Registry and
explore.SearchIndex keep theirs — neither is bound, so converting them
would be churn for no binding removed.
Four things differed from the plan and are written up in it: GPU policy
moved to the per-window LinuxWindow options rather than surviving on
LinuxOptions; there is no OnStartup/OnDomReady option, so app-level
wiring hangs off ApplicationStarted; application.NewService is generic,
so FEBindings []any could not survive (the binding generator is a
static analyser and would have seen nothing); and the quit veto had to
be restructured, because v3's dialog answers on a callback rather than
returning the button, so ShouldQuit vetoes, asks, and quits again from
the callback.
Window state saving moves to a WindowClosing hook — the size has to be
read while the window still exists, and v3's OnShutdown has neither
context nor window. backend/logging is deleted rather than ported:
v3 takes a *slog.Logger directly, so the v2 logger.Logger adapter had
no caller left.
Phase 1's tail rides along, now that it can: the Makefile's wails
invocations, all 50 webkit2_41 sites, lefthook, both packaging recipes
and ci.yml's apt lists. v3 builds against GTK4 + WebKitGTK 6.0, which
Arch and ubuntu:24.04 both ship, so the tag is a deletion rather than
a translation.
Phase 4 is next and the branch is not usable until it lands: the app
builds, but frontend/wailsjs/ is v2's tree and nothing regenerates it,
so the frontend cannot reach the backend yet.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UDCbcCZQepnpSQYJ6SxxZm
123 lines
3.1 KiB
Go
123 lines
3.1 KiB
Go
// Package frontendutil provides Go functions bound to the frontend.
|
|
package frontendutil
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"os"
|
|
|
|
"github.com/wailsapp/wails/v3/pkg/application"
|
|
)
|
|
|
|
// ErrNoRuntime is returned when a dialog is asked for with no running
|
|
// application to parent it to — under test, or after shutdown.
|
|
var ErrNoRuntime = errors.New("no Wails runtime to show a dialog")
|
|
|
|
// FrontendUtil provides frontend-bound Go functions.
|
|
type FrontendUtil struct {
|
|
ctx context.Context
|
|
}
|
|
|
|
// NewFrontendUtil creates a new FrontendUtil instance.
|
|
func NewFrontendUtil() (*FrontendUtil, error) {
|
|
return &FrontendUtil{}, nil
|
|
}
|
|
|
|
// ServiceStartup is v3's service lifecycle hook: it runs once the
|
|
// runtime exists, and ctx is cancelled when the app shuts down. It
|
|
// replaces v2's SetContext, which had to be called by hand from
|
|
// OnStartup and was exported, so it was also bound to the frontend.
|
|
func (fe *FrontendUtil) ServiceStartup(
|
|
ctx context.Context,
|
|
_ application.ServiceOptions,
|
|
) error {
|
|
fe.ctx = ctx
|
|
|
|
return nil
|
|
}
|
|
|
|
// DirectoryPicker opens a directory selection dialog.
|
|
//
|
|
// v3 has no separate directory dialog: it is the file dialog told to
|
|
// choose directories and not files.
|
|
func (fe *FrontendUtil) DirectoryPicker() (string, error) {
|
|
app := application.Get()
|
|
if app == nil {
|
|
return "", ErrNoRuntime
|
|
}
|
|
|
|
slog.Default().Info("selecting a directory")
|
|
|
|
dir, err := app.Dialog.OpenFile().
|
|
CanChooseDirectories(true).
|
|
CanChooseFiles(false).
|
|
PromptForSingleSelection()
|
|
if err != nil {
|
|
return "", fmt.Errorf(
|
|
"could not open directory dialog\n%w", err,
|
|
)
|
|
}
|
|
|
|
return dir, nil
|
|
}
|
|
|
|
// PlaylistFilePicker opens a file selection dialog filtered
|
|
// to M3U/M3U8 playlist files. Multiple files may be selected.
|
|
func (fe *FrontendUtil) PlaylistFilePicker() (
|
|
[]string,
|
|
error,
|
|
) {
|
|
app := application.Get()
|
|
if app == nil {
|
|
return nil, ErrNoRuntime
|
|
}
|
|
|
|
slog.Default().Info("selecting playlist files")
|
|
|
|
files, err := app.Dialog.OpenFile().
|
|
SetTitle("Import Playlist").
|
|
AddFilter("Playlist Files (*.m3u, *.m3u8)", "*.m3u;*.m3u8").
|
|
PromptForMultipleSelection()
|
|
if err != nil {
|
|
return nil, fmt.Errorf(
|
|
"could not open file dialog: %w", err,
|
|
)
|
|
}
|
|
|
|
return files, nil
|
|
}
|
|
|
|
// ImageFilePicker opens a file selection dialog filtered to image
|
|
// files (JPEG, PNG). Returns the selected file path, or empty
|
|
// string if the user cancelled.
|
|
func (fe *FrontendUtil) ImageFilePicker() (string, error) {
|
|
app := application.Get()
|
|
if app == nil {
|
|
return "", ErrNoRuntime
|
|
}
|
|
|
|
file, err := app.Dialog.OpenFile().
|
|
SetTitle("Select Cover Art").
|
|
AddFilter("Image Files (*.jpg, *.jpeg, *.png)", "*.jpg;*.jpeg;*.png").
|
|
PromptForSingleSelection()
|
|
if err != nil {
|
|
return "", fmt.Errorf("could not open file dialog: %w", err)
|
|
}
|
|
|
|
return file, nil
|
|
}
|
|
|
|
// ReadFile reads a file from disk and returns its contents.
|
|
// Used by the frontend to read cover art image files selected
|
|
// via ImageFilePicker.
|
|
func (fe *FrontendUtil) ReadFile(path string) ([]byte, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read file %q: %w", path, err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|