1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
use crate::ActorMeta; use glib::{object as gobject, object::IsA, translate::*}; use std::fmt; glib_wrapper! { pub struct Effect(Object<ffi::ClutterEffect, ffi::ClutterEffectClass, EffectClass>) @extends ActorMeta, gobject::InitiallyUnowned; match fn { get_type => || ffi::clutter_effect_get_type(), } } pub const NONE_EFFECT: Option<&Effect> = None; /// Trait containing all `Effect` methods. /// /// # Implementors /// /// [`Effect`](struct.Effect.html), [`OffscreenEffect`](struct.OffscreenEffect.html) pub trait EffectExt: 'static { /// Queues a repaint of the effect. The effect can detect when the ‘paint’ /// method is called as a result of this function because it will not /// have the `EffectPaintFlags::ActorDirty` flag set. In that case the /// effect is free to assume that the actor has not changed its /// appearance since the last time it was painted so it doesn't need to /// call `ActorExt::continue_paint` if it can draw a cached /// image. This is mostly intended for effects that are using a /// `cogl::Offscreen` to redirect the actor (such as /// `OffscreenEffect`). In that case the effect can save a bit of /// rendering time by painting the cached texture without causing the /// entire actor to be painted. /// /// This function can be used by effects that have their own animatable /// parameters. For example, an effect which adds a varying degree of a /// red tint to an actor by redirecting it through a CoglOffscreen /// might have a property to specify the level of tint. When this value /// changes, the underlying actor doesn't need to be redrawn so the /// effect can call `EffectExt::queue_repaint` to make sure the /// effect is repainted. /// /// Note however that modifying the position of the parent of an actor /// may change the appearance of the actor because its transformation /// matrix would change. In this case a redraw wouldn't be queued on /// the actor itself so the `EffectPaintFlags::ActorDirty` would still /// not be set. The effect can detect this case by keeping track of the /// last modelview matrix that was used to render the actor and /// veryifying that it remains the same in the next paint. /// /// Any other effects that are layered on top of the passed in effect /// will still be passed the `EffectPaintFlags::ActorDirty` flag. If /// anything queues a redraw on the actor without specifying an effect /// or with an effect that is lower in the chain of effects than this /// one then that will override this call. In that case this effect /// will instead be called with the `EffectPaintFlags::ActorDirty` /// flag set. fn queue_repaint(&self); } impl<O: IsA<Effect>> EffectExt for O { fn queue_repaint(&self) { unsafe { ffi::clutter_effect_queue_repaint(self.as_ref().to_glib_none().0); } } } impl fmt::Display for Effect { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Effect") } }