Exemple #1
0
 internal static object Box(FillRule value) 
 { 
     if (value == FillRule.Nonzero)
     { 
         return NonzeroBox;
     }
     else
     { 
         return EvenOddBox;
     } 
 } 
 public static Telerik.Windows.Documents.Fixed.Model.Graphics.FillRule ConvertFillRule(FillRule fillRule)
 {
     switch (fillRule)
     {
         case FillRule.EvenOdd:
             return Telerik.Windows.Documents.Fixed.Model.Graphics.FillRule.EvenOdd;
         case FillRule.Nonzero:
             return Telerik.Windows.Documents.Fixed.Model.Graphics.FillRule.Nonzero;
         default:
             throw new NotSupportedException(String.Format("Not supported fill rule: {0}", fillRule));
     }
 }
        internal PathStreamGeometryContext(FillRule fillRule, 
                                           Transform transform)
        { 
            _pathGeometry = new PathGeometry(); 

            if (fillRule != s_defaultFillRule) 
            {
                _pathGeometry.FillRule = fillRule;
            }
 
            if ((transform != null) && !transform.IsIdentity)
            { 
                _pathGeometry.Transform = transform.Clone(); 
            }
        } 
Exemple #4
0
 public void ClipRule(FillRule value)
 {
   _NativeInstance.ClipRule(value);
 }
 internal unsafe static extern int MilGlyphRun_GetGlyphOutline(
     IntPtr pFontFace, 
     ushort glyphIndex, 
     bool sideways,
     double renderingEmSize, 
     out byte* pPathGeometryData,
     out UInt32 pSize,
     out FillRule pFillRule
     ); 
 internal unsafe static extern int MilUtility_PathGeometryWiden( 
     MIL_PEN_DATA *pPenData,
     double *pDashArray,
     MilMatrix3x2D* pMatrix,
     FillRule fillRule, 
     byte* pPathData,
     UInt32 nSize, 
     double rTolerance, 
     bool fRelative,
     Delegate addFigureCallback, 
     out FillRule widenedFillRule);
 internal unsafe static extern int MilUtility_PathGeometryBounds( 
     MIL_PEN_DATA *pPenData, 
     double *pDashArray,
     MilMatrix3x2D* pWorldMatrix, 
     FillRule fillRule,
     byte* pPathData,
     UInt32 nSize,
     MilMatrix3x2D* pGeometryMatrix, 
     double rTolerance,
     bool fRelative, 
     bool fSkipHollows, 
     MilRectD* pBounds);
Exemple #8
0
        /// <summary>
        /// Returns a path geometry
        /// </summary>
        /// <param name="fillRule">FillRule</param>
        /// <param name="startPoint">Start point</param>
        /// <param name="pathGeometryParams">List of path geometry parameters</param>
        /// <returns>PathGeometry</returns>
        private static PathGeometry GetPathGeometryFromList(FillRule fillRule, Point startPoint, List<PathGeometryParams> pathGeometryParams, Boolean isClosed)
        {
            PathGeometry pathGeometry = new PathGeometry();

            pathGeometry.FillRule = fillRule;
            pathGeometry.Figures = new PathFigureCollection();

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = startPoint;
            pathFigure.Segments = new PathSegmentCollection();
            pathFigure.IsClosed = isClosed;

            foreach (PathGeometryParams param in pathGeometryParams)
            {
                switch (param.GetType().Name)
                {
                    case "LineSegmentParams":
                        LineSegment lineSegment = new LineSegment();
                        lineSegment.Point = param.EndPoint;
                        pathFigure.Segments.Add(lineSegment);
                        break;

                    case "ArcSegmentParams":
                        ArcSegment arcSegment = new ArcSegment();

                        arcSegment.Point = param.EndPoint;
                        arcSegment.IsLargeArc = (param as ArcSegmentParams).IsLargeArc;
                        arcSegment.RotationAngle = (param as ArcSegmentParams).RotationAngle;
                        arcSegment.SweepDirection = (param as ArcSegmentParams).SweepDirection;
                        arcSegment.Size = (param as ArcSegmentParams).Size;
                        pathFigure.Segments.Add(arcSegment);

                        break;
                }
            }

            pathGeometry.Figures.Add(pathFigure);

            return pathGeometry;
        }
 ///<summary>
 /// Creates a new DrawableFillRule instance.
 ///</summary>
 ///<param name="fillRule">The rule to use when filling drawn objects.</param>
 public DrawableFillRule(FillRule fillRule)
 {
   FillRule = fillRule;
 }
 internal unsafe static extern int MilUtility_GetPointAtLengthFraction(
     MilMatrix3x2D *pMatrix,
     FillRule fillRule,
     byte *pPathData,
     UInt32 nSize,
     double rFraction,
     out Point pt,
     out Point vecTangent);
 public void SetFillRule(FillRule fillRule)
 {
     _target.FillRule = fillRule;
 }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="figures">A collection of figures</param>
        /// <param name="fillRule">The fill rule (OddEven or NonZero)</param>
        /// <param name="transform">A transformation to apply to the input</param>
        public PathGeometry(IEnumerable<PathFigure> figures, FillRule fillRule, Transform transform)
        {
            Transform = transform;
            if (ValidateEnums.IsFillRuleValid(fillRule))
            {
                FillRule = fillRule;

                if (figures != null)
                {
                    foreach (PathFigure item in figures)
                    {
                        Figures.Add(item);
                    }
                }
                else
                {
                    throw new ArgumentNullException("figures");
                }

                SetDirty();
            }
        }
 public void SetFillRule(FillRule fillRule)
 {
     _path.FillType = fillRule == FillRule.EvenOdd ? SKPathFillType.EvenOdd : SKPathFillType.Winding;
 }
Exemple #14
0
 public void FillRule(FillRule value)
 {
   IntPtr exception = IntPtr.Zero;
   #if ANYCPU
   if (NativeLibrary.Is64Bit)
   #endif
   #if WIN64 || ANYCPU
   NativeMethods.X64.DrawingWand_FillRule(Instance, (UIntPtr)value, out exception);
   #endif
   #if ANYCPU
   else
   #endif
   #if !WIN64 || ANYCPU
   NativeMethods.X86.DrawingWand_FillRule(Instance, (UIntPtr)value, out exception);
   #endif
   CheckException(exception);
 }
	/// <summary>
	/// <para>Construct a new <see cref="T:Xsharp.Region"/>
	/// instance that is initially set to a polygon.</para>
	/// </summary>
	///
	/// <param name="points">
	/// <para>An array of points that defines the polygon.</para>
	/// </param>
	///
	/// <param name="fillRule">
	/// <para>The area fill rule to use for the polygon.</para>
	/// </param>
	///
	/// <exception cref="T:System.ArgumentNullException">
	/// <para>Raised if <paramref name="points"/> is <see langword="null"/>.
	/// </para>
	/// </exception>
	///
	/// <exception cref="T:System.ArgumentOutOfRangeException">
	/// <para>Raised if <paramref name="points"/> has less than 3
	/// elements.</para>
	/// </exception>
	///
	/// <exception cref="T:Xsharp.XException">
	/// <para>Raised if any of the elements in <paramref name="points"/>
	/// has co-ordinates that are out of range, or if
	/// <paramref name="fillRule"/> is invalid.</para>
	/// </exception>
	public Region(Point[] points, FillRule fillRule)
			{
				// Validate the parameters.
				if(points == null)
				{
					throw new ArgumentNullException("points");
				}
				else if(points.Length < 3)
				{
					throw new ArgumentOutOfRangeException
						("points", S._("X_PolygonNeeds3Pts"));
				}

				// Convert "points" into an "XPoint[]" array.
				XPoint[] pts = new XPoint [points.Length];
				try
				{
					checked
					{
						for(int index = 0; index < points.Length; ++index)
						{
							pts[index].x = (short)(points[index].x);
							pts[index].y = (short)(points[index].y);
						}
					}
				}
				catch(OverflowException)
				{
					throw new XException(S._("X_PointCoordRange"));
				}

				// Validate the fill rule.
				if(fillRule != FillRule.EvenOddRule &&
				   fillRule != FillRule.WindingRule)
				{
					throw new XException
						(String.Format(S._("X_FillRule"), (int)fillRule));
				}

				// Create the polygon region.
				lock(typeof(Region))
				{
					region = Xlib.XPolygonRegion(pts, pts.Length,
												 (int)fillRule);
					if(region == IntPtr.Zero)
					{
						Display.OutOfMemory();
					}
				}
			}
 public void SetFillRule(FillRule fillRule)
 {
 }
 internal unsafe static extern int MilUtility_PathGeometryHitTest(
     MilMatrix3x2D *pMatrix,
     MIL_PEN_DATA* pPenData,
     double* pDashArray,
     FillRule fillRule,
     byte *pPathData,
     UInt32 nSize,
     double rTolerance,
     bool fRelative,
     Point* pHitPoint,
     out bool pDoesContain);
 internal unsafe static extern int MilUtility_PathGeometryHitTestPathGeometry(
     MilMatrix3x2D *pMatrix1,
     FillRule fillRule1,
     byte *pPathData1,
     UInt32 nSize1,
     MilMatrix3x2D *pMatrix2,
     FillRule fillRule2,
     byte *pPathData2,
     UInt32 nSize2,
     double rTolerance,
     bool fRelative,
     IntersectionDetail* pDetail);
Exemple #19
0
        //
        // Given a mini-language representation of a Geometry - write it to the 
        // supplied streamgeometrycontext
        // 

        private static void ParseStringToStreamGeometryContext ( 
            StreamGeometryContext context, 
            string pathString,
            IFormatProvider formatProvider, 
#if PRESENTATION_CORE            
            ref FillRule fillRule 
#else            
            ref bool fillRule 
 internal unsafe static extern int MilUtility_GeometryGetArea(
     FillRule fillRule,
     byte *pPathData,
     UInt32 nSize,
     MilMatrix3x2D *pMatrix,
     double rTolerance,
     bool fRelative,
     double* pArea);
        /// <summary>
        /// Sets path's winding rule (default is EvenOdd). You should call this method before any calls to BeginFigure. If you wonder why, ask Direct2D guys about their design decisions.
        /// </summary>
        /// <param name="fillRule"></param>

        public void SetFillRule(FillRule fillRule)
        {
            _impl.SetFillRule(fillRule);
        }
Exemple #22
0
		public PathGeometry (IEnumerable<PathFigure> figures, FillRule fillRule, Transform transform)
		{
			Figures = new PathFigureCollection (figures);
			FillRule = fillRule;
			Transform = transform;
		}
		public DrawableFillRule(FillRule fillRule)
			: base(AssemblyHelper.CreateInstance(Types.DrawableFillRule, new Type[] {Types.FillRule}, fillRule))
		{
		}
Exemple #24
0
 public void SetFillRule(FillRule fillRule)
 {
     _geometryImpl.FillRule = fillRule;
 }
 internal unsafe static extern int MilUtility_PathGeometryCombine( 
     MilMatrix3x2D* pMatrix, 
     MilMatrix3x2D* pMatrix1,
     FillRule fillRule1, 
     byte* pPathData1,
     UInt32 nSize1,
     MilMatrix3x2D* pMatrix2,
     FillRule fillRule2, 
     byte* pPathData2,
     UInt32 nSize2, 
     double rTolerance, 
     bool fRelative,
     Delegate addFigureCallback, 
     GeometryCombineMode combineMode,
     out FillRule resultFillRule);
 private static bool FillRuleToBool(FillRule fill)
 {
     if (fill == FillRule.EvenOdd)
         return false;
     else
         return true;
 }
 internal unsafe static extern int MilUtility_PathGeometryFlatten(
     MilMatrix3x2D* pMatrix, 
     FillRule fillRule, 
     byte* pPathData,
     UInt32 nSize, 
     double rTolerance,
     bool fRelative,
     Delegate addFigureCallback,
     out FillRule resultFillRule); 
 internal void SetFillRule(FillRule fillRule)
 public void SetFillRule(FillRule fillRule)
 {
     _sink.SetFillMode(fillRule == FillRule.EvenOdd ? FillMode.Alternate : FillMode.Winding);
 }
Exemple #30
0
 public void FillRule(FillRule value)
 {
   _NativeInstance.FillRule(value);
 }