Struct CompositorDrawingContextProxy 

pub struct CompositorDrawingContextProxy { /* private fields */ }

A drawing context that forwards to another one, postponing state changes until they are needed and applying an optional post transform.

Implementations

impl CompositorDrawingContextProxy

pub fn new(inner: Box<dyn IDrawingContextImpl>) -> Self

pub fn into_inner(self) -> Box<dyn IDrawingContextImpl>

Flushes the pending commands and returns the wrapped context.

pub fn post_transform(&self) -> Option<Matrix>

pub fn set_post_transform(&mut self, value: Option<Matrix>)

pub fn auto_flush(&self) -> bool

pub fn set_auto_flush(&mut self, value: bool)

pub fn flush(&mut self)

Trait Implementations

impl IDrawingContextImpl for CompositorDrawingContextProxy

fn transform(&self) -> Matrix

The current transform of the drawing context.

fn set_transform(&mut self, value: Matrix)

Sets the current transform of the drawing context.

fn clear(&mut self, color: Color)

Clears the render target to the specified color.

fn draw_bitmap( &mut self, source: &dyn IBitmapImpl, opacity: f64, source_rect: Rect, dest_rect: Rect, )

Draws a bitmap image.

fn draw_bitmap_with_mask( &mut self, source: &dyn IBitmapImpl, opacity_mask: &dyn IBrush, opacity_mask_rect: Rect, dest_rect: Rect, )

Draws a bitmap image through an opacity mask.

fn draw_line(&mut self, pen: Option<&dyn IPen>, p1: Point, p2: Point)

Draws a line.

fn draw_geometry( &mut self, brush: Option<&dyn IBrush>, pen: Option<&dyn IPen>, geometry: &dyn IGeometryImpl, )

Draws a geometry.

fn draw_rectangle( &mut self, brush: Option<&dyn IBrush>, pen: Option<&dyn IPen>, rect: RoundedRect, box_shadows: &BoxShadows, )

Draws a rectangle with the specified brush and pen.

fn draw_region( &mut self, brush: Option<&dyn IBrush>, pen: Option<&dyn IPen>, region: &dyn IPlatformRenderInterfaceRegion, )

Draws a region with the specified brush and pen.

fn draw_ellipse( &mut self, brush: Option<&dyn IBrush>, pen: Option<&dyn IPen>, rect: Rect, )

Draws an ellipse with the specified brush and pen.

fn draw_glyph_run( &mut self, foreground: Option<&dyn IBrush>, glyph_run: &dyn IGlyphRunImpl, )

Draws a glyph run.

fn create_layer(&mut self, size: PixelSize) -> Rc<dyn IDrawingContextLayerImpl>

Creates a new layer: an offscreen render target compatible with this drawing context that can be blitted back onto it.

fn push_clip(&mut self, clip: Rect)

Pushes a clip rectangle.

fn push_clip_rounded(&mut self, clip: RoundedRect)

Pushes a rounded clip rectangle.

fn push_clip_region(&mut self, region: &dyn IPlatformRenderInterfaceRegion)

Pushes a clip region.

fn pop_clip(&mut self)

Pops the latest pushed clip rectangle or region.

fn push_layer(&mut self, bounds: Rect)

Enforces rendering to happen on an intermediate surface.

fn pop_layer(&mut self)

Pops the latest pushed intermediate surface layer.

fn push_opacity(&mut self, opacity: f64, bounds: Option<Rect>)

Pushes an opacity value.

fn pop_opacity(&mut self)

Pops the latest pushed opacity value.

fn push_opacity_mask(&mut self, mask: &dyn IBrush, bounds: Rect)

Pushes an opacity mask.

fn pop_opacity_mask(&mut self)

Pops the latest pushed opacity mask.

fn push_geometry_clip(&mut self, clip: &dyn IGeometryImpl)

Pushes a clip geometry.

fn pop_geometry_clip(&mut self)

Pops the latest pushed geometry clip.

fn push_render_options(&mut self, render_options: RenderOptions)

Pushes render options.

fn pop_render_options(&mut self)

Pops the latest pushed render options.

fn push_text_options(&mut self, text_options: TextOptions)

Pushes text options for the drawing context.

fn pop_text_options(&mut self)

Pops the latest text options.

fn get_feature(&mut self, feature_type: TypeId) -> Option<Rc<dyn Any>>

Attempts to get an optional feature from the drawing context implementation; see IOptionalFeatureProvider.

fn try_push_compositing_layer( &mut self, blend: BitmapBlendingMode, opacity: f64, bounds: Rect, ) -> bool

Begins one isolated group for vectors, text and images, composed with blend and multiplied by opacity when popped. Bounds are in the current coordinate space and are an allocation hint, not a clip. Returning false leaves every drawing state unchanged.

fn pop_compositing_layer(&mut self)

Pops a successful try_push_compositing_layer and restores its state.

fn as_drawing_context_impl_with_effects( &mut self, ) -> Option<&mut dyn IDrawingContextImplWithEffects>

The context viewed as IDrawingContextImplWithEffects, when the backend can apply bitmap effects. This replaces the interface cast (impl as IDrawingContextImplWithEffects): a backend that implements the trait overrides this to return itself.

fn as_drawing_context_with_acrylic_like_support( &mut self, ) -> Option<&mut dyn IDrawingContextWithAcrylicLikeSupport>

The context viewed as IDrawingContextWithAcrylicLikeSupport, when the backend can draw acrylic-like materials. This replaces the interface cast: a backend that implements the trait overrides this to return itself.

fn as_drawing_context_impl_with_layer_effects( &mut self, ) -> Option<&mut dyn IDrawingContextImplWithLayerEffects>

The context viewed as IDrawingContextImplWithLayerEffects, when the backend can compose a layer with a blend mode or through a colour matrix. A backend that implements the trait overrides this to return itself.

fn as_drawing_context_impl_with_fragments( &mut self, ) -> Option<&mut dyn IDrawingContextImplWithFragments>

The context viewed as IDrawingContextImplWithFragments, when the backend can keep what is drawn as fragments and draw them again. A backend that implements the trait overrides this to return itself.

fn as_any_mut(&mut self) -> &mut dyn Any

Lets the backend recover its concrete type.

fn dispose(&mut self)

Finishes drawing and releases the context (presenting the frame where the context was created by a render target).

impl IDrawingContextImplWithEffects for CompositorDrawingContextProxy

fn push_effect(&mut self, clip_rect: Option<Rect>, effect: &dyn IEffect)

Pushes an effect: everything drawn until the matching pop_effect is drawn through it. clip_rect bounds the output of the effect, when known.

fn pop_effect(&mut self)

Pops the latest pushed effect.

impl IDrawingContextImplWithFragments for CompositorDrawingContextProxy

fn begin_fragment(&mut self)

Starts a fragment: what is drawn until the matching end_fragment is drawn as usual and also kept. Fragments do not nest; pushes and pops in between are balanced.

fn end_fragment(&mut self) -> Option<Rc<dyn IDrawingFragment>>

Ends the fragment that was started last. What was drawn stays drawn. Returns the fragment, or None when what was drawn cannot be drawn again from a fragment.

fn draw_fragment(&mut self, fragment: &Rc<dyn IDrawingFragment>) -> bool

Draws a fragment that this context’s backend made in an earlier frame, when doing so at the current state gives the pixels the commands it was made of would give. Returns false without drawing anything otherwise.

impl IDrawingContextImplWithLayerEffects for CompositorDrawingContextProxy

fn push_blend_layer(&mut self, bounds: Rect, mode: BitmapBlendingMode)

Pushes a layer: what is drawn until the matching pop_blend_layer is composed onto what is under it with mode (the Porter-Duff modes compose, the others mix and compose source-over). bounds is the area drawn into, in the coordinates of the context.

fn pop_blend_layer(&mut self)

Pops the latest blend layer.

fn push_color_matrix_layer( &mut self, bounds: Rect, matrix: &ColorMatrix, alpha_mode: ColorMatrixAlphaMode, )

Pushes a layer: what is drawn until the matching pop_color_matrix_layer is transformed by matrix (applied to premultiplied or straight colours, as alpha_mode says) and composed source-over onto what is under it. bounds is the area drawn into, in the coordinates of the context; nothing outside it is kept.

fn pop_color_matrix_layer(&mut self)

Pops the latest colour matrix layer.

fn push_multiply_layer(&mut self, bounds: Rect, factors: &MultiplyLayerFactors)

Pushes a layer: each colour channel of what is drawn until the matching pop_multiply_layer is multiplied by the factor factors has at that point (stretched over bounds, sampled bilinearly), the alpha is kept, and the result is composed source-over onto what is under it. A factor can exceed 1 (up to MultiplyLayerFactors::scale); the result is clamped to the alpha. bounds is the area drawn into, in the coordinates of the context; nothing outside it is kept. What the lights of WinUI’s composition are drawn with (winui-materials.md).

fn pop_multiply_layer(&mut self)

Pops the latest multiply layer.

impl IDrawingContextWithAcrylicLikeSupport for CompositorDrawingContextProxy

fn draw_rectangle_with_material( &mut self, material: &dyn IExperimentalAcrylicMaterial, rect: RoundedRect, )

Draws a rectangle filled with an acrylic-like material.