diff --git a/CLAUDE.md b/CLAUDE.md index 594d4c0a..402eb18a 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -38,38 +38,43 @@ The display `Service` registers with `forge.lthn.ai/core/go`'s service container All Wails application APIs are abstracted behind interfaces in `interfaces.go` (`App`, `WindowManager`, `MenuManager`, `DialogManager`, etc.). The `wailsApp` adapter wraps the real Wails app. Tests inject a `mockApp` instead — see `mocks_test.go` and the `newServiceWithMockApp(t)` helper. -### Key files in pkg/display/ +### Package structure (pkg/) -| File | Responsibility | -|------|---------------| -| `display.go` | Service struct, lifecycle (`Startup`), window CRUD, screen queries, tiling/snapping/layout, workflow presets | -| `window.go` | `WindowOption` functional options pattern, `Window` type alias for `application.WebviewWindowOptions` | -| `window_state.go` | `WindowStateManager` — persists window position/size across restarts | -| `layout.go` | `LayoutManager` — save/restore named window arrangements | -| `events.go` | `WSEventManager` — WebSocket pub/sub for window/theme/screen events | -| `interfaces.go` | Abstract interfaces + Wails adapter implementations | -| `actions.go` | `ActionOpenWindow` IPC message type | -| `menu.go` | Application menu construction | -| `tray.go` | System tray setup | -| `dialog.go` | File/directory dialogs | -| `clipboard.go` | Clipboard read/write | -| `notification.go` | System notifications | -| `theme.go` | Dark/light mode detection | -| `mocks_test.go` | Mock implementations of all interfaces for testing | +| Package | Responsibility | +|---------|---------------| +| `display` | Orchestrator service — bridges sub-service IPC to WebSocket events, menu/tray setup, config persistence | +| `window` | Window lifecycle, `Manager`, `StateManager` (position persistence), `LayoutManager` (named arrangements), tiling/snapping | +| `menu` | Application menu construction via platform abstraction | +| `systray` | System tray icon, tooltip, menu via platform abstraction | +| `dialog` | File open/save, message, confirm, and prompt dialogs | +| `clipboard` | Clipboard read/write/clear | +| `notification` | System notifications with permission management | +| `screen` | Screen/monitor queries (list, primary, at-point, work areas) | +| `environment` | Theme detection (dark/light) and OS environment info | +| `keybinding` | Global keyboard shortcut registration | +| `contextmenu` | Named context menu registration and lifecycle | +| `browser` | Open URLs and files in the default browser | +| `dock` | macOS dock icon visibility and badge | +| `lifecycle` | Application lifecycle events (start, terminate, suspend, resume) | +| `webview` | Webview automation (eval, click, type, screenshot, DOM queries) | +| `mcp` | MCP tool subsystem — exposes all services as Model Context Protocol tools | ### Patterns used throughout -- **Functional options**: `WindowOption` functions (`WindowName()`, `WindowTitle()`, `WindowWidth()`, etc.) configure `application.WebviewWindowOptions` -- **Type alias**: `Window = application.WebviewWindowOptions` — direct alias, not a wrapper +- **Platform abstraction**: Each sub-service defines a `Platform` interface and `PlatformWindow`/`PlatformTray`/etc. types; tests inject mocks +- **Functional options**: `WindowOption` functions (`WithName()`, `WithTitle()`, `WithSize()`, etc.) configure `window.Window` descriptors +- **IPC message bus**: Sub-services communicate via `core.QUERY`, `core.PERFORM`, and `core.ACTION` — display orchestrates and bridges to WebSocket events - **Event broadcasting**: `WSEventManager` uses gorilla/websocket with a buffered channel (`eventBuffer`) and per-client subscription filtering (supports `"*"` wildcard) -- **Window lookup by name**: Most Service methods iterate `s.app.Window().GetAll()` and type-assert to `*application.WebviewWindow`, then match by `Name()` +- **Error handling**: All errors use `coreerr.E(op, msg, err)` from `forge.lthn.ai/core/go-log` (aliased as `coreerr`), never `fmt.Errorf` +- **File I/O**: Use `forge.lthn.ai/core/go-io` (`coreio.Local`) for filesystem operations, never `os.ReadFile`/`os.WriteFile` ## Testing - Framework: `testify` (assert + require) -- Pattern: `newServiceWithMockApp(t)` creates a `Service` with mock Wails app — no real window system needed -- `newTestCore(t)` creates a real `core.Core` instance for integration-style tests -- Some tests use `defer func() { recover() }()` to handle nil panics from mock methods that return nil pointers (e.g., `Dialog().Info()`) +- Each sub-package has its own `*_test.go` with mock platform implementations +- `pkg/window`: `NewManagerWithDir` / `NewStateManagerWithDir` / `NewLayoutManagerWithDir` accept custom config dirs for isolated tests +- `pkg/display`: `newTestCore(t)` creates a real `core.Core` instance for integration-style tests +- Sub-services use `mock_platform.go` or `mock_test.go` for platform mocks ## CI/CD @@ -82,9 +87,13 @@ Both use reusable workflows from `core/go-devops`. ## Dependencies - `forge.lthn.ai/core/go` — Core framework with service container and DI +- `forge.lthn.ai/core/go-log` — Structured errors (`coreerr.E()`) +- `forge.lthn.ai/core/go-io` — Filesystem abstraction (`coreio.Local`) +- `forge.lthn.ai/core/config` — Configuration file management - `github.com/wailsapp/wails/v3` — Desktop app framework (alpha.74) - `github.com/gorilla/websocket` — WebSocket for real-time events - `github.com/stretchr/testify` — Test assertions +- `github.com/modelcontextprotocol/go-sdk` — MCP tool registration ## Repository migration note diff --git a/docs/RFC-CORE-008-AGENT-EXPERIENCE.md b/docs/RFC-CORE-008-AGENT-EXPERIENCE.md new file mode 100644 index 00000000..37635218 --- /dev/null +++ b/docs/RFC-CORE-008-AGENT-EXPERIENCE.md @@ -0,0 +1,440 @@ +# RFC-025: Agent Experience (AX) Design Principles + +- **Status:** Draft +- **Authors:** Snider, Cladius +- **Date:** 2026-03-19 +- **Applies to:** All Core ecosystem packages (CoreGO, CorePHP, CoreTS, core-agent) + +## Abstract + +Agent Experience (AX) is a design paradigm for software systems where the primary code consumer is an AI agent, not a human developer. AX sits alongside User Experience (UX) and Developer Experience (DX) as the third era of interface design. + +This RFC establishes AX as a formal design principle for the Core ecosystem and defines the conventions that follow from it. + +## Motivation + +As of early 2026, AI agents write, review, and maintain the majority of code in the Core ecosystem. The original author has not manually edited code (outside of Core struct design) since October 2025. Code is processed semantically — agents reason about intent, not characters. + +Design patterns inherited from the human-developer era optimise for the wrong consumer: + +- **Short names** save keystrokes but increase semantic ambiguity +- **Functional option chains** are fluent for humans but opaque for agents tracing configuration +- **Error-at-every-call-site** produces 50% boilerplate that obscures intent +- **Generic type parameters** force agents to carry type context that the runtime already has +- **Panic-hiding conventions** (`Must*`) create implicit control flow that agents must special-case + +AX acknowledges this shift and provides principles for designing code, APIs, file structures, and conventions that serve AI agents as first-class consumers. + +## The Three Eras + +| Era | Primary Consumer | Optimises For | Key Metric | +|-----|-----------------|---------------|------------| +| UX | End users | Discoverability, forgiveness, visual clarity | Task completion time | +| DX | Developers | Typing speed, IDE support, convention familiarity | Time to first commit | +| AX | AI agents | Predictability, composability, semantic navigation | Correct-on-first-pass rate | + +AX does not replace UX or DX. End users still need good UX. Developers still need good DX. But when the primary code author and maintainer is an AI agent, the codebase should be designed for that consumer first. + +## Principles + +### 1. Predictable Names Over Short Names + +Names are tokens that agents pattern-match across languages and contexts. Abbreviations introduce mapping overhead. + +``` +Config not Cfg +Service not Srv +Embed not Emb +Error not Err (as a subsystem name; err for local variables is fine) +Options not Opts +``` + +**Rule:** If a name would require a comment to explain, it is too short. + +**Exception:** Industry-standard abbreviations that are universally understood (`HTTP`, `URL`, `ID`, `IPC`, `I18n`) are acceptable. The test: would an agent trained on any mainstream language recognise it without context? + +### 2. Comments as Usage Examples + +The function signature tells WHAT. The comment shows HOW with real values. + +```go +// Detect the project type from files present +setup.Detect("/path/to/project") + +// Set up a workspace with auto-detected template +setup.Run(setup.Options{Path: ".", Template: "auto"}) + +// Scaffold a PHP module workspace +setup.Run(setup.Options{Path: "./my-module", Template: "php"}) +``` + +**Rule:** If a comment restates what the type signature already says, delete it. If a comment shows a concrete usage with realistic values, keep it. + +**Rationale:** Agents learn from examples more effectively than from descriptions. A comment like "Run executes the setup process" adds zero information. A comment like `setup.Run(setup.Options{Path: ".", Template: "auto"})` teaches an agent exactly how to call the function. + +### 3. Path Is Documentation + +File and directory paths should be self-describing. An agent navigating the filesystem should understand what it is looking at without reading a README. + +``` +flow/deploy/to/homelab.yaml — deploy TO the homelab +flow/deploy/from/github.yaml — deploy FROM GitHub +flow/code/review.yaml — code review flow +template/file/go/struct.go.tmpl — Go struct file template +template/dir/workspace/php/ — PHP workspace scaffold +``` + +**Rule:** If an agent needs to read a file to understand what a directory contains, the directory naming has failed. + +**Corollary:** The unified path convention (folder structure = HTTP route = CLI command = test path) is AX-native. One path, every surface. + +### 4. Templates Over Freeform + +When an agent generates code from a template, the output is constrained to known-good shapes. When an agent writes freeform, the output varies. + +```go +// Template-driven — consistent output +lib.RenderFile("php/action", data) +lib.ExtractDir("php", targetDir, data) + +// Freeform — variance in output +"write a PHP action class that..." +``` + +**Rule:** For any code pattern that recurs, provide a template. Templates are guardrails for agents. + +**Scope:** Templates apply to file generation, workspace scaffolding, config generation, and commit messages. They do NOT apply to novel logic — agents should write business logic freeform with the domain knowledge available. + +### 5. Declarative Over Imperative + +Agents reason better about declarations of intent than sequences of operations. + +```yaml +# Declarative — agent sees what should happen +steps: + - name: build + flow: tools/docker-build + with: + context: "{{ .app_dir }}" + image_name: "{{ .image_name }}" + + - name: deploy + flow: deploy/with/docker + with: + host: "{{ .host }}" +``` + +```go +// Imperative — agent must trace execution +cmd := exec.Command("docker", "build", "--platform", "linux/amd64", "-t", imageName, ".") +cmd.Dir = appDir +if err := cmd.Run(); err != nil { + return fmt.Errorf("docker build: %w", err) +} +``` + +**Rule:** Orchestration, configuration, and pipeline logic should be declarative (YAML/JSON). Implementation logic should be imperative (Go/PHP/TS). The boundary is: if an agent needs to compose or modify the logic, make it declarative. + +### 6. Universal Types (Core Primitives) + +Every component in the ecosystem accepts and returns the same primitive types. An agent processing any level of the tree sees identical shapes. + +```go +// Universal contract +setup.Run(core.Options{Path: ".", Template: "auto"}) +brain.New(core.Options{Name: "openbrain"}) +deploy.Run(core.Options{Flow: "deploy/to/homelab"}) + +// Fractal — Core itself is a Service +core.New(core.Options{ + Services: []core.Service{ + process.New(core.Options{Name: "process"}), + brain.New(core.Options{Name: "brain"}), + }, +}) +``` + +**Core primitive types:** + +| Type | Purpose | +|------|---------| +| `core.Options` | Input configuration (what you want) | +| `core.Config` | Runtime settings (what is active) | +| `core.Data` | Embedded or stored content | +| `core.Service` | A managed component with lifecycle | +| `core.Result[T]` | Return value with OK/fail state | + +**What this replaces:** + +| Go Convention | Core AX | Why | +|--------------|---------|-----| +| `func With*(v) Option` | `core.Options{Field: v}` | Struct literal is parseable; option chain requires tracing | +| `func Must*(v) T` | `core.Result[T]` | No hidden panics; errors flow through Core | +| `func *For[T](c) T` | `c.Service("name")` | String lookup is greppable; generics require type context | +| `val, err :=` everywhere | Single return via `core.Result` | Intent not obscured by error handling | +| `_ = err` | Never needed | Core handles all errors internally | + +### 7. Directory as Semantics + +The directory structure tells an agent the intent before it reads a word. Top-level directories are semantic categories, not organisational bins. + +``` +plans/ +├── code/ # Pure primitives — read for WHAT exists +├── project/ # Products — read for WHAT we're building and WHY +└── rfc/ # Contracts — read for constraints and rules +``` + +**Rule:** An agent should know what kind of document it's reading from the path alone. `code/core/go/io/RFC.md` = a lib primitive spec. `project/ofm/RFC.md` = a product spec that cross-references code/. `rfc/snider/borg/RFC-BORG-006-SMSG-FORMAT.md` = an immutable contract for the Borg SMSG protocol. + +**Corollary:** The three-way split (code/project/rfc) extends principle 3 (Path Is Documentation) from files to entire subtrees. The path IS the metadata. + +### 8. Lib Never Imports Consumer + +Dependency flows one direction. Libraries define primitives. Consumers compose from them. A new feature in a consumer can never break a library. + +``` +code/core/go/* → lib tier (stable foundation) +code/core/agent/ → consumer tier (composes from go/*) +code/core/cli/ → consumer tier (composes from go/*) +code/core/gui/ → consumer tier (composes from go/*) +``` + +**Rule:** If package A is in `go/` and package B is in the consumer tier, B may import A but A must never import B. The repo naming convention enforces this: `go-{name}` = lib, bare `{name}` = consumer. + +**Why this matters for agents:** When an agent is dispatched to implement a feature in `core/agent`, it can freely import from `go-io`, `go-scm`, `go-process`. But if an agent is dispatched to `go-io`, it knows its changes are foundational — every consumer depends on it, so the contract must not break. + +### 9. Issues Are N+(rounds) Deep + +Problems in code and specs are layered. Surface issues mask deeper issues. Fixing the surface reveals the next layer. This is not a failure mode — it is the discovery process. + +``` +Pass 1: Find 16 issues (surface — naming, imports, obvious errors) +Pass 2: Find 11 issues (structural — contradictions, missing types) +Pass 3: Find 5 issues (architectural — signature mismatches, registration gaps) +Pass 4: Find 4 issues (contract — cross-spec API mismatches) +Pass 5: Find 2 issues (mechanical — path format, nil safety) +Pass N: Findings are trivial → spec/code is complete +``` + +**Rule:** Iteration is required, not a failure. Each pass sees what the previous pass could not, because the context changed. An agent dispatched with the same task on the same repo will find different things each time — this is correct behaviour. + +**Corollary:** The cheapest model should do the most passes (surface work). The frontier model should arrive last, when only deep issues remain. Tiered iteration: grunt model grinds → mid model pre-warms → frontier model polishes. + +**Anti-pattern:** One-shot generation expecting valid output. No model, no human, produces correct-on-first-pass for non-trivial work. Expecting it wastes the first pass on surface issues that a cheaper pass would have caught. + +### 10. CLI Tests as Artifact Validation + +Unit tests verify the code. CLI tests verify the binary. The directory structure IS the command structure — path maps to command, Taskfile runs the test. + +``` +tests/cli/ +├── core/ +│ └── lint/ +│ ├── Taskfile.yaml ← test `core-lint` (root) +│ ├── run/ +│ │ ├── Taskfile.yaml ← test `core-lint run` +│ │ └── fixtures/ +│ ├── go/ +│ │ ├── Taskfile.yaml ← test `core-lint go` +│ │ └── fixtures/ +│ └── security/ +│ ├── Taskfile.yaml ← test `core-lint security` +│ └── fixtures/ +``` + +**Rule:** Every CLI command has a matching `tests/cli/{path}/Taskfile.yaml`. The Taskfile runs the compiled binary against fixtures with known inputs and validates the output. If the CLI test passes, the underlying actions work — because CLI commands call actions, MCP tools call actions, API endpoints call actions. Test the CLI, trust the rest. + +**Pattern:** + +```yaml +# tests/cli/core/lint/go/Taskfile.yaml +version: '3' +tasks: + test: + cmds: + - core-lint go --output json fixtures/ > /tmp/result.json + - jq -e '.findings | length > 0' /tmp/result.json + - jq -e '.summary.passed == false' /tmp/result.json +``` + +**Why this matters for agents:** An agent can validate its own work by running `task test` in the matching `tests/cli/` directory. No test framework, no mocking, no setup — just the binary, fixtures, and `jq` assertions. The agent builds the binary, runs the test, sees the result. If it fails, the agent can read the fixture, read the output, and fix the code. + +**Corollary:** Fixtures are planted bugs. Each fixture file has a known issue that the linter must find. If the linter doesn't find it, the test fails. Fixtures are the spec for what the tool must detect — they ARE the test cases, not descriptions of test cases. + +## Applying AX to Existing Patterns + +### File Structure + +``` +# AX-native: path describes content +core/agent/ +├── go/ # Go source +├── php/ # PHP source +├── ui/ # Frontend source +├── claude/ # Claude Code plugin +└── codex/ # Codex plugin + +# Not AX: generic names requiring README +src/ +├── lib/ +├── utils/ +└── helpers/ +``` + +### Error Handling + +```go +// AX-native: errors are infrastructure, not application logic +svc := c.Service("brain") +cfg := c.Config().Get("database.host") +// Errors logged by Core. Code reads like a spec. + +// Not AX: errors dominate the code +svc, err := c.ServiceFor[brain.Service]() +if err != nil { + return fmt.Errorf("get brain service: %w", err) +} +cfg, err := c.Config().Get("database.host") +if err != nil { + _ = err // silenced because "it'll be fine" +} +``` + +### API Design + +```go +// AX-native: one shape, every surface +core.New(core.Options{ + Name: "my-app", + Services: []core.Service{...}, + Config: core.Config{...}, +}) + +// Not AX: multiple patterns for the same thing +core.New( + core.WithName("my-app"), + core.WithService(factory1), + core.WithService(factory2), + core.WithConfig(cfg), +) +``` + +## The Plans Convention — AX Development Lifecycle + +The `plans/` directory structure encodes a development methodology designed for how generative AI actually works: iterative refinement across structured phases, not one-shot generation. + +### The Three-Way Split + +``` +plans/ +├── project/ # 1. WHAT and WHY — start here +├── rfc/ # 2. CONSTRAINTS — immutable contracts +└── code/ # 3. HOW — implementation specs +``` + +Each directory is a phase. Work flows from project → rfc → code. Each transition forces a refinement pass — you cannot write a code spec without discovering gaps in the project spec, and you cannot write an RFC without discovering assumptions in both. + +**Three places for data that can't be written simultaneously = three guaranteed iterations of "actually, this needs changing."** Refinement is baked into the structure, not bolted on as a review step. + +### Phase 1: Project (Vision) + +Start with `project/`. No code exists yet. Define: +- What the product IS and who it serves +- What existing primitives it consumes (cross-ref to `code/`) +- What constraints it operates under (cross-ref to `rfc/`) + +This is where creativity lives. Map features to building blocks. Connect systems. The project spec is integrative — it references everything else. + +### Phase 2: RFC (Contracts) + +Extract the immutable rules into `rfc/`. These are constraints that don't change with implementation: +- Wire formats, protocols, hash algorithms +- Security properties that must hold +- Compatibility guarantees + +RFCs are numbered per component (`RFC-BORG-006-SMSG-FORMAT.md`) and never modified after acceptance. If the contract changes, write a new RFC. + +### Phase 3: Code (Implementation Specs) + +Define the implementation in `code/`. Each component gets an RFC.md that an agent can implement from: +- Struct definitions (the DTOs — see principle 6) +- Method signatures and behaviour +- Error conditions and edge cases +- Cross-references to other code/ specs + +The code spec IS the product. Write the spec → dispatch to an agent → review output → iterate. + +### Pre-Launch: Alignment Protocol + +Before dispatching for implementation, verify spec-model alignment: + +``` +1. REVIEW — The implementation model (Codex/Jules) reads the spec + and reports missing elements. This surfaces the delta between + the model's training and the spec's assumptions. + + "I need X, Y, Z to implement this" is the model saying + "I hear you but I'm missing context" — without asking. + +2. ADJUST — Update the spec to close the gaps. Add examples, + clarify ambiguities, provide the context the model needs. + This is shared alignment, not compromise. + +3. VERIFY — A different model (or sub-agent) reviews the adjusted + spec without the planner's bias. Fresh eyes on the contract. + "Does this make sense to someone who wasn't in the room?" + +4. READY — When the review findings are trivial or deployment- + related (not architectural), the spec is ready to dispatch. +``` + +### Implementation: Iterative Dispatch + +Same prompt, multiple runs. Each pass sees deeper because the context evolved: + +``` +Round 1: Build features (the obvious gaps) +Round 2: Write tests (verify what was built) +Round 3: Harden security (what can go wrong?) +Round 4: Next RFC section (what's still missing?) +Round N: Findings are trivial → implementation is complete +``` + +Re-running is not failure. It is the process. Each pass changes the codebase, which changes what the next pass can see. The iteration IS the refinement. + +### Post-Implementation: Auto-Documentation + +The QA/verify chain produces artefacts that feed forward: +- Test results document the contract (what works, what doesn't) +- Coverage reports surface untested paths +- Diff summaries prep the changelog for the next release +- Doc site updates from the spec (the spec IS the documentation) + +The output of one cycle is the input to the next. The plans repo stays current because the specs drive the code, not the other way round. + +## Compatibility + +AX conventions are valid, idiomatic Go/PHP/TS. They do not require language extensions, code generation, or non-standard tooling. An AX-designed codebase compiles, tests, and deploys with standard toolchains. + +The conventions diverge from community patterns (functional options, Must/For, etc.) but do not violate language specifications. This is a style choice, not a fork. + +## Adoption + +AX applies to all new code in the Core ecosystem. Existing code migrates incrementally as it is touched — no big-bang rewrite. + +Priority order: +1. **Public APIs** (package-level functions, struct constructors) +2. **File structure** (path naming, template locations) +3. **Internal fields** (struct field names, local variables) + +## References + +- dAppServer unified path convention (2024) +- CoreGO DTO pattern refactor (2026-03-18) +- Core primitives design (2026-03-19) +- Go Proverbs, Rob Pike (2015) — AX provides an updated lens + +## Changelog + +- 2026-03-19: Initial draft diff --git a/docs/ref/wails-v3/go.mod b/docs/ref/wails-v3/go.mod index 41e6ac79..7dcb8325 100644 --- a/docs/ref/wails-v3/go.mod +++ b/docs/ref/wails-v3/go.mod @@ -1,3 +1,3 @@ module github.com/wailsapp/wails/v3 -go 1.24 +go 1.26.0 diff --git a/docs/ref/wails-v3/src/application/assets/index.html b/docs/ref/wails-v3/src/application/assets/index.html new file mode 100644 index 00000000..36bba670 --- /dev/null +++ b/docs/ref/wails-v3/src/application/assets/index.html @@ -0,0 +1,9 @@ + + + + + Wails Assets Placeholder + + + + diff --git a/go.mod b/go.mod index c84277c0..74d25988 100644 --- a/go.mod +++ b/go.mod @@ -3,20 +3,23 @@ module dappco.re/go/core/gui go 1.26.0 require ( - dappco.re/go/core/config v0.1.8 - dappco.re/go/core v0.3.3 - dappco.re/go/core/webview v0.1.7 + forge.lthn.ai/core/config v0.1.8 + forge.lthn.ai/core/go v0.3.3 + forge.lthn.ai/core/go-io v0.1.7 + forge.lthn.ai/core/go-log v0.0.4 + forge.lthn.ai/core/go-webview v0.1.7 github.com/gorilla/websocket v1.5.3 github.com/modelcontextprotocol/go-sdk v1.4.1 github.com/stretchr/testify v1.11.1 github.com/wailsapp/wails/v3 v3.0.0-alpha.74 ) -replace github.com/wailsapp/wails/v3 => ./stubs/wails/v3 +replace github.com/wailsapp/wails/v3 => ./stubs/wails require ( - dappco.re/go/core/io v0.1.7 // indirect - dappco.re/go/core/log v0.0.4 // indirect + dappco.re/go/core v0.8.0-alpha.1 // indirect + dappco.re/go/core/io v0.2.0 // indirect + dappco.re/go/core/log v0.1.0 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/fsnotify/fsnotify v1.9.0 // indirect github.com/go-viper/mapstructure/v2 v2.5.0 // indirect diff --git a/go.sum b/go.sum index d4799104..99b2e6a7 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,9 @@ -cloud.google.com/go/compute/metadata v0.3.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= -dappco.re/go/core v0.3.3 h1:TaE7/SObQ3YEZj4ov1BAXWwLJEIttkrxzncVGewR3Bs= -dappco.re/go/core v0.3.3/go.mod h1:Cp4ac25pghvO2iqOu59t1GyngTKVOzKB5/VPdhRi9CQ= -forge.lthn.ai/Snider/Borg v0.3.1/go.mod h1:Z7DJD0yHXsxSyM7Mjl6/g4gH1NBsIz44Bf5AFlV76Wg= +dappco.re/go/core v0.8.0-alpha.1 h1:gj7+Scv+L63Z7wMxbJYHhaRFkHJo2u4MMPuUSv/Dhtk= +dappco.re/go/core v0.8.0-alpha.1/go.mod h1:f2/tBZ3+3IqDrg2F5F598llv0nmb/4gJVCFzM5geE4A= +dappco.re/go/core/io v0.2.0 h1:zuudgIiTsQQ5ipVt97saWdGLROovbEB/zdVyy9/l+I4= +dappco.re/go/core/io v0.2.0/go.mod h1:1QnQV6X9LNgFKfm8SkOtR9LLaj3bDcsOIeJOOyjbL5E= +dappco.re/go/core/log v0.1.0 h1:pa71Vq2TD2aoEUQWFKwNcaJ3GBY8HbaNGqtE688Unyc= +dappco.re/go/core/log v0.1.0/go.mod h1:Nkqb8gsXhZAO8VLpx7B8i1iAmohhzqA20b9Zr8VUcJs= forge.lthn.ai/core/config v0.1.8 h1:xP2hys7T94QGVF/OTh84/Zr5Dm/dL/0vzjht8zi+LOg= forge.lthn.ai/core/config v0.1.8/go.mod h1:8epZrkwoCt+5ayrqdinOUU/+w6UoxOyv9ZrdgVOgYfQ= forge.lthn.ai/core/go v0.3.3 h1:kYYZ2nRYy0/Be3cyuLJspRjLqTMxpckVyhb/7Sw2gd0= @@ -13,22 +15,8 @@ forge.lthn.ai/core/go-log v0.0.4 h1:KTuCEPgFmuM8KJfnyQ8vPOU1Jg654W74h8IJvfQMfv0= forge.lthn.ai/core/go-log v0.0.4/go.mod h1:r14MXKOD3LF/sI8XUJQhRk/SZHBE7jAFVuCfgkXoZPw= forge.lthn.ai/core/go-webview v0.1.7 h1:9+aEHeAvNcPX8Zwr+UGu0/T+menRm5T1YOmqZ9dawDc= forge.lthn.ai/core/go-webview v0.1.7/go.mod h1:5n1tECD1wBV/uFZRY9ZjfPFO5TYZrlaR3mQFwvO2nek= -github.com/ProtonMail/go-crypto v1.4.0/go.mod h1:e1OaTyu5SYVrO9gKOEhTc+5UcXtTUa+P3uLudwcgPqo= -github.com/aws/aws-sdk-go-v2 v1.41.4/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o= -github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.7/go.mod h1:lyw7GFp3qENLh7kwzf7iMzAxDn+NzjXEAGjKS2UOKqI= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.20/go.mod h1:oydPDJKcfMhgfcgBUZaG+toBbwy8yPWubJXBVERtI4o= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.20/go.mod h1:YJ898MhD067hSHA6xYCx5ts/jEd8BSOLtQDL3iZsvbc= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.21/go.mod h1:UUxgWxofmOdAMuqEsSppbDtGKLfR04HGsD0HXzvhI1k= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI= -github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.12/go.mod h1:v2pNpJbRNl4vEUWEh5ytQok0zACAKfdmKS51Hotc3pQ= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.20/go.mod h1:V4X406Y666khGa8ghKmphma/7C0DAtEQYhkq9z4vpbk= -github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.20/go.mod h1:4TLZCmVJDM3FOu5P5TJP0zOlu9zWgDWU7aUxWbr+rcw= -github.com/aws/aws-sdk-go-v2/service/s3 v1.97.1/go.mod h1:qXVal5H0ChqXP63t6jze5LmFalc7+ZE7wOdLtZ0LCP0= -github.com/aws/smithy-go v1.24.2/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= -github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= @@ -41,22 +29,18 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/jsonschema-go v0.4.2 h1:tmrUohrwoLZZS/P3x7ex0WAVknEkBZM46iALbcqoRA8= github.com/google/jsonschema-go v0.4.2/go.mod h1:r5quNTdLOYEz95Ru18zA0ydNbBuYoo9tgaYcxEYhJVE= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/modelcontextprotocol/go-sdk v1.4.1 h1:M4x9GyIPj+HoIlHNGpK2hq5o3BFhC+78PkEaldQRphc= github.com/modelcontextprotocol/go-sdk v1.4.1/go.mod h1:Bo/mS87hPQqHSRkMv4dQq1XCu6zv4INdXnFZabkNU6s= -github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/sagikazarmark/locafero v0.12.0 h1:/NQhBAkUb4+fH1jivKHWusDYFjMOOKU88eegjfxfHb4= @@ -65,7 +49,6 @@ github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0= github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= github.com/segmentio/encoding v0.5.4 h1:OW1VRern8Nw6ITAtwSZ7Idrl3MXCFwXHPgqESYfvNt0= github.com/segmentio/encoding v0.5.4/go.mod h1:HS1ZKa3kSN32ZHVZ7ZLPLXWvOVIiZtyJnO1gPH1sKt0= -github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U= github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I= github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg= github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY= @@ -74,7 +57,6 @@ github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk= github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU= github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= @@ -83,11 +65,8 @@ github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zI github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4= go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= -golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA= -golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= -golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo= golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8= diff --git a/internal/wails3 b/internal/wails3 new file mode 160000 index 00000000..bb4fbf95 --- /dev/null +++ b/internal/wails3 @@ -0,0 +1 @@ +Subproject commit bb4fbf95744fafe5acf84e143a419bfffc2159e6 diff --git a/pkg/browser/register.go b/pkg/browser/register.go index ff081e78..bb9dffb0 100644 --- a/pkg/browser/register.go +++ b/pkg/browser/register.go @@ -1,10 +1,9 @@ -// pkg/browser/register.go package browser import "forge.lthn.ai/core/go/pkg/core" -// Register creates a factory closure that captures the Platform adapter. -// The returned function has the signature WithService requires: func(*Core) (any, error). +// Register(p) binds the browser service to a Core instance. +// core.WithService(browser.Register(wailsBrowser)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ diff --git a/pkg/browser/service.go b/pkg/browser/service.go index a3b8915f..7d05721e 100644 --- a/pkg/browser/service.go +++ b/pkg/browser/service.go @@ -1,4 +1,3 @@ -// pkg/browser/service.go package browser import ( @@ -7,29 +6,22 @@ import ( "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the browser service. type Options struct{} -// Service is a core.Service that delegates browser/file-open operations -// to the platform. It is stateless — no queries, no actions. type Service struct { *core.ServiceRuntime[Options] platform Platform } -// OnStartup registers IPC handlers. func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterTask(s.handleTask) return nil } -// HandleIPCEvents is auto-discovered and registered by core.WithService. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } -// --- Task Handlers --- - func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { case TaskOpenURL: diff --git a/pkg/clipboard/messages.go b/pkg/clipboard/messages.go index e6a703fb..72051e04 100644 --- a/pkg/clipboard/messages.go +++ b/pkg/clipboard/messages.go @@ -4,9 +4,15 @@ package clipboard // QueryText reads the clipboard. Result: ClipboardContent type QueryText struct{} +// QueryImage reads image data from the clipboard. Result: ImageContent +type QueryImage struct{} + // TaskSetText writes text to the clipboard. Result: bool (success) type TaskSetText struct{ Text string } +// TaskSetImage writes image data to the clipboard. Result: bool (success) +type TaskSetImage struct{ Data []byte } + // TaskClear clears the clipboard. Result: bool (success) type TaskClear struct{} diff --git a/pkg/clipboard/platform.go b/pkg/clipboard/platform.go index 3dd1d592..614f7e6e 100644 --- a/pkg/clipboard/platform.go +++ b/pkg/clipboard/platform.go @@ -9,27 +9,20 @@ type Platform interface { SetText(text string) bool } +// ImagePlatform is an optional extension for clipboard backends that support images. +type ImagePlatform interface { + Image() ([]byte, bool) + SetImage(data []byte) bool +} + // ClipboardContent is the result of QueryText. type ClipboardContent struct { Text string `json:"text"` HasContent bool `json:"hasContent"` } -// imageReader is an optional clipboard capability for image reads. -type imageReader interface { - Image() ([]byte, bool) -} - -// imageWriter is an optional clipboard capability for image writes. -type imageWriter interface { - SetImage(data []byte) bool -} - -// encodeImageContent converts raw bytes to transport-safe clipboard image content. -func encodeImageContent(data []byte) ClipboardImageContent { - return ClipboardImageContent{ - Base64: base64.StdEncoding.EncodeToString(data), - MimeType: "image/png", - HasContent: len(data) > 0, - } +// ImageContent is the result of QueryImage. +type ImageContent struct { + Data []byte `json:"data"` + HasImage bool `json:"hasImage"` } diff --git a/pkg/clipboard/service.go b/pkg/clipboard/service.go index fa8c4c2d..196e6c6c 100644 --- a/pkg/clipboard/service.go +++ b/pkg/clipboard/service.go @@ -4,22 +4,19 @@ package clipboard import ( "context" + coreerr "forge.lthn.ai/core/go-log" "forge.lthn.ai/core/go/pkg/core" ) -// Options configures the clipboard service. -// Use: core.WithService(clipboard.Register(platform)) type Options struct{} -// Service manages clipboard operations via Core queries and tasks. -// Use: svc := &clipboard.Service{} type Service struct { *core.ServiceRuntime[Options] platform Platform } -// Register creates a Core service factory for the clipboard backend. -// Use: core.New(core.WithService(clipboard.Register(platform))) +// Register(p) binds the clipboard service to a Core instance. +// c.WithService(clipboard.Register(wailsClipboard)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ @@ -29,15 +26,12 @@ func Register(p Platform) func(*core.Core) (any, error) { } } -// OnStartup registers clipboard handlers with Core. -// Use: _ = svc.OnStartup(context.Background()) func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterQuery(s.handleQuery) s.Core().RegisterTask(s.handleTask) return nil } -// HandleIPCEvents satisfies Core's IPC hook. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -48,11 +42,12 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { text, ok := s.platform.Text() return ClipboardContent{Text: text, HasContent: ok && text != ""}, true, nil case QueryImage: - if reader, ok := s.platform.(imageReader); ok { - data, _ := reader.Image() - return encodeImageContent(data), true, nil + imgPlatform, ok := s.platform.(ImagePlatform) + if !ok { + return ImageContent{}, true, nil } - return ClipboardImageContent{MimeType: "image/png"}, true, nil + data, hasImage := imgPlatform.Image() + return ImageContent{Data: data, HasImage: hasImage && len(data) > 0}, true, nil default: return nil, false, nil } @@ -62,18 +57,18 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { case TaskSetText: return s.platform.SetText(t.Text), true, nil - case TaskClear: - _ = s.platform.SetText("") - if writer, ok := s.platform.(imageWriter); ok { - // Best-effort clear for image-aware clipboard backends. - _ = writer.SetImage(nil) - } - return true, true, nil case TaskSetImage: - if writer, ok := s.platform.(imageWriter); ok { - return writer.SetImage(t.Data), true, nil + imgPlatform, ok := s.platform.(ImagePlatform) + if !ok { + return nil, true, coreerr.E("clipboard.handleTask", "clipboard image operations are not supported by this platform", nil) } - return false, true, core.E("clipboard.handleTask", "clipboard image write not supported", nil) + return imgPlatform.SetImage(t.Data), true, nil + case TaskClear: + success := s.platform.SetText("") + if imgPlatform, ok := s.platform.(ImagePlatform); ok { + success = imgPlatform.SetImage(nil) && success + } + return success, true, nil default: return nil, false, nil } diff --git a/pkg/clipboard/service_test.go b/pkg/clipboard/service_test.go index 5991d2d5..c7ee3c8f 100644 --- a/pkg/clipboard/service_test.go +++ b/pkg/clipboard/service_test.go @@ -11,10 +11,10 @@ import ( ) type mockPlatform struct { - text string - ok bool - img []byte - imgOk bool + text string + ok bool + image []byte + hasImage bool } func (m *mockPlatform) Text() (string, bool) { return m.text, m.ok } @@ -23,10 +23,10 @@ func (m *mockPlatform) SetText(text string) bool { m.ok = text != "" return true } -func (m *mockPlatform) Image() ([]byte, bool) { return m.img, m.imgOk } +func (m *mockPlatform) Image() ([]byte, bool) { return m.image, m.hasImage } func (m *mockPlatform) SetImage(data []byte) bool { - m.img = data - m.imgOk = len(data) > 0 + m.image = append([]byte(nil), data...) + m.hasImage = len(data) > 0 return true } @@ -89,32 +89,15 @@ func TestTaskClear_Good(t *testing.T) { } func TestQueryImage_Good(t *testing.T) { - mock := &mockPlatform{img: []byte{1, 2, 3}, imgOk: true} - c, err := core.New( - core.WithService(Register(mock)), - core.WithServiceLock(), - ) + _, c := newTestService(t) + _, handled, err := c.PERFORM(TaskSetImage{Data: []byte{0x89, 0x50, 0x4e, 0x47}}) require.NoError(t, err) - require.NoError(t, c.ServiceStartup(context.Background(), nil)) + assert.True(t, handled) result, handled, err := c.QUERY(QueryImage{}) require.NoError(t, err) assert.True(t, handled) - image := result.(ClipboardImageContent) - assert.True(t, image.HasContent) -} - -func TestTaskSetImage_Good(t *testing.T) { - mock := &mockPlatform{} - c, err := core.New( - core.WithService(Register(mock)), - core.WithServiceLock(), - ) - require.NoError(t, err) - require.NoError(t, c.ServiceStartup(context.Background(), nil)) - - _, handled, err := c.PERFORM(TaskSetImage{Data: []byte{9, 8, 7}}) - require.NoError(t, err) - assert.True(t, handled) - assert.True(t, mock.imgOk) + content := result.(ImageContent) + assert.True(t, content.HasImage) + assert.Equal(t, []byte{0x89, 0x50, 0x4e, 0x47}, content.Data) } diff --git a/pkg/contextmenu/messages.go b/pkg/contextmenu/messages.go index c596a94b..30cd6a42 100644 --- a/pkg/contextmenu/messages.go +++ b/pkg/contextmenu/messages.go @@ -1,42 +1,57 @@ -// pkg/contextmenu/messages.go package contextmenu -import corego "dappco.re/go/core" +import core "dappco.re/go/core" -// ErrMenuNotFound is returned when attempting to remove or get a menu -// that does not exist in the registry. -var ErrMenuNotFound = corego.NewError("contextmenu: menu not found") +var ErrorMenuNotFound = core.E("contextmenu", "menu not found", nil) -// --- Queries --- - -// QueryGet returns a single context menu by name. Result: *ContextMenuDef (nil if not found) +// QueryGet returns a named context menu definition. Result: *ContextMenuDef (nil if not found) +// +// result := c.QUERY(contextmenu.QueryGet{Name: "editor"}) type QueryGet struct { Name string `json:"name"` } // QueryList returns all registered context menus. Result: map[string]ContextMenuDef +// +// result := c.QUERY(contextmenu.QueryList{}) type QueryList struct{} -// --- Tasks --- +// QueryGetAll returns all context menus as a slice. Result: []ContextMenuDef +// +// result := c.QUERY(contextmenu.QueryGetAll{}) +type QueryGetAll struct{} -// TaskAdd registers a context menu. Result: nil -// If a menu with the same name already exists it is replaced (remove + re-add). +// TaskAdd registers a named context menu. Replaces if already exists. +// +// c.PERFORM(contextmenu.TaskAdd{Name: "editor", Menu: def}) type TaskAdd struct { Name string `json:"name"` Menu ContextMenuDef `json:"menu"` } -// TaskRemove unregisters a context menu. Result: nil -// Returns ErrMenuNotFound if the menu does not exist. +// TaskRemove unregisters a context menu by name. Error: ErrorMenuNotFound if missing. +// +// c.PERFORM(contextmenu.TaskRemove{Name: "editor"}) type TaskRemove struct { Name string `json:"name"` } -// --- Actions --- +// TaskUpdate replaces a context menu definition. Error: ErrorMenuNotFound if missing. +// +// c.PERFORM(contextmenu.TaskUpdate{Name: "editor", Menu: newDef}) +type TaskUpdate struct { + Name string `json:"name"` + Menu ContextMenuDef `json:"menu"` +} + +// TaskDestroy removes a context menu and releases resources. +// +// c.PERFORM(contextmenu.TaskDestroy{Name: "editor"}) +type TaskDestroy struct { + Name string `json:"name"` +} // ActionItemClicked is broadcast when a context menu item is clicked. -// The Data field is populated from the CSS --custom-contextmenu-data property -// on the element that triggered the context menu. type ActionItemClicked struct { MenuName string `json:"menuName"` ActionID string `json:"actionId"` diff --git a/pkg/contextmenu/register.go b/pkg/contextmenu/register.go index afb06044..548be983 100644 --- a/pkg/contextmenu/register.go +++ b/pkg/contextmenu/register.go @@ -1,16 +1,15 @@ -// pkg/contextmenu/register.go package contextmenu import "forge.lthn.ai/core/go/pkg/core" -// Register creates a factory closure that captures the Platform adapter. -// The returned function has the signature WithService requires: func(*Core) (any, error). +// Register(p) binds the context menu service to a Core instance. +// core.WithService(contextmenu.Register(wailsContextMenu)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ - ServiceRuntime: core.NewServiceRuntime[Options](c, Options{}), - platform: p, - menus: make(map[string]ContextMenuDef), + ServiceRuntime: core.NewServiceRuntime[Options](c, Options{}), + platform: p, + registeredMenus: make(map[string]ContextMenuDef), }, nil } } diff --git a/pkg/contextmenu/service.go b/pkg/contextmenu/service.go index 8ff3a507..f1ded3f4 100644 --- a/pkg/contextmenu/service.go +++ b/pkg/contextmenu/service.go @@ -4,30 +4,24 @@ package contextmenu import ( "context" - corego "dappco.re/go/core" + coreerr "forge.lthn.ai/core/go-log" "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the context menu service. type Options struct{} -// Service is a core.Service managing context menus via IPC. -// It maintains an in-memory registry of menus (map[string]ContextMenuDef) -// and delegates platform-level registration to the Platform interface. type Service struct { *core.ServiceRuntime[Options] - platform Platform - menus map[string]ContextMenuDef + platform Platform + registeredMenus map[string]ContextMenuDef } -// OnStartup registers IPC handlers. func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterQuery(s.handleQuery) s.Core().RegisterTask(s.handleTask) return nil } -// HandleIPCEvents is auto-discovered and registered by core.WithService. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -40,24 +34,28 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { return s.queryGet(q), true, nil case QueryList: return s.queryList(), true, nil + case QueryGetAll: + menus := make([]ContextMenuDef, 0, len(s.registeredMenus)) + for _, menu := range s.registeredMenus { + menus = append(menus, menu) + } + return menus, true, nil default: return nil, false, nil } } -// queryGet returns a single menu definition by name, or nil if not found. func (s *Service) queryGet(q QueryGet) *ContextMenuDef { - menu, ok := s.menus[q.Name] + menu, ok := s.registeredMenus[q.Name] if !ok { return nil } return &menu } -// queryList returns a copy of all registered menus. func (s *Service) queryList() map[string]ContextMenuDef { - result := make(map[string]ContextMenuDef, len(s.menus)) - for k, v := range s.menus { + result := make(map[string]ContextMenuDef, len(s.registeredMenus)) + for k, v := range s.registeredMenus { result[k] = v } return result @@ -71,6 +69,20 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { return nil, true, s.taskAdd(t) case TaskRemove: return nil, true, s.taskRemove(t) + case TaskUpdate: + if _, exists := s.registeredMenus[t.Name]; !exists { + return nil, true, ErrorMenuNotFound + } + _ = s.platform.Remove(t.Name) + delete(s.registeredMenus, t.Name) + return nil, true, s.taskAdd(TaskAdd{Name: t.Name, Menu: t.Menu}) + case TaskDestroy: + if _, exists := s.registeredMenus[t.Name]; !exists { + return nil, true, ErrorMenuNotFound + } + _ = s.platform.Remove(t.Name) + delete(s.registeredMenus, t.Name) + return nil, true, nil default: return nil, false, nil } @@ -78,9 +90,9 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { func (s *Service) taskAdd(t TaskAdd) error { // If menu already exists, remove it first (replace semantics) - if _, exists := s.menus[t.Name]; exists { + if _, exists := s.registeredMenus[t.Name]; exists { _ = s.platform.Remove(t.Name) - delete(s.menus, t.Name) + delete(s.registeredMenus, t.Name) } // Register on platform with a callback that broadcasts ActionItemClicked @@ -92,23 +104,23 @@ func (s *Service) taskAdd(t TaskAdd) error { }) }) if err != nil { - return corego.Wrap(err, "contextmenu.add", "platform add failed") + return coreerr.E("contextmenu.taskAdd", "platform add failed", err) } - s.menus[t.Name] = t.Menu + s.registeredMenus[t.Name] = t.Menu return nil } func (s *Service) taskRemove(t TaskRemove) error { - if _, exists := s.menus[t.Name]; !exists { - return ErrMenuNotFound + if _, exists := s.registeredMenus[t.Name]; !exists { + return ErrorMenuNotFound } err := s.platform.Remove(t.Name) if err != nil { - return corego.Wrap(err, "contextmenu.remove", "platform remove failed") + return coreerr.E("contextmenu.taskRemove", "platform remove failed", err) } - delete(s.menus, t.Name) + delete(s.registeredMenus, t.Name) return nil } diff --git a/pkg/contextmenu/service_test.go b/pkg/contextmenu/service_test.go index 93dd8d3c..edab1710 100644 --- a/pkg/contextmenu/service_test.go +++ b/pkg/contextmenu/service_test.go @@ -171,7 +171,7 @@ func TestTaskRemove_Bad_NotFound(t *testing.T) { _, handled, err := c.PERFORM(TaskRemove{Name: "nonexistent"}) assert.True(t, handled) - assert.ErrorIs(t, err, ErrMenuNotFound) + assert.ErrorIs(t, err, ErrorMenuNotFound) } func TestQueryGet_Good(t *testing.T) { diff --git a/pkg/dialog/messages.go b/pkg/dialog/messages.go index 131592e7..4cc05ef4 100644 --- a/pkg/dialog/messages.go +++ b/pkg/dialog/messages.go @@ -1,14 +1,67 @@ -// pkg/dialog/messages.go package dialog -// TaskOpenFile shows an open file dialog. Result: []string (paths) -type TaskOpenFile struct{ Opts OpenFileOptions } +// TaskOpenFile opens a file picker dialog. Result: []string (selected paths) +type TaskOpenFile struct{ Options OpenFileOptions } -// TaskSaveFile shows a save file dialog. Result: string (path) -type TaskSaveFile struct{ Opts SaveFileOptions } +// TaskOpenFileWithOptions opens a file picker, applying caller-supplied options. Result: []string +// paths, _, err := c.PERFORM(TaskOpenFileWithOptions{Title: "Import", AllowMultiple: true}) +type TaskOpenFileWithOptions struct { + Title string + Directory string + Filename string + Filters []FileFilter + AllowMultiple bool + CanChooseDirectories bool + CanChooseFiles bool + ShowHiddenFiles bool +} -// TaskOpenDirectory shows a directory picker. Result: string (path) -type TaskOpenDirectory struct{ Opts OpenDirectoryOptions } +// TaskSaveFile opens a save file dialog. Result: string (chosen path) +type TaskSaveFile struct{ Options SaveFileOptions } -// TaskMessageDialog shows a message dialog. Result: string (button clicked) -type TaskMessageDialog struct{ Opts MessageDialogOptions } +// TaskSaveFileWithOptions opens a save dialog with caller-supplied options. Result: string +// path, _, err := c.PERFORM(TaskSaveFileWithOptions{Title: "Export", Filename: "out.csv"}) +type TaskSaveFileWithOptions struct { + Title string + Directory string + Filename string + Filters []FileFilter +} + +// TaskOpenDirectory opens a directory picker. Result: string +type TaskOpenDirectory struct{ Options OpenDirectoryOptions } + +// TaskMessageDialog opens an arbitrary message dialog. Result: string (button clicked) +type TaskMessageDialog struct{ Options MessageDialogOptions } + +// TaskInfo shows an informational dialog. Result: string (button clicked) +// result, _, err := c.PERFORM(TaskInfo{Title: "Done", Message: "File saved."}) +type TaskInfo struct { + Title string + Message string + Buttons []string +} + +// TaskQuestion shows a question dialog. Result: string (button clicked) +// result, _, err := c.PERFORM(TaskQuestion{Title: "Confirm", Message: "Delete?", Buttons: []string{"Yes","No"}}) +type TaskQuestion struct { + Title string + Message string + Buttons []string +} + +// TaskWarning shows a warning dialog. Result: string (button clicked) +// result, _, err := c.PERFORM(TaskWarning{Title: "Warning", Message: "File exists."}) +type TaskWarning struct { + Title string + Message string + Buttons []string +} + +// TaskError shows an error dialog. Result: string (button clicked) +// result, _, err := c.PERFORM(TaskError{Title: "Error", Message: "Write failed."}) +type TaskError struct { + Title string + Message string + Buttons []string +} diff --git a/pkg/dialog/platform.go b/pkg/dialog/platform.go index 80b74d73..fac7d4df 100644 --- a/pkg/dialog/platform.go +++ b/pkg/dialog/platform.go @@ -3,10 +3,10 @@ package dialog // Platform abstracts the native dialog backend. type Platform interface { - OpenFile(opts OpenFileOptions) ([]string, error) - SaveFile(opts SaveFileOptions) (string, error) - OpenDirectory(opts OpenDirectoryOptions) (string, error) - MessageDialog(opts MessageDialogOptions) (string, error) + OpenFile(options OpenFileOptions) ([]string, error) + SaveFile(options SaveFileOptions) (string, error) + OpenDirectory(options OpenDirectoryOptions) (string, error) + MessageDialog(options MessageDialogOptions) (string, error) } // DialogType represents the type of message dialog. @@ -21,11 +21,14 @@ const ( // OpenFileOptions contains options for the open file dialog. type OpenFileOptions struct { - Title string `json:"title,omitempty"` - Directory string `json:"directory,omitempty"` - Filename string `json:"filename,omitempty"` - Filters []FileFilter `json:"filters,omitempty"` - AllowMultiple bool `json:"allowMultiple,omitempty"` + Title string `json:"title,omitempty"` + Directory string `json:"directory,omitempty"` + Filename string `json:"filename,omitempty"` + Filters []FileFilter `json:"filters,omitempty"` + AllowMultiple bool `json:"allowMultiple,omitempty"` + CanChooseDirectories bool `json:"canChooseDirectories,omitempty"` + CanChooseFiles bool `json:"canChooseFiles,omitempty"` + ShowHiddenFiles bool `json:"showHiddenFiles,omitempty"` } // SaveFileOptions contains options for the save file dialog. diff --git a/pkg/dialog/service.go b/pkg/dialog/service.go index 231f3be8..ef213808 100644 --- a/pkg/dialog/service.go +++ b/pkg/dialog/service.go @@ -7,16 +7,13 @@ import ( "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the dialog service. type Options struct{} -// Service is a core.Service managing native dialogs via IPC. type Service struct { *core.ServiceRuntime[Options] platform Platform } -// Register creates a factory closure that captures the Platform adapter. func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ @@ -26,13 +23,11 @@ func Register(p Platform) func(*core.Core) (any, error) { } } -// OnStartup registers IPC handlers. func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterTask(s.handleTask) return nil } -// HandleIPCEvents is auto-discovered by core.WithService. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -40,16 +35,68 @@ func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { case TaskOpenFile: - paths, err := s.platform.OpenFile(t.Opts) + paths, err := s.platform.OpenFile(t.Options) + return paths, true, err + case TaskOpenFileWithOptions: + paths, err := s.platform.OpenFile(OpenFileOptions{ + Title: t.Title, + Directory: t.Directory, + Filename: t.Filename, + Filters: t.Filters, + AllowMultiple: t.AllowMultiple, + CanChooseDirectories: t.CanChooseDirectories, + CanChooseFiles: t.CanChooseFiles, + ShowHiddenFiles: t.ShowHiddenFiles, + }) return paths, true, err case TaskSaveFile: - path, err := s.platform.SaveFile(t.Opts) + path, err := s.platform.SaveFile(t.Options) + return path, true, err + case TaskSaveFileWithOptions: + path, err := s.platform.SaveFile(SaveFileOptions{ + Title: t.Title, + Directory: t.Directory, + Filename: t.Filename, + Filters: t.Filters, + }) return path, true, err case TaskOpenDirectory: - path, err := s.platform.OpenDirectory(t.Opts) + path, err := s.platform.OpenDirectory(t.Options) return path, true, err case TaskMessageDialog: - button, err := s.platform.MessageDialog(t.Opts) + button, err := s.platform.MessageDialog(t.Options) + return button, true, err + case TaskInfo: + button, err := s.platform.MessageDialog(MessageDialogOptions{ + Type: DialogInfo, + Title: t.Title, + Message: t.Message, + Buttons: t.Buttons, + }) + return button, true, err + case TaskQuestion: + button, err := s.platform.MessageDialog(MessageDialogOptions{ + Type: DialogQuestion, + Title: t.Title, + Message: t.Message, + Buttons: t.Buttons, + }) + return button, true, err + case TaskWarning: + button, err := s.platform.MessageDialog(MessageDialogOptions{ + Type: DialogWarning, + Title: t.Title, + Message: t.Message, + Buttons: t.Buttons, + }) + return button, true, err + case TaskError: + button, err := s.platform.MessageDialog(MessageDialogOptions{ + Type: DialogError, + Title: t.Title, + Message: t.Message, + Buttons: t.Buttons, + }) return button, true, err default: return nil, false, nil diff --git a/pkg/dialog/service_test.go b/pkg/dialog/service_test.go index 66fe7608..2be9053f 100644 --- a/pkg/dialog/service_test.go +++ b/pkg/dialog/service_test.go @@ -11,18 +11,18 @@ import ( ) type mockPlatform struct { - openFilePaths []string - saveFilePath string - openDirPath string - messageButton string - openFileErr error - saveFileErr error - openDirErr error - messageErr error - lastOpenOpts OpenFileOptions - lastSaveOpts SaveFileOptions - lastDirOpts OpenDirectoryOptions - lastMsgOpts MessageDialogOptions + openFilePaths []string + saveFilePath string + openDirPath string + messageButton string + openFileErr error + saveFileErr error + openDirErr error + messageErr error + lastOpenOpts OpenFileOptions + lastSaveOpts SaveFileOptions + lastDirOpts OpenDirectoryOptions + lastMsgOpts MessageDialogOptions } func (m *mockPlatform) OpenFile(opts OpenFileOptions) ([]string, error) { @@ -70,7 +70,7 @@ func TestTaskOpenFile_Good(t *testing.T) { mock.openFilePaths = []string{"/a.txt", "/b.txt"} result, handled, err := c.PERFORM(TaskOpenFile{ - Opts: OpenFileOptions{Title: "Pick", AllowMultiple: true}, + Options: OpenFileOptions{Title: "Pick", AllowMultiple: true}, }) require.NoError(t, err) assert.True(t, handled) @@ -83,7 +83,7 @@ func TestTaskOpenFile_Good(t *testing.T) { func TestTaskSaveFile_Good(t *testing.T) { _, c := newTestService(t) result, handled, err := c.PERFORM(TaskSaveFile{ - Opts: SaveFileOptions{Filename: "out.txt"}, + Options: SaveFileOptions{Filename: "out.txt"}, }) require.NoError(t, err) assert.True(t, handled) @@ -93,7 +93,7 @@ func TestTaskSaveFile_Good(t *testing.T) { func TestTaskOpenDirectory_Good(t *testing.T) { _, c := newTestService(t) result, handled, err := c.PERFORM(TaskOpenDirectory{ - Opts: OpenDirectoryOptions{Title: "Pick Dir"}, + Options: OpenDirectoryOptions{Title: "Pick Dir"}, }) require.NoError(t, err) assert.True(t, handled) @@ -105,7 +105,7 @@ func TestTaskMessageDialog_Good(t *testing.T) { mock.messageButton = "Yes" result, handled, err := c.PERFORM(TaskMessageDialog{ - Opts: MessageDialogOptions{ + Options: MessageDialogOptions{ Type: DialogQuestion, Title: "Confirm", Message: "Sure?", Buttons: []string{"Yes", "No"}, }, @@ -121,3 +121,137 @@ func TestTaskOpenFile_Bad(t *testing.T) { _, handled, _ := c.PERFORM(TaskOpenFile{}) assert.False(t, handled) } + +func TestTaskOpenFileWithOptions_Good(t *testing.T) { + mock, c := newTestService(t) + mock.openFilePaths = []string{"/docs/report.pdf"} + + result, handled, err := c.PERFORM(TaskOpenFileWithOptions{ + Title: "Select Document", + AllowMultiple: false, + ShowHiddenFiles: true, + CanChooseFiles: true, + }) + require.NoError(t, err) + assert.True(t, handled) + paths := result.([]string) + assert.Equal(t, []string{"/docs/report.pdf"}, paths) + assert.Equal(t, "Select Document", mock.lastOpenOpts.Title) + assert.True(t, mock.lastOpenOpts.ShowHiddenFiles) + assert.True(t, mock.lastOpenOpts.CanChooseFiles) +} + +func TestTaskOpenFileWithOptions_CanChooseDirectories_Good(t *testing.T) { + mock, c := newTestService(t) + mock.openFilePaths = []string{"/home/user/projects"} + + _, handled, err := c.PERFORM(TaskOpenFileWithOptions{ + Title: "Pick folder", + CanChooseDirectories: true, + CanChooseFiles: false, + }) + require.NoError(t, err) + assert.True(t, handled) + assert.True(t, mock.lastOpenOpts.CanChooseDirectories) + assert.False(t, mock.lastOpenOpts.CanChooseFiles) +} + +func TestTaskOpenFileWithOptions_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskOpenFileWithOptions{}) + assert.False(t, handled) +} + +func TestTaskSaveFileWithOptions_Good(t *testing.T) { + mock, c := newTestService(t) + mock.saveFilePath = "/exports/data.csv" + + result, handled, err := c.PERFORM(TaskSaveFileWithOptions{ + Title: "Export CSV", + Filename: "data.csv", + }) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, "/exports/data.csv", result) + assert.Equal(t, "Export CSV", mock.lastSaveOpts.Title) + assert.Equal(t, "data.csv", mock.lastSaveOpts.Filename) +} + +func TestTaskSaveFileWithOptions_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskSaveFileWithOptions{}) + assert.False(t, handled) +} + +func TestTaskInfo_Good(t *testing.T) { + mock, c := newTestService(t) + mock.messageButton = "OK" + + result, handled, err := c.PERFORM(TaskInfo{Title: "Done", Message: "Saved successfully."}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, "OK", result) + assert.Equal(t, DialogInfo, mock.lastMsgOpts.Type) + assert.Equal(t, "Done", mock.lastMsgOpts.Title) +} + +func TestTaskQuestion_Good(t *testing.T) { + mock, c := newTestService(t) + mock.messageButton = "Yes" + + result, handled, err := c.PERFORM(TaskQuestion{ + Title: "Confirm", + Message: "Delete this file?", + Buttons: []string{"Yes", "No"}, + }) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, "Yes", result) + assert.Equal(t, DialogQuestion, mock.lastMsgOpts.Type) +} + +func TestTaskWarning_Good(t *testing.T) { + mock, c := newTestService(t) + mock.messageButton = "OK" + + result, handled, err := c.PERFORM(TaskWarning{Title: "Warning", Message: "File exists."}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, "OK", result) + assert.Equal(t, DialogWarning, mock.lastMsgOpts.Type) +} + +func TestTaskError_Good(t *testing.T) { + mock, c := newTestService(t) + mock.messageButton = "OK" + + result, handled, err := c.PERFORM(TaskError{Title: "Error", Message: "Write failed."}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, "OK", result) + assert.Equal(t, DialogError, mock.lastMsgOpts.Type) +} + +func TestTaskInfo_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskInfo{}) + assert.False(t, handled) +} + +func TestTaskQuestion_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskQuestion{}) + assert.False(t, handled) +} + +func TestTaskWarning_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskWarning{}) + assert.False(t, handled) +} + +func TestTaskError_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskError{}) + assert.False(t, handled) +} diff --git a/pkg/display/FEATURES.md b/pkg/display/FEATURES.md index a68b70a0..8091eeeb 100644 --- a/pkg/display/FEATURES.md +++ b/pkg/display/FEATURES.md @@ -194,7 +194,7 @@ This document tracks the implementation of display server features that enable A ### Phase 3 - Layouts (DONE) - [x] layout_save, layout_restore, layout_list - [x] layout_delete, layout_get -- [ ] layout_tile, layout_beside_editor (future) +- [x] layout_tile, layout_beside_editor ### Phase 4 - WebView Debug (DONE) - [x] webview_screenshot, webview_screenshot_element @@ -203,7 +203,7 @@ This document tracks the implementation of display server features that enable A - [x] webview_scroll, webview_hover, webview_select, webview_check - [x] webview_highlight, webview_errors - [x] webview_performance, webview_resources -- [ ] webview_network, webview_devtools (future) +- [~] webview_network complete; webview_devtools pending ### Phase 5 - System Integration (DONE) - [x] clipboard_read, clipboard_write, clipboard_has, clipboard_clear @@ -236,8 +236,9 @@ This document tracks the implementation of display server features that enable A - [x] `tray_info` - Get tray status ### Phase 8 - Remaining Features (Future) -- [ ] layout_beside_editor, layout_suggest +- [ ] window_opacity (true opacity if Wails adds support) +- [x] layout_beside_editor, layout_suggest - [ ] webview_devtools_open, webview_devtools_close -- [ ] clipboard_read_image, clipboard_write_image -- [ ] notification_with_actions, notification_clear -- [ ] tray_show_message - Balloon notifications +- [x] clipboard_read_image, clipboard_write_image +- [x] notification_with_actions, notification_clear +- [x] tray_show_message - Balloon notifications diff --git a/pkg/display/display.go b/pkg/display/display.go index 0b8d5eaf..eac9ba2d 100644 --- a/pkg/display/display.go +++ b/pkg/display/display.go @@ -3,57 +3,49 @@ package display import ( "context" - "encoding/base64" - "os" "runtime" corego "dappco.re/go/core" "forge.lthn.ai/core/config" + coreerr "forge.lthn.ai/core/go-log" "forge.lthn.ai/core/go/pkg/core" + coreutil "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/browser" - "dappco.re/go/core/gui/pkg/clipboard" - "dappco.re/go/core/gui/pkg/contextmenu" - "dappco.re/go/core/gui/pkg/dialog" - "dappco.re/go/core/gui/pkg/dock" - "dappco.re/go/core/gui/pkg/environment" - "dappco.re/go/core/gui/pkg/keybinding" - "dappco.re/go/core/gui/pkg/lifecycle" - "dappco.re/go/core/gui/pkg/menu" - "dappco.re/go/core/gui/pkg/notification" - "dappco.re/go/core/gui/pkg/screen" - "dappco.re/go/core/gui/pkg/systray" - "dappco.re/go/core/gui/pkg/webview" - "dappco.re/go/core/gui/pkg/window" + "forge.lthn.ai/core/gui/pkg/browser" + "forge.lthn.ai/core/gui/pkg/contextmenu" + "forge.lthn.ai/core/gui/pkg/dialog" + "forge.lthn.ai/core/gui/pkg/dock" + "forge.lthn.ai/core/gui/pkg/environment" + "forge.lthn.ai/core/gui/pkg/events" + "forge.lthn.ai/core/gui/pkg/keybinding" + "forge.lthn.ai/core/gui/pkg/lifecycle" + "forge.lthn.ai/core/gui/pkg/menu" + "forge.lthn.ai/core/gui/pkg/notification" + "forge.lthn.ai/core/gui/pkg/screen" + "forge.lthn.ai/core/gui/pkg/systray" + "forge.lthn.ai/core/gui/pkg/webview" + "forge.lthn.ai/core/gui/pkg/window" "github.com/wailsapp/wails/v3/pkg/application" ) -// Options holds configuration for the display service. -// Use: svc, err := display.NewService() type Options struct{} // WindowInfo is an alias for window.WindowInfo (backward compatibility). type WindowInfo = window.WindowInfo -// LayoutSuggestion is an alias for window.LayoutSuggestion (backward compatibility). -type LayoutSuggestion = window.LayoutSuggestion - -// Service manages windowing, dialogs, and other visual elements. -// It orchestrates sub-services (window, systray, menu) via IPC and bridges -// IPC actions to WebSocket events for TypeScript apps. -// Use: svc, err := display.NewService() +// Service orchestrates window, systray, and menu sub-services via IPC. +// Bridges IPC actions to WebSocket events for TypeScript apps. type Service struct { *core.ServiceRuntime[Options] wailsApp *application.App app App - config Options configData map[string]map[string]any - cfg *config.Config // config instance for file persistence + configFile *config.Config // config instance for file persistence events *WSEventManager } -// NewService creates a display service with empty config sections. -// Use: svc, err := display.NewService() +// NewService returns a display Service with empty config sections. +// svc, _ := display.NewService(); _, _ = svc.CreateWindow(display.CreateWindowOptions{Name: "settings", URL: "/settings", Width: 800, Height: 600}) func NewService() (*Service, error) { return &Service{ configData: map[string]map[string]any{ @@ -64,15 +56,14 @@ func NewService() (*Service, error) { }, nil } -// Deprecated: use NewService. -// Use: svc, err := display.New() +// Deprecated: use NewService(). func New() (*Service, error) { return NewService() } -// Register creates a factory closure that captures the Wails app. -// Use: core.WithService(display.Register(app)) -// Pass nil for testing without a Wails runtime. +// Register binds the display service to a Core instance. +// core.WithService(display.Register(app)) // production (Wails app) +// core.WithService(display.Register(nil)) // tests (no Wails runtime) func Register(wailsApp *application.App) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { s, err := NewService() @@ -85,10 +76,8 @@ func Register(wailsApp *application.App) func(*core.Core) (any, error) { } } -// OnStartup loads config and registers IPC handlers synchronously. -// CRITICAL: config handlers MUST be registered before returning — -// sub-services depend on them during their own OnStartup. -// Use: _ = svc.OnStartup(context.Background()) +// OnStartup loads config and registers handlers before sub-services start. +// Config handlers are registered first — sub-services query them during their own OnStartup. func (s *Service) OnStartup(ctx context.Context) error { s.loadConfig() @@ -105,9 +94,7 @@ func (s *Service) OnStartup(ctx context.Context) error { return nil } -// HandleIPCEvents is auto-discovered and registered by core.WithService. -// It bridges sub-service IPC actions to WebSocket events for TS apps. -// Use: _ = svc.HandleIPCEvents(core, msg) +// HandleIPCEvents bridges IPC actions from sub-services to WebSocket events for TS apps. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { switch m := msg.(type) { case core.ActionServiceStartup: @@ -132,7 +119,7 @@ func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { case window.ActionWindowResized: if s.events != nil { s.events.Emit(Event{Type: EventWindowResize, Window: m.Name, - Data: map[string]any{"w": m.W, "h": m.H}}) + Data: map[string]any{"w": m.Width, "h": m.Height}}) } case window.ActionWindowFocused: if s.events != nil { @@ -238,6 +225,31 @@ func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { s.events.Emit(Event{Type: EventWebviewException, Window: m.Window, Data: map[string]any{"exception": m.Exception}}) } + case events.ActionEventFired: + if s.events != nil { + s.events.Emit(Event{Type: EventCustomEvent, + Data: map[string]any{"name": m.Name, "data": m.Data}}) + } + case dock.ActionProgressChanged: + if s.events != nil { + s.events.Emit(Event{Type: EventDockProgress, + Data: map[string]any{"value": m.Value}}) + } + case dock.ActionBounceStarted: + if s.events != nil { + s.events.Emit(Event{Type: EventDockBounce, + Data: map[string]any{"bounceId": m.BounceID, "type": m.Type}}) + } + case notification.ActionNotificationActionTriggered: + if s.events != nil { + s.events.Emit(Event{Type: EventNotificationAction, + Data: map[string]any{"notificationId": m.NotificationID, "actionId": m.ActionID}}) + } + case notification.ActionNotificationDismissed: + if s.events != nil { + s.events.Emit(Event{Type: EventNotificationDismiss, + Data: map[string]any{"notificationId": m.NotificationID}}) + } case ActionIDECommand: if s.events != nil { s.events.Emit(Event{Type: EventIDECommand, @@ -257,7 +269,7 @@ type WSMessage struct { func wsRequire(data map[string]any, key string) (string, error) { v, _ := data[key].(string) if v == "" { - return "", corego.NewError(corego.Sprintf("ws: missing required field %q", key)) + return "", coreerr.E("display.wsRequire", "missing required field \""+key+"\"", nil) } return v, nil } @@ -443,11 +455,9 @@ func (s *Service) handleWSMessage(msg WSMessage) (any, bool, error) { result, handled, err = s.Core().QUERY(dock.QueryVisible{}) case "contextmenu:add": name, _ := msg.Data["name"].(string) - menuR := corego.JSONMarshal(msg.Data["menu"]) + menuJSON := coreutil.JSONMarshalString(msg.Data["menu"]) var menuDef contextmenu.ContextMenuDef - if menuR.OK { - _ = corego.JSONUnmarshal(menuR.Value.([]byte), &menuDef) - } + _ = coreutil.JSONUnmarshalString(menuJSON, &menuDef) result, handled, err = s.Core().PERFORM(contextmenu.TaskAdd{ Name: name, Menu: menuDef, }) @@ -1145,10 +1155,10 @@ func (s *Service) handleTrayAction(actionID string) { result, handled, _ := s.Core().QUERY(environment.QueryInfo{}) if handled { info := result.(environment.EnvironmentInfo) - details := corego.Sprintf("OS: %s\nArch: %s\nPlatform: %s %s", - info.OS, info.Arch, info.Platform.Name, info.Platform.Version) + details := "OS: " + info.OS + "\nArch: " + info.Arch + "\nPlatform: " + + info.Platform.Name + " " + info.Platform.Version _, _, _ = s.Core().PERFORM(dialog.TaskMessageDialog{ - Opts: dialog.MessageDialogOptions{ + Options: dialog.MessageDialogOptions{ Type: dialog.DialogInfo, Title: "Environment", Message: details, Buttons: []string{"OK"}, }, @@ -1162,31 +1172,31 @@ func (s *Service) handleTrayAction(actionID string) { } func guiConfigPath() string { - home, err := os.UserHomeDir() - if err != nil { - return corego.JoinPath(".core", "gui", "config.yaml") + home := coreutil.Env("DIR_HOME") + if home == "" { + return coreutil.JoinPath(".core", "gui", "config.yaml") } - return corego.JoinPath(home, ".core", "gui", "config.yaml") + return coreutil.JoinPath(home, ".core", "gui", "config.yaml") } func (s *Service) loadConfig() { - if s.cfg != nil { + if s.configFile != nil { return // Already loaded (e.g., via loadConfigFrom in tests) } s.loadConfigFrom(guiConfigPath()) } func (s *Service) loadConfigFrom(path string) { - cfg, err := config.New(config.WithPath(path)) + configFile, err := config.New(config.WithPath(path)) if err != nil { // Non-critical — continue with empty configData return } - s.cfg = cfg + s.configFile = configFile for _, section := range []string{"window", "systray", "menu"} { var data map[string]any - if err := cfg.Get(section, &data); err == nil && data != nil { + if err := configFile.Get(section, &data); err == nil && data != nil { s.configData[section] = data } } @@ -1208,16 +1218,16 @@ func (s *Service) handleConfigQuery(c *core.Core, q core.Query) (any, bool, erro func (s *Service) handleConfigTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { case window.TaskSaveConfig: - s.configData["window"] = t.Value - s.persistSection("window", t.Value) + s.configData["window"] = t.Config + s.persistSection("window", t.Config) return nil, true, nil case systray.TaskSaveConfig: - s.configData["systray"] = t.Value - s.persistSection("systray", t.Value) + s.configData["systray"] = t.Config + s.persistSection("systray", t.Config) return nil, true, nil case menu.TaskSaveConfig: - s.configData["menu"] = t.Value - s.persistSection("menu", t.Value) + s.configData["menu"] = t.Config + s.persistSection("menu", t.Config) return nil, true, nil default: return nil, false, nil @@ -1225,11 +1235,11 @@ func (s *Service) handleConfigTask(c *core.Core, t core.Task) (any, bool, error) } func (s *Service) persistSection(key string, value map[string]any) { - if s.cfg == nil { + if s.configFile == nil { return } - _ = s.cfg.Set(key, value) - _ = s.cfg.Commit() + _ = s.configFile.Set(key, value) + _ = s.configFile.Commit() } // --- Service accessors --- @@ -1245,10 +1255,13 @@ func (s *Service) windowService() *window.Service { // --- Window Management (delegates via IPC) --- -// OpenWindow creates a new window via IPC. -// Use: _ = svc.OpenWindow(window.WithName("editor"), window.WithURL("/editor")) -func (s *Service) OpenWindow(opts ...window.WindowOption) error { - _, _, err := s.Core().PERFORM(window.TaskOpenWindow{Opts: opts}) +// Deprecated: use CreateWindow(display.CreateWindowOptions{Name: "settings", URL: "/settings", Width: 800, Height: 600}). +func (s *Service) OpenWindow(options ...window.WindowOption) error { + spec, err := window.ApplyOptions(options...) + if err != nil { + return err + } + _, _, err = s.Core().PERFORM(window.TaskOpenWindow{Window: spec}) return err } @@ -1260,7 +1273,7 @@ func (s *Service) GetWindowInfo(name string) (*window.WindowInfo, error) { return nil, err } if !handled { - return nil, corego.NewError(corego.Sprintf("window service not available")) + return nil, coreerr.E("display.GetWindowInfo", "window service not available", nil) } info, _ := result.(*window.WindowInfo) return info, nil @@ -1287,7 +1300,7 @@ func (s *Service) SetWindowPosition(name string, x, y int) error { // SetWindowSize resizes a window via IPC. // Use: _ = svc.SetWindowSize("editor", 1280, 800) func (s *Service) SetWindowSize(name string, width, height int) error { - _, _, err := s.Core().PERFORM(window.TaskSetSize{Name: name, W: width, H: height}) + _, _, err := s.Core().PERFORM(window.TaskSetSize{Name: name, Width: width, Height: height}) return err } @@ -1297,7 +1310,7 @@ func (s *Service) SetWindowBounds(name string, x, y, width, height int) error { if _, _, err := s.Core().PERFORM(window.TaskSetPosition{Name: name, X: x, Y: y}); err != nil { return err } - _, _, err := s.Core().PERFORM(window.TaskSetSize{Name: name, W: width, H: height}) + _, _, err := s.Core().PERFORM(window.TaskSetSize{Name: name, Width: width, Height: height}) return err } @@ -1335,71 +1348,44 @@ func (s *Service) CloseWindow(name string) error { return err } -// RestoreWindow restores a maximized/minimized window via IPC. -// Use: _ = svc.RestoreWindow("editor") +// RestoreWindow restores a maximized/minimized window. func (s *Service) RestoreWindow(name string) error { _, _, err := s.Core().PERFORM(window.TaskRestore{Name: name}) return err } -// SetWindowVisibility shows or hides a window via IPC. -// Use: _ = svc.SetWindowVisibility("editor", false) +// SetWindowVisibility shows or hides a window. func (s *Service) SetWindowVisibility(name string, visible bool) error { _, _, err := s.Core().PERFORM(window.TaskSetVisibility{Name: name, Visible: visible}) return err } -// SetWindowAlwaysOnTop sets whether a window stays on top via IPC. -// Use: _ = svc.SetWindowAlwaysOnTop("editor", true) +// SetWindowAlwaysOnTop sets whether a window stays on top. func (s *Service) SetWindowAlwaysOnTop(name string, alwaysOnTop bool) error { _, _, err := s.Core().PERFORM(window.TaskSetAlwaysOnTop{Name: name, AlwaysOnTop: alwaysOnTop}) return err } -// SetWindowTitle changes a window's title via IPC. -// Use: _ = svc.SetWindowTitle("editor", "Core Editor") +// SetWindowTitle changes a window's title. func (s *Service) SetWindowTitle(name string, title string) error { _, _, err := s.Core().PERFORM(window.TaskSetTitle{Name: name, Title: title}) return err } -// SetWindowFullscreen sets a window to fullscreen mode via IPC. -// Use: _ = svc.SetWindowFullscreen("editor", true) +// SetWindowFullscreen sets a window to fullscreen mode. func (s *Service) SetWindowFullscreen(name string, fullscreen bool) error { _, _, err := s.Core().PERFORM(window.TaskFullscreen{Name: name, Fullscreen: fullscreen}) return err } -// SetWindowBackgroundColour sets the background colour of a window via IPC. -// Use: _ = svc.SetWindowBackgroundColour("editor", 0, 0, 0, 0) +// SetWindowBackgroundColour sets the background colour of a window. func (s *Service) SetWindowBackgroundColour(name string, r, g, b, a uint8) error { _, _, err := s.Core().PERFORM(window.TaskSetBackgroundColour{ - Name: name, - Red: r, - Green: g, - Blue: b, - Alpha: a, + Name: name, Red: r, Green: g, Blue: b, Alpha: a, }) return err } -// SetWindowOpacity updates a window's opacity via IPC. -// Use: _ = svc.SetWindowOpacity("editor", 0.85) -func (s *Service) SetWindowOpacity(name string, opacity float32) error { - _, _, err := s.Core().PERFORM(window.TaskSetOpacity{ - Name: name, - Opacity: opacity, - }) - return err -} - -// ClearWebviewConsole clears the captured console buffer for a window. -// Use: _ = svc.ClearWebviewConsole("editor") -func (s *Service) ClearWebviewConsole(name string) error { - _, _, err := s.Core().PERFORM(webview.TaskClearConsole{Window: name}) - return err -} - // GetFocusedWindow returns the name of the currently focused window. // Use: focused := svc.GetFocusedWindow() func (s *Service) GetFocusedWindow() string { @@ -1420,7 +1406,7 @@ func (s *Service) GetWindowTitle(name string) (string, error) { return "", err } if info == nil { - return "", corego.NewError(corego.Sprintf("window not found: %s", name)) + return "", coreerr.E("display.GetWindowTitle", "window not found: "+name, nil) } return info.Title, nil } @@ -1451,8 +1437,8 @@ func (s *Service) GetSavedWindowStates() map[string]window.WindowState { return result } -// CreateWindowOptions contains options for creating a new window. -// Use: opts := display.CreateWindowOptions{Name: "editor", URL: "/editor"} +// CreateWindowOptions specifies the initial state for a new named window. +// svc.CreateWindow(display.CreateWindowOptions{Name: "settings", URL: "/settings", Width: 800, Height: 600}) type CreateWindowOptions struct { Name string `json:"name"` Title string `json:"title,omitempty"` @@ -1465,23 +1451,19 @@ type CreateWindowOptions struct { BackgroundColour [4]uint8 `json:"backgroundColour,omitempty"` } -// CreateWindow creates a new window with the specified options. -// Use: info, err := svc.CreateWindow(display.CreateWindowOptions{Name: "editor", URL: "/editor"}) -func (s *Service) CreateWindow(opts CreateWindowOptions) (*window.WindowInfo, error) { - if opts.Name == "" { - return nil, corego.NewError(corego.Sprintf("window name is required")) +func (s *Service) CreateWindow(options CreateWindowOptions) (*window.WindowInfo, error) { + if options.Name == "" { + return nil, coreerr.E("display.CreateWindow", "window name is required", nil) } result, _, err := s.Core().PERFORM(window.TaskOpenWindow{ Window: &window.Window{ - Name: opts.Name, - Title: opts.Title, - URL: opts.URL, - X: opts.X, - Y: opts.Y, - Width: opts.Width, - Height: opts.Height, - AlwaysOnTop: opts.AlwaysOnTop, - BackgroundColour: opts.BackgroundColour, + Name: options.Name, + Title: options.Title, + URL: options.URL, + Width: options.Width, + Height: options.Height, + X: options.X, + Y: options.Y, }, }) if err != nil { @@ -1496,79 +1478,44 @@ func (s *Service) CreateWindow(opts CreateWindowOptions) (*window.WindowInfo, er // SaveLayout saves the current window arrangement as a named layout. // Use: _ = svc.SaveLayout("coding") func (s *Service) SaveLayout(name string) error { - ws := s.windowService() - if ws == nil { - return corego.NewError(corego.Sprintf("window service not available")) - } - states := make(map[string]window.WindowState) - for _, n := range ws.Manager().List() { - if pw, ok := ws.Manager().Get(n); ok { - x, y := pw.Position() - w, h := pw.Size() - states[n] = window.WindowState{X: x, Y: y, Width: w, Height: h, Maximized: pw.IsMaximised()} - } - } - return ws.Manager().Layout().SaveLayout(name, states) + _, _, err := s.Core().PERFORM(window.TaskSaveLayout{Name: name}) + return err } // RestoreLayout applies a saved layout. // Use: _ = svc.RestoreLayout("coding") func (s *Service) RestoreLayout(name string) error { - ws := s.windowService() - if ws == nil { - return corego.NewError(corego.Sprintf("window service not available")) - } - layout, ok := ws.Manager().Layout().GetLayout(name) - if !ok { - return corego.NewError(corego.Sprintf("layout not found: %s", name)) - } - for wName, state := range layout.Windows { - if pw, ok := ws.Manager().Get(wName); ok { - pw.SetPosition(state.X, state.Y) - pw.SetSize(state.Width, state.Height) - if state.Maximized { - pw.Maximise() - } else { - pw.Restore() - } - } - } - return nil + _, _, err := s.Core().PERFORM(window.TaskRestoreLayout{Name: name}) + return err } // ListLayouts returns all saved layout names with metadata. // Use: layouts := svc.ListLayouts() func (s *Service) ListLayouts() []window.LayoutInfo { - ws := s.windowService() - if ws == nil { + result, handled, _ := s.Core().QUERY(window.QueryLayoutList{}) + if !handled { return nil } - return ws.Manager().Layout().ListLayouts() + layouts, _ := result.([]window.LayoutInfo) + return layouts } // DeleteLayout removes a saved layout by name. // Use: _ = svc.DeleteLayout("coding") func (s *Service) DeleteLayout(name string) error { - ws := s.windowService() - if ws == nil { - return corego.NewError(corego.Sprintf("window service not available")) - } - ws.Manager().Layout().DeleteLayout(name) - return nil + _, _, err := s.Core().PERFORM(window.TaskDeleteLayout{Name: name}) + return err } // GetLayout returns a specific layout by name. // Use: layout := svc.GetLayout("coding") func (s *Service) GetLayout(name string) *window.Layout { - ws := s.windowService() - if ws == nil { + result, handled, _ := s.Core().QUERY(window.QueryLayoutGet{Name: name}) + if !handled { return nil } - layout, ok := ws.Manager().Layout().GetLayout(name) - if !ok { - return nil - } - return &layout + layout, _ := result.(*window.Layout) + return layout } // --- Tiling/snapping delegation --- @@ -1576,700 +1523,33 @@ func (s *Service) GetLayout(name string) *window.Layout { // TileWindows arranges windows in a tiled layout. // Use: _ = svc.TileWindows(window.TileModeLeftRight, []string{"left", "right"}) func (s *Service) TileWindows(mode window.TileMode, windowNames []string) error { - ws := s.windowService() - if ws == nil { - return corego.NewError(corego.Sprintf("window service not available")) - } - screenWidth, screenHeight := s.primaryScreenSize() - return ws.Manager().TileWindows(mode, windowNames, screenWidth, screenHeight) + _, _, err := s.Core().PERFORM(window.TaskTileWindows{Mode: mode.String(), Windows: windowNames}) + return err } // SnapWindow snaps a window to a screen edge or corner. // Use: _ = svc.SnapWindow("editor", window.SnapRight) func (s *Service) SnapWindow(name string, position window.SnapPosition) error { - ws := s.windowService() - if ws == nil { - return corego.NewError(corego.Sprintf("window service not available")) - } - screenWidth, screenHeight := s.primaryScreenSize() - return ws.Manager().SnapWindow(name, position, screenWidth, screenHeight) -} - -func (s *Service) primaryScreenSize() (int, int) { - const fallbackWidth = 1920 - const fallbackHeight = 1080 - - result, handled, err := s.Core().QUERY(screen.QueryPrimary{}) - if err != nil || !handled { - return fallbackWidth, fallbackHeight - } - - primary, ok := result.(*screen.Screen) - if !ok || primary == nil { - return fallbackWidth, fallbackHeight - } - - width := primary.WorkArea.Width - height := primary.WorkArea.Height - if width <= 0 || height <= 0 { - width = primary.Bounds.Width - height = primary.Bounds.Height - } - if width <= 0 || height <= 0 { - return fallbackWidth, fallbackHeight - } - - return width, height + _, _, err := s.Core().PERFORM(window.TaskSnapWindow{Name: name, Position: position.String()}) + return err } // StackWindows arranges windows in a cascade pattern. // Use: _ = svc.StackWindows([]string{"editor", "terminal"}, 24, 24) func (s *Service) StackWindows(windowNames []string, offsetX, offsetY int) error { - ws := s.windowService() - if ws == nil { - return corego.NewError(corego.Sprintf("window service not available")) - } - return ws.Manager().StackWindows(windowNames, offsetX, offsetY) + _, _, err := s.Core().PERFORM(window.TaskStackWindows{Windows: windowNames, OffsetX: offsetX, OffsetY: offsetY}) + return err } // ApplyWorkflowLayout applies a predefined layout for a specific workflow. // Use: _ = svc.ApplyWorkflowLayout(window.WorkflowCoding) func (s *Service) ApplyWorkflowLayout(workflow window.WorkflowLayout) error { - ws := s.windowService() - if ws == nil { - return corego.NewError(corego.Sprintf("window service not available")) - } - screenWidth, screenHeight := s.primaryScreenSize() - return ws.Manager().ApplyWorkflow(workflow, ws.Manager().List(), screenWidth, screenHeight) -} - -// ArrangeWindowPair places two windows side by side using the window manager's balanced split. -// Use: _ = svc.ArrangeWindowPair("editor", "terminal") -func (s *Service) ArrangeWindowPair(first, second string) error { - ws := s.windowService() - if ws == nil { - return corego.NewError(corego.Sprintf("window service not available")) - } - screenWidth, screenHeight := s.primaryScreenSize() - return ws.Manager().ArrangePair(first, second, screenWidth, screenHeight) -} - -// FindSpace returns a free placement suggestion for a new window. -// Use: space, err := svc.FindSpace(800, 600) -func (s *Service) FindSpace(width, height int) (window.SpaceInfo, error) { - ws := s.windowService() - if ws == nil { - return window.SpaceInfo{}, corego.NewError(corego.Sprintf("window service not available")) - } - screenWidth, screenHeight := s.primaryScreenSize() - if width <= 0 { - width = screenWidth / 2 - } - if height <= 0 { - height = screenHeight / 2 - } - return ws.Manager().FindSpace(screenWidth, screenHeight, width, height), nil -} - -// SuggestLayout returns a recommended arrangement for the current screen. -// Use: suggestion, err := svc.SuggestLayout(3, 1920, 1080) -func (s *Service) SuggestLayout(windowCount, screenWidth, screenHeight int) (window.LayoutSuggestion, error) { - result, handled, err := s.Core().QUERY(window.QueryLayoutSuggestion{ - WindowCount: windowCount, - ScreenWidth: screenWidth, - ScreenHeight: screenHeight, - }) - if err != nil { - return window.LayoutSuggestion{}, err - } - if !handled { - return window.LayoutSuggestion{}, corego.NewError(corego.Sprintf("window service not available")) - } - suggestion, _ := result.(window.LayoutSuggestion) - return suggestion, nil -} - -// BesideEditor positions a target window beside an editor window. -// Use: _ = svc.BesideEditor("editor", "assistant") -func (s *Service) BesideEditor(editorName, windowName string) error { - _, _, err := s.Core().PERFORM(window.TaskBesideEditor{ - Editor: editorName, - Window: windowName, + _, _, err := s.Core().PERFORM(window.TaskApplyWorkflow{ + Workflow: workflow.String(), }) return err } -// --- Screen management --- - -// GetScreens returns all known screens. -// Use: screens := svc.GetScreens() -func (s *Service) GetScreens() []screen.Screen { - result, handled, _ := s.Core().QUERY(screen.QueryAll{}) - if !handled { - return nil - } - screens, _ := result.([]screen.Screen) - return screens -} - -// GetScreen returns a screen by ID. -// Use: screenInfo, err := svc.GetScreen("primary") -func (s *Service) GetScreen(id string) (*screen.Screen, error) { - result, handled, err := s.Core().QUERY(screen.QueryByID{ID: id}) - if err != nil { - return nil, err - } - if !handled { - return nil, corego.NewError(corego.Sprintf("screen service not available")) - } - scr, _ := result.(*screen.Screen) - return scr, nil -} - -// GetPrimaryScreen returns the primary screen. -// Use: primary, err := svc.GetPrimaryScreen() -func (s *Service) GetPrimaryScreen() (*screen.Screen, error) { - result, handled, err := s.Core().QUERY(screen.QueryPrimary{}) - if err != nil { - return nil, err - } - if !handled { - return nil, corego.NewError(corego.Sprintf("screen service not available")) - } - scr, _ := result.(*screen.Screen) - return scr, nil -} - -// GetScreenAtPoint returns the screen containing the specified point. -// Use: screenInfo, err := svc.GetScreenAtPoint(1280, 720) -func (s *Service) GetScreenAtPoint(x, y int) (*screen.Screen, error) { - result, handled, err := s.Core().QUERY(screen.QueryAtPoint{X: x, Y: y}) - if err != nil { - return nil, err - } - if !handled { - return nil, corego.NewError(corego.Sprintf("screen service not available")) - } - scr, _ := result.(*screen.Screen) - return scr, nil -} - -// GetScreenForWindow returns the screen containing the named window. -// Use: screenInfo, err := svc.GetScreenForWindow("editor") -func (s *Service) GetScreenForWindow(name string) (*screen.Screen, error) { - info, err := s.GetWindowInfo(name) - if err != nil { - return nil, err - } - if info == nil { - return nil, nil - } - x := info.X - y := info.Y - if info.Width > 0 && info.Height > 0 { - x += info.Width / 2 - y += info.Height / 2 - } - return s.GetScreenAtPoint(x, y) -} - -// GetWorkAreas returns the usable area of every screen. -// Use: areas := svc.GetWorkAreas() -func (s *Service) GetWorkAreas() []screen.Rect { - result, handled, _ := s.Core().QUERY(screen.QueryWorkAreas{}) - if !handled { - return nil - } - areas, _ := result.([]screen.Rect) - return areas -} - -// --- Clipboard --- - -// ReadClipboard returns the current clipboard text content. -// Use: text, err := svc.ReadClipboard() -func (s *Service) ReadClipboard() (string, error) { - result, handled, err := s.Core().QUERY(clipboard.QueryText{}) - if err != nil { - return "", err - } - if !handled { - return "", core.E("display.ReadClipboard", "clipboard service not available", nil) - } - content, _ := result.(clipboard.ClipboardContent) - return content.Text, nil -} - -// WriteClipboard writes text to the clipboard. -// Use: _ = svc.WriteClipboard("updated") -func (s *Service) WriteClipboard(text string) error { - result, handled, err := s.Core().PERFORM(clipboard.TaskSetText{Text: text}) - if err != nil { - return err - } - if !handled { - return core.E("display.WriteClipboard", "clipboard service not available", nil) - } - if ok, _ := result.(bool); !ok { - return core.E("display.WriteClipboard", "clipboard write failed", nil) - } - return nil -} - -// HasClipboard reports whether the clipboard has text or image content. -// Use: hasContent := svc.HasClipboard() -func (s *Service) HasClipboard() bool { - textResult, textHandled, _ := s.Core().QUERY(clipboard.QueryText{}) - if textHandled { - if content, ok := textResult.(clipboard.ClipboardContent); ok && content.HasContent { - return true - } - } - imageResult, imageHandled, _ := s.Core().QUERY(clipboard.QueryImage{}) - if imageHandled { - if content, ok := imageResult.(clipboard.ClipboardImageContent); ok && content.HasContent { - return true - } - } - return false -} - -// ClearClipboard clears clipboard text and any image data when supported. -// Use: _ = svc.ClearClipboard() -func (s *Service) ClearClipboard() error { - result, handled, err := s.Core().PERFORM(clipboard.TaskClear{}) - if err != nil { - return err - } - if !handled { - return core.E("display.ClearClipboard", "clipboard service not available", nil) - } - if ok, _ := result.(bool); !ok { - return core.E("display.ClearClipboard", "clipboard clear failed", nil) - } - return nil -} - -// ReadClipboardImage returns the clipboard image content. -// Use: image, err := svc.ReadClipboardImage() -func (s *Service) ReadClipboardImage() (clipboard.ClipboardImageContent, error) { - result, handled, err := s.Core().QUERY(clipboard.QueryImage{}) - if err != nil { - return clipboard.ClipboardImageContent{}, err - } - if !handled { - return clipboard.ClipboardImageContent{}, core.E("display.ReadClipboardImage", "clipboard service not available", nil) - } - content, _ := result.(clipboard.ClipboardImageContent) - return content, nil -} - -// WriteClipboardImage writes raw image data to the clipboard. -// Use: _ = svc.WriteClipboardImage(data) -func (s *Service) WriteClipboardImage(data []byte) error { - result, handled, err := s.Core().PERFORM(clipboard.TaskSetImage{Data: data}) - if err != nil { - return err - } - if !handled { - return core.E("display.WriteClipboardImage", "clipboard service not available", nil) - } - if ok, _ := result.(bool); !ok { - return core.E("display.WriteClipboardImage", "clipboard image write failed", nil) - } - return nil -} - -// --- Notifications --- - -// ShowNotification sends a native notification. -// Use: _ = svc.ShowNotification(notification.NotificationOptions{Title: "Build complete", Message: "All checks passed"}) -func (s *Service) ShowNotification(opts notification.NotificationOptions) error { - _, handled, err := s.Core().PERFORM(notification.TaskSend{Opts: opts}) - if err != nil { - return err - } - if !handled { - return core.E("display.ShowNotification", "notification service not available", nil) - } - return nil -} - -// ShowInfoNotification sends an informational notification. -// Use: _ = svc.ShowInfoNotification("Build complete", "All checks passed") -func (s *Service) ShowInfoNotification(title, message string) error { - return s.ShowNotification(notification.NotificationOptions{ - Title: title, - Message: message, - Severity: notification.SeverityInfo, - }) -} - -// ShowWarningNotification sends a warning notification. -// Use: _ = svc.ShowWarningNotification("Build warning", "Tests are flaky") -func (s *Service) ShowWarningNotification(title, message string) error { - return s.ShowNotification(notification.NotificationOptions{ - Title: title, - Message: message, - Severity: notification.SeverityWarning, - }) -} - -// ShowErrorNotification sends an error notification. -// Use: _ = svc.ShowErrorNotification("Build failed", "See the log output") -func (s *Service) ShowErrorNotification(title, message string) error { - return s.ShowNotification(notification.NotificationOptions{ - Title: title, - Message: message, - Severity: notification.SeverityError, - }) -} - -// RequestNotificationPermission requests notification permission. -// Use: granted, err := svc.RequestNotificationPermission() -func (s *Service) RequestNotificationPermission() (bool, error) { - result, handled, err := s.Core().PERFORM(notification.TaskRequestPermission{}) - if err != nil { - return false, err - } - if !handled { - return false, corego.NewError(corego.Sprintf("notification service not available")) - } - granted, _ := result.(bool) - return granted, nil -} - -// CheckNotificationPermission checks notification permission. -// Use: granted, err := svc.CheckNotificationPermission() -func (s *Service) CheckNotificationPermission() (bool, error) { - result, handled, err := s.Core().QUERY(notification.QueryPermission{}) - if err != nil { - return false, err - } - if !handled { - return false, corego.NewError(corego.Sprintf("notification service not available")) - } - status, _ := result.(notification.PermissionStatus) - return status.Granted, nil -} - -// ClearNotifications clears notifications when supported. -// Use: _ = svc.ClearNotifications() -func (s *Service) ClearNotifications() error { - _, handled, err := s.Core().PERFORM(notification.TaskClear{}) - if err != nil { - return err - } - if !handled { - return corego.NewError(corego.Sprintf("notification service not available")) - } - return nil -} - -// --- Dialogs --- - -// OpenFileDialog opens a file picker and returns all selected paths. -// Use: paths, err := svc.OpenFileDialog(dialog.OpenFileOptions{Title: "Open report"}) -func (s *Service) OpenFileDialog(opts dialog.OpenFileOptions) ([]string, error) { - result, handled, err := s.Core().PERFORM(dialog.TaskOpenFile{Opts: opts}) - if err != nil { - return nil, err - } - if !handled { - return nil, corego.NewError(corego.Sprintf("dialog service not available")) - } - paths, _ := result.([]string) - return paths, nil -} - -// OpenSingleFileDialog opens a file picker and returns the first selected path. -// Use: path, err := svc.OpenSingleFileDialog(dialog.OpenFileOptions{Title: "Open report"}) -func (s *Service) OpenSingleFileDialog(opts dialog.OpenFileOptions) (string, error) { - paths, err := s.OpenFileDialog(opts) - if err != nil { - return "", err - } - if len(paths) == 0 { - return "", nil - } - return paths[0], nil -} - -// SaveFileDialog opens a save dialog and returns the selected path. -// Use: path, err := svc.SaveFileDialog(dialog.SaveFileOptions{Title: "Export report"}) -func (s *Service) SaveFileDialog(opts dialog.SaveFileOptions) (string, error) { - result, handled, err := s.Core().PERFORM(dialog.TaskSaveFile{Opts: opts}) - if err != nil { - return "", err - } - if !handled { - return "", corego.NewError(corego.Sprintf("dialog service not available")) - } - path, _ := result.(string) - return path, nil -} - -// OpenDirectoryDialog opens a directory picker and returns the selected path. -// Use: path, err := svc.OpenDirectoryDialog(dialog.OpenDirectoryOptions{Title: "Choose workspace"}) -func (s *Service) OpenDirectoryDialog(opts dialog.OpenDirectoryOptions) (string, error) { - result, handled, err := s.Core().PERFORM(dialog.TaskOpenDirectory{Opts: opts}) - if err != nil { - return "", err - } - if !handled { - return "", corego.NewError(corego.Sprintf("dialog service not available")) - } - path, _ := result.(string) - return path, nil -} - -// ConfirmDialog shows a confirmation prompt. -// Use: confirmed, err := svc.ConfirmDialog("Delete file", "Remove report.txt?") -func (s *Service) ConfirmDialog(title, message string) (bool, error) { - result, handled, err := s.Core().PERFORM(dialog.TaskMessageDialog{ - Opts: dialog.MessageDialogOptions{ - Type: dialog.DialogQuestion, - Title: title, - Message: message, - Buttons: []string{"Yes", "No"}, - }, - }) - if err != nil { - return false, err - } - if !handled { - return false, corego.NewError(corego.Sprintf("dialog service not available")) - } - button, _ := result.(string) - return button == "Yes" || button == "OK", nil -} - -// PromptDialog shows a prompt-style dialog and returns entered text when the webview -// prompt path is available, otherwise it falls back to a button-based message dialog. -// Use: value, accepted, err := svc.PromptDialog("Rename file", "Enter a new name") -func (s *Service) PromptDialog(title, message string) (string, bool, error) { - if text, ok, err := s.promptViaWebView(title, message); err == nil { - if ok { - return text, true, nil - } - return "", false, nil - } - - // Fall back to the native message dialog path when no webview prompt is available. - // The returned error is intentionally ignored unless the fallback also fails. - - result, handled, err := s.Core().PERFORM(dialog.TaskMessageDialog{ - Opts: dialog.MessageDialogOptions{ - Type: dialog.DialogInfo, - Title: title, - Message: message, - Buttons: []string{"OK", "Cancel"}, - }, - }) - if err != nil { - return "", false, err - } - if !handled { - return "", false, corego.NewError(corego.Sprintf("dialog service not available")) - } - button, _ := result.(string) - return button, button == "OK", nil -} - -func (s *Service) promptViaWebView(title, message string) (string, bool, error) { - windowName := s.GetFocusedWindow() - if windowName == "" { - infos := s.ListWindowInfos() - if len(infos) > 0 { - windowName = infos[0].Name - } - } - if windowName == "" { - return "", false, corego.NewError(corego.Sprintf("no webview window available")) - } - - encodedTitleR := corego.JSONMarshal(title) - if !encodedTitleR.OK { - return "", false, corego.E("display.showDialog", "failed to marshal title", nil) - } - encodedMessageR := corego.JSONMarshal(message) - if !encodedMessageR.OK { - return "", false, corego.E("display.showDialog", "failed to marshal message", nil) - } - - result, handled, err := s.Core().PERFORM(webview.TaskEvaluate{ - Window: windowName, - Script: "window.prompt(" + string(encodedTitleR.Value.([]byte)) + "," + string(encodedMessageR.Value.([]byte)) + ")", - }) - if err != nil { - return "", false, err - } - if !handled { - return "", false, corego.NewError(corego.Sprintf("webview service not available")) - } - if result == nil { - return "", false, nil - } - if text, ok := result.(string); ok { - return text, true, nil - } - return corego.Sprint(result), true, nil -} - -// DialogMessage shows an informational, warning, or error message via the notification pipeline. -// Use: _ = svc.DialogMessage("warning", "Build failed", "Check the log output") -func (s *Service) DialogMessage(kind, title, message string) error { - var severity notification.NotificationSeverity - switch kind { - case "warning": - severity = notification.SeverityWarning - case "error": - severity = notification.SeverityError - default: - severity = notification.SeverityInfo - } - _, _, err := s.Core().PERFORM(notification.TaskSend{ - Opts: notification.NotificationOptions{ - Title: title, - Message: message, - Severity: severity, - }, - }) - return err -} - -// --- Theme --- - -// GetTheme returns the current theme state. -// Use: theme := svc.GetTheme() -func (s *Service) GetTheme() *Theme { - result, handled, err := s.Core().QUERY(environment.QueryTheme{}) - if err != nil || !handled { - return nil - } - theme, ok := result.(environment.ThemeInfo) - if !ok { - return nil - } - return &Theme{IsDark: theme.IsDark} -} - -// GetSystemTheme returns the current system theme preference. -// Use: theme := svc.GetSystemTheme() -func (s *Service) GetSystemTheme() string { - result, handled, err := s.Core().QUERY(environment.QueryTheme{}) - if err != nil || !handled { - return "" - } - theme, ok := result.(environment.ThemeInfo) - if !ok { - return "" - } - if theme.IsDark { - return "dark" - } - return "light" -} - -// SetTheme overrides the application theme. -// Use: _ = svc.SetTheme(true) -func (s *Service) SetTheme(isDark bool) error { - if isDark { - return s.SetThemeMode("dark") - } - return s.SetThemeMode("light") -} - -// SetThemeMode overrides the application theme using a declarative mode string. -// Use: _ = svc.SetThemeMode("system") -func (s *Service) SetThemeMode(theme string) error { - _, handled, err := s.Core().PERFORM(environment.TaskSetTheme{Theme: theme}) - if err != nil { - return err - } - if !handled { - return corego.NewError(corego.Sprintf("environment service not available")) - } - return nil -} - -// --- Tray --- - -// SetTrayIcon sets the tray icon image. -// Use: _ = svc.SetTrayIcon(iconBytes) -func (s *Service) SetTrayIcon(data []byte) error { - _, handled, err := s.Core().PERFORM(systray.TaskSetTrayIcon{Data: data}) - if err != nil { - return err - } - if !handled { - return corego.NewError(corego.Sprintf("systray service not available")) - } - return nil -} - -// SetTrayTooltip updates the tray tooltip. -// Use: _ = svc.SetTrayTooltip("Core is ready") -func (s *Service) SetTrayTooltip(tooltip string) error { - _, handled, err := s.Core().PERFORM(systray.TaskSetTooltip{Tooltip: tooltip}) - if err != nil { - return err - } - if !handled { - return corego.NewError(corego.Sprintf("systray service not available")) - } - return nil -} - -// SetTrayLabel updates the tray label. -// Use: _ = svc.SetTrayLabel("Core") -func (s *Service) SetTrayLabel(label string) error { - _, handled, err := s.Core().PERFORM(systray.TaskSetLabel{Label: label}) - if err != nil { - return err - } - if !handled { - return corego.NewError(corego.Sprintf("systray service not available")) - } - return nil -} - -// SetTrayMenu replaces the tray menu items. -// Use: _ = svc.SetTrayMenu([]systray.TrayMenuItem{{Label: "Quit", ActionID: "quit"}}) -func (s *Service) SetTrayMenu(items []systray.TrayMenuItem) error { - _, handled, err := s.Core().PERFORM(systray.TaskSetTrayMenu{Items: items}) - if err != nil { - return err - } - if !handled { - return corego.NewError(corego.Sprintf("systray service not available")) - } - return nil -} - -// GetTrayInfo returns current tray state information. -// Use: info := svc.GetTrayInfo() -func (s *Service) GetTrayInfo() map[string]any { - trayService, err := core.ServiceFor[*systray.Service](s.Core(), "systray") - if err != nil || trayService == nil || trayService.Manager() == nil { - return nil - } - return trayService.Manager().GetInfo() -} - -// ShowTrayMessage shows a tray message or notification. -// Use: _ = svc.ShowTrayMessage("Core", "Sync complete") -func (s *Service) ShowTrayMessage(title, message string) error { - _, handled, err := s.Core().PERFORM(systray.TaskShowMessage{Title: title, Message: message}) - if err != nil { - return err - } - if !handled { - return corego.NewError(corego.Sprintf("systray service not available")) - } - return nil -} - // GetEventManager returns the event manager for WebSocket event subscriptions. // Use: events := svc.GetEventManager() func (s *Service) GetEventManager() *WSEventManager { @@ -2326,11 +1606,12 @@ func ptr[T any](v T) *T { return &v } func (s *Service) handleNewWorkspace() { _, _, _ = s.Core().PERFORM(window.TaskOpenWindow{ - Opts: []window.WindowOption{ - window.WithName("workspace-new"), - window.WithTitle("New Workspace"), - window.WithURL("/workspace/new"), - window.WithSize(500, 400), + Window: &window.Window{ + Name: "workspace-new", + Title: "New Workspace", + URL: "/workspace/new", + Width: 500, + Height: 400, }, }) } @@ -2349,18 +1630,19 @@ func (s *Service) handleListWorkspaces() { func (s *Service) handleNewFile() { _, _, _ = s.Core().PERFORM(window.TaskOpenWindow{ - Opts: []window.WindowOption{ - window.WithName("editor"), - window.WithTitle("New File - Editor"), - window.WithURL("/#/developer/editor?new=true"), - window.WithSize(1200, 800), + Window: &window.Window{ + Name: "editor", + Title: "New File - Editor", + URL: "/#/developer/editor?new=true", + Width: 1200, + Height: 800, }, }) } func (s *Service) handleOpenFile() { result, handled, err := s.Core().PERFORM(dialog.TaskOpenFile{ - Opts: dialog.OpenFileOptions{ + Options: dialog.OpenFileOptions{ Title: "Open File", AllowMultiple: false, }, @@ -2373,11 +1655,12 @@ func (s *Service) handleOpenFile() { return } _, _, _ = s.Core().PERFORM(window.TaskOpenWindow{ - Opts: []window.WindowOption{ - window.WithName("editor"), - window.WithTitle(paths[0] + " - Editor"), - window.WithURL("/#/developer/editor?file=" + paths[0]), - window.WithSize(1200, 800), + Window: &window.Window{ + Name: "editor", + Title: paths[0] + " - Editor", + URL: "/#/developer/editor?file=" + paths[0], + Width: 1200, + Height: 800, }, }) } @@ -2385,21 +1668,23 @@ func (s *Service) handleOpenFile() { func (s *Service) handleSaveFile() { _ = s.Core().ACTION(ActionIDECommand{Command: "save"}) } func (s *Service) handleOpenEditor() { _, _, _ = s.Core().PERFORM(window.TaskOpenWindow{ - Opts: []window.WindowOption{ - window.WithName("editor"), - window.WithTitle("Editor"), - window.WithURL("/#/developer/editor"), - window.WithSize(1200, 800), + Window: &window.Window{ + Name: "editor", + Title: "Editor", + URL: "/#/developer/editor", + Width: 1200, + Height: 800, }, }) } func (s *Service) handleOpenTerminal() { _, _, _ = s.Core().PERFORM(window.TaskOpenWindow{ - Opts: []window.WindowOption{ - window.WithName("terminal"), - window.WithTitle("Terminal"), - window.WithURL("/#/developer/terminal"), - window.WithSize(800, 500), + Window: &window.Window{ + Name: "terminal", + Title: "Terminal", + URL: "/#/developer/terminal", + Width: 800, + Height: 500, }, }) } diff --git a/pkg/display/display_test.go b/pkg/display/display_test.go index 384f345a..7a8c5448 100644 --- a/pkg/display/display_test.go +++ b/pkg/display/display_test.go @@ -2,21 +2,14 @@ package display import ( "context" - "encoding/base64" - "os" - "path/filepath" "testing" + coreio "forge.lthn.ai/core/go-io" "forge.lthn.ai/core/go/pkg/core" - "dappco.re/go/core/gui/pkg/clipboard" - "dappco.re/go/core/gui/pkg/dialog" - "dappco.re/go/core/gui/pkg/environment" - "dappco.re/go/core/gui/pkg/menu" - "dappco.re/go/core/gui/pkg/notification" - "dappco.re/go/core/gui/pkg/screen" - "dappco.re/go/core/gui/pkg/systray" - "dappco.re/go/core/gui/pkg/webview" - "dappco.re/go/core/gui/pkg/window" + coreutil "dappco.re/go/core" + "forge.lthn.ai/core/gui/pkg/menu" + "forge.lthn.ai/core/gui/pkg/systray" + "forge.lthn.ai/core/gui/pkg/window" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -201,84 +194,29 @@ func newTestConclave(t *testing.T) *core.Core { return c } -func newExtendedTestConclave(t *testing.T) *core.Core { +func requireCreateWindow(t *testing.T, svc *Service, options CreateWindowOptions) { t.Helper() - fixture := newExtendedTestConclaveWithMocks(t) - return fixture.core -} - -type extendedTestConclave struct { - core *core.Core - clipboardPlatform *mockClipboardPlatform - notificationPlatform *mockNotificationPlatform - dialogPlatform *mockDialogPlatform - environmentPlatform *mockEnvironmentPlatform -} - -func newExtendedTestConclaveWithMocks(t *testing.T) *extendedTestConclave { - t.Helper() - clipboardPlatform := &mockClipboardPlatform{text: "hello", ok: true, image: []byte{1, 2, 3}, imgOk: true} - notificationPlatform := &mockNotificationPlatform{permGranted: true} - dialogPlatform := &mockDialogPlatform{button: "OK"} - environmentPlatform := &mockEnvironmentPlatform{ - isDark: true, - accent: "rgb(0,122,255)", - info: environment.EnvironmentInfo{ - OS: "darwin", Arch: "arm64", - Platform: environment.PlatformInfo{Name: "macOS", Version: "14.0"}, - }, - } - - c, err := core.New( - core.WithService(Register(nil)), - core.WithService(window.Register(window.NewMockPlatform())), - core.WithService(screen.Register(&mockScreenPlatform{ - screens: []screen.Screen{{ - ID: "primary", Name: "Primary", IsPrimary: true, - Size: screen.Size{Width: 2560, Height: 1440}, - Bounds: screen.Rect{X: 0, Y: 0, Width: 2560, Height: 1440}, - WorkArea: screen.Rect{X: 0, Y: 0, Width: 2560, Height: 1440}, - }}, - })), - core.WithService(systray.Register(systray.NewMockPlatform())), - core.WithService(menu.Register(menu.NewMockPlatform())), - core.WithService(clipboard.Register(clipboardPlatform)), - core.WithService(notification.Register(notificationPlatform)), - core.WithService(dialog.Register(dialogPlatform)), - core.WithService(environment.Register(environmentPlatform)), - core.WithService(webview.Register(webview.Options{})), - core.WithServiceLock(), - ) + _, err := svc.CreateWindow(options) require.NoError(t, err) - require.NoError(t, c.ServiceStartup(context.Background(), nil)) - return &extendedTestConclave{ - core: c, - clipboardPlatform: clipboardPlatform, - notificationPlatform: notificationPlatform, - dialogPlatform: dialogPlatform, - environmentPlatform: environmentPlatform, - } } // --- Tests --- -func TestNew(t *testing.T) { - t.Run("creates service successfully", func(t *testing.T) { - service, err := New() - assert.NoError(t, err) - assert.NotNil(t, service, "New() should return a non-nil service instance") - }) - - t.Run("returns independent instances", func(t *testing.T) { - service1, err1 := New() - service2, err2 := New() - assert.NoError(t, err1) - assert.NoError(t, err2) - assert.NotSame(t, service1, service2, "New() should return different instances") - }) +func TestNewService_Good(t *testing.T) { + service, err := NewService() + assert.NoError(t, err) + assert.NotNil(t, service) } -func TestRegisterClosure_Good(t *testing.T) { +func TestNewService_Good_IndependentInstances(t *testing.T) { + service1, err1 := NewService() + service2, err2 := NewService() + assert.NoError(t, err1) + assert.NoError(t, err2) + assert.NotSame(t, service1, service2) +} + +func TestRegister_Good(t *testing.T) { factory := Register(nil) // nil wailsApp for testing assert.NotNil(t, factory) @@ -320,7 +258,7 @@ func TestConfigTask_Good(t *testing.T) { _, c := newTestDisplayService(t) newCfg := map[string]any{"default_width": 800} - _, handled, err := c.PERFORM(window.TaskSaveConfig{Value: newCfg}) + _, handled, err := c.PERFORM(window.TaskSaveConfig{Config: newCfg}) require.NoError(t, err) assert.True(t, handled) @@ -337,7 +275,7 @@ func TestServiceConclave_Good(t *testing.T) { // Open a window via IPC result, handled, err := c.PERFORM(window.TaskOpenWindow{ - Opts: []window.WindowOption{window.WithName("main")}, + Window: &window.Window{Name: "main"}, }) require.NoError(t, err) assert.True(t, handled) @@ -379,7 +317,7 @@ func TestServiceConclave_Bad(t *testing.T) { // --- IPC delegation tests (full conclave) --- -func TestOpenWindow_Good(t *testing.T) { +func TestOpenWindow_Compatibility_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") @@ -392,17 +330,16 @@ func TestOpenWindow_Good(t *testing.T) { assert.GreaterOrEqual(t, len(infos), 1) }) - t.Run("creates window with custom options", func(t *testing.T) { - err := svc.OpenWindow( - window.WithName("custom-window"), - window.WithTitle("Custom Title"), - window.WithSize(640, 480), - window.WithURL("/custom"), - ) - assert.NoError(t, err) + t.Run("creates window with declarative options", func(t *testing.T) { + info, err := svc.CreateWindow(CreateWindowOptions{ + Name: "custom-window", + Title: "Custom Title", + URL: "/custom", + Width: 640, + Height: 480, + }) + require.NoError(t, err) - result, _, _ := c.QUERY(window.QueryWindowByName{Name: "custom-window"}) - info := result.(*window.WindowInfo) assert.Equal(t, "custom-window", info.Name) }) } @@ -411,10 +348,7 @@ func TestGetWindowInfo_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow( - window.WithName("test-win"), - window.WithSize(800, 600), - ) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "test-win", Width: 800, Height: 600}) // Modify position via IPC _, _, _ = c.PERFORM(window.TaskSetPosition{Name: "test-win", X: 100, Y: 200}) @@ -463,9 +397,8 @@ func TestListWindowInfos_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("win-1")) - _ = svc.OpenWindow(window.WithName("win-2")) - _ = svc.MinimizeWindow("win-2") + requireCreateWindow(t, svc, CreateWindowOptions{Name: "win-1"}) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "win-2"}) infos := svc.ListWindowInfos() assert.Len(t, infos, 2) @@ -484,7 +417,7 @@ func TestListWindowInfos_Good(t *testing.T) { func TestSetWindowPosition_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("pos-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "pos-win"}) err := svc.SetWindowPosition("pos-win", 300, 400) assert.NoError(t, err) @@ -505,7 +438,7 @@ func TestSetWindowPosition_Bad(t *testing.T) { func TestSetWindowSize_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("size-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "size-win"}) err := svc.SetWindowSize("size-win", 1024, 768) assert.NoError(t, err) @@ -518,7 +451,7 @@ func TestSetWindowSize_Good(t *testing.T) { func TestMaximizeWindow_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("max-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "max-win"}) err := svc.MaximizeWindow("max-win") assert.NoError(t, err) @@ -530,7 +463,7 @@ func TestMaximizeWindow_Good(t *testing.T) { func TestRestoreWindow_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("restore-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "restore-win"}) _ = svc.MaximizeWindow("restore-win") err := svc.RestoreWindow("restore-win") @@ -543,7 +476,7 @@ func TestRestoreWindow_Good(t *testing.T) { func TestFocusWindow_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("focus-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "focus-win"}) err := svc.FocusWindow("focus-win") assert.NoError(t, err) @@ -555,7 +488,7 @@ func TestFocusWindow_Good(t *testing.T) { func TestCloseWindow_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("close-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "close-win"}) err := svc.CloseWindow("close-win") assert.NoError(t, err) @@ -568,7 +501,7 @@ func TestCloseWindow_Good(t *testing.T) { func TestSetWindowVisibility_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("vis-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "vis-win"}) err := svc.SetWindowVisibility("vis-win", false) assert.NoError(t, err) @@ -586,7 +519,7 @@ func TestSetWindowVisibility_Good(t *testing.T) { func TestSetWindowAlwaysOnTop_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("ontop-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "ontop-win"}) err := svc.SetWindowAlwaysOnTop("ontop-win", true) assert.NoError(t, err) @@ -595,7 +528,7 @@ func TestSetWindowAlwaysOnTop_Good(t *testing.T) { func TestSetWindowTitle_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("title-win")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "title-win"}) err := svc.SetWindowTitle("title-win", "New Title") assert.NoError(t, err) @@ -604,18 +537,18 @@ func TestSetWindowTitle_Good(t *testing.T) { func TestGetFocusedWindow_Good(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("win-a")) - _ = svc.OpenWindow(window.WithName("win-b")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "win-a"}) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "win-b"}) _ = svc.FocusWindow("win-b") focused := svc.GetFocusedWindow() assert.Equal(t, "win-b", focused) } -func TestGetFocusedWindow_NoneSelected(t *testing.T) { +func TestGetFocusedWindow_Good_NoneSelected(t *testing.T) { c := newTestConclave(t) svc := core.MustServiceFor[*Service](c, "display") - _ = svc.OpenWindow(window.WithName("win-a")) + requireCreateWindow(t, svc, CreateWindowOptions{Name: "win-a"}) focused := svc.GetFocusedWindow() assert.Equal(t, "", focused) @@ -835,7 +768,7 @@ func TestHandleIPCEvents_WindowOpened_Good(t *testing.T) { // Open a window — this should trigger ActionWindowOpened // which HandleIPCEvents should convert to a WS event result, handled, err := c.PERFORM(window.TaskOpenWindow{ - Opts: []window.WindowOption{window.WithName("test")}, + Window: &window.Window{Name: "test"}, }) require.NoError(t, err) assert.True(t, handled) @@ -866,9 +799,9 @@ func TestWSEventManager_Good(t *testing.T) { func TestLoadConfig_Good(t *testing.T) { // Create temp config file dir := t.TempDir() - cfgPath := filepath.Join(dir, ".core", "gui", "config.yaml") - require.NoError(t, os.MkdirAll(filepath.Dir(cfgPath), 0o755)) - require.NoError(t, os.WriteFile(cfgPath, []byte(` + cfgPath := coreutil.JoinPath(dir, ".core", "gui", "config.yaml") + require.NoError(t, coreio.Local.EnsureDir(coreutil.JoinPath(dir, ".core", "gui"))) + require.NoError(t, coreio.Local.Write(cfgPath, ` window: default_width: 1280 default_height: 720 @@ -876,9 +809,9 @@ systray: tooltip: "Test App" menu: show_dev_tools: false -`), 0o644)) +`)) - s, _ := New() + s, _ := NewService() s.loadConfigFrom(cfgPath) // Verify configData was populated from file @@ -888,8 +821,8 @@ menu: } func TestLoadConfig_Bad_MissingFile(t *testing.T) { - s, _ := New() - s.loadConfigFrom(filepath.Join(t.TempDir(), "nonexistent.yaml")) + s, _ := NewService() + s.loadConfigFrom(coreutil.JoinPath(t.TempDir(), "nonexistent.yaml")) // Should not panic, configData stays at empty defaults assert.Empty(t, s.configData["window"]) @@ -899,9 +832,9 @@ func TestLoadConfig_Bad_MissingFile(t *testing.T) { func TestHandleConfigTask_Persists_Good(t *testing.T) { dir := t.TempDir() - cfgPath := filepath.Join(dir, "config.yaml") + cfgPath := coreutil.JoinPath(dir, "config.yaml") - s, _ := New() + s, _ := NewService() s.loadConfigFrom(cfgPath) // Creates empty config (file doesn't exist yet) // Simulate a TaskSaveConfig through the handler @@ -915,15 +848,15 @@ func TestHandleConfigTask_Persists_Good(t *testing.T) { c.ServiceStartup(context.Background(), nil) _, handled, err := c.PERFORM(window.TaskSaveConfig{ - Value: map[string]any{"default_width": 1920}, + Config: map[string]any{"default_width": 1920}, }) require.NoError(t, err) assert.True(t, handled) // Verify file was written - data, err := os.ReadFile(cfgPath) + data, err := coreio.Local.Read(cfgPath) require.NoError(t, err) - assert.Contains(t, string(data), "default_width") + assert.Contains(t, data, "default_width") } func TestHandleWSMessage_Extended_Good(t *testing.T) { diff --git a/pkg/display/events.go b/pkg/display/events.go index 9c468a82..35876ddd 100644 --- a/pkg/display/events.go +++ b/pkg/display/events.go @@ -3,11 +3,12 @@ package display import ( "net/http" + "strconv" "sync" "time" - "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/window" + core "dappco.re/go/core" + "forge.lthn.ai/core/gui/pkg/window" "github.com/gorilla/websocket" ) @@ -41,6 +42,11 @@ const ( EventContextMenuClick EventType = "contextmenu.item-clicked" EventWebviewConsole EventType = "webview.console" EventWebviewException EventType = "webview.exception" + EventCustomEvent EventType = "event.custom" + EventDockProgress EventType = "dock.progress" + EventDockBounce EventType = "dock.bounce" + EventNotificationAction EventType = "notification.action" + EventNotificationDismiss EventType = "notification.dismiss" ) // Event represents a display event sent to subscribers. @@ -143,13 +149,13 @@ func (em *WSEventManager) sendEvent(conn *websocket.Conn, event Event) { return } - r := core.JSONMarshal(event) - if !r.OK { + result := core.JSONMarshal(event) + if !result.OK { return } conn.SetWriteDeadline(time.Now().Add(10 * time.Second)) - if err := conn.WriteMessage(websocket.TextMessage, r.Value.([]byte)); err != nil { + if err := conn.WriteMessage(websocket.TextMessage, result.Value.([]byte)); err != nil { em.removeClient(conn) } } @@ -187,7 +193,7 @@ func (em *WSEventManager) handleMessages(conn *websocket.Conn) { EventTypes []EventType `json:"eventTypes,omitempty"` } - if r := core.JSONUnmarshal(message, &msg); !r.OK { + if !core.JSONUnmarshal(message, &msg).OK { continue } @@ -216,7 +222,7 @@ func (em *WSEventManager) subscribe(conn *websocket.Conn, id string, eventTypes if id == "" { em.mu.Lock() em.nextSubID++ - id = core.Sprintf("sub-%d", em.nextSubID) + id = "sub-" + strconv.Itoa(em.nextSubID) em.mu.Unlock() } @@ -233,8 +239,7 @@ func (em *WSEventManager) subscribe(conn *websocket.Conn, id string, eventTypes "id": id, "eventTypes": eventTypes, } - r := core.JSONMarshal(response) - if r.OK { + if r := core.JSONMarshal(response); r.OK { conn.WriteMessage(websocket.TextMessage, r.Value.([]byte)) } } @@ -258,8 +263,7 @@ func (em *WSEventManager) unsubscribe(conn *websocket.Conn, id string) { "type": "unsubscribed", "id": id, } - r := core.JSONMarshal(response) - if r.OK { + if r := core.JSONMarshal(response); r.OK { conn.WriteMessage(websocket.TextMessage, r.Value.([]byte)) } } @@ -285,8 +289,7 @@ func (em *WSEventManager) listSubscriptions(conn *websocket.Conn) { "type": "subscriptions", "subscriptions": subs, } - r := core.JSONMarshal(response) - if r.OK { + if r := core.JSONMarshal(response); r.OK { conn.WriteMessage(websocket.TextMessage, r.Value.([]byte)) } } diff --git a/pkg/dock/messages.go b/pkg/dock/messages.go index f45cc31c..86d57aa8 100644 --- a/pkg/dock/messages.go +++ b/pkg/dock/messages.go @@ -23,7 +23,31 @@ type TaskSetBadge struct{ Label string } // TaskRemoveBadge removes the dock/taskbar badge. Result: nil type TaskRemoveBadge struct{} +// TaskSetProgressBar sets the progress indicator on the dock/taskbar icon. +// Value must be in the range [0.0, 1.0]. Use -1.0 to remove the bar. +// Result: nil +// _, _, err := c.PERFORM(TaskSetProgressBar{Value: 0.75}) +type TaskSetProgressBar struct{ Value float64 } + +// TaskBounce animates the dock icon to attract the user's attention. Result: int (bounce ID) +// _, result, err := c.PERFORM(TaskBounce{Type: BounceCritical}) +// bounceID := result.(int) +type TaskBounce struct{ Type BounceType } + +// TaskStopBounce cancels a running dock bounce animation. Result: nil +// _, _, err := c.PERFORM(TaskStopBounce{BounceID: bounceID}) +type TaskStopBounce struct{ BounceID int } + // --- Actions (broadcasts) --- // ActionVisibilityChanged is broadcast after a successful TaskShowIcon or TaskHideIcon. type ActionVisibilityChanged struct{ Visible bool } + +// ActionProgressChanged is broadcast after a successful TaskSetProgressBar. +type ActionProgressChanged struct{ Value float64 } + +// ActionBounceStarted is broadcast after a successful TaskBounce. +type ActionBounceStarted struct { + BounceID int `json:"bounceId"` + Type BounceType `json:"type"` +} diff --git a/pkg/dock/platform.go b/pkg/dock/platform.go index d34004a8..54702cb2 100644 --- a/pkg/dock/platform.go +++ b/pkg/dock/platform.go @@ -1,9 +1,19 @@ // pkg/dock/platform.go package dock +// BounceType controls the style of the macOS dock icon bounce animation. +type BounceType int + +const ( + // BounceInformational bounces the dock icon once briefly. + BounceInformational BounceType = iota + // BounceCritical bounces the dock icon continuously until the app is focused. + BounceCritical +) + // Platform abstracts the dock/taskbar backend (Wails v3). -// macOS: dock icon show/hide + badge. -// Windows: taskbar badge only (show/hide not supported). +// macOS: dock icon show/hide + badge + bounce + progress. +// Windows: taskbar badge and progress only (show/hide/bounce not supported). // Linux: not supported — adapter returns nil for all operations. type Platform interface { ShowIcon() error @@ -11,4 +21,15 @@ type Platform interface { SetBadge(label string) error RemoveBadge() error IsVisible() bool + // SetProgressBar sets a progress indicator on the dock/taskbar icon. + // value is in the range [0.0, 1.0]. Use -1.0 to remove the progress bar. + // p.SetProgressBar(0.5) // 50% progress + SetProgressBar(value float64) error + // Bounce animates the dock icon to attract the user's attention. + // bounceType controls whether the animation loops (BounceCritical) or plays once (BounceInformational). + // Returns a bounce ID that can be passed to StopBounce. + Bounce(bounceType BounceType) (int, error) + // StopBounce cancels a running bounce animation identified by bounceID. + // p.StopBounce(id) + StopBounce(bounceID int) error } diff --git a/pkg/dock/register.go b/pkg/dock/register.go index 11239270..1d9c3cd8 100644 --- a/pkg/dock/register.go +++ b/pkg/dock/register.go @@ -1,10 +1,9 @@ -// pkg/dock/register.go package dock import "forge.lthn.ai/core/go/pkg/core" -// Register creates a factory closure that captures the Platform adapter. -// The returned function has the signature WithService requires: func(*Core) (any, error). +// Register(p) binds the dock service to a Core instance. +// core.WithService(dock.Register(wailsDock)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ diff --git a/pkg/dock/service.go b/pkg/dock/service.go index 260ff0a4..735f578b 100644 --- a/pkg/dock/service.go +++ b/pkg/dock/service.go @@ -1,4 +1,3 @@ -// pkg/dock/service.go package dock import ( @@ -7,30 +6,23 @@ import ( "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the dock service. type Options struct{} -// Service is a core.Service managing dock/taskbar operations via IPC. -// It embeds ServiceRuntime for Core access and delegates to Platform. type Service struct { *core.ServiceRuntime[Options] platform Platform } -// OnStartup registers IPC handlers. func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterQuery(s.handleQuery) s.Core().RegisterTask(s.handleTask) return nil } -// HandleIPCEvents is auto-discovered and registered by core.WithService. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } -// --- Query Handlers --- - func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { switch q.(type) { case QueryVisible: @@ -40,8 +32,6 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { } } -// --- Task Handlers --- - func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { case TaskShowIcon: @@ -66,6 +56,24 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { return nil, true, err } return nil, true, nil + case TaskSetProgressBar: + if err := s.platform.SetProgressBar(t.Value); err != nil { + return nil, true, err + } + _ = s.Core().ACTION(ActionProgressChanged{Value: t.Value}) + return nil, true, nil + case TaskBounce: + bounceID, err := s.platform.Bounce(t.Type) + if err != nil { + return nil, true, err + } + _ = s.Core().ACTION(ActionBounceStarted{BounceID: bounceID, Type: t.Type}) + return bounceID, true, nil + case TaskStopBounce: + if err := s.platform.StopBounce(t.BounceID); err != nil { + return nil, true, err + } + return nil, true, nil default: return nil, false, nil } diff --git a/pkg/dock/service_test.go b/pkg/dock/service_test.go index 503e8706..6db7c197 100644 --- a/pkg/dock/service_test.go +++ b/pkg/dock/service_test.go @@ -13,13 +13,21 @@ import ( // --- Mock Platform --- type mockPlatform struct { - visible bool - badge string - hasBadge bool - showErr error - hideErr error - badgeErr error - removeErr error + visible bool + badge string + hasBadge bool + progress float64 + hasProgress bool + bounceID int + bounceCount int + stopBounceIDs []int + showErr error + hideErr error + badgeErr error + removeErr error + progressErr error + bounceErr error + stopBounceErr error } func (m *mockPlatform) ShowIcon() error { @@ -58,6 +66,32 @@ func (m *mockPlatform) RemoveBadge() error { func (m *mockPlatform) IsVisible() bool { return m.visible } +func (m *mockPlatform) SetProgressBar(value float64) error { + if m.progressErr != nil { + return m.progressErr + } + m.progress = value + m.hasProgress = value >= 0 + return nil +} + +func (m *mockPlatform) Bounce(bounceType BounceType) (int, error) { + if m.bounceErr != nil { + return 0, m.bounceErr + } + m.bounceCount++ + m.bounceID++ + return m.bounceID, nil +} + +func (m *mockPlatform) StopBounce(bounceID int) error { + if m.stopBounceErr != nil { + return m.stopBounceErr + } + m.stopBounceIDs = append(m.stopBounceIDs, bounceID) + return nil +} + // --- Test helpers --- func newTestDockService(t *testing.T) (*Service, *core.Core, *mockPlatform) { @@ -192,3 +226,127 @@ func TestTaskSetBadge_Bad(t *testing.T) { assert.True(t, handled) assert.Error(t, err) } + +func TestTaskSetProgressBar_Good(t *testing.T) { + _, c, mock := newTestDockService(t) + + var received *ActionProgressChanged + c.RegisterAction(func(_ *core.Core, msg core.Message) error { + if a, ok := msg.(ActionProgressChanged); ok { + received = &a + } + return nil + }) + + _, handled, err := c.PERFORM(TaskSetProgressBar{Value: 0.75}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, 0.75, mock.progress) + assert.True(t, mock.hasProgress) + require.NotNil(t, received) + assert.Equal(t, 0.75, received.Value) +} + +func TestTaskSetProgressBar_Remove_Good(t *testing.T) { + _, c, mock := newTestDockService(t) + + _, _, _ = c.PERFORM(TaskSetProgressBar{Value: 0.5}) + _, handled, err := c.PERFORM(TaskSetProgressBar{Value: -1.0}) + require.NoError(t, err) + assert.True(t, handled) + assert.False(t, mock.hasProgress) +} + +func TestTaskSetProgressBar_Bad(t *testing.T) { + _, c, mock := newTestDockService(t) + mock.progressErr = assert.AnError + + _, handled, err := c.PERFORM(TaskSetProgressBar{Value: 0.5}) + assert.True(t, handled) + assert.Error(t, err) +} + +func TestTaskBounce_Good(t *testing.T) { + _, c, mock := newTestDockService(t) + + var received *ActionBounceStarted + c.RegisterAction(func(_ *core.Core, msg core.Message) error { + if a, ok := msg.(ActionBounceStarted); ok { + received = &a + } + return nil + }) + + result, handled, err := c.PERFORM(TaskBounce{Type: BounceInformational}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, 1, mock.bounceCount) + bounceID := result.(int) + assert.Equal(t, 1, bounceID) + require.NotNil(t, received) + assert.Equal(t, 1, received.BounceID) + assert.Equal(t, BounceInformational, received.Type) +} + +func TestTaskBounce_Critical_Good(t *testing.T) { + _, c, mock := newTestDockService(t) + + result, handled, err := c.PERFORM(TaskBounce{Type: BounceCritical}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, 1, mock.bounceCount) + assert.Equal(t, 1, result.(int)) +} + +func TestTaskBounce_Bad(t *testing.T) { + _, c, mock := newTestDockService(t) + mock.bounceErr = assert.AnError + + _, handled, err := c.PERFORM(TaskBounce{Type: BounceInformational}) + assert.True(t, handled) + assert.Error(t, err) +} + +func TestTaskStopBounce_Good(t *testing.T) { + _, c, mock := newTestDockService(t) + + result, _, _ := c.PERFORM(TaskBounce{Type: BounceInformational}) + bounceID := result.(int) + + _, handled, err := c.PERFORM(TaskStopBounce{BounceID: bounceID}) + require.NoError(t, err) + assert.True(t, handled) + assert.Contains(t, mock.stopBounceIDs, bounceID) +} + +func TestTaskStopBounce_Bad(t *testing.T) { + _, c, mock := newTestDockService(t) + mock.stopBounceErr = assert.AnError + + _, handled, err := c.PERFORM(TaskStopBounce{BounceID: 99}) + assert.True(t, handled) + assert.Error(t, err) +} + +func TestBounceType_Ugly(t *testing.T) { + // BounceInformational and BounceCritical must be distinct constants. + assert.NotEqual(t, BounceInformational, BounceCritical) +} + +func TestTaskSetProgressBar_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskSetProgressBar{}) + assert.False(t, handled) +} + +func TestTaskBounce_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskBounce{}) + assert.False(t, handled) +} + +func TestTaskStopBounce_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskStopBounce{}) + assert.False(t, handled) +} diff --git a/pkg/environment/messages.go b/pkg/environment/messages.go index b560450d..b79a6730 100644 --- a/pkg/environment/messages.go +++ b/pkg/environment/messages.go @@ -10,18 +10,21 @@ type QueryInfo struct{} // QueryAccentColour returns the system accent colour. Result: string type QueryAccentColour struct{} +// TaskSetTheme overrides the application theme. Theme values: "light", "dark", "system". +type TaskSetTheme struct { + Theme string `json:"theme"` +} + // TaskOpenFileManager opens the system file manager. Result: error only type TaskOpenFileManager struct { Path string `json:"path"` Select bool `json:"select"` } -// TaskSetTheme applies an application theme override when supported. -// Theme values: "dark", "light", or "system". -type TaskSetTheme struct { - Theme string `json:"theme,omitempty"` - IsDark bool `json:"isDark,omitempty"` -} +// QueryFocusFollowsMouse returns whether focus-follows-mouse is enabled. Result: bool +// +// result := c.QUERY(environment.QueryFocusFollowsMouse{}) +type QueryFocusFollowsMouse struct{} // ActionThemeChanged is broadcast when the system theme changes. type ActionThemeChanged struct { diff --git a/pkg/environment/platform.go b/pkg/environment/platform.go index 3e403f9b..b513dabf 100644 --- a/pkg/environment/platform.go +++ b/pkg/environment/platform.go @@ -7,6 +7,7 @@ type Platform interface { Info() EnvironmentInfo AccentColour() string OpenFileManager(path string, selectFile bool) error + HasFocusFollowsMouse() bool OnThemeChange(handler func(isDark bool)) func() // returns cancel func } diff --git a/pkg/environment/service.go b/pkg/environment/service.go index 9dfd2812..ee8674f0 100644 --- a/pkg/environment/service.go +++ b/pkg/environment/service.go @@ -3,23 +3,23 @@ package environment import ( "context" + "strings" - corego "dappco.re/go/core" + coreerr "forge.lthn.ai/core/go-log" "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the environment service. type Options struct{} -// Service is a core.Service providing environment queries and theme change events via IPC. type Service struct { *core.ServiceRuntime[Options] - platform Platform - cancelTheme func() // cancel function for theme change listener - overrideDark *bool + platform Platform + cancelTheme func() // returned by Platform.OnThemeChange — called on shutdown + override *bool } -// Register creates a factory closure that captures the Platform adapter. +// Register(p) binds the environment service to a Core instance. +// core.WithService(environment.Register(wailsEnvironment)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ @@ -29,19 +29,20 @@ func Register(p Platform) func(*core.Core) (any, error) { } } -// OnStartup registers IPC handlers and the theme change listener. func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterQuery(s.handleQuery) s.Core().RegisterTask(s.handleTask) // Register theme change callback — broadcasts ActionThemeChanged via IPC s.cancelTheme = s.platform.OnThemeChange(func(isDark bool) { + if s.override != nil { + isDark = *s.override + } _ = s.Core().ACTION(ActionThemeChanged{IsDark: isDark}) }) return nil } -// OnShutdown cancels the theme change listener. func (s *Service) OnShutdown(ctx context.Context) error { if s.cancelTheme != nil { s.cancelTheme() @@ -49,7 +50,6 @@ func (s *Service) OnShutdown(ctx context.Context) error { return nil } -// HandleIPCEvents is auto-discovered by core.WithService. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -57,7 +57,7 @@ func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { switch q.(type) { case QueryTheme: - isDark := s.currentTheme() + isDark := s.currentThemeIsDark() theme := "light" if isDark { theme = "dark" @@ -67,6 +67,8 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { return s.platform.Info(), true, nil case QueryAccentColour: return s.platform.AccentColour(), true, nil + case QueryFocusFollowsMouse: + return s.platform.HasFocusFollowsMouse(), true, nil default: return nil, false, nil } @@ -74,6 +76,8 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { + case TaskSetTheme: + return nil, true, s.setThemeOverride(strings.ToLower(strings.TrimSpace(t.Theme))) case TaskOpenFileManager: return nil, true, s.platform.OpenFileManager(t.Path, t.Select) case TaskSetTheme: @@ -86,42 +90,27 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { } } -func (s *Service) taskSetTheme(task TaskSetTheme) error { - shouldApplyTheme := false - switch task.Theme { - case "dark": - isDark := true - s.overrideDark = &isDark - shouldApplyTheme = true - case "light": - isDark := false - s.overrideDark = &isDark - shouldApplyTheme = true - case "system": - s.overrideDark = nil - case "": - isDark := task.IsDark - s.overrideDark = &isDark - shouldApplyTheme = true - default: - return corego.E("environment.setTheme", corego.Sprintf("invalid theme mode: %s", task.Theme), nil) - } - - if shouldApplyTheme { - if setter, ok := s.platform.(interface{ SetTheme(bool) error }); ok { - if err := setter.SetTheme(s.currentTheme()); err != nil { - return err - } - } - } - - _ = s.Core().ACTION(ActionThemeChanged{IsDark: s.currentTheme()}) - return nil -} - -func (s *Service) currentTheme() bool { - if s.overrideDark != nil { - return *s.overrideDark +func (s *Service) currentThemeIsDark() bool { + if s.override != nil { + return *s.override } return s.platform.IsDarkMode() } + +func (s *Service) setThemeOverride(theme string) error { + switch theme { + case "", "system": + s.override = nil + case "dark": + value := true + s.override = &value + case "light": + value := false + s.override = &value + default: + return coreerr.E("environment.setThemeOverride", "theme must be one of: light, dark, system", nil) + } + + _ = s.Core().ACTION(ActionThemeChanged{IsDark: s.currentThemeIsDark()}) + return nil +} diff --git a/pkg/environment/service_test.go b/pkg/environment/service_test.go index b3716e7e..f10517be 100644 --- a/pkg/environment/service_test.go +++ b/pkg/environment/service_test.go @@ -28,6 +28,7 @@ func (m *mockPlatform) AccentColour() string { return m.accentColour } func (m *mockPlatform) OpenFileManager(path string, selectFile bool) error { return m.openFMErr } +func (m *mockPlatform) HasFocusFollowsMouse() bool { return false } func (m *mockPlatform) OnThemeChange(handler func(isDark bool)) func() { m.mu.Lock() m.themeHandler = handler @@ -141,11 +142,11 @@ func TestThemeChange_ActionBroadcast_Good(t *testing.T) { } func TestTaskSetTheme_Good(t *testing.T) { - mock, c := newTestService(t) + _, c := newTestService(t) + _, handled, err := c.PERFORM(TaskSetTheme{Theme: "light"}) require.NoError(t, err) assert.True(t, handled) - assert.True(t, mock.setThemeSeen) result, handled, err := c.QUERY(QueryTheme{}) require.NoError(t, err) @@ -155,12 +156,16 @@ func TestTaskSetTheme_Good(t *testing.T) { assert.Equal(t, "light", theme.Theme) } -func TestTaskSetTheme_Compatibility_Good(t *testing.T) { +func TestTaskSetTheme_Good_SystemClearsOverride(t *testing.T) { mock, c := newTestService(t) - _, handled, err := c.PERFORM(TaskSetTheme{IsDark: true}) + + _, _, err := c.PERFORM(TaskSetTheme{Theme: "light"}) + require.NoError(t, err) + + mock.isDark = true + _, handled, err := c.PERFORM(TaskSetTheme{Theme: "system"}) require.NoError(t, err) assert.True(t, handled) - assert.True(t, mock.setThemeSeen) result, handled, err := c.QUERY(QueryTheme{}) require.NoError(t, err) diff --git a/pkg/events/messages.go b/pkg/events/messages.go new file mode 100644 index 00000000..b85b5f88 --- /dev/null +++ b/pkg/events/messages.go @@ -0,0 +1,34 @@ +// pkg/events/messages.go +package events + +// TaskEmit fires a custom event by name with optional data. +// c.PERFORM(events.TaskEmit{Name: "build:done", Data: result}) +type TaskEmit struct { + Name string + Data any +} + +// TaskOn registers a persistent listener for a named event. +// The listener ID returned in the result can be used with TaskOff. +// c.PERFORM(events.TaskOn{Name: "build:done"}) +type TaskOn struct { + Name string +} + +// TaskOff removes all listeners for a named event. +// c.PERFORM(events.TaskOff{Name: "build:done"}) +type TaskOff struct { + Name string +} + +// QueryListeners returns the count of listeners registered for a named event. +// count := c.QUERY(events.QueryListeners{Name: "build:done"}) +type QueryListeners struct { + Name string +} + +// ActionEventFired is broadcast when a custom event is emitted via TaskEmit. +type ActionEventFired struct { + Name string + Data any +} diff --git a/pkg/events/platform.go b/pkg/events/platform.go new file mode 100644 index 00000000..b75a0500 --- /dev/null +++ b/pkg/events/platform.go @@ -0,0 +1,26 @@ +// pkg/events/platform.go +package events + +// Platform abstracts the custom event backend (Wails v3 EventManager). +// Emit fires an event by name with optional data arguments. +// On registers a persistent listener; returns a cancel function. +// Off removes all listeners for the named event. +// OnMultiple registers a listener that auto-deregisters after counter firings. +// Reset removes all custom event listeners. +// +// cancel := platform.On("build:done", func(e *CustomEvent) { ... }) +// defer cancel() +// platform.Emit("build:done", result) +type Platform interface { + Emit(name string, data ...any) bool + On(name string, callback func(event *CustomEvent)) func() + Off(name string) + OnMultiple(name string, callback func(event *CustomEvent), counter int) + Reset() +} + +// CustomEvent is the event object delivered to On/OnMultiple listeners. +type CustomEvent struct { + Name string + Data any +} diff --git a/pkg/events/register.go b/pkg/events/register.go new file mode 100644 index 00000000..5eb65550 --- /dev/null +++ b/pkg/events/register.go @@ -0,0 +1,16 @@ +// pkg/events/register.go +package events + +import "forge.lthn.ai/core/go/pkg/core" + +// Register(p) binds the events service to a Core instance. +// core.WithService(events.Register(wailsEventManager)) +func Register(p Platform) func(*core.Core) (any, error) { + return func(c *core.Core) (any, error) { + return &Service{ + ServiceRuntime: core.NewServiceRuntime[Options](c, Options{}), + platform: p, + counts: make(map[string]int), + }, nil + } +} diff --git a/pkg/events/service.go b/pkg/events/service.go new file mode 100644 index 00000000..a5516e2b --- /dev/null +++ b/pkg/events/service.go @@ -0,0 +1,103 @@ +// pkg/events/service.go +package events + +import ( + "context" + "sync" + + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/go/pkg/core" +) + +// Options holds configuration for the events service (currently none). +type Options struct{} + +// Service bridges the platform custom event system to the Core IPC bus. +type Service struct { + *core.ServiceRuntime[Options] + platform Platform + mu sync.RWMutex + counts map[string]int // listener count per event name + cancels []func() +} + +func (s *Service) OnStartup(ctx context.Context) error { + s.Core().RegisterQuery(s.handleQuery) + s.Core().RegisterTask(s.handleTask) + return nil +} + +func (s *Service) OnShutdown(ctx context.Context) error { + s.mu.Lock() + defer s.mu.Unlock() + for _, cancel := range s.cancels { + cancel() + } + s.cancels = nil + s.counts = make(map[string]int) + s.platform.Reset() + return nil +} + +func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { + return nil +} + +func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { + switch q := q.(type) { + case QueryListeners: + s.mu.RLock() + count := s.counts[q.Name] + s.mu.RUnlock() + return count, true, nil + default: + return nil, false, nil + } +} + +func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { + switch t := t.(type) { + case TaskEmit: + return s.taskEmit(t) + case TaskOn: + return s.taskOn(t) + case TaskOff: + return nil, true, s.taskOff(t) + default: + return nil, false, nil + } +} + +func (s *Service) taskEmit(t TaskEmit) (any, bool, error) { + if t.Name == "" { + return nil, true, coreerr.E("events.taskEmit", "event name is required", nil) + } + cancelled := s.platform.Emit(t.Name, t.Data) + _ = s.Core().ACTION(ActionEventFired{Name: t.Name, Data: t.Data}) + return cancelled, true, nil +} + +func (s *Service) taskOn(t TaskOn) (any, bool, error) { + if t.Name == "" { + return nil, true, coreerr.E("events.taskOn", "event name is required", nil) + } + cancel := s.platform.On(t.Name, func(event *CustomEvent) { + _ = s.Core().ACTION(ActionEventFired{Name: event.Name, Data: event.Data}) + }) + s.mu.Lock() + s.cancels = append(s.cancels, cancel) + s.counts[t.Name]++ + s.mu.Unlock() + return nil, true, nil +} + +func (s *Service) taskOff(t TaskOff) error { + if t.Name == "" { + return coreerr.E("events.taskOff", "event name is required", nil) + } + s.platform.Off(t.Name) + s.mu.Lock() + delete(s.counts, t.Name) + s.mu.Unlock() + return nil +} diff --git a/pkg/events/service_test.go b/pkg/events/service_test.go new file mode 100644 index 00000000..2ea9acb3 --- /dev/null +++ b/pkg/events/service_test.go @@ -0,0 +1,272 @@ +// pkg/events/service_test.go +package events + +import ( + "context" + "sync" + "testing" + + "forge.lthn.ai/core/go/pkg/core" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// --- Mock Platform --- + +type mockPlatform struct { + mu sync.Mutex + listeners map[string][]*mockListener + emitted []mockEmit +} + +type mockListener struct { + callback func(*CustomEvent) +} + +type mockEmit struct { + name string + data any +} + +func newMockPlatform() *mockPlatform { + return &mockPlatform{ + listeners: make(map[string][]*mockListener), + } +} + +func (m *mockPlatform) Emit(name string, data ...any) bool { + m.mu.Lock() + var payload any + if len(data) == 1 { + payload = data[0] + } else if len(data) > 1 { + payload = data + } + m.emitted = append(m.emitted, mockEmit{name: name, data: payload}) + listeners := append([]*mockListener(nil), m.listeners[name]...) + m.mu.Unlock() + + event := &CustomEvent{Name: name, Data: payload} + for _, l := range listeners { + l.callback(event) + } + return false +} + +func (m *mockPlatform) On(name string, callback func(*CustomEvent)) func() { + m.mu.Lock() + defer m.mu.Unlock() + listener := &mockListener{callback: callback} + m.listeners[name] = append(m.listeners[name], listener) + return func() { + m.mu.Lock() + defer m.mu.Unlock() + slice := m.listeners[name] + for i, l := range slice { + if l == listener { + m.listeners[name] = append(slice[:i], slice[i+1:]...) + return + } + } + } +} + +func (m *mockPlatform) Off(name string) { + m.mu.Lock() + defer m.mu.Unlock() + delete(m.listeners, name) +} + +func (m *mockPlatform) OnMultiple(name string, callback func(*CustomEvent), counter int) { + m.mu.Lock() + defer m.mu.Unlock() + listener := &mockListener{callback: callback} + m.listeners[name] = append(m.listeners[name], listener) +} + +func (m *mockPlatform) Reset() { + m.mu.Lock() + defer m.mu.Unlock() + m.listeners = make(map[string][]*mockListener) +} + +func (m *mockPlatform) listenerCount(name string) int { + m.mu.Lock() + defer m.mu.Unlock() + return len(m.listeners[name]) +} + +func (m *mockPlatform) emitCount() int { + m.mu.Lock() + defer m.mu.Unlock() + return len(m.emitted) +} + +// --- Test helpers --- + +func newTestEventsService(t *testing.T) (*Service, *core.Core, *mockPlatform) { + t.Helper() + mock := newMockPlatform() + c, err := core.New( + core.WithService(Register(mock)), + core.WithServiceLock(), + ) + require.NoError(t, err) + require.NoError(t, c.ServiceStartup(context.Background(), nil)) + svc := core.MustServiceFor[*Service](c, "events") + return svc, c, mock +} + +// --- Good tests --- + +func TestRegister_Good(t *testing.T) { + svc, _, _ := newTestEventsService(t) + assert.NotNil(t, svc) +} + +func TestTaskEmit_Good(t *testing.T) { + _, c, mock := newTestEventsService(t) + + var fired ActionEventFired + c.RegisterAction(func(_ *core.Core, msg core.Message) error { + if a, ok := msg.(ActionEventFired); ok { + fired = a + } + return nil + }) + + _, handled, err := c.PERFORM(TaskEmit{Name: "ping", Data: "hello"}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, 1, mock.emitCount()) + assert.Equal(t, "ping", fired.Name) + assert.Equal(t, "hello", fired.Data) +} + +func TestTaskOn_Good(t *testing.T) { + _, c, mock := newTestEventsService(t) + + _, handled, err := c.PERFORM(TaskOn{Name: "build:done"}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, 1, mock.listenerCount("build:done")) +} + +func TestTaskOff_Good(t *testing.T) { + _, c, mock := newTestEventsService(t) + + _, _, _ = c.PERFORM(TaskOn{Name: "build:done"}) + assert.Equal(t, 1, mock.listenerCount("build:done")) + + _, handled, err := c.PERFORM(TaskOff{Name: "build:done"}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, 0, mock.listenerCount("build:done")) +} + +func TestQueryListeners_Good(t *testing.T) { + _, c, _ := newTestEventsService(t) + + _, _, _ = c.PERFORM(TaskOn{Name: "my:event"}) + _, _, _ = c.PERFORM(TaskOn{Name: "my:event"}) + + result, handled, err := c.QUERY(QueryListeners{Name: "my:event"}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, 2, result.(int)) +} + +func TestOnShutdown_ResetsAll_Good(t *testing.T) { + svc, _, mock := newTestEventsService(t) + + _, _, _ = svc.Core().PERFORM(TaskOn{Name: "a"}) + _, _, _ = svc.Core().PERFORM(TaskOn{Name: "b"}) + + err := svc.OnShutdown(context.Background()) + require.NoError(t, err) + + assert.Equal(t, 0, mock.listenerCount("a")) + assert.Equal(t, 0, mock.listenerCount("b")) + + result, _, _ := svc.Core().QUERY(QueryListeners{Name: "a"}) + assert.Equal(t, 0, result.(int)) +} + +// --- Bad tests --- + +func TestTaskEmit_Bad_EmptyName(t *testing.T) { + _, c, _ := newTestEventsService(t) + _, handled, err := c.PERFORM(TaskEmit{Name: ""}) + assert.True(t, handled) + assert.Error(t, err) +} + +func TestTaskOn_Bad_EmptyName(t *testing.T) { + _, c, _ := newTestEventsService(t) + _, handled, err := c.PERFORM(TaskOn{Name: ""}) + assert.True(t, handled) + assert.Error(t, err) +} + +func TestTaskOff_Bad_EmptyName(t *testing.T) { + _, c, _ := newTestEventsService(t) + _, handled, err := c.PERFORM(TaskOff{Name: ""}) + assert.True(t, handled) + assert.Error(t, err) +} + +func TestQueryListeners_Bad_NoService(t *testing.T) { + // No events service registered — query is not handled + c, err := core.New(core.WithServiceLock()) + require.NoError(t, err) + _, handled, _ := c.QUERY(QueryListeners{Name: "anything"}) + assert.False(t, handled) +} + +// --- Ugly tests --- + +func TestTaskEmit_Ugly_NilData(t *testing.T) { + _, c, mock := newTestEventsService(t) + _, handled, err := c.PERFORM(TaskEmit{Name: "null:event", Data: nil}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, 1, mock.emitCount()) +} + +func TestTaskOn_Ugly_MultipleListenersSameEvent(t *testing.T) { + _, c, mock := newTestEventsService(t) + + for i := 0; i < 5; i++ { + _, _, _ = c.PERFORM(TaskOn{Name: "flood"}) + } + + result, _, _ := c.QUERY(QueryListeners{Name: "flood"}) + assert.Equal(t, 5, result.(int)) + assert.Equal(t, 5, mock.listenerCount("flood")) +} + +func TestTaskOff_Ugly_NonExistentEvent(t *testing.T) { + // Off on unknown event name should not error + _, c, _ := newTestEventsService(t) + _, handled, err := c.PERFORM(TaskOff{Name: "never-registered"}) + require.NoError(t, err) + assert.True(t, handled) +} + +func TestTaskEmit_Ugly_ActionBroadcastOnEachEmit(t *testing.T) { + _, c, _ := newTestEventsService(t) + + var count int + c.RegisterAction(func(_ *core.Core, msg core.Message) error { + if _, ok := msg.(ActionEventFired); ok { + count++ + } + return nil + }) + + for i := 0; i < 3; i++ { + _, _, _ = c.PERFORM(TaskEmit{Name: "tick"}) + } + + assert.Equal(t, 3, count) +} diff --git a/pkg/keybinding/messages.go b/pkg/keybinding/messages.go index 1bfc2c5c..a9faa240 100644 --- a/pkg/keybinding/messages.go +++ b/pkg/keybinding/messages.go @@ -1,40 +1,41 @@ -// pkg/keybinding/messages.go package keybinding -import corego "dappco.re/go/core" +import coreerr "forge.lthn.ai/core/go-log" -// ErrAlreadyRegistered is returned when attempting to add a binding -// that already exists. Callers must TaskRemove first to rebind. -var ErrAlreadyRegistered = corego.NewError("keybinding: accelerator already registered") +// ErrorAlreadyRegistered is returned by TaskAdd when the accelerator is already bound. +var ErrorAlreadyRegistered = coreerr.NewError("keybinding: accelerator already registered") -// BindingInfo describes a registered keyboard shortcut. +// ErrorNotRegistered is returned by TaskRemove and TaskProcess when the accelerator is unknown. +var ErrorNotRegistered = coreerr.NewError("keybinding: accelerator not registered") + +// BindingInfo describes a registered global key binding. type BindingInfo struct { Accelerator string `json:"accelerator"` Description string `json:"description"` } -// --- Queries --- - -// QueryList returns all registered bindings. Result: []BindingInfo +// QueryList returns all registered key bindings. Result: []BindingInfo type QueryList struct{} -// --- Tasks --- - -// TaskAdd registers a new keyboard shortcut. Result: nil -// Returns ErrAlreadyRegistered if the accelerator is already bound. +// TaskAdd registers a global key binding. Error: ErrorAlreadyRegistered if accelerator taken. type TaskAdd struct { Accelerator string `json:"accelerator"` Description string `json:"description"` } -// TaskRemove unregisters a keyboard shortcut. Result: nil +// TaskRemove unregisters a global key binding by accelerator. type TaskRemove struct { Accelerator string `json:"accelerator"` } -// --- Actions --- +// TaskProcess programmatically triggers a registered key binding as if the user pressed it. +// Error: ErrorNotRegistered if the accelerator has not been registered. +// _, _, err := c.PERFORM(TaskProcess{Accelerator: "Ctrl+S"}) +type TaskProcess struct { + Accelerator string `json:"accelerator"` +} -// ActionTriggered is broadcast when a registered shortcut is activated. +// ActionTriggered is broadcast when a registered key binding fires. type ActionTriggered struct { Accelerator string `json:"accelerator"` } diff --git a/pkg/keybinding/platform.go b/pkg/keybinding/platform.go index 732ad202..9ce6e6d2 100644 --- a/pkg/keybinding/platform.go +++ b/pkg/keybinding/platform.go @@ -12,6 +12,11 @@ type Platform interface { // Remove unregisters a previously registered keyboard shortcut. Remove(accelerator string) error + // Process programmatically triggers the shortcut as if the user pressed it. + // Returns an error if the platform cannot trigger the shortcut. + // p.Process("Ctrl+S") + Process(accelerator string) error + // GetAll returns all currently registered accelerator strings. // Used for adapter-level reconciliation only — not read by QueryList. GetAll() []string diff --git a/pkg/keybinding/register.go b/pkg/keybinding/register.go index 417819e9..8e584841 100644 --- a/pkg/keybinding/register.go +++ b/pkg/keybinding/register.go @@ -1,16 +1,15 @@ -// pkg/keybinding/register.go package keybinding import "forge.lthn.ai/core/go/pkg/core" -// Register creates a factory closure that captures the Platform adapter. -// The returned function has the signature WithService requires: func(*Core) (any, error). +// Register(p) binds the keybinding service to a Core instance. +// core.WithService(keybinding.Register(wailsKeybinding)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ - ServiceRuntime: core.NewServiceRuntime[Options](c, Options{}), - platform: p, - bindings: make(map[string]BindingInfo), + ServiceRuntime: core.NewServiceRuntime[Options](c, Options{}), + platform: p, + registeredBindings: make(map[string]BindingInfo), }, nil } } diff --git a/pkg/keybinding/service.go b/pkg/keybinding/service.go index 44fb4d32..fb8d2578 100644 --- a/pkg/keybinding/service.go +++ b/pkg/keybinding/service.go @@ -4,30 +4,24 @@ package keybinding import ( "context" - corego "dappco.re/go/core" + coreerr "forge.lthn.ai/core/go-log" "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the keybinding service. type Options struct{} -// Service is a core.Service managing keyboard shortcuts via IPC. -// It maintains an in-memory registry of bindings and delegates -// platform-level registration to the Platform interface. type Service struct { *core.ServiceRuntime[Options] - platform Platform - bindings map[string]BindingInfo + platform Platform + registeredBindings map[string]BindingInfo } -// OnStartup registers IPC handlers. func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterQuery(s.handleQuery) s.Core().RegisterTask(s.handleTask) return nil } -// HandleIPCEvents is auto-discovered and registered by core.WithService. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -43,10 +37,9 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { } } -// queryList reads from the in-memory registry (not platform.GetAll()). func (s *Service) queryList() []BindingInfo { - result := make([]BindingInfo, 0, len(s.bindings)) - for _, info := range s.bindings { + result := make([]BindingInfo, 0, len(s.registeredBindings)) + for _, info := range s.registeredBindings { result = append(result, info) } return result @@ -60,14 +53,16 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { return nil, true, s.taskAdd(t) case TaskRemove: return nil, true, s.taskRemove(t) + case TaskProcess: + return nil, true, s.taskProcess(t) default: return nil, false, nil } } func (s *Service) taskAdd(t TaskAdd) error { - if _, exists := s.bindings[t.Accelerator]; exists { - return ErrAlreadyRegistered + if _, exists := s.registeredBindings[t.Accelerator]; exists { + return ErrorAlreadyRegistered } // Register on platform with a callback that broadcasts ActionTriggered @@ -75,10 +70,10 @@ func (s *Service) taskAdd(t TaskAdd) error { _ = s.Core().ACTION(ActionTriggered{Accelerator: t.Accelerator}) }) if err != nil { - return corego.Wrap(err, "keybinding.add", "platform add failed") + return coreerr.E("keybinding.taskAdd", "platform add failed", err) } - s.bindings[t.Accelerator] = BindingInfo{ + s.registeredBindings[t.Accelerator] = BindingInfo{ Accelerator: t.Accelerator, Description: t.Description, } @@ -86,15 +81,28 @@ func (s *Service) taskAdd(t TaskAdd) error { } func (s *Service) taskRemove(t TaskRemove) error { - if _, exists := s.bindings[t.Accelerator]; !exists { - return corego.E("keybinding.remove", corego.Sprintf("not registered: %s", t.Accelerator), nil) + if _, exists := s.registeredBindings[t.Accelerator]; !exists { + return ErrorNotRegistered } err := s.platform.Remove(t.Accelerator) if err != nil { - return corego.Wrap(err, "keybinding.remove", "platform remove failed") + return coreerr.E("keybinding.taskRemove", "platform remove failed", err) + } + + delete(s.registeredBindings, t.Accelerator) + return nil +} + +func (s *Service) taskProcess(t TaskProcess) error { + if _, exists := s.registeredBindings[t.Accelerator]; !exists { + return ErrorNotRegistered + } + + err := s.platform.Process(t.Accelerator) + if err != nil { + return coreerr.E("keybinding.taskProcess", "platform process failed", err) } - delete(s.bindings, t.Accelerator) return nil } diff --git a/pkg/keybinding/service_test.go b/pkg/keybinding/service_test.go index 14749f24..942a95af 100644 --- a/pkg/keybinding/service_test.go +++ b/pkg/keybinding/service_test.go @@ -11,11 +11,13 @@ import ( "github.com/stretchr/testify/require" ) -// mockPlatform records Add/Remove calls and allows triggering shortcuts. +// mockPlatform records Add/Remove/Process calls and allows triggering shortcuts. type mockPlatform struct { - mu sync.Mutex - handlers map[string]func() - removed []string + mu sync.Mutex + handlers map[string]func() + removed []string + processed []string + processErr error } func newMockPlatform() *mockPlatform { @@ -37,6 +39,16 @@ func (m *mockPlatform) Remove(accelerator string) error { return nil } +func (m *mockPlatform) Process(accelerator string) error { + m.mu.Lock() + defer m.mu.Unlock() + if m.processErr != nil { + return m.processErr + } + m.processed = append(m.processed, accelerator) + return nil +} + func (m *mockPlatform) GetAll() []string { m.mu.Lock() defer m.mu.Unlock() @@ -99,7 +111,7 @@ func TestTaskAdd_Bad_Duplicate(t *testing.T) { // Second add with same accelerator should fail _, handled, err := c.PERFORM(TaskAdd{Accelerator: "Ctrl+S", Description: "Save Again"}) assert.True(t, handled) - assert.ErrorIs(t, err, ErrAlreadyRegistered) + assert.ErrorIs(t, err, ErrorAlreadyRegistered) } func TestTaskRemove_Good(t *testing.T) { @@ -121,7 +133,7 @@ func TestTaskRemove_Bad_NotFound(t *testing.T) { _, handled, err := c.PERFORM(TaskRemove{Accelerator: "Ctrl+X"}) assert.True(t, handled) - assert.Error(t, err) + assert.ErrorIs(t, err, ErrorNotRegistered) } func TestQueryList_Good(t *testing.T) { @@ -199,3 +211,47 @@ func TestQueryList_Bad_NoService(t *testing.T) { _, handled, _ := c.QUERY(QueryList{}) assert.False(t, handled) } + +func TestTaskProcess_Good(t *testing.T) { + mp := newMockPlatform() + _, c := newTestKeybindingService(t, mp) + + _, _, _ = c.PERFORM(TaskAdd{Accelerator: "Ctrl+P", Description: "Print"}) + + _, handled, err := c.PERFORM(TaskProcess{Accelerator: "Ctrl+P"}) + require.NoError(t, err) + assert.True(t, handled) + assert.Contains(t, mp.processed, "Ctrl+P") +} + +func TestTaskProcess_Bad_NotRegistered(t *testing.T) { + mp := newMockPlatform() + _, c := newTestKeybindingService(t, mp) + + _, handled, err := c.PERFORM(TaskProcess{Accelerator: "Ctrl+Z"}) + assert.True(t, handled) + assert.ErrorIs(t, err, ErrorNotRegistered) +} + +func TestTaskProcess_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskProcess{}) + assert.False(t, handled) +} + +func TestTaskProcess_Bad_PlatformError(t *testing.T) { + mp := newMockPlatform() + mp.processErr = assert.AnError + _, c := newTestKeybindingService(t, mp) + + _, _, _ = c.PERFORM(TaskAdd{Accelerator: "Ctrl+P", Description: "Print"}) + _, handled, err := c.PERFORM(TaskProcess{Accelerator: "Ctrl+P"}) + assert.True(t, handled) + assert.Error(t, err) +} + +func TestErrorNotRegistered_Ugly(t *testing.T) { + // ErrorNotRegistered and ErrorAlreadyRegistered must be distinct sentinels. + assert.NotEqual(t, ErrorNotRegistered, ErrorAlreadyRegistered) + assert.NotErrorIs(t, ErrorNotRegistered, ErrorAlreadyRegistered) +} diff --git a/pkg/lifecycle/register.go b/pkg/lifecycle/register.go index 90e5d404..55031e01 100644 --- a/pkg/lifecycle/register.go +++ b/pkg/lifecycle/register.go @@ -1,10 +1,9 @@ -// pkg/lifecycle/register.go package lifecycle import "forge.lthn.ai/core/go/pkg/core" -// Register creates a factory closure that captures the Platform adapter. -// The returned function has the signature WithService requires: func(*Core) (any, error). +// Register(p) binds the lifecycle service to a Core instance. +// core.WithService(lifecycle.Register(wailsLifecycle)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ diff --git a/pkg/lifecycle/service.go b/pkg/lifecycle/service.go index 41e7ca88..3ba42551 100644 --- a/pkg/lifecycle/service.go +++ b/pkg/lifecycle/service.go @@ -1,4 +1,3 @@ -// pkg/lifecycle/service.go package lifecycle import ( @@ -7,22 +6,15 @@ import ( "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the lifecycle service. type Options struct{} -// Service is a core.Service that registers platform lifecycle callbacks -// and broadcasts corresponding IPC Actions. It implements both Startable -// and Stoppable: OnStartup registers all callbacks, OnShutdown cancels them. type Service struct { *core.ServiceRuntime[Options] platform Platform cancels []func() } -// OnStartup registers a platform callback for each EventType and for file-open. -// Each callback broadcasts the corresponding Action via s.Core().ACTION(). func (s *Service) OnStartup(ctx context.Context) error { - // Register fire-and-forget event callbacks eventActions := map[EventType]func(){ EventApplicationStarted: func() { _ = s.Core().ACTION(ActionApplicationStarted{}) }, EventWillTerminate: func() { _ = s.Core().ACTION(ActionWillTerminate{}) }, @@ -38,7 +30,6 @@ func (s *Service) OnStartup(ctx context.Context) error { s.cancels = append(s.cancels, cancel) } - // Register file-open callback (carries data) cancel := s.platform.OnOpenedWithFile(func(path string) { _ = s.Core().ACTION(ActionOpenedWithFile{Path: path}) }) @@ -47,7 +38,6 @@ func (s *Service) OnStartup(ctx context.Context) error { return nil } -// OnShutdown cancels all registered platform callbacks. func (s *Service) OnShutdown(ctx context.Context) error { for _, cancel := range s.cancels { cancel() @@ -56,8 +46,6 @@ func (s *Service) OnShutdown(ctx context.Context) error { return nil } -// HandleIPCEvents is auto-discovered and registered by core.WithService. -// Lifecycle events are all outbound (platform -> IPC) so there is nothing to handle here. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } diff --git a/pkg/mcp/layout_helpers.go b/pkg/mcp/layout_helpers.go new file mode 100644 index 00000000..b19fdb4c --- /dev/null +++ b/pkg/mcp/layout_helpers.go @@ -0,0 +1,195 @@ +package mcp + +import ( + "sort" + + "forge.lthn.ai/core/go/pkg/core" + "forge.lthn.ai/core/gui/pkg/screen" + "forge.lthn.ai/core/gui/pkg/window" +) + +func (s *Subsystem) allWindows() ([]window.WindowInfo, error) { + result, _, err := s.core.QUERY(window.QueryWindowList{}) + if err != nil { + return nil, err + } + windows, _ := result.([]window.WindowInfo) + return windows, nil +} + +func (s *Subsystem) allScreens() ([]screen.Screen, error) { + result, _, err := s.core.QUERY(screen.QueryAll{}) + if err != nil { + return nil, err + } + screens, _ := result.([]screen.Screen) + return screens, nil +} + +func (s *Subsystem) primaryScreen() (*screen.Screen, error) { + result, _, err := s.core.QUERY(screen.QueryPrimary{}) + if err != nil { + return nil, err + } + scr, _ := result.(*screen.Screen) + return scr, nil +} + +func (s *Subsystem) screenByID(id string) (*screen.Screen, error) { + if id == "" { + return nil, nil + } + result, _, err := s.core.QUERY(screen.QueryByID{ID: id}) + if err != nil { + return nil, err + } + scr, _ := result.(*screen.Screen) + return scr, nil +} + +func screenForWindowInfo(screens []screen.Screen, info window.WindowInfo) *screen.Screen { + cx := info.X + info.Width/2 + cy := info.Y + info.Height/2 + for i := range screens { + if screens[i].Bounds.Contains(cx, cy) { + return &screens[i] + } + } + return nil +} + +func chooseScreenByIDOrPrimary(screens []screen.Screen, screenID string) *screen.Screen { + if screenID != "" { + for i := range screens { + if screens[i].ID == screenID { + return &screens[i] + } + } + } + for i := range screens { + if screens[i].IsPrimary { + return &screens[i] + } + } + if len(screens) == 0 { + return nil + } + return &screens[0] +} + +func workAreaRect(scr *screen.Screen) screen.Rect { + if scr == nil { + return screen.Rect{} + } + if scr.WorkArea.Width > 0 && scr.WorkArea.Height > 0 { + return scr.WorkArea + } + return scr.Bounds +} + +func uniqueSorted(values []int) []int { + sort.Ints(values) + if len(values) == 0 { + return values + } + out := values[:1] + for _, value := range values[1:] { + if value != out[len(out)-1] { + out = append(out, value) + } + } + return out +} + +func clipRectToWorkArea(rect, workArea screen.Rect) (screen.Rect, bool) { + x1 := max(rect.X, workArea.X) + y1 := max(rect.Y, workArea.Y) + x2 := min(rect.X+rect.Width, workArea.X+workArea.Width) + y2 := min(rect.Y+rect.Height, workArea.Y+workArea.Height) + if x2 <= x1 || y2 <= y1 { + return screen.Rect{}, false + } + return screen.Rect{X: x1, Y: y1, Width: x2 - x1, Height: y2 - y1}, true +} + +func findLargestFreeRect(workArea screen.Rect, occupied []screen.Rect, minWidth, minHeight int) (screen.Rect, bool) { + xs := []int{workArea.X, workArea.X + workArea.Width} + ys := []int{workArea.Y, workArea.Y + workArea.Height} + + for _, rect := range occupied { + clipped, ok := clipRectToWorkArea(rect, workArea) + if !ok { + continue + } + xs = append(xs, clipped.X, clipped.X+clipped.Width) + ys = append(ys, clipped.Y, clipped.Y+clipped.Height) + } + + xs = uniqueSorted(xs) + ys = uniqueSorted(ys) + + bestArea := -1 + best := screen.Rect{} + + for xi := 0; xi < len(xs)-1; xi++ { + for xj := xi + 1; xj < len(xs); xj++ { + width := xs[xj] - xs[xi] + if width < minWidth { + continue + } + for yi := 0; yi < len(ys)-1; yi++ { + for yj := yi + 1; yj < len(ys); yj++ { + height := ys[yj] - ys[yi] + if height < minHeight { + continue + } + candidate := screen.Rect{X: xs[xi], Y: ys[yi], Width: width, Height: height} + if candidate.X < workArea.X || candidate.Y < workArea.Y || + candidate.X+candidate.Width > workArea.X+workArea.Width || + candidate.Y+candidate.Height > workArea.Y+workArea.Height { + continue + } + overlaps := false + for _, occ := range occupied { + if candidate.Overlaps(occ) { + overlaps = true + break + } + } + if overlaps { + continue + } + area := candidate.Width * candidate.Height + if area > bestArea || (area == bestArea && (candidate.Y < best.Y || (candidate.Y == best.Y && candidate.X < best.X))) { + bestArea = area + best = candidate + } + } + } + } + } + + return best, bestArea >= 0 +} + +func applyRect(c *core.Core, windowName string, rect screen.Rect) error { + if _, _, err := c.PERFORM(window.TaskSetPosition{Name: windowName, X: rect.X, Y: rect.Y}); err != nil { + return err + } + _, _, err := c.PERFORM(window.TaskSetSize{Name: windowName, Width: rect.Width, Height: rect.Height}) + return err +} + +func min(a, b int) int { + if a < b { + return a + } + return b +} + +func max(a, b int) int { + if a > b { + return a + } + return b +} diff --git a/pkg/mcp/mcp_test.go b/pkg/mcp/mcp_test.go index 5862d188..801167b1 100644 --- a/pkg/mcp/mcp_test.go +++ b/pkg/mcp/mcp_test.go @@ -6,13 +6,10 @@ import ( "testing" "forge.lthn.ai/core/go/pkg/core" - "dappco.re/go/core/gui/pkg/clipboard" - "dappco.re/go/core/gui/pkg/display" - "dappco.re/go/core/gui/pkg/environment" - "dappco.re/go/core/gui/pkg/notification" - "dappco.re/go/core/gui/pkg/screen" - "dappco.re/go/core/gui/pkg/webview" - "dappco.re/go/core/gui/pkg/window" + "forge.lthn.ai/core/gui/pkg/clipboard" + "forge.lthn.ai/core/gui/pkg/environment" + "forge.lthn.ai/core/gui/pkg/screen" + "forge.lthn.ai/core/gui/pkg/window" "github.com/modelcontextprotocol/go-sdk/mcp" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -20,13 +17,13 @@ import ( func TestSubsystem_Good_Name(t *testing.T) { c, _ := core.New(core.WithServiceLock()) - sub := New(c) + sub := NewSubsystem(c) assert.Equal(t, "display", sub.Name()) } func TestSubsystem_Good_RegisterTools(t *testing.T) { c, _ := core.New(core.WithServiceLock()) - sub := New(c) + sub := NewSubsystem(c) // RegisterTools should not panic with a real mcp.Server server := mcp.NewServer(&mcp.Implementation{Name: "test", Version: "0.1.0"}, nil) assert.NotPanics(t, func() { sub.RegisterTools(server) }) @@ -35,61 +32,19 @@ func TestSubsystem_Good_RegisterTools(t *testing.T) { // Integration test: verify the IPC round-trip that MCP tool handlers use. type mockClipPlatform struct { - text string - ok bool + text string + ok bool + image []byte + hasImage bool } func (m *mockClipPlatform) Text() (string, bool) { return m.text, m.ok } func (m *mockClipPlatform) SetText(t string) bool { m.text = t; m.ok = t != ""; return true } - -type mockNotificationPlatform struct { - sendCalled bool - lastOpts notification.NotificationOptions -} - -func (m *mockNotificationPlatform) Send(opts notification.NotificationOptions) error { - m.sendCalled = true - m.lastOpts = opts - return nil -} -func (m *mockNotificationPlatform) RequestPermission() (bool, error) { return true, nil } -func (m *mockNotificationPlatform) CheckPermission() (bool, error) { return true, nil } - -type mockEnvironmentPlatform struct { - isDark bool -} - -func (m *mockEnvironmentPlatform) IsDarkMode() bool { return m.isDark } -func (m *mockEnvironmentPlatform) Info() environment.EnvironmentInfo { - return environment.EnvironmentInfo{} -} -func (m *mockEnvironmentPlatform) AccentColour() string { return "" } -func (m *mockEnvironmentPlatform) OpenFileManager(path string, selectFile bool) error { - return nil -} -func (m *mockEnvironmentPlatform) OnThemeChange(handler func(isDark bool)) func() { - return func() {} -} -func (m *mockEnvironmentPlatform) SetTheme(isDark bool) error { - m.isDark = isDark - return nil -} - -type mockScreenPlatform struct { - screens []screen.Screen -} - -func (m *mockScreenPlatform) GetAll() []screen.Screen { return m.screens } -func (m *mockScreenPlatform) GetPrimary() *screen.Screen { - for i := range m.screens { - if m.screens[i].IsPrimary { - return &m.screens[i] - } - } - if len(m.screens) == 0 { - return nil - } - return &m.screens[0] +func (m *mockClipPlatform) Image() ([]byte, bool) { return m.image, m.hasImage } +func (m *mockClipPlatform) SetImage(data []byte) bool { + m.image = append([]byte(nil), data...) + m.hasImage = len(data) > 0 + return true } func TestMCP_Good_ClipboardRoundTrip(t *testing.T) { @@ -280,3 +235,87 @@ func TestMCP_Bad_NoServices(t *testing.T) { _, handled, _ := c.QUERY(clipboard.QueryText{}) assert.False(t, handled) } + +type mockEnvPlatform struct { + isDark bool +} + +func (m *mockEnvPlatform) IsDarkMode() bool { return m.isDark } +func (m *mockEnvPlatform) Info() environment.EnvironmentInfo { return environment.EnvironmentInfo{} } +func (m *mockEnvPlatform) AccentColour() string { return "" } +func (m *mockEnvPlatform) OpenFileManager(path string, selectFile bool) error { return nil } +func (m *mockEnvPlatform) HasFocusFollowsMouse() bool { return false } +func (m *mockEnvPlatform) OnThemeChange(handler func(isDark bool)) func() { + return func() {} +} + +type mockScreenPlatform struct { + screens []screen.Screen +} + +func (m *mockScreenPlatform) GetAll() []screen.Screen { return m.screens } +func (m *mockScreenPlatform) GetPrimary() *screen.Screen { + for i := range m.screens { + if m.screens[i].IsPrimary { + return &m.screens[i] + } + } + return nil +} +func (m *mockScreenPlatform) GetCurrent() *screen.Screen { return m.GetPrimary() } + +func TestMCP_Good_ThemeSetRoundTrip(t *testing.T) { + c, err := core.New( + core.WithService(environment.Register(&mockEnvPlatform{isDark: true})), + core.WithServiceLock(), + ) + require.NoError(t, err) + require.NoError(t, c.ServiceStartup(context.Background(), nil)) + + sub := NewSubsystem(c) + _, output, err := sub.themeSet(context.Background(), nil, ThemeSetInput{Theme: "light"}) + require.NoError(t, err) + assert.True(t, output.Success) + + result, handled, err := c.QUERY(environment.QueryTheme{}) + require.NoError(t, err) + assert.True(t, handled) + theme := result.(environment.ThemeInfo) + assert.Equal(t, "light", theme.Theme) + assert.False(t, theme.IsDark) +} + +func TestMCP_Good_ScreenFindSpaceAndArrangePair(t *testing.T) { + c, err := core.New( + core.WithService(screen.Register(&mockScreenPlatform{screens: []screen.Screen{ + { + ID: "1", Name: "Primary", IsPrimary: true, + Bounds: screen.Rect{X: 0, Y: 0, Width: 1600, Height: 900}, + WorkArea: screen.Rect{X: 0, Y: 0, Width: 1600, Height: 900}, + }, + }})), + core.WithService(window.Register(window.NewMockPlatform())), + core.WithServiceLock(), + ) + require.NoError(t, err) + require.NoError(t, c.ServiceStartup(context.Background(), nil)) + + _, _, err = c.PERFORM(window.TaskOpenWindow{Window: &window.Window{Name: "editor", X: 0, Y: 0, Width: 800, Height: 900}}) + require.NoError(t, err) + _, _, err = c.PERFORM(window.TaskOpenWindow{Window: &window.Window{Name: "preview", X: 800, Y: 0, Width: 800, Height: 450}}) + require.NoError(t, err) + + sub := NewSubsystem(c) + + _, free, err := sub.screenFindSpace(context.Background(), nil, ScreenFindSpaceInput{Width: 300, Height: 300}) + require.NoError(t, err) + assert.Equal(t, "1", free.ScreenID) + assert.Equal(t, screen.Rect{X: 800, Y: 450, Width: 800, Height: 450}, free.Bounds) + + _, arranged, err := sub.windowArrangePair(context.Background(), nil, WindowArrangePairInput{ + First: "editor", Second: "preview", + }) + require.NoError(t, err) + assert.Equal(t, screen.Rect{X: 0, Y: 0, Width: 800, Height: 900}, arranged.FirstBounds) + assert.Equal(t, screen.Rect{X: 800, Y: 0, Width: 800, Height: 900}, arranged.SecondBounds) +} diff --git a/pkg/mcp/subsystem.go b/pkg/mcp/subsystem.go index b567d1bf..1f51f84e 100644 --- a/pkg/mcp/subsystem.go +++ b/pkg/mcp/subsystem.go @@ -6,21 +6,24 @@ import ( "github.com/modelcontextprotocol/go-sdk/mcp" ) -// Subsystem implements the MCP Subsystem interface via structural typing. -// It registers GUI tools that translate MCP tool calls to IPC messages. +// Subsystem translates MCP tool calls to Core IPC messages for GUI operations. type Subsystem struct { core *core.Core } -// New creates a display MCP subsystem backed by the given Core instance. -func New(c *core.Core) *Subsystem { +// NewSubsystem creates the display MCP bridge for a Core instance. +// sub := mcp.NewSubsystem(c); sub.RegisterTools(server) +func NewSubsystem(c *core.Core) *Subsystem { return &Subsystem{core: c} } -// Name returns the subsystem identifier. +// Deprecated: use NewSubsystem(c). +func New(c *core.Core) *Subsystem { + return NewSubsystem(c) +} + func (s *Subsystem) Name() string { return "display" } -// RegisterTools registers all GUI tools with the MCP server. func (s *Subsystem) RegisterTools(server *mcp.Server) { s.registerWebviewTools(server) s.registerWindowTools(server) @@ -36,4 +39,5 @@ func (s *Subsystem) RegisterTools(server *mcp.Server) { s.registerKeybindingTools(server) s.registerDockTools(server) s.registerLifecycleTools(server) + s.registerEventTools(server) } diff --git a/pkg/mcp/tools_clipboard.go b/pkg/mcp/tools_clipboard.go index f5732bbf..3af897b8 100644 --- a/pkg/mcp/tools_clipboard.go +++ b/pkg/mcp/tools_clipboard.go @@ -3,9 +3,10 @@ package mcp import ( "context" + "encoding/base64" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/clipboard" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/clipboard" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -23,7 +24,7 @@ func (s *Subsystem) clipboardRead(_ context.Context, _ *mcp.CallToolRequest, _ C } content, ok := result.(clipboard.ClipboardContent) if !ok { - return nil, ClipboardReadOutput{}, corego.E("mcp.clipboard", "unexpected result type from clipboard read query", nil) + return nil, ClipboardReadOutput{}, coreerr.E("mcp.clipboardRead", "unexpected result type", nil) } return nil, ClipboardReadOutput{Content: content.Text}, nil } @@ -44,7 +45,7 @@ func (s *Subsystem) clipboardWrite(_ context.Context, _ *mcp.CallToolRequest, in } success, ok := result.(bool) if !ok { - return nil, ClipboardWriteOutput{}, corego.E("mcp.clipboard", "unexpected result type from clipboard write task", nil) + return nil, ClipboardWriteOutput{}, coreerr.E("mcp.clipboardWrite", "unexpected result type", nil) } return nil, ClipboardWriteOutput{Success: success}, nil } @@ -63,7 +64,7 @@ func (s *Subsystem) clipboardHas(_ context.Context, _ *mcp.CallToolRequest, _ Cl } content, ok := result.(clipboard.ClipboardContent) if !ok { - return nil, ClipboardHasOutput{}, corego.E("mcp.clipboard", "unexpected result type from clipboard has query", nil) + return nil, ClipboardHasOutput{}, coreerr.E("mcp.clipboardHas", "unexpected result type", nil) } return nil, ClipboardHasOutput{HasContent: content.HasContent}, nil } @@ -82,7 +83,7 @@ func (s *Subsystem) clipboardClear(_ context.Context, _ *mcp.CallToolRequest, _ } success, ok := result.(bool) if !ok { - return nil, ClipboardClearOutput{}, corego.E("mcp.clipboard", "unexpected result type from clipboard clear task", nil) + return nil, ClipboardClearOutput{}, coreerr.E("mcp.clipboardClear", "unexpected result type", nil) } return nil, ClipboardClearOutput{Success: success}, nil } @@ -91,7 +92,7 @@ func (s *Subsystem) clipboardClear(_ context.Context, _ *mcp.CallToolRequest, _ type ClipboardReadImageInput struct{} type ClipboardReadImageOutput struct { - Image clipboard.ClipboardImageContent `json:"image"` + Base64 string `json:"base64"` } func (s *Subsystem) clipboardReadImage(_ context.Context, _ *mcp.CallToolRequest, _ ClipboardReadImageInput) (*mcp.CallToolResult, ClipboardReadImageOutput, error) { @@ -99,28 +100,39 @@ func (s *Subsystem) clipboardReadImage(_ context.Context, _ *mcp.CallToolRequest if err != nil { return nil, ClipboardReadImageOutput{}, err } - image, ok := result.(clipboard.ClipboardImageContent) + content, ok := result.(clipboard.ImageContent) if !ok { - return nil, ClipboardReadImageOutput{}, corego.E("mcp.clipboard", "unexpected result type from clipboard image query", nil) + return nil, ClipboardReadImageOutput{}, coreerr.E("mcp.clipboardReadImage", "unexpected result type", nil) } - return nil, ClipboardReadImageOutput{Image: image}, nil + if !content.HasImage { + return nil, ClipboardReadImageOutput{}, nil + } + return nil, ClipboardReadImageOutput{Base64: base64.StdEncoding.EncodeToString(content.Data)}, nil } // --- clipboard_write_image --- type ClipboardWriteImageInput struct { - Data []byte `json:"data"` + Base64 string `json:"base64"` } type ClipboardWriteImageOutput struct { Success bool `json:"success"` } func (s *Subsystem) clipboardWriteImage(_ context.Context, _ *mcp.CallToolRequest, input ClipboardWriteImageInput) (*mcp.CallToolResult, ClipboardWriteImageOutput, error) { - _, _, err := s.core.PERFORM(clipboard.TaskSetImage{Data: input.Data}) + data, err := base64.StdEncoding.DecodeString(input.Base64) if err != nil { return nil, ClipboardWriteImageOutput{}, err } - return nil, ClipboardWriteImageOutput{Success: true}, nil + result, _, err := s.core.PERFORM(clipboard.TaskSetImage{Data: data}) + if err != nil { + return nil, ClipboardWriteImageOutput{}, err + } + success, ok := result.(bool) + if !ok { + return nil, ClipboardWriteImageOutput{}, coreerr.E("mcp.clipboardWriteImage", "unexpected result type", nil) + } + return nil, ClipboardWriteImageOutput{Success: success}, nil } // --- Registration --- @@ -129,6 +141,8 @@ func (s *Subsystem) registerClipboardTools(server *mcp.Server) { mcp.AddTool(server, &mcp.Tool{Name: "clipboard_read", Description: "Read the current clipboard content"}, s.clipboardRead) mcp.AddTool(server, &mcp.Tool{Name: "clipboard_write", Description: "Write text to the clipboard"}, s.clipboardWrite) mcp.AddTool(server, &mcp.Tool{Name: "clipboard_has", Description: "Check if the clipboard has content"}, s.clipboardHas) + mcp.AddTool(server, &mcp.Tool{Name: "clipboard_read_image", Description: "Read image data from the clipboard as base64"}, s.clipboardReadImage) + mcp.AddTool(server, &mcp.Tool{Name: "clipboard_write_image", Description: "Write base64 image data to the clipboard"}, s.clipboardWriteImage) mcp.AddTool(server, &mcp.Tool{Name: "clipboard_clear", Description: "Clear the clipboard"}, s.clipboardClear) mcp.AddTool(server, &mcp.Tool{Name: "clipboard_read_image", Description: "Read an image from the clipboard"}, s.clipboardReadImage) mcp.AddTool(server, &mcp.Tool{Name: "clipboard_write_image", Description: "Write an image to the clipboard"}, s.clipboardWriteImage) diff --git a/pkg/mcp/tools_contextmenu.go b/pkg/mcp/tools_contextmenu.go index c1112459..d6da3a57 100644 --- a/pkg/mcp/tools_contextmenu.go +++ b/pkg/mcp/tools_contextmenu.go @@ -3,9 +3,10 @@ package mcp import ( "context" + "encoding/json" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/contextmenu" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/contextmenu" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -24,13 +25,13 @@ type ContextMenuAddOutput struct { func (s *Subsystem) contextMenuAdd(_ context.Context, _ *mcp.CallToolRequest, input ContextMenuAddInput) (*mcp.CallToolResult, ContextMenuAddOutput, error) { // Convert map[string]any to ContextMenuDef via JSON round-trip - r := corego.JSONMarshal(input.Menu) - if !r.OK { - return nil, ContextMenuAddOutput{}, corego.Wrap(r.Value.(error), "mcp.contextmenu", "failed to marshal menu definition") + menuJSON, err := json.Marshal(input.Menu) + if err != nil { + return nil, ContextMenuAddOutput{}, coreerr.E("mcp.contextMenuAdd", "failed to marshal menu definition", err) } var menuDef contextmenu.ContextMenuDef - if r2 := corego.JSONUnmarshal(r.Value.([]byte), &menuDef); !r2.OK { - return nil, ContextMenuAddOutput{}, corego.Wrap(r2.Value.(error), "mcp.contextmenu", "failed to unmarshal menu definition") + if err := json.Unmarshal(menuJSON, &menuDef); err != nil { + return nil, ContextMenuAddOutput{}, coreerr.E("mcp.contextMenuAdd", "failed to unmarshal menu definition", err) } _, _, err = s.core.PERFORM(contextmenu.TaskAdd{Name: input.Name, Menu: menuDef}) if err != nil { @@ -72,19 +73,19 @@ func (s *Subsystem) contextMenuGet(_ context.Context, _ *mcp.CallToolRequest, in } menu, ok := result.(*contextmenu.ContextMenuDef) if !ok { - return nil, ContextMenuGetOutput{}, corego.E("mcp.contextmenu", "unexpected result type from context menu get query", nil) + return nil, ContextMenuGetOutput{}, coreerr.E("mcp.contextMenuGet", "unexpected result type", nil) } if menu == nil { return nil, ContextMenuGetOutput{}, nil } // Convert to map[string]any via JSON round-trip to avoid cyclic type in schema - r := corego.JSONMarshal(menu) - if !r.OK { - return nil, ContextMenuGetOutput{}, corego.Wrap(r.Value.(error), "mcp.contextmenu", "failed to marshal context menu") + menuJSON, err := json.Marshal(menu) + if err != nil { + return nil, ContextMenuGetOutput{}, coreerr.E("mcp.contextMenuGet", "failed to marshal context menu", err) } var menuMap map[string]any - if r2 := corego.JSONUnmarshal(r.Value.([]byte), &menuMap); !r2.OK { - return nil, ContextMenuGetOutput{}, corego.Wrap(r2.Value.(error), "mcp.contextmenu", "failed to unmarshal context menu") + if err := json.Unmarshal(menuJSON, &menuMap); err != nil { + return nil, ContextMenuGetOutput{}, coreerr.E("mcp.contextMenuGet", "failed to unmarshal context menu", err) } return nil, ContextMenuGetOutput{Menu: menuMap}, nil } @@ -103,16 +104,16 @@ func (s *Subsystem) contextMenuList(_ context.Context, _ *mcp.CallToolRequest, _ } menus, ok := result.(map[string]contextmenu.ContextMenuDef) if !ok { - return nil, ContextMenuListOutput{}, corego.E("mcp.contextmenu", "unexpected result type from context menu list query", nil) + return nil, ContextMenuListOutput{}, coreerr.E("mcp.contextMenuList", "unexpected result type", nil) } // Convert to map[string]any via JSON round-trip to avoid cyclic type in schema - r := corego.JSONMarshal(menus) - if !r.OK { - return nil, ContextMenuListOutput{}, corego.Wrap(r.Value.(error), "mcp.contextmenu", "failed to marshal context menus") + menusJSON, err := json.Marshal(menus) + if err != nil { + return nil, ContextMenuListOutput{}, coreerr.E("mcp.contextMenuList", "failed to marshal context menus", err) } var menusMap map[string]any - if r2 := corego.JSONUnmarshal(r.Value.([]byte), &menusMap); !r2.OK { - return nil, ContextMenuListOutput{}, corego.Wrap(r2.Value.(error), "mcp.contextmenu", "failed to unmarshal context menus") + if err := json.Unmarshal(menusJSON, &menusMap); err != nil { + return nil, ContextMenuListOutput{}, coreerr.E("mcp.contextMenuList", "failed to unmarshal context menus", err) } return nil, ContextMenuListOutput{Menus: menusMap}, nil } diff --git a/pkg/mcp/tools_dialog.go b/pkg/mcp/tools_dialog.go index a4d80b39..ff601940 100644 --- a/pkg/mcp/tools_dialog.go +++ b/pkg/mcp/tools_dialog.go @@ -4,8 +4,8 @@ package mcp import ( "context" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/dialog" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/dialog" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -22,7 +22,7 @@ type DialogOpenFileOutput struct { } func (s *Subsystem) dialogOpenFile(_ context.Context, _ *mcp.CallToolRequest, input DialogOpenFileInput) (*mcp.CallToolResult, DialogOpenFileOutput, error) { - result, _, err := s.core.PERFORM(dialog.TaskOpenFile{Opts: dialog.OpenFileOptions{ + result, _, err := s.core.PERFORM(dialog.TaskOpenFile{Options: dialog.OpenFileOptions{ Title: input.Title, Directory: input.Directory, Filters: input.Filters, @@ -33,7 +33,7 @@ func (s *Subsystem) dialogOpenFile(_ context.Context, _ *mcp.CallToolRequest, in } paths, ok := result.([]string) if !ok { - return nil, DialogOpenFileOutput{}, corego.E("mcp.dialog", "unexpected result type from open file dialog", nil) + return nil, DialogOpenFileOutput{}, coreerr.E("mcp.dialogOpenFile", "unexpected result type", nil) } return nil, DialogOpenFileOutput{Paths: paths}, nil } @@ -51,7 +51,7 @@ type DialogSaveFileOutput struct { } func (s *Subsystem) dialogSaveFile(_ context.Context, _ *mcp.CallToolRequest, input DialogSaveFileInput) (*mcp.CallToolResult, DialogSaveFileOutput, error) { - result, _, err := s.core.PERFORM(dialog.TaskSaveFile{Opts: dialog.SaveFileOptions{ + result, _, err := s.core.PERFORM(dialog.TaskSaveFile{Options: dialog.SaveFileOptions{ Title: input.Title, Directory: input.Directory, Filename: input.Filename, @@ -62,7 +62,7 @@ func (s *Subsystem) dialogSaveFile(_ context.Context, _ *mcp.CallToolRequest, in } path, ok := result.(string) if !ok { - return nil, DialogSaveFileOutput{}, corego.E("mcp.dialog", "unexpected result type from save file dialog", nil) + return nil, DialogSaveFileOutput{}, coreerr.E("mcp.dialogSaveFile", "unexpected result type", nil) } return nil, DialogSaveFileOutput{Path: path}, nil } @@ -78,7 +78,7 @@ type DialogOpenDirectoryOutput struct { } func (s *Subsystem) dialogOpenDirectory(_ context.Context, _ *mcp.CallToolRequest, input DialogOpenDirectoryInput) (*mcp.CallToolResult, DialogOpenDirectoryOutput, error) { - result, _, err := s.core.PERFORM(dialog.TaskOpenDirectory{Opts: dialog.OpenDirectoryOptions{ + result, _, err := s.core.PERFORM(dialog.TaskOpenDirectory{Options: dialog.OpenDirectoryOptions{ Title: input.Title, Directory: input.Directory, }}) @@ -87,11 +87,40 @@ func (s *Subsystem) dialogOpenDirectory(_ context.Context, _ *mcp.CallToolReques } path, ok := result.(string) if !ok { - return nil, DialogOpenDirectoryOutput{}, corego.E("mcp.dialog", "unexpected result type from open directory dialog", nil) + return nil, DialogOpenDirectoryOutput{}, coreerr.E("mcp.dialogOpenDirectory", "unexpected result type", nil) } return nil, DialogOpenDirectoryOutput{Path: path}, nil } +// --- dialog_message --- + +type DialogMessageInput struct { + Type dialog.DialogType `json:"type"` + Title string `json:"title"` + Message string `json:"message"` + Buttons []string `json:"buttons,omitempty"` +} +type DialogMessageOutput struct { + Button string `json:"button"` +} + +func (s *Subsystem) dialogMessage(_ context.Context, _ *mcp.CallToolRequest, input DialogMessageInput) (*mcp.CallToolResult, DialogMessageOutput, error) { + result, _, err := s.core.PERFORM(dialog.TaskMessageDialog{Options: dialog.MessageDialogOptions{ + Type: input.Type, + Title: input.Title, + Message: input.Message, + Buttons: input.Buttons, + }}) + if err != nil { + return nil, DialogMessageOutput{}, err + } + button, ok := result.(string) + if !ok { + return nil, DialogMessageOutput{}, coreerr.E("mcp.dialogMessage", "unexpected result type", nil) + } + return nil, DialogMessageOutput{Button: button}, nil +} + // --- dialog_confirm --- type DialogConfirmInput struct { @@ -104,7 +133,7 @@ type DialogConfirmOutput struct { } func (s *Subsystem) dialogConfirm(_ context.Context, _ *mcp.CallToolRequest, input DialogConfirmInput) (*mcp.CallToolResult, DialogConfirmOutput, error) { - result, _, err := s.core.PERFORM(dialog.TaskMessageDialog{Opts: dialog.MessageDialogOptions{ + result, _, err := s.core.PERFORM(dialog.TaskMessageDialog{Options: dialog.MessageDialogOptions{ Type: dialog.DialogQuestion, Title: input.Title, Message: input.Message, @@ -115,7 +144,7 @@ func (s *Subsystem) dialogConfirm(_ context.Context, _ *mcp.CallToolRequest, inp } button, ok := result.(string) if !ok { - return nil, DialogConfirmOutput{}, corego.E("mcp.dialog", "unexpected result type from confirm dialog", nil) + return nil, DialogConfirmOutput{}, coreerr.E("mcp.dialogConfirm", "unexpected result type", nil) } return nil, DialogConfirmOutput{Button: button}, nil } @@ -131,7 +160,7 @@ type DialogPromptOutput struct { } func (s *Subsystem) dialogPrompt(_ context.Context, _ *mcp.CallToolRequest, input DialogPromptInput) (*mcp.CallToolResult, DialogPromptOutput, error) { - result, _, err := s.core.PERFORM(dialog.TaskMessageDialog{Opts: dialog.MessageDialogOptions{ + result, _, err := s.core.PERFORM(dialog.TaskMessageDialog{Options: dialog.MessageDialogOptions{ Type: dialog.DialogInfo, Title: input.Title, Message: input.Message, @@ -142,7 +171,7 @@ func (s *Subsystem) dialogPrompt(_ context.Context, _ *mcp.CallToolRequest, inpu } button, ok := result.(string) if !ok { - return nil, DialogPromptOutput{}, corego.E("mcp.dialog", "unexpected result type from prompt dialog", nil) + return nil, DialogPromptOutput{}, coreerr.E("mcp.dialogPrompt", "unexpected result type", nil) } return nil, DialogPromptOutput{Button: button}, nil } @@ -153,6 +182,7 @@ func (s *Subsystem) registerDialogTools(server *mcp.Server) { mcp.AddTool(server, &mcp.Tool{Name: "dialog_open_file", Description: "Show an open file dialog"}, s.dialogOpenFile) mcp.AddTool(server, &mcp.Tool{Name: "dialog_save_file", Description: "Show a save file dialog"}, s.dialogSaveFile) mcp.AddTool(server, &mcp.Tool{Name: "dialog_open_directory", Description: "Show a directory picker dialog"}, s.dialogOpenDirectory) + mcp.AddTool(server, &mcp.Tool{Name: "dialog_message", Description: "Show a message dialog"}, s.dialogMessage) mcp.AddTool(server, &mcp.Tool{Name: "dialog_confirm", Description: "Show a confirmation dialog"}, s.dialogConfirm) mcp.AddTool(server, &mcp.Tool{Name: "dialog_prompt", Description: "Show a prompt dialog"}, s.dialogPrompt) } diff --git a/pkg/mcp/tools_environment.go b/pkg/mcp/tools_environment.go index 09b7fcea..570b91f7 100644 --- a/pkg/mcp/tools_environment.go +++ b/pkg/mcp/tools_environment.go @@ -4,8 +4,8 @@ package mcp import ( "context" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/environment" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/environment" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -23,7 +23,7 @@ func (s *Subsystem) themeGet(_ context.Context, _ *mcp.CallToolRequest, _ ThemeG } theme, ok := result.(environment.ThemeInfo) if !ok { - return nil, ThemeGetOutput{}, corego.E("mcp.environment", "unexpected result type from theme query", nil) + return nil, ThemeGetOutput{}, coreerr.E("mcp.themeGet", "unexpected result type", nil) } return nil, ThemeGetOutput{Theme: theme}, nil } @@ -42,7 +42,7 @@ func (s *Subsystem) themeSystem(_ context.Context, _ *mcp.CallToolRequest, _ The } info, ok := result.(environment.EnvironmentInfo) if !ok { - return nil, ThemeSystemOutput{}, corego.E("mcp.environment", "unexpected result type from environment info query", nil) + return nil, ThemeSystemOutput{}, coreerr.E("mcp.themeSystem", "unexpected result type", nil) } return nil, ThemeSystemOutput{Info: info}, nil } @@ -53,7 +53,7 @@ type ThemeSetInput struct { Theme string `json:"theme"` } type ThemeSetOutput struct { - Theme environment.ThemeInfo `json:"theme"` + Success bool `json:"success"` } func (s *Subsystem) themeSet(_ context.Context, _ *mcp.CallToolRequest, input ThemeSetInput) (*mcp.CallToolResult, ThemeSetOutput, error) { @@ -61,21 +61,14 @@ func (s *Subsystem) themeSet(_ context.Context, _ *mcp.CallToolRequest, input Th if err != nil { return nil, ThemeSetOutput{}, err } - result, _, err := s.core.QUERY(environment.QueryTheme{}) - if err != nil { - return nil, ThemeSetOutput{}, err - } - theme, ok := result.(environment.ThemeInfo) - if !ok { - return nil, ThemeSetOutput{}, corego.E("mcp.environment", "unexpected result type from theme query", nil) - } - return nil, ThemeSetOutput{Theme: theme}, nil + return nil, ThemeSetOutput{Success: true}, nil } // --- Registration --- func (s *Subsystem) registerEnvironmentTools(server *mcp.Server) { mcp.AddTool(server, &mcp.Tool{Name: "theme_get", Description: "Get the current application theme"}, s.themeGet) + mcp.AddTool(server, &mcp.Tool{Name: "theme_set", Description: "Override the application theme to light, dark, or system"}, s.themeSet) mcp.AddTool(server, &mcp.Tool{Name: "theme_system", Description: "Get system environment and theme information"}, s.themeSystem) mcp.AddTool(server, &mcp.Tool{Name: "theme_set", Description: "Set the application theme override"}, s.themeSet) } diff --git a/pkg/mcp/tools_events.go b/pkg/mcp/tools_events.go new file mode 100644 index 00000000..1238d31a --- /dev/null +++ b/pkg/mcp/tools_events.go @@ -0,0 +1,100 @@ +// pkg/mcp/tools_events.go +package mcp + +import ( + "context" + + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/events" + "github.com/modelcontextprotocol/go-sdk/mcp" +) + +// --- event_emit --- + +type EventEmitInput struct { + Name string `json:"name"` + Data any `json:"data,omitempty"` +} +type EventEmitOutput struct { + Success bool `json:"success"` +} + +// eventEmit fires a custom event by name with optional data. +// c.PERFORM(events.TaskEmit{Name: "build:done", Data: result}) +func (s *Subsystem) eventEmit(_ context.Context, _ *mcp.CallToolRequest, input EventEmitInput) (*mcp.CallToolResult, EventEmitOutput, error) { + _, _, err := s.core.PERFORM(events.TaskEmit{Name: input.Name, Data: input.Data}) + if err != nil { + return nil, EventEmitOutput{}, err + } + return nil, EventEmitOutput{Success: true}, nil +} + +// --- event_on --- + +type EventOnInput struct { + Name string `json:"name"` +} +type EventOnOutput struct { + Success bool `json:"success"` +} + +// eventOn registers a persistent listener for a named event. +// c.PERFORM(events.TaskOn{Name: "build:done"}) +func (s *Subsystem) eventOn(_ context.Context, _ *mcp.CallToolRequest, input EventOnInput) (*mcp.CallToolResult, EventOnOutput, error) { + _, _, err := s.core.PERFORM(events.TaskOn{Name: input.Name}) + if err != nil { + return nil, EventOnOutput{}, err + } + return nil, EventOnOutput{Success: true}, nil +} + +// --- event_off --- + +type EventOffInput struct { + Name string `json:"name"` +} +type EventOffOutput struct { + Success bool `json:"success"` +} + +// eventOff removes all listeners for a named event. +// c.PERFORM(events.TaskOff{Name: "build:done"}) +func (s *Subsystem) eventOff(_ context.Context, _ *mcp.CallToolRequest, input EventOffInput) (*mcp.CallToolResult, EventOffOutput, error) { + _, _, err := s.core.PERFORM(events.TaskOff{Name: input.Name}) + if err != nil { + return nil, EventOffOutput{}, err + } + return nil, EventOffOutput{Success: true}, nil +} + +// --- event_list --- + +type EventListInput struct { + Name string `json:"name"` +} +type EventListOutput struct { + Count int `json:"count"` +} + +// eventList returns the number of listeners registered for a named event. +// count := c.QUERY(events.QueryListeners{Name: "build:done"}) +func (s *Subsystem) eventList(_ context.Context, _ *mcp.CallToolRequest, input EventListInput) (*mcp.CallToolResult, EventListOutput, error) { + result, _, err := s.core.QUERY(events.QueryListeners{Name: input.Name}) + if err != nil { + return nil, EventListOutput{}, err + } + count, ok := result.(int) + if !ok { + return nil, EventListOutput{}, coreerr.E("mcp.eventList", "unexpected result type", nil) + } + return nil, EventListOutput{Count: count}, nil +} + +// --- Registration --- + +func (s *Subsystem) registerEventTools(server *mcp.Server) { + mcp.AddTool(server, &mcp.Tool{Name: "event_emit", Description: "Fire a custom event by name with optional data"}, s.eventEmit) + mcp.AddTool(server, &mcp.Tool{Name: "event_on", Description: "Register a persistent listener for a named event"}, s.eventOn) + mcp.AddTool(server, &mcp.Tool{Name: "event_off", Description: "Remove all listeners for a named event"}, s.eventOff) + mcp.AddTool(server, &mcp.Tool{Name: "event_list", Description: "Return the number of listeners registered for a named event"}, s.eventList) +} diff --git a/pkg/mcp/tools_layout.go b/pkg/mcp/tools_layout.go index 7942fd5b..b57f8edc 100644 --- a/pkg/mcp/tools_layout.go +++ b/pkg/mcp/tools_layout.go @@ -3,11 +3,11 @@ package mcp import ( "context" + "strings" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/screen" - "dappco.re/go/core/gui/pkg/window" - "forge.lthn.ai/core/go/pkg/core" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/screen" + "forge.lthn.ai/core/gui/pkg/window" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -59,7 +59,7 @@ func (s *Subsystem) layoutList(_ context.Context, _ *mcp.CallToolRequest, _ Layo } layouts, ok := result.([]window.LayoutInfo) if !ok { - return nil, LayoutListOutput{}, corego.E("mcp.layout", "unexpected result type from layout list query", nil) + return nil, LayoutListOutput{}, coreerr.E("mcp.layoutList", "unexpected result type", nil) } return nil, LayoutListOutput{Layouts: layouts}, nil } @@ -97,7 +97,7 @@ func (s *Subsystem) layoutGet(_ context.Context, _ *mcp.CallToolRequest, input L } layout, ok := result.(*window.Layout) if !ok { - return nil, LayoutGetOutput{}, corego.E("mcp.layout", "unexpected result type from layout get query", nil) + return nil, LayoutGetOutput{}, coreerr.E("mcp.layoutGet", "unexpected result type", nil) } return nil, LayoutGetOutput{Layout: layout}, nil } @@ -138,145 +138,19 @@ func (s *Subsystem) layoutSnap(_ context.Context, _ *mcp.CallToolRequest, input return nil, LayoutSnapOutput{Success: true}, nil } -// --- layout_beside_editor --- - -type LayoutBesideEditorInput struct { - Editor string `json:"editor,omitempty"` - Window string `json:"window,omitempty"` -} -type LayoutBesideEditorOutput struct { - Success bool `json:"success"` -} - -func (s *Subsystem) layoutBesideEditor(_ context.Context, _ *mcp.CallToolRequest, input LayoutBesideEditorInput) (*mcp.CallToolResult, LayoutBesideEditorOutput, error) { - _, _, err := s.core.PERFORM(window.TaskBesideEditor{Editor: input.Editor, Window: input.Window}) - if err != nil { - return nil, LayoutBesideEditorOutput{}, err - } - return nil, LayoutBesideEditorOutput{Success: true}, nil -} - -// --- layout_suggest --- - -type LayoutSuggestInput struct { - WindowCount int `json:"windowCount,omitempty"` - ScreenWidth int `json:"screenWidth,omitempty"` - ScreenHeight int `json:"screenHeight,omitempty"` -} -type LayoutSuggestOutput struct { - Suggestion window.LayoutSuggestion `json:"suggestion"` -} - -func (s *Subsystem) layoutSuggest(_ context.Context, _ *mcp.CallToolRequest, input LayoutSuggestInput) (*mcp.CallToolResult, LayoutSuggestOutput, error) { - windowCount := input.WindowCount - if windowCount <= 0 { - result, _, err := s.core.QUERY(window.QueryWindowList{}) - if err != nil { - return nil, LayoutSuggestOutput{}, err - } - windows, ok := result.([]window.WindowInfo) - if !ok { - return nil, LayoutSuggestOutput{}, corego.E("mcp.layout", "unexpected result type from window list query", nil) - } - windowCount = len(windows) - } - screenW, screenH := input.ScreenWidth, input.ScreenHeight - if screenW <= 0 || screenH <= 0 { - screenW, screenH = primaryScreenSize(s.core) - } - result, handled, err := s.core.QUERY(window.QueryLayoutSuggestion{ - WindowCount: windowCount, - ScreenWidth: screenW, - ScreenHeight: screenH, - }) - if err != nil { - return nil, LayoutSuggestOutput{}, err - } - if !handled { - return nil, LayoutSuggestOutput{}, corego.E("mcp.layout", "window service not available", nil) - } - suggestion, ok := result.(window.LayoutSuggestion) - if !ok { - return nil, LayoutSuggestOutput{}, corego.E("mcp.layout", "unexpected result type from layout suggestion query", nil) - } - return nil, LayoutSuggestOutput{Suggestion: suggestion}, nil -} - -// --- screen_find_space --- - -type ScreenFindSpaceInput struct { - Width int `json:"width,omitempty"` - Height int `json:"height,omitempty"` -} -type ScreenFindSpaceOutput struct { - Space window.SpaceInfo `json:"space"` -} - -func (s *Subsystem) screenFindSpace(_ context.Context, _ *mcp.CallToolRequest, input ScreenFindSpaceInput) (*mcp.CallToolResult, ScreenFindSpaceOutput, error) { - screenW, screenH := primaryScreenSize(s.core) - if screenW <= 0 || screenH <= 0 { - screenW, screenH = 1920, 1080 - } - result, handled, err := s.core.QUERY(window.QueryFindSpace{ - Width: input.Width, - Height: input.Height, - ScreenWidth: screenW, - ScreenHeight: screenH, - }) - if err != nil { - return nil, ScreenFindSpaceOutput{}, err - } - if !handled { - return nil, ScreenFindSpaceOutput{}, corego.E("mcp.layout", "window service not available", nil) - } - space, ok := result.(window.SpaceInfo) - if !ok { - return nil, ScreenFindSpaceOutput{}, corego.E("mcp.layout", "unexpected result type from find space query", nil) - } - if space.ScreenWidth == 0 { - space.ScreenWidth = screenW - } - if space.ScreenHeight == 0 { - space.ScreenHeight = screenH - } - return nil, ScreenFindSpaceOutput{Space: space}, nil -} - -// --- window_arrange_pair --- - -type WindowArrangePairInput struct { - First string `json:"first"` - Second string `json:"second"` -} -type WindowArrangePairOutput struct { - Success bool `json:"success"` -} - -func (s *Subsystem) windowArrangePair(_ context.Context, _ *mcp.CallToolRequest, input WindowArrangePairInput) (*mcp.CallToolResult, WindowArrangePairOutput, error) { - _, _, err := s.core.PERFORM(window.TaskArrangePair{First: input.First, Second: input.Second}) - if err != nil { - return nil, WindowArrangePairOutput{}, err - } - return nil, WindowArrangePairOutput{Success: true}, nil -} - // --- layout_stack --- type LayoutStackInput struct { Windows []string `json:"windows,omitempty"` - OffsetX int `json:"offsetX,omitempty"` - OffsetY int `json:"offsetY,omitempty"` + OffsetX int `json:"offsetX"` + OffsetY int `json:"offsetY"` } type LayoutStackOutput struct { Success bool `json:"success"` } func (s *Subsystem) layoutStack(_ context.Context, _ *mcp.CallToolRequest, input LayoutStackInput) (*mcp.CallToolResult, LayoutStackOutput, error) { - _, _, err := s.core.PERFORM(window.TaskStackWindows{ - Windows: input.Windows, - OffsetX: input.OffsetX, - OffsetY: input.OffsetY, - }) + _, _, err := s.core.PERFORM(window.TaskStackWindows{Windows: input.Windows, OffsetX: input.OffsetX, OffsetY: input.OffsetY}) if err != nil { return nil, LayoutStackOutput{}, err } @@ -294,20 +168,186 @@ type LayoutWorkflowOutput struct { } func (s *Subsystem) layoutWorkflow(_ context.Context, _ *mcp.CallToolRequest, input LayoutWorkflowInput) (*mcp.CallToolResult, LayoutWorkflowOutput, error) { - workflow, ok := window.ParseWorkflowLayout(input.Workflow) - if !ok { - return nil, LayoutWorkflowOutput{}, corego.E("mcp.layout", corego.Sprintf("unknown workflow: %s", input.Workflow), nil) - } - _, _, err := s.core.PERFORM(window.TaskApplyWorkflow{ - Workflow: workflow, - Windows: input.Windows, - }) + _, _, err := s.core.PERFORM(window.TaskApplyWorkflow{Workflow: input.Workflow, Windows: input.Windows}) if err != nil { return nil, LayoutWorkflowOutput{}, err } return nil, LayoutWorkflowOutput{Success: true}, nil } +// --- layout_suggest --- + +type LayoutSuggestInput struct { + Width int `json:"width"` + Height int `json:"height"` + WindowCount int `json:"windowCount"` +} +type LayoutSuggestOutput struct { + Mode string `json:"mode"` + Placements []screen.Rect `json:"placements"` +} + +func (s *Subsystem) layoutSuggest(_ context.Context, _ *mcp.CallToolRequest, input LayoutSuggestInput) (*mcp.CallToolResult, LayoutSuggestOutput, error) { + width := input.Width + height := input.Height + if width <= 0 { + width = 1920 + } + if height <= 0 { + height = 1080 + } + count := input.WindowCount + if count <= 0 { + count = 1 + } + + workArea := screen.Rect{X: 0, Y: 0, Width: width, Height: height} + switch { + case count == 1: + return nil, LayoutSuggestOutput{Mode: "full", Placements: []screen.Rect{workArea}}, nil + case count == 2: + if width >= height { + half := width / 2 + return nil, LayoutSuggestOutput{ + Mode: "side-by-side", + Placements: []screen.Rect{ + {X: 0, Y: 0, Width: half, Height: height}, + {X: half, Y: 0, Width: width - half, Height: height}, + }, + }, nil + } + half := height / 2 + return nil, LayoutSuggestOutput{ + Mode: "stacked", + Placements: []screen.Rect{ + {X: 0, Y: 0, Width: width, Height: half}, + {X: 0, Y: half, Width: width, Height: height - half}, + }, + }, nil + case count == 3 && width >= height: + mainWidth := width * 2 / 3 + sideHeight := height / 2 + return nil, LayoutSuggestOutput{ + Mode: "editor-plus-stack", + Placements: []screen.Rect{ + {X: 0, Y: 0, Width: mainWidth, Height: height}, + {X: mainWidth, Y: 0, Width: width - mainWidth, Height: sideHeight}, + {X: mainWidth, Y: sideHeight, Width: width - mainWidth, Height: height - sideHeight}, + }, + }, nil + default: + cols := 2 + if count > 4 { + cols = 3 + } + rows := (count + cols - 1) / cols + cellWidth := width / cols + cellHeight := height / rows + placements := make([]screen.Rect, 0, count) + for i := 0; i < count; i++ { + row := i / cols + col := i % cols + placements = append(placements, screen.Rect{ + X: col * cellWidth, Y: row * cellHeight, + Width: cellWidth, Height: cellHeight, + }) + } + return nil, LayoutSuggestOutput{Mode: "grid", Placements: placements}, nil + } +} + +// --- layout_beside_editor --- + +type LayoutBesideEditorInput struct { + Name string `json:"name"` + EditorNames []string `json:"editorNames,omitempty"` +} +type LayoutBesideEditorOutput struct { + Editor string `json:"editor"` + Bounds screen.Rect `json:"bounds"` +} + +func (s *Subsystem) layoutBesideEditor(_ context.Context, _ *mcp.CallToolRequest, input LayoutBesideEditorInput) (*mcp.CallToolResult, LayoutBesideEditorOutput, error) { + windows, err := s.allWindows() + if err != nil { + return nil, LayoutBesideEditorOutput{}, err + } + screens, err := s.allScreens() + if err != nil { + return nil, LayoutBesideEditorOutput{}, err + } + + editorHints := map[string]struct{}{} + for _, name := range input.EditorNames { + editorHints[strings.ToLower(name)] = struct{}{} + } + defaultHints := []string{"code", "cursor", "vscode", "studio", "goland", "intellij", "webstorm", "xcode", "vim", "nvim", "emacs", "editor"} + + var editor *window.WindowInfo + for i := range windows { + if windows[i].Name == input.Name { + continue + } + name := strings.ToLower(windows[i].Name) + title := strings.ToLower(windows[i].Title) + if _, ok := editorHints[name]; ok { + editor = &windows[i] + break + } + for _, hint := range defaultHints { + if strings.Contains(name, hint) || strings.Contains(title, hint) { + editor = &windows[i] + break + } + } + if editor != nil { + break + } + } + if editor == nil { + return nil, LayoutBesideEditorOutput{}, coreerr.E("mcp.layoutBesideEditor", "no editor window detected", nil) + } + + editorScreen := screenForWindowInfo(screens, *editor) + if editorScreen == nil { + editorScreen = chooseScreenByIDOrPrimary(screens, "") + } + workArea := workAreaRect(editorScreen) + + editorRect := screen.Rect{X: editor.X, Y: editor.Y, Width: editor.Width, Height: editor.Height} + candidates := []screen.Rect{ + {X: workArea.X, Y: workArea.Y, Width: max(0, editorRect.X-workArea.X), Height: workArea.Height}, + {X: editorRect.X + editorRect.Width, Y: workArea.Y, Width: max(0, workArea.X+workArea.Width-(editorRect.X+editorRect.Width)), Height: workArea.Height}, + {X: workArea.X, Y: workArea.Y, Width: workArea.Width, Height: max(0, editorRect.Y-workArea.Y)}, + {X: workArea.X, Y: editorRect.Y + editorRect.Height, Width: workArea.Width, Height: max(0, workArea.Y+workArea.Height-(editorRect.Y+editorRect.Height))}, + } + + best := screen.Rect{} + bestArea := -1 + for _, candidate := range candidates { + area := candidate.Width * candidate.Height + if candidate.Width <= 0 || candidate.Height <= 0 { + continue + } + if area > bestArea { + bestArea = area + best = candidate + } + } + if bestArea <= 0 { + arranged, err := s.arrangePairOnScreen(editor.Name, input.Name, editorScreen, "") + if err != nil { + return nil, LayoutBesideEditorOutput{}, err + } + return nil, LayoutBesideEditorOutput{Editor: editor.Name, Bounds: arranged.Second}, nil + } + + if err := applyRect(s.core, input.Name, best); err != nil { + return nil, LayoutBesideEditorOutput{}, err + } + return nil, LayoutBesideEditorOutput{Editor: editor.Name, Bounds: best}, nil +} + // --- Registration --- func (s *Subsystem) registerLayoutTools(server *mcp.Server) { @@ -317,29 +357,9 @@ func (s *Subsystem) registerLayoutTools(server *mcp.Server) { mcp.AddTool(server, &mcp.Tool{Name: "layout_delete", Description: "Delete a saved layout"}, s.layoutDelete) mcp.AddTool(server, &mcp.Tool{Name: "layout_get", Description: "Get a specific layout by name"}, s.layoutGet) mcp.AddTool(server, &mcp.Tool{Name: "layout_tile", Description: "Tile windows in a grid arrangement"}, s.layoutTile) + mcp.AddTool(server, &mcp.Tool{Name: "layout_suggest", Description: "Suggest an optimal arrangement for the given screen size and window count"}, s.layoutSuggest) + mcp.AddTool(server, &mcp.Tool{Name: "layout_beside_editor", Description: "Place a window beside a detected editor or IDE window"}, s.layoutBesideEditor) mcp.AddTool(server, &mcp.Tool{Name: "layout_snap", Description: "Snap a window to a screen edge or corner"}, s.layoutSnap) - mcp.AddTool(server, &mcp.Tool{Name: "layout_beside_editor", Description: "Place a window beside a detected editor window"}, s.layoutBesideEditor) - mcp.AddTool(server, &mcp.Tool{Name: "layout_suggest", Description: "Suggest an optimal layout for the current screen"}, s.layoutSuggest) - mcp.AddTool(server, &mcp.Tool{Name: "screen_find_space", Description: "Find an empty area for a new window"}, s.screenFindSpace) - mcp.AddTool(server, &mcp.Tool{Name: "window_arrange_pair", Description: "Arrange two windows side-by-side"}, s.windowArrangePair) - mcp.AddTool(server, &mcp.Tool{Name: "layout_stack", Description: "Cascade windows with an offset"}, s.layoutStack) - mcp.AddTool(server, &mcp.Tool{Name: "layout_workflow", Description: "Apply a predefined workflow layout"}, s.layoutWorkflow) -} - -func primaryScreenSize(c *core.Core) (int, int) { - result, handled, err := c.QUERY(screen.QueryPrimary{}) - if err == nil && handled { - if scr, ok := result.(*screen.Screen); ok && scr != nil { - if scr.WorkArea.Width > 0 && scr.WorkArea.Height > 0 { - return scr.WorkArea.Width, scr.WorkArea.Height - } - if scr.Bounds.Width > 0 && scr.Bounds.Height > 0 { - return scr.Bounds.Width, scr.Bounds.Height - } - if scr.Size.Width > 0 && scr.Size.Height > 0 { - return scr.Size.Width, scr.Size.Height - } - } - } - return 1920, 1080 + mcp.AddTool(server, &mcp.Tool{Name: "layout_stack", Description: "Stack windows in a cascade pattern"}, s.layoutStack) + mcp.AddTool(server, &mcp.Tool{Name: "layout_workflow", Description: "Apply a preset workflow layout"}, s.layoutWorkflow) } diff --git a/pkg/mcp/tools_notification.go b/pkg/mcp/tools_notification.go index f6c32c75..1eeb9e08 100644 --- a/pkg/mcp/tools_notification.go +++ b/pkg/mcp/tools_notification.go @@ -4,8 +4,8 @@ package mcp import ( "context" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/notification" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/notification" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -21,7 +21,7 @@ type NotificationShowOutput struct { } func (s *Subsystem) notificationShow(_ context.Context, _ *mcp.CallToolRequest, input NotificationShowInput) (*mcp.CallToolResult, NotificationShowOutput, error) { - _, _, err := s.core.PERFORM(notification.TaskSend{Opts: notification.NotificationOptions{ + _, _, err := s.core.PERFORM(notification.TaskSend{Options: notification.NotificationOptions{ Title: input.Title, Message: input.Message, Subtitle: input.Subtitle, @@ -38,14 +38,14 @@ type NotificationWithActionsInput struct { Title string `json:"title"` Message string `json:"message"` Subtitle string `json:"subtitle,omitempty"` - Actions []notification.NotificationAction `json:"actions,omitempty"` + Actions []notification.NotificationAction `json:"actions"` } type NotificationWithActionsOutput struct { Success bool `json:"success"` } func (s *Subsystem) notificationWithActions(_ context.Context, _ *mcp.CallToolRequest, input NotificationWithActionsInput) (*mcp.CallToolResult, NotificationWithActionsOutput, error) { - _, _, err := s.core.PERFORM(notification.TaskSend{Opts: notification.NotificationOptions{ + _, _, err := s.core.PERFORM(notification.TaskSend{Options: notification.NotificationOptions{ Title: input.Title, Message: input.Message, Subtitle: input.Subtitle, @@ -71,7 +71,7 @@ func (s *Subsystem) notificationPermissionRequest(_ context.Context, _ *mcp.Call } granted, ok := result.(bool) if !ok { - return nil, NotificationPermissionRequestOutput{}, corego.E("mcp.notification", "unexpected result type from notification permission request", nil) + return nil, NotificationPermissionRequestOutput{}, coreerr.E("mcp.notificationPermissionRequest", "unexpected result type", nil) } return nil, NotificationPermissionRequestOutput{Granted: granted}, nil } @@ -90,65 +90,34 @@ func (s *Subsystem) notificationPermissionCheck(_ context.Context, _ *mcp.CallTo } status, ok := result.(notification.PermissionStatus) if !ok { - return nil, NotificationPermissionCheckOutput{}, corego.E("mcp.notification", "unexpected result type from notification permission check", nil) + return nil, NotificationPermissionCheckOutput{}, coreerr.E("mcp.notificationPermissionCheck", "unexpected result type", nil) } return nil, NotificationPermissionCheckOutput{Granted: status.Granted}, nil } // --- notification_clear --- -type NotificationClearInput struct{} +type NotificationClearInput struct { + ID string `json:"id,omitempty"` +} type NotificationClearOutput struct { Success bool `json:"success"` } -func (s *Subsystem) notificationClear(_ context.Context, _ *mcp.CallToolRequest, _ NotificationClearInput) (*mcp.CallToolResult, NotificationClearOutput, error) { - _, _, err := s.core.PERFORM(notification.TaskClear{}) +func (s *Subsystem) notificationClear(_ context.Context, _ *mcp.CallToolRequest, input NotificationClearInput) (*mcp.CallToolResult, NotificationClearOutput, error) { + _, _, err := s.core.PERFORM(notification.TaskClear{ID: input.ID}) if err != nil { return nil, NotificationClearOutput{}, err } return nil, NotificationClearOutput{Success: true}, nil } -// --- dialog_message --- - -type DialogMessageInput struct { - Title string `json:"title"` - Message string `json:"message"` - Kind string `json:"kind,omitempty"` -} -type DialogMessageOutput struct { - Success bool `json:"success"` -} - -func (s *Subsystem) dialogMessage(_ context.Context, _ *mcp.CallToolRequest, input DialogMessageInput) (*mcp.CallToolResult, DialogMessageOutput, error) { - var severity notification.NotificationSeverity - switch input.Kind { - case "warning": - severity = notification.SeverityWarning - case "error": - severity = notification.SeverityError - default: - severity = notification.SeverityInfo - } - _, _, err := s.core.PERFORM(notification.TaskSend{Opts: notification.NotificationOptions{ - Title: input.Title, - Message: input.Message, - Severity: severity, - }}) - if err != nil { - return nil, DialogMessageOutput{}, err - } - return nil, DialogMessageOutput{Success: true}, nil -} - // --- Registration --- func (s *Subsystem) registerNotificationTools(server *mcp.Server) { mcp.AddTool(server, &mcp.Tool{Name: "notification_show", Description: "Show a desktop notification"}, s.notificationShow) - mcp.AddTool(server, &mcp.Tool{Name: "notification_with_actions", Description: "Show a desktop notification with actions"}, s.notificationWithActions) + mcp.AddTool(server, &mcp.Tool{Name: "notification_with_actions", Description: "Show a desktop notification with action buttons"}, s.notificationWithActions) mcp.AddTool(server, &mcp.Tool{Name: "notification_permission_request", Description: "Request notification permission"}, s.notificationPermissionRequest) mcp.AddTool(server, &mcp.Tool{Name: "notification_permission_check", Description: "Check notification permission status"}, s.notificationPermissionCheck) - mcp.AddTool(server, &mcp.Tool{Name: "notification_clear", Description: "Clear notifications when supported"}, s.notificationClear) - mcp.AddTool(server, &mcp.Tool{Name: "dialog_message", Description: "Show a message dialog using the notification pipeline"}, s.dialogMessage) + mcp.AddTool(server, &mcp.Tool{Name: "notification_clear", Description: "Clear a notification by ID or clear all notifications"}, s.notificationClear) } diff --git a/pkg/mcp/tools_screen.go b/pkg/mcp/tools_screen.go index 5d076bf8..90633147 100644 --- a/pkg/mcp/tools_screen.go +++ b/pkg/mcp/tools_screen.go @@ -4,10 +4,9 @@ package mcp import ( "context" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/display" - "dappco.re/go/core/gui/pkg/screen" - "forge.lthn.ai/core/go/pkg/core" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/screen" + "forge.lthn.ai/core/gui/pkg/window" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -25,7 +24,7 @@ func (s *Subsystem) screenList(_ context.Context, _ *mcp.CallToolRequest, _ Scre } screens, ok := result.([]screen.Screen) if !ok { - return nil, ScreenListOutput{}, corego.E("mcp.screen", "unexpected result type from screen list query", nil) + return nil, ScreenListOutput{}, coreerr.E("mcp.screenList", "unexpected result type", nil) } return nil, ScreenListOutput{Screens: screens}, nil } @@ -46,7 +45,7 @@ func (s *Subsystem) screenGet(_ context.Context, _ *mcp.CallToolRequest, input S } scr, ok := result.(*screen.Screen) if !ok { - return nil, ScreenGetOutput{}, corego.E("mcp.screen", "unexpected result type from screen get query", nil) + return nil, ScreenGetOutput{}, coreerr.E("mcp.screenGet", "unexpected result type", nil) } return nil, ScreenGetOutput{Screen: scr}, nil } @@ -65,7 +64,7 @@ func (s *Subsystem) screenPrimary(_ context.Context, _ *mcp.CallToolRequest, _ S } scr, ok := result.(*screen.Screen) if !ok { - return nil, ScreenPrimaryOutput{}, corego.E("mcp.screen", "unexpected result type from screen primary query", nil) + return nil, ScreenPrimaryOutput{}, coreerr.E("mcp.screenPrimary", "unexpected result type", nil) } return nil, ScreenPrimaryOutput{Screen: scr}, nil } @@ -87,7 +86,7 @@ func (s *Subsystem) screenAtPoint(_ context.Context, _ *mcp.CallToolRequest, inp } scr, ok := result.(*screen.Screen) if !ok { - return nil, ScreenAtPointOutput{}, corego.E("mcp.screen", "unexpected result type from screen at point query", nil) + return nil, ScreenAtPointOutput{}, coreerr.E("mcp.screenAtPoint", "unexpected result type", nil) } return nil, ScreenAtPointOutput{Screen: scr}, nil } @@ -106,35 +105,105 @@ func (s *Subsystem) screenWorkAreas(_ context.Context, _ *mcp.CallToolRequest, _ } areas, ok := result.([]screen.Rect) if !ok { - return nil, ScreenWorkAreasOutput{}, corego.E("mcp.screen", "unexpected result type from screen work areas query", nil) + return nil, ScreenWorkAreasOutput{}, coreerr.E("mcp.screenWorkAreas", "unexpected result type", nil) } return nil, ScreenWorkAreasOutput{WorkAreas: areas}, nil } // --- screen_work_area --- -func (s *Subsystem) screenWorkArea(ctx context.Context, req *mcp.CallToolRequest, input ScreenWorkAreasInput) (*mcp.CallToolResult, ScreenWorkAreasOutput, error) { - return s.screenWorkAreas(ctx, req, input) +type ScreenWorkAreaInput struct { + ID string `json:"id,omitempty"` +} +type ScreenWorkAreaOutput struct { + WorkArea screen.Rect `json:"workArea"` +} + +func (s *Subsystem) screenWorkArea(_ context.Context, _ *mcp.CallToolRequest, input ScreenWorkAreaInput) (*mcp.CallToolResult, ScreenWorkAreaOutput, error) { + screens, err := s.allScreens() + if err != nil { + return nil, ScreenWorkAreaOutput{}, err + } + scr := chooseScreenByIDOrPrimary(screens, input.ID) + if scr == nil { + return nil, ScreenWorkAreaOutput{}, nil + } + return nil, ScreenWorkAreaOutput{WorkArea: workAreaRect(scr)}, nil +} + +// --- screen_find_space --- + +type ScreenFindSpaceInput struct { + ScreenID string `json:"screenId,omitempty"` + Width int `json:"width,omitempty"` + Height int `json:"height,omitempty"` +} +type ScreenFindSpaceOutput struct { + ScreenID string `json:"screenId"` + Bounds screen.Rect `json:"bounds"` +} + +func (s *Subsystem) screenFindSpace(_ context.Context, _ *mcp.CallToolRequest, input ScreenFindSpaceInput) (*mcp.CallToolResult, ScreenFindSpaceOutput, error) { + screens, err := s.allScreens() + if err != nil { + return nil, ScreenFindSpaceOutput{}, err + } + windows, err := s.allWindows() + if err != nil { + return nil, ScreenFindSpaceOutput{}, err + } + + orderedScreens := make([]screen.Screen, 0, len(screens)) + if selected := chooseScreenByIDOrPrimary(screens, input.ScreenID); selected != nil { + orderedScreens = append(orderedScreens, *selected) + for _, scr := range screens { + if scr.ID != selected.ID { + orderedScreens = append(orderedScreens, scr) + } + } + } + + for _, scr := range orderedScreens { + workArea := workAreaRect(&scr) + occupied := make([]screen.Rect, 0, len(windows)) + for _, info := range windows { + if windowScreen := screenForWindowInfo(screens, info); windowScreen != nil && windowScreen.ID == scr.ID { + occupied = append(occupied, screen.Rect{X: info.X, Y: info.Y, Width: info.Width, Height: info.Height}) + } + } + if candidate, ok := findLargestFreeRect(workArea, occupied, input.Width, input.Height); ok { + return nil, ScreenFindSpaceOutput{ScreenID: scr.ID, Bounds: candidate}, nil + } + } + + return nil, ScreenFindSpaceOutput{}, nil } // --- screen_for_window --- type ScreenForWindowInput struct { - Window string `json:"window"` + Name string `json:"name"` } type ScreenForWindowOutput struct { Screen *screen.Screen `json:"screen"` } func (s *Subsystem) screenForWindow(_ context.Context, _ *mcp.CallToolRequest, input ScreenForWindowInput) (*mcp.CallToolResult, ScreenForWindowOutput, error) { - svc, err := core.ServiceFor[*display.Service](s.core, "display") + result, _, err := s.core.QUERY(window.QueryWindowByName{Name: input.Name}) if err != nil { return nil, ScreenForWindowOutput{}, err } - scr, err := svc.GetScreenForWindow(input.Window) + info, _ := result.(*window.WindowInfo) + if info == nil { + return nil, ScreenForWindowOutput{}, nil + } + centerX := info.X + info.Width/2 + centerY := info.Y + info.Height/2 + screenResult, _, err := s.core.QUERY(screen.QueryAtPoint{X: centerX, Y: centerY}) if err != nil { return nil, ScreenForWindowOutput{}, err } + scr, _ := screenResult.(*screen.Screen) return nil, ScreenForWindowOutput{Screen: scr}, nil } @@ -145,7 +214,8 @@ func (s *Subsystem) registerScreenTools(server *mcp.Server) { mcp.AddTool(server, &mcp.Tool{Name: "screen_get", Description: "Get information about a specific screen"}, s.screenGet) mcp.AddTool(server, &mcp.Tool{Name: "screen_primary", Description: "Get the primary screen"}, s.screenPrimary) mcp.AddTool(server, &mcp.Tool{Name: "screen_at_point", Description: "Get the screen at a specific point"}, s.screenAtPoint) + mcp.AddTool(server, &mcp.Tool{Name: "screen_work_area", Description: "Get the work area for a screen"}, s.screenWorkArea) mcp.AddTool(server, &mcp.Tool{Name: "screen_work_areas", Description: "Get work areas for all screens"}, s.screenWorkAreas) - mcp.AddTool(server, &mcp.Tool{Name: "screen_work_area", Description: "Alias for screen_work_areas"}, s.screenWorkArea) + mcp.AddTool(server, &mcp.Tool{Name: "screen_find_space", Description: "Find the largest empty area on a screen that fits the requested size"}, s.screenFindSpace) mcp.AddTool(server, &mcp.Tool{Name: "screen_for_window", Description: "Get the screen containing a window"}, s.screenForWindow) } diff --git a/pkg/mcp/tools_tray.go b/pkg/mcp/tools_tray.go index e0c95fa2..4064a42b 100644 --- a/pkg/mcp/tools_tray.go +++ b/pkg/mcp/tools_tray.go @@ -36,7 +36,7 @@ type TraySetTooltipOutput struct { } func (s *Subsystem) traySetTooltip(_ context.Context, _ *mcp.CallToolRequest, input TraySetTooltipInput) (*mcp.CallToolResult, TraySetTooltipOutput, error) { - _, _, err := s.core.PERFORM(systray.TaskSetTooltip{Tooltip: input.Tooltip}) + _, _, err := s.core.PERFORM(systray.TaskSetTrayTooltip{Tooltip: input.Tooltip}) if err != nil { return nil, TraySetTooltipOutput{}, err } @@ -53,13 +53,52 @@ type TraySetLabelOutput struct { } func (s *Subsystem) traySetLabel(_ context.Context, _ *mcp.CallToolRequest, input TraySetLabelInput) (*mcp.CallToolResult, TraySetLabelOutput, error) { - _, _, err := s.core.PERFORM(systray.TaskSetLabel{Label: input.Label}) + _, _, err := s.core.PERFORM(systray.TaskSetTrayLabel{Label: input.Label}) if err != nil { return nil, TraySetLabelOutput{}, err } return nil, TraySetLabelOutput{Success: true}, nil } +// --- tray_set_menu --- + +type TraySetMenuInput struct { + Items []map[string]any `json:"items"` +} +type TraySetMenuOutput struct { + Success bool `json:"success"` +} + +func (s *Subsystem) traySetMenu(_ context.Context, _ *mcp.CallToolRequest, input TraySetMenuInput) (*mcp.CallToolResult, TraySetMenuOutput, error) { + items := make([]systray.TrayMenuItem, 0, len(input.Items)) + for _, item := range input.Items { + items = append(items, decodeTrayMenuItem(item)) + } + _, _, err := s.core.PERFORM(systray.TaskSetTrayMenu{Items: items}) + if err != nil { + return nil, TraySetMenuOutput{}, err + } + return nil, TraySetMenuOutput{Success: true}, nil +} + +// --- tray_show_message --- + +type TrayShowMessageInput struct { + Title string `json:"title"` + Message string `json:"message"` +} +type TrayShowMessageOutput struct { + Success bool `json:"success"` +} + +func (s *Subsystem) trayShowMessage(_ context.Context, _ *mcp.CallToolRequest, input TrayShowMessageInput) (*mcp.CallToolResult, TrayShowMessageOutput, error) { + _, _, err := s.core.PERFORM(systray.TaskShowMessage{Title: input.Title, Message: input.Message}) + if err != nil { + return nil, TrayShowMessageOutput{}, err + } + return nil, TrayShowMessageOutput{Success: true}, nil +} + // --- tray_info --- type TrayInfoInput struct{} @@ -74,7 +113,7 @@ func (s *Subsystem) trayInfo(_ context.Context, _ *mcp.CallToolRequest, _ TrayIn } config, ok := result.(map[string]any) if !ok { - return nil, TrayInfoOutput{}, corego.E("mcp.trayInfo", "unexpected result type from tray config query", nil) + config = map[string]any{} } return nil, TrayInfoOutput{Config: config}, nil } @@ -103,6 +142,42 @@ func (s *Subsystem) registerTrayTools(server *mcp.Server) { mcp.AddTool(server, &mcp.Tool{Name: "tray_set_icon", Description: "Set the system tray icon"}, s.traySetIcon) mcp.AddTool(server, &mcp.Tool{Name: "tray_set_tooltip", Description: "Set the system tray tooltip"}, s.traySetTooltip) mcp.AddTool(server, &mcp.Tool{Name: "tray_set_label", Description: "Set the system tray label"}, s.traySetLabel) + mcp.AddTool(server, &mcp.Tool{Name: "tray_set_menu", Description: "Set the system tray menu"}, s.traySetMenu) + mcp.AddTool(server, &mcp.Tool{Name: "tray_show_message", Description: "Show a tray balloon or tray message"}, s.trayShowMessage) mcp.AddTool(server, &mcp.Tool{Name: "tray_info", Description: "Get system tray configuration"}, s.trayInfo) mcp.AddTool(server, &mcp.Tool{Name: "tray_show_message", Description: "Show a tray message or notification"}, s.trayShowMessage) } + +func decodeTrayMenuItem(input map[string]any) systray.TrayMenuItem { + item := systray.TrayMenuItem{} + if label, ok := input["label"].(string); ok { + item.Label = label + } + if itemType, ok := input["type"].(string); ok { + item.Type = itemType + } + if checked, ok := input["checked"].(bool); ok { + item.Checked = checked + } + if disabled, ok := input["disabled"].(bool); ok { + item.Disabled = disabled + } + if tooltip, ok := input["tooltip"].(string); ok { + item.Tooltip = tooltip + } + if actionID, ok := input["actionId"].(string); ok { + item.ActionID = actionID + } + if actionID, ok := input["action_id"].(string); ok && item.ActionID == "" { + item.ActionID = actionID + } + if rawSubmenu, ok := input["submenu"].([]any); ok { + item.Submenu = make([]systray.TrayMenuItem, 0, len(rawSubmenu)) + for _, child := range rawSubmenu { + if childMap, ok := child.(map[string]any); ok { + item.Submenu = append(item.Submenu, decodeTrayMenuItem(childMap)) + } + } + } + return item +} diff --git a/pkg/mcp/tools_webview.go b/pkg/mcp/tools_webview.go index 26b43611..5ad64ab2 100644 --- a/pkg/mcp/tools_webview.go +++ b/pkg/mcp/tools_webview.go @@ -4,8 +4,8 @@ package mcp import ( "context" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/webview" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/webview" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -105,7 +105,7 @@ func (s *Subsystem) webviewScreenshot(_ context.Context, _ *mcp.CallToolRequest, } sr, ok := result.(webview.ScreenshotResult) if !ok { - return nil, WebviewScreenshotOutput{}, corego.E("mcp.webview", "unexpected result type from webview screenshot", nil) + return nil, WebviewScreenshotOutput{}, coreerr.E("mcp.webviewScreenshot", "unexpected result type", nil) } return nil, WebviewScreenshotOutput{Base64: sr.Base64, MimeType: sr.MimeType}, nil } @@ -272,7 +272,7 @@ func (s *Subsystem) webviewConsole(_ context.Context, _ *mcp.CallToolRequest, in } msgs, ok := result.([]webview.ConsoleMessage) if !ok { - return nil, WebviewConsoleOutput{}, corego.E("mcp.webview", "unexpected result type from webview console query", nil) + return nil, WebviewConsoleOutput{}, coreerr.E("mcp.webviewConsole", "unexpected result type", nil) } return nil, WebviewConsoleOutput{Messages: msgs}, nil } @@ -370,7 +370,7 @@ func (s *Subsystem) webviewQuery(_ context.Context, _ *mcp.CallToolRequest, inpu } el, ok := result.(*webview.ElementInfo) if !ok { - return nil, WebviewQueryOutput{}, corego.E("mcp.webview", "unexpected result type from webview query", nil) + return nil, WebviewQueryOutput{}, coreerr.E("mcp.webviewQuery", "unexpected result type", nil) } return nil, WebviewQueryOutput{Element: el}, nil } @@ -399,7 +399,7 @@ func (s *Subsystem) webviewQueryAll(_ context.Context, _ *mcp.CallToolRequest, i } els, ok := result.([]*webview.ElementInfo) if !ok { - return nil, WebviewQueryAllOutput{}, corego.E("mcp.webview", "unexpected result type from webview query all", nil) + return nil, WebviewQueryAllOutput{}, coreerr.E("mcp.webviewQueryAll", "unexpected result type", nil) } return nil, WebviewQueryAllOutput{Elements: els}, nil } @@ -422,7 +422,7 @@ func (s *Subsystem) webviewDOMTree(_ context.Context, _ *mcp.CallToolRequest, in } html, ok := result.(string) if !ok { - return nil, WebviewDOMTreeOutput{}, corego.E("mcp.webview", "unexpected result type from webview DOM tree query", nil) + return nil, WebviewDOMTreeOutput{}, coreerr.E("mcp.webviewDOMTree", "unexpected result type", nil) } return nil, WebviewDOMTreeOutput{HTML: html}, nil } @@ -637,7 +637,7 @@ func (s *Subsystem) webviewURL(_ context.Context, _ *mcp.CallToolRequest, input } url, ok := result.(string) if !ok { - return nil, WebviewURLOutput{}, corego.E("mcp.webview", "unexpected result type from webview URL query", nil) + return nil, WebviewURLOutput{}, coreerr.E("mcp.webviewURL", "unexpected result type", nil) } return nil, WebviewURLOutput{URL: url}, nil } @@ -659,7 +659,7 @@ func (s *Subsystem) webviewTitle(_ context.Context, _ *mcp.CallToolRequest, inpu } title, ok := result.(string) if !ok { - return nil, WebviewTitleOutput{}, corego.E("mcp.webview", "unexpected result type from webview title query", nil) + return nil, WebviewTitleOutput{}, coreerr.E("mcp.webviewTitle", "unexpected result type", nil) } return nil, WebviewTitleOutput{Title: title}, nil } diff --git a/pkg/mcp/tools_window.go b/pkg/mcp/tools_window.go index 748eaadb..131e16de 100644 --- a/pkg/mcp/tools_window.go +++ b/pkg/mcp/tools_window.go @@ -4,8 +4,9 @@ package mcp import ( "context" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/window" + coreerr "forge.lthn.ai/core/go-log" + "forge.lthn.ai/core/gui/pkg/screen" + "forge.lthn.ai/core/gui/pkg/window" "github.com/modelcontextprotocol/go-sdk/mcp" ) @@ -23,7 +24,7 @@ func (s *Subsystem) windowList(_ context.Context, _ *mcp.CallToolRequest, _ Wind } windows, ok := result.([]window.WindowInfo) if !ok { - return nil, WindowListOutput{}, corego.E("mcp.window", "unexpected result type from window list query", nil) + return nil, WindowListOutput{}, coreerr.E("mcp.windowList", "unexpected result type", nil) } return nil, WindowListOutput{Windows: windows}, nil } @@ -44,7 +45,7 @@ func (s *Subsystem) windowGet(_ context.Context, _ *mcp.CallToolRequest, input W } info, ok := result.(*window.WindowInfo) if !ok { - return nil, WindowGetOutput{}, corego.E("mcp.window", "unexpected result type from window get query", nil) + return nil, WindowGetOutput{}, coreerr.E("mcp.windowGet", "unexpected result type", nil) } return nil, WindowGetOutput{Window: info}, nil } @@ -63,7 +64,7 @@ func (s *Subsystem) windowFocused(_ context.Context, _ *mcp.CallToolRequest, _ W } windows, ok := result.([]window.WindowInfo) if !ok { - return nil, WindowFocusedOutput{}, corego.E("mcp.window", "unexpected result type from window list query", nil) + return nil, WindowFocusedOutput{}, coreerr.E("mcp.windowFocused", "unexpected result type", nil) } for _, w := range windows { if w.Focused { @@ -105,7 +106,7 @@ func (s *Subsystem) windowCreate(_ context.Context, _ *mcp.CallToolRequest, inpu } info, ok := result.(window.WindowInfo) if !ok { - return nil, WindowCreateOutput{}, corego.E("mcp.window", "unexpected result type from window create task", nil) + return nil, WindowCreateOutput{}, coreerr.E("mcp.windowCreate", "unexpected result type", nil) } return nil, WindowCreateOutput{Window: info}, nil } @@ -258,6 +259,23 @@ func (s *Subsystem) windowFocus(_ context.Context, _ *mcp.CallToolRequest, input return nil, WindowFocusOutput{Success: true}, nil } +// --- focus_set --- + +type FocusSetInput struct { + Name string `json:"name"` +} +type FocusSetOutput struct { + Success bool `json:"success"` +} + +func (s *Subsystem) focusSet(ctx context.Context, req *mcp.CallToolRequest, input FocusSetInput) (*mcp.CallToolResult, FocusSetOutput, error) { + _, out, err := s.windowFocus(ctx, req, WindowFocusInput{Name: input.Name}) + if err != nil { + return nil, FocusSetOutput{}, err + } + return nil, FocusSetOutput{Success: out.Success}, nil +} + // --- window_title --- type WindowTitleInput struct { @@ -276,12 +294,6 @@ func (s *Subsystem) windowTitle(_ context.Context, _ *mcp.CallToolRequest, input return nil, WindowTitleOutput{Success: true}, nil } -// --- window_title_set --- - -func (s *Subsystem) windowTitleSet(ctx context.Context, req *mcp.CallToolRequest, input WindowTitleInput) (*mcp.CallToolResult, WindowTitleOutput, error) { - return s.windowTitle(ctx, req, input) -} - // --- window_title_get --- type WindowTitleGetInput struct { @@ -362,24 +374,6 @@ func (s *Subsystem) windowBackgroundColour(_ context.Context, _ *mcp.CallToolReq return nil, WindowBackgroundColourOutput{Success: true}, nil } -// --- window_opacity --- - -type WindowOpacityInput struct { - Name string `json:"name"` - Opacity float32 `json:"opacity"` -} -type WindowOpacityOutput struct { - Success bool `json:"success"` -} - -func (s *Subsystem) windowOpacity(_ context.Context, _ *mcp.CallToolRequest, input WindowOpacityInput) (*mcp.CallToolResult, WindowOpacityOutput, error) { - _, _, err := s.core.PERFORM(window.TaskSetOpacity{Name: input.Name, Opacity: input.Opacity}) - if err != nil { - return nil, WindowOpacityOutput{}, err - } - return nil, WindowOpacityOutput{Success: true}, nil -} - // --- window_fullscreen --- type WindowFullscreenInput struct { @@ -398,6 +392,94 @@ func (s *Subsystem) windowFullscreen(_ context.Context, _ *mcp.CallToolRequest, return nil, WindowFullscreenOutput{Success: true}, nil } +type arrangedPair struct { + First screen.Rect + Second screen.Rect +} + +func (s *Subsystem) arrangePairOnScreen(firstName, secondName string, scr *screen.Screen, orientation string) (arrangedPair, error) { + workArea := workAreaRect(scr) + if workArea.Width == 0 || workArea.Height == 0 { + return arrangedPair{}, coreerr.E("mcp.arrangePairOnScreen", "screen work area is empty", nil) + } + if orientation == "" { + if workArea.Width >= workArea.Height { + orientation = "horizontal" + } else { + orientation = "vertical" + } + } + + var firstRect screen.Rect + var secondRect screen.Rect + switch orientation { + case "vertical", "stacked": + firstHeight := workArea.Height / 2 + firstRect = screen.Rect{X: workArea.X, Y: workArea.Y, Width: workArea.Width, Height: firstHeight} + secondRect = screen.Rect{X: workArea.X, Y: workArea.Y + firstHeight, Width: workArea.Width, Height: workArea.Height - firstHeight} + default: + firstWidth := workArea.Width / 2 + firstRect = screen.Rect{X: workArea.X, Y: workArea.Y, Width: firstWidth, Height: workArea.Height} + secondRect = screen.Rect{X: workArea.X + firstWidth, Y: workArea.Y, Width: workArea.Width - firstWidth, Height: workArea.Height} + } + + if err := applyRect(s.core, firstName, firstRect); err != nil { + return arrangedPair{}, err + } + if err := applyRect(s.core, secondName, secondRect); err != nil { + return arrangedPair{}, err + } + return arrangedPair{First: firstRect, Second: secondRect}, nil +} + +// --- window_arrange_pair --- + +type WindowArrangePairInput struct { + First string `json:"first"` + Second string `json:"second"` + ScreenID string `json:"screenId,omitempty"` + Orientation string `json:"orientation,omitempty"` +} +type WindowArrangePairOutput struct { + FirstBounds screen.Rect `json:"firstBounds"` + SecondBounds screen.Rect `json:"secondBounds"` +} + +func (s *Subsystem) windowArrangePair(_ context.Context, _ *mcp.CallToolRequest, input WindowArrangePairInput) (*mcp.CallToolResult, WindowArrangePairOutput, error) { + screens, err := s.allScreens() + if err != nil { + return nil, WindowArrangePairOutput{}, err + } + windows, err := s.allWindows() + if err != nil { + return nil, WindowArrangePairOutput{}, err + } + + var targetScreen *screen.Screen + if input.ScreenID != "" { + targetScreen = chooseScreenByIDOrPrimary(screens, input.ScreenID) + } else { + for _, info := range windows { + if info.Name == input.First { + targetScreen = screenForWindowInfo(screens, info) + break + } + } + if targetScreen == nil { + targetScreen = chooseScreenByIDOrPrimary(screens, "") + } + } + if targetScreen == nil { + return nil, WindowArrangePairOutput{}, coreerr.E("mcp.windowArrangePair", "no screen available", nil) + } + + arranged, err := s.arrangePairOnScreen(input.First, input.Second, targetScreen, input.Orientation) + if err != nil { + return nil, WindowArrangePairOutput{}, err + } + return nil, WindowArrangePairOutput{FirstBounds: arranged.First, SecondBounds: arranged.Second}, nil +} + // --- Registration --- func (s *Subsystem) registerWindowTools(server *mcp.Server) { @@ -413,13 +495,12 @@ func (s *Subsystem) registerWindowTools(server *mcp.Server) { mcp.AddTool(server, &mcp.Tool{Name: "window_minimize", Description: "Minimise a window"}, s.windowMinimize) mcp.AddTool(server, &mcp.Tool{Name: "window_restore", Description: "Restore a maximised or minimised window"}, s.windowRestore) mcp.AddTool(server, &mcp.Tool{Name: "window_focus", Description: "Bring a window to the front"}, s.windowFocus) - mcp.AddTool(server, &mcp.Tool{Name: "focus_set", Description: "Alias for window_focus"}, s.windowFocus) + mcp.AddTool(server, &mcp.Tool{Name: "focus_set", Description: "Set focus to a specific window"}, s.focusSet) mcp.AddTool(server, &mcp.Tool{Name: "window_title", Description: "Set the title of a window"}, s.windowTitle) - mcp.AddTool(server, &mcp.Tool{Name: "window_title_set", Description: "Alias for window_title"}, s.windowTitleSet) mcp.AddTool(server, &mcp.Tool{Name: "window_title_get", Description: "Get the title of a window"}, s.windowTitleGet) mcp.AddTool(server, &mcp.Tool{Name: "window_visibility", Description: "Show or hide a window"}, s.windowVisibility) mcp.AddTool(server, &mcp.Tool{Name: "window_always_on_top", Description: "Pin a window above others"}, s.windowAlwaysOnTop) mcp.AddTool(server, &mcp.Tool{Name: "window_background_colour", Description: "Set a window background colour"}, s.windowBackgroundColour) - mcp.AddTool(server, &mcp.Tool{Name: "window_opacity", Description: "Set a window opacity"}, s.windowOpacity) mcp.AddTool(server, &mcp.Tool{Name: "window_fullscreen", Description: "Set a window to fullscreen mode"}, s.windowFullscreen) + mcp.AddTool(server, &mcp.Tool{Name: "window_arrange_pair", Description: "Arrange two windows side-by-side or stacked on a screen"}, s.windowArrangePair) } diff --git a/pkg/menu/menu.go b/pkg/menu/menu.go index e429fe1d..8841cdad 100644 --- a/pkg/menu/menu.go +++ b/pkg/menu/menu.go @@ -22,13 +22,13 @@ type Manager struct { } // NewManager creates a menu Manager. -// Use: mgr := menu.NewManager(platform) +// menu.NewManager(menu.NewWailsPlatform(app)).SetApplicationMenu([]menu.MenuItem{{Label: "File"}}) func NewManager(platform Platform) *Manager { return &Manager{platform: platform} } // Build constructs a PlatformMenu from a tree of MenuItems. -// Use: built := mgr.Build([]menu.MenuItem{{Label: "File"}}) +// menu.NewManager(menu.NewWailsPlatform(app)).Build([]menu.MenuItem{{Label: "File"}}) func (m *Manager) Build(items []MenuItem) PlatformMenu { menu := m.platform.NewMenu() m.buildItems(menu, items) @@ -64,7 +64,7 @@ func (m *Manager) buildItems(menu PlatformMenu, items []MenuItem) { } // SetApplicationMenu builds and sets the application menu. -// Use: mgr.SetApplicationMenu([]menu.MenuItem{{Label: "Quit"}}) +// menu.NewManager(menu.NewWailsPlatform(app)).SetApplicationMenu([]menu.MenuItem{{Label: "File"}}) func (m *Manager) SetApplicationMenu(items []MenuItem) { menu := m.Build(items) m.platform.SetApplicationMenu(menu) diff --git a/pkg/menu/messages.go b/pkg/menu/messages.go index bd4eb401..96430175 100644 --- a/pkg/menu/messages.go +++ b/pkg/menu/messages.go @@ -1,17 +1,10 @@ // pkg/menu/messages.go package menu -// QueryConfig requests this service's config section from the display orchestrator. -// Result: map[string]any type QueryConfig struct{} -// QueryGetAppMenu returns the current app menu item descriptors. -// Result: []MenuItem type QueryGetAppMenu struct{} -// TaskSetAppMenu sets the application menu. OnClick closures work because -// core/go IPC is in-process (no serialisation boundary). type TaskSetAppMenu struct{ Items []MenuItem } -// TaskSaveConfig persists this service's config section via the display orchestrator. -type TaskSaveConfig struct{ Value map[string]any } +type TaskSaveConfig struct{ Config map[string]any } diff --git a/pkg/menu/register.go b/pkg/menu/register.go index 4138debf..76094d37 100644 --- a/pkg/menu/register.go +++ b/pkg/menu/register.go @@ -3,7 +3,8 @@ package menu import "forge.lthn.ai/core/go/pkg/core" -// Register creates a factory closure that captures the Platform adapter. +// Register(p) binds the menu service to a Core instance. +// core.WithService(menu.Register(wailsMenu)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ diff --git a/pkg/menu/service.go b/pkg/menu/service.go index 80281495..776efcc2 100644 --- a/pkg/menu/service.go +++ b/pkg/menu/service.go @@ -7,24 +7,21 @@ import ( "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the menu service. type Options struct{} -// Service is a core.Service managing application menus via IPC. type Service struct { *core.ServiceRuntime[Options] manager *Manager platform Platform - items []MenuItem // last-set menu items for QueryGetAppMenu + menuItems []MenuItem showDevTools bool } -// OnStartup queries config and registers IPC handlers. func (s *Service) OnStartup(ctx context.Context) error { - cfg, handled, _ := s.Core().QUERY(QueryConfig{}) + configValue, handled, _ := s.Core().QUERY(QueryConfig{}) if handled { - if mCfg, ok := cfg.(map[string]any); ok { - s.applyConfig(mCfg) + if menuConfig, ok := configValue.(map[string]any); ok { + s.applyConfig(menuConfig) } } s.Core().RegisterQuery(s.handleQuery) @@ -32,20 +29,18 @@ func (s *Service) OnStartup(ctx context.Context) error { return nil } -func (s *Service) applyConfig(cfg map[string]any) { - if v, ok := cfg["show_dev_tools"]; ok { +func (s *Service) applyConfig(configData map[string]any) { + if v, ok := configData["show_dev_tools"]; ok { if show, ok := v.(bool); ok { s.showDevTools = show } } } -// ShowDevTools returns whether developer tools menu items should be shown. func (s *Service) ShowDevTools() bool { return s.showDevTools } -// HandleIPCEvents is auto-discovered and registered by core.WithService. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -53,7 +48,7 @@ func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { switch q.(type) { case QueryGetAppMenu: - return s.items, true, nil + return s.menuItems, true, nil default: return nil, false, nil } @@ -62,7 +57,7 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { case TaskSetAppMenu: - s.items = t.Items + s.menuItems = t.Items s.manager.SetApplicationMenu(t.Items) return nil, true, nil default: @@ -70,7 +65,6 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { } } -// Manager returns the underlying menu Manager. func (s *Service) Manager() *Manager { return s.manager } diff --git a/pkg/notification/messages.go b/pkg/notification/messages.go index 935e8317..df7b60c6 100644 --- a/pkg/notification/messages.go +++ b/pkg/notification/messages.go @@ -1,17 +1,37 @@ -// pkg/notification/messages.go package notification -// QueryPermission checks notification authorisation. Result: PermissionStatus +// QueryPermission returns current notification permission status. Result: PermissionStatus type QueryPermission struct{} -// TaskSend sends a notification. Falls back to dialog if platform fails. -type TaskSend struct{ Opts NotificationOptions } +// TaskSend sends a native notification, falling back to dialog on failure. +type TaskSend struct{ Options NotificationOptions } -// TaskRequestPermission requests notification authorisation. Result: bool (granted) +// TaskRequestPermission requests notification permission from the OS. Result: bool (granted) type TaskRequestPermission struct{} -// TaskClear clears pending notifications when the backend supports it. -type TaskClear struct{} +// TaskRevokePermission revokes previously granted notification permission. +// Result: nil +// _, _, err := c.PERFORM(TaskRevokePermission{}) +type TaskRevokePermission struct{} -// ActionNotificationClicked is broadcast when a notification is clicked. +// TaskRegisterCategory registers a notification category with its action buttons. +// Must be called before sending notifications that use that category. +// _, _, err := c.PERFORM(TaskRegisterCategory{Category: NotificationCategory{ID: "message", Actions: [...]}}) +type TaskRegisterCategory struct{ Category NotificationCategory } + +// TaskClear removes a notification by ID. An empty ID clears all notifications if supported. +type TaskClear struct{ ID string } + +// ActionNotificationClicked is broadcast when the user clicks a notification. type ActionNotificationClicked struct{ ID string } + +// ActionNotificationActionTriggered is broadcast when the user taps an action button on a notification. +type ActionNotificationActionTriggered struct { + NotificationID string `json:"notificationId"` + ActionID string `json:"actionId"` +} + +// ActionNotificationDismissed is broadcast when the user dismisses a notification without acting on it. +type ActionNotificationDismissed struct { + NotificationID string `json:"notificationId"` +} diff --git a/pkg/notification/platform.go b/pkg/notification/platform.go index cb616ba4..1006b9f4 100644 --- a/pkg/notification/platform.go +++ b/pkg/notification/platform.go @@ -3,9 +3,16 @@ package notification // Platform abstracts the native notification backend. type Platform interface { - Send(opts NotificationOptions) error + Send(options NotificationOptions) error RequestPermission() (bool, error) CheckPermission() (bool, error) + RevokePermission() error + RegisterCategory(category NotificationCategory) error +} + +// ClearPlatform is an optional extension for removing notifications. +type ClearPlatform interface { + Clear(id string) error } // NotificationAction represents an interactive notification action. @@ -25,12 +32,13 @@ const ( // NotificationOptions contains options for sending a notification. type NotificationOptions struct { - ID string `json:"id,omitempty"` - Title string `json:"title"` - Message string `json:"message"` - Subtitle string `json:"subtitle,omitempty"` - Severity NotificationSeverity `json:"severity,omitempty"` - Actions []NotificationAction `json:"actions,omitempty"` + ID string `json:"id,omitempty"` + Title string `json:"title"` + Message string `json:"message"` + Subtitle string `json:"subtitle,omitempty"` + Severity NotificationSeverity `json:"severity,omitempty"` + CategoryID string `json:"categoryId,omitempty"` + Actions []NotificationAction `json:"actions,omitempty"` } // PermissionStatus indicates whether notifications are authorised. @@ -38,10 +46,15 @@ type PermissionStatus struct { Granted bool `json:"granted"` } -type clearer interface { - Clear() error +// NotificationAction describes a tappable action button on a notification. +type NotificationAction struct { + ID string `json:"id"` + Title string `json:"title"` } -type actionSender interface { - SendWithActions(opts NotificationOptions) error +// NotificationCategory groups a set of actions that can appear on notifications. +// Register categories on startup so the OS knows the available action buttons. +type NotificationCategory struct { + ID string `json:"id"` + Actions []NotificationAction `json:"actions"` } diff --git a/pkg/notification/service.go b/pkg/notification/service.go index b15afe5d..0e9c1935 100644 --- a/pkg/notification/service.go +++ b/pkg/notification/service.go @@ -3,26 +3,20 @@ package notification import ( "context" + "strconv" "time" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/dialog" + coreerr "forge.lthn.ai/core/go-log" "forge.lthn.ai/core/go/pkg/core" ) -// Options configures the notification service. -// Use: core.WithService(notification.Register(platform)) type Options struct{} -// Service manages notifications via Core tasks and queries. -// Use: svc := ¬ification.Service{} type Service struct { *core.ServiceRuntime[Options] platform Platform } -// Register creates a Core service factory for the notification backend. -// Use: core.New(core.WithService(notification.Register(platform))) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ @@ -32,15 +26,12 @@ func Register(p Platform) func(*core.Core) (any, error) { } } -// OnStartup registers notification handlers with Core. -// Use: _ = svc.OnStartup(context.Background()) func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterQuery(s.handleQuery) s.Core().RegisterTask(s.handleTask) return nil } -// HandleIPCEvents satisfies Core's IPC hook. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -58,47 +49,58 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { case TaskSend: - return nil, true, s.sendNotification(t.Opts) + return nil, true, s.send(t.Options) case TaskRequestPermission: granted, err := s.platform.RequestPermission() return granted, true, err + case TaskRevokePermission: + return nil, true, s.platform.RevokePermission() + case TaskRegisterCategory: + return nil, true, s.platform.RegisterCategory(t.Category) case TaskClear: - if clr, ok := s.platform.(clearer); ok { - return nil, true, clr.Clear() + clearPlatform, ok := s.platform.(ClearPlatform) + if !ok { + return nil, true, coreerr.E("notification.handleTask", "notification clearing is not supported by this platform", nil) } - return nil, true, nil + return nil, true, clearPlatform.Clear(t.ID) default: return nil, false, nil } } -// sendNotification attempts a native notification and falls back to a dialog via IPC. -func (s *Service) sendNotification(opts NotificationOptions) error { - // Generate an ID when the caller does not provide one. - if opts.ID == "" { - opts.ID = corego.Sprintf("core-%d", time.Now().UnixNano()) +// send attempts native notification, falls back to dialog via IPC. +func (s *Service) send(options NotificationOptions) error { + // Generate ID if not provided + if options.ID == "" { + options.ID = "core-" + strconv.FormatInt(time.Now().UnixNano(), 10) } - if len(opts.Actions) > 0 { - if sender, ok := s.platform.(actionSender); ok { - if err := sender.SendWithActions(opts); err == nil { - return nil - } + if len(options.Actions) > 0 { + categoryID := options.CategoryID + if categoryID == "" { + categoryID = options.ID } + if err := s.platform.RegisterCategory(NotificationCategory{ + ID: categoryID, + Actions: options.Actions, + }); err != nil { + return err + } + options.CategoryID = categoryID } - if err := s.platform.Send(opts); err != nil { - // Fall back to a dialog when the native notification fails. - return s.showFallbackDialog(opts) + if err := s.platform.Send(options); err != nil { + // Fallback: show as dialog via IPC + return s.fallbackDialog(options) } return nil } -// showFallbackDialog shows a dialog via IPC when native notifications fail. -func (s *Service) showFallbackDialog(opts NotificationOptions) error { - // Map severity to dialog type. +// fallbackDialog shows a dialog via IPC when native notifications fail. +func (s *Service) fallbackDialog(options NotificationOptions) error { + // Map severity to dialog type var dt dialog.DialogType - switch opts.Severity { + switch options.Severity { case SeverityWarning: dt = dialog.DialogWarning case SeverityError: @@ -107,15 +109,15 @@ func (s *Service) showFallbackDialog(opts NotificationOptions) error { dt = dialog.DialogInfo } - msg := opts.Message - if opts.Subtitle != "" { - msg = opts.Subtitle + "\n\n" + msg + msg := options.Message + if options.Subtitle != "" { + msg = options.Subtitle + "\n\n" + msg } _, _, err := s.Core().PERFORM(dialog.TaskMessageDialog{ - Opts: dialog.MessageDialogOptions{ + Options: dialog.MessageDialogOptions{ Type: dt, - Title: opts.Title, + Title: options.Title, Message: msg, Buttons: []string{"OK"}, }, diff --git a/pkg/notification/service_test.go b/pkg/notification/service_test.go index 5cab891d..1b9d5c92 100644 --- a/pkg/notification/service_test.go +++ b/pkg/notification/service_test.go @@ -13,12 +13,19 @@ import ( ) type mockPlatform struct { - sendErr error - permGranted bool - permErr error - lastOpts NotificationOptions - sendCalled bool - clearCalled bool + sendErr error + permGranted bool + permErr error + revokeErr error + registerCategoryErr error + clearErr error + lastOpts NotificationOptions + lastCategory NotificationCategory + sendCalled bool + revokeCalled bool + registerCategoryCalled bool + clearCalled bool + lastClearedID string } func (m *mockPlatform) Send(opts NotificationOptions) error { @@ -33,7 +40,20 @@ func (m *mockPlatform) SendWithActions(opts NotificationOptions) error { } func (m *mockPlatform) RequestPermission() (bool, error) { return m.permGranted, m.permErr } func (m *mockPlatform) CheckPermission() (bool, error) { return m.permGranted, m.permErr } -func (m *mockPlatform) Clear() error { m.clearCalled = true; return nil } +func (m *mockPlatform) RevokePermission() error { + m.revokeCalled = true + return m.revokeErr +} +func (m *mockPlatform) RegisterCategory(category NotificationCategory) error { + m.registerCategoryCalled = true + m.lastCategory = category + return m.registerCategoryErr +} +func (m *mockPlatform) Clear(id string) error { + m.clearCalled = true + m.lastClearedID = id + return m.clearErr +} // mockDialogPlatform tracks whether MessageDialog was called (for fallback test). type mockDialogPlatform struct { @@ -73,7 +93,7 @@ func TestRegister_Good(t *testing.T) { func TestTaskSend_Good(t *testing.T) { mock, c := newTestService(t) _, handled, err := c.PERFORM(TaskSend{ - Opts: NotificationOptions{Title: "Test", Message: "Hello"}, + Options: NotificationOptions{Title: "Test", Message: "Hello"}, }) require.NoError(t, err) assert.True(t, handled) @@ -94,7 +114,7 @@ func TestTaskSend_Fallback_Good(t *testing.T) { require.NoError(t, c.ServiceStartup(context.Background(), nil)) _, handled, err := c.PERFORM(TaskSend{ - Opts: NotificationOptions{Title: "Warn", Message: "Oops", Severity: SeverityWarning}, + Options: NotificationOptions{Title: "Warn", Message: "Oops", Severity: SeverityWarning}, }) assert.True(t, handled) assert.NoError(t, err) // fallback succeeds even though platform failed @@ -125,25 +145,117 @@ func TestTaskSend_Bad(t *testing.T) { assert.False(t, handled) } -func TestTaskSend_WithActions_Good(t *testing.T) { +func TestTaskRevokePermission_Good(t *testing.T) { mock, c := newTestService(t) + _, handled, err := c.PERFORM(TaskRevokePermission{}) + require.NoError(t, err) + assert.True(t, handled) + assert.True(t, mock.revokeCalled) +} + +func TestTaskRevokePermission_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskRevokePermission{}) + assert.False(t, handled) +} + +func TestTaskRegisterCategory_Good(t *testing.T) { + mock, c := newTestService(t) + category := NotificationCategory{ + ID: "message", + Actions: []NotificationAction{ + {ID: "reply", Title: "Reply"}, + {ID: "dismiss", Title: "Dismiss"}, + }, + } + + _, handled, err := c.PERFORM(TaskRegisterCategory{Category: category}) + require.NoError(t, err) + assert.True(t, handled) + assert.True(t, mock.registerCategoryCalled) + assert.Equal(t, "message", mock.lastCategory.ID) + assert.Len(t, mock.lastCategory.Actions, 2) + assert.Equal(t, "reply", mock.lastCategory.Actions[0].ID) +} + +func TestTaskRegisterCategory_Bad_NoService(t *testing.T) { + c, _ := core.New(core.WithServiceLock()) + _, handled, _ := c.PERFORM(TaskRegisterCategory{}) + assert.False(t, handled) +} + +func TestTaskSendWithActions_Good(t *testing.T) { + mock, c := newTestService(t) + _, handled, err := c.PERFORM(TaskSend{ - Opts: NotificationOptions{ - Title: "Test", - Message: "Hello", - Actions: []NotificationAction{{ID: "ok", Label: "OK"}}, + Options: NotificationOptions{ + Title: "Message", + Message: "Reply?", + Actions: []NotificationAction{ + {ID: "reply", Title: "Reply"}, + {ID: "dismiss", Title: "Dismiss"}, + }, }, }) require.NoError(t, err) assert.True(t, handled) - assert.True(t, mock.sendCalled) - assert.Len(t, mock.lastOpts.Actions, 1) + assert.True(t, mock.registerCategoryCalled) + assert.Len(t, mock.lastCategory.Actions, 2) + assert.NotEmpty(t, mock.lastOpts.CategoryID) } func TestTaskClear_Good(t *testing.T) { mock, c := newTestService(t) - _, handled, err := c.PERFORM(TaskClear{}) + + _, handled, err := c.PERFORM(TaskClear{ID: "notif-1"}) require.NoError(t, err) assert.True(t, handled) assert.True(t, mock.clearCalled) + assert.Equal(t, "notif-1", mock.lastClearedID) +} + +func TestActionNotificationActionTriggered_Ugly(t *testing.T) { + // Verify the action structs are distinct types. + var triggered ActionNotificationActionTriggered + var dismissed ActionNotificationDismissed + triggered.NotificationID = "n1" + triggered.ActionID = "reply" + dismissed.NotificationID = "n1" + assert.Equal(t, "n1", triggered.NotificationID) + assert.Equal(t, "reply", triggered.ActionID) + assert.Equal(t, "n1", dismissed.NotificationID) +} + +func TestActionNotificationDismissed_Good(t *testing.T) { + _, c := newTestService(t) + + var received *ActionNotificationDismissed + c.RegisterAction(func(_ *core.Core, msg core.Message) error { + if a, ok := msg.(ActionNotificationDismissed); ok { + received = &a + } + return nil + }) + + // Broadcast dismissed action directly (as the platform adapter would). + _ = c.ACTION(ActionNotificationDismissed{NotificationID: "notif-42"}) + require.NotNil(t, received) + assert.Equal(t, "notif-42", received.NotificationID) +} + +func TestActionNotificationActionTriggered_Good(t *testing.T) { + _, c := newTestService(t) + + var received *ActionNotificationActionTriggered + c.RegisterAction(func(_ *core.Core, msg core.Message) error { + if a, ok := msg.(ActionNotificationActionTriggered); ok { + received = &a + } + return nil + }) + + _ = c.ACTION(ActionNotificationActionTriggered{NotificationID: "notif-7", ActionID: "archive"}) + require.NotNil(t, received) + assert.Equal(t, "notif-7", received.NotificationID) + assert.Equal(t, "archive", received.ActionID) } diff --git a/pkg/screen/messages.go b/pkg/screen/messages.go index cd9195d1..d99085ad 100644 --- a/pkg/screen/messages.go +++ b/pkg/screen/messages.go @@ -9,6 +9,10 @@ type QueryAll struct{} // Use: result, _, err := c.QUERY(screen.QueryPrimary{}) type QueryPrimary struct{} +// QueryCurrent returns the screen currently in use (e.g. containing the focused window). +// Result: *Screen (nil if not determinable) +type QueryCurrent struct{} + // QueryByID returns a screen by ID. Result: *Screen (nil if not found) // Use: result, _, err := c.QUERY(screen.QueryByID{ID: "display-1"}) type QueryByID struct{ ID string } diff --git a/pkg/screen/platform.go b/pkg/screen/platform.go index 59c63244..fd4bcf25 100644 --- a/pkg/screen/platform.go +++ b/pkg/screen/platform.go @@ -6,6 +6,7 @@ package screen type Platform interface { GetAll() []Screen GetPrimary() *Screen + GetCurrent() *Screen } // Screen describes a display/monitor. @@ -30,9 +31,61 @@ type Rect struct { Height int `json:"height"` } +// Contains reports whether the point (x, y) lies within the rectangle. +// +// if rect.Contains(mouseX, mouseY) { handleClick() } +func (r Rect) Contains(x, y int) bool { + return x >= r.X && x < r.X+r.Width && y >= r.Y && y < r.Y+r.Height +} + +// Overlaps reports whether the rectangle r overlaps with other. +// +// if bounds.Overlaps(workArea) { show() } +func (r Rect) Overlaps(other Rect) bool { + return r.X < other.X+other.Width && + r.X+r.Width > other.X && + r.Y < other.Y+other.Height && + r.Y+r.Height > other.Y +} + +// Center returns the centre point of the rectangle. +// +// cx, cy := rect.Center() +func (r Rect) Center() (x, y int) { + return r.X + r.Width/2, r.Y + r.Height/2 +} + // Size represents dimensions. // Use: size := screen.Size{Width: 1920, Height: 1080} type Size struct { Width int `json:"width"` Height int `json:"height"` } + +// ScreenPlacement describes a desired window position relative to a screen. +// +// p := screen.ScreenPlacement{ScreenID: "1", X: 100, Y: 200, Width: 800, Height: 600} +// p.Apply(platformWindow) +type ScreenPlacement struct { + ScreenID string `json:"screenId"` + X int `json:"x"` + Y int `json:"y"` + Width int `json:"width"` + Height int `json:"height"` +} + +// Placer is implemented by platform windows that can be repositioned. +type Placer interface { + SetPosition(x, y int) + SetSize(width, height int) +} + +// Apply positions and sizes the given Placer according to the placement. +// +// placement.Apply(pw) +func (p ScreenPlacement) Apply(target Placer) { + if p.Width > 0 && p.Height > 0 { + target.SetSize(p.Width, p.Height) + } + target.SetPosition(p.X, p.Y) +} diff --git a/pkg/screen/service.go b/pkg/screen/service.go index e81fc181..b0e51542 100644 --- a/pkg/screen/service.go +++ b/pkg/screen/service.go @@ -7,19 +7,15 @@ import ( "forge.lthn.ai/core/go/pkg/core" ) -// Options holds configuration for the screen service. -// Use: svc, err := screen.Register(platform)(core.New()) type Options struct{} -// Service is a core.Service providing screen/display queries via IPC. -// Use: svc, err := screen.Register(platform)(core.New()) type Service struct { *core.ServiceRuntime[Options] platform Platform } -// Register creates a factory closure that captures the Platform adapter. -// Use: core.WithService(screen.Register(platform)) +// Register(p) binds the screen service to a Core instance. +// core.WithService(screen.Register(wailsScreen)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ @@ -29,15 +25,11 @@ func Register(p Platform) func(*core.Core) (any, error) { } } -// OnStartup registers IPC handlers. -// Use: _ = svc.OnStartup(context.Background()) func (s *Service) OnStartup(ctx context.Context) error { s.Core().RegisterQuery(s.handleQuery) return nil } -// HandleIPCEvents is auto-discovered by core.WithService. -// Use: _ = svc.HandleIPCEvents(core, msg) func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -48,6 +40,8 @@ func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { return s.platform.GetAll(), true, nil case QueryPrimary: return s.platform.GetPrimary(), true, nil + case QueryCurrent: + return s.platform.GetCurrent(), true, nil case QueryByID: return s.queryByID(q.ID), true, nil case QueryAtPoint: diff --git a/pkg/screen/service_test.go b/pkg/screen/service_test.go index 56c08335..7dcb93e7 100644 --- a/pkg/screen/service_test.go +++ b/pkg/screen/service_test.go @@ -12,6 +12,7 @@ import ( type mockPlatform struct { screens []Screen + current *Screen } func (m *mockPlatform) GetAll() []Screen { return m.screens } @@ -23,6 +24,7 @@ func (m *mockPlatform) GetPrimary() *Screen { } return nil } +func (m *mockPlatform) GetCurrent() *Screen { return m.current } func newTestService(t *testing.T) (*mockPlatform, *core.Core) { t.Helper() @@ -130,3 +132,127 @@ func TestQueryWorkAreas_Good(t *testing.T) { assert.Len(t, areas, 2) assert.Equal(t, 38, areas[0].Y) // primary has menu bar offset } + +// --- QueryCurrent --- + +func TestQueryCurrent_Good(t *testing.T) { + mock, c := newTestService(t) + mock.current = &mock.screens[1] // set "External" as current + + result, handled, err := c.QUERY(QueryCurrent{}) + require.NoError(t, err) + assert.True(t, handled) + scr := result.(*Screen) + require.NotNil(t, scr) + assert.Equal(t, "External", scr.Name) +} + +func TestQueryCurrent_Bad_NilWhenNoCurrentScreen(t *testing.T) { + // current is nil by default + _, c := newTestService(t) + result, handled, err := c.QUERY(QueryCurrent{}) + require.NoError(t, err) + assert.True(t, handled) + assert.Nil(t, result) +} + +func TestQueryCurrent_Ugly_NoServiceRegistered(t *testing.T) { + c, err := core.New(core.WithServiceLock()) + require.NoError(t, err) + _, handled, _ := c.QUERY(QueryCurrent{}) + assert.False(t, handled) +} + +// --- Rect geometry helpers --- + +func TestRect_Contains_Good(t *testing.T) { + r := Rect{X: 100, Y: 100, Width: 200, Height: 150} + assert.True(t, r.Contains(100, 100)) // top-left corner (inclusive) + assert.True(t, r.Contains(200, 175)) // centre + assert.True(t, r.Contains(299, 249)) // bottom-right corner (exclusive boundary - 1) +} + +func TestRect_Contains_Bad(t *testing.T) { + r := Rect{X: 100, Y: 100, Width: 200, Height: 150} + assert.False(t, r.Contains(99, 100)) // just left + assert.False(t, r.Contains(100, 99)) // just above + assert.False(t, r.Contains(300, 200)) // right boundary (exclusive) + assert.False(t, r.Contains(200, 250)) // bottom boundary (exclusive) +} + +func TestRect_Center_Good(t *testing.T) { + r := Rect{X: 0, Y: 0, Width: 200, Height: 100} + cx, cy := r.Center() + assert.Equal(t, 100, cx) + assert.Equal(t, 50, cy) +} + +func TestRect_Center_Ugly_OddDimensions(t *testing.T) { + r := Rect{X: 1, Y: 1, Width: 101, Height: 51} + cx, cy := r.Center() + assert.Equal(t, 51, cx) // integer division: 1 + 101/2 = 1 + 50 = 51 + assert.Equal(t, 26, cy) // 1 + 51/2 = 1 + 25 = 26 +} + +func TestRect_Overlaps_Good(t *testing.T) { + a := Rect{X: 0, Y: 0, Width: 200, Height: 200} + b := Rect{X: 100, Y: 100, Width: 200, Height: 200} + assert.True(t, a.Overlaps(b)) + assert.True(t, b.Overlaps(a)) +} + +func TestRect_Overlaps_Bad(t *testing.T) { + a := Rect{X: 0, Y: 0, Width: 100, Height: 100} + b := Rect{X: 200, Y: 200, Width: 100, Height: 100} + assert.False(t, a.Overlaps(b)) +} + +func TestRect_Overlaps_Ugly_AdjacentEdge(t *testing.T) { + // touching at edge — not overlapping (exclusive right/bottom boundary) + a := Rect{X: 0, Y: 0, Width: 100, Height: 100} + b := Rect{X: 100, Y: 0, Width: 100, Height: 100} + assert.False(t, a.Overlaps(b)) +} + +// --- ScreenPlacement --- + +type mockPlacer struct { + x, y int + width, height int +} + +func (m *mockPlacer) SetPosition(x, y int) { m.x = x; m.y = y } +func (m *mockPlacer) SetSize(width, height int) { m.width = width; m.height = height } + +func TestScreenPlacement_Apply_Good(t *testing.T) { + p := ScreenPlacement{ScreenID: "1", X: 50, Y: 75, Width: 800, Height: 600} + placer := &mockPlacer{} + p.Apply(placer) + assert.Equal(t, 50, placer.x) + assert.Equal(t, 75, placer.y) + assert.Equal(t, 800, placer.width) + assert.Equal(t, 600, placer.height) +} + +func TestScreenPlacement_Apply_Bad_ZeroDimensions(t *testing.T) { + // Zero dimensions should skip SetSize but still call SetPosition + p := ScreenPlacement{ScreenID: "1", X: 100, Y: 200, Width: 0, Height: 0} + placer := &mockPlacer{width: 1280, height: 800} + p.Apply(placer) + assert.Equal(t, 100, placer.x) + assert.Equal(t, 200, placer.y) + // Size should remain unchanged when both dimensions are zero + assert.Equal(t, 1280, placer.width) + assert.Equal(t, 800, placer.height) +} + +func TestScreenPlacement_Apply_Ugly_NegativeCoords(t *testing.T) { + // Negative coordinates are valid (multi-monitor setups with negative origin) + p := ScreenPlacement{ScreenID: "2", X: -1920, Y: 0, Width: 1920, Height: 1080} + placer := &mockPlacer{} + p.Apply(placer) + assert.Equal(t, -1920, placer.x) + assert.Equal(t, 0, placer.y) + assert.Equal(t, 1920, placer.width) + assert.Equal(t, 1080, placer.height) +} diff --git a/pkg/systray/menu.go b/pkg/systray/menu.go index 32ee3603..ec977647 100644 --- a/pkg/systray/menu.go +++ b/pkg/systray/menu.go @@ -1,28 +1,22 @@ // pkg/systray/menu.go package systray -import "forge.lthn.ai/core/go/pkg/core" +import coreerr "forge.lthn.ai/core/go-log" // SetMenu sets a dynamic menu on the tray from TrayMenuItem descriptors. // Use: _ = m.SetMenu([]TrayMenuItem{{Label: "Quit", ActionID: "quit"}}) func (m *Manager) SetMenu(items []TrayMenuItem) error { if m.tray == nil { - return core.E("systray.SetMenu", "tray not initialised", nil) + return coreerr.E("systray.SetMenu", "tray not initialised", nil) } - m.menuItems = append([]TrayMenuItem(nil), items...) - menu := m.buildMenu(items) + menu := m.platform.NewMenu() + m.buildMenu(menu, items) m.tray.SetMenu(menu) return nil } // buildMenu recursively builds a PlatformMenu from TrayMenuItem descriptors. -func (m *Manager) buildMenu(items []TrayMenuItem) PlatformMenu { - menu := m.platform.NewMenu() - m.buildMenuInto(menu, items) - return menu -} - -func (m *Manager) buildMenuInto(menu PlatformMenu, items []TrayMenuItem) { +func (m *Manager) buildMenu(menu PlatformMenu, items []TrayMenuItem) { for _, item := range items { if item.Type == "separator" { menu.AddSeparator() @@ -30,7 +24,7 @@ func (m *Manager) buildMenuInto(menu PlatformMenu, items []TrayMenuItem) { } if len(item.Submenu) > 0 { sub := menu.AddSubmenu(item.Label) - m.buildMenuInto(sub, item.Submenu) + m.buildMenu(sub, item.Submenu) continue } mi := menu.Add(item.Label) diff --git a/pkg/systray/messages.go b/pkg/systray/messages.go index 9507a889..79d82ef8 100644 --- a/pkg/systray/messages.go +++ b/pkg/systray/messages.go @@ -1,54 +1,27 @@ // pkg/systray/messages.go package systray -// QueryConfig requests this service's config section from the display orchestrator. -// Result: map[string]any -// Use: result, _, err := c.QUERY(systray.QueryConfig{}) type QueryConfig struct{} -// --- Tasks --- - -// TaskSetTrayIcon sets the tray icon. -// Use: _, _, err := c.PERFORM(systray.TaskSetTrayIcon{Data: iconBytes}) type TaskSetTrayIcon struct{ Data []byte } -// TaskSetTooltip updates the tray tooltip text. -// Use: _, _, err := c.PERFORM(systray.TaskSetTooltip{Tooltip: "Core is ready"}) -type TaskSetTooltip struct{ Tooltip string } +type TaskSetTrayTooltip struct{ Tooltip string } -// TaskSetLabel updates the tray label text. -// Use: _, _, err := c.PERFORM(systray.TaskSetLabel{Label: "Core"}) -type TaskSetLabel struct{ Label string } +type TaskSetTrayLabel struct{ Label string } -// TaskSetTrayMenu sets the tray menu items. -// Use: _, _, err := c.PERFORM(systray.TaskSetTrayMenu{Items: items}) type TaskSetTrayMenu struct{ Items []TrayMenuItem } -// TaskShowPanel shows the tray panel window. -// Use: _, _, err := c.PERFORM(systray.TaskShowPanel{}) -type TaskShowPanel struct{} - -// TaskHidePanel hides the tray panel window. -// Use: _, _, err := c.PERFORM(systray.TaskHidePanel{}) -type TaskHidePanel struct{} - -// TaskShowMessage shows a tray message or notification. -// Use: _, _, err := c.PERFORM(systray.TaskShowMessage{Title: "Core", Message: "Sync complete"}) type TaskShowMessage struct { Title string `json:"title"` Message string `json:"message"` } -// TaskSaveConfig persists this service's config section via the display orchestrator. -// Use: _, _, err := c.PERFORM(systray.TaskSaveConfig{Value: map[string]any{"tooltip": "Core"}}) -type TaskSaveConfig struct{ Value map[string]any } +type TaskShowPanel struct{} -// --- Actions --- +type TaskHidePanel struct{} + +type TaskSaveConfig struct{ Config map[string]any } -// ActionTrayClicked is broadcast when the tray icon is clicked. -// Use: _ = c.ACTION(systray.ActionTrayClicked{}) type ActionTrayClicked struct{} -// ActionTrayMenuItemClicked is broadcast when a tray menu item is clicked. -// Use: _ = c.ACTION(systray.ActionTrayMenuItemClicked{ActionID: "quit"}) type ActionTrayMenuItemClicked struct{ ActionID string } diff --git a/pkg/systray/mock_platform.go b/pkg/systray/mock_platform.go index 32e2362e..7cc955fd 100644 --- a/pkg/systray/mock_platform.go +++ b/pkg/systray/mock_platform.go @@ -22,16 +22,17 @@ type exportedMockTray struct { tooltip, label string } -func (t *exportedMockTray) SetIcon(data []byte) { t.icon = data } -func (t *exportedMockTray) SetTemplateIcon(data []byte) { t.templateIcon = data } -func (t *exportedMockTray) SetTooltip(text string) { t.tooltip = text } -func (t *exportedMockTray) SetLabel(text string) { t.label = text } -func (t *exportedMockTray) SetMenu(menu PlatformMenu) {} -func (t *exportedMockTray) AttachWindow(w WindowHandle) {} +func (t *exportedMockTray) SetIcon(data []byte) { t.icon = data } +func (t *exportedMockTray) SetTemplateIcon(data []byte) { t.templateIcon = data } +func (t *exportedMockTray) SetTooltip(text string) { t.tooltip = text } +func (t *exportedMockTray) SetLabel(text string) { t.label = text } +func (t *exportedMockTray) SetMenu(menu PlatformMenu) {} +func (t *exportedMockTray) AttachWindow(w WindowHandle) {} +func (t *exportedMockTray) ShowMessage(title, message string) error { return nil } type exportedMockMenu struct { - items []exportedMockMenuItem - submenus []*exportedMockMenu + items []exportedMockMenuItem + subs []*exportedMockMenu } func (m *exportedMockMenu) Add(label string) PlatformMenuItem { @@ -41,9 +42,9 @@ func (m *exportedMockMenu) Add(label string) PlatformMenuItem { } func (m *exportedMockMenu) AddSeparator() {} func (m *exportedMockMenu) AddSubmenu(label string) PlatformMenu { - sub := &exportedMockMenu{} m.items = append(m.items, exportedMockMenuItem{label: label}) - m.submenus = append(m.submenus, sub) + sub := &exportedMockMenu{} + m.subs = append(m.subs, sub) return sub } @@ -53,8 +54,7 @@ type exportedMockMenuItem struct { onClick func() } -func (mi *exportedMockMenuItem) SetTooltip(tip string) { mi.tooltip = tip } -func (mi *exportedMockMenuItem) SetChecked(checked bool) { mi.checked = checked } -func (mi *exportedMockMenuItem) SetEnabled(enabled bool) { mi.enabled = enabled } -func (mi *exportedMockMenuItem) OnClick(fn func()) { mi.onClick = fn } -func (mi *exportedMockMenuItem) AddSubmenu() PlatformMenu { return &exportedMockMenu{} } +func (mi *exportedMockMenuItem) SetTooltip(tip string) { mi.tooltip = tip } +func (mi *exportedMockMenuItem) SetChecked(checked bool) { mi.checked = checked } +func (mi *exportedMockMenuItem) SetEnabled(enabled bool) { mi.enabled = enabled } +func (mi *exportedMockMenuItem) OnClick(fn func()) { mi.onClick = fn } diff --git a/pkg/systray/mock_test.go b/pkg/systray/mock_test.go index 64dbc385..9ab2f1c4 100644 --- a/pkg/systray/mock_test.go +++ b/pkg/systray/mock_test.go @@ -21,8 +21,8 @@ func (p *mockPlatform) NewMenu() PlatformMenu { } type mockTrayMenu struct { - items []string - submenus []*mockTrayMenu + items []string + subs []*mockTrayMenu } func (m *mockTrayMenu) Add(label string) PlatformMenuItem { @@ -33,23 +33,24 @@ func (m *mockTrayMenu) AddSeparator() { m.items = append(m.items, "---") } func (m *mockTrayMenu) AddSubmenu(label string) PlatformMenu { m.items = append(m.items, label) sub := &mockTrayMenu{} - m.submenus = append(m.submenus, sub) + m.subs = append(m.subs, sub) return sub } type mockTrayMenuItem struct{} -func (mi *mockTrayMenuItem) SetTooltip(text string) {} -func (mi *mockTrayMenuItem) SetChecked(checked bool) {} -func (mi *mockTrayMenuItem) SetEnabled(enabled bool) {} -func (mi *mockTrayMenuItem) OnClick(fn func()) {} -func (mi *mockTrayMenuItem) AddSubmenu() PlatformMenu { return &mockTrayMenu{} } +func (mi *mockTrayMenuItem) SetTooltip(text string) {} +func (mi *mockTrayMenuItem) SetChecked(checked bool) {} +func (mi *mockTrayMenuItem) SetEnabled(enabled bool) {} +func (mi *mockTrayMenuItem) OnClick(fn func()) {} type mockTray struct { icon, templateIcon []byte tooltip, label string menu PlatformMenu attachedWindow WindowHandle + lastMessageTitle string + lastMessageBody string } func (t *mockTray) SetIcon(data []byte) { t.icon = data } @@ -58,3 +59,8 @@ func (t *mockTray) SetTooltip(text string) { t.tooltip = text } func (t *mockTray) SetLabel(text string) { t.label = text } func (t *mockTray) SetMenu(menu PlatformMenu) { t.menu = menu } func (t *mockTray) AttachWindow(w WindowHandle) { t.attachedWindow = w } +func (t *mockTray) ShowMessage(title, message string) error { + t.lastMessageTitle = title + t.lastMessageBody = message + return nil +} diff --git a/pkg/systray/platform.go b/pkg/systray/platform.go index 7c23929e..9ceb0ca6 100644 --- a/pkg/systray/platform.go +++ b/pkg/systray/platform.go @@ -17,6 +17,7 @@ type PlatformTray interface { SetLabel(text string) SetMenu(menu PlatformMenu) AttachWindow(w WindowHandle) + ShowMessage(title, message string) error } // PlatformMenu is a tray menu built by the backend. @@ -34,7 +35,6 @@ type PlatformMenuItem interface { SetChecked(checked bool) SetEnabled(enabled bool) OnClick(fn func()) - AddSubmenu() PlatformMenu } // WindowHandle is a cross-package interface for window operations. diff --git a/pkg/systray/register.go b/pkg/systray/register.go index 01b625f0..caa1d574 100644 --- a/pkg/systray/register.go +++ b/pkg/systray/register.go @@ -3,7 +3,8 @@ package systray import "forge.lthn.ai/core/go/pkg/core" -// Register creates a factory closure that captures the Platform adapter. +// Register(p) binds the systray service to a Core instance. +// core.WithService(systray.Register(wailsSystray)) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ diff --git a/pkg/systray/service.go b/pkg/systray/service.go index a690c58d..9715b03b 100644 --- a/pkg/systray/service.go +++ b/pkg/systray/service.go @@ -8,12 +8,8 @@ import ( "dappco.re/go/core/gui/pkg/notification" ) -// Options configures the systray service. -// Use: core.WithService(systray.Register(platform)) type Options struct{} -// Service manages system tray operations via Core tasks. -// Use: svc := &systray.Service{} type Service struct { *core.ServiceRuntime[Options] manager *Manager @@ -21,34 +17,31 @@ type Service struct { iconPath string } -// OnStartup loads tray config and registers task handlers. -// Use: _ = svc.OnStartup(context.Background()) func (s *Service) OnStartup(ctx context.Context) error { - cfg, handled, _ := s.Core().QUERY(QueryConfig{}) + configValue, handled, _ := s.Core().QUERY(QueryConfig{}) if handled { - if tCfg, ok := cfg.(map[string]any); ok { - s.applyConfig(tCfg) + if trayConfig, ok := configValue.(map[string]any); ok { + s.applyConfig(trayConfig) } } s.Core().RegisterTask(s.handleTask) return nil } -func (s *Service) applyConfig(cfg map[string]any) { - tooltip, _ := cfg["tooltip"].(string) +func (s *Service) applyConfig(configData map[string]any) { + tooltip, _ := configData["tooltip"].(string) if tooltip == "" { tooltip = "Core" } _ = s.manager.Setup(tooltip, tooltip) - if iconPath, ok := cfg["icon"].(string); ok && iconPath != "" { + if iconPath, ok := configData["icon"].(string); ok && iconPath != "" { // Icon loading is deferred to when assets are available. // Store the path for later use. s.iconPath = iconPath } } -// HandleIPCEvents satisfies Core's IPC hook. func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } @@ -57,12 +50,14 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { switch t := t.(type) { case TaskSetTrayIcon: return nil, true, s.manager.SetIcon(t.Data) - case TaskSetTooltip: + case TaskSetTrayTooltip: return nil, true, s.manager.SetTooltip(t.Tooltip) - case TaskSetLabel: + case TaskSetTrayLabel: return nil, true, s.manager.SetLabel(t.Label) case TaskSetTrayMenu: return nil, true, s.taskSetTrayMenu(t) + case TaskShowMessage: + return nil, true, s.manager.ShowMessage(t.Title, t.Message) case TaskShowPanel: return nil, true, s.manager.ShowPanel() case TaskHidePanel: @@ -87,29 +82,6 @@ func (s *Service) taskSetTrayMenu(t TaskSetTrayMenu) error { return s.manager.SetMenu(t.Items) } -func (s *Service) showTrayMessage(title, message string) error { - if s.manager == nil || !s.manager.IsActive() { - _, _, err := s.Core().PERFORM(notification.TaskSend{ - Opts: notification.NotificationOptions{Title: title, Message: message}, - }) - return err - } - tray := s.manager.Tray() - if tray == nil { - return core.E("systray.showTrayMessage", "tray not initialised", nil) - } - if messenger, ok := tray.(interface{ ShowMessage(title, message string) }); ok { - messenger.ShowMessage(title, message) - return nil - } - _, _, err := s.Core().PERFORM(notification.TaskSend{ - Opts: notification.NotificationOptions{Title: title, Message: message}, - }) - return err -} - -// Manager returns the underlying systray Manager. -// Use: manager := svc.Manager() func (s *Service) Manager() *Manager { return s.manager } diff --git a/pkg/systray/service_test.go b/pkg/systray/service_test.go index 7188d990..6a7984fc 100644 --- a/pkg/systray/service_test.go +++ b/pkg/systray/service_test.go @@ -84,31 +84,36 @@ func TestTaskSetTrayMenu_Good(t *testing.T) { assert.True(t, handled) } -func TestTaskSetTrayMenu_Submenu_Good(t *testing.T) { - p := newMockPlatform() - c, err := core.New( - core.WithService(Register(p)), - core.WithServiceLock(), - ) - require.NoError(t, err) - require.NoError(t, c.ServiceStartup(context.Background(), nil)) - - svc := core.MustServiceFor[*Service](c, "systray") +func TestTaskSetTrayTooltip_Good(t *testing.T) { + svc, c := newTestSystrayService(t) require.NoError(t, svc.manager.Setup("Test", "Test")) - _, handled, err := c.PERFORM(TaskSetTrayMenu{Items: []TrayMenuItem{ - { - Label: "File", - Submenu: []TrayMenuItem{ - {Label: "Open", ActionID: "open"}, - }, - }, - }}) + _, handled, err := c.PERFORM(TaskSetTrayTooltip{Tooltip: "Updated"}) require.NoError(t, err) assert.True(t, handled) - require.Len(t, p.trays, 1) - require.NotEmpty(t, p.menus) - require.Len(t, p.menus[0].submenus, 1) + assert.Equal(t, "Updated", svc.manager.Tray().(*mockTray).tooltip) +} + +func TestTaskSetTrayLabel_Good(t *testing.T) { + svc, c := newTestSystrayService(t) + require.NoError(t, svc.manager.Setup("Test", "Test")) + + _, handled, err := c.PERFORM(TaskSetTrayLabel{Label: "CoreGUI"}) + require.NoError(t, err) + assert.True(t, handled) + assert.Equal(t, "CoreGUI", svc.manager.Tray().(*mockTray).label) +} + +func TestTaskShowMessage_Good(t *testing.T) { + svc, c := newTestSystrayService(t) + require.NoError(t, svc.manager.Setup("Test", "Test")) + + _, handled, err := c.PERFORM(TaskShowMessage{Title: "Heads up", Message: "Background work finished"}) + require.NoError(t, err) + assert.True(t, handled) + tray := svc.manager.Tray().(*mockTray) + assert.Equal(t, "Heads up", tray.lastMessageTitle) + assert.Equal(t, "Background work finished", tray.lastMessageBody) } func TestTaskSetTrayIcon_Bad(t *testing.T) { diff --git a/pkg/systray/tray.go b/pkg/systray/tray.go index 7d23b2a5..c391b2c8 100644 --- a/pkg/systray/tray.go +++ b/pkg/systray/tray.go @@ -5,7 +5,7 @@ import ( _ "embed" "sync" - "forge.lthn.ai/core/go/pkg/core" + coreerr "forge.lthn.ai/core/go-log" ) //go:embed assets/apptray.png @@ -27,7 +27,7 @@ type Manager struct { } // NewManager creates a systray Manager. -// Use: manager := systray.NewManager(platform) +// systray.NewManager(systray.NewWailsPlatform(app)).Setup("Core", "Core") func NewManager(platform Platform) *Manager { return &Manager{ platform: platform, @@ -36,11 +36,11 @@ func NewManager(platform Platform) *Manager { } // Setup creates the system tray with default icon and tooltip. -// Use: _ = manager.Setup("Core", "Core") +// systray.NewManager(systray.NewWailsPlatform(app)).Setup("Core", "Core") func (m *Manager) Setup(tooltip, label string) error { m.tray = m.platform.NewTray() if m.tray == nil { - return core.E("systray.Setup", "platform returned nil tray", nil) + return coreerr.E("systray.Setup", "platform returned nil tray", nil) } m.tray.SetTemplateIcon(defaultIcon) m.tray.SetTooltip(tooltip) @@ -55,7 +55,7 @@ func (m *Manager) Setup(tooltip, label string) error { // Use: _ = manager.SetIcon(iconBytes) func (m *Manager) SetIcon(data []byte) error { if m.tray == nil { - return core.E("systray.SetIcon", "tray not initialised", nil) + return coreerr.E("systray.SetIcon", "tray not initialised", nil) } m.tray.SetIcon(data) m.hasIcon = len(data) > 0 @@ -66,7 +66,7 @@ func (m *Manager) SetIcon(data []byte) error { // Use: _ = manager.SetTemplateIcon(iconBytes) func (m *Manager) SetTemplateIcon(data []byte) error { if m.tray == nil { - return core.E("systray.SetTemplateIcon", "tray not initialised", nil) + return coreerr.E("systray.SetTemplateIcon", "tray not initialised", nil) } m.tray.SetTemplateIcon(data) m.hasTemplateIcon = len(data) > 0 @@ -77,7 +77,7 @@ func (m *Manager) SetTemplateIcon(data []byte) error { // Use: _ = manager.SetTooltip("Core is ready") func (m *Manager) SetTooltip(text string) error { if m.tray == nil { - return core.E("systray.SetTooltip", "tray not initialised", nil) + return coreerr.E("systray.SetTooltip", "tray not initialised", nil) } m.tray.SetTooltip(text) m.tooltip = text @@ -88,7 +88,7 @@ func (m *Manager) SetTooltip(text string) error { // Use: _ = manager.SetLabel("Core") func (m *Manager) SetLabel(text string) error { if m.tray == nil { - return core.E("systray.SetLabel", "tray not initialised", nil) + return coreerr.E("systray.SetLabel", "tray not initialised", nil) } m.tray.SetLabel(text) m.label = text @@ -99,7 +99,7 @@ func (m *Manager) SetLabel(text string) error { // Use: _ = manager.AttachWindow(windowHandle) func (m *Manager) AttachWindow(w WindowHandle) error { if m.tray == nil { - return core.E("systray.AttachWindow", "tray not initialised", nil) + return coreerr.E("systray.AttachWindow", "tray not initialised", nil) } m.mu.Lock() m.panelWindow = w @@ -108,30 +108,12 @@ func (m *Manager) AttachWindow(w WindowHandle) error { return nil } -// ShowPanel shows the attached tray panel window if one is configured. -// Use: _ = manager.ShowPanel() -func (m *Manager) ShowPanel() error { - m.mu.RLock() - w := m.panelWindow - m.mu.RUnlock() - if w == nil { - return nil +// ShowMessage displays a tray message if the backend supports it. +func (m *Manager) ShowMessage(title, message string) error { + if m.tray == nil { + return coreerr.E("systray.ShowMessage", "tray not initialised", nil) } - w.Show() - return nil -} - -// HidePanel hides the attached tray panel window if one is configured. -// Use: _ = manager.HidePanel() -func (m *Manager) HidePanel() error { - m.mu.RLock() - w := m.panelWindow - m.mu.RUnlock() - if w == nil { - return nil - } - w.Hide() - return nil + return m.tray.ShowMessage(title, message) } // Tray returns the underlying platform tray for direct access. diff --git a/pkg/systray/tray_test.go b/pkg/systray/tray_test.go index f8028282..6de6d392 100644 --- a/pkg/systray/tray_test.go +++ b/pkg/systray/tray_test.go @@ -84,3 +84,29 @@ func TestManager_GetInfo_Good(t *testing.T) { info = m.GetInfo() assert.True(t, info["active"].(bool)) } + +func TestManager_Build_Submenu_Recursive_Good(t *testing.T) { + m, p := newTestManager() + require.NoError(t, m.Setup("Core", "Core")) + + items := []TrayMenuItem{ + { + Label: "Parent", + Submenu: []TrayMenuItem{ + {Label: "Child 1"}, + {Label: "Child 2"}, + }, + }, + } + + require.NoError(t, m.SetMenu(items)) + require.Len(t, p.menus, 1) + + menu := p.menus[0] + require.Len(t, menu.items, 1) + assert.Equal(t, "Parent", menu.items[0]) + require.Len(t, menu.subs, 1) + require.Len(t, menu.subs[0].items, 2) + assert.Equal(t, "Child 1", menu.subs[0].items[0]) + assert.Equal(t, "Child 2", menu.subs[0].items[1]) +} diff --git a/pkg/systray/wails.go b/pkg/systray/wails.go index b9e46ac7..a4d80b4d 100644 --- a/pkg/systray/wails.go +++ b/pkg/systray/wails.go @@ -60,6 +60,12 @@ func (wt *wailsTray) AttachWindow(w WindowHandle) { wt.tray.AttachWindow(window) } +func (wt *wailsTray) ShowMessage(title, message string) error { + _ = title + _ = message + return nil +} + // wailsTrayMenu wraps *application.Menu for the PlatformMenu interface. type wailsTrayMenu struct { menu *application.Menu @@ -88,7 +94,3 @@ func (mi *wailsTrayMenuItem) SetEnabled(enabled bool) { mi.item.SetEnabled(enabl func (mi *wailsTrayMenuItem) OnClick(fn func()) { mi.item.OnClick(func(ctx *application.Context) { fn() }) } -func (mi *wailsTrayMenuItem) AddSubmenu() PlatformMenu { - // Wails doesn't have a direct AddSubmenu on MenuItem — use Menu.AddSubmenu instead - return &wailsTrayMenu{menu: application.NewMenu()} -} diff --git a/pkg/webview/service.go b/pkg/webview/service.go index 0e8bb4d6..56dceaec 100644 --- a/pkg/webview/service.go +++ b/pkg/webview/service.go @@ -46,19 +46,37 @@ type connector interface { Close() error } -// Options holds configuration for the webview service. -// Use: svc, err := webview.Register(webview.Options{})(core.New()) type Options struct { DebugURL string // Chrome debug endpoint (default: "http://localhost:9222") Timeout time.Duration // Operation timeout (default: 30s) ConsoleLimit int // Max console messages per window (default: 1000) } -// Service is a core.Service managing webview interactions via IPC. -// Use: svc, err := webview.Register(webview.Options{})(core.New()) +func defaultOptions() Options { + return Options{ + DebugURL: "http://localhost:9222", + Timeout: 30 * time.Second, + ConsoleLimit: 1000, + } +} + +func normalizeOptions(options Options) Options { + defaults := defaultOptions() + if options.DebugURL == "" { + options.DebugURL = defaults.DebugURL + } + if options.Timeout == 0 { + options.Timeout = defaults.Timeout + } + if options.ConsoleLimit == 0 { + options.ConsoleLimit = defaults.ConsoleLimit + } + return options +} + type Service struct { *core.ServiceRuntime[Options] - opts Options + options Options connections map[string]connector exceptions map[string][]ExceptionInfo mu sync.RWMutex @@ -66,27 +84,14 @@ type Service struct { watcherSetup func(conn connector, windowName string) // called after connection creation } -// Register creates a factory closure with declarative options. -// Use: core.WithService(webview.Register(webview.Options{ConsoleLimit: 500})) -func Register(options Options) func(*core.Core) (any, error) { - o := Options{ - DebugURL: "http://localhost:9222", - Timeout: 30 * time.Second, - ConsoleLimit: 1000, - } - if options.DebugURL != "" { - o.DebugURL = options.DebugURL - } - if options.Timeout != 0 { - o.Timeout = options.Timeout - } - if options.ConsoleLimit != 0 { - o.ConsoleLimit = options.ConsoleLimit - } +// RegisterWithOptions binds the webview service to a Core instance using a declarative Options literal. +// core.WithService(webview.RegisterWithOptions(webview.Options{DebugURL: "http://localhost:9223", Timeout: 30 * time.Second, ConsoleLimit: 1000})) +func RegisterWithOptions(options Options) func(*core.Core) (any, error) { + o := normalizeOptions(options) return func(c *core.Core) (any, error) { svc := &Service{ ServiceRuntime: core.NewServiceRuntime[Options](c, o), - opts: o, + options: o, connections: make(map[string]connector), exceptions: make(map[string][]ExceptionInfo), newConn: defaultNewConn(o), @@ -96,8 +101,19 @@ func Register(options Options) func(*core.Core) (any, error) { } } +// Deprecated: use RegisterWithOptions(webview.Options{DebugURL: "http://localhost:9223", Timeout: 30 * time.Second, ConsoleLimit: 1000}). +func Register(optionFns ...func(*Options)) func(*core.Core) (any, error) { + options := defaultOptions() + for _, fn := range optionFns { + if fn != nil { + fn(&options) + } + } + return RegisterWithOptions(options) +} + // defaultNewConn creates real go-webview connections. -func defaultNewConn(opts Options) func(string, string) (connector, error) { +func defaultNewConn(options Options) func(string, string) (connector, error) { return func(debugURL, windowName string) (connector, error) { // Enumerate targets, match by title/URL containing window name targets, err := gowebview.ListTargets(debugURL) @@ -106,7 +122,7 @@ func defaultNewConn(opts Options) func(string, string) (connector, error) { } var wsURL string for _, t := range targets { - if t.Type == "page" && (corego.Contains(t.Title, windowName) || corego.Contains(t.URL, windowName)) { + if t.Type == "page" && (bytes.Contains([]byte(t.Title), []byte(windowName)) || bytes.Contains([]byte(t.URL), []byte(windowName))) { wsURL = t.WebSocketDebuggerURL break } @@ -125,8 +141,8 @@ func defaultNewConn(opts Options) func(string, string) (connector, error) { } wv, err := gowebview.New( gowebview.WithDebugURL(debugURL), - gowebview.WithTimeout(opts.Timeout), - gowebview.WithConsoleLimit(opts.ConsoleLimit), + gowebview.WithTimeout(options.Timeout), + gowebview.WithConsoleLimit(options.ConsoleLimit), ) if err != nil { return nil, err @@ -174,7 +190,6 @@ func (s *Service) defaultWatcherSetup(conn connector, windowName string) { }) } -// OnStartup registers IPC handlers. func (s *Service) OnStartup(_ context.Context) error { s.Core().RegisterQuery(s.handleQuery) s.Core().RegisterTask(s.handleTask) @@ -224,7 +239,7 @@ func (s *Service) getConn(windowName string) (connector, error) { if conn, ok := s.connections[windowName]; ok { return conn, nil } - conn, err := s.newConn(s.opts.DebugURL, windowName) + conn, err := s.newConn(s.options.DebugURL, windowName) if err != nil { return nil, err } @@ -674,7 +689,6 @@ func (r *realConnector) GetURL() (string, error) { return r.wv.G func (r *realConnector) GetTitle() (string, error) { return r.wv.GetTitle() } func (r *realConnector) GetHTML(sel string) (string, error) { return r.wv.GetHTML(sel) } func (r *realConnector) ClearConsole() { r.wv.ClearConsole() } -func (r *realConnector) Print() error { _, err := r.wv.Evaluate("window.print()"); return err } func (r *realConnector) Close() error { return r.wv.Close() } func (r *realConnector) SetViewport(w, h int) error { return r.wv.SetViewport(w, h) } func (r *realConnector) UploadFile(sel string, p []string) error { return r.wv.UploadFile(sel, p) } diff --git a/pkg/webview/service_test.go b/pkg/webview/service_test.go index 23e93f78..99374403 100644 --- a/pkg/webview/service_test.go +++ b/pkg/webview/service_test.go @@ -65,31 +65,18 @@ func (m *mockConnector) Check(sel string, c bool) error { m.lastCheckVal = c return nil } -func (m *mockConnector) Evaluate(s string) (any, error) { - m.lastEvalScript = s - if m.evalFn != nil { - return m.evalFn(s) - } - return m.evalResult, nil -} +func (m *mockConnector) Evaluate(s string) (any, error) { return m.evalResult, nil } func (m *mockConnector) Screenshot() ([]byte, error) { return m.screenshot, nil } func (m *mockConnector) GetURL() (string, error) { return m.url, nil } func (m *mockConnector) GetTitle() (string, error) { return m.title, nil } func (m *mockConnector) GetHTML(sel string) (string, error) { return m.html, nil } func (m *mockConnector) ClearConsole() { m.consoleClearCalled = true } -func (m *mockConnector) Print() error { m.printCalled = true; return nil } func (m *mockConnector) Close() error { m.closed = true; return nil } func (m *mockConnector) SetViewport(w, h int) error { m.lastViewportW = w m.lastViewportH = h return nil } -func (m *mockConnector) PrintToPDF() ([]byte, error) { - if len(m.pdfBytes) == 0 { - return []byte("%PDF-1.4\n"), nil - } - return m.pdfBytes, nil -} func (m *mockConnector) UploadFile(sel string, p []string) error { m.lastUploadSel = sel m.lastUploadPaths = p @@ -111,12 +98,8 @@ func (m *mockConnector) GetConsole() []ConsoleMessage { return m.console } func newTestService(t *testing.T, mock *mockConnector) (*Service, *core.Core) { t.Helper() - factory := Register(Options{}) - c, err := core.New( - core.WithService(window.Register(window.NewMockPlatform())), - core.WithService(factory), - core.WithServiceLock(), - ) + factory := RegisterWithOptions(Options{}) + c, err := core.New(core.WithService(factory), core.WithServiceLock()) require.NoError(t, err) require.NoError(t, c.ServiceStartup(context.Background(), nil)) svc := core.MustServiceFor[*Service](c, "webview") @@ -125,7 +108,7 @@ func newTestService(t *testing.T, mock *mockConnector) (*Service, *core.Core) { return svc, c } -func TestRegister_Good(t *testing.T) { +func TestRegisterWithOptions_Good(t *testing.T) { svc, _ := newTestService(t, &mockConnector{}) assert.NotNil(t, svc) } diff --git a/pkg/window/layout.go b/pkg/window/layout.go index ca1f74ea..b3c6fc83 100644 --- a/pkg/window/layout.go +++ b/pkg/window/layout.go @@ -2,11 +2,13 @@ package window import ( + "encoding/json" "os" "sync" "time" - corego "dappco.re/go/core" + coreio "forge.lthn.ai/core/go-io" + coreerr "forge.lthn.ai/core/go-log" ) // Layout is a named window arrangement. @@ -69,13 +71,13 @@ func (lm *LayoutManager) loadLayouts() { if lm.configDir == "" { return } - data, err := os.ReadFile(lm.layoutsFilePath()) + content, err := coreio.Local.Read(lm.filePath()) if err != nil { return } lm.mu.Lock() defer lm.mu.Unlock() - _ = corego.JSONUnmarshal(data, &lm.layouts) + _ = json.Unmarshal([]byte(content), &lm.layouts) } func (lm *LayoutManager) saveLayouts() { @@ -88,15 +90,15 @@ func (lm *LayoutManager) saveLayouts() { if !r.OK { return } - _ = os.MkdirAll(lm.configDir, 0o755) - _ = os.WriteFile(lm.layoutsFilePath(), r.Value.([]byte), 0o644) + _ = coreio.Local.EnsureDir(lm.configDir) + _ = coreio.Local.Write(lm.filePath(), string(data)) } // SaveLayout creates or updates a named layout. // Use: _ = lm.SaveLayout("coding", windowStates) func (lm *LayoutManager) SaveLayout(name string, windowStates map[string]WindowState) error { if name == "" { - return corego.E("layout.save", "layout name cannot be empty", nil) + return coreerr.E("window.LayoutManager.SaveLayout", "layout name cannot be empty", nil) } now := time.Now().UnixMilli() lm.mu.Lock() diff --git a/pkg/window/messages.go b/pkg/window/messages.go index 6146ac28..54232b8f 100644 --- a/pkg/window/messages.go +++ b/pkg/window/messages.go @@ -1,8 +1,6 @@ // pkg/window/messages.go package window -// WindowInfo contains information about a window. -// Use: info := window.WindowInfo{Name: "editor", Title: "Core Editor"} type WindowInfo struct { Name string `json:"name"` Title string `json:"title"` @@ -16,113 +14,46 @@ type WindowInfo struct { Focused bool `json:"focused"` } -// Bounds describes the position and size of a window. -// Use: bounds := window.Bounds{X: 10, Y: 10, Width: 1280, Height: 800} -type Bounds struct { - X int `json:"x"` - Y int `json:"y"` - Width int `json:"width"` - Height int `json:"height"` -} - -// --- Queries (read-only) --- - -// QueryWindowList returns all tracked windows. Result: []WindowInfo -// Use: result, _, err := c.QUERY(window.QueryWindowList{}) type QueryWindowList struct{} -// QueryWindowByName returns a single window by name. Result: *WindowInfo (nil if not found) -// Use: result, _, err := c.QUERY(window.QueryWindowByName{Name: "editor"}) type QueryWindowByName struct{ Name string } -// QueryConfig requests this service's config section from the display orchestrator. -// Result: map[string]any -// Use: result, _, err := c.QUERY(window.QueryConfig{}) type QueryConfig struct{} -// QueryWindowBounds returns the current bounds for a window. -// Use: result, _, err := c.QUERY(window.QueryWindowBounds{Name: "editor"}) -type QueryWindowBounds struct{ Name string } +// TaskOpenWindow opens a concrete Window descriptor. +// window.TaskOpenWindow{Window: &window.Window{Name: "settings", URL: "/", Width: 800, Height: 600}} +type TaskOpenWindow struct{ Window *Window } -// QueryFindSpace returns a suggested free placement for a new window. -// Use: result, _, err := c.QUERY(window.QueryFindSpace{Width: 1280, Height: 800}) -type QueryFindSpace struct { - Width int - Height int - ScreenWidth int - ScreenHeight int -} - -// QueryLayoutSuggestion returns a layout recommendation for the current screen. -// Use: result, _, err := c.QUERY(window.QueryLayoutSuggestion{WindowCount: 2}) -type QueryLayoutSuggestion struct { - WindowCount int - ScreenWidth int - ScreenHeight int -} - -// --- Tasks (side-effects) --- - -// TaskOpenWindow creates a new window. Result: WindowInfo -// Use: _, _, err := c.PERFORM(window.TaskOpenWindow{Opts: []window.WindowOption{window.WithName("editor")}}) -type TaskOpenWindow struct { - Window *Window - Opts []WindowOption -} - -// TaskCloseWindow closes a window after persisting state. -// Platform close events emit ActionWindowClosed through the tracked window handler. -// Use: _, _, err := c.PERFORM(window.TaskCloseWindow{Name: "editor"}) type TaskCloseWindow struct{ Name string } -// TaskSetPosition moves a window. -// Use: _, _, err := c.PERFORM(window.TaskSetPosition{Name: "editor", X: 160, Y: 120}) type TaskSetPosition struct { Name string X, Y int } -// TaskSetSize resizes a window. -// Use: _, _, err := c.PERFORM(window.TaskSetSize{Name: "editor", Width: 1280, Height: 800}) type TaskSetSize struct { Name string Width, Height int - // W and H are compatibility aliases for older call sites. - W, H int } -// TaskMaximise maximises a window. -// Use: _, _, err := c.PERFORM(window.TaskMaximise{Name: "editor"}) type TaskMaximise struct{ Name string } -// TaskMinimise minimises a window. -// Use: _, _, err := c.PERFORM(window.TaskMinimise{Name: "editor"}) type TaskMinimise struct{ Name string } -// TaskFocus brings a window to the front. -// Use: _, _, err := c.PERFORM(window.TaskFocus{Name: "editor"}) type TaskFocus struct{ Name string } -// TaskRestore restores a maximised or minimised window to its normal state. -// Use: _, _, err := c.PERFORM(window.TaskRestore{Name: "editor"}) type TaskRestore struct{ Name string } -// TaskSetTitle changes a window's title. -// Use: _, _, err := c.PERFORM(window.TaskSetTitle{Name: "editor", Title: "Core Editor"}) type TaskSetTitle struct { Name string Title string } -// TaskSetAlwaysOnTop pins a window above others. -// Use: _, _, err := c.PERFORM(window.TaskSetAlwaysOnTop{Name: "editor", AlwaysOnTop: true}) type TaskSetAlwaysOnTop struct { Name string AlwaysOnTop bool } -// TaskSetBackgroundColour updates the window background colour. -// Use: _, _, err := c.PERFORM(window.TaskSetBackgroundColour{Name: "editor", Red: 0, Green: 0, Blue: 0, Alpha: 0}) type TaskSetBackgroundColour struct { Name string Red uint8 @@ -131,99 +62,94 @@ type TaskSetBackgroundColour struct { Alpha uint8 } -// TaskSetOpacity updates the window opacity as a value between 0 and 1. -// Use: _, _, err := c.PERFORM(window.TaskSetOpacity{Name: "editor", Opacity: 0.85}) -type TaskSetOpacity struct { - Name string - Opacity float32 -} - -// TaskSetVisibility shows or hides a window. -// Use: _, _, err := c.PERFORM(window.TaskSetVisibility{Name: "editor", Visible: false}) type TaskSetVisibility struct { Name string Visible bool } -// TaskFullscreen enters or exits fullscreen mode. -// Use: _, _, err := c.PERFORM(window.TaskFullscreen{Name: "editor", Fullscreen: true}) type TaskFullscreen struct { Name string Fullscreen bool } -// --- Layout Queries --- - -// QueryLayoutList returns summaries of all saved layouts. Result: []LayoutInfo -// Use: result, _, err := c.QUERY(window.QueryLayoutList{}) type QueryLayoutList struct{} -// QueryLayoutGet returns a layout by name. Result: *Layout (nil if not found) -// Use: result, _, err := c.QUERY(window.QueryLayoutGet{Name: "coding"}) type QueryLayoutGet struct{ Name string } -// --- Layout Tasks --- - -// TaskSaveLayout saves the current window arrangement as a named layout. Result: bool -// Use: _, _, err := c.PERFORM(window.TaskSaveLayout{Name: "coding"}) type TaskSaveLayout struct{ Name string } -// TaskRestoreLayout restores a saved layout by name. -// Use: _, _, err := c.PERFORM(window.TaskRestoreLayout{Name: "coding"}) type TaskRestoreLayout struct{ Name string } -// TaskDeleteLayout removes a saved layout by name. -// Use: _, _, err := c.PERFORM(window.TaskDeleteLayout{Name: "coding"}) type TaskDeleteLayout struct{ Name string } -// TaskTileWindows arranges windows in a tiling mode. -// Use: _, _, err := c.PERFORM(window.TaskTileWindows{Mode: "grid"}) type TaskTileWindows struct { Mode string // "left-right", "grid", "left-half", "right-half", etc. Windows []string // window names; empty = all } -// TaskSnapWindow snaps a window to a screen edge/corner. -// Use: _, _, err := c.PERFORM(window.TaskSnapWindow{Name: "editor", Position: "left"}) +type TaskStackWindows struct { + Windows []string // window names; empty = all + OffsetX int + OffsetY int +} + type TaskSnapWindow struct { Name string // window name Position string // "left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right", "center" } -// TaskArrangePair places two windows side-by-side in a balanced split. -// Use: _, _, err := c.PERFORM(window.TaskArrangePair{First: "editor", Second: "terminal"}) -type TaskArrangePair struct { - First string - Second string -} - -// TaskBesideEditor places a target window beside an editor/IDE window. -// Use: _, _, err := c.PERFORM(window.TaskBesideEditor{Editor: "editor", Window: "terminal"}) -type TaskBesideEditor struct { - Editor string - Window string -} - -// TaskStackWindows cascades windows with a shared offset. -// Use: _, _, err := c.PERFORM(window.TaskStackWindows{Windows: []string{"editor", "terminal"}}) -type TaskStackWindows struct { - Windows []string - OffsetX int - OffsetY int -} - -// TaskApplyWorkflow applies a predefined workflow layout to windows. -// Use: _, _, err := c.PERFORM(window.TaskApplyWorkflow{Workflow: window.WorkflowCoding}) type TaskApplyWorkflow struct { - Workflow WorkflowLayout - Windows []string + Workflow string + Windows []string // window names; empty = all } -// TaskSaveConfig persists this service's config section via the display orchestrator. -// Use: _, _, err := c.PERFORM(window.TaskSaveConfig{Value: map[string]any{"default_width": 1280}}) -type TaskSaveConfig struct{ Value map[string]any } +type TaskSaveConfig struct{ Config map[string]any } -// --- Actions (broadcasts) --- +// QueryWindowZoom queries the current zoom factor for a named window. Result: float64 +type QueryWindowZoom struct{ Name string } + +// QueryWindowBounds queries the current bounds for a named window. Result: *Bounds +type QueryWindowBounds struct{ Name string } + +// TaskSetZoom sets the zoom factor for a named window. +// c.PERFORM(window.TaskSetZoom{Name: "main", Factor: 1.5}) +type TaskSetZoom struct { + Name string + Factor float64 +} + +// TaskSetURL navigates a named window to a new URL. +// c.PERFORM(window.TaskSetURL{Name: "main", URL: "/settings"}) +type TaskSetURL struct { + Name string + URL string +} + +// TaskSetHTML replaces the content of a named window with HTML. +// c.PERFORM(window.TaskSetHTML{Name: "main", HTML: "

Hello

"}) +type TaskSetHTML struct { + Name string + HTML string +} + +// TaskExecJS evaluates JavaScript in a named window. +// c.PERFORM(window.TaskExecJS{Name: "main", JS: "document.title = 'Updated'"}) +type TaskExecJS struct { + Name string + JS string +} + +// TaskToggleFullscreen toggles fullscreen on a named window. +type TaskToggleFullscreen struct{ Name string } + +// TaskPrint triggers the platform print dialog for a named window. +type TaskPrint struct{ Name string } + +// TaskFlash flashes (or stops flashing) the taskbar entry for a named window (Windows). +type TaskFlash struct { + Name string + Enabled bool +} // ActionWindowOpened is broadcast when a window is created. // Use: _ = c.ACTION(window.ActionWindowOpened{Name: "editor"}) @@ -245,8 +171,6 @@ type ActionWindowMoved struct { type ActionWindowResized struct { Name string Width, Height int - // W and H are compatibility aliases for older listeners. - W, H int } // ActionWindowFocused is broadcast when a window gains focus. diff --git a/pkg/window/mock_platform.go b/pkg/window/mock_platform.go index 89146fb7..44d4d7e7 100644 --- a/pkg/window/mock_platform.go +++ b/pkg/window/mock_platform.go @@ -14,16 +14,11 @@ func NewMockPlatform() *MockPlatform { return &MockPlatform{} } -// CreateWindow creates an in-memory window for tests. -// Use: w := platform.CreateWindow(window.PlatformWindowOptions{Name: "editor"}) -func (m *MockPlatform) CreateWindow(opts PlatformWindowOptions) PlatformWindow { +func (m *MockPlatform) CreateWindow(options PlatformWindowOptions) PlatformWindow { w := &MockWindow{ - name: opts.Name, title: opts.Title, url: opts.URL, - width: opts.Width, height: opts.Height, - x: opts.X, y: opts.Y, - alwaysOnTop: opts.AlwaysOnTop, - backgroundColor: opts.BackgroundColour, - visible: !opts.Hidden, + name: options.Name, title: options.Title, url: options.URL, + width: options.Width, height: options.Height, + x: options.X, y: options.Y, } m.Windows = append(m.Windows, w) return w @@ -42,47 +37,62 @@ func (m *MockPlatform) GetWindows() []PlatformWindow { // MockWindow is an in-memory window handle used by tests. // Use: w := &window.MockWindow{} type MockWindow struct { - name, title, url string - width, height, x, y int - maximised, minimised bool - focused bool - visible, alwaysOnTop bool - backgroundColor [4]uint8 - opacity float32 - closed bool - eventHandlers []func(WindowEvent) - fileDropHandlers []func(paths []string, targetID string) + name, title, url string + width, height, x, y int + maximised, focused bool + visible, alwaysOnTop bool + backgroundColour [4]uint8 + closed bool + zoom float64 + html string + lastJS string + flashing bool + printCalled bool + toggleFullscreenCount int + eventHandlers []func(WindowEvent) + fileDropHandlers []func(paths []string, targetID string) } func (w *MockWindow) Name() string { return w.name } func (w *MockWindow) Title() string { return w.title } func (w *MockWindow) Position() (int, int) { return w.x, w.y } func (w *MockWindow) Size() (int, int) { return w.width, w.height } -func (w *MockWindow) IsVisible() bool { return w.visible } -func (w *MockWindow) IsMinimised() bool { return w.minimised } func (w *MockWindow) IsMaximised() bool { return w.maximised } func (w *MockWindow) IsFocused() bool { return w.focused } func (w *MockWindow) SetTitle(title string) { w.title = title } func (w *MockWindow) SetPosition(x, y int) { w.x = x; w.y = y } func (w *MockWindow) SetSize(width, height int) { w.width = width; w.height = height } -func (w *MockWindow) SetBackgroundColour(r, g, b, a uint8) { w.backgroundColor = [4]uint8{r, g, b, a} } -func (w *MockWindow) SetOpacity(opacity float32) { w.opacity = opacity } +func (w *MockWindow) SetBackgroundColour(r, g, b, a uint8) { w.backgroundColour = [4]uint8{r, g, b, a} } func (w *MockWindow) SetVisibility(visible bool) { w.visible = visible } func (w *MockWindow) SetAlwaysOnTop(alwaysOnTop bool) { w.alwaysOnTop = alwaysOnTop } -func (w *MockWindow) Maximise() { w.maximised = true; w.minimised = false; w.visible = true } -func (w *MockWindow) Restore() { w.maximised = false; w.minimised = false; w.visible = true } -func (w *MockWindow) Minimise() { w.minimised = true; w.maximised = false; w.visible = false } +func (w *MockWindow) Maximise() { w.maximised = true } +func (w *MockWindow) Restore() { w.maximised = false } +func (w *MockWindow) Minimise() {} func (w *MockWindow) Focus() { w.focused = true } -func (w *MockWindow) Close() { - w.closed = true - w.emit(WindowEvent{Type: "close", Name: w.name}) +func (w *MockWindow) Close() { w.closed = true } +func (w *MockWindow) Show() { w.visible = true } +func (w *MockWindow) Hide() { w.visible = false } +func (w *MockWindow) Fullscreen() {} +func (w *MockWindow) UnFullscreen() {} +func (w *MockWindow) GetZoom() float64 { return w.zoom } +func (w *MockWindow) SetZoom(factor float64) { w.zoom = factor } +func (w *MockWindow) ZoomIn() { w.zoom += 0.1 } +func (w *MockWindow) ZoomOut() { w.zoom -= 0.1 } +func (w *MockWindow) SetURL(url string) { w.url = url } +func (w *MockWindow) SetHTML(html string) { w.html = html } +func (w *MockWindow) ExecJS(js string) { w.lastJS = js } +func (w *MockWindow) GetBounds() Bounds { + return Bounds{X: w.x, Y: w.y, Width: w.width, Height: w.height} } -func (w *MockWindow) Show() { w.visible = true } -func (w *MockWindow) Hide() { w.visible = false } -func (w *MockWindow) Fullscreen() {} -func (w *MockWindow) UnFullscreen() {} -func (w *MockWindow) OpenDevTools() {} -func (w *MockWindow) CloseDevTools() {} +func (w *MockWindow) SetBounds(bounds Bounds) { + w.x = bounds.X + w.y = bounds.Y + w.width = bounds.Width + w.height = bounds.Height +} +func (w *MockWindow) ToggleFullscreen() { w.toggleFullscreenCount++ } +func (w *MockWindow) Print() error { w.printCalled = true; return nil } +func (w *MockWindow) Flash(enabled bool) { w.flashing = enabled } func (w *MockWindow) OnWindowEvent(handler func(WindowEvent)) { w.eventHandlers = append(w.eventHandlers, handler) } diff --git a/pkg/window/mock_test.go b/pkg/window/mock_test.go index 4e0edad0..046338ff 100644 --- a/pkg/window/mock_test.go +++ b/pkg/window/mock_test.go @@ -1,4 +1,3 @@ -// pkg/window/mock_test.go package window type mockPlatform struct { @@ -9,14 +8,11 @@ func newMockPlatform() *mockPlatform { return &mockPlatform{} } -func (m *mockPlatform) CreateWindow(opts PlatformWindowOptions) PlatformWindow { +func (m *mockPlatform) CreateWindow(options PlatformWindowOptions) PlatformWindow { w := &mockWindow{ - name: opts.Name, title: opts.Title, url: opts.URL, - width: opts.Width, height: opts.Height, - x: opts.X, y: opts.Y, - alwaysOnTop: opts.AlwaysOnTop, - backgroundColor: opts.BackgroundColour, - visible: !opts.Hidden, + name: options.Name, title: options.Title, url: options.URL, + width: options.Width, height: options.Height, + x: options.X, y: options.Y, } m.windows = append(m.windows, w) return w @@ -31,48 +27,64 @@ func (m *mockPlatform) GetWindows() []PlatformWindow { } type mockWindow struct { - name, title, url string - width, height, x, y int - maximised, minimised bool - focused bool - visible, alwaysOnTop bool - backgroundColor [4]uint8 - opacity float32 - devtoolsOpen bool - closed bool - eventHandlers []func(WindowEvent) - fileDropHandlers []func(paths []string, targetID string) + name, title, url string + width, height, x, y int + maximised, focused bool + visible, alwaysOnTop bool + backgroundColour [4]uint8 + closed bool + minimised bool + fullscreened bool + zoom float64 + html string + lastJS string + flashing bool + printCalled bool + toggleFullscreenCount int + eventHandlers []func(WindowEvent) + fileDropHandlers []func(paths []string, targetID string) } func (w *mockWindow) Name() string { return w.name } func (w *mockWindow) Title() string { return w.title } func (w *mockWindow) Position() (int, int) { return w.x, w.y } func (w *mockWindow) Size() (int, int) { return w.width, w.height } -func (w *mockWindow) IsVisible() bool { return w.visible } -func (w *mockWindow) IsMinimised() bool { return w.minimised } func (w *mockWindow) IsMaximised() bool { return w.maximised } func (w *mockWindow) IsFocused() bool { return w.focused } func (w *mockWindow) SetTitle(title string) { w.title = title } func (w *mockWindow) SetPosition(x, y int) { w.x = x; w.y = y } func (w *mockWindow) SetSize(width, height int) { w.width = width; w.height = height } -func (w *mockWindow) SetBackgroundColour(r, g, b, a uint8) { w.backgroundColor = [4]uint8{r, g, b, a} } -func (w *mockWindow) SetOpacity(opacity float32) { w.opacity = opacity } +func (w *mockWindow) SetBackgroundColour(r, g, b, a uint8) { w.backgroundColour = [4]uint8{r, g, b, a} } func (w *mockWindow) SetVisibility(visible bool) { w.visible = visible } func (w *mockWindow) SetAlwaysOnTop(alwaysOnTop bool) { w.alwaysOnTop = alwaysOnTop } -func (w *mockWindow) Maximise() { w.maximised = true; w.minimised = false; w.visible = true } -func (w *mockWindow) Restore() { w.maximised = false; w.minimised = false; w.visible = true } -func (w *mockWindow) Minimise() { w.minimised = true; w.maximised = false; w.visible = false } +func (w *mockWindow) Maximise() { w.maximised = true } +func (w *mockWindow) Restore() { w.maximised = false } +func (w *mockWindow) Minimise() { w.minimised = true } func (w *mockWindow) Focus() { w.focused = true } -func (w *mockWindow) Close() { - w.closed = true - w.emit(WindowEvent{Type: "close", Name: w.name}) -} +func (w *mockWindow) Close() { w.closed = true } func (w *mockWindow) Show() { w.visible = true } func (w *mockWindow) Hide() { w.visible = false } -func (w *mockWindow) Fullscreen() {} -func (w *mockWindow) UnFullscreen() {} -func (w *mockWindow) OpenDevTools() { w.devtoolsOpen = true } -func (w *mockWindow) CloseDevTools() { w.devtoolsOpen = false } +func (w *mockWindow) Fullscreen() { w.fullscreened = true } +func (w *mockWindow) UnFullscreen() { w.fullscreened = false } +func (w *mockWindow) GetZoom() float64 { return w.zoom } +func (w *mockWindow) SetZoom(factor float64) { w.zoom = factor } +func (w *mockWindow) ZoomIn() { w.zoom += 0.1 } +func (w *mockWindow) ZoomOut() { w.zoom -= 0.1 } +func (w *mockWindow) SetURL(url string) { w.url = url } +func (w *mockWindow) SetHTML(html string) { w.html = html } +func (w *mockWindow) ExecJS(js string) { w.lastJS = js } +func (w *mockWindow) GetBounds() Bounds { + return Bounds{X: w.x, Y: w.y, Width: w.width, Height: w.height} +} +func (w *mockWindow) SetBounds(bounds Bounds) { + w.x = bounds.X + w.y = bounds.Y + w.width = bounds.Width + w.height = bounds.Height +} +func (w *mockWindow) ToggleFullscreen() { w.toggleFullscreenCount++ } +func (w *mockWindow) Print() error { w.printCalled = true; return nil } +func (w *mockWindow) Flash(enabled bool) { w.flashing = enabled } func (w *mockWindow) OnWindowEvent(handler func(WindowEvent)) { w.eventHandlers = append(w.eventHandlers, handler) } diff --git a/pkg/window/options.go b/pkg/window/options.go index ae18833f..4155e5a4 100644 --- a/pkg/window/options.go +++ b/pkg/window/options.go @@ -1,26 +1,25 @@ // pkg/window/options.go package window -// WindowOption is a functional option applied to a Window descriptor. +// WindowOption is the compatibility layer for option-chain callers. +// Prefer a Window literal with Manager.CreateWindow. type WindowOption func(*Window) error -// ApplyOptions creates a Window and applies all options in order. -// Use: w, err := window.ApplyOptions(window.WithName("editor"), window.WithURL("/editor")) -func ApplyOptions(opts ...WindowOption) (*Window, error) { +// Deprecated: use Manager.CreateWindow(Window{Name: "settings", URL: "/", Width: 800, Height: 600}). +func ApplyOptions(options ...WindowOption) (*Window, error) { w := &Window{} - for _, opt := range opts { - if opt == nil { + for _, option := range options { + if option == nil { continue } - if err := opt(w); err != nil { + if err := option(w); err != nil { return nil, err } } return w, nil } -// WithName sets the window name. -// Use: window.WithName("editor") +// Compatibility helpers for callers still using option chains. func WithName(name string) WindowOption { return func(w *Window) error { w.Name = name; return nil } } diff --git a/pkg/window/persistence_test.go b/pkg/window/persistence_test.go new file mode 100644 index 00000000..eed02de2 --- /dev/null +++ b/pkg/window/persistence_test.go @@ -0,0 +1,334 @@ +// pkg/window/persistence_test.go +package window + +import ( + "os" + "path/filepath" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// --- StateManager Persistence Tests --- + +func TestStateManager_SetAndGet_Good(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + state := WindowState{ + X: 150, Y: 250, Width: 1024, Height: 768, + Maximized: true, Screen: "primary", URL: "/app", + } + sm.SetState("editor", state) + + got, ok := sm.GetState("editor") + require.True(t, ok) + assert.Equal(t, 150, got.X) + assert.Equal(t, 250, got.Y) + assert.Equal(t, 1024, got.Width) + assert.Equal(t, 768, got.Height) + assert.True(t, got.Maximized) + assert.Equal(t, "primary", got.Screen) + assert.Equal(t, "/app", got.URL) + assert.NotZero(t, got.UpdatedAt, "UpdatedAt should be set by SetState") +} + +func TestStateManager_UpdatePosition_Good(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + sm.SetState("win", WindowState{X: 0, Y: 0, Width: 800, Height: 600}) + + sm.UpdatePosition("win", 300, 400) + + got, ok := sm.GetState("win") + require.True(t, ok) + assert.Equal(t, 300, got.X) + assert.Equal(t, 400, got.Y) + // Width/Height should remain unchanged + assert.Equal(t, 800, got.Width) + assert.Equal(t, 600, got.Height) +} + +func TestStateManager_UpdateSize_Good(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + sm.SetState("win", WindowState{X: 100, Y: 200, Width: 800, Height: 600}) + + sm.UpdateSize("win", 1920, 1080) + + got, ok := sm.GetState("win") + require.True(t, ok) + assert.Equal(t, 1920, got.Width) + assert.Equal(t, 1080, got.Height) + // Position should remain unchanged + assert.Equal(t, 100, got.X) + assert.Equal(t, 200, got.Y) +} + +func TestStateManager_UpdateMaximized_Good(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + sm.SetState("win", WindowState{Width: 800, Height: 600, Maximized: false}) + + sm.UpdateMaximized("win", true) + + got, ok := sm.GetState("win") + require.True(t, ok) + assert.True(t, got.Maximized) + + sm.UpdateMaximized("win", false) + + got, ok = sm.GetState("win") + require.True(t, ok) + assert.False(t, got.Maximized) +} + +func TestStateManager_CaptureState_Good(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + pw := &mockWindow{ + name: "captured", x: 75, y: 125, + width: 1440, height: 900, maximised: true, + } + + sm.CaptureState(pw) + + got, ok := sm.GetState("captured") + require.True(t, ok) + assert.Equal(t, 75, got.X) + assert.Equal(t, 125, got.Y) + assert.Equal(t, 1440, got.Width) + assert.Equal(t, 900, got.Height) + assert.True(t, got.Maximized) + assert.NotZero(t, got.UpdatedAt) +} + +func TestStateManager_ApplyState_Good(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + sm.SetState("target", WindowState{X: 55, Y: 65, Width: 700, Height: 500}) + + w := &Window{Name: "target", Width: 1280, Height: 800, X: 0, Y: 0} + sm.ApplyState(w) + + assert.Equal(t, 55, w.X) + assert.Equal(t, 65, w.Y) + assert.Equal(t, 700, w.Width) + assert.Equal(t, 500, w.Height) +} + +func TestStateManager_ApplyState_Good_NoState(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + + w := &Window{Name: "untouched", Width: 1280, Height: 800, X: 10, Y: 20} + sm.ApplyState(w) + + // Window should remain unchanged when no state is saved + assert.Equal(t, 10, w.X) + assert.Equal(t, 20, w.Y) + assert.Equal(t, 1280, w.Width) + assert.Equal(t, 800, w.Height) +} + +func TestStateManager_ListStates_Good(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + sm.SetState("alpha", WindowState{Width: 100}) + sm.SetState("beta", WindowState{Width: 200}) + sm.SetState("gamma", WindowState{Width: 300}) + + names := sm.ListStates() + assert.Len(t, names, 3) + assert.Contains(t, names, "alpha") + assert.Contains(t, names, "beta") + assert.Contains(t, names, "gamma") +} + +func TestStateManager_Clear_Good(t *testing.T) { + sm := NewStateManagerWithDir(t.TempDir()) + sm.SetState("a", WindowState{Width: 100}) + sm.SetState("b", WindowState{Width: 200}) + sm.SetState("c", WindowState{Width: 300}) + + sm.Clear() + + names := sm.ListStates() + assert.Empty(t, names) + + _, ok := sm.GetState("a") + assert.False(t, ok) +} + +func TestStateManager_Persistence_Good(t *testing.T) { + dir := t.TempDir() + + // First manager: write state and force sync to disk + sm1 := NewStateManagerWithDir(dir) + sm1.SetState("persist-win", WindowState{ + X: 42, Y: 84, Width: 500, Height: 300, + Maximized: true, Screen: "secondary", URL: "/settings", + }) + sm1.ForceSync() + + // Second manager: load from the same directory + sm2 := NewStateManagerWithDir(dir) + + got, ok := sm2.GetState("persist-win") + require.True(t, ok) + assert.Equal(t, 42, got.X) + assert.Equal(t, 84, got.Y) + assert.Equal(t, 500, got.Width) + assert.Equal(t, 300, got.Height) + assert.True(t, got.Maximized) + assert.Equal(t, "secondary", got.Screen) + assert.Equal(t, "/settings", got.URL) + assert.NotZero(t, got.UpdatedAt) +} + +func TestStateManager_SetPath_Good(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "custom", "window-state.json") + + sm := NewStateManagerWithDir(dir) + sm.SetPath(path) + sm.SetState("custom", WindowState{Width: 640, Height: 480}) + sm.ForceSync() + + content, err := os.ReadFile(path) + require.NoError(t, err) + assert.Contains(t, string(content), "custom") +} + +// --- LayoutManager Persistence Tests --- + +func TestLayoutManager_SaveAndGet_Good(t *testing.T) { + lm := NewLayoutManagerWithDir(t.TempDir()) + windows := map[string]WindowState{ + "editor": {X: 0, Y: 0, Width: 960, Height: 1080}, + "terminal": {X: 960, Y: 0, Width: 960, Height: 540}, + "browser": {X: 960, Y: 540, Width: 960, Height: 540}, + } + + err := lm.SaveLayout("coding", windows) + require.NoError(t, err) + + layout, ok := lm.GetLayout("coding") + require.True(t, ok) + assert.Equal(t, "coding", layout.Name) + assert.Len(t, layout.Windows, 3) + assert.Equal(t, 960, layout.Windows["editor"].Width) + assert.Equal(t, 1080, layout.Windows["editor"].Height) + assert.Equal(t, 960, layout.Windows["terminal"].X) + assert.NotZero(t, layout.CreatedAt) + assert.NotZero(t, layout.UpdatedAt) + assert.Equal(t, layout.CreatedAt, layout.UpdatedAt, "CreatedAt and UpdatedAt should match on first save") +} + +func TestLayoutManager_SaveLayout_EmptyName_Bad(t *testing.T) { + lm := NewLayoutManagerWithDir(t.TempDir()) + err := lm.SaveLayout("", map[string]WindowState{ + "win": {Width: 800}, + }) + assert.Error(t, err) +} + +func TestLayoutManager_SaveLayout_Update_Good(t *testing.T) { + lm := NewLayoutManagerWithDir(t.TempDir()) + + // First save + err := lm.SaveLayout("evolving", map[string]WindowState{ + "win1": {Width: 800, Height: 600}, + }) + require.NoError(t, err) + + first, ok := lm.GetLayout("evolving") + require.True(t, ok) + originalCreatedAt := first.CreatedAt + originalUpdatedAt := first.UpdatedAt + + // Small delay to ensure UpdatedAt differs + time.Sleep(2 * time.Millisecond) + + // Second save with same name but different windows + err = lm.SaveLayout("evolving", map[string]WindowState{ + "win1": {Width: 1024, Height: 768}, + "win2": {Width: 640, Height: 480}, + }) + require.NoError(t, err) + + updated, ok := lm.GetLayout("evolving") + require.True(t, ok) + + // CreatedAt should be preserved from the original save + assert.Equal(t, originalCreatedAt, updated.CreatedAt, "CreatedAt should be preserved on update") + // UpdatedAt should be newer + assert.GreaterOrEqual(t, updated.UpdatedAt, originalUpdatedAt, "UpdatedAt should advance on update") + // Windows should reflect the second save + assert.Len(t, updated.Windows, 2) + assert.Equal(t, 1024, updated.Windows["win1"].Width) +} + +func TestLayoutManager_ListLayouts_Good(t *testing.T) { + lm := NewLayoutManagerWithDir(t.TempDir()) + require.NoError(t, lm.SaveLayout("coding", map[string]WindowState{ + "editor": {Width: 960}, "terminal": {Width: 960}, + })) + require.NoError(t, lm.SaveLayout("presenting", map[string]WindowState{ + "slides": {Width: 1920}, + })) + require.NoError(t, lm.SaveLayout("debugging", map[string]WindowState{ + "code": {Width: 640}, "debugger": {Width: 640}, "console": {Width: 640}, + })) + + infos := lm.ListLayouts() + assert.Len(t, infos, 3) + + // Build a lookup map for assertions regardless of order + byName := make(map[string]LayoutInfo) + for _, info := range infos { + byName[info.Name] = info + } + + assert.Equal(t, 2, byName["coding"].WindowCount) + assert.Equal(t, 1, byName["presenting"].WindowCount) + assert.Equal(t, 3, byName["debugging"].WindowCount) +} + +func TestLayoutManager_DeleteLayout_Good(t *testing.T) { + lm := NewLayoutManagerWithDir(t.TempDir()) + require.NoError(t, lm.SaveLayout("temporary", map[string]WindowState{ + "win": {Width: 800}, + })) + + // Verify it exists + _, ok := lm.GetLayout("temporary") + require.True(t, ok) + + lm.DeleteLayout("temporary") + + // Verify it is gone + _, ok = lm.GetLayout("temporary") + assert.False(t, ok) + + // Verify list is empty + assert.Empty(t, lm.ListLayouts()) +} + +func TestLayoutManager_Persistence_Good(t *testing.T) { + dir := t.TempDir() + + // First manager: save layout to disk + lm1 := NewLayoutManagerWithDir(dir) + err := lm1.SaveLayout("persisted", map[string]WindowState{ + "main": {X: 0, Y: 0, Width: 1280, Height: 800}, + "sidebar": {X: 1280, Y: 0, Width: 640, Height: 800}, + }) + require.NoError(t, err) + + // Second manager: load from the same directory + lm2 := NewLayoutManagerWithDir(dir) + + layout, ok := lm2.GetLayout("persisted") + require.True(t, ok) + assert.Equal(t, "persisted", layout.Name) + assert.Len(t, layout.Windows, 2) + assert.Equal(t, 1280, layout.Windows["main"].Width) + assert.Equal(t, 800, layout.Windows["main"].Height) + assert.Equal(t, 640, layout.Windows["sidebar"].Width) + assert.NotZero(t, layout.CreatedAt) + assert.NotZero(t, layout.UpdatedAt) +} diff --git a/pkg/window/platform.go b/pkg/window/platform.go index 37785ff9..272cecf7 100644 --- a/pkg/window/platform.go +++ b/pkg/window/platform.go @@ -4,7 +4,7 @@ package window // Platform abstracts the windowing backend (Wails v3). // Use: var p window.Platform type Platform interface { - CreateWindow(opts PlatformWindowOptions) PlatformWindow + CreateWindow(options PlatformWindowOptions) PlatformWindow GetWindows() []PlatformWindow } @@ -63,6 +63,26 @@ type PlatformWindow interface { OpenDevTools() CloseDevTools() + // Zoom + GetZoom() float64 + SetZoom(factor float64) + ZoomIn() + ZoomOut() + + // Content + SetURL(url string) + SetHTML(html string) + ExecJS(js string) + + // Bounds + GetBounds() Bounds + SetBounds(bounds Bounds) + + // Extras + ToggleFullscreen() + Print() error + Flash(enabled bool) + // Events OnWindowEvent(handler func(event WindowEvent)) @@ -70,6 +90,14 @@ type PlatformWindow interface { OnFileDrop(handler func(paths []string, targetID string)) } +// Bounds holds the position and dimensions of a window. +type Bounds struct { + X int `json:"x"` + Y int `json:"y"` + Width int `json:"width"` + Height int `json:"height"` +} + // WindowEvent is emitted by the backend for window state changes. // Use: evt := window.WindowEvent{Type: "focus", Name: "editor"} type WindowEvent struct { diff --git a/pkg/window/register.go b/pkg/window/register.go index b0b1a707..17dbf31d 100644 --- a/pkg/window/register.go +++ b/pkg/window/register.go @@ -3,9 +3,8 @@ package window import "forge.lthn.ai/core/go/pkg/core" -// Register creates a factory closure that captures the Platform adapter. -// The returned function has the signature WithService requires: func(*Core) (any, error). -// Use: core.WithService(window.Register(platform)) +// Register(p) binds the window service to a Core instance. +// core.WithService(window.Register(window.NewWailsPlatform(app))) func Register(p Platform) func(*core.Core) (any, error) { return func(c *core.Core) (any, error) { return &Service{ diff --git a/pkg/window/service.go b/pkg/window/service.go index f41019f0..261f35da 100644 --- a/pkg/window/service.go +++ b/pkg/window/service.go @@ -4,82 +4,66 @@ package window import ( "context" - corego "dappco.re/go/core" - "dappco.re/go/core/gui/pkg/screen" + coreerr "forge.lthn.ai/core/go-log" "forge.lthn.ai/core/go/pkg/core" + "forge.lthn.ai/core/gui/pkg/screen" ) -// Options holds configuration for the window service. -// Use: svc, err := window.Register(platform)(core.New()) type Options struct{} -// Service is a core.Service managing window lifecycle via IPC. -// Use: core.WithService(window.Register(window.NewMockPlatform())) -// It embeds ServiceRuntime for Core access and composes Manager for platform operations. -// Use: svc, err := window.Register(platform)(core.New()) type Service struct { *core.ServiceRuntime[Options] manager *Manager platform Platform } -// OnStartup queries config from the display orchestrator and registers IPC handlers. -// Use: _ = svc.OnStartup(context.Background()) func (s *Service) OnStartup(ctx context.Context) error { // Query config — display registers its handler before us (registration order guarantee). // If display is not registered, handled=false and we skip config. - cfg, handled, _ := s.Core().QUERY(QueryConfig{}) + configValue, handled, _ := s.Core().QUERY(QueryConfig{}) if handled { - if wCfg, ok := cfg.(map[string]any); ok { - s.applyConfig(wCfg) + if windowConfig, ok := configValue.(map[string]any); ok { + s.applyConfig(windowConfig) } } - // Register QUERY and TASK handlers manually. - // ACTION handler (HandleIPCEvents) is auto-registered by WithService — - // do NOT call RegisterAction here or actions will double-fire. s.Core().RegisterQuery(s.handleQuery) s.Core().RegisterTask(s.handleTask) return nil } -func (s *Service) applyConfig(cfg map[string]any) { - if width, ok := cfg["default_width"]; ok { +func (s *Service) applyConfig(configData map[string]any) { + if width, ok := configData["default_width"]; ok { if width, ok := width.(int); ok { s.manager.SetDefaultWidth(width) } } - if height, ok := cfg["default_height"]; ok { + if height, ok := configData["default_height"]; ok { if height, ok := height.(int); ok { s.manager.SetDefaultHeight(height) } } - if stateFile, ok := cfg["state_file"]; ok { + if stateFile, ok := configData["state_file"]; ok { if stateFile, ok := stateFile.(string); ok { s.manager.State().SetPath(stateFile) } } } -// HandleIPCEvents is auto-discovered and registered by core.WithService. -// Use: _ = svc.HandleIPCEvents(core, msg) func (s *Service) HandleIPCEvents(c *core.Core, msg core.Message) error { return nil } -// --- Query Handlers --- - func (s *Service) handleQuery(c *core.Core, q core.Query) (any, bool, error) { switch q := q.(type) { case QueryWindowList: return s.queryWindowList(), true, nil case QueryWindowByName: return s.queryWindowByName(q.Name), true, nil + case QueryWindowZoom: + return s.queryWindowZoom(q.Name) case QueryWindowBounds: - if info := s.queryWindowByName(q.Name); info != nil { - return &Bounds{X: info.X, Y: info.Y, Width: info.Width, Height: info.Height}, true, nil - } - return (*Bounds)(nil), true, nil + return s.queryWindowBounds(q.Name) case QueryLayoutList: return s.manager.Layout().ListLayouts(), true, nil case QueryLayoutGet: @@ -129,6 +113,23 @@ func (s *Service) queryWindowList() []WindowInfo { return result } +func (s *Service) queryWindowZoom(name string) (any, bool, error) { + pw, ok := s.manager.Get(name) + if !ok { + return nil, true, coreerr.E("window.queryWindowZoom", "window not found: "+name, nil) + } + return pw.GetZoom(), true, nil +} + +func (s *Service) queryWindowBounds(name string) (any, bool, error) { + pw, ok := s.manager.Get(name) + if !ok { + return nil, true, coreerr.E("window.queryWindowBounds", "window not found: "+name, nil) + } + bounds := pw.GetBounds() + return &bounds, true, nil +} + func (s *Service) queryWindowByName(name string) *WindowInfo { pw, ok := s.manager.Get(name) if !ok { @@ -161,7 +162,7 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { case TaskSetPosition: return nil, true, s.taskSetPosition(t.Name, t.X, t.Y) case TaskSetSize: - return nil, true, s.taskSetSize(t.Name, t.Width, t.Height, t.W, t.H) + return nil, true, s.taskSetSize(t.Name, t.Width, t.Height) case TaskMaximise: return nil, true, s.taskMaximise(t.Name) case TaskMinimise: @@ -176,12 +177,24 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { return nil, true, s.taskSetAlwaysOnTop(t.Name, t.AlwaysOnTop) case TaskSetBackgroundColour: return nil, true, s.taskSetBackgroundColour(t.Name, t.Red, t.Green, t.Blue, t.Alpha) - case TaskSetOpacity: - return nil, true, s.taskSetOpacity(t.Name, t.Opacity) case TaskSetVisibility: return nil, true, s.taskSetVisibility(t.Name, t.Visible) case TaskFullscreen: return nil, true, s.taskFullscreen(t.Name, t.Fullscreen) + case TaskSetZoom: + return nil, true, s.taskSetZoom(t.Name, t.Factor) + case TaskSetURL: + return nil, true, s.taskSetURL(t.Name, t.URL) + case TaskSetHTML: + return nil, true, s.taskSetHTML(t.Name, t.HTML) + case TaskExecJS: + return nil, true, s.taskExecJS(t.Name, t.JS) + case TaskToggleFullscreen: + return nil, true, s.taskToggleFullscreen(t.Name) + case TaskPrint: + return nil, true, s.taskPrint(t.Name) + case TaskFlash: + return nil, true, s.taskFlash(t.Name, t.Enabled) case TaskSaveLayout: return nil, true, s.taskSaveLayout(t.Name) case TaskRestoreLayout: @@ -191,14 +204,10 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { return nil, true, nil case TaskTileWindows: return nil, true, s.taskTileWindows(t.Mode, t.Windows) - case TaskSnapWindow: - return nil, true, s.taskSnapWindow(t.Name, t.Position) - case TaskArrangePair: - return nil, true, s.taskArrangePair(t.First, t.Second) - case TaskBesideEditor: - return nil, true, s.taskBesideEditor(t.Editor, t.Window) case TaskStackWindows: return nil, true, s.taskStackWindows(t.Windows, t.OffsetX, t.OffsetY) + case TaskSnapWindow: + return nil, true, s.taskSnapWindow(t.Name, t.Position) case TaskApplyWorkflow: return nil, true, s.taskApplyWorkflow(t.Workflow, t.Windows) default: @@ -206,17 +215,44 @@ func (s *Service) handleTask(c *core.Core, t core.Task) (any, bool, error) { } } -func (s *Service) taskOpenWindow(t TaskOpenWindow) (any, bool, error) { - var ( - pw PlatformWindow - err error - ) - if t.Window != nil { - spec := *t.Window - pw, err = s.manager.Create(&spec) - } else { - pw, err = s.manager.Open(t.Opts...) +func (s *Service) primaryScreenArea() (int, int, int, int) { + const fallbackX = 0 + const fallbackY = 0 + const fallbackWidth = 1920 + const fallbackHeight = 1080 + + result, handled, err := s.Core().QUERY(screen.QueryPrimary{}) + if err != nil || !handled { + return fallbackX, fallbackY, fallbackWidth, fallbackHeight } + + primary, ok := result.(*screen.Screen) + if !ok || primary == nil { + return fallbackX, fallbackY, fallbackWidth, fallbackHeight + } + + x := primary.WorkArea.X + y := primary.WorkArea.Y + width := primary.WorkArea.Width + height := primary.WorkArea.Height + if width <= 0 || height <= 0 { + x = primary.Bounds.X + y = primary.Bounds.Y + width = primary.Bounds.Width + height = primary.Bounds.Height + } + if width <= 0 || height <= 0 { + return fallbackX, fallbackY, fallbackWidth, fallbackHeight + } + + return x, y, width, height +} + +func (s *Service) taskOpenWindow(t TaskOpenWindow) (any, bool, error) { + if t.Window == nil { + return nil, true, coreerr.E("window.taskOpenWindow", "window descriptor is required", nil) + } + pw, err := s.manager.CreateWindow(*t.Window) if err != nil { return nil, true, err } @@ -261,7 +297,7 @@ func (s *Service) trackWindow(pw PlatformWindow) { if data := e.Data; data != nil { w, _ := data["w"].(int) h, _ := data["h"].(int) - _ = s.Core().ACTION(ActionWindowResized{Name: e.Name, Width: w, Height: h, W: w, H: h}) + _ = s.Core().ACTION(ActionWindowResized{Name: e.Name, Width: w, Height: h}) } case "close": _ = s.Core().ACTION(ActionWindowClosed{Name: e.Name}) @@ -279,7 +315,7 @@ func (s *Service) trackWindow(pw PlatformWindow) { func (s *Service) taskCloseWindow(name string) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskClose", "window not found: "+name, nil) } // Persist state BEFORE closing (spec requirement) s.manager.State().CaptureState(pw) @@ -291,27 +327,17 @@ func (s *Service) taskCloseWindow(name string) error { func (s *Service) taskSetPosition(name string, x, y int) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskSetPosition", "window not found: "+name, nil) } pw.SetPosition(x, y) s.manager.State().UpdatePosition(name, x, y) return nil } -func (s *Service) taskSetSize(name string, width, height, fallbackWidth, fallbackHeight int) error { +func (s *Service) taskSetSize(name string, width, height int) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) - } - if width == 0 && height == 0 { - width, height = fallbackWidth, fallbackHeight - } else { - if width == 0 { - width = fallbackWidth - } - if height == 0 { - height = fallbackHeight - } + return coreerr.E("window.taskSetSize", "window not found: "+name, nil) } pw.SetSize(width, height) s.manager.State().UpdateSize(name, width, height) @@ -321,7 +347,7 @@ func (s *Service) taskSetSize(name string, width, height, fallbackWidth, fallbac func (s *Service) taskMaximise(name string) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskMaximise", "window not found: "+name, nil) } pw.Maximise() s.manager.State().UpdateMaximized(name, true) @@ -331,7 +357,7 @@ func (s *Service) taskMaximise(name string) error { func (s *Service) taskMinimise(name string) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskMinimise", "window not found: "+name, nil) } pw.Minimise() return nil @@ -340,7 +366,7 @@ func (s *Service) taskMinimise(name string) error { func (s *Service) taskFocus(name string) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskFocus", "window not found: "+name, nil) } pw.Focus() return nil @@ -349,7 +375,7 @@ func (s *Service) taskFocus(name string) error { func (s *Service) taskRestore(name string) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskRestore", "window not found: "+name, nil) } pw.Restore() s.manager.State().UpdateMaximized(name, false) @@ -359,7 +385,7 @@ func (s *Service) taskRestore(name string) error { func (s *Service) taskSetTitle(name, title string) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskSetTitle", "window not found: "+name, nil) } pw.SetTitle(title) return nil @@ -368,7 +394,7 @@ func (s *Service) taskSetTitle(name, title string) error { func (s *Service) taskSetAlwaysOnTop(name string, alwaysOnTop bool) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskSetAlwaysOnTop", "window not found: "+name, nil) } pw.SetAlwaysOnTop(alwaysOnTop) return nil @@ -377,28 +403,16 @@ func (s *Service) taskSetAlwaysOnTop(name string, alwaysOnTop bool) error { func (s *Service) taskSetBackgroundColour(name string, red, green, blue, alpha uint8) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskSetBackgroundColour", "window not found: "+name, nil) } pw.SetBackgroundColour(red, green, blue, alpha) return nil } -func (s *Service) taskSetOpacity(name string, opacity float32) error { - if opacity < 0 || opacity > 1 { - return corego.E("window.setOpacity", "opacity must be between 0 and 1", nil) - } - pw, ok := s.manager.Get(name) - if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) - } - pw.SetOpacity(opacity) - return nil -} - func (s *Service) taskSetVisibility(name string, visible bool) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskSetVisibility", "window not found: "+name, nil) } pw.SetVisibility(visible) return nil @@ -407,7 +421,7 @@ func (s *Service) taskSetVisibility(name string, visible bool) error { func (s *Service) taskFullscreen(name string, fullscreen bool) error { pw, ok := s.manager.Get(name) if !ok { - return corego.E("window.service", corego.Sprintf("window not found: %s", name), nil) + return coreerr.E("window.taskFullscreen", "window not found: "+name, nil) } if fullscreen { pw.Fullscreen() @@ -417,6 +431,68 @@ func (s *Service) taskFullscreen(name string, fullscreen bool) error { return nil } +func (s *Service) taskSetZoom(name string, factor float64) error { + pw, ok := s.manager.Get(name) + if !ok { + return coreerr.E("window.taskSetZoom", "window not found: "+name, nil) + } + pw.SetZoom(factor) + return nil +} + +func (s *Service) taskSetURL(name, url string) error { + pw, ok := s.manager.Get(name) + if !ok { + return coreerr.E("window.taskSetURL", "window not found: "+name, nil) + } + pw.SetURL(url) + return nil +} + +func (s *Service) taskSetHTML(name, html string) error { + pw, ok := s.manager.Get(name) + if !ok { + return coreerr.E("window.taskSetHTML", "window not found: "+name, nil) + } + pw.SetHTML(html) + return nil +} + +func (s *Service) taskExecJS(name, js string) error { + pw, ok := s.manager.Get(name) + if !ok { + return coreerr.E("window.taskExecJS", "window not found: "+name, nil) + } + pw.ExecJS(js) + return nil +} + +func (s *Service) taskToggleFullscreen(name string) error { + pw, ok := s.manager.Get(name) + if !ok { + return coreerr.E("window.taskToggleFullscreen", "window not found: "+name, nil) + } + pw.ToggleFullscreen() + return nil +} + +func (s *Service) taskPrint(name string) error { + pw, ok := s.manager.Get(name) + if !ok { + return coreerr.E("window.taskPrint", "window not found: "+name, nil) + } + return pw.Print() +} + +func (s *Service) taskFlash(name string, enabled bool) error { + pw, ok := s.manager.Get(name) + if !ok { + return coreerr.E("window.taskFlash", "window not found: "+name, nil) + } + pw.Flash(enabled) + return nil +} + func (s *Service) taskSaveLayout(name string) error { windows := s.queryWindowList() states := make(map[string]WindowState, len(windows)) @@ -432,7 +508,7 @@ func (s *Service) taskSaveLayout(name string) error { func (s *Service) taskRestoreLayout(name string) error { layout, ok := s.manager.Layout().GetLayout(name) if !ok { - return corego.E("window.restoreLayout", corego.Sprintf("layout not found: %s", name), nil) + return coreerr.E("window.taskRestoreLayout", "layout not found: "+name, nil) } for winName, state := range layout.Windows { pw, found := s.manager.Get(winName) @@ -449,6 +525,7 @@ func (s *Service) taskRestoreLayout(name string) error { } else { pw.Restore() } + s.manager.State().CaptureState(pw) } return nil } @@ -464,13 +541,21 @@ var tileModeMap = map[string]TileMode{ func (s *Service) taskTileWindows(mode string, names []string) error { tm, ok := tileModeMap[mode] if !ok { - return corego.E("window.tileWindows", corego.Sprintf("unknown tile mode: %s", mode), nil) + return coreerr.E("window.taskTileWindows", "unknown tile mode: "+mode, nil) } if len(names) == 0 { names = s.manager.List() } - screenW, screenH := s.primaryScreenSize() - return s.manager.TileWindows(tm, names, screenW, screenH) + originX, originY, screenWidth, screenHeight := s.primaryScreenArea() + return s.manager.TileWindows(tm, names, screenWidth, screenHeight, originX, originY) +} + +func (s *Service) taskStackWindows(names []string, offsetX, offsetY int) error { + if len(names) == 0 { + names = s.manager.List() + } + originX, originY, _, _ := s.primaryScreenArea() + return s.manager.StackWindows(names, offsetX, offsetY, originX, originY) } var snapPosMap = map[string]SnapPosition{ @@ -484,100 +569,29 @@ var snapPosMap = map[string]SnapPosition{ func (s *Service) taskSnapWindow(name, position string) error { pos, ok := snapPosMap[position] if !ok { - return corego.E("window.snapWindow", corego.Sprintf("unknown snap position: %s", position), nil) + return coreerr.E("window.taskSnapWindow", "unknown snap position: "+position, nil) } - screenW, screenH := s.primaryScreenSize() - return s.manager.SnapWindow(name, pos, screenW, screenH) + originX, originY, screenWidth, screenHeight := s.primaryScreenArea() + return s.manager.SnapWindow(name, pos, screenWidth, screenHeight, originX, originY) } -func (s *Service) taskArrangePair(first, second string) error { - screenW, screenH := s.primaryScreenSize() - return s.manager.ArrangePair(first, second, screenW, screenH) +var workflowLayoutMap = map[string]WorkflowLayout{ + "coding": WorkflowCoding, + "debugging": WorkflowDebugging, + "presenting": WorkflowPresenting, + "side-by-side": WorkflowSideBySide, } -func (s *Service) taskBesideEditor(editorName, windowName string) error { - screenW, screenH := s.primaryScreenSize() - if editorName == "" { - editorName = s.detectEditorWindow() +func (s *Service) taskApplyWorkflow(workflow string, names []string) error { + layout, ok := workflowLayoutMap[workflow] + if !ok { + return coreerr.E("window.taskApplyWorkflow", "unknown workflow layout: "+workflow, nil) } - if editorName == "" { - return corego.E("window.besideEditor", "editor window not found", nil) - } - if windowName == "" { - windowName = s.detectCompanionWindow(editorName) - } - if windowName == "" { - return corego.E("window.besideEditor", "companion window not found", nil) - } - return s.manager.BesideEditor(editorName, windowName, screenW, screenH) -} - -func (s *Service) taskStackWindows(names []string, offsetX, offsetY int) error { if len(names) == 0 { names = s.manager.List() } - return s.manager.StackWindows(names, offsetX, offsetY) -} - -func (s *Service) taskApplyWorkflow(workflow WorkflowLayout, names []string) error { - screenW, screenH := s.primaryScreenSize() - if len(names) == 0 { - names = s.manager.List() - } - return s.manager.ApplyWorkflow(workflow, names, screenW, screenH) -} - -func (s *Service) detectEditorWindow() string { - for _, info := range s.queryWindowList() { - if looksLikeEditor(info.Name, info.Title) { - return info.Name - } - } - return "" -} - -func (s *Service) detectCompanionWindow(editorName string) string { - for _, info := range s.queryWindowList() { - if info.Name == editorName { - continue - } - if !looksLikeEditor(info.Name, info.Title) { - return info.Name - } - } - return "" -} - -func looksLikeEditor(name, title string) bool { - return containsAny(name, "editor", "ide", "code", "workspace") || containsAny(title, "editor", "ide", "code") -} - -func containsAny(value string, needles ...string) bool { - lower := corego.Lower(value) - for _, needle := range needles { - if corego.Contains(lower, needle) { - return true - } - } - return false -} - -func (s *Service) primaryScreenSize() (int, int) { - result, handled, err := s.Core().QUERY(screen.QueryPrimary{}) - if err == nil && handled { - if scr, ok := result.(*screen.Screen); ok && scr != nil { - if scr.WorkArea.Width > 0 && scr.WorkArea.Height > 0 { - return scr.WorkArea.Width, scr.WorkArea.Height - } - if scr.Bounds.Width > 0 && scr.Bounds.Height > 0 { - return scr.Bounds.Width, scr.Bounds.Height - } - if scr.Size.Width > 0 && scr.Size.Height > 0 { - return scr.Size.Width, scr.Size.Height - } - } - } - return 1920, 1080 + originX, originY, screenWidth, screenHeight := s.primaryScreenArea() + return s.manager.ApplyWorkflow(layout, names, screenWidth, screenHeight, originX, originY) } // Manager returns the underlying window Manager for direct access. diff --git a/pkg/window/service_screen_test.go b/pkg/window/service_screen_test.go new file mode 100644 index 00000000..00c511eb --- /dev/null +++ b/pkg/window/service_screen_test.go @@ -0,0 +1,133 @@ +package window + +import ( + "context" + "testing" + + "forge.lthn.ai/core/go/pkg/core" + "forge.lthn.ai/core/gui/pkg/screen" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +type mockScreenPlatform struct { + screens []screen.Screen +} + +func (m *mockScreenPlatform) GetAll() []screen.Screen { return m.screens } + +func (m *mockScreenPlatform) GetPrimary() *screen.Screen { + for i := range m.screens { + if m.screens[i].IsPrimary { + return &m.screens[i] + } + } + return nil +} + +func (m *mockScreenPlatform) GetCurrent() *screen.Screen { + return m.GetPrimary() +} + +func newTestWindowServiceWithScreen(t *testing.T, screens []screen.Screen) (*Service, *core.Core) { + t.Helper() + + c, err := core.New( + core.WithService(screen.Register(&mockScreenPlatform{screens: screens})), + core.WithService(Register(newMockPlatform())), + core.WithServiceLock(), + ) + require.NoError(t, err) + require.NoError(t, c.ServiceStartup(context.Background(), nil)) + + svc := core.MustServiceFor[*Service](c, "window") + return svc, c +} + +func TestTaskTileWindows_Good_UsesPrimaryScreenSize(t *testing.T) { + _, c := newTestWindowServiceWithScreen(t, []screen.Screen{ + { + ID: "1", Name: "Primary", IsPrimary: true, + Bounds: screen.Rect{X: 0, Y: 0, Width: 2000, Height: 1000}, + WorkArea: screen.Rect{X: 0, Y: 0, Width: 2000, Height: 1000}, + }, + }) + + _ = requireOpenWindow(t, c, Window{Name: "left", Width: 400, Height: 400}) + _ = requireOpenWindow(t, c, Window{Name: "right", Width: 400, Height: 400}) + + _, handled, err := c.PERFORM(TaskTileWindows{Mode: "left-right", Windows: []string{"left", "right"}}) + require.NoError(t, err) + assert.True(t, handled) + + result, _, err := c.QUERY(QueryWindowByName{Name: "left"}) + require.NoError(t, err) + left := result.(*WindowInfo) + assert.Equal(t, 0, left.X) + assert.Equal(t, 1000, left.Width) + assert.Equal(t, 1000, left.Height) + + result, _, err = c.QUERY(QueryWindowByName{Name: "right"}) + require.NoError(t, err) + right := result.(*WindowInfo) + assert.Equal(t, 1000, right.X) + assert.Equal(t, 1000, right.Width) + assert.Equal(t, 1000, right.Height) +} + +func TestTaskSnapWindow_Good_UsesPrimaryScreenSize(t *testing.T) { + _, c := newTestWindowServiceWithScreen(t, []screen.Screen{ + { + ID: "1", Name: "Primary", IsPrimary: true, + Bounds: screen.Rect{X: 0, Y: 0, Width: 2000, Height: 1000}, + WorkArea: screen.Rect{X: 0, Y: 0, Width: 2000, Height: 1000}, + }, + }) + + _ = requireOpenWindow(t, c, Window{Name: "snap", Width: 400, Height: 300}) + + _, handled, err := c.PERFORM(TaskSnapWindow{Name: "snap", Position: "left"}) + require.NoError(t, err) + assert.True(t, handled) + + result, _, err := c.QUERY(QueryWindowByName{Name: "snap"}) + require.NoError(t, err) + info := result.(*WindowInfo) + assert.Equal(t, 0, info.X) + assert.Equal(t, 0, info.Y) + assert.Equal(t, 1000, info.Width) + assert.Equal(t, 1000, info.Height) +} + +func TestTaskTileWindows_Good_UsesPrimaryWorkAreaOrigin(t *testing.T) { + _, c := newTestWindowServiceWithScreen(t, []screen.Screen{ + { + ID: "1", Name: "Primary", IsPrimary: true, + Bounds: screen.Rect{X: 0, Y: 0, Width: 2000, Height: 1000}, + WorkArea: screen.Rect{X: 100, Y: 50, Width: 2000, Height: 1000}, + }, + }) + + _ = requireOpenWindow(t, c, Window{Name: "left", Width: 400, Height: 400}) + _ = requireOpenWindow(t, c, Window{Name: "right", Width: 400, Height: 400}) + + _, handled, err := c.PERFORM(TaskTileWindows{Mode: "left-right", Windows: []string{"left", "right"}}) + require.NoError(t, err) + assert.True(t, handled) + + result, _, err := c.QUERY(QueryWindowByName{Name: "left"}) + require.NoError(t, err) + left := result.(*WindowInfo) + assert.Equal(t, 100, left.X) + assert.Equal(t, 50, left.Y) + assert.Equal(t, 1000, left.Width) + assert.Equal(t, 1000, left.Height) + + result, _, err = c.QUERY(QueryWindowByName{Name: "right"}) + require.NoError(t, err) + right := result.(*WindowInfo) + assert.Equal(t, 1100, right.X) + assert.Equal(t, 50, right.Y) + assert.Equal(t, 1000, right.Width) + assert.Equal(t, 1000, right.Height) +} diff --git a/pkg/window/service_test.go b/pkg/window/service_test.go index 36b10d8a..e3497128 100644 --- a/pkg/window/service_test.go +++ b/pkg/window/service_test.go @@ -23,39 +23,12 @@ func newTestWindowService(t *testing.T) (*Service, *core.Core) { return svc, c } -type testScreenPlatform struct { - screens []screen.Screen -} - -func (p *testScreenPlatform) GetAll() []screen.Screen { return p.screens } - -func (p *testScreenPlatform) GetPrimary() *screen.Screen { - for i := range p.screens { - if p.screens[i].IsPrimary { - return &p.screens[i] - } - } - return nil -} - -func newTestWindowServiceWithScreen(t *testing.T) (*Service, *core.Core) { +func requireOpenWindow(t *testing.T, c *core.Core, window Window) WindowInfo { t.Helper() - c, err := core.New( - core.WithService(Register(newMockPlatform())), - core.WithService(screen.Register(&testScreenPlatform{ - screens: []screen.Screen{{ - ID: "primary", Name: "Primary", IsPrimary: true, - Size: screen.Size{Width: 2560, Height: 1440}, - Bounds: screen.Rect{X: 0, Y: 0, Width: 2560, Height: 1440}, - WorkArea: screen.Rect{X: 0, Y: 0, Width: 2560, Height: 1440}, - }}, - })), - core.WithServiceLock(), - ) + result, handled, err := c.PERFORM(TaskOpenWindow{Window: &window}) require.NoError(t, err) - require.NoError(t, c.ServiceStartup(context.Background(), nil)) - svc := core.MustServiceFor[*Service](c, "window") - return svc, c + require.True(t, handled) + return result.(WindowInfo) } func TestRegister_Good(t *testing.T) { @@ -82,7 +55,7 @@ func TestApplyConfig_Good(t *testing.T) { func TestTaskOpenWindow_Good(t *testing.T) { _, c := newTestWindowService(t) result, handled, err := c.PERFORM(TaskOpenWindow{ - Opts: []WindowOption{WithName("test"), WithURL("/")}, + Window: &Window{Name: "test", URL: "/"}, }) require.NoError(t, err) assert.True(t, handled) @@ -90,16 +63,12 @@ func TestTaskOpenWindow_Good(t *testing.T) { assert.Equal(t, "test", info.Name) } -func TestTaskOpenWindowDescriptor_Good(t *testing.T) { +func TestTaskOpenWindow_Bad_MissingWindow(t *testing.T) { _, c := newTestWindowService(t) - result, handled, err := c.PERFORM(TaskOpenWindow{ - Window: &Window{Name: "descriptor", Title: "Descriptor", Width: 640, Height: 480}, - }) - require.NoError(t, err) + result, handled, err := c.PERFORM(TaskOpenWindow{}) assert.True(t, handled) - info := result.(WindowInfo) - assert.Equal(t, "descriptor", info.Name) - assert.Equal(t, "Descriptor", info.Title) + assert.Error(t, err) + assert.Nil(t, result) } func TestTaskOpenWindow_Bad(t *testing.T) { @@ -112,9 +81,8 @@ func TestTaskOpenWindow_Bad(t *testing.T) { func TestQueryWindowList_Good(t *testing.T) { _, c := newTestWindowService(t) - _, _, _ = c.PERFORM(TaskOpenWindow{Opts: []WindowOption{WithName("a")}}) - _, _, _ = c.PERFORM(TaskOpenWindow{Opts: []WindowOption{WithName("b")}}) - _, _, _ = c.PERFORM(TaskMinimise{Name: "b"}) + _ = requireOpenWindow(t, c, Window{Name: "a"}) + _ = requireOpenWindow(t, c, Window{Name: "b"}) result, handled, err := c.QUERY(QueryWindowList{}) require.NoError(t, err) @@ -135,7 +103,7 @@ func TestQueryWindowList_Good(t *testing.T) { func TestQueryWindowByName_Good(t *testing.T) { _, c := newTestWindowService(t) - _, _, _ = c.PERFORM(TaskOpenWindow{Opts: []WindowOption{WithName("test")}}) + _ = requireOpenWindow(t, c, Window{Name: "test"}) result, handled, err := c.QUERY(QueryWindowByName{Name: "test"}) require.NoError(t, err) @@ -156,7 +124,7 @@ func TestQueryWindowByName_Bad(t *testing.T) { func TestTaskCloseWindow_Good(t *testing.T) { _, c := newTestWindowService(t) - _, _, _ = c.PERFORM(TaskOpenWindow{Opts: []WindowOption{WithName("test")}}) + _ = requireOpenWindow(t, c, Window{Name: "test"}) _, handled, err := c.PERFORM(TaskCloseWindow{Name: "test"}) require.NoError(t, err) @@ -176,7 +144,7 @@ func TestTaskCloseWindow_Bad(t *testing.T) { func TestTaskSetPosition_Good(t *testing.T) { _, c := newTestWindowService(t) - _, _, _ = c.PERFORM(TaskOpenWindow{Opts: []WindowOption{WithName("test")}}) + _ = requireOpenWindow(t, c, Window{Name: "test"}) _, handled, err := c.PERFORM(TaskSetPosition{Name: "test", X: 100, Y: 200}) require.NoError(t, err) @@ -190,9 +158,9 @@ func TestTaskSetPosition_Good(t *testing.T) { func TestTaskSetSize_Good(t *testing.T) { _, c := newTestWindowService(t) - _, _, _ = c.PERFORM(TaskOpenWindow{Opts: []WindowOption{WithName("test")}}) + _ = requireOpenWindow(t, c, Window{Name: "test"}) - _, handled, err := c.PERFORM(TaskSetSize{Name: "test", W: 800, H: 600}) + _, handled, err := c.PERFORM(TaskSetSize{Name: "test", Width: 800, Height: 600}) require.NoError(t, err) assert.True(t, handled) @@ -376,7 +344,7 @@ func TestTaskRestoreLayout_ClearsMaximizedState(t *testing.T) { func TestTaskMaximise_Good(t *testing.T) { _, c := newTestWindowService(t) - _, _, _ = c.PERFORM(TaskOpenWindow{Opts: []WindowOption{WithName("test")}}) + _ = requireOpenWindow(t, c, Window{Name: "test"}) _, handled, err := c.PERFORM(TaskMaximise{Name: "test"}) require.NoError(t, err) @@ -391,10 +359,7 @@ func TestFileDrop_Good(t *testing.T) { _, c := newTestWindowService(t) // Open a window - result, _, _ := c.PERFORM(TaskOpenWindow{ - Opts: []WindowOption{WithName("drop-test")}, - }) - info := result.(WindowInfo) + info := requireOpenWindow(t, c, Window{Name: "drop-test"}) assert.Equal(t, "drop-test", info.Name) // Capture broadcast actions @@ -422,3 +387,538 @@ func TestFileDrop_Good(t *testing.T) { assert.Equal(t, "upload-zone", dropped.TargetID) mu.Unlock() } + +// --- TaskMinimise --- + +func TestTaskMinimise_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskMinimise{Name: "test"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.True(t, mw.minimised) +} + +func TestTaskMinimise_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskMinimise{Name: "nonexistent"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskFocus --- + +func TestTaskFocus_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskFocus{Name: "test"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.True(t, mw.focused) +} + +func TestTaskFocus_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskFocus{Name: "nonexistent"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskRestore --- + +func TestTaskRestore_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + // First maximise, then restore + _, _, _ = c.PERFORM(TaskMaximise{Name: "test"}) + + _, handled, err := c.PERFORM(TaskRestore{Name: "test"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.False(t, mw.maximised) + + // Verify state was updated + state, ok := svc.Manager().State().GetState("test") + assert.True(t, ok) + assert.False(t, state.Maximized) +} + +func TestTaskRestore_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskRestore{Name: "nonexistent"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskSetTitle --- + +func TestTaskSetTitle_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskSetTitle{Name: "test", Title: "New Title"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + assert.Equal(t, "New Title", pw.Title()) +} + +func TestTaskSetTitle_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskSetTitle{Name: "nonexistent", Title: "Nope"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskSetAlwaysOnTop --- + +func TestTaskSetAlwaysOnTop_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskSetAlwaysOnTop{Name: "test", AlwaysOnTop: true}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.True(t, mw.alwaysOnTop) +} + +func TestTaskSetAlwaysOnTop_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskSetAlwaysOnTop{Name: "nonexistent", AlwaysOnTop: true}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskSetBackgroundColour --- + +func TestTaskSetBackgroundColour_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskSetBackgroundColour{ + Name: "test", Red: 10, Green: 20, Blue: 30, Alpha: 40, + }) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.Equal(t, [4]uint8{10, 20, 30, 40}, mw.backgroundColour) +} + +func TestTaskSetBackgroundColour_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskSetBackgroundColour{Name: "nonexistent", Red: 1, Green: 2, Blue: 3, Alpha: 4}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskSetVisibility --- + +func TestTaskSetVisibility_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskSetVisibility{Name: "test", Visible: true}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.True(t, mw.visible) + + // Now hide it + _, handled, err = c.PERFORM(TaskSetVisibility{Name: "test", Visible: false}) + require.NoError(t, err) + assert.True(t, handled) + assert.False(t, mw.visible) +} + +func TestTaskSetVisibility_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskSetVisibility{Name: "nonexistent", Visible: true}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskFullscreen --- + +func TestTaskFullscreen_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + // Enter fullscreen + _, handled, err := c.PERFORM(TaskFullscreen{Name: "test", Fullscreen: true}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.True(t, mw.fullscreened) + + // Exit fullscreen + _, handled, err = c.PERFORM(TaskFullscreen{Name: "test", Fullscreen: false}) + require.NoError(t, err) + assert.True(t, handled) + assert.False(t, mw.fullscreened) +} + +func TestTaskFullscreen_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskFullscreen{Name: "nonexistent", Fullscreen: true}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskSaveLayout --- + +func TestTaskSaveLayout_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "editor", Width: 960, Height: 1080, X: 0, Y: 0}) + _ = requireOpenWindow(t, c, Window{Name: "terminal", Width: 960, Height: 1080, X: 960, Y: 0}) + + _, handled, err := c.PERFORM(TaskSaveLayout{Name: "coding"}) + require.NoError(t, err) + assert.True(t, handled) + + // Verify layout was saved with correct window states + layout, ok := svc.Manager().Layout().GetLayout("coding") + assert.True(t, ok) + assert.Equal(t, "coding", layout.Name) + assert.Len(t, layout.Windows, 2) + + editorState, ok := layout.Windows["editor"] + assert.True(t, ok) + assert.Equal(t, 0, editorState.X) + assert.Equal(t, 960, editorState.Width) + + termState, ok := layout.Windows["terminal"] + assert.True(t, ok) + assert.Equal(t, 960, termState.X) + assert.Equal(t, 960, termState.Width) +} + +func TestTaskSaveLayout_Bad(t *testing.T) { + _, c := newTestWindowService(t) + // Saving an empty layout with empty name returns an error from LayoutManager + _, handled, err := c.PERFORM(TaskSaveLayout{Name: ""}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskRestoreLayout --- + +func TestTaskRestoreLayout_Good(t *testing.T) { + svc, c := newTestWindowService(t) + // Open windows + _ = requireOpenWindow(t, c, Window{Name: "editor", Width: 800, Height: 600, X: 0, Y: 0}) + _ = requireOpenWindow(t, c, Window{Name: "terminal", Width: 800, Height: 600, X: 0, Y: 0}) + + // Save a layout with specific positions + _, _, _ = c.PERFORM(TaskSaveLayout{Name: "coding"}) + + // Move the windows to different positions + _, _, _ = c.PERFORM(TaskSetPosition{Name: "editor", X: 500, Y: 500}) + _, _, _ = c.PERFORM(TaskSetPosition{Name: "terminal", X: 600, Y: 600}) + + // Restore the layout + _, handled, err := c.PERFORM(TaskRestoreLayout{Name: "coding"}) + require.NoError(t, err) + assert.True(t, handled) + + // Verify windows were moved back to saved positions + pw, ok := svc.Manager().Get("editor") + require.True(t, ok) + x, y := pw.Position() + assert.Equal(t, 0, x) + assert.Equal(t, 0, y) + + pw2, ok := svc.Manager().Get("terminal") + require.True(t, ok) + x2, y2 := pw2.Position() + assert.Equal(t, 0, x2) + assert.Equal(t, 0, y2) + + editorState, ok := svc.Manager().State().GetState("editor") + require.True(t, ok) + assert.Equal(t, 0, editorState.X) + assert.Equal(t, 0, editorState.Y) + + terminalState, ok := svc.Manager().State().GetState("terminal") + require.True(t, ok) + assert.Equal(t, 0, terminalState.X) + assert.Equal(t, 0, terminalState.Y) +} + +func TestTaskRestoreLayout_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskRestoreLayout{Name: "nonexistent"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskStackWindows --- + +func TestTaskStackWindows_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "s1", Width: 800, Height: 600}) + _ = requireOpenWindow(t, c, Window{Name: "s2", Width: 800, Height: 600}) + + _, handled, err := c.PERFORM(TaskStackWindows{Windows: []string{"s1", "s2"}, OffsetX: 25, OffsetY: 35}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("s2") + require.True(t, ok) + x, y := pw.Position() + assert.Equal(t, 25, x) + assert.Equal(t, 35, y) +} + +// --- TaskApplyWorkflow --- + +func TestTaskApplyWorkflow_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "editor", Width: 800, Height: 600}) + _ = requireOpenWindow(t, c, Window{Name: "terminal", Width: 800, Height: 600}) + + _, handled, err := c.PERFORM(TaskApplyWorkflow{Workflow: "side-by-side"}) + require.NoError(t, err) + assert.True(t, handled) + + editor, ok := svc.Manager().Get("editor") + require.True(t, ok) + x, y := editor.Position() + assert.Equal(t, 0, x) + assert.Equal(t, 0, y) + + terminal, ok := svc.Manager().Get("terminal") + require.True(t, ok) + x, y = terminal.Position() + assert.Equal(t, 960, x) + assert.Equal(t, 0, y) +} + +// --- TaskSetZoom / QueryWindowZoom --- + +func TestTaskSetZoom_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskSetZoom{Name: "test", Factor: 1.5}) + require.NoError(t, err) + assert.True(t, handled) + + result, handled, err := c.QUERY(QueryWindowZoom{Name: "test"}) + require.NoError(t, err) + assert.True(t, handled) + assert.InDelta(t, 1.5, result.(float64), 0.001) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.InDelta(t, 1.5, mw.zoom, 0.001) +} + +func TestTaskSetZoom_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskSetZoom{Name: "nonexistent", Factor: 1.2}) + assert.True(t, handled) + assert.Error(t, err) +} + +func TestQueryWindowZoom_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.QUERY(QueryWindowZoom{Name: "nonexistent"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- QueryWindowBounds --- + +func TestQueryWindowBounds_Good(t *testing.T) { + _, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "bounds-test", Width: 800, Height: 600, X: 50, Y: 75}) + + result, handled, err := c.QUERY(QueryWindowBounds{Name: "bounds-test"}) + require.NoError(t, err) + assert.True(t, handled) + bounds := result.(*Bounds) + require.NotNil(t, bounds) + assert.Equal(t, 50, bounds.X) + assert.Equal(t, 75, bounds.Y) + assert.Equal(t, 800, bounds.Width) + assert.Equal(t, 600, bounds.Height) +} + +func TestQueryWindowBounds_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.QUERY(QueryWindowBounds{Name: "nonexistent"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskSetURL --- + +func TestTaskSetURL_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskSetURL{Name: "test", URL: "/settings"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.Equal(t, "/settings", mw.url) +} + +func TestTaskSetURL_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskSetURL{Name: "nonexistent", URL: "/nope"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskSetHTML --- + +func TestTaskSetHTML_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskSetHTML{Name: "test", HTML: "

Hello

"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.Equal(t, "

Hello

", mw.html) +} + +func TestTaskSetHTML_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskSetHTML{Name: "nonexistent", HTML: "

nope

"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskExecJS --- + +func TestTaskExecJS_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskExecJS{Name: "test", JS: "document.title = 'Updated'"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.Equal(t, "document.title = 'Updated'", mw.lastJS) +} + +func TestTaskExecJS_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskExecJS{Name: "nonexistent", JS: "alert(1)"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskToggleFullscreen --- + +func TestTaskToggleFullscreen_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskToggleFullscreen{Name: "test"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.Equal(t, 1, mw.toggleFullscreenCount) +} + +func TestTaskToggleFullscreen_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskToggleFullscreen{Name: "nonexistent"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskPrint --- + +func TestTaskPrint_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskPrint{Name: "test"}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.True(t, mw.printCalled) +} + +func TestTaskPrint_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskPrint{Name: "nonexistent"}) + assert.True(t, handled) + assert.Error(t, err) +} + +// --- TaskFlash --- + +func TestTaskFlash_Good(t *testing.T) { + svc, c := newTestWindowService(t) + _ = requireOpenWindow(t, c, Window{Name: "test"}) + + _, handled, err := c.PERFORM(TaskFlash{Name: "test", Enabled: true}) + require.NoError(t, err) + assert.True(t, handled) + + pw, ok := svc.Manager().Get("test") + require.True(t, ok) + mw := pw.(*mockWindow) + assert.True(t, mw.flashing) + + _, _, _ = c.PERFORM(TaskFlash{Name: "test", Enabled: false}) + assert.False(t, mw.flashing) +} + +func TestTaskFlash_Bad(t *testing.T) { + _, c := newTestWindowService(t) + _, handled, err := c.PERFORM(TaskFlash{Name: "nonexistent", Enabled: true}) + assert.True(t, handled) + assert.Error(t, err) +} diff --git a/pkg/window/state.go b/pkg/window/state.go index 08df4d4b..ea01bb0c 100644 --- a/pkg/window/state.go +++ b/pkg/window/state.go @@ -6,7 +6,7 @@ import ( "sync" "time" - corego "dappco.re/go/core" + coreio "forge.lthn.ai/core/go-io" ) // WindowState holds the persisted position/size of a window. @@ -63,18 +63,16 @@ func (sm *StateManager) filePath() string { if sm.statePath != "" { return sm.statePath } - return corego.JoinPath(sm.configDir, "window_state.json") + return filepath.Join(sm.configDir, "window_state.json") } func (sm *StateManager) dataDir() string { if sm.statePath != "" { - return corego.PathDir(sm.statePath) + return filepath.Dir(sm.statePath) } return sm.configDir } -// SetPath overrides the persisted state file path. -// Use: sm.SetPath(filepath.Join(t.TempDir(), "window_state.json")) func (sm *StateManager) SetPath(path string) { if path == "" { return @@ -94,13 +92,13 @@ func (sm *StateManager) load() { if sm.configDir == "" && sm.statePath == "" { return } - data, err := os.ReadFile(sm.filePath()) + content, err := coreio.Local.Read(sm.filePath()) if err != nil { return } sm.mu.Lock() defer sm.mu.Unlock() - _ = corego.JSONUnmarshal(data, &sm.states) + _ = json.Unmarshal([]byte(content), &sm.states) } func (sm *StateManager) save() { @@ -113,9 +111,10 @@ func (sm *StateManager) save() { if !r.OK { return } - data := r.Value.([]byte) - _ = os.MkdirAll(sm.dataDir(), 0o755) - _ = os.WriteFile(sm.filePath(), data, 0o644) + if dir := sm.dataDir(); dir != "" { + _ = coreio.Local.EnsureDir(dir) + } + _ = coreio.Local.Write(sm.filePath(), string(data)) } func (sm *StateManager) scheduleSave() { diff --git a/pkg/window/tiling.go b/pkg/window/tiling.go index 186c868b..ef289aca 100644 --- a/pkg/window/tiling.go +++ b/pkg/window/tiling.go @@ -1,19 +1,7 @@ // pkg/window/tiling.go package window -import corego "dappco.re/go/core" - -// normalizeWindowForLayout clears transient maximise/minimise state before -// applying a new geometry. This keeps layout helpers effective even when a -// window was previously maximised. -func normalizeWindowForLayout(pw PlatformWindow) { - if pw == nil { - return - } - if pw.IsMaximised() || pw.IsMinimised() { - pw.Restore() - } -} +import coreerr "forge.lthn.ai/core/go-log" // TileMode defines how windows are arranged. // Use: mode := window.TileModeLeftRight @@ -60,6 +48,16 @@ const ( SnapCenter ) +var snapPositionNames = map[SnapPosition]string{ + SnapLeft: "left", SnapRight: "right", + SnapTop: "top", SnapBottom: "bottom", + SnapTopLeft: "top-left", SnapTopRight: "top-right", + SnapBottomLeft: "bottom-left", SnapBottomRight: "bottom-right", + SnapCenter: "center", +} + +func (p SnapPosition) String() string { return snapPositionNames[p] } + // WorkflowLayout is a predefined arrangement for common tasks. // Use: workflow := window.WorkflowCoding type WorkflowLayout int @@ -80,29 +78,36 @@ var workflowNames = map[WorkflowLayout]string{ // Use: label := window.WorkflowCoding.String() func (w WorkflowLayout) String() string { return workflowNames[w] } -// ParseWorkflowLayout converts a workflow name into its enum value. -// Use: workflow, ok := window.ParseWorkflowLayout("coding") -func ParseWorkflowLayout(name string) (WorkflowLayout, bool) { - for workflow, workflowName := range workflowNames { - if workflowName == name { - return workflow, true - } +func layoutOrigin(origin []int) (int, int) { + if len(origin) == 0 { + return 0, 0 } - return WorkflowCoding, false + if len(origin) == 1 { + return origin[0], 0 + } + return origin[0], origin[1] +} + +func (m *Manager) captureState(pw PlatformWindow) { + if m.state == nil || pw == nil { + return + } + m.state.CaptureState(pw) } // TileWindows arranges the named windows in the given mode across the screen area. -func (m *Manager) TileWindows(mode TileMode, names []string, screenW, screenH int) error { +func (m *Manager) TileWindows(mode TileMode, names []string, screenW, screenH int, origin ...int) error { + originX, originY := layoutOrigin(origin) windows := make([]PlatformWindow, 0, len(names)) for _, name := range names { pw, ok := m.Get(name) if !ok { - return corego.E("window.tiling", corego.Sprintf("window %q not found", name), nil) + return coreerr.E("window.Manager.TileWindows", "window not found: "+name, nil) } windows = append(windows, pw) } if len(windows) == 0 { - return corego.E("window.tiling", "no windows to tile", nil) + return coreerr.E("window.Manager.TileWindows", "no windows to tile", nil) } halfW, halfH := screenW/2, screenH/2 @@ -111,9 +116,9 @@ func (m *Manager) TileWindows(mode TileMode, names []string, screenW, screenH in case TileModeLeftRight: w := screenW / len(windows) for i, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(i*w, 0) + pw.SetPosition(originX+i*w, originY) pw.SetSize(w, screenH) + m.captureState(pw) } case TileModeGrid: cols := 2 @@ -127,128 +132,125 @@ func (m *Manager) TileWindows(mode TileMode, names []string, screenW, screenH in col := i % cols rows := (len(windows) + cols - 1) / cols cellH := screenH / rows - pw.SetPosition(col*cellW, row*cellH) + pw.SetPosition(originX+col*cellW, originY+row*cellH) pw.SetSize(cellW, cellH) + m.captureState(pw) } case TileModeLeftHalf: for _, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(halfW, screenH) + m.captureState(pw) } case TileModeRightHalf: for _, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(halfW, 0) + pw.SetPosition(originX+halfW, originY) pw.SetSize(halfW, screenH) + m.captureState(pw) } case TileModeTopHalf: for _, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(screenW, halfH) + m.captureState(pw) } case TileModeBottomHalf: for _, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(0, halfH) + pw.SetPosition(originX, originY+halfH) pw.SetSize(screenW, halfH) + m.captureState(pw) } case TileModeTopLeft: for _, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(halfW, halfH) + m.captureState(pw) } case TileModeTopRight: for _, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(halfW, 0) + pw.SetPosition(originX+halfW, originY) pw.SetSize(halfW, halfH) + m.captureState(pw) } case TileModeBottomLeft: for _, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(0, halfH) + pw.SetPosition(originX, originY+halfH) pw.SetSize(halfW, halfH) + m.captureState(pw) } case TileModeBottomRight: for _, pw := range windows { - normalizeWindowForLayout(pw) - pw.SetPosition(halfW, halfH) + pw.SetPosition(originX+halfW, originY+halfH) pw.SetSize(halfW, halfH) + m.captureState(pw) } } return nil } // SnapWindow snaps a window to a screen edge/corner/centre. -func (m *Manager) SnapWindow(name string, pos SnapPosition, screenW, screenH int) error { +func (m *Manager) SnapWindow(name string, pos SnapPosition, screenW, screenH int, origin ...int) error { + originX, originY := layoutOrigin(origin) pw, ok := m.Get(name) if !ok { - return corego.E("window.tiling", corego.Sprintf("window %q not found", name), nil) + return coreerr.E("window.Manager.SnapWindow", "window not found: "+name, nil) } halfW, halfH := screenW/2, screenH/2 switch pos { case SnapLeft: - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(halfW, screenH) case SnapRight: - normalizeWindowForLayout(pw) - pw.SetPosition(halfW, 0) + pw.SetPosition(originX+halfW, originY) pw.SetSize(halfW, screenH) case SnapTop: - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(screenW, halfH) case SnapBottom: - normalizeWindowForLayout(pw) - pw.SetPosition(0, halfH) + pw.SetPosition(originX, originY+halfH) pw.SetSize(screenW, halfH) case SnapTopLeft: - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(halfW, halfH) case SnapTopRight: - normalizeWindowForLayout(pw) - pw.SetPosition(halfW, 0) + pw.SetPosition(originX+halfW, originY) pw.SetSize(halfW, halfH) case SnapBottomLeft: - normalizeWindowForLayout(pw) - pw.SetPosition(0, halfH) + pw.SetPosition(originX, originY+halfH) pw.SetSize(halfW, halfH) case SnapBottomRight: - normalizeWindowForLayout(pw) - pw.SetPosition(halfW, halfH) + pw.SetPosition(originX+halfW, originY+halfH) pw.SetSize(halfW, halfH) case SnapCenter: normalizeWindowForLayout(pw) cw, ch := pw.Size() - pw.SetPosition((screenW-cw)/2, (screenH-ch)/2) + pw.SetPosition(originX+(screenW-cw)/2, originY+(screenH-ch)/2) } + m.captureState(pw) return nil } // StackWindows cascades windows with an offset. -func (m *Manager) StackWindows(names []string, offsetX, offsetY int) error { +func (m *Manager) StackWindows(names []string, offsetX, offsetY int, origin ...int) error { + originX, originY := layoutOrigin(origin) for i, name := range names { pw, ok := m.Get(name) if !ok { - return corego.E("window.tiling", corego.Sprintf("window %q not found", name), nil) + return coreerr.E("window.Manager.StackWindows", "window not found: "+name, nil) } - normalizeWindowForLayout(pw) - pw.SetPosition(i*offsetX, i*offsetY) + pw.SetPosition(originX+i*offsetX, originY+i*offsetY) + m.captureState(pw) } return nil } // ApplyWorkflow arranges windows in a predefined workflow layout. -func (m *Manager) ApplyWorkflow(workflow WorkflowLayout, names []string, screenW, screenH int) error { +func (m *Manager) ApplyWorkflow(workflow WorkflowLayout, names []string, screenW, screenH int, origin ...int) error { + originX, originY := layoutOrigin(origin) if len(names) == 0 { - return corego.E("window.tiling", "no windows for workflow", nil) + return coreerr.E("window.Manager.ApplyWorkflow", "no windows for workflow", nil) } switch workflow { @@ -256,41 +258,41 @@ func (m *Manager) ApplyWorkflow(workflow WorkflowLayout, names []string, screenW // 70/30 split — main editor + terminal mainW := screenW * 70 / 100 if pw, ok := m.Get(names[0]); ok { - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(mainW, screenH) + m.captureState(pw) } if len(names) > 1 { if pw, ok := m.Get(names[1]); ok { - normalizeWindowForLayout(pw) - pw.SetPosition(mainW, 0) + pw.SetPosition(originX+mainW, originY) pw.SetSize(screenW-mainW, screenH) + m.captureState(pw) } } case WorkflowDebugging: // 60/40 split mainW := screenW * 60 / 100 if pw, ok := m.Get(names[0]); ok { - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(mainW, screenH) + m.captureState(pw) } if len(names) > 1 { if pw, ok := m.Get(names[1]); ok { - normalizeWindowForLayout(pw) - pw.SetPosition(mainW, 0) + pw.SetPosition(originX+mainW, originY) pw.SetSize(screenW-mainW, screenH) + m.captureState(pw) } } case WorkflowPresenting: // Maximise first window if pw, ok := m.Get(names[0]); ok { - normalizeWindowForLayout(pw) - pw.SetPosition(0, 0) + pw.SetPosition(originX, originY) pw.SetSize(screenW, screenH) + m.captureState(pw) } case WorkflowSideBySide: - return m.TileWindows(TileModeLeftRight, names, screenW, screenH) + return m.TileWindows(TileModeLeftRight, names, screenW, screenH, originX, originY) } return nil } diff --git a/pkg/window/wails.go b/pkg/window/wails.go index c4c3f0ba..12786838 100644 --- a/pkg/window/wails.go +++ b/pkg/window/wails.go @@ -18,30 +18,28 @@ func NewWailsPlatform(app *application.App) *WailsPlatform { return &WailsPlatform{app: app} } -// CreateWindow opens a new Wails window from platform options. -// Use: w := wp.CreateWindow(window.PlatformWindowOptions{Name: "editor", URL: "/editor"}) -func (wp *WailsPlatform) CreateWindow(opts PlatformWindowOptions) PlatformWindow { +func (wp *WailsPlatform) CreateWindow(options PlatformWindowOptions) PlatformWindow { wOpts := application.WebviewWindowOptions{ - Name: opts.Name, - Title: opts.Title, - URL: opts.URL, - Width: opts.Width, - Height: opts.Height, - X: opts.X, - Y: opts.Y, - MinWidth: opts.MinWidth, - MinHeight: opts.MinHeight, - MaxWidth: opts.MaxWidth, - MaxHeight: opts.MaxHeight, - Frameless: opts.Frameless, - Hidden: opts.Hidden, - AlwaysOnTop: opts.AlwaysOnTop, - DisableResize: opts.DisableResize, - EnableFileDrop: opts.EnableFileDrop, - BackgroundColour: application.NewRGBA(opts.BackgroundColour[0], opts.BackgroundColour[1], opts.BackgroundColour[2], opts.BackgroundColour[3]), + Name: options.Name, + Title: options.Title, + URL: options.URL, + Width: options.Width, + Height: options.Height, + X: options.X, + Y: options.Y, + MinWidth: options.MinWidth, + MinHeight: options.MinHeight, + MaxWidth: options.MaxWidth, + MaxHeight: options.MaxHeight, + Frameless: options.Frameless, + Hidden: options.Hidden, + AlwaysOnTop: options.AlwaysOnTop, + DisableResize: options.DisableResize, + EnableFileDrop: options.EnableFileDrop, + BackgroundColour: application.NewRGBA(options.BackgroundColour[0], options.BackgroundColour[1], options.BackgroundColour[2], options.BackgroundColour[3]), } w := wp.app.Window.NewWithOptions(wOpts) - return &wailsWindow{w: w, title: opts.Title} + return &wailsWindow{w: w, title: options.Title} } // GetWindows returns the live Wails windows. @@ -64,20 +62,10 @@ type wailsWindow struct { title string } -func (ww *wailsWindow) Name() string { return ww.w.Name() } -func (ww *wailsWindow) Title() string { - if ww.title != "" { - return ww.title - } - if ww.w != nil { - return ww.w.Name() - } - return "" -} +func (ww *wailsWindow) Name() string { return ww.w.Name() } +func (ww *wailsWindow) Title() string { return ww.title } func (ww *wailsWindow) Position() (int, int) { return ww.w.Position() } func (ww *wailsWindow) Size() (int, int) { return ww.w.Size() } -func (ww *wailsWindow) IsVisible() bool { return ww.w.IsVisible() } -func (ww *wailsWindow) IsMinimised() bool { return ww.w.IsMinimised() } func (ww *wailsWindow) IsMaximised() bool { return ww.w.IsMaximised() } func (ww *wailsWindow) IsFocused() bool { return ww.w.IsFocused() } func (ww *wailsWindow) SetTitle(title string) { ww.title = title; ww.w.SetTitle(title) } @@ -102,10 +90,25 @@ func (ww *wailsWindow) Focus() { ww.w.Focus() } func (ww *wailsWindow) Close() { ww.w.Close() } func (ww *wailsWindow) Show() { ww.w.Show() } func (ww *wailsWindow) Hide() { ww.w.Hide() } -func (ww *wailsWindow) Fullscreen() { ww.w.Fullscreen() } -func (ww *wailsWindow) UnFullscreen() { ww.w.UnFullscreen() } -func (ww *wailsWindow) OpenDevTools() { ww.w.OpenDevTools() } -func (ww *wailsWindow) CloseDevTools() { ww.w.CloseDevTools() } +func (ww *wailsWindow) Fullscreen() { ww.w.Fullscreen() } +func (ww *wailsWindow) UnFullscreen() { ww.w.UnFullscreen() } +func (ww *wailsWindow) GetZoom() float64 { return ww.w.GetZoom() } +func (ww *wailsWindow) SetZoom(factor float64) { ww.w.SetZoom(factor) } +func (ww *wailsWindow) ZoomIn() { ww.w.ZoomIn() } +func (ww *wailsWindow) ZoomOut() { ww.w.ZoomOut() } +func (ww *wailsWindow) SetURL(url string) { ww.w.SetURL(url) } +func (ww *wailsWindow) SetHTML(html string) { ww.w.SetHTML(html) } +func (ww *wailsWindow) ExecJS(js string) { ww.w.ExecJS(js) } +func (ww *wailsWindow) GetBounds() Bounds { + r := ww.w.Bounds() + return Bounds{X: r.X, Y: r.Y, Width: r.Width, Height: r.Height} +} +func (ww *wailsWindow) SetBounds(b Bounds) { + ww.w.SetBounds(application.Rect{X: b.X, Y: b.Y, Width: b.Width, Height: b.Height}) +} +func (ww *wailsWindow) ToggleFullscreen() { ww.w.ToggleFullscreen() } +func (ww *wailsWindow) Print() error { return ww.w.Print() } +func (ww *wailsWindow) Flash(enabled bool) { ww.w.Flash(enabled) } func (ww *wailsWindow) OnWindowEvent(handler func(event WindowEvent)) { name := ww.w.Name() diff --git a/pkg/window/window.go b/pkg/window/window.go index 3c26b43d..95140b71 100644 --- a/pkg/window/window.go +++ b/pkg/window/window.go @@ -2,10 +2,9 @@ package window import ( - "math" "sync" - corego "dappco.re/go/core" + coreerr "forge.lthn.ai/core/go-log" ) // Window is CoreGUI's own window descriptor — NOT a Wails type alias. @@ -53,7 +52,7 @@ type Manager struct { } // NewManager creates a window Manager with the given platform backend. -// Use: mgr := window.NewManager(platform) +// window.NewManager(window.NewWailsPlatform(app)) func NewManager(platform Platform) *Manager { return &Manager{ platform: platform, @@ -64,7 +63,7 @@ func NewManager(platform Platform) *Manager { } // NewManagerWithDir creates a window Manager with a custom config directory for state/layout persistence. -// Use: mgr := window.NewManagerWithDir(platform, t.TempDir()) +// window.NewManagerWithDir(window.NewMockPlatform(), t.TempDir()) func NewManagerWithDir(platform Platform, configDir string) *Manager { return &Manager{ platform: platform, @@ -74,69 +73,82 @@ func NewManagerWithDir(platform Platform, configDir string) *Manager { } } -// SetDefaultWidth overrides the fallback width used when a window is created without one. -// Use: mgr.SetDefaultWidth(1280) func (m *Manager) SetDefaultWidth(width int) { if width > 0 { m.defaultWidth = width } } -// SetDefaultHeight overrides the fallback height used when a window is created without one. -// Use: mgr.SetDefaultHeight(800) func (m *Manager) SetDefaultHeight(height int) { if height > 0 { m.defaultHeight = height } } -// Open creates a window using functional options, applies saved state, and tracks it. -// Use: _, err := mgr.Open(window.WithName("editor"), window.WithURL("/editor")) -func (m *Manager) Open(opts ...WindowOption) (PlatformWindow, error) { - w, err := ApplyOptions(opts...) +// Deprecated: use CreateWindow(Window{Name: "settings", URL: "/settings", Width: 800, Height: 600}). +func (m *Manager) Open(options ...WindowOption) (PlatformWindow, error) { + w, err := ApplyOptions(options...) if err != nil { - return nil, corego.Wrap(err, "window.Manager.Open", "failed to apply options") + return nil, coreerr.E("window.Manager.Open", "failed to apply options", err) } - return m.Create(w) + return m.CreateWindow(*w) } -// Create creates a window from a Window descriptor. -// Use: _, err := mgr.Create(&window.Window{Name: "editor", URL: "/editor"}) +// CreateWindow creates a window from a Window descriptor. +// window.NewManager(window.NewWailsPlatform(app)).CreateWindow(window.Window{Name: "settings", URL: "/settings", Width: 800, Height: 600}) +func (m *Manager) CreateWindow(spec Window) (PlatformWindow, error) { + _, pw, err := m.createWindow(spec) + return pw, err +} + +// Deprecated: use CreateWindow(Window{Name: "settings", URL: "/settings", Width: 800, Height: 600}). func (m *Manager) Create(w *Window) (PlatformWindow, error) { - if w.Name == "" { - w.Name = "main" + if w == nil { + return nil, coreerr.E("window.Manager.Create", "window descriptor is required", nil) } - if w.Title == "" { - w.Title = "Core" + spec, pw, err := m.createWindow(*w) + if err != nil { + return nil, err } - if w.Width == 0 { + *w = spec + return pw, nil +} + +func (m *Manager) createWindow(spec Window) (Window, PlatformWindow, error) { + if spec.Name == "" { + spec.Name = "main" + } + if spec.Title == "" { + spec.Title = "Core" + } + if spec.Width == 0 { if m.defaultWidth > 0 { - w.Width = m.defaultWidth + spec.Width = m.defaultWidth } else { - w.Width = 1280 + spec.Width = 1280 } } - if w.Height == 0 { + if spec.Height == 0 { if m.defaultHeight > 0 { - w.Height = m.defaultHeight + spec.Height = m.defaultHeight } else { - w.Height = 800 + spec.Height = 800 } } - if w.URL == "" { - w.URL = "/" + if spec.URL == "" { + spec.URL = "/" } - // Apply saved state if available - m.state.ApplyState(w) + // Apply saved state if available. + m.state.ApplyState(&spec) - pw := m.platform.CreateWindow(w.ToPlatformOptions()) + pw := m.platform.CreateWindow(spec.ToPlatformOptions()) m.mu.Lock() - m.windows[w.Name] = pw + m.windows[spec.Name] = pw m.mu.Unlock() - return pw, nil + return spec, pw, nil } // Get returns a tracked window by name. diff --git a/pkg/window/window_test.go b/pkg/window/window_test.go index e5896809..be469937 100644 --- a/pkg/window/window_test.go +++ b/pkg/window/window_test.go @@ -10,7 +10,7 @@ import ( "github.com/wailsapp/wails/v3/pkg/application" ) -func TestWindowDefaults(t *testing.T) { +func TestWindowDefaults_Good(t *testing.T) { w := &Window{} assert.Equal(t, "", w.Name) assert.Equal(t, 0, w.Width) @@ -93,39 +93,48 @@ func newTestManager() (*Manager, *mockPlatform) { return m, p } -func TestManager_Open_Good(t *testing.T) { - m, p := newTestManager() - pw, err := m.Open(WithName("test"), WithTitle("Test"), WithURL("/test"), WithSize(800, 600)) +func requireCreateWindow(t *testing.T, m *Manager, w Window) PlatformWindow { + t.Helper() + pw, err := m.CreateWindow(w) require.NoError(t, err) + return pw +} + +func TestManager_CreateWindow_Good(t *testing.T) { + m, p := newTestManager() + pw := requireCreateWindow(t, m, Window{ + Name: "test", + Title: "Test", + URL: "/test", + Width: 800, + Height: 600, + }) assert.NotNil(t, pw) assert.Equal(t, "test", pw.Name()) assert.Len(t, p.windows, 1) } -func TestManager_Open_Defaults_Good(t *testing.T) { +func TestManager_CreateWindow_Defaults_Good(t *testing.T) { m, _ := newTestManager() - pw, err := m.Open() - require.NoError(t, err) + pw := requireCreateWindow(t, m, Window{}) assert.Equal(t, "main", pw.Name()) w, h := pw.Size() assert.Equal(t, 1280, w) assert.Equal(t, 800, h) } -func TestManager_DefaultSizeOverrides_Good(t *testing.T) { +func TestManager_CreateWindow_CustomDefaults_Good(t *testing.T) { m, _ := newTestManager() m.SetDefaultWidth(1440) m.SetDefaultHeight(900) - pw, err := m.Open() - require.NoError(t, err) - + pw := requireCreateWindow(t, m, Window{}) w, h := pw.Size() assert.Equal(t, 1440, w) assert.Equal(t, 900, h) } -func TestManager_Open_Bad(t *testing.T) { +func TestManager_Open_Compatibility_Bad(t *testing.T) { m, _ := newTestManager() _, err := m.Open(func(w *Window) error { return assert.AnError }) assert.Error(t, err) @@ -133,7 +142,7 @@ func TestManager_Open_Bad(t *testing.T) { func TestManager_Get_Good(t *testing.T) { m, _ := newTestManager() - _, _ = m.Open(WithName("findme")) + _ = requireCreateWindow(t, m, Window{Name: "findme"}) pw, ok := m.Get("findme") assert.True(t, ok) assert.Equal(t, "findme", pw.Name()) @@ -147,8 +156,8 @@ func TestManager_Get_Bad(t *testing.T) { func TestManager_List_Good(t *testing.T) { m, _ := newTestManager() - _, _ = m.Open(WithName("a")) - _, _ = m.Open(WithName("b")) + _ = requireCreateWindow(t, m, Window{Name: "a"}) + _ = requireCreateWindow(t, m, Window{Name: "b"}) names := m.List() assert.Len(t, names, 2) assert.Contains(t, names, "a") @@ -157,181 +166,12 @@ func TestManager_List_Good(t *testing.T) { func TestManager_Remove_Good(t *testing.T) { m, _ := newTestManager() - _, _ = m.Open(WithName("temp")) + _ = requireCreateWindow(t, m, Window{Name: "temp"}) m.Remove("temp") _, ok := m.Get("temp") assert.False(t, ok) } -func TestWailsWindow_DevToolsToggle_Good(t *testing.T) { - app := application.NewApp() - platform := NewWailsPlatform(app) - - pw := platform.CreateWindow(PlatformWindowOptions{Name: "devtools"}) - ww, ok := pw.(*wailsWindow) - require.True(t, ok) - - ww.OpenDevTools() - assert.True(t, ww.w.DevToolsOpen()) - - ww.CloseDevTools() - assert.False(t, ww.w.DevToolsOpen()) -} - -func TestWailsPlatform_GetWindows_TitleFallback_Good(t *testing.T) { - app := application.NewApp() - platform := NewWailsPlatform(app) - - pw := platform.CreateWindow(PlatformWindowOptions{Name: "fallback"}) - require.NotNil(t, pw) - - windows := platform.GetWindows() - require.Len(t, windows, 1) - assert.Equal(t, "fallback", windows[0].Title()) -} - -// --- StateManager Tests --- - -// newTestStateManager creates a clean StateManager with a temp dir for testing. -func newTestStateManager(t *testing.T) *StateManager { - return &StateManager{ - configDir: t.TempDir(), - states: make(map[string]WindowState), - } -} - -func TestStateManager_SetGet_Good(t *testing.T) { - sm := newTestStateManager(t) - state := WindowState{X: 100, Y: 200, Width: 800, Height: 600, Maximized: false} - sm.SetState("main", state) - got, ok := sm.GetState("main") - assert.True(t, ok) - assert.Equal(t, 100, got.X) - assert.Equal(t, 800, got.Width) -} - -func TestStateManager_SetGet_Bad(t *testing.T) { - sm := newTestStateManager(t) - _, ok := sm.GetState("nonexistent") - assert.False(t, ok) -} - -func TestStateManager_CaptureState_Good(t *testing.T) { - sm := newTestStateManager(t) - w := &mockWindow{name: "cap", x: 50, y: 60, width: 1024, height: 768, maximised: true} - sm.CaptureState(w) - got, ok := sm.GetState("cap") - assert.True(t, ok) - assert.Equal(t, 50, got.X) - assert.Equal(t, 1024, got.Width) - assert.True(t, got.Maximized) -} - -func TestStateManager_ApplyState_Good(t *testing.T) { - sm := newTestStateManager(t) - sm.SetState("win", WindowState{X: 10, Y: 20, Width: 640, Height: 480}) - w := &Window{Name: "win", Width: 1280, Height: 800} - sm.ApplyState(w) - assert.Equal(t, 10, w.X) - assert.Equal(t, 20, w.Y) - assert.Equal(t, 640, w.Width) - assert.Equal(t, 480, w.Height) -} - -func TestStateManager_ListStates_Good(t *testing.T) { - sm := newTestStateManager(t) - sm.SetState("a", WindowState{Width: 100}) - sm.SetState("b", WindowState{Width: 200}) - names := sm.ListStates() - assert.Len(t, names, 2) -} - -func TestStateManager_Clear_Good(t *testing.T) { - sm := newTestStateManager(t) - sm.SetState("a", WindowState{Width: 100}) - sm.Clear() - names := sm.ListStates() - assert.Empty(t, names) -} - -func TestStateManager_Persistence_Good(t *testing.T) { - dir := t.TempDir() - sm1 := &StateManager{configDir: dir, states: make(map[string]WindowState)} - sm1.SetState("persist", WindowState{X: 42, Y: 84, Width: 500, Height: 300}) - sm1.ForceSync() - - sm2 := &StateManager{configDir: dir, states: make(map[string]WindowState)} - sm2.load() - got, ok := sm2.GetState("persist") - assert.True(t, ok) - assert.Equal(t, 42, got.X) - assert.Equal(t, 500, got.Width) -} - -func TestStateManager_SetPath_Good(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "custom-window-state.json") - sm := &StateManager{states: make(map[string]WindowState)} - - sm.SetPath(path) - sm.SetState("custom", WindowState{X: 11, Y: 22, Width: 333, Height: 444}) - sm.ForceSync() - - reloaded := &StateManager{states: make(map[string]WindowState)} - reloaded.SetPath(path) - got, ok := reloaded.GetState("custom") - require.True(t, ok) - assert.Equal(t, 11, got.X) - assert.Equal(t, 333, got.Width) -} - -// --- LayoutManager Tests --- - -// newTestLayoutManager creates a clean LayoutManager with a temp dir for testing. -func newTestLayoutManager(t *testing.T) *LayoutManager { - return &LayoutManager{ - configDir: t.TempDir(), - layouts: make(map[string]Layout), - } -} - -func TestLayoutManager_SaveGet_Good(t *testing.T) { - lm := newTestLayoutManager(t) - states := map[string]WindowState{ - "editor": {X: 0, Y: 0, Width: 960, Height: 1080}, - "terminal": {X: 960, Y: 0, Width: 960, Height: 1080}, - } - err := lm.SaveLayout("coding", states) - require.NoError(t, err) - - layout, ok := lm.GetLayout("coding") - assert.True(t, ok) - assert.Equal(t, "coding", layout.Name) - assert.Len(t, layout.Windows, 2) -} - -func TestLayoutManager_GetLayout_Bad(t *testing.T) { - lm := newTestLayoutManager(t) - _, ok := lm.GetLayout("nonexistent") - assert.False(t, ok) -} - -func TestLayoutManager_ListLayouts_Good(t *testing.T) { - lm := newTestLayoutManager(t) - _ = lm.SaveLayout("a", map[string]WindowState{}) - _ = lm.SaveLayout("b", map[string]WindowState{}) - layouts := lm.ListLayouts() - assert.Len(t, layouts, 2) -} - -func TestLayoutManager_DeleteLayout_Good(t *testing.T) { - lm := newTestLayoutManager(t) - _ = lm.SaveLayout("temp", map[string]WindowState{}) - lm.DeleteLayout("temp") - _, ok := lm.GetLayout("temp") - assert.False(t, ok) -} - // --- Tiling Tests --- func TestTileMode_String_Good(t *testing.T) { @@ -341,8 +181,8 @@ func TestTileMode_String_Good(t *testing.T) { func TestManager_TileWindows_Good(t *testing.T) { m, _ := newTestManager() - _, _ = m.Open(WithName("a"), WithSize(800, 600)) - _, _ = m.Open(WithName("b"), WithSize(800, 600)) + _ = requireCreateWindow(t, m, Window{Name: "a", Width: 800, Height: 600}) + _ = requireCreateWindow(t, m, Window{Name: "b", Width: 800, Height: 600}) err := m.TileWindows(TileModeLeftRight, []string{"a", "b"}, 1920, 1080) require.NoError(t, err) a, _ := m.Get("a") @@ -361,7 +201,7 @@ func TestManager_TileWindows_Bad(t *testing.T) { func TestManager_SnapWindow_Good(t *testing.T) { m, _ := newTestManager() - _, _ = m.Open(WithName("snap"), WithSize(800, 600)) + _ = requireCreateWindow(t, m, Window{Name: "snap", Width: 800, Height: 600}) err := m.SnapWindow("snap", SnapLeft, 1920, 1080) require.NoError(t, err) w, _ := m.Get("snap") @@ -373,8 +213,8 @@ func TestManager_SnapWindow_Good(t *testing.T) { func TestManager_StackWindows_Good(t *testing.T) { m, _ := newTestManager() - _, _ = m.Open(WithName("s1"), WithSize(800, 600)) - _, _ = m.Open(WithName("s2"), WithSize(800, 600)) + _ = requireCreateWindow(t, m, Window{Name: "s1", Width: 800, Height: 600}) + _ = requireCreateWindow(t, m, Window{Name: "s2", Width: 800, Height: 600}) err := m.StackWindows([]string{"s1", "s2"}, 30, 30) require.NoError(t, err) s2, _ := m.Get("s2") @@ -388,42 +228,184 @@ func TestWorkflowLayout_Good(t *testing.T) { assert.Equal(t, "debugging", WorkflowDebugging.String()) } -func TestManager_SuggestLayout_Good(t *testing.T) { - m, _ := newTestManager() - suggestion := m.SuggestLayout(1920, 1080, 3) - assert.Equal(t, "quadrants", suggestion.Mode) - assert.Equal(t, 2, suggestion.Columns) +// --- Comprehensive Tiling Tests --- + +func TestTileWindows_AllModes_Good(t *testing.T) { + const screenW, screenH = 1920, 1080 + halfW, halfH := screenW/2, screenH/2 + + tests := []struct { + name string + mode TileMode + wantX int + wantY int + wantWidth int + wantHeight int + }{ + {"LeftHalf", TileModeLeftHalf, 0, 0, halfW, screenH}, + {"RightHalf", TileModeRightHalf, halfW, 0, halfW, screenH}, + {"TopHalf", TileModeTopHalf, 0, 0, screenW, halfH}, + {"BottomHalf", TileModeBottomHalf, 0, halfH, screenW, halfH}, + {"TopLeft", TileModeTopLeft, 0, 0, halfW, halfH}, + {"TopRight", TileModeTopRight, halfW, 0, halfW, halfH}, + {"BottomLeft", TileModeBottomLeft, 0, halfH, halfW, halfH}, + {"BottomRight", TileModeBottomRight, halfW, halfH, halfW, halfH}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + m, _ := newTestManager() + _ = requireCreateWindow(t, m, Window{Name: "win", Width: 800, Height: 600}) + + err := m.TileWindows(tc.mode, []string{"win"}, screenW, screenH) + require.NoError(t, err) + + pw, ok := m.Get("win") + require.True(t, ok) + + x, y := pw.Position() + w, h := pw.Size() + assert.Equal(t, tc.wantX, x, "x position") + assert.Equal(t, tc.wantY, y, "y position") + assert.Equal(t, tc.wantWidth, w, "width") + assert.Equal(t, tc.wantHeight, h, "height") + }) + } } -func TestManager_FindSpace_Good(t *testing.T) { - m, _ := newTestManager() - _, _ = m.Open(WithName("one"), WithPosition(0, 0), WithSize(800, 600)) - space := m.FindSpace(1920, 1080, 400, 300) - assert.GreaterOrEqual(t, space.X, 0) - assert.GreaterOrEqual(t, space.Y, 0) +func TestSnapWindow_AllPositions_Good(t *testing.T) { + const screenW, screenH = 1920, 1080 + halfW, halfH := screenW/2, screenH/2 + + tests := []struct { + name string + pos SnapPosition + initW int + initH int + wantX int + wantY int + wantWidth int + wantHeight int + }{ + {"Right", SnapRight, 800, 600, halfW, 0, halfW, screenH}, + {"Top", SnapTop, 800, 600, 0, 0, screenW, halfH}, + {"Bottom", SnapBottom, 800, 600, 0, halfH, screenW, halfH}, + {"TopLeft", SnapTopLeft, 800, 600, 0, 0, halfW, halfH}, + {"TopRight", SnapTopRight, 800, 600, halfW, 0, halfW, halfH}, + {"BottomLeft", SnapBottomLeft, 800, 600, 0, halfH, halfW, halfH}, + {"BottomRight", SnapBottomRight, 800, 600, halfW, halfH, halfW, halfH}, + {"Center", SnapCenter, 800, 600, (screenW - 800) / 2, (screenH - 600) / 2, 800, 600}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + m, _ := newTestManager() + _ = requireCreateWindow(t, m, Window{Name: "snap", Width: tc.initW, Height: tc.initH}) + + err := m.SnapWindow("snap", tc.pos, screenW, screenH) + require.NoError(t, err) + + pw, ok := m.Get("snap") + require.True(t, ok) + + x, y := pw.Position() + w, h := pw.Size() + assert.Equal(t, tc.wantX, x, "x position") + assert.Equal(t, tc.wantY, y, "y position") + assert.Equal(t, tc.wantWidth, w, "width") + assert.Equal(t, tc.wantHeight, h, "height") + }) + } } -func TestManager_ArrangePair_Good(t *testing.T) { +func TestStackWindows_ThreeWindows_Good(t *testing.T) { m, _ := newTestManager() - _, _ = m.Open(WithName("left"), WithSize(800, 600)) - _, _ = m.Open(WithName("right"), WithSize(800, 600)) - err := m.ArrangePair("left", "right", 1920, 1080) + names := []string{"s1", "s2", "s3"} + for _, name := range names { + _ = requireCreateWindow(t, m, Window{Name: name, Width: 800, Height: 600}) + } + + err := m.StackWindows(names, 30, 30) require.NoError(t, err) - left, _ := m.Get("left") - x, _ := left.Position() - assert.Equal(t, 0, x) + + for i, name := range names { + pw, ok := m.Get(name) + require.True(t, ok, "window %s should exist", name) + x, y := pw.Position() + assert.Equal(t, i*30, x, "window %s x position", name) + assert.Equal(t, i*30, y, "window %s y position", name) + } } -func TestManager_BesideEditor_Good(t *testing.T) { - m, _ := newTestManager() - _, _ = m.Open(WithName("editor")) - _, _ = m.Open(WithName("assistant")) - err := m.BesideEditor("editor", "assistant", 1920, 1080) - require.NoError(t, err) - editor, _ := m.Get("editor") - assistant, _ := m.Get("assistant") - ex, _ := editor.Size() - ax, _ := assistant.Position() - assert.Greater(t, ex, 0) - assert.Greater(t, ax, 0) +func TestApplyWorkflow_AllLayouts_Good(t *testing.T) { + const screenW, screenH = 1920, 1080 + + tests := []struct { + name string + workflow WorkflowLayout + // Expected positions/sizes for the first two windows. + // For WorkflowSideBySide, TileWindows(LeftRight) divides equally. + win0X, win0Y, win0W, win0H int + win1X, win1Y, win1W, win1H int + }{ + { + "Coding", + WorkflowCoding, + 0, 0, 1344, screenH, // 70% of 1920 = 1344 + 1344, 0, screenW - 1344, screenH, // remaining 30% + }, + { + "Debugging", + WorkflowDebugging, + 0, 0, 1152, screenH, // 60% of 1920 = 1152 + 1152, 0, screenW - 1152, screenH, // remaining 40% + }, + { + "Presenting", + WorkflowPresenting, + 0, 0, screenW, screenH, // maximised + 0, 0, 800, 600, // second window untouched + }, + { + "SideBySide", + WorkflowSideBySide, + 0, 0, 960, screenH, // left half (1920/2) + 960, 0, 960, screenH, // right half + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + m, _ := newTestManager() + _ = requireCreateWindow(t, m, Window{Name: "editor", Width: 800, Height: 600}) + _ = requireCreateWindow(t, m, Window{Name: "terminal", Width: 800, Height: 600}) + + err := m.ApplyWorkflow(tc.workflow, []string{"editor", "terminal"}, screenW, screenH) + require.NoError(t, err) + + pw0, ok := m.Get("editor") + require.True(t, ok) + x0, y0 := pw0.Position() + w0, h0 := pw0.Size() + assert.Equal(t, tc.win0X, x0, "editor x") + assert.Equal(t, tc.win0Y, y0, "editor y") + assert.Equal(t, tc.win0W, w0, "editor width") + assert.Equal(t, tc.win0H, h0, "editor height") + + pw1, ok := m.Get("terminal") + require.True(t, ok) + x1, y1 := pw1.Position() + w1, h1 := pw1.Size() + assert.Equal(t, tc.win1X, x1, "terminal x") + assert.Equal(t, tc.win1Y, y1, "terminal y") + assert.Equal(t, tc.win1W, w1, "terminal width") + assert.Equal(t, tc.win1H, h1, "terminal height") + }) + } +} + +func TestApplyWorkflow_Empty_Bad(t *testing.T) { + m, _ := newTestManager() + err := m.ApplyWorkflow(WorkflowCoding, []string{}, 1920, 1080) + assert.Error(t, err) } diff --git a/stubs/wails/go.mod b/stubs/wails/go.mod new file mode 100644 index 00000000..7dcb8325 --- /dev/null +++ b/stubs/wails/go.mod @@ -0,0 +1,3 @@ +module github.com/wailsapp/wails/v3 + +go 1.26.0 diff --git a/stubs/wails/pkg/application/application.go b/stubs/wails/pkg/application/application.go new file mode 100644 index 00000000..60a86e5a --- /dev/null +++ b/stubs/wails/pkg/application/application.go @@ -0,0 +1,778 @@ +package application + +import ( + "sync" + "unsafe" + + "github.com/wailsapp/wails/v3/pkg/events" +) + +// Context mirrors the callback context type exposed by Wails. +// +// item.OnClick(func(ctx *Context) { openPrefs() }) +type Context struct { + clickedMenuItem *MenuItem + contextMenuData *ContextMenuData + checked bool +} + +func newContext() *Context { return &Context{} } + +func (ctx *Context) withClickedMenuItem(item *MenuItem) *Context { + ctx.clickedMenuItem = item + return ctx +} + +func (ctx *Context) withContextMenuData(data *ContextMenuData) *Context { + ctx.contextMenuData = data + return ctx +} + +func (ctx *Context) withChecked(checked bool) *Context { + ctx.checked = checked + return ctx +} + +// Logger is a minimal logger surface used by the GUI packages. +type Logger struct{} + +func (l Logger) Info(message string, args ...any) {} + +// RGBA stores a colour with alpha. +// +// colour := NewRGBA(255, 128, 0, 255) // opaque orange +type RGBA struct { + Red, Green, Blue, Alpha uint8 +} + +// NewRGBA constructs an RGBA value. +// +// colour := NewRGBA(255, 128, 0, 255) // opaque orange +func NewRGBA(red, green, blue, alpha uint8) RGBA { + return RGBA{Red: red, Green: green, Blue: blue, Alpha: alpha} +} + +// Menu is a menu tree used by the GUI wrappers. +// +// menu := NewMenu() +// menu.Add("Save").SetAccelerator("CmdOrCtrl+S").OnClick(func(ctx *Context) { save() }) +type Menu struct { + label string + Items []*MenuItem +} + +// NewMenu creates a new, empty Menu. +// +// menu := NewMenu() +func NewMenu() *Menu { return &Menu{} } + +// Add appends a new text item with the given label. +func (m *Menu) Add(label string) *MenuItem { + item := NewMenuItem(label) + item.disabled = false + m.Items = append(m.Items, item) + return item +} + +// AddSeparator appends a separator item. +func (m *Menu) AddSeparator() { + m.Items = append(m.Items, NewMenuItemSeparator()) +} + +// AddSubmenu appends a submenu item and returns the child Menu. +func (m *Menu) AddSubmenu(label string) *Menu { + item := NewSubMenuItem(label) + m.Items = append(m.Items, item) + return item.submenu +} + +// AddRole appends a platform-role item. +func (m *Menu) AddRole(role Role) { + m.Items = append(m.Items, NewRole(role)) +} + +// AppendItem appends an already-constructed MenuItem. +func (m *Menu) AppendItem(item *MenuItem) { + m.Items = append(m.Items, item) +} + +// Clone returns a deep copy of the menu tree. +func (m *Menu) Clone() *Menu { + cloned := &Menu{label: m.label} + for _, item := range m.Items { + cloned.Items = append(cloned.Items, item.Clone()) + } + return cloned +} + +// Destroy frees all items in the menu. +func (m *Menu) Destroy() { + for _, item := range m.Items { + item.Destroy() + } + m.Items = nil +} + +func (m *Menu) setContextData(data *ContextMenuData) { + for _, item := range m.Items { + item.contextMenuData = data + if item.submenu != nil { + item.submenu.setContextData(data) + } + } +} + +// MenuManager owns the application menu. +// +// app.Menu.SetApplicationMenu(menu) +type MenuManager struct { + applicationMenu *Menu +} + +func (m *MenuManager) SetApplicationMenu(menu *Menu) { m.applicationMenu = menu } + +// SystemTray represents a tray instance. +type SystemTray struct { + icon []byte + templateIcon []byte + tooltip string + label string + menu *Menu + attachedWindow Window +} + +func (t *SystemTray) SetIcon(data []byte) { t.icon = append([]byte(nil), data...) } +func (t *SystemTray) SetTemplateIcon(data []byte) { t.templateIcon = append([]byte(nil), data...) } +func (t *SystemTray) SetTooltip(text string) { t.tooltip = text } +func (t *SystemTray) SetLabel(text string) { t.label = text } +func (t *SystemTray) SetMenu(menu *Menu) { t.menu = menu } + +// AttachWindow associates a window with the tray icon (shown on click). +func (t *SystemTray) AttachWindow(w Window) { t.attachedWindow = w } + +// SystemTrayManager creates tray instances. +type SystemTrayManager struct{} + +func (m *SystemTrayManager) New() *SystemTray { return &SystemTray{} } + +// WindowEventContext carries drag-and-drop details for a window event. +type WindowEventContext struct { + droppedFiles []string + dropDetails *DropTargetDetails +} + +func (c *WindowEventContext) DroppedFiles() []string { + return append([]string(nil), c.droppedFiles...) +} + +func (c *WindowEventContext) DropTargetDetails() *DropTargetDetails { + if c.dropDetails == nil { + return nil + } + details := *c.dropDetails + return &details +} + +// DropTargetDetails mirrors the fields consumed by the GUI wrappers. +type DropTargetDetails struct { + ElementID string +} + +// WindowEvent mirrors the event object passed to window callbacks. +type WindowEvent struct { + ctx *WindowEventContext +} + +func (e *WindowEvent) Context() *WindowEventContext { + if e.ctx == nil { + e.ctx = &WindowEventContext{} + } + return e.ctx +} + +// WebviewWindow is a lightweight, in-memory window implementation +// that satisfies the Window interface. +type WebviewWindow struct { + mu sync.RWMutex + opts WebviewWindowOptions + windowID uint + title string + posX, posY int + sizeW, sizeH int + maximised bool + focused bool + visible bool + alwaysOnTop bool + isFullscreen bool + closed bool + zoom float64 + resizable bool + ignoreMouseEvents bool + enabled bool + eventHandlers map[events.WindowEventType][]func(*WindowEvent) +} + +var globalWindowID uint +var globalWindowIDMu sync.Mutex + +func nextWindowID() uint { + globalWindowIDMu.Lock() + defer globalWindowIDMu.Unlock() + globalWindowID++ + return globalWindowID +} + +func newWebviewWindow(options WebviewWindowOptions) *WebviewWindow { + return &WebviewWindow{ + opts: options, + windowID: nextWindowID(), + title: options.Title, + posX: options.X, + posY: options.Y, + sizeW: options.Width, + sizeH: options.Height, + visible: !options.Hidden, + alwaysOnTop: options.AlwaysOnTop, + zoom: options.Zoom, + resizable: !options.DisableResize, + enabled: true, + eventHandlers: make(map[events.WindowEventType][]func(*WindowEvent)), + } +} + +// ID returns the unique numeric identifier for the window. +func (w *WebviewWindow) ID() uint { return w.windowID } + +// Name returns the window name set in WebviewWindowOptions. +func (w *WebviewWindow) Name() string { return w.opts.Name } + +// Show makes the window visible and returns it for chaining. +func (w *WebviewWindow) Show() Window { + w.mu.Lock() + w.visible = true + w.mu.Unlock() + return w +} + +// Hide makes the window invisible and returns it for chaining. +func (w *WebviewWindow) Hide() Window { + w.mu.Lock() + w.visible = false + w.mu.Unlock() + return w +} + +// IsVisible reports whether the window is currently visible. +func (w *WebviewWindow) IsVisible() bool { + w.mu.RLock() + defer w.mu.RUnlock() + return w.visible +} + +// Close marks the window as closed. +func (w *WebviewWindow) Close() { + w.mu.Lock() + w.closed = true + w.mu.Unlock() +} + +// Focus marks the window as focused. +func (w *WebviewWindow) Focus() { + w.mu.Lock() + w.focused = true + w.mu.Unlock() +} + +// Run is a no-op in the stub (the real implementation enters the run loop). +func (w *WebviewWindow) Run() {} + +// Center is a no-op in the stub. +func (w *WebviewWindow) Center() {} + +// Position returns the current x/y position. +func (w *WebviewWindow) Position() (int, int) { + w.mu.RLock() + defer w.mu.RUnlock() + return w.posX, w.posY +} + +// RelativePosition returns the position relative to the screen. +func (w *WebviewWindow) RelativePosition() (int, int) { + w.mu.RLock() + defer w.mu.RUnlock() + return w.posX, w.posY +} + +// Size returns the current width and height. +func (w *WebviewWindow) Size() (int, int) { + w.mu.RLock() + defer w.mu.RUnlock() + return w.sizeW, w.sizeH +} + +// Width returns the current window width. +func (w *WebviewWindow) Width() int { + w.mu.RLock() + defer w.mu.RUnlock() + return w.sizeW +} + +// Height returns the current window height. +func (w *WebviewWindow) Height() int { + w.mu.RLock() + defer w.mu.RUnlock() + return w.sizeH +} + +// Bounds returns the window's position and size as a Rect. +func (w *WebviewWindow) Bounds() Rect { + w.mu.RLock() + defer w.mu.RUnlock() + return Rect{X: w.posX, Y: w.posY, Width: w.sizeW, Height: w.sizeH} +} + +// SetPosition sets the top-left corner position. +func (w *WebviewWindow) SetPosition(x, y int) { + w.mu.Lock() + w.posX, w.posY = x, y + w.mu.Unlock() +} + +// SetRelativePosition sets position relative to the screen and returns the window. +func (w *WebviewWindow) SetRelativePosition(x, y int) Window { + w.SetPosition(x, y) + return w +} + +// SetSize sets the window dimensions and returns the window. +func (w *WebviewWindow) SetSize(width, height int) Window { + w.mu.Lock() + w.sizeW, w.sizeH = width, height + w.mu.Unlock() + return w +} + +// SetBounds sets position and size in one call. +func (w *WebviewWindow) SetBounds(bounds Rect) { + w.mu.Lock() + w.posX, w.posY = bounds.X, bounds.Y + w.sizeW, w.sizeH = bounds.Width, bounds.Height + w.mu.Unlock() +} + +// SetMaxSize is a no-op in the stub. +func (w *WebviewWindow) SetMaxSize(maxWidth, maxHeight int) Window { return w } + +// SetMinSize is a no-op in the stub. +func (w *WebviewWindow) SetMinSize(minWidth, minHeight int) Window { return w } + +// EnableSizeConstraints is a no-op in the stub. +func (w *WebviewWindow) EnableSizeConstraints() {} + +// DisableSizeConstraints is a no-op in the stub. +func (w *WebviewWindow) DisableSizeConstraints() {} + +// Resizable reports whether the user can resize the window. +func (w *WebviewWindow) Resizable() bool { + w.mu.RLock() + defer w.mu.RUnlock() + return w.resizable +} + +// SetResizable enables or disables user resizing and returns the window. +func (w *WebviewWindow) SetResizable(b bool) Window { + w.mu.Lock() + w.resizable = b + w.mu.Unlock() + return w +} + +// Maximise maximises the window and returns it. +func (w *WebviewWindow) Maximise() Window { + w.mu.Lock() + w.maximised = true + w.mu.Unlock() + return w +} + +// UnMaximise restores from maximised state. +func (w *WebviewWindow) UnMaximise() { + w.mu.Lock() + w.maximised = false + w.mu.Unlock() +} + +// ToggleMaximise toggles between maximised and normal. +func (w *WebviewWindow) ToggleMaximise() { + w.mu.Lock() + w.maximised = !w.maximised + w.mu.Unlock() +} + +// IsMaximised reports whether the window is maximised. +func (w *WebviewWindow) IsMaximised() bool { + w.mu.RLock() + defer w.mu.RUnlock() + return w.maximised +} + +// Minimise minimises the window and returns it. +func (w *WebviewWindow) Minimise() Window { + w.mu.Lock() + w.visible = false + w.mu.Unlock() + return w +} + +// UnMinimise restores from minimised state. +func (w *WebviewWindow) UnMinimise() { + w.mu.Lock() + w.visible = true + w.mu.Unlock() +} + +// IsMinimised always returns false in the stub. +func (w *WebviewWindow) IsMinimised() bool { return false } + +// Fullscreen enters fullscreen and returns the window. +func (w *WebviewWindow) Fullscreen() Window { + w.mu.Lock() + w.isFullscreen = true + w.mu.Unlock() + return w +} + +// UnFullscreen exits fullscreen. +func (w *WebviewWindow) UnFullscreen() { + w.mu.Lock() + w.isFullscreen = false + w.mu.Unlock() +} + +// ToggleFullscreen toggles between fullscreen and normal. +func (w *WebviewWindow) ToggleFullscreen() { + w.mu.Lock() + w.isFullscreen = !w.isFullscreen + w.mu.Unlock() +} + +// IsFullscreen reports whether the window is in fullscreen mode. +func (w *WebviewWindow) IsFullscreen() bool { + w.mu.RLock() + defer w.mu.RUnlock() + return w.isFullscreen +} + +// Restore exits both fullscreen and maximised states. +func (w *WebviewWindow) Restore() { + w.mu.Lock() + w.maximised = false + w.isFullscreen = false + w.mu.Unlock() +} + +// SnapAssist is a no-op in the stub. +func (w *WebviewWindow) SnapAssist() {} + +// SetTitle updates the window title and returns the window. +func (w *WebviewWindow) SetTitle(title string) Window { + w.mu.Lock() + w.title = title + w.mu.Unlock() + return w +} + +// SetURL is a no-op in the stub. +func (w *WebviewWindow) SetURL(s string) Window { return w } + +// SetHTML is a no-op in the stub. +func (w *WebviewWindow) SetHTML(html string) Window { return w } + +// SetMinimiseButtonState is a no-op in the stub. +func (w *WebviewWindow) SetMinimiseButtonState(state ButtonState) Window { return w } + +// SetMaximiseButtonState is a no-op in the stub. +func (w *WebviewWindow) SetMaximiseButtonState(state ButtonState) Window { return w } + +// SetCloseButtonState is a no-op in the stub. +func (w *WebviewWindow) SetCloseButtonState(state ButtonState) Window { return w } + +// SetMenu is a no-op in the stub. +func (w *WebviewWindow) SetMenu(menu *Menu) {} + +// ShowMenuBar is a no-op in the stub. +func (w *WebviewWindow) ShowMenuBar() {} + +// HideMenuBar is a no-op in the stub. +func (w *WebviewWindow) HideMenuBar() {} + +// ToggleMenuBar is a no-op in the stub. +func (w *WebviewWindow) ToggleMenuBar() {} + +// SetBackgroundColour is a no-op in the stub. +func (w *WebviewWindow) SetBackgroundColour(colour RGBA) Window { return w } + +// SetAlwaysOnTop sets the always-on-top flag and returns the window. +func (w *WebviewWindow) SetAlwaysOnTop(b bool) Window { + w.mu.Lock() + w.alwaysOnTop = b + w.mu.Unlock() + return w +} + +// SetFrameless is a no-op in the stub. +func (w *WebviewWindow) SetFrameless(frameless bool) Window { return w } + +// ToggleFrameless is a no-op in the stub. +func (w *WebviewWindow) ToggleFrameless() {} + +// SetIgnoreMouseEvents sets the mouse-event passthrough flag and returns the window. +func (w *WebviewWindow) SetIgnoreMouseEvents(ignore bool) Window { + w.mu.Lock() + w.ignoreMouseEvents = ignore + w.mu.Unlock() + return w +} + +// IsIgnoreMouseEvents reports whether mouse events are being ignored. +func (w *WebviewWindow) IsIgnoreMouseEvents() bool { + w.mu.RLock() + defer w.mu.RUnlock() + return w.ignoreMouseEvents +} + +// SetContentProtection is a no-op in the stub. +func (w *WebviewWindow) SetContentProtection(protection bool) Window { return w } + +// GetZoom returns the current zoom magnification. +func (w *WebviewWindow) GetZoom() float64 { + w.mu.RLock() + defer w.mu.RUnlock() + return w.zoom +} + +// SetZoom sets the zoom magnification and returns the window. +func (w *WebviewWindow) SetZoom(magnification float64) Window { + w.mu.Lock() + w.zoom = magnification + w.mu.Unlock() + return w +} + +// Zoom is a no-op in the stub. +func (w *WebviewWindow) Zoom() {} + +// ZoomIn is a no-op in the stub. +func (w *WebviewWindow) ZoomIn() {} + +// ZoomOut is a no-op in the stub. +func (w *WebviewWindow) ZoomOut() {} + +// ZoomReset resets zoom to 1.0 and returns the window. +func (w *WebviewWindow) ZoomReset() Window { + w.mu.Lock() + w.zoom = 1.0 + w.mu.Unlock() + return w +} + +// GetBorderSizes returns zero insets in the stub. +func (w *WebviewWindow) GetBorderSizes() *LRTB { return &LRTB{} } + +// GetScreen returns nil in the stub. +func (w *WebviewWindow) GetScreen() (*Screen, error) { return nil, nil } + +// ExecJS is a no-op in the stub. +func (w *WebviewWindow) ExecJS(js string) {} + +// EmitEvent always returns false in the stub. +func (w *WebviewWindow) EmitEvent(name string, data ...any) bool { return false } + +// DispatchWailsEvent is a no-op in the stub. +func (w *WebviewWindow) DispatchWailsEvent(event *CustomEvent) {} + +// OnWindowEvent registers an event callback and returns an unsubscribe function. +func (w *WebviewWindow) OnWindowEvent(eventType events.WindowEventType, callback func(event *WindowEvent)) func() { + w.mu.Lock() + w.eventHandlers[eventType] = append(w.eventHandlers[eventType], callback) + w.mu.Unlock() + return func() {} +} + +// RegisterHook is an alias for OnWindowEvent. +func (w *WebviewWindow) RegisterHook(eventType events.WindowEventType, callback func(event *WindowEvent)) func() { + return w.OnWindowEvent(eventType, callback) +} + +// handleDragAndDropMessage is a no-op in the stub. +func (w *WebviewWindow) handleDragAndDropMessage(filenames []string, dropTarget *DropTargetDetails) {} + +// InitiateFrontendDropProcessing is a no-op in the stub. +func (w *WebviewWindow) InitiateFrontendDropProcessing(filenames []string, x int, y int) {} + +// HandleMessage is a no-op in the stub. +func (w *WebviewWindow) HandleMessage(message string) {} + +// HandleWindowEvent is a no-op in the stub. +func (w *WebviewWindow) HandleWindowEvent(id uint) {} + +// HandleKeyEvent is a no-op in the stub. +func (w *WebviewWindow) HandleKeyEvent(acceleratorString string) {} + +// OpenContextMenu is a no-op in the stub. +func (w *WebviewWindow) OpenContextMenu(data *ContextMenuData) {} + +// AttachModal is a no-op in the stub. +func (w *WebviewWindow) AttachModal(modalWindow Window) {} + +// OpenDevTools is a no-op in the stub. +func (w *WebviewWindow) OpenDevTools() {} + +// Print always returns nil in the stub. +func (w *WebviewWindow) Print() error { return nil } + +// Flash is a no-op in the stub. +func (w *WebviewWindow) Flash(enabled bool) {} + +// IsFocused reports whether the window has focus. +func (w *WebviewWindow) IsFocused() bool { + w.mu.RLock() + defer w.mu.RUnlock() + return w.focused +} + +// NativeWindow returns nil in the stub. +func (w *WebviewWindow) NativeWindow() unsafe.Pointer { return nil } + +// SetEnabled sets the window's enabled state. +func (w *WebviewWindow) SetEnabled(enabled bool) { + w.mu.Lock() + w.enabled = enabled + w.mu.Unlock() +} + +// Reload is a no-op in the stub. +func (w *WebviewWindow) Reload() {} + +// ForceReload is a no-op in the stub. +func (w *WebviewWindow) ForceReload() {} + +// Info is a no-op in the stub. +func (w *WebviewWindow) Info(message string, args ...any) {} + +// Error is a no-op in the stub. +func (w *WebviewWindow) Error(message string, args ...any) {} + +// shouldUnconditionallyClose always returns false in the stub. +func (w *WebviewWindow) shouldUnconditionallyClose() bool { return false } + +// Internal editing stubs — satisfy the Window interface. +func (w *WebviewWindow) cut() {} +func (w *WebviewWindow) copy() {} +func (w *WebviewWindow) paste() {} +func (w *WebviewWindow) undo() {} +func (w *WebviewWindow) redo() {} +func (w *WebviewWindow) delete() {} +func (w *WebviewWindow) selectAll() {} + +// Title returns the current window title. +func (w *WebviewWindow) Title() string { + w.mu.RLock() + defer w.mu.RUnlock() + return w.title +} + +// WindowManager manages in-memory windows. +// +// win := app.Window.NewWithOptions(application.WebviewWindowOptions{Title: "Main"}) +type WindowManager struct { + mu sync.RWMutex + windows map[uint]*WebviewWindow +} + +func (wm *WindowManager) init() { + if wm.windows == nil { + wm.windows = make(map[uint]*WebviewWindow) + } +} + +// NewWithOptions creates and registers a new window. +func (wm *WindowManager) NewWithOptions(options WebviewWindowOptions) *WebviewWindow { + window := newWebviewWindow(options) + wm.mu.Lock() + wm.init() + wm.windows[window.windowID] = window + wm.mu.Unlock() + return window +} + +// New creates a window with default options. +func (wm *WindowManager) New() *WebviewWindow { + return wm.NewWithOptions(WebviewWindowOptions{}) +} + +// GetAll returns all managed windows as the Window interface slice. +func (wm *WindowManager) GetAll() []Window { + wm.mu.RLock() + defer wm.mu.RUnlock() + out := make([]Window, 0, len(wm.windows)) + for _, window := range wm.windows { + out = append(out, window) + } + return out +} + +// GetByName finds a window by name, returning it and whether it was found. +func (wm *WindowManager) GetByName(name string) (Window, bool) { + wm.mu.RLock() + defer wm.mu.RUnlock() + for _, window := range wm.windows { + if window.opts.Name == name { + return window, true + } + } + return nil, false +} + +// GetByID finds a window by its numeric ID. +func (wm *WindowManager) GetByID(id uint) (Window, bool) { + wm.mu.RLock() + defer wm.mu.RUnlock() + window, exists := wm.windows[id] + return window, exists +} + +// Remove unregisters a window by ID. +func (wm *WindowManager) Remove(windowID uint) { + wm.mu.Lock() + wm.init() + delete(wm.windows, windowID) + wm.mu.Unlock() +} + +// App is the top-level application object used by the GUI packages. +// +// app := &application.App{} +// win := app.Window.NewWithOptions(application.WebviewWindowOptions{Title: "Main"}) +type App struct { + Logger Logger + Window WindowManager + Menu MenuManager + SystemTray SystemTrayManager + Dialog DialogManager + Event EventManager + Browser BrowserManager + Clipboard ClipboardManager + ContextMenu ContextMenuManager + Environment EnvironmentManager + Screen ScreenManager + KeyBinding KeyBindingManager +} + +// Quit is a no-op in the stub. +func (a *App) Quit() {} + +// NewMenu creates a new empty Menu. +func (a *App) NewMenu() *Menu { + return NewMenu() +} diff --git a/stubs/wails/pkg/application/application_options.go b/stubs/wails/pkg/application/application_options.go new file mode 100644 index 00000000..fca6f5cd --- /dev/null +++ b/stubs/wails/pkg/application/application_options.go @@ -0,0 +1,348 @@ +package application + +import ( + "net/http" + "time" +) + +// Options is the top-level application configuration passed to New(). +// app := application.New(application.Options{Name: "MyApp", Services: []Service{...}}) +type Options struct { + // Name is displayed in the default about box. + Name string + + // Description is displayed in the default about box. + Description string + + // Icon is the application icon shown in the about box. + Icon []byte + + // Mac contains macOS-specific options. + Mac MacOptions + + // Windows contains Windows-specific options. + Windows WindowsOptions + + // Linux contains Linux-specific options. + Linux LinuxOptions + + // IOS contains iOS-specific options. + IOS IOSOptions + + // Android contains Android-specific options. + Android AndroidOptions + + // Services lists bound Go services exposed to the frontend. + Services []Service + + // MarshalError serialises service method errors to JSON. + // Return nil to fall back to the default error handler. + MarshalError func(error) []byte + + // BindAliases maps alias IDs to bound method IDs. + // Example: map[uint32]uint32{1: 1411160069} + BindAliases map[uint32]uint32 + + // Assets configures the embedded asset server. + Assets AssetOptions + + // Flags are key/value pairs available to the frontend at startup. + Flags map[string]any + + // PanicHandler is called when an unhandled panic occurs. + PanicHandler func(*PanicDetails) + + // DisableDefaultSignalHandler prevents Wails from handling OS signals. + DisableDefaultSignalHandler bool + + // KeyBindings maps accelerator strings to window callbacks. + // Example: map[string]func(Window){"Ctrl+Q": func(w Window) { w.Close() }} + KeyBindings map[string]func(window Window) + + // OnShutdown is called before the application terminates. + OnShutdown func() + + // PostShutdown is called after shutdown, just before process exit. + PostShutdown func() + + // ShouldQuit is called when the user attempts to quit. + // Return false to prevent the application from quitting. + ShouldQuit func() bool + + // RawMessageHandler handles raw messages from the frontend. + RawMessageHandler func(window Window, message string, originInfo *OriginInfo) + + // WarningHandler is called when a non-fatal warning occurs. + WarningHandler func(string) + + // ErrorHandler is called when a non-fatal error occurs. + ErrorHandler func(err error) + + // FileAssociations lists file extensions associated with this application. + // Each extension must include the leading dot, e.g. ".txt". + FileAssociations []string + + // SingleInstance configures single-instance enforcement. + SingleInstance *SingleInstanceOptions + + // Server configures the headless HTTP server (enabled via the "server" build tag). + Server ServerOptions +} + +// ServerOptions configures the headless HTTP server started in server mode. +// opts.Server = application.ServerOptions{Host: "0.0.0.0", Port: 8080} +type ServerOptions struct { + // Host is the bind address. Defaults to "localhost". + Host string + + // Port is the TCP port. Defaults to 8080. + Port int + + // ReadTimeout is the maximum duration for reading a complete request. + ReadTimeout time.Duration + + // WriteTimeout is the maximum duration before timing out a response write. + WriteTimeout time.Duration + + // IdleTimeout is the maximum duration to wait for the next request. + IdleTimeout time.Duration + + // ShutdownTimeout is the maximum duration to wait for active connections on shutdown. + ShutdownTimeout time.Duration + + // TLS configures HTTPS. If nil, plain HTTP is used. + TLS *TLSOptions +} + +// TLSOptions configures HTTPS for the headless server. +// opts.Server.TLS = &application.TLSOptions{CertFile: "cert.pem", KeyFile: "key.pem"} +type TLSOptions struct { + // CertFile is the path to the TLS certificate file. + CertFile string + + // KeyFile is the path to the TLS private key file. + KeyFile string +} + +// AssetOptions configures the embedded asset server. +// opts.Assets = application.AssetOptions{Handler: http.FileServer(http.FS(assets))} +type AssetOptions struct { + // Handler serves all content to the WebView. + Handler http.Handler + + // Middleware injects into the asset server request chain before Wails internals. + Middleware Middleware + + // DisableLogging suppresses per-request asset server log output. + DisableLogging bool +} + +// Middleware is an HTTP middleware function for the asset server. +// type Middleware func(next http.Handler) http.Handler +type Middleware func(next http.Handler) http.Handler + +// ChainMiddleware composes multiple Middleware values into a single Middleware. +// chain := application.ChainMiddleware(authMiddleware, loggingMiddleware) +func ChainMiddleware(middleware ...Middleware) Middleware { + return func(handler http.Handler) http.Handler { + for index := len(middleware) - 1; index >= 0; index-- { + handler = middleware[index](handler) + } + return handler + } +} + +// PanicDetails carries information about an unhandled panic. +// opts.PanicHandler = func(d *application.PanicDetails) { log(d.StackTrace) } +type PanicDetails struct { + StackTrace string + Error error + FullStackTrace string +} + +// OriginInfo carries frame-origin metadata for raw message handling. +// opts.RawMessageHandler = func(w Window, msg string, o *application.OriginInfo) { ... } +type OriginInfo struct { + Origin string + TopOrigin string + IsMainFrame bool +} + +// SingleInstanceOptions configures single-instance enforcement. +// opts.SingleInstance = &application.SingleInstanceOptions{UniqueID: "com.example.myapp"} +type SingleInstanceOptions struct { + // UniqueID identifies the application instance, e.g. "com.example.myapp". + UniqueID string + + // OnSecondInstanceLaunch is called when a second instance attempts to start. + OnSecondInstanceLaunch func(data SecondInstanceData) + + // AdditionalData passes custom data from the second instance to the first. + AdditionalData map[string]string +} + +// SecondInstanceData describes a second-instance launch event. +type SecondInstanceData struct { + Args []string `json:"args"` + WorkingDir string `json:"workingDir"` + AdditionalData map[string]string `json:"additionalData,omitempty"` +} + +// ActivationPolicy controls when a macOS application activates. +// opts.Mac.ActivationPolicy = application.ActivationPolicyAccessory +type ActivationPolicy int + +const ( + // ActivationPolicyRegular is used for applications with a main window. + ActivationPolicyRegular ActivationPolicy = iota + // ActivationPolicyAccessory is used for menu-bar or background applications. + ActivationPolicyAccessory + // ActivationPolicyProhibited prevents the application from activating. + ActivationPolicyProhibited +) + +// MacOptions contains macOS-specific application options. +// opts.Mac = application.MacOptions{ActivationPolicy: application.ActivationPolicyRegular} +type MacOptions struct { + // ActivationPolicy controls how and when the application becomes active. + ActivationPolicy ActivationPolicy + + // ApplicationShouldTerminateAfterLastWindowClosed quits the app when + // the last window closes, matching standard macOS behaviour. + ApplicationShouldTerminateAfterLastWindowClosed bool +} + +// WindowsOptions contains Windows-specific application options. +// opts.Windows = application.WindowsOptions{WndClass: "MyAppWindow"} +type WindowsOptions struct { + // WndClass is the Windows window class name. Defaults to "WailsWebviewWindow". + WndClass string + + // WndProcInterceptor intercepts all Win32 messages in the main message loop. + WndProcInterceptor func(hwnd uintptr, msg uint32, wParam, lParam uintptr) (returnCode uintptr, shouldReturn bool) + + // DisableQuitOnLastWindowClosed prevents auto-quit when the last window closes. + DisableQuitOnLastWindowClosed bool + + // WebviewUserDataPath sets the WebView2 user-data directory. + // Defaults to %APPDATA%\[BinaryName.exe]. + WebviewUserDataPath string + + // WebviewBrowserPath sets the directory containing WebView2 executables. + // Defaults to the system-installed WebView2. + WebviewBrowserPath string + + // EnabledFeatures lists WebView2 feature flags to enable. + EnabledFeatures []string + + // DisabledFeatures lists WebView2 feature flags to disable. + DisabledFeatures []string + + // AdditionalBrowserArgs are extra Chromium command-line arguments. + // Each argument must include the "--" prefix, e.g. "--remote-debugging-port=9222". + AdditionalBrowserArgs []string +} + +// LinuxOptions contains Linux-specific application options. +// opts.Linux = application.LinuxOptions{ProgramName: "myapp"} +type LinuxOptions struct { + // DisableQuitOnLastWindowClosed prevents auto-quit when the last window closes. + DisableQuitOnLastWindowClosed bool + + // ProgramName is passed to g_set_prgname() for window grouping in GTK. + ProgramName string +} + +// IOSOptions contains iOS-specific application options. +// opts.IOS = application.IOSOptions{EnableInlineMediaPlayback: true} +type IOSOptions struct { + // DisableInputAccessoryView hides the Next/Previous/Done toolbar above the keyboard. + DisableInputAccessoryView bool + + // DisableScroll disables WebView scrolling. + DisableScroll bool + + // DisableBounce disables the iOS overscroll bounce effect. + DisableBounce bool + + // DisableScrollIndicators hides scroll indicator bars. + DisableScrollIndicators bool + + // EnableBackForwardNavigationGestures enables swipe navigation gestures. + EnableBackForwardNavigationGestures bool + + // DisableLinkPreview disables long-press link preview (peek and pop). + DisableLinkPreview bool + + // EnableInlineMediaPlayback allows video to play inline rather than full-screen. + EnableInlineMediaPlayback bool + + // EnableAutoplayWithoutUserAction allows media to autoplay without a user gesture. + EnableAutoplayWithoutUserAction bool + + // DisableInspectable disables the Safari remote web inspector. + DisableInspectable bool + + // UserAgent overrides the WKWebView user agent string. + UserAgent string + + // ApplicationNameForUserAgent appends a name to the user agent. Defaults to "wails.io". + ApplicationNameForUserAgent string + + // AppBackgroundColourSet enables BackgroundColour for the main iOS window. + AppBackgroundColourSet bool + + // BackgroundColour is applied to the iOS app window before any WebView is created. + BackgroundColour RGBA + + // EnableNativeTabs enables a native UITabBar at the bottom of the screen. + EnableNativeTabs bool + + // NativeTabsItems configures the labels and SF Symbol icons for the native UITabBar. + NativeTabsItems []NativeTabItem +} + +// NativeTabItem describes a single tab in the iOS native UITabBar. +// item := application.NativeTabItem{Title: "Home", SystemImage: application.NativeTabIconHouse} +type NativeTabItem struct { + Title string `json:"Title"` + SystemImage NativeTabIcon `json:"SystemImage"` +} + +// NativeTabIcon is an SF Symbols name used for a UITabBar icon. +// tab := application.NativeTabItem{SystemImage: application.NativeTabIconGear} +type NativeTabIcon string + +const ( + NativeTabIconNone NativeTabIcon = "" + NativeTabIconHouse NativeTabIcon = "house" + NativeTabIconGear NativeTabIcon = "gear" + NativeTabIconStar NativeTabIcon = "star" + NativeTabIconPerson NativeTabIcon = "person" + NativeTabIconBell NativeTabIcon = "bell" + NativeTabIconMagnify NativeTabIcon = "magnifyingglass" + NativeTabIconList NativeTabIcon = "list.bullet" + NativeTabIconFolder NativeTabIcon = "folder" +) + +// AndroidOptions contains Android-specific application options. +// opts.Android = application.AndroidOptions{EnableZoom: true} +type AndroidOptions struct { + // DisableScroll disables WebView scrolling. + DisableScroll bool + + // DisableOverscroll disables the overscroll bounce effect. + DisableOverscroll bool + + // EnableZoom enables pinch-to-zoom in the WebView. + EnableZoom bool + + // UserAgent overrides the WebView user agent string. + UserAgent string + + // BackgroundColour sets the WebView background colour. + BackgroundColour RGBA + + // DisableHardwareAcceleration disables GPU acceleration for the WebView. + DisableHardwareAcceleration bool +} diff --git a/stubs/wails/pkg/application/browser_manager.go b/stubs/wails/pkg/application/browser_manager.go new file mode 100644 index 00000000..c08311f6 --- /dev/null +++ b/stubs/wails/pkg/application/browser_manager.go @@ -0,0 +1,21 @@ +package application + +// BrowserManager handles opening URLs and files in the system browser. +// +// manager.OpenURL("https://lthn.io") +// manager.OpenFile("/home/user/document.pdf") +type BrowserManager struct{} + +// OpenURL opens the given URL in the default browser. +// +// err := manager.OpenURL("https://lthn.io") +func (bm *BrowserManager) OpenURL(url string) error { + return nil +} + +// OpenFile opens the given file path in the default browser or file handler. +// +// err := manager.OpenFile("/home/user/report.html") +func (bm *BrowserManager) OpenFile(path string) error { + return nil +} diff --git a/stubs/wails/pkg/application/browser_window.go b/stubs/wails/pkg/application/browser_window.go new file mode 100644 index 00000000..e6dd7114 --- /dev/null +++ b/stubs/wails/pkg/application/browser_window.go @@ -0,0 +1,230 @@ +package application + +import ( + "sync" + "unsafe" + + "github.com/wailsapp/wails/v3/pkg/events" +) + +// ButtonState represents the visual state of a window control button. +// +// window.SetMinimiseButtonState(ButtonHidden) +type ButtonState int + +const ( + ButtonEnabled ButtonState = 0 + ButtonDisabled ButtonState = 1 + ButtonHidden ButtonState = 2 +) + +// LRTB holds left/right/top/bottom border sizes in pixels. +// +// sizes := window.GetBorderSizes() +type LRTB struct { + Left int + Right int + Top int + Bottom int +} + +// ContextMenuData carries context-menu position and metadata from the frontend. +// +// window.OpenContextMenu(&ContextMenuData{Id: "file-menu"}) +type ContextMenuData struct { + Id string `json:"id"` + X int `json:"x"` + Y int `json:"y"` + Data string `json:"data"` +} + +func (c *ContextMenuData) clone() *ContextMenuData { + if c == nil { + return nil + } + copy := *c + return © +} + +// CustomEvent carries a named event with arbitrary data from the frontend. +// +// window.DispatchWailsEvent(&CustomEvent{Name: "ready", Data: nil}) +type CustomEvent struct { + Name string `json:"name"` + Data any `json:"data"` + Sender string `json:"sender,omitempty"` + cancelled bool +} + +// Cancel prevents the event from reaching further listeners. +func (e *CustomEvent) Cancel() { e.cancelled = true } + +// IsCancelled reports whether Cancel has been called. +func (e *CustomEvent) IsCancelled() bool { return e.cancelled } + +// BrowserWindow represents a browser client connection in server mode. +// It satisfies the Window interface so browser clients are treated +// uniformly with native windows throughout the codebase. +// +// bw := NewBrowserWindow(1, "nano-abc123") +// bw.Focus() // no-op in browser mode +type BrowserWindow struct { + mu sync.RWMutex + id uint + name string + clientID string +} + +// NewBrowserWindow constructs a BrowserWindow with the given numeric ID and client nano-ID. +// +// bw := NewBrowserWindow(1, "nano-abc123") +func NewBrowserWindow(id uint, clientID string) *BrowserWindow { + return &BrowserWindow{ + id: id, + name: "browser-window", + clientID: clientID, + } +} + +// ID returns the numeric window identifier. +func (b *BrowserWindow) ID() uint { return b.id } + +// Name returns the window name. +func (b *BrowserWindow) Name() string { + b.mu.RLock() + defer b.mu.RUnlock() + return b.name +} + +// ClientID returns the runtime nano-ID for this client. +func (b *BrowserWindow) ClientID() string { + b.mu.RLock() + defer b.mu.RUnlock() + return b.clientID +} + +// No-op windowing methods — browser windows have no native chrome. + +func (b *BrowserWindow) Center() {} +func (b *BrowserWindow) Close() {} +func (b *BrowserWindow) DisableSizeConstraints() {} +func (b *BrowserWindow) EnableSizeConstraints() {} +func (b *BrowserWindow) ExecJS(_ string) {} +func (b *BrowserWindow) Focus() {} +func (b *BrowserWindow) ForceReload() {} +func (b *BrowserWindow) HideMenuBar() {} +func (b *BrowserWindow) OpenDevTools() {} +func (b *BrowserWindow) Reload() {} +func (b *BrowserWindow) Restore() {} +func (b *BrowserWindow) Run() {} +func (b *BrowserWindow) SetPosition(_ int, _ int) {} +func (b *BrowserWindow) ShowMenuBar() {} +func (b *BrowserWindow) SnapAssist() {} +func (b *BrowserWindow) ToggleFrameless() {} +func (b *BrowserWindow) ToggleFullscreen() {} +func (b *BrowserWindow) ToggleMaximise() {} +func (b *BrowserWindow) ToggleMenuBar() {} +func (b *BrowserWindow) UnFullscreen() {} +func (b *BrowserWindow) UnMaximise() {} +func (b *BrowserWindow) UnMinimise() {} +func (b *BrowserWindow) SetEnabled(_ bool) {} +func (b *BrowserWindow) Flash(_ bool) {} +func (b *BrowserWindow) SetMenu(_ *Menu) {} +func (b *BrowserWindow) SetBounds(_ Rect) {} +func (b *BrowserWindow) Zoom() {} +func (b *BrowserWindow) ZoomIn() {} +func (b *BrowserWindow) ZoomOut() {} +func (b *BrowserWindow) OpenContextMenu(_ *ContextMenuData) {} +func (b *BrowserWindow) HandleMessage(_ string) {} +func (b *BrowserWindow) HandleWindowEvent(_ uint) {} +func (b *BrowserWindow) HandleKeyEvent(_ string) {} +func (b *BrowserWindow) AttachModal(_ Window) {} + +// Internal editing stubs. +func (b *BrowserWindow) cut() {} +func (b *BrowserWindow) copy() {} +func (b *BrowserWindow) paste() {} +func (b *BrowserWindow) undo() {} +func (b *BrowserWindow) redo() {} +func (b *BrowserWindow) delete() {} +func (b *BrowserWindow) selectAll() {} + +// shouldUnconditionallyClose always returns false for browser windows. +func (b *BrowserWindow) shouldUnconditionallyClose() bool { return false } + +// Methods returning Window for chaining — always no-op for browser windows. + +func (b *BrowserWindow) Fullscreen() Window { return b } +func (b *BrowserWindow) Hide() Window { return b } +func (b *BrowserWindow) Maximise() Window { return b } +func (b *BrowserWindow) Minimise() Window { return b } +func (b *BrowserWindow) Show() Window { return b } +func (b *BrowserWindow) SetAlwaysOnTop(_ bool) Window { return b } +func (b *BrowserWindow) SetBackgroundColour(_ RGBA) Window { return b } +func (b *BrowserWindow) SetFrameless(_ bool) Window { return b } +func (b *BrowserWindow) SetHTML(_ string) Window { return b } +func (b *BrowserWindow) SetMinimiseButtonState(_ ButtonState) Window { return b } +func (b *BrowserWindow) SetMaximiseButtonState(_ ButtonState) Window { return b } +func (b *BrowserWindow) SetCloseButtonState(_ ButtonState) Window { return b } +func (b *BrowserWindow) SetMaxSize(_ int, _ int) Window { return b } +func (b *BrowserWindow) SetMinSize(_ int, _ int) Window { return b } +func (b *BrowserWindow) SetRelativePosition(_ int, _ int) Window { return b } +func (b *BrowserWindow) SetResizable(_ bool) Window { return b } +func (b *BrowserWindow) SetIgnoreMouseEvents(_ bool) Window { return b } +func (b *BrowserWindow) SetSize(_ int, _ int) Window { return b } +func (b *BrowserWindow) SetTitle(_ string) Window { return b } +func (b *BrowserWindow) SetURL(_ string) Window { return b } +func (b *BrowserWindow) SetZoom(_ float64) Window { return b } +func (b *BrowserWindow) SetContentProtection(_ bool) Window { return b } +func (b *BrowserWindow) ZoomReset() Window { return b } + +// Methods returning simple zero values. + +func (b *BrowserWindow) GetBorderSizes() *LRTB { return nil } +func (b *BrowserWindow) GetScreen() (*Screen, error) { return nil, nil } +func (b *BrowserWindow) GetZoom() float64 { return 1.0 } +func (b *BrowserWindow) Height() int { return 0 } +func (b *BrowserWindow) Width() int { return 0 } +func (b *BrowserWindow) IsFocused() bool { return false } +func (b *BrowserWindow) IsFullscreen() bool { return false } +func (b *BrowserWindow) IsIgnoreMouseEvents() bool { return false } +func (b *BrowserWindow) IsMaximised() bool { return false } +func (b *BrowserWindow) IsMinimised() bool { return false } +func (b *BrowserWindow) IsVisible() bool { return true } +func (b *BrowserWindow) Resizable() bool { return false } +func (b *BrowserWindow) Position() (int, int) { return 0, 0 } +func (b *BrowserWindow) RelativePosition() (int, int) { return 0, 0 } +func (b *BrowserWindow) Size() (int, int) { return 0, 0 } +func (b *BrowserWindow) Bounds() Rect { return Rect{} } +func (b *BrowserWindow) NativeWindow() unsafe.Pointer { return nil } +func (b *BrowserWindow) Print() error { return nil } + +// DispatchWailsEvent is a no-op for browser windows; events are broadcast via WebSocket. +func (b *BrowserWindow) DispatchWailsEvent(_ *CustomEvent) {} + +// EmitEvent broadcasts a named event; always returns false in the stub. +func (b *BrowserWindow) EmitEvent(_ string, _ ...any) bool { return false } + +// Error logs an error message (no-op in the stub). +func (b *BrowserWindow) Error(_ string, _ ...any) {} + +// Info logs an info message (no-op in the stub). +func (b *BrowserWindow) Info(_ string, _ ...any) {} + +// OnWindowEvent registers a callback for a window event type; returns an unsubscribe func. +// +// unsubscribe := bw.OnWindowEvent(events.Common.WindowClosing, fn) +func (b *BrowserWindow) OnWindowEvent(_ events.WindowEventType, _ func(*WindowEvent)) func() { + return func() {} +} + +// RegisterHook registers a lifecycle hook; returns an unsubscribe func. +func (b *BrowserWindow) RegisterHook(_ events.WindowEventType, _ func(*WindowEvent)) func() { + return func() {} +} + +// handleDragAndDropMessage is a no-op for browser windows. +func (b *BrowserWindow) handleDragAndDropMessage(_ []string, _ *DropTargetDetails) {} + +// InitiateFrontendDropProcessing is a no-op for browser windows. +func (b *BrowserWindow) InitiateFrontendDropProcessing(_ []string, _ int, _ int) {} diff --git a/stubs/wails/pkg/application/clipboard.go b/stubs/wails/pkg/application/clipboard.go new file mode 100644 index 00000000..a26238ef --- /dev/null +++ b/stubs/wails/pkg/application/clipboard.go @@ -0,0 +1,65 @@ +package application + +import "sync" + +// Clipboard provides direct read/write access to the system clipboard. +// +// ok := clipboard.SetText("hello") +// text, ok := clipboard.Text() +type Clipboard struct { + mu sync.RWMutex + text string +} + +// SetText writes the given text to the clipboard and returns true on success. +// +// ok := clipboard.SetText("copied text") +func (c *Clipboard) SetText(text string) bool { + c.mu.Lock() + c.text = text + c.mu.Unlock() + return true +} + +// Text reads the current clipboard text. Returns the text and true on success. +// +// text, ok := clipboard.Text() +func (c *Clipboard) Text() (string, bool) { + c.mu.RLock() + defer c.mu.RUnlock() + return c.text, true +} + +// ClipboardManager is the application-level clipboard surface. +// Lazily initialises the underlying Clipboard on first use. +// +// manager.SetText("hello") +// text, ok := manager.Text() +type ClipboardManager struct { + mu sync.Mutex + clipboard *Clipboard +} + +// SetText writes text to the clipboard and returns true on success. +// +// ok := manager.SetText("hello") +func (cm *ClipboardManager) SetText(text string) bool { + return cm.instance().SetText(text) +} + +// Text reads the current clipboard text. Returns the text and true on success. +// +// text, ok := manager.Text() +func (cm *ClipboardManager) Text() (string, bool) { + return cm.instance().Text() +} + +// instance returns the Clipboard, creating it if it does not yet exist. +func (cm *ClipboardManager) instance() *Clipboard { + cm.mu.Lock() + defer cm.mu.Unlock() + if cm.clipboard == nil { + cm.clipboard = &Clipboard{} + } + return cm.clipboard +} diff --git a/stubs/wails/pkg/application/context_menu.go b/stubs/wails/pkg/application/context_menu.go new file mode 100644 index 00000000..9acd14a4 --- /dev/null +++ b/stubs/wails/pkg/application/context_menu.go @@ -0,0 +1,73 @@ +package application + +import "sync" + +// ContextMenu is a named Menu used as a right-click context menu. +// +// cm := manager.New() +// cm.Add("Cut").OnClick(func(*Context) { ... }) +type ContextMenu struct { + *Menu + name string +} + +// ContextMenuManager manages named context menus for the application. +// +// manager.Add("fileList", cm) +// menu, ok := manager.Get("fileList") +type ContextMenuManager struct { + mu sync.RWMutex + menus map[string]*ContextMenu +} + +// New creates an empty, unnamed ContextMenu ready for population. +// +// cm := manager.New() +// cm.Add("Open") +func (cmm *ContextMenuManager) New() *ContextMenu { + return &ContextMenu{Menu: NewMenu()} +} + +// Add registers a ContextMenu under the given name, replacing any existing entry. +// +// manager.Add("fileList", cm) +func (cmm *ContextMenuManager) Add(name string, menu *ContextMenu) { + cmm.mu.Lock() + defer cmm.mu.Unlock() + if cmm.menus == nil { + cmm.menus = make(map[string]*ContextMenu) + } + cmm.menus[name] = menu +} + +// Remove unregisters the context menu with the given name. +// +// manager.Remove("fileList") +func (cmm *ContextMenuManager) Remove(name string) { + cmm.mu.Lock() + defer cmm.mu.Unlock() + delete(cmm.menus, name) +} + +// Get retrieves a registered context menu by name. +// +// menu, ok := manager.Get("fileList") +func (cmm *ContextMenuManager) Get(name string) (*ContextMenu, bool) { + cmm.mu.RLock() + defer cmm.mu.RUnlock() + menu, exists := cmm.menus[name] + return menu, exists +} + +// GetAll returns all registered context menus as a slice. +// +// for _, cm := range manager.GetAll() { ... } +func (cmm *ContextMenuManager) GetAll() []*ContextMenu { + cmm.mu.RLock() + defer cmm.mu.RUnlock() + result := make([]*ContextMenu, 0, len(cmm.menus)) + for _, menu := range cmm.menus { + result = append(result, menu) + } + return result +} diff --git a/stubs/wails/pkg/application/dialog.go b/stubs/wails/pkg/application/dialog.go new file mode 100644 index 00000000..4a5090a2 --- /dev/null +++ b/stubs/wails/pkg/application/dialog.go @@ -0,0 +1,481 @@ +package application + +// DialogType identifies the visual style of a message dialog. +type DialogType int + +const ( + InfoDialogType DialogType = iota + QuestionDialogType DialogType = iota + WarningDialogType DialogType = iota + ErrorDialogType DialogType = iota +) + +// FileFilter describes a file type filter for open/save dialogs. +// +// filter := FileFilter{DisplayName: "Images (*.png;*.jpg)", Pattern: "*.png;*.jpg"} +type FileFilter struct { + DisplayName string + Pattern string +} + +// Button is a labelled action in a MessageDialog. +// +// btn := dialog.AddButton("OK") +// btn.SetAsDefault().OnClick(func() { ... }) +type Button struct { + Label string + IsCancel bool + IsDefault bool + Callback func() +} + +// OnClick registers a click handler on the button and returns itself for chaining. +// +// btn.OnClick(func() { saveFile() }) +func (b *Button) OnClick(callback func()) *Button { + b.Callback = callback + return b +} + +// SetAsDefault marks this button as the default (Enter key) action. +func (b *Button) SetAsDefault() *Button { + b.IsDefault = true + return b +} + +// SetAsCancel marks this button as the cancel (Escape key) action. +func (b *Button) SetAsCancel() *Button { + b.IsCancel = true + return b +} + +// MessageDialogOptions holds configuration for a MessageDialog. +type MessageDialogOptions struct { + DialogType DialogType + Title string + Message string + Buttons []*Button + Icon []byte +} + +// MessageDialog is an in-memory message dialog (info / question / warning / error). +// +// dialog.Info().SetTitle("Done").SetMessage("File saved.").Show() +type MessageDialog struct { + MessageDialogOptions +} + +// SetTitle sets the dialog window title. +// +// dialog.SetTitle("Confirm Delete") +func (d *MessageDialog) SetTitle(title string) *MessageDialog { + d.Title = title + return d +} + +// SetMessage sets the body text shown in the dialog. +// +// dialog.SetMessage("Are you sure?") +func (d *MessageDialog) SetMessage(message string) *MessageDialog { + d.Message = message + return d +} + +// SetIcon sets the icon bytes shown in the dialog. +func (d *MessageDialog) SetIcon(icon []byte) *MessageDialog { + d.Icon = icon + return d +} + +// AddButton appends a labelled button and returns it for further configuration. +// +// btn := dialog.AddButton("Yes") +func (d *MessageDialog) AddButton(label string) *Button { + btn := &Button{Label: label} + d.Buttons = append(d.Buttons, btn) + return btn +} + +// AddButtons replaces the button list in bulk. +func (d *MessageDialog) AddButtons(buttons []*Button) *MessageDialog { + d.Buttons = buttons + return d +} + +// SetDefaultButton marks the given button as the default action. +func (d *MessageDialog) SetDefaultButton(button *Button) *MessageDialog { + for _, b := range d.Buttons { + b.IsDefault = false + } + button.IsDefault = true + return d +} + +// SetCancelButton marks the given button as the cancel action. +func (d *MessageDialog) SetCancelButton(button *Button) *MessageDialog { + for _, b := range d.Buttons { + b.IsCancel = false + } + button.IsCancel = true + return d +} + +// AttachToWindow associates the dialog with a parent window (no-op in the stub). +func (d *MessageDialog) AttachToWindow(window *WebviewWindow) *MessageDialog { + return d +} + +// Show presents the dialog. No-op in the stub. +func (d *MessageDialog) Show() {} + +func newMessageDialog(dialogType DialogType) *MessageDialog { + return &MessageDialog{ + MessageDialogOptions: MessageDialogOptions{DialogType: dialogType}, + } +} + +// OpenFileDialogOptions configures an OpenFileDialogStruct. +type OpenFileDialogOptions struct { + CanChooseDirectories bool + CanChooseFiles bool + CanCreateDirectories bool + ShowHiddenFiles bool + ResolvesAliases bool + AllowsMultipleSelection bool + HideExtension bool + CanSelectHiddenExtension bool + TreatsFilePackagesAsDirectories bool + AllowsOtherFileTypes bool + Filters []FileFilter + Title string + Message string + ButtonText string + Directory string +} + +// OpenFileDialogStruct is a builder for file-open dialogs. +// +// path, err := manager.OpenFile().SetTitle("Pick a file").PromptForSingleSelection() +type OpenFileDialogStruct struct { + canChooseDirectories bool + canChooseFiles bool + canCreateDirectories bool + showHiddenFiles bool + resolvesAliases bool + allowsMultipleSelection bool + hideExtension bool + canSelectHiddenExtension bool + treatsFilePackagesAsDirectories bool + allowsOtherFileTypes bool + filters []FileFilter + title string + message string + buttonText string + directory string +} + +func newOpenFileDialog() *OpenFileDialogStruct { + return &OpenFileDialogStruct{ + canChooseFiles: true, + canCreateDirectories: true, + } +} + +// SetOptions applies all fields from OpenFileDialogOptions to the dialog. +func (d *OpenFileDialogStruct) SetOptions(options *OpenFileDialogOptions) { + d.title = options.Title + d.message = options.Message + d.buttonText = options.ButtonText + d.directory = options.Directory + d.canChooseDirectories = options.CanChooseDirectories + d.canChooseFiles = options.CanChooseFiles + d.canCreateDirectories = options.CanCreateDirectories + d.showHiddenFiles = options.ShowHiddenFiles + d.resolvesAliases = options.ResolvesAliases + d.allowsMultipleSelection = options.AllowsMultipleSelection + d.hideExtension = options.HideExtension + d.canSelectHiddenExtension = options.CanSelectHiddenExtension + d.treatsFilePackagesAsDirectories = options.TreatsFilePackagesAsDirectories + d.allowsOtherFileTypes = options.AllowsOtherFileTypes + d.filters = options.Filters +} + +func (d *OpenFileDialogStruct) SetTitle(title string) *OpenFileDialogStruct { + d.title = title + return d +} + +func (d *OpenFileDialogStruct) SetMessage(message string) *OpenFileDialogStruct { + d.message = message + return d +} + +func (d *OpenFileDialogStruct) SetButtonText(text string) *OpenFileDialogStruct { + d.buttonText = text + return d +} + +func (d *OpenFileDialogStruct) SetDirectory(directory string) *OpenFileDialogStruct { + d.directory = directory + return d +} + +func (d *OpenFileDialogStruct) CanChooseFiles(canChooseFiles bool) *OpenFileDialogStruct { + d.canChooseFiles = canChooseFiles + return d +} + +func (d *OpenFileDialogStruct) CanChooseDirectories(canChooseDirectories bool) *OpenFileDialogStruct { + d.canChooseDirectories = canChooseDirectories + return d +} + +func (d *OpenFileDialogStruct) CanCreateDirectories(canCreateDirectories bool) *OpenFileDialogStruct { + d.canCreateDirectories = canCreateDirectories + return d +} + +func (d *OpenFileDialogStruct) ShowHiddenFiles(showHiddenFiles bool) *OpenFileDialogStruct { + d.showHiddenFiles = showHiddenFiles + return d +} + +func (d *OpenFileDialogStruct) HideExtension(hideExtension bool) *OpenFileDialogStruct { + d.hideExtension = hideExtension + return d +} + +func (d *OpenFileDialogStruct) CanSelectHiddenExtension(canSelectHiddenExtension bool) *OpenFileDialogStruct { + d.canSelectHiddenExtension = canSelectHiddenExtension + return d +} + +func (d *OpenFileDialogStruct) ResolvesAliases(resolvesAliases bool) *OpenFileDialogStruct { + d.resolvesAliases = resolvesAliases + return d +} + +func (d *OpenFileDialogStruct) AllowsOtherFileTypes(allowsOtherFileTypes bool) *OpenFileDialogStruct { + d.allowsOtherFileTypes = allowsOtherFileTypes + return d +} + +func (d *OpenFileDialogStruct) TreatsFilePackagesAsDirectories(treats bool) *OpenFileDialogStruct { + d.treatsFilePackagesAsDirectories = treats + return d +} + +// AddFilter appends a file type filter to the dialog. +// +// dialog.AddFilter("Images", "*.png;*.jpg") +func (d *OpenFileDialogStruct) AddFilter(displayName, pattern string) *OpenFileDialogStruct { + d.filters = append(d.filters, FileFilter{DisplayName: displayName, Pattern: pattern}) + return d +} + +func (d *OpenFileDialogStruct) AttachToWindow(window *WebviewWindow) *OpenFileDialogStruct { + return d +} + +// PromptForSingleSelection shows the dialog and returns the chosen path. +// Always returns ("", nil) in the stub. +// +// path, err := dialog.PromptForSingleSelection() +func (d *OpenFileDialogStruct) PromptForSingleSelection() (string, error) { + return "", nil +} + +// PromptForMultipleSelection shows the dialog and returns all chosen paths. +// Always returns (nil, nil) in the stub. +// +// paths, err := dialog.PromptForMultipleSelection() +func (d *OpenFileDialogStruct) PromptForMultipleSelection() ([]string, error) { + return nil, nil +} + +// SaveFileDialogOptions configures a SaveFileDialogStruct. +type SaveFileDialogOptions struct { + CanCreateDirectories bool + ShowHiddenFiles bool + CanSelectHiddenExtension bool + AllowOtherFileTypes bool + HideExtension bool + TreatsFilePackagesAsDirectories bool + Title string + Message string + Directory string + Filename string + ButtonText string + Filters []FileFilter +} + +// SaveFileDialogStruct is a builder for file-save dialogs. +// +// path, err := manager.SaveFile().SetTitle("Save As").PromptForSingleSelection() +type SaveFileDialogStruct struct { + canCreateDirectories bool + showHiddenFiles bool + canSelectHiddenExtension bool + allowOtherFileTypes bool + hideExtension bool + treatsFilePackagesAsDirectories bool + title string + message string + directory string + filename string + buttonText string + filters []FileFilter +} + +func newSaveFileDialog() *SaveFileDialogStruct { + return &SaveFileDialogStruct{canCreateDirectories: true} +} + +// SetOptions applies all fields from SaveFileDialogOptions to the dialog. +func (d *SaveFileDialogStruct) SetOptions(options *SaveFileDialogOptions) { + d.title = options.Title + d.canCreateDirectories = options.CanCreateDirectories + d.showHiddenFiles = options.ShowHiddenFiles + d.canSelectHiddenExtension = options.CanSelectHiddenExtension + d.allowOtherFileTypes = options.AllowOtherFileTypes + d.hideExtension = options.HideExtension + d.treatsFilePackagesAsDirectories = options.TreatsFilePackagesAsDirectories + d.message = options.Message + d.directory = options.Directory + d.filename = options.Filename + d.buttonText = options.ButtonText + d.filters = options.Filters +} + +func (d *SaveFileDialogStruct) SetTitle(title string) *SaveFileDialogStruct { + d.title = title + return d +} + +func (d *SaveFileDialogStruct) SetMessage(message string) *SaveFileDialogStruct { + d.message = message + return d +} + +func (d *SaveFileDialogStruct) SetDirectory(directory string) *SaveFileDialogStruct { + d.directory = directory + return d +} + +func (d *SaveFileDialogStruct) SetFilename(filename string) *SaveFileDialogStruct { + d.filename = filename + return d +} + +func (d *SaveFileDialogStruct) SetButtonText(text string) *SaveFileDialogStruct { + d.buttonText = text + return d +} + +func (d *SaveFileDialogStruct) CanCreateDirectories(canCreateDirectories bool) *SaveFileDialogStruct { + d.canCreateDirectories = canCreateDirectories + return d +} + +func (d *SaveFileDialogStruct) ShowHiddenFiles(showHiddenFiles bool) *SaveFileDialogStruct { + d.showHiddenFiles = showHiddenFiles + return d +} + +func (d *SaveFileDialogStruct) CanSelectHiddenExtension(canSelectHiddenExtension bool) *SaveFileDialogStruct { + d.canSelectHiddenExtension = canSelectHiddenExtension + return d +} + +func (d *SaveFileDialogStruct) AllowsOtherFileTypes(allowOtherFileTypes bool) *SaveFileDialogStruct { + d.allowOtherFileTypes = allowOtherFileTypes + return d +} + +func (d *SaveFileDialogStruct) HideExtension(hideExtension bool) *SaveFileDialogStruct { + d.hideExtension = hideExtension + return d +} + +func (d *SaveFileDialogStruct) TreatsFilePackagesAsDirectories(treats bool) *SaveFileDialogStruct { + d.treatsFilePackagesAsDirectories = treats + return d +} + +// AddFilter appends a file type filter to the dialog. +// +// dialog.AddFilter("Text files", "*.txt") +func (d *SaveFileDialogStruct) AddFilter(displayName, pattern string) *SaveFileDialogStruct { + d.filters = append(d.filters, FileFilter{DisplayName: displayName, Pattern: pattern}) + return d +} + +func (d *SaveFileDialogStruct) AttachToWindow(window *WebviewWindow) *SaveFileDialogStruct { + return d +} + +// PromptForSingleSelection shows the save dialog and returns the chosen path. +// Always returns ("", nil) in the stub. +// +// path, err := dialog.PromptForSingleSelection() +func (d *SaveFileDialogStruct) PromptForSingleSelection() (string, error) { + return "", nil +} + +// DialogManager exposes factory methods for all dialog types. +// +// manager.Info().SetMessage("Saved!").Show() +// path, _ := manager.OpenFile().PromptForSingleSelection() +type DialogManager struct{} + +// OpenFile creates a file-open dialog builder. +func (dm *DialogManager) OpenFile() *OpenFileDialogStruct { + return newOpenFileDialog() +} + +// OpenFileWithOptions creates a file-open dialog builder pre-populated from options. +func (dm *DialogManager) OpenFileWithOptions(options *OpenFileDialogOptions) *OpenFileDialogStruct { + result := newOpenFileDialog() + result.SetOptions(options) + return result +} + +// SaveFile creates a file-save dialog builder. +func (dm *DialogManager) SaveFile() *SaveFileDialogStruct { + return newSaveFileDialog() +} + +// SaveFileWithOptions creates a file-save dialog builder pre-populated from options. +func (dm *DialogManager) SaveFileWithOptions(options *SaveFileDialogOptions) *SaveFileDialogStruct { + result := newSaveFileDialog() + result.SetOptions(options) + return result +} + +// Info creates an information message dialog. +// +// manager.Info().SetMessage("Done").Show() +func (dm *DialogManager) Info() *MessageDialog { + return newMessageDialog(InfoDialogType) +} + +// Question creates a question message dialog. +// +// manager.Question().SetMessage("Continue?").Show() +func (dm *DialogManager) Question() *MessageDialog { + return newMessageDialog(QuestionDialogType) +} + +// Warning creates a warning message dialog. +// +// manager.Warning().SetMessage("Low disk space").Show() +func (dm *DialogManager) Warning() *MessageDialog { + return newMessageDialog(WarningDialogType) +} + +// Error creates an error message dialog. +// +// manager.Error().SetMessage("Write failed").Show() +func (dm *DialogManager) Error() *MessageDialog { + return newMessageDialog(ErrorDialogType) +} diff --git a/stubs/wails/pkg/application/environment.go b/stubs/wails/pkg/application/environment.go new file mode 100644 index 00000000..fe9f982e --- /dev/null +++ b/stubs/wails/pkg/application/environment.go @@ -0,0 +1,63 @@ +package application + +// EnvironmentInfo holds runtime information about the host OS and build. +// +// info := manager.Info() +// fmt.Println(info.OS, info.Arch) +type EnvironmentInfo struct { + OS string + Arch string + Debug bool + PlatformInfo map[string]any +} + +// EnvironmentManager provides queries about the host OS environment. +// +// if manager.IsDarkMode() { applyDarkTheme() } +// accent := manager.GetAccentColor() +type EnvironmentManager struct { + darkMode bool + accentColor string +} + +// IsDarkMode returns true when the OS is using a dark colour scheme. +// +// if manager.IsDarkMode() { applyDarkTheme() } +func (em *EnvironmentManager) IsDarkMode() bool { + return em.darkMode +} + +// GetAccentColor returns the OS accent colour as an rgb() string. +// +// colour := manager.GetAccentColor() // e.g. "rgb(0,122,255)" +func (em *EnvironmentManager) GetAccentColor() string { + if em.accentColor == "" { + return "rgb(0,122,255)" + } + return em.accentColor +} + +// Info returns a snapshot of OS and build environment information. +// +// info := manager.Info() +func (em *EnvironmentManager) Info() EnvironmentInfo { + return EnvironmentInfo{ + PlatformInfo: make(map[string]any), + } +} + +// OpenFileManager opens the file manager at the given path, optionally selecting the file. +// No-op in the stub. +// +// err := manager.OpenFileManager("/home/user/docs", false) +func (em *EnvironmentManager) OpenFileManager(path string, selectFile bool) error { + return nil +} + +// HasFocusFollowsMouse reports whether the Linux desktop is configured for +// focus-follows-mouse. Always returns false in the stub. +// +// if manager.HasFocusFollowsMouse() { adjustMouseBehaviour() } +func (em *EnvironmentManager) HasFocusFollowsMouse() bool { + return false +} diff --git a/stubs/wails/pkg/application/events.go b/stubs/wails/pkg/application/events.go new file mode 100644 index 00000000..184cac00 --- /dev/null +++ b/stubs/wails/pkg/application/events.go @@ -0,0 +1,297 @@ +package application + +import ( + "sync" + "sync/atomic" + + "github.com/wailsapp/wails/v3/pkg/events" +) + +// ApplicationEventContext carries structured data for an ApplicationEvent. +// +// files := event.Context().OpenedFiles() +// dark := event.Context().IsDarkMode() +type ApplicationEventContext struct { + data map[string]any +} + +// OpenedFiles returns the list of files provided via the event context, or nil. +// +// for _, path := range event.Context().OpenedFiles() { open(path) } +func (c *ApplicationEventContext) OpenedFiles() []string { + if c.data == nil { + return nil + } + files, ok := c.data["openedFiles"] + if !ok { + return nil + } + result, ok := files.([]string) + if !ok { + return nil + } + return result +} + +// IsDarkMode returns true when the event context reports dark mode active. +// +// if event.Context().IsDarkMode() { applyDark() } +func (c *ApplicationEventContext) IsDarkMode() bool { + return c.getBool("isDarkMode") +} + +// HasVisibleWindows returns true when the event context reports at least one visible window. +// +// if event.Context().HasVisibleWindows() { ... } +func (c *ApplicationEventContext) HasVisibleWindows() bool { + return c.getBool("hasVisibleWindows") +} + +// Filename returns the filename value from the event context, or "". +// +// path := event.Context().Filename() +func (c *ApplicationEventContext) Filename() string { + if c.data == nil { + return "" + } + v, ok := c.data["filename"] + if !ok { + return "" + } + result, ok := v.(string) + if !ok { + return "" + } + return result +} + +// URL returns the URL value from the event context, or "". +// +// url := event.Context().URL() +func (c *ApplicationEventContext) URL() string { + if c.data == nil { + return "" + } + v, ok := c.data["url"] + if !ok { + return "" + } + result, ok := v.(string) + if !ok { + return "" + } + return result +} + +func (c *ApplicationEventContext) getBool(key string) bool { + if c.data == nil { + return false + } + v, ok := c.data[key] + if !ok { + return false + } + result, ok := v.(bool) + if !ok { + return false + } + return result +} + +// ApplicationEvent is the event object delivered to OnApplicationEvent listeners. +// +// em.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { +// dark := e.Context().IsDarkMode() +// }) +type ApplicationEvent struct { + Id uint + ctx *ApplicationEventContext + cancelled atomic.Bool +} + +// Context returns the ApplicationEventContext attached to the event. +func (e *ApplicationEvent) Context() *ApplicationEventContext { + if e.ctx == nil { + e.ctx = &ApplicationEventContext{data: make(map[string]any)} + } + return e.ctx +} + +// Cancel marks the event as cancelled, preventing further listener dispatch. +func (e *ApplicationEvent) Cancel() { + e.cancelled.Store(true) +} + +// IsCancelled reports whether the event has been cancelled. +func (e *ApplicationEvent) IsCancelled() bool { + return e.cancelled.Load() +} + +// customEventListener is an internal listener registration. +type customEventListener struct { + callback func(*CustomEvent) + counter int // -1 = unlimited +} + +// applicationEventListener is an internal listener registration. +type applicationEventListener struct { + callback func(*ApplicationEvent) +} + +// EventManager manages custom and application-level event subscriptions. +// +// em.Emit("build:done", result) +// cancel := em.On("build:done", func(e *application.CustomEvent) { ... }) +// em.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { ... }) +type EventManager struct { + mu sync.RWMutex + + customListeners map[string][]*customEventListener + applicationListeners map[uint][]*applicationEventListener +} + +func (em *EventManager) ensureCustomListeners() { + if em.customListeners == nil { + em.customListeners = make(map[string][]*customEventListener) + } +} + +func (em *EventManager) ensureApplicationListeners() { + if em.applicationListeners == nil { + em.applicationListeners = make(map[uint][]*applicationEventListener) + } +} + +// Emit emits a custom event by name with optional data arguments. +// Returns true if the event was cancelled by a listener. +// +// cancelled := em.Emit("build:done", buildResult) +func (em *EventManager) Emit(name string, data ...any) bool { + event := &CustomEvent{Name: name} + if len(data) == 1 { + event.Data = data[0] + } else if len(data) > 1 { + event.Data = data + } + return em.EmitEvent(event) +} + +// EmitEvent emits a pre-constructed CustomEvent. +// Returns true if the event was cancelled by a listener. +// +// cancelled := em.EmitEvent(&application.CustomEvent{Name: "ping"}) +func (em *EventManager) EmitEvent(event *CustomEvent) bool { + em.mu.RLock() + listeners := append([]*customEventListener(nil), em.customListeners[event.Name]...) + em.mu.RUnlock() + + toRemove := []int{} + for index, listener := range listeners { + if event.IsCancelled() { + break + } + listener.callback(event) + if listener.counter > 0 { + listener.counter-- + if listener.counter == 0 { + toRemove = append(toRemove, index) + } + } + } + + if len(toRemove) > 0 { + em.mu.Lock() + remaining := em.customListeners[event.Name] + for _, index := range toRemove { + if index < len(remaining) { + remaining = append(remaining[:index], remaining[index+1:]...) + } + } + em.customListeners[event.Name] = remaining + em.mu.Unlock() + } + + return event.IsCancelled() +} + +// On registers a persistent listener for the named custom event. +// Returns a cancel function that deregisters the listener. +// +// cancel := em.On("build:done", func(e *application.CustomEvent) { ... }) +// defer cancel() +func (em *EventManager) On(name string, callback func(event *CustomEvent)) func() { + em.mu.Lock() + em.ensureCustomListeners() + listener := &customEventListener{callback: callback, counter: -1} + em.customListeners[name] = append(em.customListeners[name], listener) + em.mu.Unlock() + + return func() { + em.mu.Lock() + defer em.mu.Unlock() + slice := em.customListeners[name] + for i, l := range slice { + if l == listener { + em.customListeners[name] = append(slice[:i], slice[i+1:]...) + return + } + } + } +} + +// Off removes all listeners for the named custom event. +// +// em.Off("build:done") +func (em *EventManager) Off(name string) { + em.mu.Lock() + delete(em.customListeners, name) + em.mu.Unlock() +} + +// OnMultiple registers a listener that fires at most counter times, then auto-deregisters. +// +// em.OnMultiple("ping", func(e *application.CustomEvent) { ... }, 3) +func (em *EventManager) OnMultiple(name string, callback func(event *CustomEvent), counter int) { + em.mu.Lock() + em.ensureCustomListeners() + em.customListeners[name] = append(em.customListeners[name], &customEventListener{ + callback: callback, + counter: counter, + }) + em.mu.Unlock() +} + +// Reset removes all custom event listeners. +// +// em.Reset() +func (em *EventManager) Reset() { + em.mu.Lock() + em.customListeners = make(map[string][]*customEventListener) + em.mu.Unlock() +} + +// OnApplicationEvent registers a listener for a platform application event. +// Returns a cancel function that deregisters the listener. +// +// cancel := em.OnApplicationEvent(events.Common.ThemeChanged, func(e *application.ApplicationEvent) { ... }) +// defer cancel() +func (em *EventManager) OnApplicationEvent(eventType events.ApplicationEventType, callback func(event *ApplicationEvent)) func() { + eventID := uint(eventType) + em.mu.Lock() + em.ensureApplicationListeners() + listener := &applicationEventListener{callback: callback} + em.applicationListeners[eventID] = append(em.applicationListeners[eventID], listener) + em.mu.Unlock() + + return func() { + em.mu.Lock() + defer em.mu.Unlock() + slice := em.applicationListeners[eventID] + for i, l := range slice { + if l == listener { + em.applicationListeners[eventID] = append(slice[:i], slice[i+1:]...) + return + } + } + } +} diff --git a/stubs/wails/pkg/application/keybinding.go b/stubs/wails/pkg/application/keybinding.go new file mode 100644 index 00000000..944539d3 --- /dev/null +++ b/stubs/wails/pkg/application/keybinding.go @@ -0,0 +1,69 @@ +package application + +import "sync" + +// KeyBinding pairs an accelerator string with its callback. +// binding := &KeyBinding{Accelerator: "Ctrl+K", Callback: fn} +type KeyBinding struct { + Accelerator string + Callback func(window Window) +} + +// KeyBindingManager holds all registered global key bindings in memory. +// manager.Add("Ctrl+K", fn) — manager.Remove("Ctrl+K") — manager.GetAll() +type KeyBindingManager struct { + mu sync.RWMutex + bindings map[string]func(window Window) +} + +// NewKeyBindingManager constructs an empty KeyBindingManager. +// manager := NewKeyBindingManager() +func NewKeyBindingManager() *KeyBindingManager { + return &KeyBindingManager{ + bindings: make(map[string]func(window Window)), + } +} + +// Add registers a callback for the given accelerator string. +// manager.Add("Ctrl+Shift+P", func(w Window) { w.Focus() }) +func (m *KeyBindingManager) Add(accelerator string, callback func(window Window)) { + m.mu.Lock() + m.bindings[accelerator] = callback + m.mu.Unlock() +} + +// Remove deletes the binding for the given accelerator. +// manager.Remove("Ctrl+Shift+P") +func (m *KeyBindingManager) Remove(accelerator string) { + m.mu.Lock() + delete(m.bindings, accelerator) + m.mu.Unlock() +} + +// Process fires the callback for accelerator if registered, returning true when handled. +// handled := manager.Process("Ctrl+K", window) +func (m *KeyBindingManager) Process(accelerator string, window Window) bool { + m.mu.RLock() + callback, exists := m.bindings[accelerator] + m.mu.RUnlock() + if exists && callback != nil { + callback(window) + return true + } + return false +} + +// GetAll returns a snapshot of all registered bindings. +// for _, b := range manager.GetAll() { fmt.Println(b.Accelerator) } +func (m *KeyBindingManager) GetAll() []*KeyBinding { + m.mu.RLock() + defer m.mu.RUnlock() + result := make([]*KeyBinding, 0, len(m.bindings)) + for accelerator, callback := range m.bindings { + result = append(result, &KeyBinding{ + Accelerator: accelerator, + Callback: callback, + }) + } + return result +} diff --git a/stubs/wails/pkg/application/menuitem.go b/stubs/wails/pkg/application/menuitem.go new file mode 100644 index 00000000..74d55fb4 --- /dev/null +++ b/stubs/wails/pkg/application/menuitem.go @@ -0,0 +1,379 @@ +package application + +import "sync/atomic" + +// Role identifies a platform-defined menu role. +// +// item := NewRole(Quit) // produces the platform quit item +type Role uint + +const ( + NoRole Role = iota + AppMenu Role = iota + EditMenu Role = iota + ViewMenu Role = iota + WindowMenu Role = iota + ServicesMenu Role = iota + HelpMenu Role = iota + SpeechMenu Role = iota + FileMenu Role = iota + + Hide Role = iota + HideOthers Role = iota + ShowAll Role = iota + BringAllToFront Role = iota + UnHide Role = iota + About Role = iota + Undo Role = iota + Redo Role = iota + Cut Role = iota + Copy Role = iota + Paste Role = iota + PasteAndMatchStyle Role = iota + SelectAll Role = iota + Delete Role = iota + Quit Role = iota + CloseWindow Role = iota + Reload Role = iota + ForceReload Role = iota + OpenDevTools Role = iota + ResetZoom Role = iota + ZoomIn Role = iota + ZoomOut Role = iota + ToggleFullscreen Role = iota + Minimise Role = iota + Zoom Role = iota + FullScreen Role = iota + NewFile Role = iota + Open Role = iota + Save Role = iota + SaveAs Role = iota + StartSpeaking Role = iota + StopSpeaking Role = iota + Revert Role = iota + Print Role = iota + PageLayout Role = iota + Find Role = iota + FindAndReplace Role = iota + FindNext Role = iota + FindPrevious Role = iota + Front Role = iota + Help Role = iota +) + +// menuItemType classifies what kind of item a MenuItem is. +type menuItemType int + +const ( + menuItemTypeText menuItemType = iota + menuItemTypeSeparator menuItemType = iota + menuItemTypeCheckbox menuItemType = iota + menuItemTypeRadio menuItemType = iota + menuItemTypeSubmenu menuItemType = iota +) + +var globalMenuItemID uintptr + +// MenuItem is a node in a menu tree. +// +// item := NewMenuItem("Preferences"). +// SetAccelerator("CmdOrCtrl+,"). +// OnClick(func(ctx *Context) { openPrefs() }) +type MenuItem struct { + id uint + label string + tooltip string + disabled bool + checked bool + hidden bool + bitmap []byte + submenu *Menu + callback func(*Context) + itemType menuItemType + acceleratorStr string + role Role + contextMenuData *ContextMenuData + + radioGroupMembers []*MenuItem +} + +func nextMenuItemID() uint { + return uint(atomic.AddUintptr(&globalMenuItemID, 1)) +} + +// NewMenuItem creates a standard clickable menu item with the given label. +// +// item := NewMenuItem("Save").OnClick(func(ctx *Context) { save() }) +func NewMenuItem(label string) *MenuItem { + return &MenuItem{ + id: nextMenuItemID(), + label: label, + itemType: menuItemTypeText, + disabled: false, + } +} + +// NewMenuItemSeparator creates a horizontal separator. +// +// menu.AppendItem(NewMenuItemSeparator()) +func NewMenuItemSeparator() *MenuItem { + return &MenuItem{ + id: nextMenuItemID(), + itemType: menuItemTypeSeparator, + } +} + +// NewMenuItemCheckbox creates a checkable menu item. +// +// item := NewMenuItemCheckbox("Show Toolbar", true) +func NewMenuItemCheckbox(label string, checked bool) *MenuItem { + return &MenuItem{ + id: nextMenuItemID(), + label: label, + checked: checked, + itemType: menuItemTypeCheckbox, + } +} + +// NewMenuItemRadio creates a radio-group menu item. +// +// light := NewMenuItemRadio("Light Theme", true) +func NewMenuItemRadio(label string, checked bool) *MenuItem { + return &MenuItem{ + id: nextMenuItemID(), + label: label, + checked: checked, + itemType: menuItemTypeRadio, + } +} + +// NewSubMenuItem creates an item that reveals a child menu on hover. +// +// sub := NewSubMenuItem("Recent Files") +// sub.GetSubmenu().Add("report.pdf") +func NewSubMenuItem(label string) *MenuItem { + return &MenuItem{ + id: nextMenuItemID(), + label: label, + itemType: menuItemTypeSubmenu, + submenu: &Menu{label: label}, + } +} + +// NewRole creates a platform-managed menu item for the given role. +// +// menu.AppendItem(NewRole(Quit)) +func NewRole(role Role) *MenuItem { + item := &MenuItem{ + id: nextMenuItemID(), + label: roleLabel(role), + itemType: menuItemTypeText, + role: role, + } + return item +} + +func roleLabel(role Role) string { + switch role { + case AppMenu: + return "Application" + case EditMenu: + return "Edit" + case ViewMenu: + return "View" + case WindowMenu: + return "Window" + case ServicesMenu: + return "Services" + case HelpMenu: + return "Help" + case SpeechMenu: + return "Speech" + case FileMenu: + return "File" + case Hide: + return "Hide" + case HideOthers: + return "Hide Others" + case ShowAll: + return "Show All" + case BringAllToFront: + return "Bring All to Front" + case UnHide: + return "Unhide" + case About: + return "About" + case Undo: + return "Undo" + case Redo: + return "Redo" + case Cut: + return "Cut" + case Copy: + return "Copy" + case Paste: + return "Paste" + case PasteAndMatchStyle: + return "Paste and Match Style" + case SelectAll: + return "Select All" + case Delete: + return "Delete" + case Quit: + return "Quit" + case CloseWindow: + return "Close Window" + case Reload: + return "Reload" + case ForceReload: + return "Force Reload" + case OpenDevTools: + return "Open Dev Tools" + case ResetZoom: + return "Reset Zoom" + case ZoomIn: + return "Zoom In" + case ZoomOut: + return "Zoom Out" + case ToggleFullscreen: + return "Toggle Fullscreen" + case Minimise: + return "Minimise" + case Zoom: + return "Zoom" + case FullScreen: + return "Fullscreen" + case NewFile: + return "New" + case Open: + return "Open" + case Save: + return "Save" + case SaveAs: + return "Save As" + case StartSpeaking: + return "Start Speaking" + case StopSpeaking: + return "Stop Speaking" + case Revert: + return "Revert" + case Print: + return "Print" + case PageLayout: + return "Page Layout" + case Find: + return "Find" + case FindAndReplace: + return "Find and Replace" + case FindNext: + return "Find Next" + case FindPrevious: + return "Find Previous" + case Front: + return "Bring All to Front" + case Help: + return "Help" + default: + return "" + } +} + +// Fluent setters — all return *MenuItem for chaining. + +// SetLabel updates the visible label. +func (m *MenuItem) SetLabel(s string) *MenuItem { m.label = s; return m } + +// SetAccelerator sets the keyboard shortcut string (e.g. "CmdOrCtrl+S"). +func (m *MenuItem) SetAccelerator(shortcut string) *MenuItem { + m.acceleratorStr = shortcut + return m +} + +// GetAccelerator returns the raw accelerator string. +func (m *MenuItem) GetAccelerator() string { return m.acceleratorStr } + +// RemoveAccelerator clears the keyboard shortcut. +func (m *MenuItem) RemoveAccelerator() { m.acceleratorStr = "" } + +// SetTooltip sets the hover tooltip. +func (m *MenuItem) SetTooltip(s string) *MenuItem { m.tooltip = s; return m } + +// SetRole assigns a platform role to the item. +func (m *MenuItem) SetRole(role Role) *MenuItem { m.role = role; return m } + +// SetEnabled enables or disables the item. +func (m *MenuItem) SetEnabled(enabled bool) *MenuItem { m.disabled = !enabled; return m } + +// SetBitmap sets a raw-bytes icon for the item (Windows). +func (m *MenuItem) SetBitmap(bitmap []byte) *MenuItem { + m.bitmap = append([]byte(nil), bitmap...) + return m +} + +// SetChecked sets the checked state for checkbox/radio items. +func (m *MenuItem) SetChecked(checked bool) *MenuItem { m.checked = checked; return m } + +// SetHidden hides or shows the item without removing it. +func (m *MenuItem) SetHidden(hidden bool) *MenuItem { m.hidden = hidden; return m } + +// OnClick registers the callback invoked when the item is activated. +func (m *MenuItem) OnClick(f func(*Context)) *MenuItem { m.callback = f; return m } + +// Getters + +// Label returns the item's display label. +func (m *MenuItem) Label() string { return m.label } + +// Tooltip returns the hover tooltip. +func (m *MenuItem) Tooltip() string { return m.tooltip } + +// Enabled reports whether the item is interactive. +func (m *MenuItem) Enabled() bool { return !m.disabled } + +// Checked reports whether the item is checked. +func (m *MenuItem) Checked() bool { return m.checked } + +// Hidden reports whether the item is hidden. +func (m *MenuItem) Hidden() bool { return m.hidden } + +// IsSeparator reports whether this is a separator item. +func (m *MenuItem) IsSeparator() bool { return m.itemType == menuItemTypeSeparator } + +// IsSubmenu reports whether this item contains a child menu. +func (m *MenuItem) IsSubmenu() bool { return m.itemType == menuItemTypeSubmenu } + +// IsCheckbox reports whether this is a checkbox item. +func (m *MenuItem) IsCheckbox() bool { return m.itemType == menuItemTypeCheckbox } + +// IsRadio reports whether this is a radio item. +func (m *MenuItem) IsRadio() bool { return m.itemType == menuItemTypeRadio } + +// GetSubmenu returns the submenu, or nil if this is not a submenu item. +func (m *MenuItem) GetSubmenu() *Menu { return m.submenu } + +// Clone returns a shallow copy of the MenuItem. +func (m *MenuItem) Clone() *MenuItem { + cloned := *m + if m.submenu != nil { + cloned.submenu = m.submenu.Clone() + } + if m.bitmap != nil { + cloned.bitmap = append([]byte(nil), m.bitmap...) + } + if m.contextMenuData != nil { + cloned.contextMenuData = m.contextMenuData.clone() + } + cloned.radioGroupMembers = nil + return &cloned +} + +// Destroy frees resources held by the item and its submenu. +func (m *MenuItem) Destroy() { + if m.submenu != nil { + m.submenu.Destroy() + m.submenu = nil + } + m.callback = nil + m.radioGroupMembers = nil + m.contextMenuData = nil +} diff --git a/stubs/wails/pkg/application/screen.go b/stubs/wails/pkg/application/screen.go new file mode 100644 index 00000000..142abd43 --- /dev/null +++ b/stubs/wails/pkg/application/screen.go @@ -0,0 +1,202 @@ +package application + +import ( + "math" + "sync" +) + +// Rect describes an axis-aligned rectangle. +// r := Rect{X: 0, Y: 0, Width: 1920, Height: 1080} +type Rect struct { + X int + Y int + Width int + Height int +} + +// Point is a 2D integer coordinate. +// p := Point{X: 100, Y: 200} +type Point struct { + X int + Y int +} + +// Size holds a width/height pair. +// s := Size{Width: 1920, Height: 1080} +type Size struct { + Width int + Height int +} + +// Origin returns the top-left corner of the rect as a Point. +// origin := r.Origin() +func (r Rect) Origin() Point { return Point{X: r.X, Y: r.Y} } + +// Corner returns the exclusive bottom-right corner of the rect. +// corner := r.Corner() +func (r Rect) Corner() Point { return Point{X: r.X + r.Width, Y: r.Y + r.Height} } + +// InsideCorner returns the last pixel inside the rect. +// inside := r.InsideCorner() +func (r Rect) InsideCorner() Point { return Point{X: r.X + r.Width - 1, Y: r.Y + r.Height - 1} } + +// RectSize returns the size of the rect. +// s := r.RectSize() +func (r Rect) RectSize() Size { return Size{Width: r.Width, Height: r.Height} } + +// IsEmpty reports whether the rect has no area. +// if r.IsEmpty() { return } +func (r Rect) IsEmpty() bool { return r.Width <= 0 || r.Height <= 0 } + +// Contains reports whether the point lies inside the rect. +// if r.Contains(Point{X: 100, Y: 200}) { ... } +func (r Rect) Contains(point Point) bool { + return point.X >= r.X && point.X < r.X+r.Width && + point.Y >= r.Y && point.Y < r.Y+r.Height +} + +// Intersect returns the overlapping rectangle of r and other. +// overlap := r.Intersect(otherRect) +func (r Rect) Intersect(other Rect) Rect { + if r.IsEmpty() || other.IsEmpty() { + return Rect{} + } + maxLeft := max(r.X, other.X) + maxTop := max(r.Y, other.Y) + minRight := min(r.X+r.Width, other.X+other.Width) + minBottom := min(r.Y+r.Height, other.Y+other.Height) + if minRight > maxLeft && minBottom > maxTop { + return Rect{X: maxLeft, Y: maxTop, Width: minRight - maxLeft, Height: minBottom - maxTop} + } + return Rect{} +} + +// Screen describes a physical display. +// primary := manager.GetPrimary() +type Screen struct { + ID string + Name string + ScaleFactor float32 + X int + Y int + Size Size + Bounds Rect + PhysicalBounds Rect + WorkArea Rect + PhysicalWorkArea Rect + IsPrimary bool + Rotation float32 +} + +// Origin returns the logical origin of the screen. +// origin := screen.Origin() +func (s Screen) Origin() Point { return Point{X: s.X, Y: s.Y} } + +// scale converts a value between physical and DIP coordinates for this screen. +func (s Screen) scale(value int, toDIP bool) int { + if toDIP { + return int(math.Ceil(float64(value) / float64(s.ScaleFactor))) + } + return int(math.Floor(float64(value) * float64(s.ScaleFactor))) +} + +// ScreenManager holds the list of known screens in memory. +// screens := manager.GetAll() +type ScreenManager struct { + mu sync.RWMutex + screens []*Screen + primaryScreen *Screen +} + +// NewScreenManager constructs an empty ScreenManager. +// manager := NewScreenManager() +func NewScreenManager() *ScreenManager { + return &ScreenManager{} +} + +// SetScreens replaces the tracked screen list; the first screen with IsPrimary == true becomes primary. +// manager.SetScreens([]*Screen{primary, secondary}) +func (m *ScreenManager) SetScreens(screens []*Screen) { + m.mu.Lock() + defer m.mu.Unlock() + m.screens = screens + m.primaryScreen = nil + for _, screen := range screens { + if screen.IsPrimary { + m.primaryScreen = screen + break + } + } +} + +// GetAll returns all tracked screens. +// for _, s := range manager.GetAll() { fmt.Println(s.Name) } +func (m *ScreenManager) GetAll() []*Screen { + m.mu.RLock() + defer m.mu.RUnlock() + result := make([]*Screen, len(m.screens)) + copy(result, m.screens) + return result +} + +// GetPrimary returns the primary screen, or nil if none is set. +// primary := manager.GetPrimary() +func (m *ScreenManager) GetPrimary() *Screen { + m.mu.RLock() + defer m.mu.RUnlock() + return m.primaryScreen +} + +// GetCurrent returns the screen nearest to the given DIP point. +// current := manager.GetCurrent(Point{X: 500, Y: 300}) +func (m *ScreenManager) GetCurrent(dipPoint Point) *Screen { + m.mu.RLock() + defer m.mu.RUnlock() + for _, screen := range m.screens { + if screen.Bounds.Contains(dipPoint) { + return screen + } + } + return m.primaryScreen +} + +// DipToPhysicalPoint converts a DIP point to physical pixels using the nearest screen. +// physical := manager.DipToPhysicalPoint(Point{X: 100, Y: 200}) +func (m *ScreenManager) DipToPhysicalPoint(dipPoint Point) Point { + screen := m.GetCurrent(dipPoint) + if screen == nil { + return dipPoint + } + relativeX := dipPoint.X - screen.Bounds.X + relativeY := dipPoint.Y - screen.Bounds.Y + return Point{ + X: screen.PhysicalBounds.X + screen.scale(relativeX, false), + Y: screen.PhysicalBounds.Y + screen.scale(relativeY, false), + } +} + +// PhysicalToDipPoint converts physical pixel coordinates to DIP using the nearest screen. +// dip := manager.PhysicalToDipPoint(Point{X: 200, Y: 400}) +func (m *ScreenManager) PhysicalToDipPoint(physicalPoint Point) Point { + m.mu.RLock() + var nearest *Screen + for _, screen := range m.screens { + if screen.PhysicalBounds.Contains(physicalPoint) { + nearest = screen + break + } + } + if nearest == nil { + nearest = m.primaryScreen + } + m.mu.RUnlock() + if nearest == nil { + return physicalPoint + } + relativeX := physicalPoint.X - nearest.PhysicalBounds.X + relativeY := physicalPoint.Y - nearest.PhysicalBounds.Y + return Point{ + X: nearest.Bounds.X + nearest.scale(relativeX, true), + Y: nearest.Bounds.Y + nearest.scale(relativeY, true), + } +} diff --git a/stubs/wails/pkg/application/services.go b/stubs/wails/pkg/application/services.go new file mode 100644 index 00000000..e3546704 --- /dev/null +++ b/stubs/wails/pkg/application/services.go @@ -0,0 +1,76 @@ +package application + +import "context" + +// Service wraps a bound type instance for registration with the application. +// svc := NewService(&MyService{}) +type Service struct { + instance any + options ServiceOptions +} + +// ServiceOptions provides optional configuration for a Service. +// opts := ServiceOptions{Name: "my-service", Route: "/api/my"} +type ServiceOptions struct { + // Name overrides the service name used in logging and debugging. + // Defaults to the value from ServiceName interface, or the type name. + Name string + + // Route mounts the service on the internal asset server at this path + // when the instance implements http.Handler. + Route string + + // MarshalError serialises errors returned by service methods to JSON. + // Return nil to fall back to the globally configured error handler. + MarshalError func(error) []byte +} + +// DefaultServiceOptions is the default service options used by NewService. +var DefaultServiceOptions = ServiceOptions{} + +// NewService wraps instance as a Service. +// svc := NewService(&Calculator{}) +func NewService[T any](instance *T) Service { + return Service{instance: instance, options: DefaultServiceOptions} +} + +// NewServiceWithOptions wraps instance as a Service with explicit options. +// svc := NewServiceWithOptions(&Calculator{}, ServiceOptions{Name: "calculator"}) +func NewServiceWithOptions[T any](instance *T, options ServiceOptions) Service { + service := NewService(instance) + service.options = options + return service +} + +// Instance returns the underlying pointer passed to NewService. +// raw := svc.Instance().(*Calculator) +func (s Service) Instance() any { + return s.instance +} + +// Options returns the ServiceOptions for this service. +// opts := svc.Options() +func (s Service) Options() ServiceOptions { + return s.options +} + +// ServiceName is an optional interface that service instances may implement +// to provide a human-readable name for logging and debugging. +// func (s *MyService) ServiceName() string { return "my-service" } +type ServiceName interface { + ServiceName() string +} + +// ServiceStartup is an optional interface for services that need initialisation. +// Called in registration order during application startup. +// func (s *MyService) ServiceStartup(ctx context.Context, opts ServiceOptions) error { ... } +type ServiceStartup interface { + ServiceStartup(ctx context.Context, options ServiceOptions) error +} + +// ServiceShutdown is an optional interface for services that need cleanup. +// Called in reverse registration order during application shutdown. +// func (s *MyService) ServiceShutdown() error { ... } +type ServiceShutdown interface { + ServiceShutdown() error +} diff --git a/stubs/wails/pkg/application/webview_window_options.go b/stubs/wails/pkg/application/webview_window_options.go new file mode 100644 index 00000000..eb769736 --- /dev/null +++ b/stubs/wails/pkg/application/webview_window_options.go @@ -0,0 +1,471 @@ +package application + +import "github.com/wailsapp/wails/v3/pkg/events" + +// WindowState represents the starting visual state of a window. +type WindowState int + +const ( + WindowStateNormal WindowState = iota + WindowStateMinimised WindowState = iota + WindowStateMaximised WindowState = iota + WindowStateFullscreen WindowState = iota +) + +// WindowStartPosition determines how the initial X/Y coordinates are interpreted. +type WindowStartPosition int + +const ( + // WindowCentered places the window in the centre of the screen on first show. + WindowCentered WindowStartPosition = 0 + // WindowXY places the window at the explicit X/Y coordinates. + WindowXY WindowStartPosition = 1 +) + +// BackgroundType controls window transparency. +type BackgroundType int + +const ( + BackgroundTypeSolid BackgroundType = iota + BackgroundTypeTransparent BackgroundType = iota + BackgroundTypeTranslucent BackgroundType = iota +) + +// WebviewWindowOptions holds all configuration for a webview window. +// +// opts := WebviewWindowOptions{ +// Name: "main", +// Title: "My App", +// Width: 1280, +// Height: 800, +// Mac: MacWindow{TitleBar: MacTitleBarHiddenInset}, +// } +type WebviewWindowOptions struct { + // Name is a unique identifier for the window. + Name string + // Title is shown in the title bar. + Title string + // Width is the initial width in logical pixels. + Width int + // Height is the initial height in logical pixels. + Height int + // AlwaysOnTop makes the window float above others. + AlwaysOnTop bool + // URL is the URL to load on creation. + URL string + // HTML is inline HTML to load (alternative to URL). + HTML string + // JS is inline JavaScript to inject. + JS string + // CSS is inline CSS to inject. + CSS string + // DisableResize prevents the user from resizing the window. + DisableResize bool + // Frameless removes the OS window frame. + Frameless bool + // MinWidth is the minimum allowed width. + MinWidth int + // MinHeight is the minimum allowed height. + MinHeight int + // MaxWidth is the maximum allowed width (0 = unlimited). + MaxWidth int + // MaxHeight is the maximum allowed height (0 = unlimited). + MaxHeight int + // StartState sets the visual state when first shown. + StartState WindowState + // BackgroundType controls transparency. + BackgroundType BackgroundType + // BackgroundColour is the solid background fill colour. + BackgroundColour RGBA + // InitialPosition controls how X/Y are interpreted. + InitialPosition WindowStartPosition + // X is the initial horizontal position. + X int + // Y is the initial vertical position. + Y int + // Hidden creates the window without showing it. + Hidden bool + // Zoom sets the initial zoom magnification (0 = default = 1.0). + Zoom float64 + // ZoomControlEnabled allows the user to change zoom. + ZoomControlEnabled bool + // EnableFileDrop enables drag-and-drop of files onto the window. + EnableFileDrop bool + // OpenInspectorOnStartup opens the web inspector when first shown. + OpenInspectorOnStartup bool + // DevToolsEnabled exposes the developer tools (default true in debug builds). + DevToolsEnabled bool + // DefaultContextMenuDisabled disables the built-in right-click menu. + DefaultContextMenuDisabled bool + // KeyBindings is a map of accelerator strings to window callbacks. + KeyBindings map[string]func(window Window) + // IgnoreMouseEvents passes all mouse events through (Windows + macOS only). + IgnoreMouseEvents bool + // ContentProtectionEnabled prevents screen capture (Windows + macOS only). + ContentProtectionEnabled bool + // HideOnFocusLost hides the window when it loses focus. + HideOnFocusLost bool + // HideOnEscape hides the window when Escape is pressed. + HideOnEscape bool + // UseApplicationMenu uses the application-level menu for this window. + UseApplicationMenu bool + // MinimiseButtonState controls the minimise button state. + MinimiseButtonState ButtonState + // MaximiseButtonState controls the maximise/zoom button state. + MaximiseButtonState ButtonState + // CloseButtonState controls the close button state. + CloseButtonState ButtonState + // Mac contains macOS-specific window options. + Mac MacWindow + // Windows contains Windows-specific window options. + Windows WindowsWindow + // Linux contains Linux-specific window options. + Linux LinuxWindow +} + +// ------------------------- +// macOS-specific types +// ------------------------- + +// MacBackdrop is the backdrop material for a macOS window. +type MacBackdrop int + +const ( + // MacBackdropNormal uses an opaque background. + MacBackdropNormal MacBackdrop = iota + // MacBackdropTransparent shows the desktop behind the window. + MacBackdropTransparent MacBackdrop = iota + // MacBackdropTranslucent applies a frosted-glass vibrancy effect. + MacBackdropTranslucent MacBackdrop = iota + // MacBackdropLiquidGlass uses the Apple Liquid Glass effect (macOS 15+). + MacBackdropLiquidGlass MacBackdrop = iota +) + +// MacToolbarStyle controls toolbar layout relative to the title bar. +type MacToolbarStyle int + +const ( + MacToolbarStyleAutomatic MacToolbarStyle = iota + MacToolbarStyleExpanded MacToolbarStyle = iota + MacToolbarStylePreference MacToolbarStyle = iota + MacToolbarStyleUnified MacToolbarStyle = iota + MacToolbarStyleUnifiedCompact MacToolbarStyle = iota +) + +// MacLiquidGlassStyle defines the tint of the Liquid Glass effect. +type MacLiquidGlassStyle int + +const ( + LiquidGlassStyleAutomatic MacLiquidGlassStyle = iota + LiquidGlassStyleLight MacLiquidGlassStyle = iota + LiquidGlassStyleDark MacLiquidGlassStyle = iota + LiquidGlassStyleVibrant MacLiquidGlassStyle = iota +) + +// NSVisualEffectMaterial maps to the NSVisualEffectMaterial macOS enum. +type NSVisualEffectMaterial int + +const ( + NSVisualEffectMaterialAppearanceBased NSVisualEffectMaterial = 0 + NSVisualEffectMaterialLight NSVisualEffectMaterial = 1 + NSVisualEffectMaterialDark NSVisualEffectMaterial = 2 + NSVisualEffectMaterialTitlebar NSVisualEffectMaterial = 3 + NSVisualEffectMaterialSelection NSVisualEffectMaterial = 4 + NSVisualEffectMaterialMenu NSVisualEffectMaterial = 5 + NSVisualEffectMaterialPopover NSVisualEffectMaterial = 6 + NSVisualEffectMaterialSidebar NSVisualEffectMaterial = 7 + NSVisualEffectMaterialHeaderView NSVisualEffectMaterial = 10 + NSVisualEffectMaterialSheet NSVisualEffectMaterial = 11 + NSVisualEffectMaterialWindowBackground NSVisualEffectMaterial = 12 + NSVisualEffectMaterialHUDWindow NSVisualEffectMaterial = 13 + NSVisualEffectMaterialFullScreenUI NSVisualEffectMaterial = 15 + NSVisualEffectMaterialToolTip NSVisualEffectMaterial = 17 + NSVisualEffectMaterialContentBackground NSVisualEffectMaterial = 18 + NSVisualEffectMaterialUnderWindowBackground NSVisualEffectMaterial = 21 + NSVisualEffectMaterialUnderPageBackground NSVisualEffectMaterial = 22 + NSVisualEffectMaterialAuto NSVisualEffectMaterial = -1 +) + +// MacLiquidGlass configures the Liquid Glass compositor effect. +type MacLiquidGlass struct { + Style MacLiquidGlassStyle + Material NSVisualEffectMaterial + CornerRadius float64 + TintColor *RGBA + GroupID string + GroupSpacing float64 +} + +// MacAppearanceType is the NSAppearance name string for a macOS window. +type MacAppearanceType string + +const ( + DefaultAppearance MacAppearanceType = "" + NSAppearanceNameAqua MacAppearanceType = "NSAppearanceNameAqua" + NSAppearanceNameDarkAqua MacAppearanceType = "NSAppearanceNameDarkAqua" + NSAppearanceNameVibrantLight MacAppearanceType = "NSAppearanceNameVibrantLight" + NSAppearanceNameAccessibilityHighContrastAqua MacAppearanceType = "NSAppearanceNameAccessibilityHighContrastAqua" + NSAppearanceNameAccessibilityHighContrastDarkAqua MacAppearanceType = "NSAppearanceNameAccessibilityHighContrastDarkAqua" + NSAppearanceNameAccessibilityHighContrastVibrantLight MacAppearanceType = "NSAppearanceNameAccessibilityHighContrastVibrantLight" + NSAppearanceNameAccessibilityHighContrastVibrantDark MacAppearanceType = "NSAppearanceNameAccessibilityHighContrastVibrantDark" +) + +// MacWindowLevel controls Z-ordering relative to other windows. +type MacWindowLevel string + +const ( + MacWindowLevelNormal MacWindowLevel = "normal" + MacWindowLevelFloating MacWindowLevel = "floating" + MacWindowLevelTornOffMenu MacWindowLevel = "tornOffMenu" + MacWindowLevelModalPanel MacWindowLevel = "modalPanel" + MacWindowLevelMainMenu MacWindowLevel = "mainMenu" + MacWindowLevelStatus MacWindowLevel = "status" + MacWindowLevelPopUpMenu MacWindowLevel = "popUpMenu" + MacWindowLevelScreenSaver MacWindowLevel = "screenSaver" +) + +// MacWindowCollectionBehavior is a bitmask controlling Spaces and fullscreen behaviour. +type MacWindowCollectionBehavior int + +const ( + MacWindowCollectionBehaviorDefault MacWindowCollectionBehavior = 0 + MacWindowCollectionBehaviorCanJoinAllSpaces MacWindowCollectionBehavior = 1 << 0 + MacWindowCollectionBehaviorMoveToActiveSpace MacWindowCollectionBehavior = 1 << 1 + MacWindowCollectionBehaviorManaged MacWindowCollectionBehavior = 1 << 2 + MacWindowCollectionBehaviorTransient MacWindowCollectionBehavior = 1 << 3 + MacWindowCollectionBehaviorStationary MacWindowCollectionBehavior = 1 << 4 + MacWindowCollectionBehaviorParticipatesInCycle MacWindowCollectionBehavior = 1 << 5 + MacWindowCollectionBehaviorIgnoresCycle MacWindowCollectionBehavior = 1 << 6 + MacWindowCollectionBehaviorFullScreenPrimary MacWindowCollectionBehavior = 1 << 7 + MacWindowCollectionBehaviorFullScreenAuxiliary MacWindowCollectionBehavior = 1 << 8 + MacWindowCollectionBehaviorFullScreenNone MacWindowCollectionBehavior = 1 << 9 + MacWindowCollectionBehaviorFullScreenAllowsTiling MacWindowCollectionBehavior = 1 << 11 + MacWindowCollectionBehaviorFullScreenDisallowsTiling MacWindowCollectionBehavior = 1 << 12 +) + +// MacWebviewPreferences holds WKWebView preference flags for macOS. +// Use integer tristate: 0 = unset, 1 = true, 2 = false. +type MacWebviewPreferences struct { + TabFocusesLinks int + TextInteractionEnabled int + FullscreenEnabled int + AllowsBackForwardNavigationGestures int +} + +// MacTitleBar configures the macOS title bar appearance. +type MacTitleBar struct { + // AppearsTransparent removes the title bar background. + AppearsTransparent bool + // Hide removes the title bar entirely. + Hide bool + // HideTitle hides only the text title. + HideTitle bool + // FullSizeContent extends window content into the title bar area. + FullSizeContent bool + // UseToolbar replaces the title bar with an NSToolbar. + UseToolbar bool + // HideToolbarSeparator removes the line between toolbar and content. + HideToolbarSeparator bool + // ShowToolbarWhenFullscreen keeps the toolbar visible in fullscreen. + ShowToolbarWhenFullscreen bool + // ToolbarStyle selects the toolbar layout style. + ToolbarStyle MacToolbarStyle +} + +// MacWindow contains macOS-specific window options. +type MacWindow struct { + Backdrop MacBackdrop + DisableShadow bool + TitleBar MacTitleBar + Appearance MacAppearanceType + InvisibleTitleBarHeight int + EventMapping map[events.WindowEventType]events.WindowEventType + EnableFraudulentWebsiteWarnings bool + WebviewPreferences MacWebviewPreferences + WindowLevel MacWindowLevel + CollectionBehavior MacWindowCollectionBehavior + LiquidGlass MacLiquidGlass +} + +// Pre-built MacTitleBar configurations — use directly in MacWindow.TitleBar. + +// MacTitleBarDefault produces the standard macOS title bar. +// +// Mac: MacWindow{TitleBar: MacTitleBarDefault} +var MacTitleBarDefault = MacTitleBar{} + +// MacTitleBarHidden hides the title text while keeping the traffic-light buttons. +// +// Mac: MacWindow{TitleBar: MacTitleBarHidden} +var MacTitleBarHidden = MacTitleBar{ + AppearsTransparent: true, + HideTitle: true, + FullSizeContent: true, +} + +// MacTitleBarHiddenInset keeps traffic lights slightly inset from the window edge. +// +// Mac: MacWindow{TitleBar: MacTitleBarHiddenInset} +var MacTitleBarHiddenInset = MacTitleBar{ + AppearsTransparent: true, + HideTitle: true, + FullSizeContent: true, + UseToolbar: true, + HideToolbarSeparator: true, +} + +// MacTitleBarHiddenInsetUnified uses the unified toolbar style for a more compact look. +// +// Mac: MacWindow{TitleBar: MacTitleBarHiddenInsetUnified} +var MacTitleBarHiddenInsetUnified = MacTitleBar{ + AppearsTransparent: true, + HideTitle: true, + FullSizeContent: true, + UseToolbar: true, + HideToolbarSeparator: true, + ToolbarStyle: MacToolbarStyleUnified, +} + +// ------------------------- +// Windows-specific types +// ------------------------- + +// BackdropType selects the Windows 11 compositor effect. +type BackdropType int32 + +const ( + Auto BackdropType = 0 + None BackdropType = 1 + Mica BackdropType = 2 + Acrylic BackdropType = 3 + Tabbed BackdropType = 4 +) + +// Theme selects dark or light mode on Windows. +type Theme int + +const ( + SystemDefault Theme = 0 + Dark Theme = 1 + Light Theme = 2 +) + +// WindowTheme holds custom title-bar colours for a Windows window. +type WindowTheme struct { + BorderColour *uint32 + TitleBarColour *uint32 + TitleTextColour *uint32 +} + +// TextTheme holds foreground/background colour pair for menu text. +type TextTheme struct { + Text *uint32 + Background *uint32 +} + +// MenuBarTheme holds per-state text themes for the Windows menu bar. +type MenuBarTheme struct { + Default *TextTheme + Hover *TextTheme + Selected *TextTheme +} + +// ThemeSettings holds custom colours for dark/light mode on Windows. +// Colours use 0x00BBGGRR encoding. +type ThemeSettings struct { + DarkModeActive *WindowTheme + DarkModeInactive *WindowTheme + LightModeActive *WindowTheme + LightModeInactive *WindowTheme + DarkModeMenuBar *MenuBarTheme + LightModeMenuBar *MenuBarTheme +} + +// CoreWebView2PermissionKind identifies a WebView2 permission category. +type CoreWebView2PermissionKind uint32 + +const ( + CoreWebView2PermissionKindUnknownPermission CoreWebView2PermissionKind = iota + CoreWebView2PermissionKindMicrophone + CoreWebView2PermissionKindCamera + CoreWebView2PermissionKindGeolocation + CoreWebView2PermissionKindNotifications + CoreWebView2PermissionKindOtherSensors + CoreWebView2PermissionKindClipboardRead +) + +// CoreWebView2PermissionState sets whether a permission is granted. +type CoreWebView2PermissionState uint32 + +const ( + CoreWebView2PermissionStateDefault CoreWebView2PermissionState = iota + CoreWebView2PermissionStateAllow + CoreWebView2PermissionStateDeny +) + +// WindowsWindow contains Windows-specific window options. +type WindowsWindow struct { + BackdropType BackdropType + DisableIcon bool + Theme Theme + CustomTheme ThemeSettings + DisableFramelessWindowDecorations bool + WindowMask []byte + WindowMaskDraggable bool + ResizeDebounceMS uint16 + WindowDidMoveDebounceMS uint16 + EventMapping map[events.WindowEventType]events.WindowEventType + HiddenOnTaskbar bool + EnableSwipeGestures bool + Menu *Menu + Permissions map[CoreWebView2PermissionKind]CoreWebView2PermissionState + ExStyle int + GeneralAutofillEnabled bool + PasswordAutosaveEnabled bool +} + +// ------------------------- +// Linux-specific types +// ------------------------- + +// WebviewGpuPolicy controls GPU acceleration for the Linux webview. +type WebviewGpuPolicy int + +const ( + WebviewGpuPolicyAlways WebviewGpuPolicy = iota + WebviewGpuPolicyOnDemand WebviewGpuPolicy = iota + WebviewGpuPolicyNever WebviewGpuPolicy = iota +) + +// LinuxMenuStyle selects how the application menu is rendered on Linux. +type LinuxMenuStyle int + +const ( + LinuxMenuStyleMenuBar LinuxMenuStyle = iota + LinuxMenuStylePrimaryMenu LinuxMenuStyle = iota +) + +// LinuxWindow contains Linux-specific window options. +type LinuxWindow struct { + Icon []byte + WindowIsTranslucent bool + WebviewGpuPolicy WebviewGpuPolicy + WindowDidMoveDebounceMS uint16 + Menu *Menu + MenuStyle LinuxMenuStyle +} + +// NewRGB constructs an RGBA value with full opacity from RGB components. +// +// colour := NewRGB(255, 128, 0) +func NewRGB(red, green, blue uint8) RGBA { + return RGBA{Red: red, Green: green, Blue: blue, Alpha: 255} +} + +// NewRGBPtr encodes RGB as a packed uint32 pointer (0x00BBGGRR) for ThemeSettings. +// +// theme.BorderColour = NewRGBPtr(255, 0, 0) +func NewRGBPtr(red, green, blue uint8) *uint32 { + result := uint32(red) | uint32(green)<<8 | uint32(blue)<<16 + return &result +} diff --git a/stubs/wails/pkg/application/window.go b/stubs/wails/pkg/application/window.go new file mode 100644 index 00000000..13bb641a --- /dev/null +++ b/stubs/wails/pkg/application/window.go @@ -0,0 +1,160 @@ +package application + +import ( + "unsafe" + + "github.com/wailsapp/wails/v3/pkg/events" +) + +// Window is the interface satisfied by all window types in the application. +// Fluent mutating methods return Window so callers can chain calls: +// +// app.Window.NewWithOptions(opts).SetTitle("Main").Show() +type Window interface { + // Identity + ID() uint + Name() string + + // Visibility + Show() Window + Hide() Window + IsVisible() bool + + // Lifecycle + Close() + Focus() + Run() + + // Geometry + Center() + Position() (x int, y int) + RelativePosition() (x int, y int) + Size() (width int, height int) + Width() int + Height() int + Bounds() Rect + SetPosition(x, y int) + SetRelativePosition(x, y int) Window + SetSize(width, height int) Window + SetBounds(bounds Rect) + SetMaxSize(maxWidth, maxHeight int) Window + SetMinSize(minWidth, minHeight int) Window + EnableSizeConstraints() + DisableSizeConstraints() + Resizable() bool + SetResizable(b bool) Window + + // State + Maximise() Window + UnMaximise() + ToggleMaximise() + IsMaximised() bool + Minimise() Window + UnMinimise() + IsMinimised() bool + Fullscreen() Window + UnFullscreen() + ToggleFullscreen() + IsFullscreen() bool + Restore() + SnapAssist() + + // Title and content + SetTitle(title string) Window + SetURL(s string) Window + SetHTML(html string) Window + + // Titlebar buttons (macOS / Windows) + SetMinimiseButtonState(state ButtonState) Window + SetMaximiseButtonState(state ButtonState) Window + SetCloseButtonState(state ButtonState) Window + + // Menu bar + SetMenu(menu *Menu) + ShowMenuBar() + HideMenuBar() + ToggleMenuBar() + + // Appearance + SetBackgroundColour(colour RGBA) Window + SetAlwaysOnTop(b bool) Window + SetFrameless(frameless bool) Window + ToggleFrameless() + SetIgnoreMouseEvents(ignore bool) Window + IsIgnoreMouseEvents() bool + SetContentProtection(protection bool) Window + + // Zoom + GetZoom() float64 + SetZoom(magnification float64) Window + Zoom() + ZoomIn() + ZoomOut() + ZoomReset() Window + + // Border sizes (Windows) + GetBorderSizes() *LRTB + + // Screen + GetScreen() (*Screen, error) + + // JavaScript / events + ExecJS(js string) + EmitEvent(name string, data ...any) bool + DispatchWailsEvent(event *CustomEvent) + OnWindowEvent(eventType events.WindowEventType, callback func(event *WindowEvent)) func() + RegisterHook(eventType events.WindowEventType, callback func(event *WindowEvent)) func() + + // Drag-and-drop (internal message bus) + handleDragAndDropMessage(filenames []string, dropTarget *DropTargetDetails) + InitiateFrontendDropProcessing(filenames []string, x int, y int) + + // Message handling (internal) + HandleMessage(message string) + HandleWindowEvent(id uint) + HandleKeyEvent(acceleratorString string) + + // Context menu + OpenContextMenu(data *ContextMenuData) + + // Modal + AttachModal(modalWindow Window) + + // DevTools + OpenDevTools() + + // Print + Print() error + + // Flash (Windows taskbar flash) + Flash(enabled bool) + + // Focus tracking + IsFocused() bool + + // Native handle (platform-specific, use with care) + NativeWindow() unsafe.Pointer + + // Enabled state + SetEnabled(enabled bool) + + // Reload + Reload() + ForceReload() + + // Logging (routed to the application logger) + Info(message string, args ...any) + Error(message string, args ...any) + + // Internal hooks + shouldUnconditionallyClose() bool + + // Editing operations (routed to focused element) + cut() + copy() + paste() + undo() + redo() + delete() + selectAll() +} diff --git a/stubs/wails/pkg/events/events.go b/stubs/wails/pkg/events/events.go new file mode 100644 index 00000000..80d67b1d --- /dev/null +++ b/stubs/wails/pkg/events/events.go @@ -0,0 +1,44 @@ +package events + +// ApplicationEventType identifies a platform-level application event. +// Matches the type used by the real Wails v3 package. +// +// em.OnApplicationEvent(events.Common.ThemeChanged, handler) +type ApplicationEventType uint + +// WindowEventType identifies a window event emitted by the application layer. +type WindowEventType int + +const ( + WindowFocus WindowEventType = iota + WindowLostFocus + WindowDidMove + WindowDidResize + WindowClosing + WindowFilesDropped +) + +// Common matches the event namespace used by the real Wails package. +var Common = struct { + ApplicationOpenedWithFile ApplicationEventType + ApplicationStarted ApplicationEventType + ApplicationLaunchedWithUrl ApplicationEventType + ThemeChanged ApplicationEventType + WindowFocus WindowEventType + WindowLostFocus WindowEventType + WindowDidMove WindowEventType + WindowDidResize WindowEventType + WindowClosing WindowEventType + WindowFilesDropped WindowEventType +}{ + ApplicationOpenedWithFile: 1024, + ApplicationStarted: 1025, + ApplicationLaunchedWithUrl: 1026, + ThemeChanged: 1027, + WindowFocus: WindowFocus, + WindowLostFocus: WindowLostFocus, + WindowDidMove: WindowDidMove, + WindowDidResize: WindowDidResize, + WindowClosing: WindowClosing, + WindowFilesDropped: WindowFilesDropped, +}