Struct PartialRenderer

pub struct PartialRenderer<'a, T> {
    pub dirty_region: DirtyRegion,
    pub actual_renderer: T,
    /* private fields */
}

Put this structure in the renderer to help with partial rendering

Fields

dirty_region: DirtyRegion

The region of the screen which is considered dirty and that should be repainted

actual_renderer: T

The actual renderer which the drawing call will be forwarded to

Implementations

impl<'a, T> PartialRenderer<'a, T>

pub fn new( cache: &'a RefCell<PartialRenderingCache>, initial_dirty_region: DirtyRegion, actual_renderer: T, ) -> Self

Create a new PartialRenderer

pub fn compute_dirty_regions( &mut self, component: &ItemTreeRc, origin: LogicalPoint, size: LogicalSize, )

Visit the tree of item and compute what are the dirty regions

pub fn into_inner(self) -> T

Move the actual renderer

Trait Implementations

impl<'a, T: ItemRenderer> ItemRenderer for PartialRenderer<'a, T>

fn filter_item(&mut self, item_rc: &ItemRc) -> (bool, LogicalRect)

This is called before it is being rendered (before the draw_* function). Returns

fn draw_rectangle( &mut self, obj: Pin<&Rectangle>, item_rc: &ItemRc, size: LogicalSize, )

fn draw_border_rectangle( &mut self, obj: Pin<&dyn RenderBorderRectangle>, item_rc: &ItemRc, size: LogicalSize, cache: &CachedRenderingData, )

fn draw_image( &mut self, obj: Pin<&dyn RenderImage>, item_rc: &ItemRc, size: LogicalSize, cache: &CachedRenderingData, )

fn draw_text( &mut self, obj: Pin<&dyn RenderText>, item_rc: &ItemRc, size: LogicalSize, cache: &CachedRenderingData, )

fn draw_text_input( &mut self, obj: Pin<&TextInput>, item_rc: &ItemRc, size: LogicalSize, )

fn draw_path(&mut self, obj: Pin<&Path>, item_rc: &ItemRc, size: LogicalSize)

fn draw_box_shadow( &mut self, obj: Pin<&BoxShadow>, item_rc: &ItemRc, size: LogicalSize, )

fn visit_clip( &mut self, obj: Pin<&Clip>, item_rc: &ItemRc, size: LogicalSize, ) -> RenderingResult

fn visit_opacity( &mut self, obj: Pin<&Opacity>, item_rc: &ItemRc, size: LogicalSize, ) -> RenderingResult

fn combine_clip( &mut self, rect: LogicalRect, radius: LogicalBorderRadius, border_width: LogicalLength, ) -> bool

Clip the further call until restore_state. radius/border_width can be used for border rectangle clip. (FIXME: consider removing radius/border_width and have another function that take a path instead) Returns a boolean indicating the state of the new clip region: true if the clip region covers an area; false if the clip region is empty.

fn get_current_clip(&self) -> LogicalRect

Get the current clip bounding box in the current transformed coordinate.

fn translate(&mut self, distance: LogicalVector)

fn translation(&self) -> LogicalVector

fn rotate(&mut self, angle_in_degrees: f32)

fn apply_opacity(&mut self, opacity: f32)

Apply the opacity (between 0 and 1) for all following items until the next call to restore_state.

fn save_state(&mut self)

fn restore_state(&mut self)

fn scale_factor(&self) -> f32

Returns the scale factor

fn draw_cached_pixmap( &mut self, item_rc: &ItemRc, update_fn: &dyn Fn(&mut dyn FnMut(u32, u32, &[u8])), )

Draw a pixmap in position indicated by the pos. The pixmap will be taken from cache if the cache is valid, otherwise, update_fn will be called with a callback that need to be called once with fn (width, height, data) where data are the RGBA premultiplied pixel values

fn draw_string(&mut self, string: &str, color: Color)

Draw the given string with the specified color at current (0, 0) with the default font. Mainly used by the performance counter overlay.

fn draw_image_direct(&mut self, image: Image)

fn draw_rect(&mut self, size: LogicalSize, brush: Brush)

Fills a rectangle at (0,0) with the given size. This is used for example by the Skia renderer to handle window backgrounds with a brush (gradient).

fn window(&self) -> &WindowInner

fn as_any(&mut self) -> Option<&mut dyn Any>

Return the internal renderer

fn visit_layer( &mut self, _layer_item: Pin<&Layer>, _self_rc: &ItemRc, _size: LogicalSize, ) -> RenderingResult

fn metrics(&self) -> RenderingMetrics

Returns any rendering metrics collecting since the creation of the renderer (typically per frame)