public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); result.Children.Add(new TranslateTransform(_offsetLeft, _offsetTop)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); result.Children.Add(new TranslateTransform(_leftOffset, _topOffset)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup result = new GeneralTransformGroup(); result.Children.Add (transform); result.Children.Add (new TranslateTransform (this.offset.X, this.offset.Y)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var transformGroup = new GeneralTransformGroup(); transformGroup.Children.Add(base.GetDesiredTransform(transform)); transformGroup.Children.Add(new TranslateTransform(_currentPoint.X - _startPoint.X, _currentPoint.Y - _startPoint.Y)); return transformGroup; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); result.Children.Add(new TranslateTransform(position.X, position.Y)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup newTransform = new GeneralTransformGroup(); newTransform.Children.Add(base.GetDesiredTransform(transform)); newTransform.Children.Add(new TranslateTransform(this._adornerOffset.X, this._adornerOffset.Y)); return newTransform; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); result.Children.Add(new TranslateTransform(this.left, this.top)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup group = new GeneralTransformGroup(); group.Children.Add(base.GetDesiredTransform(transform)); group.Children.Add(translate); return group; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); result.Children.Add(new TranslateTransform(this.MousePosition.X - 4, this.MousePosition.Y - 4)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); result.Children.Add(new TranslateTransform( position.X - treeViewEx.ScrollViewer.ContentHorizontalOffset, position.Y - treeViewEx.ScrollViewer.ContentVerticalOffset)); return result; }
/// <summary> /// Override. /// </summary> /// <param name="transform"></param> /// <returns></returns> public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var result = new GeneralTransformGroup(); // ReSharper disable AssignNullToNotNullAttribute result.Children.Add(base.GetDesiredTransform(transform)); // ReSharper restore AssignNullToNotNullAttribute result.Children.Add(new TranslateTransform(offsetLeft, offsetTop)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup result = new GeneralTransformGroup(); result.Children.Add(new TranslateTransform(Left, Top)); if (Left > 0) this.Visibility = Visibility.Visible; result.Children.Add(base.GetDesiredTransform(transform)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var result = new GeneralTransformGroup(); var desired = base.GetDesiredTransform(transform); if (desired != null) { result.Children.Add(desired); } result.Children.Add(new TranslateTransform(_offsetLeft, _offsetTop)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var result = new GeneralTransformGroup(); var tf = base.GetDesiredTransform(transform); Debug.Assert(tf != null); result.Children.Add(tf); result.Children.Add(new TranslateTransform(_left, _top)); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var baseTransform = base.GetDesiredTransform(transform); var translateTransform = new TranslateTransform(MousePosition.X - 4, MousePosition.Y - 4); var result = new GeneralTransformGroup(); if (baseTransform != null) result.Children.Add(baseTransform); result.Children.Add(translateTransform); return result; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); var mousePositionTransform = new TranslateTransform(MousePosition.X, MousePosition.Y); result.Children.Add(mousePositionTransform); var mousePositionOffsetTransform = new TranslateTransform(-4, -4); result.Children.Add(mousePositionOffsetTransform); return result; }
/// <summary> /// Adorners don't always want to be transformed in the same way as the elements they /// adorn. Adorners which adorn points, such as resize handles, want to be translated /// and rotated but not scaled. Adorners adorning an object, like a marquee, may want /// all transforms. This method is called by AdornerLayer to allow the adorner to /// filter out the transforms it doesn't want and return a new transform with just the /// transforms it wants applied. An adorner can also add an additional translation /// transform at this time, allowing it to be positioned somewhere other than the upper /// left corner of its adorned element. /// </summary> /// <param name="transform">The transform applied to the object the adorner adorns</param> /// <returns>Transform to apply to the adorner</returns> public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { if (ReferenceElement == null) return transform; GeneralTransformGroup group = new GeneralTransformGroup(); group.Children.Add(transform); GeneralTransform t = this.TransformToDescendant(ReferenceElement); if (t != null) { group.Children.Add(t); } return group; }
/// <summary> /// Returns a <see cref="T:System.Windows.Media.Transform"/> for the adorner, based on the transform that is currently applied to the adorned element. /// </summary> /// <param name="transform">The transform that is currently applied to the adorned element.</param> /// <returns>A transform to apply to the adorner.</returns> public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { if (PlaceholderReferenceElement == null) { return transform; } var group = new GeneralTransformGroup(); group.Children.Add(transform); var transform2 = TransformToDescendant(PlaceholderReferenceElement); if (transform2 != null) { group.Children.Add(transform2); } return group; }
//------------------------------------------------------ // // Public Methods // //------------------------------------------------------ #region Public Methods /// <summary> /// Add a transform so that the adorner is in right spot. /// </summary> /// <param name="transform"> /// The transform applied to the object the adorner adorns /// </param> /// <returns> /// Transform to apply to the adorner /// </returns> public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { GeneralTransformGroup group; TranslateTransform translation; group = new GeneralTransformGroup(); translation = new TranslateTransform(_x, _top); group.Children.Add(translation); if (transform != null) { group.Children.Add(transform); } return group; }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { Rect adornedElementRect = new Rect(this.AdornedElement.RenderSize); double positionX = adornedElementRect.Left; double positionY; if (Content.Before) { positionY = adornedElementRect.Top; } else { positionY = adornedElementRect.Bottom; } GeneralTransformGroup result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); result.Children.Add(new TranslateTransform(positionX, positionY - contentPresenter.ActualHeight/2)); return result; }
/// <summary> /// The overridden GetDesiredTransform method /// </summary> public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { if ( transform == null ) { throw new ArgumentNullException("transform"); } VerifyAccess(); GeneralTransformGroup desiredTransform = new GeneralTransformGroup(); desiredTransform.Children.Add(transform); // Check if we need translate the adorner. if ( !DoubleUtil.AreClose(_offsetX, 0) || !DoubleUtil.AreClose(_offsetY, 0) ) { desiredTransform.Children.Add(new TranslateTransform(_offsetX, _offsetY)); } return desiredTransform; }
internal GeneralTransform2DTo3D(GeneralTransform transform2D, Viewport2DVisual3D containingVisual3D, GeneralTransform3D transform3D) { Visual child = containingVisual3D.Visual; Debug.Assert(child != null, "Going from 2D to 3D containingVisual3D.Visual should not be null"); _transform3D = (GeneralTransform3D)transform3D.GetCurrentValueAsFrozen(); // we also need to go one more level up to handle a transform being placed // on the Viewport2DVisual3D's child GeneralTransformGroup transformGroup = new GeneralTransformGroup(); transformGroup.Children.Add((GeneralTransform)transform2D.GetCurrentValueAsFrozen()); transformGroup.Children.Add((GeneralTransform)child.TransformToOuterSpace().GetCurrentValueAsFrozen()); transformGroup.Freeze(); _transform2D = transformGroup; _positions = containingVisual3D.InternalPositionsCache; _textureCoords = containingVisual3D.InternalTextureCoordinatesCache; _triIndices = containingVisual3D.InternalTriangleIndicesCache; _childBounds = child.CalculateSubgraphRenderBoundsOuterSpace(); }
/// <summary> /// Provides the transform or the inverse transform between this visual and the specified ancestor. /// Returns true if the transform is "simple" - in which case the GeneralTransform is null /// and the caller should use the Matrix. /// Otherwise, returns false - use the GeneralTransform and ignore the Matrix. /// If inverse is requested but not available (if the transform is not invertible), false is /// returned and the GeneralTransform is null. /// </summary> /// <param name="ancestor">Ancestor visual.</param> /// <param name="inverse">Returns inverse if this argument is true.</param> /// <param name="generalTransform">The GeneralTransform if this method returns false.</param> /// <param name="simpleTransform">The Matrix if this method returns true.</param> internal bool TrySimpleTransformToAncestor(Visual ancestor, bool inverse, out GeneralTransform generalTransform, out Matrix simpleTransform) { Debug.Assert(ancestor != null); // flag to indicate if we have a case where we do multile 2D->3D->2D transitions bool embedded2Don3D = false; DependencyObject g = this; Matrix m = Matrix.Identity; // Keep this null until it's needed GeneralTransformGroup group = null; // This while loop will walk up the visual tree until we encounter the ancestor. // As it does so, it will accumulate the descendent->ancestor transform. // In most cases, this is simply a matrix, though if we encounter a bitmap effect we // will need to use a general transform group to store the transform. // We will accumulate the current transform in a matrix until we encounter a bitmap effect, // at which point we will add the matrix's current value and the bitmap effect's transforms // to the GeneralTransformGroup and continue to accumulate further transforms in the matrix again. // At the end of this loop, we will have 0 or more transforms in the GeneralTransformGroup // and the matrix which, if not identity, should be appended to the GeneralTransformGroup. // If, as is commonly the case, this loop terminates without encountering a bitmap effect // we will simply use the Matrix. while ((VisualTreeHelper.GetParent(g) != null) && (g != ancestor)) { Visual gAsVisual = g as Visual; if (gAsVisual != null) { if (gAsVisual.CheckFlagsAnd(VisualFlags.NodeHasEffect)) { // Only check for Effect, not legacy BitmapEffect. Previous // version had an incorrect BitmapEffect implementation // here, and there's no need to improve on our // BitmapEffect implementation if it didn't work // before. Effect imageEffect = EffectField.GetValue(gAsVisual); if (imageEffect != null) { GeneralTransform gt = imageEffect.CoerceToUnitSpaceGeneralTransform( imageEffect.EffectMapping, gAsVisual.VisualDescendantBounds); Transform affineTransform = gt.AffineTransform; if (affineTransform != null) { Matrix cm = affineTransform.Value; MatrixUtil.MultiplyMatrix(ref m, ref cm); } else { if (group == null) { group = new GeneralTransformGroup(); } group.Children.Add(new MatrixTransform(m)); m = Matrix.Identity; group.Children.Add(gt); } } } Transform transform = TransformField.GetValue(gAsVisual); if (transform != null) { Matrix cm = transform.Value; MatrixUtil.MultiplyMatrix(ref m, ref cm); } m.Translate(gAsVisual._offset.X, gAsVisual._offset.Y); // Consider having a bit that indicates that we have a non-null offset. g = gAsVisual._parent; } else { // we just hit a Visual3D - use a GeneralTransform to go from 2D -> 3D -> 2D // and then return to the tree using the 2D parent - the general transform will deal with the // actual transformation. This Visual3D also must be a Viewport2DVisual3D since this is the only // Visual3D that can have a 2D child. Viewport2DVisual3D gAsVisual3D = g as Viewport2DVisual3D; if (group == null) { group = new GeneralTransformGroup(); } group.Children.Add(new MatrixTransform(m)); m = Matrix.Identity; Visual visualForGenTransform = null; if (embedded2Don3D) { visualForGenTransform = gAsVisual3D.Visual; } else { visualForGenTransform = this; embedded2Don3D = true; } group.Children.Add(new GeneralTransform2DTo3DTo2D(gAsVisual3D, visualForGenTransform)); g = VisualTreeHelper.GetContainingVisual2D(gAsVisual3D); } } if (g != ancestor) { throw new System.InvalidOperationException(SR.Get(inverse ? SRID.Visual_NotADescendant : SRID.Visual_NotAnAncestor)); } // At this point, we will have 0 or more transforms in the GeneralTransformGroup // and the matrix which, if not identity, should be appended to the GeneralTransformGroup. // If, as is commonly the case, this loop terminates without encountering a bitmap effect // we will simply use the Matrix. // Assert that a non-null group implies at least one child Debug.Assert((group == null) || (group.Children.Count > 0)); // Do we have a group? if (group != null) { if (!m.IsIdentity) { group.Children.Add(new MatrixTransform(m)); } if (inverse) { group = (GeneralTransformGroup)group.Inverse; } // group can be null if it does not have an inverse if (group != null) { group.Freeze(); } // Initialize out params generalTransform = group; simpleTransform = new Matrix(); return false; // simple transform failed } // If not, the entire transform is stored in the matrix else { // Initialize out params generalTransform = null; if (inverse) { if (!m.HasInverse) { simpleTransform = new Matrix(); return false; // inversion failed, so simple transform failed. } m.Invert(); } simpleTransform = m; return true; // simple transform succeeded } }
public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { try { GeneralTransformGroup result = new GeneralTransformGroup(); result.Children.Add(base.GetDesiredTransform(transform)); result.Children.Add(new TranslateTransform(_leftOffset, _topOffset)); return result; } catch (Exception ex) { VMuktiAPI.VMuktiHelper.ExceptionHandler(ex, "GetDesiredTransform", "VMukti.Presentation.Controls.ModuleExplorer.DragDropAdorner"); return null; } }
// provides a transform that goes between the Visual's coordinate space // and that after applying the transforms that bring it to outer space. internal GeneralTransform TransformToOuterSpace() { Matrix m = Matrix.Identity; GeneralTransformGroup group = null; GeneralTransform result = null; if (CheckFlagsAnd(VisualFlags.NodeHasEffect)) { Effect effect = EffectField.GetValue(this); if (effect != null) { GeneralTransform gt = effect.CoerceToUnitSpaceGeneralTransform( effect.EffectMapping, VisualDescendantBounds); Transform affineTransform = gt.AffineTransform; if (affineTransform != null) { Matrix cm = affineTransform.Value; MatrixUtil.MultiplyMatrix(ref m, ref cm); } else { group = new GeneralTransformGroup(); group.Children.Add(gt); } } else { BitmapEffectState bitmapEffectState = BitmapEffectStateField.GetValue(this); // If we have an effect on this node and it isn't an Effect, it must be a BitmapEffect. // Since BitmapEffects are deprecated and ignored, they do not change a Visual's transform. Debug.Assert(bitmapEffectState != null); } } Transform transform = TransformField.GetValue(this); if (transform != null) { Matrix cm = transform.Value; MatrixUtil.MultiplyMatrix(ref m, ref cm); } m.Translate(_offset.X, _offset.Y); // Consider having a bit that indicates that we have a non-null offset. if (group == null) { result = new MatrixTransform(m); } else { group.Children.Add(new MatrixTransform(m)); result = group; } result.Freeze(); return result; }
//------------------------------------------------------ // // Public Methods // //------------------------------------------------------ #region Public Methods /// <summary> /// Add a transform so that the composition adorner gets positioned at the correct spot within the text being edited /// </summary> /// <param name="transform"> /// The transform applied to the object the adorner adorns /// </param> /// <returns> /// Transform to apply to the adorner /// </returns> public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { TranslateTransform translation; GeneralTransformGroup group = new GeneralTransformGroup(); // Get the matrix transform out, skip all non affine transforms Transform t = transform.AffineTransform; if (t == null) { t = Transform.Identity; } // Translate the adorner to (0, 0) point translation = new TranslateTransform(-(t.Value.OffsetX), -(t.Value.OffsetY)); group.Children.Add(translation); if (transform != null) { group.Children.Add(transform); } return group; }
/// <summary> /// Constructor /// </summary> /// <param name="visual3D">The Visual3D that contains the 2D visual</param> /// <param name="fromVisual">The visual on the Visual3D</param> internal GeneralTransform2DTo3DTo2D(Viewport2DVisual3D visual3D, Visual fromVisual) { IsInverse = false; // get a copy of the geometry information - we store our own model to reuse hit // test code on the GeometryModel3D _geometry = new MeshGeometry3D(); _geometry.Positions = visual3D.InternalPositionsCache; _geometry.TextureCoordinates = visual3D.InternalTextureCoordinatesCache; _geometry.TriangleIndices = visual3D.InternalTriangleIndicesCache; _geometry.Freeze(); Visual visual3Dchild = visual3D.Visual; // Special case - Setting CacheMode on V2DV3D causes an internal switch from using a VisualBrush // to using a BitmapCacheBrush. It also introduces an extra 2D Visual in the Visual tree above // the V2DV3D.Visual, but this extra node has no effect on transforms and can safely be ignored. // The transform returned will be identical to the one created for calling TransformTo* with // the V2DV3D.Visual itself. Visual descendentVisual = (fromVisual == visual3Dchild._parent) ? visual3Dchild : fromVisual; // get a copy of the size of the visual brush and the rect on the // visual that the transform is going to/from _visualBrushBounds = visual3Dchild.CalculateSubgraphRenderBoundsOuterSpace(); _visualBounds = descendentVisual.CalculateSubgraphRenderBoundsInnerSpace(); // get the transform that will let us go from the fromVisual to its last 2D // parent before it reaches the 3D part of the graph (i.e. visual3D.Child) GeneralTransformGroup transformGroup = new GeneralTransformGroup(); transformGroup.Children.Add(descendentVisual.TransformToAncestor(visual3Dchild)); transformGroup.Children.Add(visual3Dchild.TransformToOuterSpace()); transformGroup.Freeze(); _transform2D = transformGroup; // store the inverse as well _transform2DInverse = (GeneralTransform)_transform2D.Inverse; if (_transform2DInverse != null) { _transform2DInverse.Freeze(); } // make a copy of the camera and other values on the Viewport3D Viewport3DVisual viewport3D = (Viewport3DVisual)VisualTreeHelper.GetContainingVisual2D(visual3D); _camera = viewport3D.Camera; if (_camera != null) { _camera = (Camera)viewport3D.Camera.GetCurrentValueAsFrozen(); } _viewSize = viewport3D.Viewport.Size; _boundingRect = viewport3D.ComputeSubgraphBounds3D(); _objectToViewport = visual3D.TransformToAncestor(viewport3D); // if the transform was not possible, it could be null - check before freezing if (_objectToViewport != null) { _objectToViewport.Freeze(); } // store the needed transformations for the various operations _worldTransformation = M3DUtil.GetWorldTransformationMatrix(visual3D); _validEdgesCache = null; }
/// <summary> /// The returned matrix can be used to transform coordinates from this Visual to /// the specified Visual. /// Returns null if no such transform exists due to a non-invertible Transform. /// </summary> /// <exception cref="ArgumentNullException">If visual is null.</exception> /// <exception cref="InvalidOperationException">If the Visuals are not connected.</exception> public GeneralTransform TransformToVisual(Visual visual) { DependencyObject ancestor = FindCommonVisualAncestor(visual); Visual ancestorAsVisual = ancestor as Visual; if (ancestorAsVisual == null) { throw new System.InvalidOperationException(SR.Get(SRID.Visual_NoCommonAncestor)); } GeneralTransform g0; Matrix m0; bool isSimple0 = this.TrySimpleTransformToAncestor(ancestorAsVisual, false, out g0, out m0); GeneralTransform g1; Matrix m1; bool isSimple1 = visual.TrySimpleTransformToAncestor(ancestorAsVisual, true, out g1, out m1); // combine the transforms // if both transforms are simple Matrix transforms, just multiply them and // return the result. if (isSimple0 && isSimple1) { MatrixUtil.MultiplyMatrix(ref m0, ref m1); MatrixTransform m = new MatrixTransform(m0); m.Freeze(); return m; } // Handle the case where 0 is simple and 1 is complex. if (isSimple0) { g0 = new MatrixTransform(m0); g0.Freeze(); } else if (isSimple1) { g1 = new MatrixTransform(m1); g1.Freeze(); } // If inverse was requested, TrySimpleTransformToAncestor can return null // add the transform only if it is not null if (g1 != null) { GeneralTransformGroup group = new GeneralTransformGroup(); group.Children.Add(g0); group.Children.Add(g1); group.Freeze(); return group; } return g0; }
private GeneralTransform GetTabletToElementTransform(IInputElement relativeTo) { GeneralTransformGroup group = new GeneralTransformGroup(); group.Children.Add(new MatrixTransform(_stylusLogic.GetTabletToViewTransform(TabletDevice))); group.Children.Add(GetElementTransform(relativeTo)); return group; }
//-------------------------------------------------------------- /// <summary> /// Returns a <see cref="Transform"/> for the adorner, based on the transform that is /// currently applied to the adorned element. /// </summary> /// <param name="transform"> /// The transform that is currently applied to the adorned element. /// </param> /// <returns>A transform to apply to the adorner.</returns> public override GeneralTransform GetDesiredTransform(GeneralTransform transform) { var baseTransform = base.GetDesiredTransform(transform); var localTransform = new TranslateTransform(_horizontalOffset, _verticalOffset); if (baseTransform != null) { // Add translation to original transform. var result = new GeneralTransformGroup(); result.Children.Add(baseTransform); result.Children.Add(localTransform); return result; } return localTransform; }