Struct BuiltinEditor 

pub struct BuiltinEditor<P: Params> { /* private fields */ }

Built-in editor that renders parameter widgets to a pixel buffer.

Uses the CPU backend (tiny-skia) for software rasterization. When open() is called, creates a baseview window and blits pixels via wgpu.

Implementations

impl<P: Params + 'static> BuiltinEditor<P>

pub fn request_repaint(&self)

Request a repaint on the next idle tick. Call this if plugin code mutates display state outside the normal param or state_changed pathways (uncommon). User interaction and host automation already flag themselves dirty automatically.

pub fn new(params: Arc<P>, layout: PluginLayout) -> Self

pub fn new_with_layout(params: Arc<P>, layout: Layout) -> Self

pub fn new_grid(params: Arc<P>, layout: GridLayout) -> Self

pub fn with_theme(self, theme: Theme) -> Self

pub fn render(&mut self)

Render the full UI to the internal CPU pixel buffer.

Only available when the cpu feature is on. In gpu-only mode, render through Self::render_to with a truce_gpu::WgpuBackend instead.

Panics

Panics if the lazy CpuBackend::new allocation fails (out of memory or zero dimensions). The backend is allocated on first render - subsequent calls reuse it.

pub fn dispatch_events(&mut self, events: &[InputEvent])

Feed a batch of input events through interaction::dispatch and apply the resulting param edits. Flags a repaint when hover, dropdown-open state, or any param moved.

Typically callers build the events by running each baseview event through interaction::BaseviewTranslator and batching the non-None results.

pub fn pixel_data(&self) -> Option<&[u8]>

Get the raw pixel data after rendering (RGBA premultiplied). Only available when the cpu feature is on.

pub fn has_context(&self) -> bool

Whether the editor has an active context.

pub fn take_context(&mut self) -> Option<PluginContext>

Take the editor context, leaving None in its place. Used by hot-reload to preserve the context when swapping editors.

pub fn set_context(&mut self, context: PluginContext)

Set the editor context (host callbacks) without opening the CPU view.

pub fn size(&self) -> (u32, u32)

Editor logical size (width, height in points). Inherent method so it stays callable when the Editor trait impl is cfg’d out in gpu-only builds.

pub fn can_resize(&self) -> bool

Whether the editor supports host/user-driven resize. Inherent for the same reason as Self::size: the GPU editor wraps this type and delegates to it in gpu-only builds where the Editor trait impl is cfg’d out.

pub fn min_size(&self) -> (u32, u32)

Minimum logical size in points. Inherent (see Self::size).

pub fn max_size(&self) -> (u32, u32)

Maximum logical size in points. Inherent (see Self::size).

pub fn size_increment(&self) -> Option<(u32, u32)>

Cell-step resize increment, or None when not resizable. Inherent (see Self::size).

pub fn can_maximize(&self) -> bool

Whether the standalone host may maximize the window. Inherent (see Self::size) so the gpu-only GpuEditor wrapper can reach it when this Editor impl is cfg’d out. Sourced from the grid’s .maximizable() (default false); Rows layouts are fixed-size and never maximizable, and the value is moot there anyway since can_resize is false.

pub fn set_size(&mut self, width: u32, height: u32) -> bool

Snap a requested logical size to whole cells, reflow the grid, and post the result for the next frame. Returns true when accepted. Inherent (see Self::size).

pub fn state_changed(&mut self)

Notify the widget tree that plugin state was restored (preset recall, undo, session load). Inherent for the same reason as Self::size above.

pub fn render_to(&mut self, backend: &mut dyn RenderBackend)

Render all widgets to an external RenderBackend.

Used by truce-gpu to draw through the GPU backend instead of the internal CPU backend.

Trait Implementations

impl<P: Params + 'static> Drop for BuiltinEditor<P>

Available on crate feature cpu only.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<P: Params + 'static> Editor for BuiltinEditor<P>

Available on crate feature cpu only.

fn size(&self) -> (u32, u32)

Initial window size in logical points.

fn state_changed(&mut self)

Plugin state was restored (preset recall, undo, session load).

fn can_resize(&self) -> bool

Whether the plugin supports resizing.

fn can_maximize(&self) -> bool

Whether the editor permits the standalone window to be maximized (the WM maximize button / double-click-titlebar maximize / macOS zoom-and-fullscreen / Windows maximize box).

fn min_size(&self) -> (u32, u32)

Minimum size the editor can render at, in logical points. Defaults to (1, 1). Wrappers consult this for CLAP’s gui_get_resize_hints and VST3’s checkSizeConstraint. Ignored when can_resize() returns false.

fn max_size(&self) -> (u32, u32)

Maximum size the editor can render at, in logical points. Defaults to (u32::MAX, u32::MAX). Same wrapper consumers as min_size.

fn size_increment(&self) -> Option<(u32, u32)>

Logical-point granularity for interactive resize, or None for free (pixel-precise) resizing. The standalone X11 host maps this onto WM resize increments (PResizeInc) so the window manager snaps edge-drags to whole cells - the same mechanism terminal emulators use to snap to character cells. The snap counts from Self::min_size, which is already cell-aligned, so every allowed size lands on a boundary. Ignored when can_resize() returns false.

fn set_size(&mut self, width: u32, height: u32) -> bool

Host requests a resize. Return true to accept.

fn open(&mut self, parent: RawWindowHandle, context: PluginContext)

Create the GUI as a child of the host-provided parent window.

fn set_scale_factor(&mut self, factor: f64)

Host notifies the editor of a new content scale factor.

fn set_uses_system_scale(&mut self, yes: bool)

Opt the editor into honoring the desktop (system) scale.

fn close(&mut self)

Destroy the GUI.

fn idle(&mut self)

Called ~60fps on the host’s UI thread for repaint/animation.

fn screenshot( &mut self, _params: Arc<dyn Params>, ) -> Option<(Vec<u8>, u32, u32)>

Render a headless screenshot of the editor at its natural size.

fn aspect_ratio(&self) -> Option<(u32, u32)>

Aspect-ratio constraint as (numerator, denominator), or None for free resizing. CLAP, VST3, AU v3, standalone, and LV2 honour this; VST2 / AAX silently ignore. Integer pair (not f64) avoids the Cubase-9 aspect-rounding quirk JUCE special-cases.

fn prefers_pow2(&self) -> bool

Hint that the renderer prefers power-of-two surface sizes (some GPU-backed editors). Maps onto CLAP’s clap_gui_resize_hints.preserve_aspect_ratio / aspect_ratio_width siblings; ignored on formats without an equivalent.

impl<P: Params> Send for BuiltinEditor<P>