pub struct Renderer { /* private fields */ }Expand description
Draws windows. One serves every window; it holds the glyph and icon caches.
Implementations§
Source§impl Renderer
impl Renderer
Sourcepub fn set_icon_theme(&mut self, theme: impl Into<String>)
pub fn set_icon_theme(&mut self, theme: impl Into<String>)
Sets the icon theme names are looked up in.
Sourcepub fn icon_lookup(&self) -> IconLookup
pub fn icon_lookup(&self) -> IconLookup
The lookup icon names go through, which follows
set_icon_theme.
Sourcepub fn forget_captures(&mut self, gone: &[u64])
pub fn forget_captures(&mut self, gone: &[u64])
Drops the scaled frames kept for screencopy views gone, at once:
each is as large as its view, and an idle shell may draw nothing
for a long while.
Sourcepub fn decode_off_thread(&mut self)
pub fn decode_off_thread(&mut self)
From now on, decodes image files on a worker thread, which starts with the first and ends once none is left: a GIF’s frames, a blurred picture, and any file past 64 KiB or drawn past 256 by 256 pixels. Until its picture comes in, an image draws the picture its transition leaves, or the one it drew before at its size, or nothing. Without this, as for a snapshot, each is decoded as it is first drawn.
The platform then follows decoding, and while it
holds asks to be woken with
wake_when_decoded and calls
take_decoded when it is.
Sourcepub fn load_images(&mut self, view: &WindowView<'_>, scale: f32)
pub fn load_images(&mut self, view: &WindowView<'_>, scale: f32)
Loads the images of view whose status still waits, drawn or not,
at their laid-out size at scale, or one pixel without one, and
tells each status: at once, or when the worker is done with it. The
platform calls it for every window, drawn or not, whenever
image_sources_changed says
a source changed.
Sourcepub fn decoding(&self) -> bool
pub fn decoding(&self) -> bool
Whether pictures are being decoded for images drawn, or came in and
weren’t taken with take_decoded yet.
Sourcepub fn wake_when_decoded(&mut self, wake: impl FnOnce() + Send + 'static)
pub fn wake_when_decoded(&mut self, wake: impl FnOnce() + Send + 'static)
Calls wake once, from the worker thread, when a picture is
decoded, or at once if one waits to be taken. It replaces a wake
given before.
Sourcepub fn waits_for_pictures(&self) -> bool
pub fn waits_for_pictures(&self) -> bool
Whether the last draw drew an image whose picture is still being decoded, so the platform can hold a window’s first frame for it.
Sourcepub fn take_decoded(&mut self) -> Vec<u64>
pub fn take_decoded(&mut self) -> Vec<u64>
Caches the pictures decoded since the last call, logging each
failure once, and returns the ids of the images that wait for them,
for the platform to repaint with
Window::repaint_image in
every window.
Sourcepub fn next_image_frame(&mut self, now: Instant) -> Option<Instant>
pub fn next_image_frame(&mut self, now: Instant) -> Option<Instant>
When the next frame of an animated GIF is due, counting from now
for one drawn since the last call. None while no GIF drawn plays.
The platform wakes then and calls
advance_images.
Sourcepub fn advance_images(&mut self, now: Instant) -> Vec<u64>
pub fn advance_images(&mut self, now: Instant) -> Vec<u64>
Moves each GIF whose next frame is due by now on to it, and returns
their image ids for the platform to repaint with
Window::repaint_image. A
GIF waits for its next frame only once that one is drawn, so one no
longer shown wakes nothing more.
Sourcepub fn draw(
&mut self,
view: &WindowView<'_>,
damage: &[Rect],
text: &mut TextSystem,
history: &mut DamageHistory,
canvas: Canvas<'_>,
) -> Result<Vec<PixelRect>, CanvasError>
pub fn draw( &mut self, view: &WindowView<'_>, damage: &[Rect], text: &mut TextSystem, history: &mut DamageHistory, canvas: Canvas<'_>, ) -> Result<Vec<PixelRect>, CanvasError>
Draws the laid-out window view into canvas and returns the areas
to report with wl_surface.damage_buffer.
damage is what the window reported since the last draw, from
Window::take_damage. The draw
repaints that, plus what changed in frames this buffer missed
according to history, or the whole buffer when that is more than
half of it or the buffer is new. Text and glyphs come from text.
An image in that area it skips, at opacity 0 or cut out by its mask
region, still has its picture loaded at the size drawing it would
give, once a draw, so revealing it draws it on its first frame.
Commit the buffer after every successful draw, in order: the history counts each one as a frame the compositor showed.
§Errors
If canvas holds the wrong number of bytes for its size, or its
scale isn’t a positive number. Nothing is drawn and the history
doesn’t advance.