widgetkit 0.3.0

Modular Rust framework for building desktop widgets.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

# WidgetKit

---

language: English, [Russian](README.ru.md)

---
[![Version](https://img.shields.io/badge/version-0.3.0-blue)](#)
[![Platform](https://img.shields.io/badge/platform-Windows-lightgrey)](#)
[![Renderer](https://img.shields.io/badge/renderer-software%202D-lightgrey)](#)
[![Status](https://img.shields.io/badge/status-window%20%2B%20layout%20foundations-green)](#)

Modular Rust library for building small desktop widgets.

Current scope: software 2D rendering on Windows with window configuration, content-driven sizing,
and layout measurement foundations behind the public `Canvas` API.

Core assembly: `Widget + Canvas + WindowsHost + WidgetApp`.

For the full release history, see [CHANGELOG.md](CHANGELOG.md).

## Overview

- `Canvas` — stable drawing API
- demand-driven redraw and layout invalidation
- `WindowConfig` and Windows host flags for frameless, transparent, resizable, visible, and always-on-top windows
- `SizePolicy` with fixed and content-driven sizing
- `LayoutCtx::measure_text(...)` for preferred-size calculations
- software 2D renderer backed by an internal render pipeline

## Quick Start

```rust
use widgetkit::prelude::*;

fn main() -> widgetkit::Result<()> {
    WidgetApp::new()
        .widget("clock", ClockWidget)
        .host(
            WindowsHost::new()
                .size_policy(SizePolicy::ContentWithLimits {
                    min: Some(Size::new(280.0, 112.0)),
                    max: Some(Size::new(520.0, 180.0)),
                })
                .frameless(true)
                .transparent(true)
                .always_on_top(true),
        )
        .renderer(SoftwareRenderer::new())
        .run()
}
```

## Example Widget

```rust
use widgetkit::prelude::*;

struct MyWidget;

struct MyState {
    label: String,
}

impl Widget for MyWidget {
    type State = MyState;
    type Message = ();

    fn mount(&mut self, _ctx: &mut MountCtx<Self>) -> Self::State {
        MyState {
            label: "Hello WidgetKit".to_string(),
        }
    }

    fn preferred_size(&self, state: &Self::State, ctx: &LayoutCtx<Self>) -> Size {
        let label = ctx.measure_text(&state.label, TextStyle::new().size(16.0));
        ctx.constrain(Size::new(label.width + 48.0, label.height + 48.0))
    }

    fn render(&self, state: &Self::State, canvas: &mut Canvas, ctx: &RenderCtx<Self>) {
        let size = ctx.surface_size();

        canvas.clear(Color::rgba(0, 0, 0, 0));
        canvas.round_rect(
            Rect::xywh(8.0, 8.0, size.width - 16.0, size.height - 16.0),
            16.0,
            Color::rgb(30, 36, 48),
        );
        canvas.text(
            Point::new(24.0, 28.0),
            &state.label,
            TextStyle::new().size(16.0),
            Color::rgb(127, 160, 255),
        );
    }
}
```

## Examples

```bash
cargo run --example clock --features "windows canvas"
cargo run --example pulse --features "windows canvas"
```

With the Tokio-backed task runtime:

```bash
cargo run --example clock --features "windows canvas runtime-tokio"
```

## Features

- `canvas`
- `windows`
- `runtime-tokio`

```toml
[dependencies]
widgetkit = { version = "0.3.0", default-features = false, features = ["windows", "canvas"] }
```

## Workspace Layout

```text
widgetkit/
  crates/
    widgetkit
    widgetkit-core
    widgetkit-runtime
    widgetkit-render
    widgetkit-host-windows
```

- `widgetkit` - top-level facade crate
- `widgetkit-core` - geometry, colors, ids, errors, host events
- `widgetkit-runtime` - lifecycle, scheduler, tasks, layout/redraw coordination
- `widgetkit-render` - `Canvas`, text styles, measurement, software renderer
- `widgetkit-host-windows` - Windows host built on `winit` and `softbuffer`

## Roadmap

- declarative UI and layout
- richer input model
- image pipeline stabilization
- GPU renderer backend
- hybrid and web-backed integration paths

## License

MIT