Example #1
0
 private void ApplyRelativeTransformToElements(IEnumerable targetElements, PropertyReference reference, IApplyRelativeTransform transformModel)
 {
     foreach (SceneNode sceneNode in targetElements)
     {
         SceneElement sceneElement = sceneNode as SceneElement;
         if (sceneElement != null)
         {
             if (sceneElement is BaseFrameworkElement && sceneElement.IsSet(Base2DElement.RenderTransformOriginProperty) == PropertyState.Unset)
             {
                 sceneElement.SetValueAsWpf(Base2DElement.RenderTransformOriginProperty, (object)new Point(0.5, 0.5));
             }
             object             computedValueAsWpf = sceneElement.GetComputedValueAsWpf(reference);
             object             obj = transformModel.ApplyRelativeTransform(computedValueAsWpf);
             CanonicalTransform canonicalTransform = obj as CanonicalTransform;
             if (canonicalTransform != (CanonicalTransform)null)
             {
                 sceneElement.SetValue(reference, canonicalTransform.GetPlatformTransform(sceneElement.Platform.GeometryHelper));
             }
             else
             {
                 CanonicalTransform3D canonicalTransform3D = obj as CanonicalTransform3D;
                 if (canonicalTransform3D != (CanonicalTransform3D)null)
                 {
                     sceneElement.SetValue(reference, (object)canonicalTransform3D.ToTransform());
                 }
             }
         }
     }
 }
Example #2
0
        public override System.Windows.Media.Geometry GetRenderedGeometryAsWpf(SceneElement shapeElement)
        {
            IViewObject element = shapeElement != null ? shapeElement.ViewObject : (IViewObject)null;

            if (element == null)
            {
                return((System.Windows.Media.Geometry) new PathGeometry());
            }
            Rect actualBounds = this.GetActualBounds(element);

            if (!actualBounds.IsEmpty && (Brush)shapeElement.GetComputedValueAsWpf(ShapeElement.StrokeProperty) != null)
            {
                double num1 = (double)shapeElement.GetComputedValue(ShapeElement.StrokeThicknessProperty);
                if (!double.IsNaN(num1) && !double.IsInfinity(num1))
                {
                    double num2 = Math.Min(actualBounds.Width, num1) / 2.0;
                    double num3 = Math.Min(actualBounds.Height, num1) / 2.0;
                    actualBounds.Inflate(-num2, -num3);
                }
            }
            System.Windows.Media.Geometry geometry = this.platformSurface.GetShapeRenderedGeometry(element.PlatformSpecificObject, actualBounds);
            if (geometry == null)
            {
                if (ProjectNeutralTypes.PrimitiveShape.IsAssignableFrom((ITypeId)shapeElement.Type))
                {
                    geometry = shapeElement.GetComputedValueAsWpf(PrimitiveShapeElement.RenderedGeometryProperty) as System.Windows.Media.Geometry;
                }
                else if (PlatformTypes.Path.IsAssignableFrom((ITypeId)shapeElement.Type))
                {
                    geometry = shapeElement.GetComputedValueAsWpf(PathElement.DataProperty) as System.Windows.Media.Geometry;
                }
            }
            if (geometry == null)
            {
                geometry = (System.Windows.Media.Geometry) new PathGeometry();
            }
            if (!PlatformTypes.Rectangle.Equals((object)shapeElement.Type) && !PlatformTypes.Ellipse.Equals((object)shapeElement.Type))
            {
                MatrixTransform matrixTransform = shapeElement.GetComputedValueAsWpf(ShapeElement.GeometryTransformProperty) as MatrixTransform;
                if (matrixTransform != null && !matrixTransform.Matrix.IsIdentity)
                {
                    Matrix matrix = geometry.Transform != null ? geometry.Transform.Value * matrixTransform.Matrix : matrixTransform.Matrix;
                    geometry.Transform = (Transform) new MatrixTransform(matrix);
                }
            }
            return(geometry);
        }
Example #3
0
        protected static void UpdateElementTransform(SceneElement element, CanonicalDecomposition newTransform, AdornedToolBehavior.TransformPropertyFlags properties)
        {
            Transform transform = element.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty) as Transform;
            CanonicalDecomposition canonicalDecomposition = new CanonicalDecomposition();

            if (transform != null)
            {
                canonicalDecomposition = new CanonicalTransform(transform).Decomposition;
            }
            double num1 = RoundingHelper.RoundScale(newTransform.ScaleX);
            double num2 = RoundingHelper.RoundScale(newTransform.ScaleY);
            double num3 = RoundingHelper.RoundLength(newTransform.TranslationX);
            double num4 = RoundingHelper.RoundLength(newTransform.TranslationY);
            double num5 = RoundingHelper.RoundLength(newTransform.SkewX);
            double num6 = RoundingHelper.RoundLength(newTransform.SkewY);
            double num7 = RoundingHelper.RoundAngle(newTransform.RotationAngle);

            if ((properties & AdornedToolBehavior.TransformPropertyFlags.ScaleX) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.ScaleX, num1))
            {
                element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformScaleX, (object)num1);
            }
            if ((properties & AdornedToolBehavior.TransformPropertyFlags.ScaleY) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.ScaleY, num2))
            {
                element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformScaleY, (object)num2);
            }
            if ((properties & AdornedToolBehavior.TransformPropertyFlags.TranslationX) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.TranslationX, num3))
            {
                element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformTranslationX, (object)num3);
            }
            if ((properties & AdornedToolBehavior.TransformPropertyFlags.TranslationY) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.TranslationY, num4))
            {
                element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformTranslationY, (object)num4);
            }
            if ((properties & AdornedToolBehavior.TransformPropertyFlags.SkewX) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.SkewX, num5))
            {
                element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformSkewX, (object)num5);
            }
            if ((properties & AdornedToolBehavior.TransformPropertyFlags.SkewY) != AdornedToolBehavior.TransformPropertyFlags.None && !Tolerances.AreClose(canonicalDecomposition.SkewY, num6))
            {
                element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformSkewY, (object)num6);
            }
            if ((properties & AdornedToolBehavior.TransformPropertyFlags.RotatationAngle) == AdornedToolBehavior.TransformPropertyFlags.None || Tolerances.AreClose(canonicalDecomposition.RotationAngle, num7))
            {
                return;
            }
            element.SetValue(element.Platform.Metadata.CommonProperties.RenderTransformRotationAngle, (object)num7);
        }
        protected object GetBrushValue(IPropertyId property)
        {
            SceneElement primarySelection = this.ActiveView.ElementSelectionSet.PrimarySelection;

            if (primarySelection == null)
            {
                return((object)null);
            }
            PropertyReference propertyReference1 = this.GetBrushPropertyReference((SceneNode)primarySelection);

            if (propertyReference1 == null)
            {
                return((object)null);
            }
            PropertyReference propertyReference2 = propertyReference1.Append(property);

            return(primarySelection.GetComputedValueAsWpf(propertyReference2));
        }
 private static bool IsAxisAligned(SceneElement element)
 {
     if (element.IsSet(Base2DElement.RenderTransformProperty) == PropertyState.Set)
     {
         Matrix matrixFromTransform = VectorUtilities.GetMatrixFromTransform(element.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty) as GeneralTransform);
         if (!matrixFromTransform.IsIdentity)
         {
             Vector vector1 = matrixFromTransform.Transform(new Vector(1.0, 0.0));
             Vector vector2 = matrixFromTransform.Transform(new Vector(0.0, 1.0));
             double num     = 1E-06;
             if (Math.Abs(vector1.Y) > num || Math.Abs(vector2.X) > num)
             {
                 return(false);
             }
         }
     }
     return(true);
 }
Example #6
0
        public static LayoutSettings GetLayoutSettingsFromElement(SceneElement element)
        {
            LayoutSettings layoutSettings = new LayoutSettings();

            layoutSettings.LayoutOverrides = (LayoutOverrides)element.GetComputedValue(DesignTimeProperties.LayoutOverridesProperty);
            if (element.Parent is GridElement)
            {
                layoutSettings.GridBox = LayoutUtilities.GetGridBoxFromElement(element);
                if (LayoutUtilities.PropertyIsExpression((SceneNode)element, GridElement.ColumnProperty) || LayoutUtilities.PropertyIsExpression((SceneNode)element, GridElement.ColumnSpanProperty) || (LayoutUtilities.PropertyIsExpression((SceneNode)element, GridElement.RowProperty) || LayoutUtilities.PropertyIsExpression((SceneNode)element, GridElement.RowSpanProperty)))
                {
                    layoutSettings.LayoutOverrides |= LayoutOverrides.GridBox;
                }
            }
            layoutSettings.HorizontalAlignment = (HorizontalAlignment)element.GetComputedValue(BaseFrameworkElement.HorizontalAlignmentProperty);
            if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.HorizontalAlignmentProperty))
            {
                layoutSettings.LayoutOverrides |= LayoutOverrides.HorizontalAlignment;
            }
            layoutSettings.VerticalAlignment = (VerticalAlignment)element.GetComputedValue(BaseFrameworkElement.VerticalAlignmentProperty);
            if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.VerticalAlignmentProperty))
            {
                layoutSettings.LayoutOverrides |= LayoutOverrides.VerticalAlignment;
            }
            layoutSettings.Width = (double)element.GetComputedValue(BaseFrameworkElement.WidthProperty);
            if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.WidthProperty))
            {
                layoutSettings.LayoutOverrides |= LayoutOverrides.Width;
            }
            layoutSettings.Height = (double)element.GetComputedValue(BaseFrameworkElement.HeightProperty);
            if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.HeightProperty))
            {
                layoutSettings.LayoutOverrides |= LayoutOverrides.Height;
            }
            layoutSettings.Margin = (Thickness)element.GetComputedValueAsWpf(BaseFrameworkElement.MarginProperty);
            if (LayoutUtilities.PropertyIsExpression((SceneNode)element, BaseFrameworkElement.MarginProperty))
            {
                layoutSettings.LayoutOverrides |= LayoutOverrides.Margin;
            }
            return(layoutSettings);
        }
 private System.Windows.Media.Geometry ApplyCurrentClippingToGeometry(System.Windows.Media.Geometry targetGeometry, SceneElement clippedElement)
 {
     System.Windows.Media.Geometry geometry1 = (System.Windows.Media.Geometry)(clippedElement.GetComputedValueAsWpf(Base2DElement.ClipProperty) as PathGeometry);
     if (geometry1 != null && !geometry1.IsEmpty())
     {
         targetGeometry = (System.Windows.Media.Geometry)System.Windows.Media.Geometry.Combine(geometry1, targetGeometry, GeometryCombineMode.Intersect, (Transform)null);
     }
     return(targetGeometry);
 }
        private Transform GetGeometryTransform(SceneElement clipper, SceneElement elementToBeClipped)
        {
            Transform identity = Transform.Identity;

            return(elementToBeClipped == null?clipper.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty) as Transform : (Transform) new MatrixTransform(clipper.GetComputedTransformToElement(elementToBeClipped)));
        }