C# RectangleGeometry.Freeze方法代码示例

        public static void Render(
            this DrawingContext cx,
            double drawingWidth,
            double drawingHeight,
            DrawingRenderInfo drawing)
        {
            // expand drawings to desired size using transparent rectangle
            var canvas = new RectangleGeometry(new Rect(0, 0, drawingWidth, drawingHeight));
            canvas.Freeze();
            cx.DrawGeometry(Brushes.Transparent, null, canvas);

            cx.Render(drawing);
        }

        IPixelCanvas RandomSquares__DrawGeometry(int count, int square_size, int canvas_size)
        {
            var rd = new Random();

            var pc = new PixelArrayCanvas(canvas_size, canvas_size);

            var geom = new RectangleGeometry(new System.Windows.Rect(0, 0, square_size, square_size));
            geom.Freeze();

            for (int i = 0; i < count; i++)
            {
                pc.DrawGeometry(rd.Next(0, canvas_size - square_size), rd.Next(0, canvas_size - square_size), geom, Brushes.Red, new Pen(Brushes.Red, 1));
            }

            return pc;
        }

		protected override void OnRender(DrawingContext drawingContext) {
			base.OnRender(drawingContext);
			if (hexBox.Selection == null || hexBox.VisibleBytesPerLine < 1)
				return;

			ulong selStart = hexBox.Selection.Value.StartOffset;
			ulong selEnd = hexBox.Selection.Value.EndOffset;
			int lines = hexBox.VisibleLinesPerPage;
			ulong bpl = (ulong)hexBox.VisibleBytesPerLine;
			ulong visibleStart = hexBox.TopOffset;
			ulong visibleEnd = NumberUtils.AddUInt64(NumberUtils.AddUInt64(visibleStart, NumberUtils.MulUInt64(bpl, NumberUtils.SubUInt64((ulong)lines, 1))), NumberUtils.SubUInt64(bpl, 1));
			if (selStart > visibleEnd || selEnd < visibleStart)
				return;

			ulong offset = Math.Max(selStart, visibleStart);
			ulong endOffset = Math.Min(selEnd, visibleEnd);
			double x = -hexBox.CharacterWidth * hexBox.LeftColumn;
			double y = (offset - hexBox.TopOffset) / bpl * hexBox.CharacterHeight;
			var path = new PathGeometry();
			double hexByteX = hexBox.GetHexByteColumnIndex() * hexBox.CharacterWidth;
			double asciiX = hexBox.GetAsciiColumnIndex() * hexBox.CharacterWidth;
			while (offset <= endOffset) {
				ulong byteIndex = hexBox.GetLineByteIndex(offset);
				ulong count = Math.Min(bpl - byteIndex, endOffset - offset + 1);

				double dx = byteIndex * hexBox.CharacterWidth;
				var rectGeo = new RectangleGeometry(new Rect(x + dx * 3 + hexByteX + hexBox.CharacterWidth, y, count * hexBox.CharacterWidth * 3 - hexBox.CharacterWidth, hexBox.CharacterHeight));
				rectGeo.Freeze();
				path.AddGeometry(rectGeo);

				if (hexBox.ShowAscii) {
					rectGeo = new RectangleGeometry(new Rect(x + dx + asciiX, y, count * hexBox.CharacterWidth, hexBox.CharacterHeight));
					rectGeo.Freeze();
					path.AddGeometry(rectGeo);
				}

				if (offset + bpl - byteIndex < offset)
					break;
				offset += bpl - byteIndex;
				y += hexBox.CharacterHeight;
			}

			path.Freeze();
			drawingContext.DrawGeometry(Background, null, path);
		}

        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            if (values.Length == 3 && values[0] is double && values[1] is double && values[2] is CornerRadius)
            {
                var width = (double)values[0];
                var height = (double)values[1];

                if (width < double.Epsilon || height < double.Epsilon)
                    return Geometry.Empty;

                var radius = (CornerRadius)values[2];

                // Actually we need more complex geometry, when CornerRadius has different values.
                // But let me not to take this into account, and simplify example for a common value.
                var clip = new RectangleGeometry(new Rect(0, 0, width, height), radius.TopLeft, radius.TopLeft);
                clip.Freeze();

                return clip;
            }

            return DependencyProperty.UnsetValue;
        }

 /// <summary>
 ///     Override of UIElement.GetLayoutClip().  This is a tricky way to ensure we always clip regardless of the value of ClipToBounds. 
 /// </summary>
 protected override Geometry GetLayoutClip(Size layoutSlotSize)
 {
     RectangleGeometry clip = new RectangleGeometry(new Rect(RenderSize)); 
     clip.Freeze();
     return clip; 
 } 

      /// <summary>Draws the text glyph in the specified target area.</summary>
      /// <param name="dc">The drawing context to draw on.</param>
      /// <param name="foreground">The text foreground brush.</param>
      /// <param name="targetArea">The target area where the text is to be drawn (according to the specified alignment).</param>
      /// <param name="alignment">Indicates how to align the text with respect to the target area.</param>
      public void Draw(DrawingContext dc, Brush foreground, Rect targetArea, TextAlign alignment) {
         if (IsEmpty || targetArea.IsEmpty || foreground == null) return;

         // compute bounds 
         var bounds = _computeBounds(targetArea, alignment);
         dc.PushTranslate(bounds.X + SharpnessVector.X, bounds.Y + SharpnessVector.Y);

         if (TextOverflow == TextOverflow.Ignore || Width <= bounds.Width) {
            // ignore overflow - use original glyph run and draw it without clipping
            _drawGlyphRun(dc, _fullRun, foreground);

         } else if (TextOverflow == TextOverflow.Clip) {
            // clip overflow - use original glyph run but clip it to fit bounds
            var clipRect = new RectangleGeometry(new Rect(new Point(), bounds.Size));
            clipRect.Freeze();
            dc.PushClip(clipRect);
            _drawGlyphRun(dc, _fullRun, foreground);
            dc.Pop();

         } else {
            // trim overflow - create a trimmed glyph run that fits the bounds and cache it for next invocation 
            // (the caching of the trimmed glyph is effective only if the width does not change - e.g., when drawing the same glyph in a different color)
            if (_trimmedWidth.CertainlyDifferent(bounds.Width)) {
               var result = _buildGlyph(false, bounds.Width);
               _trimmedRun = (result != null ? result.GlyphRun : null);
               _trimmedWidth = bounds.Width;
            }
            _drawGlyphRun(dc, _trimmedRun, foreground);
         }

         dc.Pop();
      }

        /// <summary>
        /// Draw the hatches and the transparent area where isn't covering the elements.
        /// </summary>
        /// <param name="drawingContext"></param>
        private void DrawBackgound(DrawingContext drawingContext)
        {
            PathGeometry hatchGeometry = null;
            Geometry rectGeometry = null;

            int count = _elementsBounds.Count;
            if ( count != 0 )
            {
                // Create a union collection of the element regions.
                for ( int i = 0; i < count; i++ )
                {
                    Rect hatchRect = _elementsBounds[i];

                    if ( hatchRect.IsEmpty )
                    {
                        continue;
                    }

                    hatchRect.Inflate(HatchBorderMargin / 2, HatchBorderMargin / 2);

                    if ( hatchGeometry == null )
                    {
                        PathFigure path = new PathFigure();
                        path.StartPoint = new Point(hatchRect.Left, hatchRect.Top);

                        PathSegmentCollection segments = new PathSegmentCollection();
                        
                        PathSegment line = new LineSegment(new Point(hatchRect.Right, hatchRect.Top), true); 
                        line.Freeze();
                        segments.Add(line);
                        
                        line = new LineSegment(new Point(hatchRect.Right, hatchRect.Bottom), true); 
                        line.Freeze();
                        segments.Add(line);

                        line = new LineSegment(new Point(hatchRect.Left, hatchRect.Bottom), true);
                        line.Freeze();
                        segments.Add(line);

                        line = new LineSegment(new Point(hatchRect.Left, hatchRect.Top), true);
                        line.Freeze();
                        segments.Add(line);

                        segments.Freeze();
                        path.Segments = segments;

                        path.IsClosed = true;
                        path.Freeze();

                        hatchGeometry = new PathGeometry();
                        hatchGeometry.Figures.Add(path);
                    }
                    else
                    {
                        rectGeometry = new RectangleGeometry(hatchRect);
                        rectGeometry.Freeze();

                        hatchGeometry = Geometry.Combine(hatchGeometry, rectGeometry, GeometryCombineMode.Union, null);
                    }
                }
            }

            // Then, create a region which equals to "SelectionFrame - element1 bounds - element2 bounds - ..."
            GeometryGroup backgroundGeometry = new GeometryGroup( );
            GeometryCollection geometryCollection = new GeometryCollection();

            // Add the entile rectanlge to the group.
            rectGeometry = new RectangleGeometry(new Rect(0, 0, RenderSize.Width, RenderSize.Height));
            rectGeometry.Freeze();
            geometryCollection.Add(rectGeometry);

            // Add the union of the element rectangles. Then the group will do oddeven operation.
            Geometry outlineGeometry = null;

            if ( hatchGeometry != null )
            {
                hatchGeometry.Freeze();

                outlineGeometry = hatchGeometry.GetOutlinedPathGeometry();
                outlineGeometry.Freeze();
                if ( count == 1 && ((InkCanvasInnerCanvas)AdornedElement).InkCanvas.GetSelectedStrokes().Count == 0 )
                {
                    geometryCollection.Add(outlineGeometry);
                }
            }

            geometryCollection.Freeze();
            backgroundGeometry.Children = geometryCollection;
            backgroundGeometry.Freeze();

            // Then, draw the region which may contain holes so that the elements cannot be covered.
            // After that, the underneath elements can receive the messages.
#if DEBUG_OUTPUT
            // Draw the debug feedback
            drawingContext.DrawGeometry(new SolidColorBrush(Color.FromArgb(128, 255, 255, 0)), null, backgroundGeometry);
#else
//.........这里部分代码省略.........

		/// <summary>
		/// </summary>
		/// <exception cref="ArgumentNullException">
		/// <para><paramref name="span"/> is <see langword="null"/>.</para>
		/// </exception>
		/// <exception cref="ArgumentOutOfRangeException">
		/// <para><paramref name="span"/> is less than zero or greater than the buffer length for the associated <see cref="ISourceEditorView"/>.</para>
		/// </exception>
		public Geometry GetMarkerGeometry(Span span)
		{
			if (span == null)
			{
				throw new ArgumentNullException("span");
			}
			if ((span.Start < 0) || (span.End > _editorView.TextBuffer.Length))
			{
				throw new ArgumentOutOfRangeException("span");
			}
			if (span.IsEmpty)
			{
				return null;
			}
			PathGeometry geometry = new PathGeometry();
			geometry.FillRule = FillRule.Nonzero;
			IList<ITextLine> textLines = _editorView.TextLines;
			if (textLines.Count == 0)
			{
				return null;
			}
			if ((span.Start > base.LastRenderedCharacter) || (span.End < base.FirstRenderedCharacter))
			{
				return null;
			}
			ITextLine item = null;
			ITextLine textLineClosestTo = null;
			if (span.Start < base.FirstRenderedCharacter)
			{
				item = textLines[0];
			}
			if (span.End > base.LastRenderedCharacter)
			{
				textLineClosestTo = textLines[textLines.Count - 1];
			}
			if (item == null)
			{
				item = base.GetTextLineClosestTo(span.Start);
			}
			if (textLineClosestTo == null)
			{
				textLineClosestTo = base.GetTextLineClosestTo(span.End);
			}
			if (item == textLineClosestTo)
			{
				foreach (TextBounds bounds in item.GetTextBounds(span))
				{
					RectangleGeometry geometry2 = new RectangleGeometry(new Rect(bounds.Left - 0.2, bounds.Top - 1, bounds.Width + 0.4, bounds.Height + 1), 0.6, 0.6);
					geometry2.Freeze();
					geometry.AddGeometry(geometry2);
				}
			}
			else
			{
				foreach (TextBounds bounds2 in item.GetTextBounds(span))
				{
					RectangleGeometry geometry3 = new RectangleGeometry(new Rect(bounds2.Left - 0.2, bounds2.Top - 1, bounds2.Width + 0.4, bounds2.Height + 1), 0.6, 0.6);
					geometry3.Freeze();
					geometry.AddGeometry(geometry3);
				}
				Int32 num = textLines.IndexOf(item) + 1;
				Int32 index = textLines.IndexOf(textLineClosestTo);
				for (Int32 i = num; i < index; i++)
				{
					ITextLine line3 = textLines[i];
					RectangleGeometry geometry4 = new RectangleGeometry(new Rect(-0.2, line3.VerticalOffset - 0.2, line3.Width, line3.Height + 0.4), 0.6, 0.6);
					geometry4.Freeze();
					geometry.AddGeometry(geometry4);
				}
				foreach (TextBounds bounds3 in textLineClosestTo.GetTextBounds(span))
				{
					RectangleGeometry geometry5 = new RectangleGeometry(new Rect(bounds3.Left - 0.2, bounds3.Top - 1, bounds3.Width + 0.4, bounds3.Height + 1), 0.6, 0.6);
					geometry5.Freeze();
					geometry.AddGeometry(geometry5);
				}
			}
			geometry.Freeze();
			return geometry.GetOutlinedPathGeometry();
		}

        /////////////////////////////////////////////////////////////////////
 
        /// <summary>
        /// [TBS] - On UIContext
        /// </summary>
        public DynamicRenderer() : base() 
        {
            _zeroSizedFrozenRect = new RectangleGeometry(new Rect(0,0,0,0)); 
            _zeroSizedFrozenRect.Freeze(); 
        }

        IEnumerable<DrawingRenderInfo> produceSquares(int count, int square_size, int canvas_size)
        {
            Random rd = new Random();

            for(int i = 0; i < count; i++)
            {
                var di = new DrawingRenderInfo();
                di.Transform = new TranslateTransform(rd.Next(0, canvas_size - square_size), rd.Next(0, canvas_size - square_size));
                di.Transform.Freeze();

                var geom = new RectangleGeometry(new Rect(0, 0, square_size, square_size));
                geom.Freeze();

                di.Drawing = new GeometryDrawing(Brushes.Red, null, geom);
                di.Drawing.Freeze();

                yield return di;
            }
        }

        IPixelCanvas RandomSquares__DrawVisual2(int count, int square_size, int canvas_size)
        {
            var rd = new Random();

            var pc = new PixelArrayCanvas(canvas_size, canvas_size);

            var dv = new DrawingVisual();

            var geom = new RectangleGeometry(new System.Windows.Rect(0, 0, square_size, square_size));
            geom.Freeze();

            using (var cx = dv.RenderOpen())
            {
                var canvas = new RectangleGeometry(new Rect(0, 0, canvas_size, canvas_size));
                canvas.Freeze();

                cx.DrawGeometry(Brushes.Transparent, null, canvas);

                var lols = new ConcurrentBag<DrawingWithExtras>();                

                Parallel.For(0, count, i =>
                 {
                     var drawing = new GeometryDrawing(Brushes.Red, new Pen(Brushes.Red, 1), geom);
                     drawing.Freeze();

                     var trans = new TranslateTransform(rd.Next(0, canvas_size - square_size), rd.Next(0, canvas_size - square_size));
                     trans.Freeze();

                     lols.Add(new DrawingWithExtras { drawing = drawing, transform = trans });
                 });

                foreach(var lol in lols)
                {
                    cx.PushTransform(lol.transform);
                    cx.DrawDrawing(lol.drawing);
                    cx.Pop();
                }
            }

            pc.DrawVisual(0, 0, dv, BlendMode.Copy);

            return pc;
        }

        IPixelCanvas RandomSquares__DrawVisual(int count, int square_size, int canvas_size)
        {
            var rd = new Random();

            var pc = new PixelArrayCanvas(canvas_size, canvas_size);

            var dv = new DrawingVisual();

            var geom = new RectangleGeometry(new System.Windows.Rect(0, 0, square_size, square_size));
            geom.Freeze();

            using (var cx = dv.RenderOpen())
            {
                var canvas = new RectangleGeometry(new Rect(0, 0, canvas_size, canvas_size));
                canvas.Freeze();

                cx.DrawGeometry(Brushes.Transparent, null, canvas);

                for(int i = 0; i < count; i++)
                {
                    cx.PushTransform(new TranslateTransform(rd.Next(0, canvas_size - square_size), rd.Next(0, canvas_size - square_size)));
                    cx.DrawGeometry(Brushes.Red, new Pen(Brushes.Red, 1), geom);
                    cx.Pop(); 
                }
            }

            pc.DrawVisual(0, 0, dv, BlendMode.Copy);

            return pc;
        }

 /// <summary>
 /// This method supplies an additional (to the <seealso cref="Clip"/> property) clip geometry
 /// that is used to intersect Clip in case if <seealso cref="ClipToBounds"/> property is set to "true".
 /// Typcally, this is a size of layout space given to the UIElement.
 /// </summary>
 /// <returns>Geometry to use as additional clip if ClipToBounds=true</returns>
 protected virtual Geometry GetLayoutClip(Size layoutSlotSize)
 {
     if(ClipToBounds)
     {
         RectangleGeometry rect = new RectangleGeometry(new Rect(RenderSize));
         rect.Freeze();
         return rect;
     }
     else
         return null;
 }