Expand description
Draws Crabshell windows on the CPU: backgrounds, rounded corners, borders and opacity with tiny-skia, glyphs from cosmic-text, and icons from SVG, PNG or raw pixels. Only what changed is repainted.
The platform keeps one Renderer, a DamageHistory per window and
a BufferAge per buffer. Each frame it hands the renderer the window’s
view and damage and a Canvas over the buffer’s memory, and reports
the returned rectangles to the compositor:
use crabshell_reactive::Runtime;
use crabshell_render::{BufferAge, Canvas, DamageHistory, PixelFormat, Renderer};
use crabshell_ui::prelude::*;
let runtime = Runtime::current();
let cx = Cx::new(runtime.new_owner());
let bar = PanelWindow::new(&Output::new("DP-1"))
.style(Style::new().background(Color::rgb(0x1e, 0x1e, 0x2e)))
.child(Text::new("hello"));
let window = Window::new(&cx, bar);
let mut text = TextSystem::new();
window.set_size(Size::new(200.0, 30.0));
runtime.flush();
window.layout(&mut text);
let mut renderer = Renderer::new();
let mut history = DamageHistory::new();
let mut age = BufferAge::default();
let scale = 1.5;
let (width, height) = (300, 45); // 200 x 30 logical pixels at 1.5
let mut buffer = vec![0; width * height * 4];
let damage = window.take_damage();
let report = renderer.draw(
&window.view(),
&damage,
&mut text,
&mut history,
Canvas {
pixels: &mut buffer,
width: width as u32,
height: height as u32,
scale,
format: PixelFormat::Argb8888,
age: &mut age,
},
)?;
assert_eq!(report.len(), 1); // a new buffer is drawn whole§How it works
Damage arrives in logical pixels and becomes buffer pixels, rounded
outward. A buffer that skipped frames also repaints what changed in
them, and one more than half dirty repaints whole. Damaged areas are
drawn in fixed 64-pixel tiles, so a repaint matches a full draw. Edges
snap to whole pixels, text is drawn as grayscale masks, and icons are
cached by source and size. capture_frame and quantize_colors
serve screencopy views and wallpaper themes. The design doc’s
Rendering
section has the full rules.
Structs§
- Buffer
Age - The frame a buffer last held. Keep one next to each buffer, starting
with
BufferAge::defaultfor a new one. - Canvas
- A buffer to draw a window into.
- Canvas
Error - A canvas whose bytes don’t fit its size, or whose scale isn’t a positive number.
- Damage
History - What changed in one window’s recent frames, and the layers the renderer keeps while something in it fades or moves. Keep one per window; dropping it frees them.
- Icon
Lookup - The icon theme in use and the lookups in it, shared by the renderer
and
cx.icon_path, so both find the same file and read each directory once. - Pixel
Rect - A rectangle of buffer pixels.
- Renderer
- Draws windows. One serves every window; it holds the glyph and icon caches.
- Turn
- How the compositor turned a captured buffer, as
wl_output.transformsays: rotated counter-clockwise by a quarter turn or more, and flipped around the vertical axis before that.
Enums§
- Pixel
Format - How a buffer stores each pixel, as
wl_shmnames the formats. Both are 32 bits per pixel with premultiplied alpha.
Constants§
- DEFAULT_
ICON_ THEME - The theme icon names are looked up in when the config doesn’t set one.
Functions§
- capture_
frame - The frame a view keeps of a
widthbyheightbuffer of premultiplied pixels informat, which the compositorturned. Withopaque, as inXRGB8888andXBGR8888, the fourth byte is ignored. The frame is turned back upright and scaled down toframe_sizeforcover. Its logical size is the source’s upright size in pixels, for the platform to replace with the source’s logical one.Noneifpixelsdoesn’t holdwidth * heightpixels. - frame_
size - The size a
sourcesized frame is kept at to show in a box ofcoverpixels: scaled down, keeping its shape, to the smallest size that still covers the box, so any fit draws it without scaling up. It is never scaled up, and keeps at least one pixel a side. - quantize_
colors - The main colors of the image file at
path, most common first.