public override void Echo(TimeScaler Scaler) { using (DrawingContext dc = this.RenderOpen()) { if (Line.Header != null) { var ft = new FormattedText(Line.Header, System.Globalization.CultureInfo.CurrentCulture, System.Windows.FlowDirection.LeftToRight, LabelTypeFace, 10, Foreground); var x = Scaler.GetHorizontalOffset(Scaler.LeftDate) + 1; var w = ft.Width + 4; var y = Scaler.GetVerticalOffset(this.Line) + 1; var h = ft.Height + 2; Rect r = new Rect(x, y, w, h); r = RoundRect(r); var gl = new GuidelineSet(); AddRectToGuidlineSet(gl, r); dc.PushGuidelineSet(gl); dc.DrawRoundedRectangle(Background, null, r, 2, 2); dc.DrawText(ft, new Point(x + 2, y + 1)); dc.Pop(); // GuidelineSet } } }
/// <summary> /// Добавляет в GuidelineSet значения привязок для границ прямоугольника /// </summary> /// <param name="gl">GuidelineSet для добавления</param> /// <param name="r">Ограничиваемый прямоугольник</param> /// <param name="PenThickness">Толщина границы прямоугольника</param> protected void AddRectToGuidlineSet(GuidelineSet gl, Rect r, Double PenThickness = 0) { gl.GuidelinesX.Add(GetGuideline(r.Left, PenThickness)); gl.GuidelinesX.Add(GetGuideline(r.Right, PenThickness)); gl.GuidelinesY.Add(GetGuideline(r.Top, PenThickness)); gl.GuidelinesY.Add(GetGuideline(r.Bottom, PenThickness)); }
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which will apply to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public override void PushGuidelineSet( GuidelineSet guidelines) { _drawingContext.PushGuidelineSet( guidelines ); }
private static GuidelineSet CreateGuidelineSet(Pen pen, Rect rect) { var halfPenWidth = pen.Thickness / 2; var guidelines = new GuidelineSet(new[] {rect.Left - halfPenWidth, rect.Right - halfPenWidth}, new [] {rect.Top - halfPenWidth, rect.Bottom - halfPenWidth}); return guidelines; }
private static void IsDynamicPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { GuidelineSet target = ((GuidelineSet)d); target.PropertyChanged(IsDynamicProperty); }
protected override void OnRender(DrawingContext drawingContext) { var fe = AdornedElement as FrameworkElement; if (fe == null) { return; } var rect = new Rect(1, 1, Math.Max(0, fe.ActualWidth - 2), Math.Max(0, fe.ActualHeight - 2)); var color = Colors.Red; var brush = new SolidColorBrush(color); var pen = new Pen(brush, 1); pen.Freeze(); var dashPen = new Pen(brush, 1) { DashStyle = new DashStyle(new double[] { 1, 6 }, 0) }; dashPen.Freeze(); var guidelineSet = new GuidelineSet(); guidelineSet.GuidelinesX.Add(0.5); guidelineSet.GuidelinesY.Add(0.5); //var outlinePen = new Pen(new SolidColorBrush(Color.FromArgb(0x70, 0xFF, 0xFF, 0xFF)), 5); //outlinePen.Freeze(); drawingContext.PushGuidelineSet(guidelineSet); //drawingContext.DrawRectangle(null, outlinePen, rect); drawingContext.DrawRectangle(null, pen, rect); //var parent = VisualTreeHelper.GetParent(fe) as FrameworkElement; //if (parent != null) //{ // var thisLeft = new Point(0, fe.ActualHeight / 2); // var thisRight = new Point(fe.ActualWidth, fe.ActualHeight / 2); // var thisTop = new Point(fe.ActualWidth / 2, 0); // var thisBottom = new Point(fe.ActualWidth / 2, fe.ActualHeight); // var ancestorLeft = new Point(parent.TranslatePoint(thisLeft, fe).X, thisLeft.Y); // var ancestorRight = ancestorLeft + new Vector(parent.ActualWidth, 0); // var ancestorTop = new Point(thisTop.X, parent.TranslatePoint(new Point(), fe).Y); // var ancestorBottom = new Point(thisBottom.X, parent.TranslatePoint(new Point(), fe).Y + parent.ActualHeight); // var leftPen = fe.HorizontalAlignment == HorizontalAlignment.Left || fe.HorizontalAlignment == HorizontalAlignment.Stretch ? pen : dashPen; // var rightPen = fe.HorizontalAlignment == HorizontalAlignment.Right || fe.HorizontalAlignment == HorizontalAlignment.Stretch ? pen : dashPen; // var topPen = fe.VerticalAlignment == VerticalAlignment.Top || fe.VerticalAlignment == VerticalAlignment.Stretch ? pen : dashPen; // var bottomPen = fe.VerticalAlignment == VerticalAlignment.Bottom || fe.VerticalAlignment == VerticalAlignment.Stretch ? pen : dashPen; // drawingContext.DrawLine(leftPen, thisLeft, ancestorLeft); // drawingContext.DrawLine(rightPen, thisRight, ancestorRight); // drawingContext.DrawLine(topPen, thisTop, ancestorTop); // drawingContext.DrawLine(bottomPen, thisBottom, ancestorBottom); //} var formattedHeight = new FormattedText(string.Format("{0:0}", fe.ActualHeight), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, TypeFace, 10, brush); var formattedWidth = new FormattedText(string.Format("{0:0}", fe.ActualWidth), CultureInfo.InvariantCulture, FlowDirection.LeftToRight, TypeFace, 10, brush); drawingContext.DrawText(formattedHeight, new Point(rect.Width + 5, (rect.Height / 2) - (formattedHeight.Height / 2))); drawingContext.DrawText(formattedWidth, new Point(rect.Width / 2 - formattedWidth.Width / 2, rect.Height + 5)); drawingContext.Pop(); }
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which should be applied /// to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public override void PushGuidelineSet( GuidelineSet guidelines) { if (!IsPushNoOp()) { // This Push doesn't affect the hit test, so just push the current point PushPointStack(_point); } }
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which should be applied /// to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public override void PushGuidelineSet( GuidelineSet guidelines) { // Push the guidelines type PushTypeStack(PushType.Guidelines); // Nothing else to do. Guidelines are not used, // so we only need to register Push() type in order to treat // Pop() properly. }
private static GuidelineSet CreateGuidelineSet(Pen pen, Rect rect) { var halfPenWidth = pen.Thickness / 2; var guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rect.Left + halfPenWidth); guidelines.GuidelinesX.Add(rect.Right + halfPenWidth); guidelines.GuidelinesY.Add(rect.Top + halfPenWidth); guidelines.GuidelinesY.Add(rect.Bottom + halfPenWidth); return guidelines; }
public static void DrawGuideLineLine(this DrawingContext dc, Pen pen, Point point0, Point point1) { var halfPenWidth = pen.Thickness / 2; var guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(point0.X + halfPenWidth); guidelines.GuidelinesX.Add(point1.X + halfPenWidth); guidelines.GuidelinesY.Add(point0.Y + halfPenWidth); guidelines.GuidelinesY.Add(point1.Y + halfPenWidth); dc.PushGuidelineSet(guidelines); dc.DrawLine(pen, point0, point1); dc.Pop(); }
public void DrawPoint(double x, double y) { rectPoint.X = x; rectPoint.Y = y; using (DrawingContext dc = this.RenderOpen()) { GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rectPoint.Left + halfPenWidth); guidelines.GuidelinesX.Add(rectPoint.Right + halfPenWidth); guidelines.GuidelinesY.Add(rectPoint.Top + halfPenWidth); guidelines.GuidelinesY.Add(rectPoint.Bottom + halfPenWidth); dc.PushGuidelineSet(guidelines); dc.DrawRectangle(scbBkg, null, rectPoint); dc.Pop(); } }
protected override void OnRender(DrawingContext drawingContext) { Pen pen = new Pen(Brushes.Gray, 1); Pen penDash = new Pen(Brushes.Silver, 1) { DashStyle = DashStyles.Dash }; Rect rect = new Rect(20, 20, 50, 60); double halfPenWidth = pen.Thickness / 2; TimeSpan StartTime = TimeSpan.FromHours(6); TimeSpan EndTime = TimeSpan.FromHours(24); GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rect.Left + halfPenWidth); guidelines.GuidelinesX.Add(rect.Right + halfPenWidth); guidelines.GuidelinesY.Add(rect.Top + halfPenWidth); guidelines.GuidelinesY.Add(rect.Bottom + halfPenWidth); drawingContext.PushGuidelineSet(guidelines); TimeSpan tmpTime = StartTime; int drawHours = (int)EndTime.Subtract(StartTime).TotalHours; double segmentHeight = this.ActualHeight / drawHours; for (int i = 0; i < drawHours; i++) { int y = (int)(segmentHeight * i); drawingContext.DrawLine(pen, new Point(0, y), new Point(this.ActualWidth, y)); int y2 = (int)(y + segmentHeight / 2); drawingContext.DrawLine(penDash, new Point(0, y2), new Point(this.ActualWidth, y2)); drawingContext.DrawText(new FormattedText( tmpTime.ToString(@"h\:mm"), System.Globalization.CultureInfo.CurrentCulture, FlowDirection.RightToLeft, new Typeface("Segoe UI"), 12, Brushes.Black, null, TextFormattingMode.Display),new Point(this.ActualWidth, y)); tmpTime = tmpTime.Add(TimeSpan.FromHours(1)); } TimeSpan timeNow = new TimeSpan(DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second).Subtract(StartTime); double h = segmentHeight * (timeNow.TotalHours); drawingContext.DrawLine(new Pen(Brushes.Red, 1), new Point(0, h), new Point(this.ActualWidth, h)); drawingContext.Pop(); }
public GuidelineSetBlock( DrawingContext target, IEnumerable<double> xGuides = null, IEnumerable<double> yGuides = null) { Debug.Assert(target != null); _target = target; var guidelines = new GuidelineSet(); { xGuides?.ForEach(g => guidelines.GuidelinesX.Add(g)); yGuides?.ForEach(g => guidelines.GuidelinesY.Add(g)); } target.PushGuidelineSet(guidelines); }
public void UpdateVisual() { using (DrawingContext dc = base.RenderOpen()) { GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(this.Offset.X); guidelines.GuidelinesY.Add(this.Offset.Y); dc.PushGuidelineSet(guidelines); Render.DrawingRenderer renderer = new Render.DrawingRenderer(dc); renderer.Begin(); CircuitElement.Render(renderer, false); renderer.End(); } }
public void DrawBlood(double x, double y) { rectBlood.X = x; rectBlood.Y = y; using (DrawingContext dc = this.RenderOpen()) { halfPenWidth = (pen.Thickness * 1) / 2; GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rectBlood.Left + halfPenWidth); guidelines.GuidelinesX.Add(rectBlood.Right + halfPenWidth); guidelines.GuidelinesY.Add(rectBlood.Top + halfPenWidth); guidelines.GuidelinesY.Add(rectBlood.Bottom + halfPenWidth); dc.PushGuidelineSet(guidelines); dc.DrawRectangle(scbBkg, null, rectBlood); dc.Pop(); } }
public void DrawPointAndShadow(double x, double y) { rectPoint.X = x; rectPoint.Y = y; using (DrawingContext dc = this.RenderOpen()) { GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rectPoint.Left + halfPenWidth); guidelines.GuidelinesX.Add(rectPoint.Right + halfPenWidth); guidelines.GuidelinesY.Add(rectPoint.Top + halfPenWidth); guidelines.GuidelinesY.Add(rectPoint.Bottom + halfPenWidth); dc.PushGuidelineSet(guidelines); dc.DrawRectangle(scbBkg, null, rectPoint); dc.Pop(); if (shadow!=null) dc.DrawImage(shadow, new Rect(x - 18, y - 4, shadow.PixelWidth, shadow.PixelHeight)); } }
private static void GuidelineSetPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { // The first change to the default value of a mutable collection property (e.g. GeometryGroup.Children) // will promote the property value from a default value to a local value. This is technically a sub-property // change because the collection was changed and not a new collection set (GeometryGroup.Children. // Add versus GeometryGroup.Children = myNewChildrenCollection). However, we never marshalled // the default value to the compositor. If the property changes from a default value, the new local value // needs to be marshalled to the compositor. We detect this scenario with the second condition // e.OldValueSource != e.NewValueSource. Specifically in this scenario the OldValueSource will be // Default and the NewValueSource will be Local. if (e.IsASubPropertyChange && (e.OldValueSource == e.NewValueSource)) { return; } DrawingGroup target = ((DrawingGroup)d); GuidelineSet oldV = (GuidelineSet)e.OldValue; GuidelineSet newV = (GuidelineSet)e.NewValue; System.Windows.Threading.Dispatcher dispatcher = target.Dispatcher; if (dispatcher != null) { DUCE.IResource targetResource = (DUCE.IResource)target; using (CompositionEngineLock.Acquire()) { int channelCount = targetResource.GetChannelCount(); for (int channelIndex = 0; channelIndex < channelCount; channelIndex++) { DUCE.Channel channel = targetResource.GetChannel(channelIndex); Debug.Assert(!channel.IsOutOfBandChannel); Debug.Assert(!targetResource.GetHandle(channel).IsNull); target.ReleaseResource(oldV, channel); target.AddRefResource(newV, channel); } } } target.PropertyChanged(GuidelineSetProperty); }
internal override DUCE.ResourceHandle AddRefOnChannelCore(DUCE.Channel channel) { if (_duceResource.CreateOrAddRefOnChannel(this, channel, System.Windows.Media.Composition.DUCE.ResourceType.TYPE_DRAWINGGROUP)) { Geometry vClipGeometry = ClipGeometry; if (vClipGeometry != null) { ((DUCE.IResource)vClipGeometry).AddRefOnChannel(channel); } Brush vOpacityMask = OpacityMask; if (vOpacityMask != null) { ((DUCE.IResource)vOpacityMask).AddRefOnChannel(channel); } Transform vTransform = Transform; if (vTransform != null) { ((DUCE.IResource)vTransform).AddRefOnChannel(channel); } GuidelineSet vGuidelineSet = GuidelineSet; if (vGuidelineSet != null) { ((DUCE.IResource)vGuidelineSet).AddRefOnChannel(channel); } DrawingCollection vChildren = Children; if (vChildren != null) { int count = vChildren.Count; for (int i = 0; i < count; i++) { ((DUCE.IResource)vChildren.Internal_GetItem(i)).AddRefOnChannel(channel); } } AddRefOnChannelAnimations(channel); UpdateResource(channel, true /* skip "on channel" check - we already know that we're on channel */); } return(_duceResource.GetHandle(channel)); }
public void DrawLine(Pen p, Point startPoint, Point endPoint) { #if !GRID_GUIDELINE double halfPenWidth = p.Thickness / 2; // Create a guidelines set System.Windows.Media.GuidelineSet guidelines = new System.Windows.Media.GuidelineSet(); guidelines.GuidelinesX.Add(startPoint.X + halfPenWidth); guidelines.GuidelinesY.Add(startPoint.Y + halfPenWidth); g.PushGuidelineSet(guidelines); #endif // GRID_GUIDELINE g.DrawLine(p, (System.Windows.Point)startPoint, (System.Windows.Point)endPoint); #if !GRID_GUIDELINE g.Pop(); #endif // GRID_GUIDELINE }
protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); Pen pen = new Pen(LineBrush, 1); GuidelineSet gs = new GuidelineSet(); gs.GuidelinesX.Clear(); gs.GuidelinesY.Clear(); gs.GuidelinesY.Add(_lastPoint.Y - 0.5); gs.GuidelinesY.Add(_lastPoint.Y + 0.5); drawingContext.PushGuidelineSet(gs.Clone()); drawingContext.DrawLine(pen, new Point(0, _lastPoint.Y), new Point(ActualWidth, _lastPoint.Y)); drawingContext.PushGuidelineSet(gs.Clone()); gs.GuidelinesX.Clear(); gs.GuidelinesY.Clear(); gs.GuidelinesX.Add(_lastPoint.X - 0.5); gs.GuidelinesX.Add(_lastPoint.X + 0.5); drawingContext.PushGuidelineSet(gs.Clone()); drawingContext.DrawLine(pen, new Point(_lastPoint.X, 0), new Point(_lastPoint.X, ActualHeight)); drawingContext.PushGuidelineSet(gs.Clone()); }
//for linescontrol public static void DrawColumnLines(this FrameworkElement element, DrawingContext drawingContext, double RowWidth, double xOffset,double offset,Pen pen) { double halfPenHeight = pen.Thickness / 2; Point start = new Point(0, 0); Point end = new Point(0, element.RenderSize.Height); GuidelineSet guidelines = new GuidelineSet(); //draw column var count = Convert.ToInt32(element.RenderSize.Width / RowWidth); for (int i = 1; i <= count; i++) { start.X = xOffset - offset; end.X = xOffset - offset; guidelines.GuidelinesX = new DoubleCollection(new[] { xOffset - halfPenHeight, xOffset + halfPenHeight }); drawingContext.PushGuidelineSet(guidelines); drawingContext.DrawLine(pen, start, end); drawingContext.Pop(); xOffset += RowWidth; } }
internal override void ReleaseOnChannelCore(DUCE.Channel channel) { Debug.Assert(_duceResource.IsOnChannel(channel)); if (_duceResource.ReleaseOnChannel(channel)) { Geometry vClipGeometry = ClipGeometry; if (vClipGeometry != null) { ((DUCE.IResource)vClipGeometry).ReleaseOnChannel(channel); } Brush vOpacityMask = OpacityMask; if (vOpacityMask != null) { ((DUCE.IResource)vOpacityMask).ReleaseOnChannel(channel); } Transform vTransform = Transform; if (vTransform != null) { ((DUCE.IResource)vTransform).ReleaseOnChannel(channel); } GuidelineSet vGuidelineSet = GuidelineSet; if (vGuidelineSet != null) { ((DUCE.IResource)vGuidelineSet).ReleaseOnChannel(channel); } DrawingCollection vChildren = Children; if (vChildren != null) { int count = vChildren.Count; for (int i = 0; i < count; i++) { ((DUCE.IResource)vChildren.Internal_GetItem(i)).ReleaseOnChannel(channel); } } ReleaseOnChannelAnimations(channel); } }
public override void Echo(TimeScaler Scaler) { //this.Opacity = 0.5; using (DrawingContext dc = this.RenderOpen()) { var x = Scaler.GetHorizontalOffset(StartDate); var w = Scaler.GetWidth(EndDate - StartDate); var y = Scaler.GetVerticalOffset(this.Line); var h = Scaler.GetHeight(this.Line); Rect r = new Rect(x, y + h * (1 - Value), w, h * Value); r = RoundRect(r); var gl = new GuidelineSet(); AddRectToGuidlineSet(gl, r, 0); dc.PushGuidelineSet(gl); dc.DrawRectangle(Background, null, r); dc.Pop(); // GuidelineSet } }
public static void DrawPoint(DrawingContext dc, Point? point,string fromColor, string toColor, double duration, bool isAutoReverse) { SolidColorBrush scbW = new SolidColorBrush(Colors.Black); ColorAnimation myAnimation = new ColorAnimation((Color)ColorConverter.ConvertFromString(fromColor), (Color)ColorConverter.ConvertFromString(toColor), new Duration(TimeSpan.FromSeconds(duration))); myAnimation.AutoReverse = isAutoReverse; myAnimation.RepeatBehavior = RepeatBehavior.Forever; scbW.BeginAnimation(SolidColorBrush.ColorProperty, myAnimation); Pen wpen = new Pen(scbW, 1); Rect rectW = new Rect(point.Value.X, point.Value.Y, 0.1, 0.1); double halfPenWidth = wpen.Thickness / 2; GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rectW.Left + halfPenWidth); guidelines.GuidelinesX.Add(rectW.Right + halfPenWidth); guidelines.GuidelinesY.Add(rectW.Top + halfPenWidth); guidelines.GuidelinesY.Add(rectW.Bottom + halfPenWidth); dc.PushGuidelineSet(guidelines); dc.DrawRectangle(null, wpen, rectW); dc.Pop(); }
/// <summary> /// OnRender method. /// </summary> /// <param name="drawingContext">Drawing context.</param> protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); if (TimeAxis.ZoomMode == ZoomMode.FrameLevel) { GuidelineSet gs = new GuidelineSet(); Pen pen = new Pen(Brushes.LightGray, 1); double halfPen = pen.Thickness / 2; // draw time line for each frame for (int i = 0; i <= ActualWidth / ViewHelper.TimespanToPixel(TimeAxis.SampleInterval, TimeAxis.ZoomScale); ++i) { double x = ViewHelper.TimespanToPixel(TimeAxis.SampleInterval * (double)i, TimeAxis.ZoomScale); gs.GuidelinesX.Clear(); gs.GuidelinesX.Add(x - halfPen); gs.GuidelinesX.Add(x + halfPen); drawingContext.PushGuidelineSet(gs.Clone()); drawingContext.DrawLine(pen, new Point(x, 0), new Point(x, Height)); drawingContext.Pop(); } } }
public override void Echo(TimeScaler Scaler) { using (DrawingContext dc = this.RenderOpen()) { var x = Scaler.GetHorizontalOffset(StartDate); var w = Scaler.GetWidth(EndDate - StartDate); var y = Scaler.GetVerticalOffset(this.Line); var h = Scaler.GetHeight(this.Line); Pen pb = new Pen(StrokeBrush ?? Background, 1); Rect r = new Rect(x, y, w, h); r = RoundRect(r); var gl = new GuidelineSet(); AddRectToGuidlineSet(gl, r, pb.Thickness); dc.PushGuidelineSet(gl); dc.DrawRectangle(Background, pb, r); if (LabelText != null) { var ZeroX = Scaler.GetHorizontalOffset(Scaler.LeftDate); var TextX = Math.Max(x, ZeroX) + 2; var ft = new FormattedText(this.LabelText, System.Globalization.CultureInfo.CurrentCulture, System.Windows.FlowDirection.LeftToRight, LabelTypeFace, 8, Foreground); if (TextX + ft.Width + 10 <= x + w) dc.DrawText(ft, new Point(TextX, y + 3)); } dc.Pop(); // GuidelineSet } }
public GuidelineSetBlock( DrawingContext target, Rect rect, double rectPenWidth = 0, IEnumerable<double> xGuides = null, IEnumerable<double> yGuides = null) { Debug.Assert(target != null); _target = target; var guidelines = new GuidelineSet(); { guidelines.GuidelinesX.Add(rect.Left + rectPenWidth*0.5); guidelines.GuidelinesX.Add(rect.Right + rectPenWidth*0.5); guidelines.GuidelinesY.Add(rect.Top + rectPenWidth*0.5); guidelines.GuidelinesY.Add(rect.Bottom + rectPenWidth*0.5); xGuides?.ForEach(g => guidelines.GuidelinesX.Add(g)); yGuides?.ForEach(g => guidelines.GuidelinesY.Add(g)); } target.PushGuidelineSet(guidelines); }
public abstract void PushGuidelineSet(GuidelineSet set);
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which should be applied /// to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public override void PushGuidelineSet( GuidelineSet guidelines) { // GuidelineSet does not affect hit testing, but requires a place-holder on the stack PushModifierStack(null); }
protected override void OnRender(DrawingContext dc) { if (!guidelinesFixed) { System.Windows.Media.Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice; halfDpiX = m.M11 * 0.5; halfDpiY = m.M22 * 0.5; guidelinesFixed = true; } // Create a guidelines set GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(halfDpiX); guidelines.GuidelinesY.Add(halfDpiY); dc.PushGuidelineSet(guidelines); dc.DrawRectangle(backgroundBrush, null, new Rect(0, 0, ActualWidth, ActualHeight)); double range; double pos = 0; double orderOfMag; double stepSize = 0.1; switch (Orientation) { case RulerOrientation.Vertical: //// Thin horizontal lines //range = MaxY - MinY; //orderOfMag = Math.Pow(10, Math.Truncate(Math.Log10(range))); //stepSize = 0.1 * orderOfMag; pos = (Math.Truncate(MinY / stepSize) - 0) * stepSize; //DrawGridHorizonalLines(dc, pos, stepSize, gridLinePen); break; case RulerOrientation.Horizontal: // Thin vertical lines. //range = MaxX - MinX; //orderOfMag = Math.Pow(10, Math.Truncate(Math.Log10(range))); //stepSize = 0.1 * orderOfMag; pos = Math.Truncate(MinX / stepSize) * stepSize; //DrawGridVerticalLines(dc, pos, stepSize, gridLinePen); // Draw the seek needle var needlePos = new System.Windows.Point(NeedlePosition, 0); needlePos = CurveCoordsToScreen(ref needlePos); dc.PushTransform(new TranslateTransform(needlePos.X, needlePos.Y)); dc.DrawDrawing(SeekNeedle); dc.Pop(); break; } dc.Pop(); switch (Orientation) { case RulerOrientation.Vertical: DrawHorizontalLinesText(dc, pos, stepSize); break; case RulerOrientation.Horizontal: DrawVerticalLinesText(dc, pos, stepSize); break; } base.OnRender(dc); }
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which will apply to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public override void PushGuidelineSet( GuidelineSet guidelines) { _drawingContext.PushGuidelineSet( guidelines ); }
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which should be applied /// to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public override void PushGuidelineSet( GuidelineSet guidelines) { // GuidelineSet does not affect hit testing, but requires a place-holder on the stack PushModifierStack(null); }
protected override void OnRender(DrawingContext ctx) { base.OnRender(ctx); if (ctx != null) { // only solid brush is supported now var brush = (IsContentActive ? ActiveBorderBrush : InactiveBorderBrush) as SolidColorBrush; if (brush != null) { Rect rClient = new Rect(0, 0, this.ActualWidth, this.ActualHeight); var thick = BorderThickness; var clientW = rClient.Width - thick.Right - thick.Left;// -1; var clientH = rClient.Height - thick.Top - thick.Bottom;// -1; if (clientW > 1 && clientH > 1) { rClient.X += thick.Left; rClient.Y += thick.Top; rClient.Width = clientW; rClient.Height = clientH; var rTop = new Rect(rClient.Left, 0, rClient.Width, thick.Top); var rTopLeft = new Rect(0, 0, thick.Left, thick.Top); var rTopRight = new Rect(rClient.Right, 0, thick.Right, thick.Top); var rBottom = new Rect(rClient.Left, rClient.Bottom, rClient.Width, thick.Bottom); var rBottomLeft = new Rect(0, rClient.Bottom, thick.Left, thick.Bottom); var rBottomRight = new Rect(rClient.Right, rClient.Bottom, thick.Right, thick.Bottom); var rLeft = new Rect(0, rClient.Top, thick.Left, rClient.Height); var rRight = new Rect(rClient.Right, rClient.Top, thick.Right, rClient.Height); var brushes = GetShadowBrushes(brush.Color);//, (thick.Top + thick.Bottom + thick.Right + thick.Left) / 4); ctx.DrawRectangle(brushes[(int)BorderSide.TopLeft], null, rTopLeft); ctx.DrawRectangle(brushes[(int)BorderSide.TopRight], null, rTopRight); ctx.DrawRectangle(brushes[(int)BorderSide.Top], null, rTop); ctx.DrawRectangle(brushes[(int)BorderSide.BottomLeft], null, rBottomLeft); ctx.DrawRectangle(brushes[(int)BorderSide.BottomRight], null, rBottomRight); ctx.DrawRectangle(brushes[(int)BorderSide.Bottom], null, rBottom); ctx.DrawRectangle(brushes[(int)BorderSide.Left], null, rLeft); ctx.DrawRectangle(brushes[(int)BorderSide.Right], null, rRight); Pen borderPen = new Pen(brush, 1); // from http://wpftutorial.net/DrawOnPhysicalDevicePixels.html double halfPenWidth = borderPen.Thickness / 2; // Create a guidelines set GuidelineSet guidelines = new GuidelineSet(); guidelines.GuidelinesX.Add(rClient.Left + halfPenWidth); guidelines.GuidelinesX.Add(rClient.Right + halfPenWidth); guidelines.GuidelinesY.Add(rClient.Top + halfPenWidth); guidelines.GuidelinesY.Add(rClient.Bottom + halfPenWidth); ctx.PushGuidelineSet(guidelines); rClient.X -= 1; rClient.Y -= 1; rClient.Width += 1; rClient.Height += 1; ctx.DrawRectangle(null, borderPen, rClient); //ctx.DrawRectangle(null, new Pen(Brushes.Red, 1), rect); } } } }
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which will apply to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public abstract void PushGuidelineSet( GuidelineSet guidelines);
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which should be applied /// to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public override void PushGuidelineSet( GuidelineSet guidelines) { if (!IsPushNoOp()) { // This Push doesn't affect the hit test, so just push the current point PushPointStack(_point); } }
protected override void OnRender( DrawingContext drawingContext ) { if( this.ConnectionLinePen != null ) { bool left = false; bool top = false; bool middle = false; switch( this.ConnectionLineAlignment ) { case ConnectionLineAlignment.LeftToBottom: left = true; break; case ConnectionLineAlignment.RightToTop: top = true; break; case ConnectionLineAlignment.LeftToTop: left = true; top = true; break; case ConnectionLineAlignment.CenterToCenter: middle = true; break; case ConnectionLineAlignment.RightToBottom: default: break; } //cycling with count -1 because we don't want to draw a ligne after last item for( int i = 0; i < this.InternalChildren.Count - 1; i++ ) { UIElement startItem = this.InternalChildren[ i ]; UIElement endItem = this.InternalChildren[ i + 1 ]; Vector startOffset = VisualTreeHelper.GetOffset( startItem ); Vector endOffset = VisualTreeHelper.GetOffset( endItem ); Size startSize = startItem.RenderSize; Size endSize = endItem.RenderSize; double startPointX = 0.0d; double startPointY = 0.0d; double endPointX = 0.0d; double endPointY = 0.0d; List<PathSegment> myPathSegments = null; GuidelineSet guidelineSet = new GuidelineSet(); drawingContext.PushGuidelineSet( guidelineSet ); if( middle == true ) { startPointX = startOffset.X + startSize.Width + this.ConnectionLineOffset; startPointY = startOffset.Y + ( startSize.Height / 2 ); endPointY = endOffset.Y + ( endSize.Height / 2 ); endPointX = endOffset.X - this.ConnectionLineOffset; double deltaX = ( endPointX - startPointX ); guidelineSet.GuidelinesX.Add( startPointX ); guidelineSet.GuidelinesX.Add( startPointX + ( deltaX / 2 ) + 0.5d ); guidelineSet.GuidelinesX.Add( startPointX + deltaX ); guidelineSet.GuidelinesY.Add( startPointY ); guidelineSet.GuidelinesY.Add( endPointY ); myPathSegments = new List<PathSegment>( 4 ); //we know there are going be only 4 segments myPathSegments.Add( new LineSegment( new Point( startPointX, startPointY ), true ) ); myPathSegments.Add( new LineSegment( new Point( startPointX + ( deltaX / 2 ), startPointY ), true ) ); myPathSegments.Add( new LineSegment( new Point( startPointX + ( deltaX / 2 ), endPointY ), true ) ); myPathSegments.Add( new LineSegment( new Point( startPointX + deltaX, endPointY ), true ) ); } else { if( left == true ) { startPointX = startOffset.X + this.ConnectionLineOffset; } else { startPointX = startOffset.X + startSize.Width - this.ConnectionLineOffset; } startPointY = startOffset.Y + startSize.Height; if( top == true ) { endPointY = endOffset.Y + this.ConnectionLineOffset; } else { endPointY = endOffset.Y + endSize.Height - this.ConnectionLineOffset; } endPointX = endOffset.X; guidelineSet.GuidelinesX.Add( startPointX ); guidelineSet.GuidelinesX.Add( endPointX ); guidelineSet.GuidelinesY.Add( startPointY ); guidelineSet.GuidelinesY.Add( endPointY ); myPathSegments = new List<PathSegment>( 2 ); //we know there are going be only 2 segments myPathSegments.Add( new LineSegment( new Point( startPointX, endPointY ), true ) ); myPathSegments.Add( new LineSegment( new Point( endPointX, endPointY ), true ) ); } PathFigure myPathFigure = new PathFigure( new Point( startPointX, startPointY ), myPathSegments, false ); PathGeometry myPathGeometry = new PathGeometry(); myPathGeometry.Figures.Add( myPathFigure ); drawingContext.DrawGeometry( null, this.ConnectionLinePen, myPathGeometry ); // pop the context to remove the GuidelineSet drawingContext.Pop(); } } base.OnRender( drawingContext ); }
//------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ #region Internal Methods internal override void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck) { // If we're told we can skip the channel check, then we must be on channel Debug.Assert(!skipOnChannelCheck || _duceResource.IsOnChannel(channel)); if (skipOnChannelCheck || _duceResource.IsOnChannel(channel)) { base.UpdateResource(channel, skipOnChannelCheck); // Read values of properties into local variables DrawingCollection vChildren = Children; Geometry vClipGeometry = ClipGeometry; Brush vOpacityMask = OpacityMask; Transform vTransform = Transform; GuidelineSet vGuidelineSet = GuidelineSet; // Obtain handles for properties that implement DUCE.IResource DUCE.ResourceHandle hClipGeometry = vClipGeometry != null ? ((DUCE.IResource)vClipGeometry).GetHandle(channel) : DUCE.ResourceHandle.Null; DUCE.ResourceHandle hOpacityMask = vOpacityMask != null ? ((DUCE.IResource)vOpacityMask).GetHandle(channel) : DUCE.ResourceHandle.Null; DUCE.ResourceHandle hTransform; if (vTransform == null || Object.ReferenceEquals(vTransform, Transform.Identity) ) { hTransform = DUCE.ResourceHandle.Null; } else { hTransform = ((DUCE.IResource)vTransform).GetHandle(channel); } DUCE.ResourceHandle hGuidelineSet = vGuidelineSet != null ? ((DUCE.IResource)vGuidelineSet).GetHandle(channel) : DUCE.ResourceHandle.Null; // Obtain handles for animated properties DUCE.ResourceHandle hOpacityAnimations = GetAnimationResourceHandle(OpacityProperty, channel); // Store the count of this resource's contained collections in local variables. int ChildrenCount = (vChildren == null) ? 0 : vChildren.Count; // Pack & send command packet DUCE.MILCMD_DRAWINGGROUP data; unsafe { data.Type = MILCMD.MilCmdDrawingGroup; data.Handle = _duceResource.GetHandle(channel); data.ChildrenSize = (uint)(sizeof(DUCE.ResourceHandle) * ChildrenCount); data.hClipGeometry = hClipGeometry; if (hOpacityAnimations.IsNull) { data.Opacity = Opacity; } data.hOpacityAnimations = hOpacityAnimations; data.hOpacityMask = hOpacityMask; data.hTransform = hTransform; data.hGuidelineSet = hGuidelineSet; data.EdgeMode = (EdgeMode)GetValue(RenderOptions.EdgeModeProperty); data.bitmapScalingMode = (BitmapScalingMode)GetValue(RenderOptions.BitmapScalingModeProperty); data.ClearTypeHint = (ClearTypeHint)GetValue(RenderOptions.ClearTypeHintProperty); channel.BeginCommand( (byte *)&data, sizeof(DUCE.MILCMD_DRAWINGGROUP), (int)(data.ChildrenSize) ); // Copy this collection's elements (or their handles) to reserved data for (int i = 0; i < ChildrenCount; i++) { DUCE.ResourceHandle resource = ((DUCE.IResource)vChildren.Internal_GetItem(i)).GetHandle(channel);; channel.AppendCommandData( (byte *)&resource, sizeof(DUCE.ResourceHandle) ); } channel.EndCommand(); } } }
private static void DrawPathGeometryInternal(DrawingContext dc, double half, Brush brush, Pen pen, bool isStroked, bool isFilled, PathGeometry pg) { if (!isStroked && !isFilled) return; var gs = new GuidelineSet( new double[] { pg.Bounds.TopLeft.X + half, pg.Bounds.BottomRight.X + half }, new double[] { pg.Bounds.TopLeft.Y + half, pg.Bounds.BottomRight.Y + half }); dc.PushGuidelineSet(gs); dc.DrawGeometry(isFilled ? brush : null, isStroked ? pen : null, pg); dc.Pop(); }
private static void DrawEllipseInternal(DrawingContext dc, double half, Brush brush, Pen pen, bool isStroked, bool isFilled, ref Point center, double rx, double ry) { if (!isStroked && !isFilled) return; var gs = new GuidelineSet( new double[] { center.X - rx + half, center.X + rx + half }, new double[] { center.Y - ry + half, center.Y + ry + half }); dc.PushGuidelineSet(gs); dc.DrawEllipse(isFilled ? brush : null, isStroked ? pen : null, center, rx, ry); dc.Pop(); }
private static void DrawRectangleInternal(DrawingContext dc, double half, Brush brush, Pen pen, bool isStroked, bool isFilled, ref Rect rect) { if (!isStroked && !isFilled) return; var gs = new GuidelineSet( new double[] { rect.TopLeft.X + half, rect.BottomRight.X + half }, new double[] { rect.TopLeft.Y + half, rect.BottomRight.Y + half }); dc.PushGuidelineSet(gs); dc.DrawRectangle(isFilled ? brush : null, isStroked ? pen : null, rect); dc.Pop(); }
private static void DrawLineInternal(DrawingContext dc, double half, Pen pen, bool isStroked, ref Point p0, ref Point p1) { if (!isStroked) return; var gs = new GuidelineSet( new double[] { p0.X + half, p1.X + half }, new double[] { p0.Y + half, p1.Y + half }); dc.PushGuidelineSet(gs); dc.DrawLine(isStroked ? pen : null, p0, p1); dc.Pop(); }
/// <summary> /// Performs the actual rendering of the caret on the given context. Called by /// CaretSubElement. /// </summary> /// <param name="context">Drawing context</param> /// <remarks>This method is on CaretElement instead of CaretSubElement because CaretElement /// knows all of the necessary data, and conceptually CaretSubElement only exists to provide /// a rendering surface.</remarks> internal void OnRenderCaretSubElement(DrawingContext context) { // [....] up Win32 caret position with Avalon caret position. Win32SetCaretPos(); if (_showCaret) { TextEditorThreadLocalStore threadLocalStore = TextEditor._ThreadLocalStore; Invariant.Assert(!(_italic && this.IsInInterimState), "Assert !(_italic && IsInInterimState)"); // Drawing context's pushed count to pop it up int contextPushedCount = 0; // Apply internally requested opacity. context.PushOpacity(_opacity); contextPushedCount++; // Apply italic transformation if (_italic && !(threadLocalStore.Bidi)) { // Rotate transform 20 degree for italic that is the based on 'H' italic degree. // NOTE: The angle of italic caret is constant. This is Word behavior // established after usability studies with conditional angle dependent // on font properties - they discovered that variations look annoying. // NOTE: We ignore _italic setting in _bidi case. This is Word behavior. // When flow direction is Right to Left, we need to reverse the caret transform. // // Get the flow direction which is the flow direction of AdornedElement. // CaretElement is rendering the caret that based on AdornedElement, so we can // render the right italic caret whatever the text content set the flow direction. FlowDirection flowDirection = (FlowDirection)AdornedElement.GetValue(FlowDirectionProperty); context.PushTransform(new RotateTransform( flowDirection == FlowDirection.RightToLeft ? -20 : 20, 0, _height)); contextPushedCount++; } if (this.IsInInterimState || _systemCaretWidth > DefaultNarrowCaretWidth) { // Make the block caret partially transparent to avoid obstructing text. context.PushOpacity(CaretOpacity); contextPushedCount++; } if (this.IsInInterimState) { // Render the interim block caret as the specified interim block caret width. context.DrawRectangle(_caretBrush, null, new Rect(0, 0, _interimWidth, _height)); } else { // Snap the caret to device pixels. if (!_italic || threadLocalStore.Bidi) { GuidelineSet guidelineSet = new GuidelineSet(new double[] { -(_systemCaretWidth / 2), _systemCaretWidth / 2 }, null); context.PushGuidelineSet(guidelineSet); contextPushedCount++; } // If we don't snap, the caret will render as a 2 pixel wide rect, one pixel in each bordering char bounding box. context.DrawRectangle(_caretBrush, null, new Rect(-(_systemCaretWidth / 2), 0, _systemCaretWidth, _height)); } if (threadLocalStore.Bidi) { // Set the Bidi caret indicator width. TextBox/RichTextBox control must have // the enough margin to display BiDi indicator. double bidiCaretIndicatorWidth = BidiCaretIndicatorWidth; // Get the flow direction which is the flow direction of AdornedElement. // Because CaretElement is rendering the caret that based on AdornedElement. // With getting the flow direction, we can render the BiDi caret indicator correctly // whatever AdornedElement's flow direction is set. FlowDirection flowDirection = (FlowDirection)AdornedElement.GetValue(FlowDirectionProperty); if (flowDirection == FlowDirection.RightToLeft) { // BiDi caret indicator should always direct by the right to left bidiCaretIndicatorWidth = bidiCaretIndicatorWidth * (-1); } // Draw BIDI caret to indicate the coming input is BIDI characters. // Shape is a little flag oriented to the left - as in Word. // Orientation does not depend on anything (which seems to be Word behavior). // PathGeometry pathGeometry; PathFigure pathFigure; pathGeometry = new PathGeometry(); pathFigure = new PathFigure(); pathFigure.StartPoint = new Point(0, 0); pathFigure.Segments.Add(new LineSegment(new Point(-bidiCaretIndicatorWidth, 0), true)); pathFigure.Segments.Add(new LineSegment(new Point(0, _height / BidiIndicatorHeightRatio), true)); pathFigure.IsClosed = true; pathGeometry.Figures.Add(pathFigure); context.DrawGeometry(_caretBrush, null, pathGeometry); } // Pop the drawing context if pushed for italic or opacity setting for (int i = 0; i < contextPushedCount; i++) { context.Pop(); } } else { // Destroy Win32 caret. Win32DestroyCaret(); } }
/// <summary> /// PushGuidelineSet - /// Push a set of guidelines which will apply to all drawing operations until the /// corresponding Pop. /// </summary> /// <param name="guidelines"> The GuidelineSet to push. </param> public override void PushGuidelineSet( GuidelineSet guidelines) { Debug.Assert(false); }