public override void Draw(DrawingContext context, Matrix matrix) { if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.LinearGradientBrush, (ITypeResolver)this.Element.ProjectContext)) { return; } switch (this.kind) { case LinearGradientAdornerKind.StartPoint: this.DrawArrowTail(context, matrix, this.StartPoint, this.EndPoint); break; case LinearGradientAdornerKind.EndPoint: this.DrawArrowHead(context, matrix, this.StartPoint, this.EndPoint); break; case LinearGradientAdornerKind.StartRotation: context.DrawEllipse((Brush)Brushes.Transparent, (Pen)null, this.GetOffsetStartPoint(matrix, RotateAdornerHelper.Radius), RotateAdornerHelper.Radius, RotateAdornerHelper.Radius); break; case LinearGradientAdornerKind.EndRotation: context.DrawEllipse((Brush)Brushes.Transparent, (Pen)null, this.GetOffsetEndPoint(matrix, RotateAdornerHelper.Radius), RotateAdornerHelper.Radius, RotateAdornerHelper.Radius); break; default: throw new NotImplementedException(ExceptionStringTable.UnknownLinearGradientAdorner); } }
private void UpdateTranslation(bool scrollNow) { SceneView activeView = this.ActiveView; SceneViewModel viewModel = activeView.ViewModel; Vector delta = this.dragCurrentPosition - this.dragStartPosition; if (this.isConstraining) { delta = this.ConstrainDeltaToAxis(delta); } if (delta == this.lastMove || this.IsAltDown) { return; } this.EnsureEditTransaction(); Vector vector1 = delta - this.lastMove; SceneElement primarySelection = viewModel.ElementSelectionSet.PrimarySelection; if (primarySelection == null) { return; } PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection); if (propertyReference == null) { return; } object computedValue = primarySelection.GetComputedValue(propertyReference); if (computedValue != null && !PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)primarySelection.ProjectContext)) { Vector vector2 = vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, true); if (PlatformTypes.IsInstance(computedValue, PlatformTypes.LinearGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool) { ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.StartPointProperty); ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.EndPointProperty); Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2); Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2); this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point1); this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point2); } else if (PlatformTypes.IsInstance(computedValue, PlatformTypes.RadialGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool) { ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.CenterProperty); ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.GradientOriginProperty); Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2); Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2); this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point1); this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point2); } else { this.TranslateBrushPosition(vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, false), primarySelection); } } activeView.EnsureVisible(this.dragStartPosition + delta, scrollNow); this.lastMove = delta; this.UpdateEditTransaction(); }
public void TranslateBrushPosition(Vector elementDelta, SceneElement element) { PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)element); if (propertyReference == null) { return; } object computedValue = element.GetComputedValue(propertyReference); if (computedValue == null || PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)element.ProjectContext)) { return; } ReferenceStep referenceStep = (ReferenceStep)element.Platform.Metadata.ResolveProperty(BrushNode.RelativeTransformProperty); object obj = element.ViewModel.DefaultView.ConvertToWpfValue(referenceStep.GetCurrentValue(computedValue)); CanonicalTransform canonicalTransform = !(obj is Transform) ? new CanonicalTransform(Matrix.Identity) : new CanonicalTransform((Transform)obj); elementDelta *= canonicalTransform.TransformGroup.Value; double valueToSet1 = RoundingHelper.RoundLength(canonicalTransform.TranslationX + elementDelta.X); double valueToSet2 = RoundingHelper.RoundLength(canonicalTransform.TranslationY + elementDelta.Y); this.SetBrushTransformValue(element.Platform.Metadata.CommonProperties.BrushTranslationXReference, valueToSet1); this.SetBrushTransformValue(element.Platform.Metadata.CommonProperties.BrushTranslationYReference, valueToSet2); }
public override void Draw(DrawingContext context, Matrix matrix) { if (!this.ShouldDraw) { return; } bool flag = this.AdornerSet.Behavior.Tool is BrushTransformTool; Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix; if (flag) { Rect brushBounds = this.BrushBounds; if (brushBounds.Width <= 0.0 || brushBounds.Height <= 0.0) { return; } Pen thinPen = this.ThinPen; System.Windows.Media.Geometry rectangleGeometry = Adorner.GetTransformedRectangleGeometry(brushBounds, matrix1, thinPen.Thickness); context.DrawGeometry((Brush)Brushes.Transparent, thinPen, rectangleGeometry); } else { Pen pen = new Pen((Brush)Brushes.Transparent, 15.0); pen.Freeze(); if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.GradientBrush, (ITypeResolver)this.Element.ProjectContext)) { return; } Point startPoint; Point endPoint; this.GetBrushOffsetEndpoints(out startPoint, out endPoint, 13.0, 11.0, matrix); context.DrawLine(pen, startPoint, endPoint); context.DrawLine(this.ThinPen, startPoint, endPoint); } }
private static int GetFigureCount(PathElement pathElement) { if (pathElement == null || !pathElement.IsViewObjectValid) { return(0); } IPlatformTypes metadata = pathElement.Platform.Metadata; if (!PlatformTypes.IsInstance(pathElement.GetLocalValue(PathElement.DataProperty), PlatformTypes.PathGeometry, metadata.DefaultTypeResolver)) { return(pathElement.PathGeometry.Figures.Count); } object obj = new PropertyReference(new List <ReferenceStep>() { metadata.ResolveProperty(PathElement.DataProperty) as ReferenceStep, metadata.ResolveProperty(PathElement.FiguresProperty) as ReferenceStep, metadata.ResolveProperty(PathElement.PathFigureCollectionCountProperty) as ReferenceStep }).GetValue(pathElement.ViewObject.PlatformSpecificObject); if (obj is int) { return((int)obj); } return(0); }
public override void Draw(DrawingContext ctx, Matrix matrix) { if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.RadialGradientBrush, (ITypeResolver)this.Element.ProjectContext) || !(this.AdornerSet.Behavior.Tool is GradientBrushTool)) { return; } base.Draw(ctx, matrix); }
protected override void CreateAdorners() { BrushTranslateAdorner translateAdorner = new BrushTranslateAdorner((BrushTransformAdornerSet)this); if (this.Behavior.Tool is GradientBrushTool && PlatformTypes.IsInstance(translateAdorner.PlatformBrush, PlatformTypes.RadialGradientBrush, (ITypeResolver)this.Element.ProjectContext)) { this.AddAdorner((Adorner) new RadialGradientBrushTranslateAdorner((BrushTransformAdornerSet)this)); } this.AddAdorner((Adorner)translateAdorner); }
private object ConvertImageBrush(object value, object result, ITypeResolver sourceTypeResolver, ITypeResolver targetTypeResolver) { ReferenceStep referenceStep1 = (ReferenceStep)sourceTypeResolver.ResolveProperty(TileBrushNode.StretchProperty); ReferenceStep referenceStep2 = (ReferenceStep)targetTypeResolver.ResolveProperty(TileBrushNode.StretchProperty); object valueToSet1 = this.ConvertInternalFast(referenceStep1.GetValue(value), sourceTypeResolver, targetTypeResolver); referenceStep2.SetValue(result, valueToSet1); object objToInspect = ((ReferenceStep)sourceTypeResolver.ResolveProperty(ImageBrushNode.ImageSourceProperty)).GetValue(value); if (!PlatformTypes.IsInstance(objToInspect, PlatformTypes.BitmapImage, sourceTypeResolver)) { return(result); } object obj1 = ((ReferenceStep)sourceTypeResolver.ResolveProperty(BitmapImageNode.UriSourceProperty)).GetValue(objToInspect); if (obj1 == null) { return(result); } Type type1 = obj1.GetType(); IType type2 = targetTypeResolver.ResolveType(PlatformTypes.Uri); string text = Microsoft.Expression.DesignModel.Metadata.MetadataStore.GetTypeConverter(type1).ConvertToInvariantString(obj1); if (string.IsNullOrEmpty(text)) { return(result); } object valueToSet2 = Microsoft.Expression.DesignModel.Metadata.MetadataStore.GetTypeConverter(type2.RuntimeType).ConvertFromInvariantString(text); ReferenceStep referenceStep3 = (ReferenceStep)targetTypeResolver.ResolveProperty(ImageBrushNode.ImageSourceProperty); object obj2 = InstanceBuilderOperations.InstantiateType(targetTypeResolver.ResolveType(PlatformTypes.BitmapImage).RuntimeType, true); referenceStep3.SetValue(result, obj2); try { BitmapImage bitmapImage = obj2 as BitmapImage; if (bitmapImage != null) { bitmapImage.BeginInit(); bitmapImage.CacheOption = BitmapCacheOption.OnLoad; } ((ReferenceStep)targetTypeResolver.ResolveProperty(BitmapImageNode.UriSourceProperty)).SetValue(obj2, valueToSet2); if (bitmapImage != null) { bitmapImage.EndInit(); } } catch (Exception ex) { result = (object)null; } return(result); }
protected Point GetRadialGradientEndPoint() { Point point = new Point(); if (PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.RadialGradientBrush, (ITypeResolver)this.Element.ProjectContext)) { Vector direction = (Point)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.CenterProperty) - (Point)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.GradientOriginProperty); if (direction.X == 0.0 && direction.Y == 0.0) { direction = new Vector(1.0, -1.0); } point = (Point)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.CenterProperty) + BrushAdorner.IntersectRayAndEllipse(direction, (double)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.RadiusXProperty), (double)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.RadiusYProperty)); } return(point); }
public override void Draw(DrawingContext context, Matrix matrix) { if (!this.ShouldDraw || !PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.RadialGradientBrush, (ITypeResolver)this.Element.ProjectContext)) { return; } Pen pen = new Pen((Brush)Brushes.Transparent, 15.0); pen.Freeze(); Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix; EllipseGeometry ellipseGeometry = new EllipseGeometry((Point)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.CenterProperty), (double)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.RadiusXProperty), (double)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.RadiusYProperty)); ellipseGeometry.Transform = (Transform) new MatrixTransform(matrix1); ellipseGeometry.Freeze(); context.DrawGeometry((Brush)null, pen, (System.Windows.Media.Geometry)ellipseGeometry); context.DrawGeometry((Brush)null, this.ThinPen, (System.Windows.Media.Geometry)ellipseGeometry); }
public bool GetBrushEndpoints(out Point startPoint, out Point endPoint) { startPoint = new Point(); endPoint = new Point(); if (PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.LinearGradientBrush, (ITypeResolver)this.Element.ProjectContext)) { startPoint = (Point)this.GetBrushPropertyAsWpf(LinearGradientBrushNode.StartPointProperty); endPoint = (Point)this.GetBrushPropertyAsWpf(LinearGradientBrushNode.EndPointProperty); return(true); } if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.RadialGradientBrush, (ITypeResolver)this.Element.ProjectContext)) { return(false); } startPoint = (Point)this.GetBrushPropertyAsWpf(RadialGradientBrushNode.GradientOriginProperty); endPoint = this.GetRadialGradientEndPoint(); return(true); }
private void Rebuild() { if (!this.editingProperty.IsMixedValue) { object obj = this.editingProperty.GetValue(); if (PlatformTypes.IsInstance(obj, PlatformTypes.GridLength, (ITypeResolver)((SceneNodeProperty)this.editingProperty).SceneNodeObjectSet.ProjectContext)) { SceneNodeObjectSet sceneNodeObjectSet = ((SceneNodeProperty)this.editingProperty).SceneNodeObjectSet; GridLength gridLength = (GridLength)sceneNodeObjectSet.DesignerContext.PlatformConverter.ConvertToWpf(((SceneNodeProperty)this.editingProperty).SceneNodeObjectSet.DocumentContext, obj); this.value = JoltHelper.RoundDouble(sceneNodeObjectSet.ProjectContext, gridLength.Value); this.gridUnitType = gridLength.GridUnitType; this.OnPropertyChanged("Value"); } } else { this.gridUnitType = GridUnitType.Star; } this.OnPropertyChanged("GridUnitType"); }
public override void Draw(DrawingContext context, Matrix matrix) { if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.RadialGradientBrush, (ITypeResolver)this.Element.ProjectContext)) { return; } switch (this.kind) { case RadialGradientAdornerKind.GradientOriginPoint: this.DrawArrowTail(context, matrix, this.GradientOriginPoint, this.RadiusPoint); break; case RadialGradientAdornerKind.RadiusPoint: this.DrawArrowHead(context, matrix, this.GradientOriginPoint, this.RadiusPoint); break; default: throw new NotImplementedException(ExceptionStringTable.UnknownRadialGradientAdorner); } }
public override Point GetClickablePoint(Matrix matrix) { if (PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.GradientBrush, (ITypeResolver)this.Element.ProjectContext)) { GradientStopCollection gradientStopCollection = (GradientStopCollection)this.GetBrushPropertyAsWpf(GradientBrushNode.GradientStopsProperty); Point startPoint; Point endPoint; if (this.GetBrushEndpoints(out startPoint, out endPoint) && this.Index >= 0 && this.Index < gradientStopCollection.Count) { GradientStop gradientStop = gradientStopCollection[this.Index]; if (gradientStop != null) { Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix; Point point = startPoint * matrix1; endPoint *= matrix1; return((endPoint - point) * gradientStop.Offset + point); } } } return(new Point(0.0, 0.0)); }
public override void Draw(DrawingContext context, Matrix matrix) { if (this.Hidden || !this.ShouldDraw || !PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.GradientBrush, (ITypeResolver)this.Element.ProjectContext)) { return; } Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix; PropertyReference propertyReference1 = this.AdornerSet.BrushPropertyReference.Append(GradientBrushNode.GradientStopsProperty); int num1 = (int)this.Element.GetComputedValue(propertyReference1.Append(GradientStopCollectionNode.CountProperty)); Point startPoint; Point endPoint; if (!this.GetBrushEndpoints(out startPoint, out endPoint) || this.Index < 0 || this.Index >= num1) { return; } PropertyReference propertyReference2 = propertyReference1.Append((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((IPlatformMetadata)this.Element.ViewModel.ProjectContext.Platform.Metadata, PlatformTypes.GradientStopCollection, this.Index)); PropertyReference propertyReference3 = propertyReference2.Append(GradientStopNode.OffsetProperty); PropertyReference propertyReference4 = propertyReference2.Append(GradientStopNode.ColorProperty); double num2 = (double)this.Element.GetComputedValue(propertyReference3); int index = this.DesignerContext.GradientToolSelectionService.Index; Point point = (endPoint - startPoint) * num2 + startPoint; double num3 = 3.5; Color color = (Color)this.Element.GetComputedValueAsWpf(propertyReference4); color.A = byte.MaxValue; SolidColorBrush solidColorBrush = new SolidColorBrush(color); Pen pen = this.ThinPen; if (index == this.Index) { pen = this.ThickPen; num3 = 4.5; } context.DrawEllipse((Brush)Brushes.Transparent, (Pen)null, point * matrix1, num3 + 4.0, num3 + 4.0); context.DrawEllipse((Brush)solidColorBrush, pen, point * matrix1, num3, num3); }
public override void Draw(DrawingContext ctx, Matrix matrix) { if (!this.ShouldDraw || PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.LinearGradientBrush, (ITypeResolver)this.Element.ProjectContext) && this.AdornerSet.Behavior.Tool is GradientBrushTool) { return; } Rect brushBounds = this.BrushBounds; if (brushBounds.Width > 0.0 && brushBounds.Height > 0.0) { Point anchorPoint = this.GetAnchorPoint(matrix); Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix; RotateAdornerHelper.DrawAdorner(ctx, anchorPoint, this.EdgeFlags, matrix1, (Brush)Brushes.Transparent); } else { if (brushBounds.Width <= 0.0 && brushBounds.Height <= 0.0 || this.EdgeFlags != EdgeFlags.TopLeft && this.EdgeFlags != EdgeFlags.BottomRight) { return; } Point anchorPoint = this.GetAnchorPoint(matrix); ctx.DrawEllipse((Brush)Brushes.Transparent, (Pen)null, anchorPoint, RotateAdornerHelper.Radius, RotateAdornerHelper.Radius); } }
public static Matrix GetCompleteBrushTransformMatrix(Base2DElement element, object brush, bool includeTransformFromElementToBrushCoordinates) { Matrix matrix1 = Matrix.Identity; if (brush != null && element != null) { Rect computedTightBounds = element.GetComputedTightBounds(); Matrix matrix2 = BrushAdorner.GetBrushMatrix(element, brush, BrushNode.RelativeTransformProperty); if (PlatformTypes.IsInstance(brush, PlatformTypes.GradientBrush, (ITypeResolver)element.ProjectContext)) { if ((BrushMappingMode)BrushAdorner.GetBrushPropertyAsWpf(element, brush, GradientBrushNode.MappingModeProperty) == BrushMappingMode.Absolute) { if (includeTransformFromElementToBrushCoordinates) { Matrix identity = Matrix.Identity; identity.Translate(-computedTightBounds.X, -computedTightBounds.Y); double scaleX = computedTightBounds.Width == 0.0 ? 1.0 : 1.0 / computedTightBounds.Width; double scaleY = computedTightBounds.Height == 0.0 ? 1.0 : 1.0 / computedTightBounds.Height; identity.Scale(scaleX, scaleY); matrix2 = identity * matrix2; } } else if (BrushAdorner.IsAdorningFillProperty((SceneElement)element)) { matrix2 *= BrushAdorner.GetStrokeTransform((SceneElement)element); } } if (PlatformTypes.IsInstance(brush, PlatformTypes.TileBrush, (ITypeResolver)element.ProjectContext) && BrushAdorner.IsAdorningFillProperty((SceneElement)element)) { matrix2 *= BrushAdorner.GetStrokeTransform((SceneElement)element); } Matrix matrix3 = new Matrix(computedTightBounds.Width, 0.0, 0.0, computedTightBounds.Height, computedTightBounds.X, computedTightBounds.Y); matrix1 = matrix2 * matrix3 * BrushAdorner.GetBrushMatrix(element, brush, BrushNode.TransformProperty); } return(matrix1); }
private void UpdateTranslation(bool scrollNow) { SceneView activeView = this.ActiveView; SceneViewModel viewModel = activeView.ViewModel; if (!this.HasMouseMovedAfterDown) { this.hasInitializedBrush = false; } SceneElement primarySelection = this.ActiveView.ElementSelectionSet.PrimarySelection; if (primarySelection == null) { return; } PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection); if (propertyReference == null || Adorner.NonAffineTransformInParentStack(primarySelection)) { return; } this.EnsureEditTransaction(); if (!this.hasInitializedBrush) { if (!PlatformTypes.IsInstance(this.ActiveView.ElementSelectionSet.PrimarySelection.GetComputedValue(propertyReference), PlatformTypes.GradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { object lastUsed = BrushCategory.GetLastUsed(this.ActiveView.DesignerContext, this.ActiveView.Document.DocumentContext, BrushCategory.Gradient); this.ActiveView.ElementSelectionSet.PrimarySelection.SetValueAsWpf(propertyReference, lastUsed); this.UpdateEditTransaction(); } this.CopyPrimaryBrushToSelection(); this.hasInitializedBrush = true; } object computedValue = primarySelection.GetComputedValue(propertyReference); Matrix matrix = activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, true); Point point1 = this.dragStartPosition * matrix; Point point2 = this.dragCurrentPosition * matrix; Point point3 = RoundingHelper.RoundPosition(point1); Point point4 = RoundingHelper.RoundPosition(point2); if (PlatformTypes.IsInstance(computedValue, PlatformTypes.LinearGradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point3); this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point4); } else if (PlatformTypes.IsInstance(computedValue, PlatformTypes.RadialGradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point3); this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point3); if (this.IsShiftDown) { Vector vector = point4 - point3; this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)vector.Length); this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)vector.Length); } else { Point point5 = RoundingHelper.RoundPosition(new Point(Math.Abs(point3.X - point4.X), Math.Abs(point3.Y - point4.Y))); this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)point5.X); this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)point5.Y); } } activeView.EnsureVisible(this.dragStartPosition + this.dragCurrentPosition - this.dragStartPosition, scrollNow); this.UpdateEditTransaction(); }
private LayoutConstraintMode GetHeightConstraintModeCore(IViewVisual parent, IViewVisual child, SceneView view, bool allowGridAutoChecks) { if (parent == null) { return(LayoutConstraintMode.CanvasLike); } LayoutConstraintMode layoutConstraintMode = LayoutConstraintMode.NonOverlappingGridlike; IType itype = parent.GetIType((ITypeResolver)view.ProjectContext); if (PlatformTypes.Grid.IsAssignableFrom((ITypeId)itype) || PlatformTypes.Canvas.IsAssignableFrom((ITypeId)itype)) { layoutConstraintMode |= LayoutConstraintMode.Overlapping; } IViewVisual viewVisual = parent.VisualParent as IViewVisual; if (viewVisual != null && PlatformTypes.IsInstance(viewVisual.PlatformSpecificObject, ProjectNeutralTypes.Viewbox, (ITypeResolver)view.ProjectContext)) { layoutConstraintMode |= LayoutConstraintMode.CanvasLike; } if (PlatformTypes.Canvas.IsAssignableFrom((ITypeId)itype) || PlatformTypes.TextBlock.IsAssignableFrom((ITypeId)itype) || (PlatformTypes.RichTextBox.IsAssignableFrom((ITypeId)itype) || PlatformTypes.FlowDocumentScrollViewer.IsAssignableFrom((ITypeId)itype)) || (PlatformTypes.ScrollContentPresenter.IsAssignableFrom((ITypeId)itype) || ProjectNeutralTypes.Viewbox.IsAssignableFrom((ITypeId)itype) || (PlatformTypes.Popup.IsAssignableFrom((ITypeId)itype) || ProjectNeutralTypes.PathPanel.IsAssignableFrom((ITypeId)itype)))) { layoutConstraintMode |= LayoutConstraintMode.CanvasLike; } if (PlatformTypes.StackPanel.IsAssignableFrom((ITypeId)itype) && ((IViewPanel)parent).Orientation == Orientation.Vertical) { layoutConstraintMode |= LayoutConstraintMode.CanvasLike; } if (ProjectNeutralTypes.DockPanel.IsAssignableFrom((ITypeId)itype) && child != null) { switch ((Dock)view.ConvertToWpfValue(child.GetCurrentValue(view.ProjectContext.ResolveProperty(DockPanelElement.DockProperty)))) { case Dock.Top: case Dock.Bottom: layoutConstraintMode |= LayoutConstraintMode.CanvasLike; break; } } if (ProjectNeutralTypes.WrapPanel.IsAssignableFrom((ITypeId)itype) && double.IsNaN((double)parent.GetCurrentValue(view.ProjectContext.ResolveProperty(WrapPanelElement.ItemHeightProperty)))) { layoutConstraintMode |= LayoutConstraintMode.CanvasLike; } if ((layoutConstraintMode & LayoutConstraintMode.CanvasLike) == LayoutConstraintMode.NonOverlappingGridlike && double.IsNaN((double)parent.GetCurrentValue(view.ProjectContext.ResolveProperty(BaseFrameworkElement.HeightProperty))) && double.IsNaN((double)parent.GetCurrentValue(view.ProjectContext.ResolveProperty(DesignTimeProperties.DesignHeightProperty)))) { IViewGrid viewGrid = parent as IViewGrid; if (viewGrid != null) { if (!allowGridAutoChecks) { return(layoutConstraintMode); } IType type = child == null ? (IType)null : child.GetIType((ITypeResolver)view.ProjectContext); if (child != null && (!PlatformTypes.Path.IsAssignableFrom((ITypeId)type) || !double.IsNaN((double)child.GetCurrentValue(view.ProjectContext.ResolveProperty(BaseFrameworkElement.HeightProperty))))) { int val2_1 = (int)child.GetCurrentValue(view.ProjectContext.ResolveProperty(GridElement.RowProperty)); int val2_2 = val2_1 + (int)child.GetCurrentValue(view.ProjectContext.ResolveProperty(GridElement.RowSpanProperty)); int num1 = Math.Max(0, Math.Min(viewGrid.RowDefinitionsCount - 1, val2_1)); int num2 = Math.Max(0, Math.Min(viewGrid.RowDefinitionsCount, val2_2)); double num3 = 0.0; bool flag1 = true; bool flag2 = true; if (num2 == 0) { flag1 = false; flag2 = false; num3 = viewGrid.RenderSize.Height; } else { for (int index = num1; index < num2; ++index) { IViewRowDefinition rowDefinition = viewGrid.GetRowDefinition(index); flag1 &= rowDefinition.Height.IsAuto; flag2 &= rowDefinition.Height.IsAbsolute; num3 += rowDefinition.ActualHeight; } } double height = child.DesiredSize.Height; IProperty propertyKey = view.Platform.Metadata.ResolveProperty(Base2DElement.UseLayoutRoundingProperty); if (propertyKey != null && child.GetCurrentValue(propertyKey) != parent.GetCurrentValue(propertyKey)) { height += 0.999; } if (Tolerances.LessThan(height, num3) || flag2) { return(layoutConstraintMode); } if (flag1) { layoutConstraintMode |= LayoutConstraintMode.CanvasLike; } } } if ((VerticalAlignment)view.ConvertToWpfValue(parent.GetCurrentValue(view.ProjectContext.ResolveProperty(BaseFrameworkElement.VerticalAlignmentProperty))) != VerticalAlignment.Stretch) { layoutConstraintMode |= LayoutConstraintMode.CanvasLike; } else { if (PlatformTypes.Control.IsAssignableFrom((ITypeId)itype) || PlatformTypes.ContentPresenter.IsAssignableFrom((ITypeId)itype)) { allowGridAutoChecks = true; } if ((this.GetHeightConstraintModeCore(parent.VisualParent as IViewVisual, parent, view, allowGridAutoChecks) & LayoutConstraintMode.CanvasLike) != LayoutConstraintMode.NonOverlappingGridlike) { layoutConstraintMode |= LayoutConstraintMode.CanvasLike; } } } return(layoutConstraintMode); }
private void UpdateTranslation() { SceneViewModel viewModel = this.ActiveView.ViewModel; PropertyReference propertyReference1 = this.GetBrushPropertyReference((SceneNode)this.EditingElement); if (propertyReference1 == null) { return; } Matrix matrixToAdornerLayer = this.ActiveAdorner.AdornerSet.GetTransformMatrixToAdornerLayer(); this.EnsureEditTransaction(); Point startPoint; Point endPoint; if (PlatformTypes.IsInstance(this.ActiveAdorner.PlatformBrush, PlatformTypes.GradientBrush, (ITypeResolver)this.EditingElement.ProjectContext) && this.ActiveAdorner.GetBrushEndpoints(out startPoint, out endPoint)) { if (!this.HasMouseMovedAfterDown) { this.CopyPrimaryBrushToSelection(); } PropertyReference propertyReference2 = propertyReference1.Append(GradientBrushNode.GradientStopsProperty); PropertyReference propertyReference3 = propertyReference2.Append((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((IPlatformMetadata)viewModel.ProjectContext.Platform.Metadata, PlatformTypes.GradientStopCollection, this.ActiveAdorner.Index)); PropertyReference propertyReference4 = propertyReference3.Append(GradientStopNode.OffsetProperty); PropertyReference propertyReference5 = propertyReference3.Append(GradientStopNode.ColorProperty); Matrix matrix = this.ActiveAdorner.GetCompleteBrushTransformMatrix(true) * this.ActiveView.GetComputedTransformToRoot(this.EditingElement); GradientStopCollection gradientStopCollection = (GradientStopCollection)this.EditingElement.GetComputedValueAsWpf(propertyReference2); GradientStop gradientStop = gradientStopCollection[this.ActiveAdorner.Index]; Vector perpendicular; double num1 = GradientStopBehavior.VectorProjection(startPoint * matrix, endPoint * matrix, this.dragCurrentPosition, gradientStop.Offset, out perpendicular); double length = (perpendicular * matrixToAdornerLayer).Length; int index = this.ActiveAdorner.Index + 1; if (index >= gradientStopCollection.Count) { index = this.ActiveAdorner.Index - 1; } if (length > 30.0 && !this.isDraggedOff && gradientStopCollection.Count > 2) { this.isDraggedOff = true; this.ActiveAdorner.Hidden = true; this.saveDraggedOffColor = gradientStop.Color; this.SetBrushValue(propertyReference5, (object)gradientStopCollection[index].Color); this.SetBrushValue(propertyReference4, (object)gradientStopCollection[index].Offset); this.Cursor = ToolCursors.MinusArrowCursor; } if (length <= 30.0 && this.isDraggedOff) { this.isDraggedOff = false; this.ActiveAdorner.Hidden = false; this.SetBrushValue(propertyReference5, (object)this.saveDraggedOffColor); this.Cursor = this.ActiveAdorner.AdornerSet.GetCursor((IAdorner)this.ActiveAdorner); } if (!this.isDraggedOff) { double num2 = RoundingHelper.RoundLength(gradientStop.Offset + num1); if (num2 > 1.0) { num2 = 1.0; } else if (num2 < 0.0) { num2 = 0.0; } this.SetBrushValue(propertyReference4, (object)num2); } else { this.SetBrushValue(propertyReference4, (object)gradientStopCollection[index].Offset); } } if (!this.HasMouseMovedAfterDown) { this.SetSelectedStopIndex(this.ActiveAdorner.Index); } this.UpdateEditTransaction(); }