use bitflags::bitflags;
use crate::Matrix;
use crate::Vector;
use crate::Vector3D;
use crate::media::IBrush;
use crate::media::IImmutableEffect;
use crate::media::RenderOptions;
use crate::media::TextOptions;
use crate::numerics::Quaternion;
use crate::platform::IGeometryImpl;
use crate::rendering::composition::CompositionBackfaceVisibility;
use crate::rendering::composition::CompositionBorderMode;
use crate::rendering::composition::CompositionCompositeMode;
use crate::rendering::composition::ICompositionObject;
use crate::rendering::composition::ICompositionObjectHost;
use crate::rendering::composition::animations::AnimationInstanceFactory;
use crate::rendering::composition::animations::ICompositionAnimation;
use crate::rendering::composition::expressions::ExpressionVariant;
use crate::rendering::composition::server::AsServerRenderResource;
use crate::rendering::composition::server::CompositionProperty;
use crate::rendering::composition::server::CompositionPropertyOf;
use crate::rendering::composition::server::IServerAnimatedPropertyHost;
use crate::rendering::composition::server::IServerObject;
use crate::rendering::composition::server::ServerPropertyValue;
use crate::rendering::composition::server::ServerResourceRef;
use crate::rendering::composition::server::ServerValueChange;
use crate::rendering::composition::server::props_of;
use crate::rendering::composition::server::read_resource;
use crate::rendering::composition::server::read_server_object;
use crate::rendering::composition::transport::BatchResource;
use crate::rendering::composition::transport::BatchStreamReader;
use crate::rendering::composition::transport::BatchStreamWriter;
use crate::rendering::composition::transport::BatchValue;
use crate::rendering::composition::transport::BatchValueReader;
use crate::utilities::OptionCell;
use std::any::Any;
use std::any::TypeId;
use std::cell::Cell;
use std::cell::OnceCell;
use std::rc::Rc;
use std::sync::Arc;
use std::sync::OnceLock;
use std::time::Duration;
bitflags! {
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CompositionVisualChangedFields: u64 {
const ROOT = 1;
const PARENT = 2;
const VISIBLE = 4;
const VISIBLE_ANIMATED = 8;
const OPACITY = 16;
const OPACITY_ANIMATED = 32;
const CLIP = 64;
const CLIP_TO_BOUNDS = 128;
const CLIP_TO_BOUNDS_ANIMATED = 256;
const OFFSET = 512;
const OFFSET_ANIMATED = 1024;
const TRANSLATION = 2048;
const TRANSLATION_ANIMATED = 4096;
const SIZE = 8192;
const SIZE_ANIMATED = 16384;
const ANCHOR_POINT = 32768;
const ANCHOR_POINT_ANIMATED = 65536;
const CENTER_POINT = 131072;
const CENTER_POINT_ANIMATED = 262144;
const ROTATION_ANGLE = 524288;
const ROTATION_ANGLE_ANIMATED = 1048576;
const ORIENTATION = 2097152;
const ORIENTATION_ANIMATED = 4194304;
const SCALE = 8388608;
const SCALE_ANIMATED = 16777216;
const TRANSFORM_MATRIX = 33554432;
const TRANSFORM_MATRIX_ANIMATED = 67108864;
const ADORNED_VISUAL = 134217728;
const ADORNER_IS_CLIPPED = 268435456;
const OPACITY_MASK_BRUSH = 536870912;
const EFFECT = 1073741824;
const RENDER_OPTIONS = 2147483648;
const TEXT_OPTIONS = 4294967296;
const CACHE_MODE = 8589934592;
const COMPOSITION_CLIP = 17179869184;
const ROTATION_AXIS = 34359738368;
const ROTATION_AXIS_ANIMATED = 68719476736;
const RELATIVE_OFFSET_ADJUSTMENT = 137438953472;
const RELATIVE_OFFSET_ADJUSTMENT_ANIMATED = 274877906944;
const RELATIVE_SIZE_ADJUSTMENT = 549755813888;
const RELATIVE_SIZE_ADJUSTMENT_ANIMATED = 1099511627776;
const IS_HIT_TEST_VISIBLE = 2199023255552;
const IS_PIXEL_SNAPPING_ENABLED = 4398046511104;
const BORDER_MODE = 8796093022208;
const BACKFACE_VISIBILITY = 17592186044416;
const COMPOSITE_MODE = 35184372088832;
const PARENT_FOR_TRANSFORM = 70368744177664;
}
}
impl BatchValue for CompositionVisualChangedFields {
#[inline]
fn write_to(&self, out: &mut Vec<u8>) {
self.bits().write_to(out);
}
#[inline]
fn read_from(input: &mut BatchValueReader<'_>) -> Self {
CompositionVisualChangedFields::from_bits_retain(u64::read_from(input))
}
}
pub trait CompositionVisualHooks: ICompositionObjectHost {
fn initialize_defaults_extra(&self) {}
fn on_animated_property_assigned(&self, _property_name: &str) {}
fn validate_root_change(&self, _old_value: &Option<Rc<dyn ICompositionObject>>, _new_value: &Option<Rc<dyn ICompositionObject>>) {}
fn on_root_changed(&self) {}
fn on_root_changing(&self) {}
fn validate_parent_change(&self, _old_value: &Option<Rc<dyn ICompositionObject>>, _new_value: &Option<Rc<dyn ICompositionObject>>) {}
fn on_parent_changed(&self) {}
fn on_parent_changing(&self) {}
fn validate_visible_change(&self, _old_value: bool, _new_value: bool) {}
fn on_visible_changed(&self) {}
fn on_visible_changing(&self) {}
fn validate_opacity_change(&self, _old_value: f32, _new_value: f32) {}
fn on_opacity_changed(&self) {}
fn on_opacity_changing(&self) {}
fn validate_clip_change(&self, _old_value: &Option<Arc<dyn IGeometryImpl>>, _new_value: &Option<Arc<dyn IGeometryImpl>>) {}
fn on_clip_changed(&self) {}
fn on_clip_changing(&self) {}
fn validate_clip_to_bounds_change(&self, _old_value: bool, _new_value: bool) {}
fn on_clip_to_bounds_changed(&self) {}
fn on_clip_to_bounds_changing(&self) {}
fn validate_offset_change(&self, _old_value: Vector3D, _new_value: Vector3D) {}
fn on_offset_changed(&self) {}
fn on_offset_changing(&self) {}
fn validate_translation_change(&self, _old_value: Vector3D, _new_value: Vector3D) {}
fn on_translation_changed(&self) {}
fn on_translation_changing(&self) {}
fn validate_size_change(&self, _old_value: Vector, _new_value: Vector) {}
fn on_size_changed(&self) {}
fn on_size_changing(&self) {}
fn validate_anchor_point_change(&self, _old_value: Vector, _new_value: Vector) {}
fn on_anchor_point_changed(&self) {}
fn on_anchor_point_changing(&self) {}
fn validate_center_point_change(&self, _old_value: Vector3D, _new_value: Vector3D) {}
fn on_center_point_changed(&self) {}
fn on_center_point_changing(&self) {}
fn validate_rotation_angle_change(&self, _old_value: f32, _new_value: f32) {}
fn on_rotation_angle_changed(&self) {}
fn on_rotation_angle_changing(&self) {}
fn validate_orientation_change(&self, _old_value: Quaternion, _new_value: Quaternion) {}
fn on_orientation_changed(&self) {}
fn on_orientation_changing(&self) {}
fn validate_scale_change(&self, _old_value: Vector3D, _new_value: Vector3D) {}
fn on_scale_changed(&self) {}
fn on_scale_changing(&self) {}
fn validate_transform_matrix_change(&self, _old_value: Matrix, _new_value: Matrix) {}
fn on_transform_matrix_changed(&self) {}
fn on_transform_matrix_changing(&self) {}
fn validate_adorned_visual_change(&self, _old_value: &Option<Rc<dyn ICompositionObject>>, _new_value: &Option<Rc<dyn ICompositionObject>>) {}
fn on_adorned_visual_changed(&self) {}
fn on_adorned_visual_changing(&self) {}
fn validate_adorner_is_clipped_change(&self, _old_value: bool, _new_value: bool) {}
fn on_adorner_is_clipped_changed(&self) {}
fn on_adorner_is_clipped_changing(&self) {}
fn validate_opacity_mask_brush_change(&self, _old_value: &Option<BatchResource<dyn IBrush>>, _new_value: &Option<BatchResource<dyn IBrush>>) {}
fn on_opacity_mask_brush_changed(&self) {}
fn on_opacity_mask_brush_changing(&self) {}
fn validate_effect_change(&self, _old_value: &Option<Arc<dyn IImmutableEffect>>, _new_value: &Option<Arc<dyn IImmutableEffect>>) {}
fn on_effect_changed(&self) {}
fn on_effect_changing(&self) {}
fn validate_render_options_change(&self, _old_value: RenderOptions, _new_value: RenderOptions) {}
fn on_render_options_changed(&self) {}
fn on_render_options_changing(&self) {}
fn validate_text_options_change(&self, _old_value: TextOptions, _new_value: TextOptions) {}
fn on_text_options_changed(&self) {}
fn on_text_options_changing(&self) {}
fn validate_cache_mode_change(&self, _old_value: &Option<Rc<dyn ICompositionObject>>, _new_value: &Option<Rc<dyn ICompositionObject>>) {}
fn on_cache_mode_changed(&self) {}
fn on_cache_mode_changing(&self) {}
fn validate_composition_clip_change(&self, _old_value: &Option<Rc<dyn ICompositionObject>>, _new_value: &Option<Rc<dyn ICompositionObject>>) {}
fn on_composition_clip_changed(&self) {}
fn on_composition_clip_changing(&self) {}
fn validate_rotation_axis_change(&self, _old_value: Vector3D, _new_value: Vector3D) {}
fn on_rotation_axis_changed(&self) {}
fn on_rotation_axis_changing(&self) {}
fn validate_relative_offset_adjustment_change(&self, _old_value: Vector3D, _new_value: Vector3D) {}
fn on_relative_offset_adjustment_changed(&self) {}
fn on_relative_offset_adjustment_changing(&self) {}
fn validate_relative_size_adjustment_change(&self, _old_value: Vector, _new_value: Vector) {}
fn on_relative_size_adjustment_changed(&self) {}
fn on_relative_size_adjustment_changing(&self) {}
fn validate_is_hit_test_visible_change(&self, _old_value: bool, _new_value: bool) {}
fn on_is_hit_test_visible_changed(&self) {}
fn on_is_hit_test_visible_changing(&self) {}
fn validate_is_pixel_snapping_enabled_change(&self, _old_value: bool, _new_value: bool) {}
fn on_is_pixel_snapping_enabled_changed(&self) {}
fn on_is_pixel_snapping_enabled_changing(&self) {}
fn validate_border_mode_change(&self, _old_value: CompositionBorderMode, _new_value: CompositionBorderMode) {}
fn on_border_mode_changed(&self) {}
fn on_border_mode_changing(&self) {}
fn validate_backface_visibility_change(&self, _old_value: CompositionBackfaceVisibility, _new_value: CompositionBackfaceVisibility) {}
fn on_backface_visibility_changed(&self) {}
fn on_backface_visibility_changing(&self) {}
fn validate_composite_mode_change(&self, _old_value: CompositionCompositeMode, _new_value: CompositionCompositeMode) {}
fn on_composite_mode_changed(&self) {}
fn on_composite_mode_changing(&self) {}
fn validate_parent_for_transform_change(&self, _old_value: &Option<Rc<dyn ICompositionObject>>, _new_value: &Option<Rc<dyn ICompositionObject>>) {}
fn on_parent_for_transform_changed(&self) {}
fn on_parent_for_transform_changing(&self) {}
}
pub struct CompositionVisualProps {
changed_fields_of_composition_visual: Cell<CompositionVisualChangedFields>,
root: OptionCell<Rc<dyn ICompositionObject>>,
parent: OptionCell<Rc<dyn ICompositionObject>>,
visible: Cell<bool>,
opacity: Cell<f32>,
clip_to_bounds: Cell<bool>,
offset: Cell<Vector3D>,
size: Cell<Vector>,
render_options: Cell<RenderOptions>,
text_options: Cell<TextOptions>,
is_hit_test_visible: Cell<bool>,
is_pixel_snapping_enabled: Cell<bool>,
rare: OnceCell<Box<CompositionVisualRareProps>>,
}
impl Default for CompositionVisualProps {
fn default() -> Self {
Self::new()
}
}
impl CompositionVisualProps {
pub fn new() -> Self {
Self {
changed_fields_of_composition_visual: Cell::new(CompositionVisualChangedFields::empty()),
root: OptionCell::new(),
parent: OptionCell::new(),
visible: Cell::new(Default::default()),
opacity: Cell::new(Default::default()),
clip_to_bounds: Cell::new(Default::default()),
offset: Cell::new(Default::default()),
size: Cell::new(Default::default()),
render_options: Cell::new(Default::default()),
text_options: Cell::new(Default::default()),
is_hit_test_visible: Cell::new(Default::default()),
is_pixel_snapping_enabled: Cell::new(Default::default()),
rare: OnceCell::new(),
}
}
pub fn initialize_defaults(&self, host: &dyn CompositionVisualHooks) {
self.initialize_own_defaults(host);
}
pub fn initialize_own_defaults(&self, host: &dyn CompositionVisualHooks) {
CompositionVisualHooks::initialize_defaults_extra(host);
self.visible.set(true);
self.opacity.set(1.0);
self.clip_to_bounds.set(true);
self.is_hit_test_visible.set(true);
host.register_for_serialization();
}
pub fn root(&self) -> Option<Rc<dyn ICompositionObject>> {
self.root.get()
}
pub fn set_root(&self, host: &dyn CompositionVisualHooks, value: Option<Rc<dyn ICompositionObject>>) {
let mut changed = false;
let old_value = self.root.get();
if old_value.differs(&value) {
CompositionVisualHooks::validate_root_change(host, &old_value, &value);
CompositionVisualHooks::on_root_changing(host);
changed = true;
self.root.set(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROOT);
host.register_for_serialization();
}
self.root.set(value);
if changed {
CompositionVisualHooks::on_root_changed(host);
}
}
pub fn parent(&self) -> Option<Rc<dyn ICompositionObject>> {
self.parent.get()
}
pub fn set_parent(&self, host: &dyn CompositionVisualHooks, value: Option<Rc<dyn ICompositionObject>>) {
let mut changed = false;
let old_value = self.parent.get();
if old_value.differs(&value) {
CompositionVisualHooks::validate_parent_change(host, &old_value, &value);
CompositionVisualHooks::on_parent_changing(host);
changed = true;
self.parent.set(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::PARENT);
host.register_for_serialization();
}
self.parent.set(value);
if changed {
CompositionVisualHooks::on_parent_changed(host);
}
}
pub fn visible(&self) -> bool {
self.visible.get()
}
pub fn set_visible(&self, host: &dyn CompositionVisualHooks, value: bool) {
let mut changed = false;
let old_value = self.visible.get();
CompositionVisualHooks::on_animated_property_assigned(host, "Visible");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_visible_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::VISIBLE) & !CompositionVisualChangedFields::VISIBLE_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_visible_change(host, old_value, value);
CompositionVisualHooks::on_visible_changing(host);
changed = true;
self.visible.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::VISIBLE);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_visible_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::VISIBLE_ANIMATED);
if let Some(animation) = host.implicit_animation("Visible") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::VISIBLE_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_visible_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "Visible", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::VISIBLE_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::VISIBLE);
}
}
}
self.visible.set(value);
if changed {
CompositionVisualHooks::on_visible_changed(host);
}
}
pub fn opacity(&self) -> f32 {
self.opacity.get()
}
pub fn set_opacity(&self, host: &dyn CompositionVisualHooks, value: f32) {
let mut changed = false;
let old_value = self.opacity.get();
CompositionVisualHooks::on_animated_property_assigned(host, "Opacity");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_opacity_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OPACITY) & !CompositionVisualChangedFields::OPACITY_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_opacity_change(host, old_value, value);
CompositionVisualHooks::on_opacity_changing(host);
changed = true;
self.opacity.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OPACITY);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_opacity_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::OPACITY_ANIMATED);
if let Some(animation) = host.implicit_animation("Opacity") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OPACITY_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_opacity_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "Opacity", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::OPACITY_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::OPACITY);
}
}
}
self.opacity.set(value);
if changed {
CompositionVisualHooks::on_opacity_changed(host);
}
}
pub fn clip(&self) -> Option<Arc<dyn IGeometryImpl>> {
self.rare_clip()
}
pub fn set_clip(&self, host: &dyn CompositionVisualHooks, value: Option<Arc<dyn IGeometryImpl>>) {
let mut changed = false;
let old_value = self.rare_clip();
if old_value.differs(&value) {
CompositionVisualHooks::validate_clip_change(host, &old_value, &value);
CompositionVisualHooks::on_clip_changing(host);
changed = true;
self.store_rare_clip(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CLIP);
host.register_for_serialization();
}
self.store_rare_clip(value);
if changed {
CompositionVisualHooks::on_clip_changed(host);
}
}
pub fn clip_to_bounds(&self) -> bool {
self.clip_to_bounds.get()
}
pub fn set_clip_to_bounds(&self, host: &dyn CompositionVisualHooks, value: bool) {
let mut changed = false;
let old_value = self.clip_to_bounds.get();
CompositionVisualHooks::on_animated_property_assigned(host, "ClipToBounds");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_clip_to_bounds_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CLIP_TO_BOUNDS) & !CompositionVisualChangedFields::CLIP_TO_BOUNDS_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_clip_to_bounds_change(host, old_value, value);
CompositionVisualHooks::on_clip_to_bounds_changing(host);
changed = true;
self.clip_to_bounds.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CLIP_TO_BOUNDS);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_clip_to_bounds_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::CLIP_TO_BOUNDS_ANIMATED);
if let Some(animation) = host.implicit_animation("ClipToBounds") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CLIP_TO_BOUNDS_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_clip_to_bounds_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "ClipToBounds", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::CLIP_TO_BOUNDS_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::CLIP_TO_BOUNDS);
}
}
}
self.clip_to_bounds.set(value);
if changed {
CompositionVisualHooks::on_clip_to_bounds_changed(host);
}
}
pub fn offset(&self) -> Vector3D {
self.offset.get()
}
pub fn set_offset(&self, host: &dyn CompositionVisualHooks, value: Vector3D) {
let mut changed = false;
let old_value = self.offset.get();
CompositionVisualHooks::on_animated_property_assigned(host, "Offset");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_offset_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OFFSET) & !CompositionVisualChangedFields::OFFSET_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_offset_change(host, old_value, value);
CompositionVisualHooks::on_offset_changing(host);
changed = true;
self.offset.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OFFSET);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_offset_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::OFFSET_ANIMATED);
if let Some(animation) = host.implicit_animation("Offset") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OFFSET_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_offset_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "Offset", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::OFFSET_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::OFFSET);
}
}
}
self.offset.set(value);
if changed {
CompositionVisualHooks::on_offset_changed(host);
}
}
pub fn translation(&self) -> Vector3D {
self.rare_translation()
}
pub fn set_translation(&self, host: &dyn CompositionVisualHooks, value: Vector3D) {
let mut changed = false;
let old_value = self.rare_translation();
CompositionVisualHooks::on_animated_property_assigned(host, "Translation");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_translation_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TRANSLATION) & !CompositionVisualChangedFields::TRANSLATION_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_translation_change(host, old_value, value);
CompositionVisualHooks::on_translation_changing(host);
changed = true;
self.store_rare_translation(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TRANSLATION);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_translation_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::TRANSLATION_ANIMATED);
if let Some(animation) = host.implicit_animation("Translation") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TRANSLATION_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_translation_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "Translation", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::TRANSLATION_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::TRANSLATION);
}
}
}
self.store_rare_translation(value);
if changed {
CompositionVisualHooks::on_translation_changed(host);
}
}
pub fn size(&self) -> Vector {
self.size.get()
}
pub fn set_size(&self, host: &dyn CompositionVisualHooks, value: Vector) {
let mut changed = false;
let old_value = self.size.get();
CompositionVisualHooks::on_animated_property_assigned(host, "Size");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_size_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::SIZE) & !CompositionVisualChangedFields::SIZE_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_size_change(host, old_value, value);
CompositionVisualHooks::on_size_changing(host);
changed = true;
self.size.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::SIZE);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_size_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::SIZE_ANIMATED);
if let Some(animation) = host.implicit_animation("Size") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::SIZE_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_size_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "Size", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::SIZE_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::SIZE);
}
}
}
self.size.set(value);
if changed {
CompositionVisualHooks::on_size_changed(host);
}
}
pub fn anchor_point(&self) -> Vector {
self.rare_anchor_point()
}
pub fn set_anchor_point(&self, host: &dyn CompositionVisualHooks, value: Vector) {
let mut changed = false;
let old_value = self.rare_anchor_point();
CompositionVisualHooks::on_animated_property_assigned(host, "AnchorPoint");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_anchor_point_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ANCHOR_POINT) & !CompositionVisualChangedFields::ANCHOR_POINT_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_anchor_point_change(host, old_value, value);
CompositionVisualHooks::on_anchor_point_changing(host);
changed = true;
self.store_rare_anchor_point(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ANCHOR_POINT);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_anchor_point_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::ANCHOR_POINT_ANIMATED);
if let Some(animation) = host.implicit_animation("AnchorPoint") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ANCHOR_POINT_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_anchor_point_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "AnchorPoint", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::ANCHOR_POINT_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::ANCHOR_POINT);
}
}
}
self.store_rare_anchor_point(value);
if changed {
CompositionVisualHooks::on_anchor_point_changed(host);
}
}
pub fn center_point(&self) -> Vector3D {
self.rare_center_point()
}
pub fn set_center_point(&self, host: &dyn CompositionVisualHooks, value: Vector3D) {
let mut changed = false;
let old_value = self.rare_center_point();
CompositionVisualHooks::on_animated_property_assigned(host, "CenterPoint");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_center_point_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CENTER_POINT) & !CompositionVisualChangedFields::CENTER_POINT_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_center_point_change(host, old_value, value);
CompositionVisualHooks::on_center_point_changing(host);
changed = true;
self.store_rare_center_point(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CENTER_POINT);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_center_point_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::CENTER_POINT_ANIMATED);
if let Some(animation) = host.implicit_animation("CenterPoint") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CENTER_POINT_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_center_point_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "CenterPoint", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::CENTER_POINT_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::CENTER_POINT);
}
}
}
self.store_rare_center_point(value);
if changed {
CompositionVisualHooks::on_center_point_changed(host);
}
}
pub fn rotation_angle(&self) -> f32 {
self.rare_rotation_angle()
}
pub fn set_rotation_angle(&self, host: &dyn CompositionVisualHooks, value: f32) {
let mut changed = false;
let old_value = self.rare_rotation_angle();
CompositionVisualHooks::on_animated_property_assigned(host, "RotationAngle");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_rotation_angle_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROTATION_ANGLE) & !CompositionVisualChangedFields::ROTATION_ANGLE_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_rotation_angle_change(host, old_value, value);
CompositionVisualHooks::on_rotation_angle_changing(host);
changed = true;
self.store_rare_rotation_angle(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROTATION_ANGLE);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_rotation_angle_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::ROTATION_ANGLE_ANIMATED);
if let Some(animation) = host.implicit_animation("RotationAngle") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROTATION_ANGLE_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_rotation_angle_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "RotationAngle", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::ROTATION_ANGLE_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::ROTATION_ANGLE);
}
}
}
self.store_rare_rotation_angle(value);
if changed {
CompositionVisualHooks::on_rotation_angle_changed(host);
}
}
pub fn orientation(&self) -> Quaternion {
self.rare_orientation()
}
pub fn set_orientation(&self, host: &dyn CompositionVisualHooks, value: Quaternion) {
let mut changed = false;
let old_value = self.rare_orientation();
CompositionVisualHooks::on_animated_property_assigned(host, "Orientation");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_orientation_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ORIENTATION) & !CompositionVisualChangedFields::ORIENTATION_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_orientation_change(host, old_value, value);
CompositionVisualHooks::on_orientation_changing(host);
changed = true;
self.store_rare_orientation(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ORIENTATION);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_orientation_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::ORIENTATION_ANIMATED);
if let Some(animation) = host.implicit_animation("Orientation") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ORIENTATION_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_orientation_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "Orientation", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::ORIENTATION_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::ORIENTATION);
}
}
}
self.store_rare_orientation(value);
if changed {
CompositionVisualHooks::on_orientation_changed(host);
}
}
pub fn scale(&self) -> Vector3D {
self.rare_scale()
}
pub fn set_scale(&self, host: &dyn CompositionVisualHooks, value: Vector3D) {
let mut changed = false;
let old_value = self.rare_scale();
CompositionVisualHooks::on_animated_property_assigned(host, "Scale");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_scale_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::SCALE) & !CompositionVisualChangedFields::SCALE_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_scale_change(host, old_value, value);
CompositionVisualHooks::on_scale_changing(host);
changed = true;
self.store_rare_scale(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::SCALE);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_scale_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::SCALE_ANIMATED);
if let Some(animation) = host.implicit_animation("Scale") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::SCALE_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_scale_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "Scale", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::SCALE_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::SCALE);
}
}
}
self.store_rare_scale(value);
if changed {
CompositionVisualHooks::on_scale_changed(host);
}
}
pub fn transform_matrix(&self) -> Matrix {
self.rare_transform_matrix()
}
pub fn set_transform_matrix(&self, host: &dyn CompositionVisualHooks, value: Matrix) {
let mut changed = false;
let old_value = self.rare_transform_matrix();
CompositionVisualHooks::on_animated_property_assigned(host, "TransformMatrix");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_transform_matrix_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TRANSFORM_MATRIX) & !CompositionVisualChangedFields::TRANSFORM_MATRIX_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_transform_matrix_change(host, old_value, value);
CompositionVisualHooks::on_transform_matrix_changing(host);
changed = true;
self.store_rare_transform_matrix(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TRANSFORM_MATRIX);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_transform_matrix_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::TRANSFORM_MATRIX_ANIMATED);
if let Some(animation) = host.implicit_animation("TransformMatrix") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TRANSFORM_MATRIX_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_transform_matrix_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "TransformMatrix", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::TRANSFORM_MATRIX_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::TRANSFORM_MATRIX);
}
}
}
self.store_rare_transform_matrix(value);
if changed {
CompositionVisualHooks::on_transform_matrix_changed(host);
}
}
pub fn adorned_visual(&self) -> Option<Rc<dyn ICompositionObject>> {
self.rare_adorned_visual()
}
pub fn set_adorned_visual(&self, host: &dyn CompositionVisualHooks, value: Option<Rc<dyn ICompositionObject>>) {
let mut changed = false;
let old_value = self.rare_adorned_visual();
if old_value.differs(&value) {
CompositionVisualHooks::validate_adorned_visual_change(host, &old_value, &value);
CompositionVisualHooks::on_adorned_visual_changing(host);
changed = true;
self.store_rare_adorned_visual(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ADORNED_VISUAL);
host.register_for_serialization();
}
self.store_rare_adorned_visual(value);
if changed {
CompositionVisualHooks::on_adorned_visual_changed(host);
}
}
pub fn adorner_is_clipped(&self) -> bool {
self.rare_adorner_is_clipped()
}
pub fn set_adorner_is_clipped(&self, host: &dyn CompositionVisualHooks, value: bool) {
let mut changed = false;
let old_value = self.rare_adorner_is_clipped();
if old_value.differs(&value) {
CompositionVisualHooks::validate_adorner_is_clipped_change(host, old_value, value);
CompositionVisualHooks::on_adorner_is_clipped_changing(host);
changed = true;
self.store_rare_adorner_is_clipped(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ADORNER_IS_CLIPPED);
host.register_for_serialization();
}
self.store_rare_adorner_is_clipped(value);
if changed {
CompositionVisualHooks::on_adorner_is_clipped_changed(host);
}
}
pub fn opacity_mask_brush_transport_field(&self) -> Option<BatchResource<dyn IBrush>> {
self.rare_opacity_mask_brush()
}
pub fn set_opacity_mask_brush_transport_field(&self, host: &dyn CompositionVisualHooks, value: Option<BatchResource<dyn IBrush>>) {
let mut changed = false;
let old_value = self.rare_opacity_mask_brush();
if old_value.differs(&value) {
CompositionVisualHooks::validate_opacity_mask_brush_change(host, &old_value, &value);
CompositionVisualHooks::on_opacity_mask_brush_changing(host);
changed = true;
self.store_rare_opacity_mask_brush(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OPACITY_MASK_BRUSH);
host.register_for_serialization();
}
self.store_rare_opacity_mask_brush(value);
if changed {
CompositionVisualHooks::on_opacity_mask_brush_changed(host);
}
}
pub fn effect(&self) -> Option<Arc<dyn IImmutableEffect>> {
self.rare_effect()
}
pub fn set_effect(&self, host: &dyn CompositionVisualHooks, value: Option<Arc<dyn IImmutableEffect>>) {
let mut changed = false;
let old_value = self.rare_effect();
if old_value.differs(&value) {
CompositionVisualHooks::validate_effect_change(host, &old_value, &value);
CompositionVisualHooks::on_effect_changing(host);
changed = true;
self.store_rare_effect(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::EFFECT);
host.register_for_serialization();
}
self.store_rare_effect(value);
if changed {
CompositionVisualHooks::on_effect_changed(host);
}
}
pub fn render_options(&self) -> RenderOptions {
self.render_options.get()
}
pub fn set_render_options(&self, host: &dyn CompositionVisualHooks, value: RenderOptions) {
let mut changed = false;
let old_value = self.render_options.get();
if old_value.differs(&value) {
CompositionVisualHooks::validate_render_options_change(host, old_value, value);
CompositionVisualHooks::on_render_options_changing(host);
changed = true;
self.render_options.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RENDER_OPTIONS);
host.register_for_serialization();
}
self.render_options.set(value);
if changed {
CompositionVisualHooks::on_render_options_changed(host);
}
}
pub fn text_options(&self) -> TextOptions {
self.text_options.get()
}
pub fn set_text_options(&self, host: &dyn CompositionVisualHooks, value: TextOptions) {
let mut changed = false;
let old_value = self.text_options.get();
if old_value.differs(&value) {
CompositionVisualHooks::validate_text_options_change(host, old_value, value);
CompositionVisualHooks::on_text_options_changing(host);
changed = true;
self.text_options.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TEXT_OPTIONS);
host.register_for_serialization();
}
self.text_options.set(value);
if changed {
CompositionVisualHooks::on_text_options_changed(host);
}
}
pub fn cache_mode(&self) -> Option<Rc<dyn ICompositionObject>> {
self.rare_cache_mode()
}
pub fn set_cache_mode(&self, host: &dyn CompositionVisualHooks, value: Option<Rc<dyn ICompositionObject>>) {
let mut changed = false;
let old_value = self.rare_cache_mode();
if old_value.differs(&value) {
CompositionVisualHooks::validate_cache_mode_change(host, &old_value, &value);
CompositionVisualHooks::on_cache_mode_changing(host);
changed = true;
self.store_rare_cache_mode(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CACHE_MODE);
host.register_for_serialization();
}
self.store_rare_cache_mode(value);
if changed {
CompositionVisualHooks::on_cache_mode_changed(host);
}
}
pub fn composition_clip(&self) -> Option<Rc<dyn ICompositionObject>> {
self.rare_composition_clip()
}
pub fn set_composition_clip(&self, host: &dyn CompositionVisualHooks, value: Option<Rc<dyn ICompositionObject>>) {
let mut changed = false;
let old_value = self.rare_composition_clip();
if old_value.differs(&value) {
CompositionVisualHooks::validate_composition_clip_change(host, &old_value, &value);
CompositionVisualHooks::on_composition_clip_changing(host);
changed = true;
self.store_rare_composition_clip(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::COMPOSITION_CLIP);
host.register_for_serialization();
}
self.store_rare_composition_clip(value);
if changed {
CompositionVisualHooks::on_composition_clip_changed(host);
}
}
pub fn rotation_axis(&self) -> Vector3D {
self.rare_rotation_axis()
}
pub fn set_rotation_axis(&self, host: &dyn CompositionVisualHooks, value: Vector3D) {
let mut changed = false;
let old_value = self.rare_rotation_axis();
CompositionVisualHooks::on_animated_property_assigned(host, "RotationAxis");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_rotation_axis_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROTATION_AXIS) & !CompositionVisualChangedFields::ROTATION_AXIS_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_rotation_axis_change(host, old_value, value);
CompositionVisualHooks::on_rotation_axis_changing(host);
changed = true;
self.store_rare_rotation_axis(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROTATION_AXIS);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_rotation_axis_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::ROTATION_AXIS_ANIMATED);
if let Some(animation) = host.implicit_animation("RotationAxis") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROTATION_AXIS_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_rotation_axis_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "RotationAxis", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::ROTATION_AXIS_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::ROTATION_AXIS);
}
}
}
self.store_rare_rotation_axis(value);
if changed {
CompositionVisualHooks::on_rotation_axis_changed(host);
}
}
pub fn relative_offset_adjustment(&self) -> Vector3D {
self.rare_relative_offset_adjustment()
}
pub fn set_relative_offset_adjustment(&self, host: &dyn CompositionVisualHooks, value: Vector3D) {
let mut changed = false;
let old_value = self.rare_relative_offset_adjustment();
CompositionVisualHooks::on_animated_property_assigned(host, "RelativeOffsetAdjustment");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_relative_offset_adjustment_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT) & !CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_relative_offset_adjustment_change(host, old_value, value);
CompositionVisualHooks::on_relative_offset_adjustment_changing(host);
changed = true;
self.store_rare_relative_offset_adjustment(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_relative_offset_adjustment_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT_ANIMATED);
if let Some(animation) = host.implicit_animation("RelativeOffsetAdjustment") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_relative_offset_adjustment_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "RelativeOffsetAdjustment", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT);
}
}
}
self.store_rare_relative_offset_adjustment(value);
if changed {
CompositionVisualHooks::on_relative_offset_adjustment_changed(host);
}
}
pub fn relative_size_adjustment(&self) -> Vector {
self.rare_relative_size_adjustment()
}
pub fn set_relative_size_adjustment(&self, host: &dyn CompositionVisualHooks, value: Vector) {
let mut changed = false;
let old_value = self.rare_relative_size_adjustment();
CompositionVisualHooks::on_animated_property_assigned(host, "RelativeSizeAdjustment");
if !old_value.differs(&value) {
host.pending_animations().remove(ServerCompositionVisualProps::id_of_relative_size_adjustment_property().base());
self.changed_fields_of_composition_visual.set((self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT) & !CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT_ANIMATED);
host.register_for_serialization();
}
if old_value.differs(&value) {
CompositionVisualHooks::validate_relative_size_adjustment_change(host, old_value, value);
CompositionVisualHooks::on_relative_size_adjustment_changing(host);
changed = true;
self.store_rare_relative_size_adjustment(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT);
host.register_for_serialization();
host.pending_animations().remove(ServerCompositionVisualProps::id_of_relative_size_adjustment_property().base());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT_ANIMATED);
if let Some(animation) = host.implicit_animation("RelativeSizeAdjustment") {
if let Some(a) = animation.as_composition_animation() {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT_ANIMATED);
host.pending_animations().set(
ServerCompositionVisualProps::id_of_relative_size_adjustment_property().base(),
a.create_instance(host.server(), Some(ExpressionVariant::create(value))),
);
}
host.start_animation_group(&animation, "RelativeSizeAdjustment", ExpressionVariant::create(value));
if self.changed_fields_of_composition_visual.get().contains(CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT_ANIMATED) {
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() & !CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT);
}
}
}
self.store_rare_relative_size_adjustment(value);
if changed {
CompositionVisualHooks::on_relative_size_adjustment_changed(host);
}
}
pub fn is_hit_test_visible(&self) -> bool {
self.is_hit_test_visible.get()
}
pub fn set_is_hit_test_visible(&self, host: &dyn CompositionVisualHooks, value: bool) {
let mut changed = false;
let old_value = self.is_hit_test_visible.get();
if old_value.differs(&value) {
CompositionVisualHooks::validate_is_hit_test_visible_change(host, old_value, value);
CompositionVisualHooks::on_is_hit_test_visible_changing(host);
changed = true;
self.is_hit_test_visible.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::IS_HIT_TEST_VISIBLE);
host.register_for_serialization();
}
self.is_hit_test_visible.set(value);
if changed {
CompositionVisualHooks::on_is_hit_test_visible_changed(host);
}
}
pub fn is_pixel_snapping_enabled(&self) -> bool {
self.is_pixel_snapping_enabled.get()
}
pub fn set_is_pixel_snapping_enabled(&self, host: &dyn CompositionVisualHooks, value: bool) {
let mut changed = false;
let old_value = self.is_pixel_snapping_enabled.get();
if old_value.differs(&value) {
CompositionVisualHooks::validate_is_pixel_snapping_enabled_change(host, old_value, value);
CompositionVisualHooks::on_is_pixel_snapping_enabled_changing(host);
changed = true;
self.is_pixel_snapping_enabled.set(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::IS_PIXEL_SNAPPING_ENABLED);
host.register_for_serialization();
}
self.is_pixel_snapping_enabled.set(value);
if changed {
CompositionVisualHooks::on_is_pixel_snapping_enabled_changed(host);
}
}
pub fn border_mode(&self) -> CompositionBorderMode {
self.rare_border_mode()
}
pub fn set_border_mode(&self, host: &dyn CompositionVisualHooks, value: CompositionBorderMode) {
let mut changed = false;
let old_value = self.rare_border_mode();
if old_value.differs(&value) {
CompositionVisualHooks::validate_border_mode_change(host, old_value, value);
CompositionVisualHooks::on_border_mode_changing(host);
changed = true;
self.store_rare_border_mode(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::BORDER_MODE);
host.register_for_serialization();
}
self.store_rare_border_mode(value);
if changed {
CompositionVisualHooks::on_border_mode_changed(host);
}
}
pub fn backface_visibility(&self) -> CompositionBackfaceVisibility {
self.rare_backface_visibility()
}
pub fn set_backface_visibility(&self, host: &dyn CompositionVisualHooks, value: CompositionBackfaceVisibility) {
let mut changed = false;
let old_value = self.rare_backface_visibility();
if old_value.differs(&value) {
CompositionVisualHooks::validate_backface_visibility_change(host, old_value, value);
CompositionVisualHooks::on_backface_visibility_changing(host);
changed = true;
self.store_rare_backface_visibility(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::BACKFACE_VISIBILITY);
host.register_for_serialization();
}
self.store_rare_backface_visibility(value);
if changed {
CompositionVisualHooks::on_backface_visibility_changed(host);
}
}
pub fn composite_mode(&self) -> CompositionCompositeMode {
self.rare_composite_mode()
}
pub fn set_composite_mode(&self, host: &dyn CompositionVisualHooks, value: CompositionCompositeMode) {
let mut changed = false;
let old_value = self.rare_composite_mode();
if old_value.differs(&value) {
CompositionVisualHooks::validate_composite_mode_change(host, old_value, value);
CompositionVisualHooks::on_composite_mode_changing(host);
changed = true;
self.store_rare_composite_mode(value);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::COMPOSITE_MODE);
host.register_for_serialization();
}
self.store_rare_composite_mode(value);
if changed {
CompositionVisualHooks::on_composite_mode_changed(host);
}
}
pub fn parent_for_transform(&self) -> Option<Rc<dyn ICompositionObject>> {
self.rare_parent_for_transform()
}
pub fn set_parent_for_transform(&self, host: &dyn CompositionVisualHooks, value: Option<Rc<dyn ICompositionObject>>) {
let mut changed = false;
let old_value = self.rare_parent_for_transform();
if old_value.differs(&value) {
CompositionVisualHooks::validate_parent_for_transform_change(host, &old_value, &value);
CompositionVisualHooks::on_parent_for_transform_changing(host);
changed = true;
self.store_rare_parent_for_transform(value.clone());
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::PARENT_FOR_TRANSFORM);
host.register_for_serialization();
}
self.store_rare_parent_for_transform(value);
if changed {
CompositionVisualHooks::on_parent_for_transform_changed(host);
}
}
pub fn start_animation(
&self,
host: &dyn CompositionVisualHooks,
property_name: &str,
animation: &dyn ICompositionAnimation,
final_value: Option<ExpressionVariant>,
) -> bool {
if property_name == "Visible" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_visible_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::VISIBLE_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "Opacity" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_opacity_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OPACITY_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "ClipToBounds" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_clip_to_bounds_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CLIP_TO_BOUNDS_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "Offset" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_offset_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::OFFSET_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "Translation" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_translation_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TRANSLATION_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "Size" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_size_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::SIZE_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "AnchorPoint" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_anchor_point_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ANCHOR_POINT_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "CenterPoint" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_center_point_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::CENTER_POINT_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "RotationAngle" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_rotation_angle_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROTATION_ANGLE_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "Orientation" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_orientation_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ORIENTATION_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "Scale" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_scale_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::SCALE_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "TransformMatrix" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_transform_matrix_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::TRANSFORM_MATRIX_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "RotationAxis" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_rotation_axis_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::ROTATION_AXIS_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "RelativeOffsetAdjustment" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_relative_offset_adjustment_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT_ANIMATED);
host.register_for_serialization();
return true;
}
if property_name == "RelativeSizeAdjustment" {
let server = animation.create_instance(host.server(), final_value);
host.pending_animations().set(ServerCompositionVisualProps::id_of_relative_size_adjustment_property().base(), server);
self.changed_fields_of_composition_visual.set(self.changed_fields_of_composition_visual.get() | CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT_ANIMATED);
host.register_for_serialization();
return true;
}
false
}
pub fn serialize_changes_core(&self, host: &dyn CompositionVisualHooks, writer: &mut BatchStreamWriter<'_>) {
let changed = self.changed_fields_of_composition_visual.get();
writer.write(changed);
if changed.contains(CompositionVisualChangedFields::ROOT) {
writer.write_server_object(self.root.get().map(|o| o.server()));
}
if changed.contains(CompositionVisualChangedFields::PARENT) {
writer.write_server_object(self.parent.get().map(|o| o.server()));
}
if changed.contains(CompositionVisualChangedFields::VISIBLE) {
writer.write(self.visible.get());
}
if changed.contains(CompositionVisualChangedFields::VISIBLE_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_visible_property().base()));
}
if changed.contains(CompositionVisualChangedFields::OPACITY) {
writer.write(self.opacity.get());
}
if changed.contains(CompositionVisualChangedFields::OPACITY_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_opacity_property().base()));
}
if changed.contains(CompositionVisualChangedFields::CLIP) {
writer.write_value(self.rare_clip());
}
if changed.contains(CompositionVisualChangedFields::CLIP_TO_BOUNDS) {
writer.write(self.clip_to_bounds.get());
}
if changed.contains(CompositionVisualChangedFields::CLIP_TO_BOUNDS_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_clip_to_bounds_property().base()));
}
if changed.contains(CompositionVisualChangedFields::OFFSET) {
writer.write(self.offset.get());
}
if changed.contains(CompositionVisualChangedFields::OFFSET_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_offset_property().base()));
}
if changed.contains(CompositionVisualChangedFields::TRANSLATION) {
writer.write(self.rare_translation());
}
if changed.contains(CompositionVisualChangedFields::TRANSLATION_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_translation_property().base()));
}
if changed.contains(CompositionVisualChangedFields::SIZE) {
writer.write(self.size.get());
}
if changed.contains(CompositionVisualChangedFields::SIZE_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_size_property().base()));
}
if changed.contains(CompositionVisualChangedFields::ANCHOR_POINT) {
writer.write(self.rare_anchor_point());
}
if changed.contains(CompositionVisualChangedFields::ANCHOR_POINT_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_anchor_point_property().base()));
}
if changed.contains(CompositionVisualChangedFields::CENTER_POINT) {
writer.write(self.rare_center_point());
}
if changed.contains(CompositionVisualChangedFields::CENTER_POINT_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_center_point_property().base()));
}
if changed.contains(CompositionVisualChangedFields::ROTATION_ANGLE) {
writer.write(self.rare_rotation_angle());
}
if changed.contains(CompositionVisualChangedFields::ROTATION_ANGLE_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_rotation_angle_property().base()));
}
if changed.contains(CompositionVisualChangedFields::ORIENTATION) {
writer.write(self.rare_orientation());
}
if changed.contains(CompositionVisualChangedFields::ORIENTATION_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_orientation_property().base()));
}
if changed.contains(CompositionVisualChangedFields::SCALE) {
writer.write(self.rare_scale());
}
if changed.contains(CompositionVisualChangedFields::SCALE_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_scale_property().base()));
}
if changed.contains(CompositionVisualChangedFields::TRANSFORM_MATRIX) {
writer.write(self.rare_transform_matrix());
}
if changed.contains(CompositionVisualChangedFields::TRANSFORM_MATRIX_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_transform_matrix_property().base()));
}
if changed.contains(CompositionVisualChangedFields::ADORNED_VISUAL) {
writer.write_server_object(self.rare_adorned_visual().map(|o| o.server()));
}
if changed.contains(CompositionVisualChangedFields::ADORNER_IS_CLIPPED) {
writer.write(self.rare_adorner_is_clipped());
}
if changed.contains(CompositionVisualChangedFields::OPACITY_MASK_BRUSH) {
writer.write_resource(self.rare_opacity_mask_brush());
}
if changed.contains(CompositionVisualChangedFields::EFFECT) {
writer.write_value(self.rare_effect());
}
if changed.contains(CompositionVisualChangedFields::RENDER_OPTIONS) {
writer.write(self.render_options.get());
}
if changed.contains(CompositionVisualChangedFields::TEXT_OPTIONS) {
writer.write(self.text_options.get());
}
if changed.contains(CompositionVisualChangedFields::CACHE_MODE) {
writer.write_server_object(self.rare_cache_mode().map(|o| o.server()));
}
if changed.contains(CompositionVisualChangedFields::COMPOSITION_CLIP) {
writer.write_server_object(self.rare_composition_clip().map(|o| o.server()));
}
if changed.contains(CompositionVisualChangedFields::ROTATION_AXIS) {
writer.write(self.rare_rotation_axis());
}
if changed.contains(CompositionVisualChangedFields::ROTATION_AXIS_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_rotation_axis_property().base()));
}
if changed.contains(CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT) {
writer.write(self.rare_relative_offset_adjustment());
}
if changed.contains(CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_relative_offset_adjustment_property().base()));
}
if changed.contains(CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT) {
writer.write(self.rare_relative_size_adjustment());
}
if changed.contains(CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT_ANIMATED) {
writer.write_value(host.pending_animations().get_and_remove(ServerCompositionVisualProps::id_of_relative_size_adjustment_property().base()));
}
if changed.contains(CompositionVisualChangedFields::IS_HIT_TEST_VISIBLE) {
writer.write(self.is_hit_test_visible.get());
}
if changed.contains(CompositionVisualChangedFields::IS_PIXEL_SNAPPING_ENABLED) {
writer.write(self.is_pixel_snapping_enabled.get());
}
if changed.contains(CompositionVisualChangedFields::BORDER_MODE) {
writer.write(self.rare_border_mode());
}
if changed.contains(CompositionVisualChangedFields::BACKFACE_VISIBILITY) {
writer.write(self.rare_backface_visibility());
}
if changed.contains(CompositionVisualChangedFields::COMPOSITE_MODE) {
writer.write(self.rare_composite_mode());
}
if changed.contains(CompositionVisualChangedFields::PARENT_FOR_TRANSFORM) {
writer.write_server_object(self.rare_parent_for_transform().map(|o| o.server()));
}
self.changed_fields_of_composition_visual.set(CompositionVisualChangedFields::empty());
}
}
struct CompositionVisualRareProps {
clip: OptionCell<Arc<dyn IGeometryImpl>>,
translation: Cell<Vector3D>,
anchor_point: Cell<Vector>,
center_point: Cell<Vector3D>,
rotation_angle: Cell<f32>,
orientation: Cell<Quaternion>,
scale: Cell<Vector3D>,
transform_matrix: Cell<Matrix>,
adorned_visual: OptionCell<Rc<dyn ICompositionObject>>,
adorner_is_clipped: Cell<bool>,
opacity_mask_brush: OptionCell<BatchResource<dyn IBrush>>,
effect: OptionCell<Arc<dyn IImmutableEffect>>,
cache_mode: OptionCell<Rc<dyn ICompositionObject>>,
composition_clip: OptionCell<Rc<dyn ICompositionObject>>,
rotation_axis: Cell<Vector3D>,
relative_offset_adjustment: Cell<Vector3D>,
relative_size_adjustment: Cell<Vector>,
border_mode: Cell<CompositionBorderMode>,
backface_visibility: Cell<CompositionBackfaceVisibility>,
composite_mode: Cell<CompositionCompositeMode>,
parent_for_transform: OptionCell<Rc<dyn ICompositionObject>>,
}
impl CompositionVisualRareProps {
fn new() -> Self {
Self {
clip: OptionCell::new(),
translation: Cell::new(Default::default()),
anchor_point: Cell::new(Default::default()),
center_point: Cell::new(Default::default()),
rotation_angle: Cell::new(Default::default()),
orientation: Cell::new(Quaternion::IDENTITY),
scale: Cell::new(Vector3D::new(1.0, 1.0, 1.0)),
transform_matrix: Cell::new(Matrix::IDENTITY),
adorned_visual: OptionCell::new(),
adorner_is_clipped: Cell::new(Default::default()),
opacity_mask_brush: OptionCell::new(),
effect: OptionCell::new(),
cache_mode: OptionCell::new(),
composition_clip: OptionCell::new(),
rotation_axis: Cell::new(Vector3D::new(0.0, 0.0, 1.0)),
relative_offset_adjustment: Cell::new(Default::default()),
relative_size_adjustment: Cell::new(Default::default()),
border_mode: Cell::new(Default::default()),
backface_visibility: Cell::new(Default::default()),
composite_mode: Cell::new(Default::default()),
parent_for_transform: OptionCell::new(),
}
}
}
impl CompositionVisualProps {
pub fn has_rare_properties(&self) -> bool {
self.rare.get().is_some()
}
#[cold]
fn rare_block(&self) -> &CompositionVisualRareProps {
self.rare.get_or_init(|| Box::new(CompositionVisualRareProps::new()))
}
#[inline]
fn rare_clip(&self) -> Option<Arc<dyn IGeometryImpl>> {
match self.rare.get() {
Some(rare) => rare.clip.get(),
None => None,
}
}
#[inline]
fn store_rare_clip(&self, value: Option<Arc<dyn IGeometryImpl>>) {
match self.rare.get() {
Some(rare) => rare.clip.set(value),
None => {
if value.is_some() {
self.rare_block().clip.set(value);
}
}
}
}
#[inline]
fn rare_translation(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.translation.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_translation(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.translation.set(value),
None => {
let initial: Vector3D = Default::default();
if value.differs(&initial) {
self.rare_block().translation.set(value);
}
}
}
}
#[inline]
fn rare_anchor_point(&self) -> Vector {
match self.rare.get() {
Some(rare) => rare.anchor_point.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_anchor_point(&self, value: Vector) {
match self.rare.get() {
Some(rare) => rare.anchor_point.set(value),
None => {
let initial: Vector = Default::default();
if value.differs(&initial) {
self.rare_block().anchor_point.set(value);
}
}
}
}
#[inline]
fn rare_center_point(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.center_point.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_center_point(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.center_point.set(value),
None => {
let initial: Vector3D = Default::default();
if value.differs(&initial) {
self.rare_block().center_point.set(value);
}
}
}
}
#[inline]
fn rare_rotation_angle(&self) -> f32 {
match self.rare.get() {
Some(rare) => rare.rotation_angle.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_rotation_angle(&self, value: f32) {
match self.rare.get() {
Some(rare) => rare.rotation_angle.set(value),
None => {
let initial: f32 = Default::default();
if value.differs(&initial) {
self.rare_block().rotation_angle.set(value);
}
}
}
}
#[inline]
fn rare_orientation(&self) -> Quaternion {
match self.rare.get() {
Some(rare) => rare.orientation.get(),
None => Quaternion::IDENTITY,
}
}
#[inline]
fn store_rare_orientation(&self, value: Quaternion) {
match self.rare.get() {
Some(rare) => rare.orientation.set(value),
None => {
let initial: Quaternion = Quaternion::IDENTITY;
if value.differs(&initial) {
self.rare_block().orientation.set(value);
}
}
}
}
#[inline]
fn rare_scale(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.scale.get(),
None => Vector3D::new(1.0, 1.0, 1.0),
}
}
#[inline]
fn store_rare_scale(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.scale.set(value),
None => {
let initial: Vector3D = Vector3D::new(1.0, 1.0, 1.0);
if value.differs(&initial) {
self.rare_block().scale.set(value);
}
}
}
}
#[inline]
fn rare_transform_matrix(&self) -> Matrix {
match self.rare.get() {
Some(rare) => rare.transform_matrix.get(),
None => Matrix::IDENTITY,
}
}
#[inline]
fn store_rare_transform_matrix(&self, value: Matrix) {
match self.rare.get() {
Some(rare) => rare.transform_matrix.set(value),
None => {
let initial: Matrix = Matrix::IDENTITY;
if value.differs(&initial) {
self.rare_block().transform_matrix.set(value);
}
}
}
}
#[inline]
fn rare_adorned_visual(&self) -> Option<Rc<dyn ICompositionObject>> {
match self.rare.get() {
Some(rare) => rare.adorned_visual.get(),
None => None,
}
}
#[inline]
fn store_rare_adorned_visual(&self, value: Option<Rc<dyn ICompositionObject>>) {
match self.rare.get() {
Some(rare) => rare.adorned_visual.set(value),
None => {
if value.is_some() {
self.rare_block().adorned_visual.set(value);
}
}
}
}
#[inline]
fn rare_adorner_is_clipped(&self) -> bool {
match self.rare.get() {
Some(rare) => rare.adorner_is_clipped.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_adorner_is_clipped(&self, value: bool) {
match self.rare.get() {
Some(rare) => rare.adorner_is_clipped.set(value),
None => {
let initial: bool = Default::default();
if value.differs(&initial) {
self.rare_block().adorner_is_clipped.set(value);
}
}
}
}
#[inline]
fn rare_opacity_mask_brush(&self) -> Option<BatchResource<dyn IBrush>> {
match self.rare.get() {
Some(rare) => rare.opacity_mask_brush.get(),
None => None,
}
}
#[inline]
fn store_rare_opacity_mask_brush(&self, value: Option<BatchResource<dyn IBrush>>) {
match self.rare.get() {
Some(rare) => rare.opacity_mask_brush.set(value),
None => {
if value.is_some() {
self.rare_block().opacity_mask_brush.set(value);
}
}
}
}
#[inline]
fn rare_effect(&self) -> Option<Arc<dyn IImmutableEffect>> {
match self.rare.get() {
Some(rare) => rare.effect.get(),
None => None,
}
}
#[inline]
fn store_rare_effect(&self, value: Option<Arc<dyn IImmutableEffect>>) {
match self.rare.get() {
Some(rare) => rare.effect.set(value),
None => {
if value.is_some() {
self.rare_block().effect.set(value);
}
}
}
}
#[inline]
fn rare_cache_mode(&self) -> Option<Rc<dyn ICompositionObject>> {
match self.rare.get() {
Some(rare) => rare.cache_mode.get(),
None => None,
}
}
#[inline]
fn store_rare_cache_mode(&self, value: Option<Rc<dyn ICompositionObject>>) {
match self.rare.get() {
Some(rare) => rare.cache_mode.set(value),
None => {
if value.is_some() {
self.rare_block().cache_mode.set(value);
}
}
}
}
#[inline]
fn rare_composition_clip(&self) -> Option<Rc<dyn ICompositionObject>> {
match self.rare.get() {
Some(rare) => rare.composition_clip.get(),
None => None,
}
}
#[inline]
fn store_rare_composition_clip(&self, value: Option<Rc<dyn ICompositionObject>>) {
match self.rare.get() {
Some(rare) => rare.composition_clip.set(value),
None => {
if value.is_some() {
self.rare_block().composition_clip.set(value);
}
}
}
}
#[inline]
fn rare_rotation_axis(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.rotation_axis.get(),
None => Vector3D::new(0.0, 0.0, 1.0),
}
}
#[inline]
fn store_rare_rotation_axis(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.rotation_axis.set(value),
None => {
let initial: Vector3D = Vector3D::new(0.0, 0.0, 1.0);
if value.differs(&initial) {
self.rare_block().rotation_axis.set(value);
}
}
}
}
#[inline]
fn rare_relative_offset_adjustment(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.relative_offset_adjustment.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_relative_offset_adjustment(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.relative_offset_adjustment.set(value),
None => {
let initial: Vector3D = Default::default();
if value.differs(&initial) {
self.rare_block().relative_offset_adjustment.set(value);
}
}
}
}
#[inline]
fn rare_relative_size_adjustment(&self) -> Vector {
match self.rare.get() {
Some(rare) => rare.relative_size_adjustment.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_relative_size_adjustment(&self, value: Vector) {
match self.rare.get() {
Some(rare) => rare.relative_size_adjustment.set(value),
None => {
let initial: Vector = Default::default();
if value.differs(&initial) {
self.rare_block().relative_size_adjustment.set(value);
}
}
}
}
#[inline]
fn rare_border_mode(&self) -> CompositionBorderMode {
match self.rare.get() {
Some(rare) => rare.border_mode.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_border_mode(&self, value: CompositionBorderMode) {
match self.rare.get() {
Some(rare) => rare.border_mode.set(value),
None => {
let initial: CompositionBorderMode = Default::default();
if value.differs(&initial) {
self.rare_block().border_mode.set(value);
}
}
}
}
#[inline]
fn rare_backface_visibility(&self) -> CompositionBackfaceVisibility {
match self.rare.get() {
Some(rare) => rare.backface_visibility.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_backface_visibility(&self, value: CompositionBackfaceVisibility) {
match self.rare.get() {
Some(rare) => rare.backface_visibility.set(value),
None => {
let initial: CompositionBackfaceVisibility = Default::default();
if value.differs(&initial) {
self.rare_block().backface_visibility.set(value);
}
}
}
}
#[inline]
fn rare_composite_mode(&self) -> CompositionCompositeMode {
match self.rare.get() {
Some(rare) => rare.composite_mode.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_composite_mode(&self, value: CompositionCompositeMode) {
match self.rare.get() {
Some(rare) => rare.composite_mode.set(value),
None => {
let initial: CompositionCompositeMode = Default::default();
if value.differs(&initial) {
self.rare_block().composite_mode.set(value);
}
}
}
}
#[inline]
fn rare_parent_for_transform(&self) -> Option<Rc<dyn ICompositionObject>> {
match self.rare.get() {
Some(rare) => rare.parent_for_transform.get(),
None => None,
}
}
#[inline]
fn store_rare_parent_for_transform(&self, value: Option<Rc<dyn ICompositionObject>>) {
match self.rare.get() {
Some(rare) => rare.parent_for_transform.set(value),
None => {
if value.is_some() {
self.rare_block().parent_for_transform.set(value);
}
}
}
}
}
pub trait ServerCompositionVisualHooks: IServerAnimatedPropertyHost {
fn deserialize_changes_extra(&self, _reader: &mut BatchStreamReader<'_>) {}
fn on_fields_deserialized(&self, _changed: CompositionVisualChangedFields) {}
fn on_root_changed(&self) {}
fn on_root_changing(&self) {}
fn on_parent_changed(&self) {}
fn on_parent_changing(&self) {}
fn on_clip_changed(&self) {}
fn on_clip_changing(&self) {}
fn on_adorned_visual_changed(&self) {}
fn on_adorned_visual_changing(&self) {}
fn on_adorner_is_clipped_changed(&self) {}
fn on_adorner_is_clipped_changing(&self) {}
fn on_opacity_mask_brush_changed(&self) {}
fn on_opacity_mask_brush_changing(&self) {}
fn on_effect_changed(&self) {}
fn on_effect_changing(&self) {}
fn on_render_options_changed(&self) {}
fn on_render_options_changing(&self) {}
fn on_text_options_changed(&self) {}
fn on_text_options_changing(&self) {}
fn on_cache_mode_changed(&self) {}
fn on_cache_mode_changing(&self) {}
fn on_composition_clip_changed(&self) {}
fn on_composition_clip_changing(&self) {}
fn on_is_hit_test_visible_changed(&self) {}
fn on_is_hit_test_visible_changing(&self) {}
fn on_is_pixel_snapping_enabled_changed(&self) {}
fn on_is_pixel_snapping_enabled_changing(&self) {}
fn on_border_mode_changed(&self) {}
fn on_border_mode_changing(&self) {}
fn on_backface_visibility_changed(&self) {}
fn on_backface_visibility_changing(&self) {}
fn on_composite_mode_changed(&self) {}
fn on_composite_mode_changing(&self) {}
fn on_parent_for_transform_changed(&self) {}
fn on_parent_for_transform_changing(&self) {}
}
pub struct ServerCompositionVisualProps {
root: OptionCell<Rc<dyn IServerObject>>,
parent: OptionCell<Rc<dyn IServerObject>>,
visible: Cell<bool>,
opacity: Cell<f32>,
clip_to_bounds: Cell<bool>,
offset: Cell<Vector3D>,
size: Cell<Vector>,
render_options: Cell<RenderOptions>,
text_options: Cell<TextOptions>,
is_hit_test_visible: Cell<bool>,
is_pixel_snapping_enabled: Cell<bool>,
rare: OnceCell<Box<ServerCompositionVisualRareProps>>,
defaults_reported: Cell<bool>,
}
impl Default for ServerCompositionVisualProps {
fn default() -> Self {
Self::new()
}
}
impl ServerCompositionVisualProps {
pub const DEFAULT_FIELDS: CompositionVisualChangedFields = CompositionVisualChangedFields::VISIBLE
.union(CompositionVisualChangedFields::OPACITY)
.union(CompositionVisualChangedFields::CLIP_TO_BOUNDS)
.union(CompositionVisualChangedFields::ORIENTATION)
.union(CompositionVisualChangedFields::SCALE)
.union(CompositionVisualChangedFields::TRANSFORM_MATRIX)
.union(CompositionVisualChangedFields::ROTATION_AXIS)
.union(CompositionVisualChangedFields::IS_HIT_TEST_VISIBLE);
pub fn new() -> Self {
Self {
root: OptionCell::new(),
parent: OptionCell::new(),
visible: Cell::new(true),
opacity: Cell::new(1.0),
clip_to_bounds: Cell::new(true),
offset: Cell::new(Default::default()),
size: Cell::new(Default::default()),
render_options: Cell::new(Default::default()),
text_options: Cell::new(Default::default()),
is_hit_test_visible: Cell::new(true),
is_pixel_snapping_enabled: Cell::new(Default::default()),
rare: OnceCell::new(),
defaults_reported: Cell::new(false),
}
}
pub fn find_props(&self, type_id: TypeId) -> Option<&dyn Any> {
if type_id == TypeId::of::<Self>() {
return Some(self);
}
None
}
pub fn id_of_root_property() -> &'static CompositionPropertyOf<Option<Rc<dyn IServerObject>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<Rc<dyn IServerObject>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<Rc<dyn IServerObject>>>(
"Root",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).root.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).root.set(v),
None,
None,
)
})
}
pub fn root(&self) -> Option<Rc<dyn IServerObject>> {
self.root.get()
}
pub fn set_root(&self, host: &dyn ServerCompositionVisualHooks, value: Option<Rc<dyn IServerObject>>) {
let old_value = self.root.get();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_root_changing(host);
changed = true;
}
host.set_value(
Self::id_of_root_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: old_value.as_server_render_resource(),
new_resource: value.as_server_render_resource(),
assign: &mut || self.root.set(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_root_changed(host);
}
}
pub fn id_of_parent_property() -> &'static CompositionPropertyOf<Option<Rc<dyn IServerObject>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<Rc<dyn IServerObject>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<Rc<dyn IServerObject>>>(
"Parent",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).parent.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).parent.set(v),
None,
None,
)
})
}
pub fn parent(&self) -> Option<Rc<dyn IServerObject>> {
self.parent.get()
}
pub fn set_parent(&self, host: &dyn ServerCompositionVisualHooks, value: Option<Rc<dyn IServerObject>>) {
let old_value = self.parent.get();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_parent_changing(host);
changed = true;
}
host.set_value(
Self::id_of_parent_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: old_value.as_server_render_resource(),
new_resource: value.as_server_render_resource(),
assign: &mut || self.parent.set(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_parent_changed(host);
}
}
pub fn id_of_visible_property() -> &'static CompositionPropertyOf<bool> {
static PROPERTY: OnceLock<CompositionPropertyOf<bool>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, bool>(
"Visible",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).visible.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).visible.set(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).visible.get())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).visible.set(v.cast_or_default::<bool>())),
)
})
}
pub fn visible(&self) -> bool {
self.visible.get()
}
pub fn set_visible(&self, host: &dyn ServerCompositionVisualHooks, value: bool) {
self.visible.set(value);
host.remove_animation_for_property(Self::id_of_visible_property().base());
}
pub fn id_of_opacity_property() -> &'static CompositionPropertyOf<f32> {
static PROPERTY: OnceLock<CompositionPropertyOf<f32>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, f32>(
"Opacity",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).opacity.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).opacity.set(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).opacity.get())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).opacity.set(v.cast_or_default::<f32>())),
)
})
}
pub fn opacity(&self) -> f32 {
self.opacity.get()
}
pub fn set_opacity(&self, host: &dyn ServerCompositionVisualHooks, value: f32) {
self.opacity.set(value);
host.remove_animation_for_property(Self::id_of_opacity_property().base());
}
pub fn id_of_clip_property() -> &'static CompositionPropertyOf<Option<Arc<dyn IGeometryImpl>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<Arc<dyn IGeometryImpl>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<Arc<dyn IGeometryImpl>>>(
"Clip",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_clip(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_clip(v),
None,
None,
)
})
}
pub fn clip(&self) -> Option<Arc<dyn IGeometryImpl>> {
self.rare_clip()
}
pub fn set_clip(&self, host: &dyn ServerCompositionVisualHooks, value: Option<Arc<dyn IGeometryImpl>>) {
let old_value = self.rare_clip();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_clip_changing(host);
changed = true;
}
host.set_value(
Self::id_of_clip_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.store_rare_clip(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_clip_changed(host);
}
}
pub fn id_of_clip_to_bounds_property() -> &'static CompositionPropertyOf<bool> {
static PROPERTY: OnceLock<CompositionPropertyOf<bool>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, bool>(
"ClipToBounds",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).clip_to_bounds.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).clip_to_bounds.set(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).clip_to_bounds.get())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).clip_to_bounds.set(v.cast_or_default::<bool>())),
)
})
}
pub fn clip_to_bounds(&self) -> bool {
self.clip_to_bounds.get()
}
pub fn set_clip_to_bounds(&self, host: &dyn ServerCompositionVisualHooks, value: bool) {
self.clip_to_bounds.set(value);
host.remove_animation_for_property(Self::id_of_clip_to_bounds_property().base());
}
pub fn id_of_offset_property() -> &'static CompositionPropertyOf<Vector3D> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector3D>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector3D>(
"Offset",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).offset.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).offset.set(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).offset.get())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).offset.set(v.cast_or_default::<Vector3D>())),
)
})
}
pub fn offset(&self) -> Vector3D {
self.offset.get()
}
pub fn set_offset(&self, host: &dyn ServerCompositionVisualHooks, value: Vector3D) {
self.offset.set(value);
host.remove_animation_for_property(Self::id_of_offset_property().base());
}
pub fn id_of_translation_property() -> &'static CompositionPropertyOf<Vector3D> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector3D>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector3D>(
"Translation",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_translation(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_translation(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_translation())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_translation(v.cast_or_default::<Vector3D>())),
)
})
}
pub fn translation(&self) -> Vector3D {
self.rare_translation()
}
pub fn set_translation(&self, host: &dyn ServerCompositionVisualHooks, value: Vector3D) {
self.store_rare_translation(value);
host.remove_animation_for_property(Self::id_of_translation_property().base());
}
pub fn id_of_size_property() -> &'static CompositionPropertyOf<Vector> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector>(
"Size",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).size.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).size.set(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).size.get())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).size.set(v.cast_or_default::<Vector>())),
)
})
}
pub fn size(&self) -> Vector {
self.size.get()
}
pub fn set_size(&self, host: &dyn ServerCompositionVisualHooks, value: Vector) {
self.size.set(value);
host.remove_animation_for_property(Self::id_of_size_property().base());
}
pub fn id_of_anchor_point_property() -> &'static CompositionPropertyOf<Vector> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector>(
"AnchorPoint",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_anchor_point(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_anchor_point(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_anchor_point())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_anchor_point(v.cast_or_default::<Vector>())),
)
})
}
pub fn anchor_point(&self) -> Vector {
self.rare_anchor_point()
}
pub fn set_anchor_point(&self, host: &dyn ServerCompositionVisualHooks, value: Vector) {
self.store_rare_anchor_point(value);
host.remove_animation_for_property(Self::id_of_anchor_point_property().base());
}
pub fn id_of_center_point_property() -> &'static CompositionPropertyOf<Vector3D> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector3D>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector3D>(
"CenterPoint",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_center_point(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_center_point(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_center_point())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_center_point(v.cast_or_default::<Vector3D>())),
)
})
}
pub fn center_point(&self) -> Vector3D {
self.rare_center_point()
}
pub fn set_center_point(&self, host: &dyn ServerCompositionVisualHooks, value: Vector3D) {
self.store_rare_center_point(value);
host.remove_animation_for_property(Self::id_of_center_point_property().base());
}
pub fn id_of_rotation_angle_property() -> &'static CompositionPropertyOf<f32> {
static PROPERTY: OnceLock<CompositionPropertyOf<f32>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, f32>(
"RotationAngle",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_rotation_angle(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_rotation_angle(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_rotation_angle())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_rotation_angle(v.cast_or_default::<f32>())),
)
})
}
pub fn rotation_angle(&self) -> f32 {
self.rare_rotation_angle()
}
pub fn set_rotation_angle(&self, host: &dyn ServerCompositionVisualHooks, value: f32) {
self.store_rare_rotation_angle(value);
host.remove_animation_for_property(Self::id_of_rotation_angle_property().base());
}
pub fn id_of_orientation_property() -> &'static CompositionPropertyOf<Quaternion> {
static PROPERTY: OnceLock<CompositionPropertyOf<Quaternion>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Quaternion>(
"Orientation",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_orientation(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_orientation(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_orientation())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_orientation(v.cast_or_default::<Quaternion>())),
)
})
}
pub fn orientation(&self) -> Quaternion {
self.rare_orientation()
}
pub fn set_orientation(&self, host: &dyn ServerCompositionVisualHooks, value: Quaternion) {
self.store_rare_orientation(value);
host.remove_animation_for_property(Self::id_of_orientation_property().base());
}
pub fn id_of_scale_property() -> &'static CompositionPropertyOf<Vector3D> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector3D>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector3D>(
"Scale",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_scale(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_scale(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_scale())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_scale(v.cast_or_default::<Vector3D>())),
)
})
}
pub fn scale(&self) -> Vector3D {
self.rare_scale()
}
pub fn set_scale(&self, host: &dyn ServerCompositionVisualHooks, value: Vector3D) {
self.store_rare_scale(value);
host.remove_animation_for_property(Self::id_of_scale_property().base());
}
pub fn id_of_transform_matrix_property() -> &'static CompositionPropertyOf<Matrix> {
static PROPERTY: OnceLock<CompositionPropertyOf<Matrix>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Matrix>(
"TransformMatrix",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_transform_matrix(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_transform_matrix(v),
None,
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_transform_matrix(v.cast_or_default::<Matrix>())),
)
})
}
pub fn transform_matrix(&self) -> Matrix {
self.rare_transform_matrix()
}
pub fn set_transform_matrix(&self, host: &dyn ServerCompositionVisualHooks, value: Matrix) {
self.store_rare_transform_matrix(value);
host.remove_animation_for_property(Self::id_of_transform_matrix_property().base());
}
pub fn id_of_adorned_visual_property() -> &'static CompositionPropertyOf<Option<Rc<dyn IServerObject>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<Rc<dyn IServerObject>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<Rc<dyn IServerObject>>>(
"AdornedVisual",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_adorned_visual(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_adorned_visual(v),
None,
None,
)
})
}
pub fn adorned_visual(&self) -> Option<Rc<dyn IServerObject>> {
self.rare_adorned_visual()
}
pub fn set_adorned_visual(&self, host: &dyn ServerCompositionVisualHooks, value: Option<Rc<dyn IServerObject>>) {
let old_value = self.rare_adorned_visual();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_adorned_visual_changing(host);
changed = true;
}
host.set_value(
Self::id_of_adorned_visual_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: old_value.as_server_render_resource(),
new_resource: value.as_server_render_resource(),
assign: &mut || self.store_rare_adorned_visual(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_adorned_visual_changed(host);
}
}
pub fn id_of_adorner_is_clipped_property() -> &'static CompositionPropertyOf<bool> {
static PROPERTY: OnceLock<CompositionPropertyOf<bool>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, bool>(
"AdornerIsClipped",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_adorner_is_clipped(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_adorner_is_clipped(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_adorner_is_clipped())),
None,
)
})
}
pub fn adorner_is_clipped(&self) -> bool {
self.rare_adorner_is_clipped()
}
pub fn set_adorner_is_clipped(&self, host: &dyn ServerCompositionVisualHooks, value: bool) {
let old_value = self.rare_adorner_is_clipped();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_adorner_is_clipped_changing(host);
changed = true;
}
host.set_value(
Self::id_of_adorner_is_clipped_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.store_rare_adorner_is_clipped(value),
},
);
if changed {
ServerCompositionVisualHooks::on_adorner_is_clipped_changed(host);
}
}
pub fn id_of_opacity_mask_brush_property() -> &'static CompositionPropertyOf<Option<ServerResourceRef<dyn IBrush>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<ServerResourceRef<dyn IBrush>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<ServerResourceRef<dyn IBrush>>>(
"OpacityMaskBrush",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_opacity_mask_brush(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_opacity_mask_brush(v),
None,
None,
)
})
}
pub fn opacity_mask_brush(&self) -> Option<ServerResourceRef<dyn IBrush>> {
self.rare_opacity_mask_brush()
}
pub fn set_opacity_mask_brush(&self, host: &dyn ServerCompositionVisualHooks, value: Option<ServerResourceRef<dyn IBrush>>) {
let old_value = self.rare_opacity_mask_brush();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_opacity_mask_brush_changing(host);
changed = true;
}
host.set_value(
Self::id_of_opacity_mask_brush_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: old_value.as_server_render_resource(),
new_resource: value.as_server_render_resource(),
assign: &mut || self.store_rare_opacity_mask_brush(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_opacity_mask_brush_changed(host);
}
}
pub fn id_of_effect_property() -> &'static CompositionPropertyOf<Option<Arc<dyn IImmutableEffect>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<Arc<dyn IImmutableEffect>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<Arc<dyn IImmutableEffect>>>(
"Effect",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_effect(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_effect(v),
None,
None,
)
})
}
pub fn effect(&self) -> Option<Arc<dyn IImmutableEffect>> {
self.rare_effect()
}
pub fn set_effect(&self, host: &dyn ServerCompositionVisualHooks, value: Option<Arc<dyn IImmutableEffect>>) {
let old_value = self.rare_effect();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_effect_changing(host);
changed = true;
}
host.set_value(
Self::id_of_effect_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.store_rare_effect(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_effect_changed(host);
}
}
pub fn id_of_render_options_property() -> &'static CompositionPropertyOf<RenderOptions> {
static PROPERTY: OnceLock<CompositionPropertyOf<RenderOptions>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, RenderOptions>(
"RenderOptions",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).render_options.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).render_options.set(v),
None,
None,
)
})
}
pub fn render_options(&self) -> RenderOptions {
self.render_options.get()
}
pub fn set_render_options(&self, host: &dyn ServerCompositionVisualHooks, value: RenderOptions) {
let old_value = self.render_options.get();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_render_options_changing(host);
changed = true;
}
host.set_value(
Self::id_of_render_options_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.render_options.set(value),
},
);
if changed {
ServerCompositionVisualHooks::on_render_options_changed(host);
}
}
pub fn id_of_text_options_property() -> &'static CompositionPropertyOf<TextOptions> {
static PROPERTY: OnceLock<CompositionPropertyOf<TextOptions>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, TextOptions>(
"TextOptions",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).text_options.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).text_options.set(v),
None,
None,
)
})
}
pub fn text_options(&self) -> TextOptions {
self.text_options.get()
}
pub fn set_text_options(&self, host: &dyn ServerCompositionVisualHooks, value: TextOptions) {
let old_value = self.text_options.get();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_text_options_changing(host);
changed = true;
}
host.set_value(
Self::id_of_text_options_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.text_options.set(value),
},
);
if changed {
ServerCompositionVisualHooks::on_text_options_changed(host);
}
}
pub fn id_of_cache_mode_property() -> &'static CompositionPropertyOf<Option<Rc<dyn IServerObject>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<Rc<dyn IServerObject>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<Rc<dyn IServerObject>>>(
"CacheMode",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_cache_mode(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_cache_mode(v),
None,
None,
)
})
}
pub fn cache_mode(&self) -> Option<Rc<dyn IServerObject>> {
self.rare_cache_mode()
}
pub fn set_cache_mode(&self, host: &dyn ServerCompositionVisualHooks, value: Option<Rc<dyn IServerObject>>) {
let old_value = self.rare_cache_mode();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_cache_mode_changing(host);
changed = true;
}
host.set_value(
Self::id_of_cache_mode_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: old_value.as_server_render_resource(),
new_resource: value.as_server_render_resource(),
assign: &mut || self.store_rare_cache_mode(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_cache_mode_changed(host);
}
}
pub fn id_of_composition_clip_property() -> &'static CompositionPropertyOf<Option<Rc<dyn IServerObject>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<Rc<dyn IServerObject>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<Rc<dyn IServerObject>>>(
"CompositionClip",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_composition_clip(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_composition_clip(v),
None,
None,
)
})
}
pub fn composition_clip(&self) -> Option<Rc<dyn IServerObject>> {
self.rare_composition_clip()
}
pub fn set_composition_clip(&self, host: &dyn ServerCompositionVisualHooks, value: Option<Rc<dyn IServerObject>>) {
let old_value = self.rare_composition_clip();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_composition_clip_changing(host);
changed = true;
}
host.set_value(
Self::id_of_composition_clip_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: old_value.as_server_render_resource(),
new_resource: value.as_server_render_resource(),
assign: &mut || self.store_rare_composition_clip(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_composition_clip_changed(host);
}
}
pub fn id_of_rotation_axis_property() -> &'static CompositionPropertyOf<Vector3D> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector3D>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector3D>(
"RotationAxis",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_rotation_axis(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_rotation_axis(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_rotation_axis())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_rotation_axis(v.cast_or_default::<Vector3D>())),
)
})
}
pub fn rotation_axis(&self) -> Vector3D {
self.rare_rotation_axis()
}
pub fn set_rotation_axis(&self, host: &dyn ServerCompositionVisualHooks, value: Vector3D) {
self.store_rare_rotation_axis(value);
host.remove_animation_for_property(Self::id_of_rotation_axis_property().base());
}
pub fn id_of_relative_offset_adjustment_property() -> &'static CompositionPropertyOf<Vector3D> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector3D>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector3D>(
"RelativeOffsetAdjustment",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_relative_offset_adjustment(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_relative_offset_adjustment(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_relative_offset_adjustment())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_relative_offset_adjustment(v.cast_or_default::<Vector3D>())),
)
})
}
pub fn relative_offset_adjustment(&self) -> Vector3D {
self.rare_relative_offset_adjustment()
}
pub fn set_relative_offset_adjustment(&self, host: &dyn ServerCompositionVisualHooks, value: Vector3D) {
self.store_rare_relative_offset_adjustment(value);
host.remove_animation_for_property(Self::id_of_relative_offset_adjustment_property().base());
}
pub fn id_of_relative_size_adjustment_property() -> &'static CompositionPropertyOf<Vector> {
static PROPERTY: OnceLock<CompositionPropertyOf<Vector>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Vector>(
"RelativeSizeAdjustment",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_relative_size_adjustment(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_relative_size_adjustment(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).rare_relative_size_adjustment())),
Some(|obj, v: ExpressionVariant| props_of::<ServerCompositionVisualProps>(obj).store_rare_relative_size_adjustment(v.cast_or_default::<Vector>())),
)
})
}
pub fn relative_size_adjustment(&self) -> Vector {
self.rare_relative_size_adjustment()
}
pub fn set_relative_size_adjustment(&self, host: &dyn ServerCompositionVisualHooks, value: Vector) {
self.store_rare_relative_size_adjustment(value);
host.remove_animation_for_property(Self::id_of_relative_size_adjustment_property().base());
}
pub fn id_of_is_hit_test_visible_property() -> &'static CompositionPropertyOf<bool> {
static PROPERTY: OnceLock<CompositionPropertyOf<bool>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, bool>(
"IsHitTestVisible",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).is_hit_test_visible.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).is_hit_test_visible.set(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).is_hit_test_visible.get())),
None,
)
})
}
pub fn is_hit_test_visible(&self) -> bool {
self.is_hit_test_visible.get()
}
pub fn set_is_hit_test_visible(&self, host: &dyn ServerCompositionVisualHooks, value: bool) {
let old_value = self.is_hit_test_visible.get();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_is_hit_test_visible_changing(host);
changed = true;
}
host.set_value(
Self::id_of_is_hit_test_visible_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.is_hit_test_visible.set(value),
},
);
if changed {
ServerCompositionVisualHooks::on_is_hit_test_visible_changed(host);
}
}
pub fn id_of_is_pixel_snapping_enabled_property() -> &'static CompositionPropertyOf<bool> {
static PROPERTY: OnceLock<CompositionPropertyOf<bool>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, bool>(
"IsPixelSnappingEnabled",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).is_pixel_snapping_enabled.get(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).is_pixel_snapping_enabled.set(v),
Some(|obj| ExpressionVariant::create(props_of::<ServerCompositionVisualProps>(obj).is_pixel_snapping_enabled.get())),
None,
)
})
}
pub fn is_pixel_snapping_enabled(&self) -> bool {
self.is_pixel_snapping_enabled.get()
}
pub fn set_is_pixel_snapping_enabled(&self, host: &dyn ServerCompositionVisualHooks, value: bool) {
let old_value = self.is_pixel_snapping_enabled.get();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_is_pixel_snapping_enabled_changing(host);
changed = true;
}
host.set_value(
Self::id_of_is_pixel_snapping_enabled_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.is_pixel_snapping_enabled.set(value),
},
);
if changed {
ServerCompositionVisualHooks::on_is_pixel_snapping_enabled_changed(host);
}
}
pub fn id_of_border_mode_property() -> &'static CompositionPropertyOf<CompositionBorderMode> {
static PROPERTY: OnceLock<CompositionPropertyOf<CompositionBorderMode>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, CompositionBorderMode>(
"BorderMode",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_border_mode(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_border_mode(v),
None,
None,
)
})
}
pub fn border_mode(&self) -> CompositionBorderMode {
self.rare_border_mode()
}
pub fn set_border_mode(&self, host: &dyn ServerCompositionVisualHooks, value: CompositionBorderMode) {
let old_value = self.rare_border_mode();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_border_mode_changing(host);
changed = true;
}
host.set_value(
Self::id_of_border_mode_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.store_rare_border_mode(value),
},
);
if changed {
ServerCompositionVisualHooks::on_border_mode_changed(host);
}
}
pub fn id_of_backface_visibility_property() -> &'static CompositionPropertyOf<CompositionBackfaceVisibility> {
static PROPERTY: OnceLock<CompositionPropertyOf<CompositionBackfaceVisibility>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, CompositionBackfaceVisibility>(
"BackfaceVisibility",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_backface_visibility(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_backface_visibility(v),
None,
None,
)
})
}
pub fn backface_visibility(&self) -> CompositionBackfaceVisibility {
self.rare_backface_visibility()
}
pub fn set_backface_visibility(&self, host: &dyn ServerCompositionVisualHooks, value: CompositionBackfaceVisibility) {
let old_value = self.rare_backface_visibility();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_backface_visibility_changing(host);
changed = true;
}
host.set_value(
Self::id_of_backface_visibility_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.store_rare_backface_visibility(value),
},
);
if changed {
ServerCompositionVisualHooks::on_backface_visibility_changed(host);
}
}
pub fn id_of_composite_mode_property() -> &'static CompositionPropertyOf<CompositionCompositeMode> {
static PROPERTY: OnceLock<CompositionPropertyOf<CompositionCompositeMode>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, CompositionCompositeMode>(
"CompositeMode",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_composite_mode(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_composite_mode(v),
None,
None,
)
})
}
pub fn composite_mode(&self) -> CompositionCompositeMode {
self.rare_composite_mode()
}
pub fn set_composite_mode(&self, host: &dyn ServerCompositionVisualHooks, value: CompositionCompositeMode) {
let old_value = self.rare_composite_mode();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_composite_mode_changing(host);
changed = true;
}
host.set_value(
Self::id_of_composite_mode_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: None,
new_resource: None,
assign: &mut || self.store_rare_composite_mode(value),
},
);
if changed {
ServerCompositionVisualHooks::on_composite_mode_changed(host);
}
}
pub fn id_of_parent_for_transform_property() -> &'static CompositionPropertyOf<Option<Rc<dyn IServerObject>>> {
static PROPERTY: OnceLock<CompositionPropertyOf<Option<Rc<dyn IServerObject>>>> = OnceLock::new();
PROPERTY.get_or_init(|| {
CompositionProperty::register::<ServerCompositionVisualProps, Option<Rc<dyn IServerObject>>>(
"ParentForTransform",
"ServerCompositionVisual",
|obj| props_of::<ServerCompositionVisualProps>(obj).rare_parent_for_transform(),
|obj, v| props_of::<ServerCompositionVisualProps>(obj).store_rare_parent_for_transform(v),
None,
None,
)
})
}
pub fn parent_for_transform(&self) -> Option<Rc<dyn IServerObject>> {
self.rare_parent_for_transform()
}
pub fn set_parent_for_transform(&self, host: &dyn ServerCompositionVisualHooks, value: Option<Rc<dyn IServerObject>>) {
let old_value = self.rare_parent_for_transform();
let mut changed = false;
if old_value.differs(&value) {
ServerCompositionVisualHooks::on_parent_for_transform_changing(host);
changed = true;
}
host.set_value(
Self::id_of_parent_for_transform_property().base(),
ServerValueChange {
equal: old_value.default_equals(&value),
old_resource: old_value.as_server_render_resource(),
new_resource: value.as_server_render_resource(),
assign: &mut || self.store_rare_parent_for_transform(value.clone()),
},
);
if changed {
ServerCompositionVisualHooks::on_parent_for_transform_changed(host);
}
}
pub fn deserialize_changes_core(
&self,
host: &dyn ServerCompositionVisualHooks,
reader: &mut BatchStreamReader<'_>,
committed_at: Duration,
) {
let compositor = host.server_compositor();
ServerCompositionVisualHooks::deserialize_changes_extra(host, reader);
let changed = reader.read::<CompositionVisualChangedFields>();
if changed.contains(CompositionVisualChangedFields::ROOT) {
let value = read_server_object(reader, compositor.as_ref());
self.set_root(host, value);
}
if changed.contains(CompositionVisualChangedFields::PARENT) {
let value = read_server_object(reader, compositor.as_ref());
self.set_parent(host, value);
}
if changed.contains(CompositionVisualChangedFields::VISIBLE) {
let value = reader.read::<bool>();
self.set_visible(host, value);
}
if changed.contains(CompositionVisualChangedFields::VISIBLE_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `Visible` without an animation instance");
};
host.set_animated_value(
Self::id_of_visible_property().base(),
ExpressionVariant::create(self.visible.get()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::OPACITY) {
let value = reader.read::<f32>();
self.set_opacity(host, value);
}
if changed.contains(CompositionVisualChangedFields::OPACITY_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `Opacity` without an animation instance");
};
host.set_animated_value(
Self::id_of_opacity_property().base(),
ExpressionVariant::create(self.opacity.get()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::CLIP) {
let value = reader.read_value::<Arc<dyn IGeometryImpl>>();
self.set_clip(host, value);
}
if changed.contains(CompositionVisualChangedFields::CLIP_TO_BOUNDS) {
let value = reader.read::<bool>();
self.set_clip_to_bounds(host, value);
}
if changed.contains(CompositionVisualChangedFields::CLIP_TO_BOUNDS_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `ClipToBounds` without an animation instance");
};
host.set_animated_value(
Self::id_of_clip_to_bounds_property().base(),
ExpressionVariant::create(self.clip_to_bounds.get()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::OFFSET) {
let value = reader.read::<Vector3D>();
self.set_offset(host, value);
}
if changed.contains(CompositionVisualChangedFields::OFFSET_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `Offset` without an animation instance");
};
host.set_animated_value(
Self::id_of_offset_property().base(),
ExpressionVariant::create(self.offset.get()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::TRANSLATION) {
let value = reader.read::<Vector3D>();
self.set_translation(host, value);
}
if changed.contains(CompositionVisualChangedFields::TRANSLATION_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `Translation` without an animation instance");
};
host.set_animated_value(
Self::id_of_translation_property().base(),
ExpressionVariant::create(self.rare_translation()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::SIZE) {
let value = reader.read::<Vector>();
self.set_size(host, value);
}
if changed.contains(CompositionVisualChangedFields::SIZE_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `Size` without an animation instance");
};
host.set_animated_value(
Self::id_of_size_property().base(),
ExpressionVariant::create(self.size.get()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::ANCHOR_POINT) {
let value = reader.read::<Vector>();
self.set_anchor_point(host, value);
}
if changed.contains(CompositionVisualChangedFields::ANCHOR_POINT_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `AnchorPoint` without an animation instance");
};
host.set_animated_value(
Self::id_of_anchor_point_property().base(),
ExpressionVariant::create(self.rare_anchor_point()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::CENTER_POINT) {
let value = reader.read::<Vector3D>();
self.set_center_point(host, value);
}
if changed.contains(CompositionVisualChangedFields::CENTER_POINT_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `CenterPoint` without an animation instance");
};
host.set_animated_value(
Self::id_of_center_point_property().base(),
ExpressionVariant::create(self.rare_center_point()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::ROTATION_ANGLE) {
let value = reader.read::<f32>();
self.set_rotation_angle(host, value);
}
if changed.contains(CompositionVisualChangedFields::ROTATION_ANGLE_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `RotationAngle` without an animation instance");
};
host.set_animated_value(
Self::id_of_rotation_angle_property().base(),
ExpressionVariant::create(self.rare_rotation_angle()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::ORIENTATION) {
let value = reader.read::<Quaternion>();
self.set_orientation(host, value);
}
if changed.contains(CompositionVisualChangedFields::ORIENTATION_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `Orientation` without an animation instance");
};
host.set_animated_value(
Self::id_of_orientation_property().base(),
ExpressionVariant::create(self.rare_orientation()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::SCALE) {
let value = reader.read::<Vector3D>();
self.set_scale(host, value);
}
if changed.contains(CompositionVisualChangedFields::SCALE_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `Scale` without an animation instance");
};
host.set_animated_value(
Self::id_of_scale_property().base(),
ExpressionVariant::create(self.rare_scale()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::TRANSFORM_MATRIX) {
let value = reader.read::<Matrix>();
self.set_transform_matrix(host, value);
}
if changed.contains(CompositionVisualChangedFields::TRANSFORM_MATRIX_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `TransformMatrix` without an animation instance");
};
host.set_animated_value(
Self::id_of_transform_matrix_property().base(),
ExpressionVariant::create(self.rare_transform_matrix()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::ADORNED_VISUAL) {
let value = read_server_object(reader, compositor.as_ref());
self.set_adorned_visual(host, value);
}
if changed.contains(CompositionVisualChangedFields::ADORNER_IS_CLIPPED) {
let value = reader.read::<bool>();
self.set_adorner_is_clipped(host, value);
}
if changed.contains(CompositionVisualChangedFields::OPACITY_MASK_BRUSH) {
let value = read_resource(reader, compositor.as_ref(), |o| o.as_brush());
self.set_opacity_mask_brush(host, value);
}
if changed.contains(CompositionVisualChangedFields::EFFECT) {
let value = reader.read_value::<Arc<dyn IImmutableEffect>>();
self.set_effect(host, value);
}
if changed.contains(CompositionVisualChangedFields::RENDER_OPTIONS) {
let value = reader.read::<RenderOptions>();
self.set_render_options(host, value);
}
if changed.contains(CompositionVisualChangedFields::TEXT_OPTIONS) {
let value = reader.read::<TextOptions>();
self.set_text_options(host, value);
}
if changed.contains(CompositionVisualChangedFields::CACHE_MODE) {
let value = read_server_object(reader, compositor.as_ref());
self.set_cache_mode(host, value);
}
if changed.contains(CompositionVisualChangedFields::COMPOSITION_CLIP) {
let value = read_server_object(reader, compositor.as_ref());
self.set_composition_clip(host, value);
}
if changed.contains(CompositionVisualChangedFields::ROTATION_AXIS) {
let value = reader.read::<Vector3D>();
self.set_rotation_axis(host, value);
}
if changed.contains(CompositionVisualChangedFields::ROTATION_AXIS_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `RotationAxis` without an animation instance");
};
host.set_animated_value(
Self::id_of_rotation_axis_property().base(),
ExpressionVariant::create(self.rare_rotation_axis()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT) {
let value = reader.read::<Vector3D>();
self.set_relative_offset_adjustment(host, value);
}
if changed.contains(CompositionVisualChangedFields::RELATIVE_OFFSET_ADJUSTMENT_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `RelativeOffsetAdjustment` without an animation instance");
};
host.set_animated_value(
Self::id_of_relative_offset_adjustment_property().base(),
ExpressionVariant::create(self.rare_relative_offset_adjustment()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT) {
let value = reader.read::<Vector>();
self.set_relative_size_adjustment(host, value);
}
if changed.contains(CompositionVisualChangedFields::RELATIVE_SIZE_ADJUSTMENT_ANIMATED) {
let Some(animation) = reader.read_value::<AnimationInstanceFactory>().map(AnimationInstanceFactory::create) else {
panic!("a batch starts an animation of `RelativeSizeAdjustment` without an animation instance");
};
host.set_animated_value(
Self::id_of_relative_size_adjustment_property().base(),
ExpressionVariant::create(self.rare_relative_size_adjustment()),
committed_at,
animation,
);
}
if changed.contains(CompositionVisualChangedFields::IS_HIT_TEST_VISIBLE) {
let value = reader.read::<bool>();
self.set_is_hit_test_visible(host, value);
}
if changed.contains(CompositionVisualChangedFields::IS_PIXEL_SNAPPING_ENABLED) {
let value = reader.read::<bool>();
self.set_is_pixel_snapping_enabled(host, value);
}
if changed.contains(CompositionVisualChangedFields::BORDER_MODE) {
let value = reader.read::<CompositionBorderMode>();
self.set_border_mode(host, value);
}
if changed.contains(CompositionVisualChangedFields::BACKFACE_VISIBILITY) {
let value = reader.read::<CompositionBackfaceVisibility>();
self.set_backface_visibility(host, value);
}
if changed.contains(CompositionVisualChangedFields::COMPOSITE_MODE) {
let value = reader.read::<CompositionCompositeMode>();
self.set_composite_mode(host, value);
}
if changed.contains(CompositionVisualChangedFields::PARENT_FOR_TRANSFORM) {
let value = read_server_object(reader, compositor.as_ref());
self.set_parent_for_transform(host, value);
}
let changed = if self.defaults_reported.replace(true) { changed } else { changed | Self::DEFAULT_FIELDS };
ServerCompositionVisualHooks::on_fields_deserialized(host, changed);
}
pub fn get_composition_property(name: &str) -> Option<&'static CompositionProperty> {
if name == "Visible" {
return Some(Self::id_of_visible_property().base());
}
if name == "Opacity" {
return Some(Self::id_of_opacity_property().base());
}
if name == "ClipToBounds" {
return Some(Self::id_of_clip_to_bounds_property().base());
}
if name == "Offset" {
return Some(Self::id_of_offset_property().base());
}
if name == "Translation" {
return Some(Self::id_of_translation_property().base());
}
if name == "Size" {
return Some(Self::id_of_size_property().base());
}
if name == "AnchorPoint" {
return Some(Self::id_of_anchor_point_property().base());
}
if name == "CenterPoint" {
return Some(Self::id_of_center_point_property().base());
}
if name == "RotationAngle" {
return Some(Self::id_of_rotation_angle_property().base());
}
if name == "Orientation" {
return Some(Self::id_of_orientation_property().base());
}
if name == "Scale" {
return Some(Self::id_of_scale_property().base());
}
if name == "AdornerIsClipped" {
return Some(Self::id_of_adorner_is_clipped_property().base());
}
if name == "RotationAxis" {
return Some(Self::id_of_rotation_axis_property().base());
}
if name == "RelativeOffsetAdjustment" {
return Some(Self::id_of_relative_offset_adjustment_property().base());
}
if name == "RelativeSizeAdjustment" {
return Some(Self::id_of_relative_size_adjustment_property().base());
}
if name == "IsHitTestVisible" {
return Some(Self::id_of_is_hit_test_visible_property().base());
}
if name == "IsPixelSnappingEnabled" {
return Some(Self::id_of_is_pixel_snapping_enabled_property().base());
}
None
}
}
struct ServerCompositionVisualRareProps {
clip: OptionCell<Arc<dyn IGeometryImpl>>,
translation: Cell<Vector3D>,
anchor_point: Cell<Vector>,
center_point: Cell<Vector3D>,
rotation_angle: Cell<f32>,
orientation: Cell<Quaternion>,
scale: Cell<Vector3D>,
transform_matrix: Cell<Matrix>,
adorned_visual: OptionCell<Rc<dyn IServerObject>>,
adorner_is_clipped: Cell<bool>,
opacity_mask_brush: OptionCell<ServerResourceRef<dyn IBrush>>,
effect: OptionCell<Arc<dyn IImmutableEffect>>,
cache_mode: OptionCell<Rc<dyn IServerObject>>,
composition_clip: OptionCell<Rc<dyn IServerObject>>,
rotation_axis: Cell<Vector3D>,
relative_offset_adjustment: Cell<Vector3D>,
relative_size_adjustment: Cell<Vector>,
border_mode: Cell<CompositionBorderMode>,
backface_visibility: Cell<CompositionBackfaceVisibility>,
composite_mode: Cell<CompositionCompositeMode>,
parent_for_transform: OptionCell<Rc<dyn IServerObject>>,
}
impl ServerCompositionVisualRareProps {
fn new() -> Self {
Self {
clip: OptionCell::new(),
translation: Cell::new(Default::default()),
anchor_point: Cell::new(Default::default()),
center_point: Cell::new(Default::default()),
rotation_angle: Cell::new(Default::default()),
orientation: Cell::new(Quaternion::IDENTITY),
scale: Cell::new(Vector3D::new(1.0, 1.0, 1.0)),
transform_matrix: Cell::new(Matrix::IDENTITY),
adorned_visual: OptionCell::new(),
adorner_is_clipped: Cell::new(Default::default()),
opacity_mask_brush: OptionCell::new(),
effect: OptionCell::new(),
cache_mode: OptionCell::new(),
composition_clip: OptionCell::new(),
rotation_axis: Cell::new(Vector3D::new(0.0, 0.0, 1.0)),
relative_offset_adjustment: Cell::new(Default::default()),
relative_size_adjustment: Cell::new(Default::default()),
border_mode: Cell::new(Default::default()),
backface_visibility: Cell::new(Default::default()),
composite_mode: Cell::new(Default::default()),
parent_for_transform: OptionCell::new(),
}
}
}
impl ServerCompositionVisualProps {
pub fn has_rare_properties(&self) -> bool {
self.rare.get().is_some()
}
#[cold]
fn rare_block(&self) -> &ServerCompositionVisualRareProps {
self.rare.get_or_init(|| Box::new(ServerCompositionVisualRareProps::new()))
}
#[inline]
fn rare_clip(&self) -> Option<Arc<dyn IGeometryImpl>> {
match self.rare.get() {
Some(rare) => rare.clip.get(),
None => None,
}
}
#[inline]
fn store_rare_clip(&self, value: Option<Arc<dyn IGeometryImpl>>) {
match self.rare.get() {
Some(rare) => rare.clip.set(value),
None => {
if value.is_some() {
self.rare_block().clip.set(value);
}
}
}
}
#[inline]
fn rare_translation(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.translation.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_translation(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.translation.set(value),
None => {
let initial: Vector3D = Default::default();
if value.differs(&initial) {
self.rare_block().translation.set(value);
}
}
}
}
#[inline]
fn rare_anchor_point(&self) -> Vector {
match self.rare.get() {
Some(rare) => rare.anchor_point.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_anchor_point(&self, value: Vector) {
match self.rare.get() {
Some(rare) => rare.anchor_point.set(value),
None => {
let initial: Vector = Default::default();
if value.differs(&initial) {
self.rare_block().anchor_point.set(value);
}
}
}
}
#[inline]
fn rare_center_point(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.center_point.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_center_point(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.center_point.set(value),
None => {
let initial: Vector3D = Default::default();
if value.differs(&initial) {
self.rare_block().center_point.set(value);
}
}
}
}
#[inline]
fn rare_rotation_angle(&self) -> f32 {
match self.rare.get() {
Some(rare) => rare.rotation_angle.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_rotation_angle(&self, value: f32) {
match self.rare.get() {
Some(rare) => rare.rotation_angle.set(value),
None => {
let initial: f32 = Default::default();
if value.differs(&initial) {
self.rare_block().rotation_angle.set(value);
}
}
}
}
#[inline]
fn rare_orientation(&self) -> Quaternion {
match self.rare.get() {
Some(rare) => rare.orientation.get(),
None => Quaternion::IDENTITY,
}
}
#[inline]
fn store_rare_orientation(&self, value: Quaternion) {
match self.rare.get() {
Some(rare) => rare.orientation.set(value),
None => {
let initial: Quaternion = Quaternion::IDENTITY;
if value.differs(&initial) {
self.rare_block().orientation.set(value);
}
}
}
}
#[inline]
fn rare_scale(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.scale.get(),
None => Vector3D::new(1.0, 1.0, 1.0),
}
}
#[inline]
fn store_rare_scale(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.scale.set(value),
None => {
let initial: Vector3D = Vector3D::new(1.0, 1.0, 1.0);
if value.differs(&initial) {
self.rare_block().scale.set(value);
}
}
}
}
#[inline]
fn rare_transform_matrix(&self) -> Matrix {
match self.rare.get() {
Some(rare) => rare.transform_matrix.get(),
None => Matrix::IDENTITY,
}
}
#[inline]
fn store_rare_transform_matrix(&self, value: Matrix) {
match self.rare.get() {
Some(rare) => rare.transform_matrix.set(value),
None => {
let initial: Matrix = Matrix::IDENTITY;
if value.differs(&initial) {
self.rare_block().transform_matrix.set(value);
}
}
}
}
#[inline]
fn rare_adorned_visual(&self) -> Option<Rc<dyn IServerObject>> {
match self.rare.get() {
Some(rare) => rare.adorned_visual.get(),
None => None,
}
}
#[inline]
fn store_rare_adorned_visual(&self, value: Option<Rc<dyn IServerObject>>) {
match self.rare.get() {
Some(rare) => rare.adorned_visual.set(value),
None => {
if value.is_some() {
self.rare_block().adorned_visual.set(value);
}
}
}
}
#[inline]
fn rare_adorner_is_clipped(&self) -> bool {
match self.rare.get() {
Some(rare) => rare.adorner_is_clipped.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_adorner_is_clipped(&self, value: bool) {
match self.rare.get() {
Some(rare) => rare.adorner_is_clipped.set(value),
None => {
let initial: bool = Default::default();
if value.differs(&initial) {
self.rare_block().adorner_is_clipped.set(value);
}
}
}
}
#[inline]
fn rare_opacity_mask_brush(&self) -> Option<ServerResourceRef<dyn IBrush>> {
match self.rare.get() {
Some(rare) => rare.opacity_mask_brush.get(),
None => None,
}
}
#[inline]
fn store_rare_opacity_mask_brush(&self, value: Option<ServerResourceRef<dyn IBrush>>) {
match self.rare.get() {
Some(rare) => rare.opacity_mask_brush.set(value),
None => {
if value.is_some() {
self.rare_block().opacity_mask_brush.set(value);
}
}
}
}
#[inline]
fn rare_effect(&self) -> Option<Arc<dyn IImmutableEffect>> {
match self.rare.get() {
Some(rare) => rare.effect.get(),
None => None,
}
}
#[inline]
fn store_rare_effect(&self, value: Option<Arc<dyn IImmutableEffect>>) {
match self.rare.get() {
Some(rare) => rare.effect.set(value),
None => {
if value.is_some() {
self.rare_block().effect.set(value);
}
}
}
}
#[inline]
fn rare_cache_mode(&self) -> Option<Rc<dyn IServerObject>> {
match self.rare.get() {
Some(rare) => rare.cache_mode.get(),
None => None,
}
}
#[inline]
fn store_rare_cache_mode(&self, value: Option<Rc<dyn IServerObject>>) {
match self.rare.get() {
Some(rare) => rare.cache_mode.set(value),
None => {
if value.is_some() {
self.rare_block().cache_mode.set(value);
}
}
}
}
#[inline]
fn rare_composition_clip(&self) -> Option<Rc<dyn IServerObject>> {
match self.rare.get() {
Some(rare) => rare.composition_clip.get(),
None => None,
}
}
#[inline]
fn store_rare_composition_clip(&self, value: Option<Rc<dyn IServerObject>>) {
match self.rare.get() {
Some(rare) => rare.composition_clip.set(value),
None => {
if value.is_some() {
self.rare_block().composition_clip.set(value);
}
}
}
}
#[inline]
fn rare_rotation_axis(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.rotation_axis.get(),
None => Vector3D::new(0.0, 0.0, 1.0),
}
}
#[inline]
fn store_rare_rotation_axis(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.rotation_axis.set(value),
None => {
let initial: Vector3D = Vector3D::new(0.0, 0.0, 1.0);
if value.differs(&initial) {
self.rare_block().rotation_axis.set(value);
}
}
}
}
#[inline]
fn rare_relative_offset_adjustment(&self) -> Vector3D {
match self.rare.get() {
Some(rare) => rare.relative_offset_adjustment.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_relative_offset_adjustment(&self, value: Vector3D) {
match self.rare.get() {
Some(rare) => rare.relative_offset_adjustment.set(value),
None => {
let initial: Vector3D = Default::default();
if value.differs(&initial) {
self.rare_block().relative_offset_adjustment.set(value);
}
}
}
}
#[inline]
fn rare_relative_size_adjustment(&self) -> Vector {
match self.rare.get() {
Some(rare) => rare.relative_size_adjustment.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_relative_size_adjustment(&self, value: Vector) {
match self.rare.get() {
Some(rare) => rare.relative_size_adjustment.set(value),
None => {
let initial: Vector = Default::default();
if value.differs(&initial) {
self.rare_block().relative_size_adjustment.set(value);
}
}
}
}
#[inline]
fn rare_border_mode(&self) -> CompositionBorderMode {
match self.rare.get() {
Some(rare) => rare.border_mode.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_border_mode(&self, value: CompositionBorderMode) {
match self.rare.get() {
Some(rare) => rare.border_mode.set(value),
None => {
let initial: CompositionBorderMode = Default::default();
if value.differs(&initial) {
self.rare_block().border_mode.set(value);
}
}
}
}
#[inline]
fn rare_backface_visibility(&self) -> CompositionBackfaceVisibility {
match self.rare.get() {
Some(rare) => rare.backface_visibility.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_backface_visibility(&self, value: CompositionBackfaceVisibility) {
match self.rare.get() {
Some(rare) => rare.backface_visibility.set(value),
None => {
let initial: CompositionBackfaceVisibility = Default::default();
if value.differs(&initial) {
self.rare_block().backface_visibility.set(value);
}
}
}
}
#[inline]
fn rare_composite_mode(&self) -> CompositionCompositeMode {
match self.rare.get() {
Some(rare) => rare.composite_mode.get(),
None => Default::default(),
}
}
#[inline]
fn store_rare_composite_mode(&self, value: CompositionCompositeMode) {
match self.rare.get() {
Some(rare) => rare.composite_mode.set(value),
None => {
let initial: CompositionCompositeMode = Default::default();
if value.differs(&initial) {
self.rare_block().composite_mode.set(value);
}
}
}
}
#[inline]
fn rare_parent_for_transform(&self) -> Option<Rc<dyn IServerObject>> {
match self.rare.get() {
Some(rare) => rare.parent_for_transform.get(),
None => None,
}
}
#[inline]
fn store_rare_parent_for_transform(&self, value: Option<Rc<dyn IServerObject>>) {
match self.rare.get() {
Some(rare) => rare.parent_for_transform.set(value),
None => {
if value.is_some() {
self.rare_block().parent_for_transform.set(value);
}
}
}
}
}