public void SetDEMFillMode(FillMode fillMode)
 {
     lock (gDevice)
     {
         demFillMode = fillMode;
     }
 }

        public void BeginModify(FillMode fillmode)
        {
            if(m_geometryFilled)
                CreatePathGeometry();

            m_geometrySink = m_pathGeometry.Open();
            m_geometrySink.SetFillMode((SlimDX.Direct2D.FillMode)fillmode);
        }

 /// <summary>
 /// Create objects in a cubical patern
 /// </summary>
 /// <param name="item">the GameObject to be placed in our cubic patern</param>
 /// <param name="item2">the second type of GameObject to be placed in empty places of our patern (instead of being empty)</param>
 /// <param name="position">position of the corner of the cube</param>
 /// <param name="width">width of the cube</param>
 /// <param name="height">height of the cube</param>
 /// <param name="depth">depth of the cube</param>
 /// <param name="tileSize">size of each tile of the cube (i.e distance between items)</param>
 /// <param name="fill">fill mode of the cube</param>
 /// <returns>returns if it was successful or not</returns>
 public static bool CreateCubical(GameObject item, GameObject item2, Vector3 position, float width, float height, float depth, float tileSize, FillMode fill)
 {
     if (item == null || width <= 0 || height <= 0 || depth <= 0 || tileSize <= 0)
     {
         return false;
     }
     //some modes can not tolerate even numbers
     if (fill == FillMode.YesNo)
     {
         if (width % 2 == 0) width++;
         if (height % 2 == 0) height++;
         if (depth % 2 == 0) depth++;
     }
     currentPosition = position;
     for (int i = 0; i < width; i++)
     {
         for (int j = 0; j < height; j++)
         {
             for (int k = 0; k < depth; k++)
             {
                 if (fill == FillMode.fill)
                 {
                     GameObject.Instantiate(item, currentPosition, Quaternion.identity);
                 }
                 else if (fill == FillMode.empty)
                 {
                     if (i == 0 || j == 0 || k == 0 || i == width - 1 || j == height - 1 || k == depth - 1)
                     {
                         GameObject.Instantiate(item, currentPosition, Quaternion.identity);
                     }
                     else if (item2 != null)
                     {
                         GameObject.Instantiate(item2, currentPosition, Quaternion.identity);
                     }
                 }
                 else if (fill == FillMode.YesNo)
                 {
                     if ((i % 2 == 0 && j % 2 == 0 && k % 2 == 0) || i == 0 || j == 0 || k == 0 || i == width - 1 || j == height - 1 || k == depth - 1)
                     {
                         GameObject.Instantiate(item, currentPosition, Quaternion.identity);
                     }
                     else if (item2 != null)
                     {
                         GameObject.Instantiate(item2, currentPosition, Quaternion.identity);
                     }
                 }
                 currentPosition.z += tileSize;
             }
             currentPosition.y += tileSize;
             currentPosition.z = position.z;
         }
         currentPosition.x += tileSize;
         currentPosition.y = position.y;
         currentPosition.z = position.z;
     }
     return true;
 }

 /// <summary>
 /// </summary>
 /// <param name="parent"> </param>
 /// <param name="title"> </param>
 public Page(Version parent, string title)
 {
     Title = title;
     _parent = parent;
     if (parent != null)
         _parent.Pages.Add(this);
     _items = new List<IOption>();
     _fillMode = FillMode.TopToBottom;
 }

        public IFillStyleInfo ProduceNewFillStyleInfo(
			Color FillColor,
			Color GradientColor,
			FillMode mode)
        {
            IFillStyleInfo NewFillStyle = new GDIFillStyle(
                FillColor, GradientColor, mode);
            return NewFillStyle;
        }

        public GraphicsPath(FillMode fillMode) {
            IntPtr nativePath = IntPtr.Zero;

            int status = SafeNativeMethods.Gdip.GdipCreatePath(unchecked((int)fillMode), out nativePath);

            if (status != SafeNativeMethods.Gdip.Ok)
                throw SafeNativeMethods.Gdip.StatusException(status);

            this.nativePath = nativePath;
        }

 public SmoothProgressBar()
 {
     InitializeComponent();
     m_min = 0;
     m_max = 100;
     m_value = 0;
     m_fillMode = FillMode.LEFT_TO_RIGHT;
     m_text = "";
     m_txtColor = SystemColors.WindowText;
 }

		public GraphicsPath (PointF[] pts, byte[] types, FillMode fillMode)
		{
			if (pts == null)
				throw new ArgumentNullException ("pts");
			if (pts.Length != types.Length)
				throw new ArgumentException ("Invalid parameter passed. Number of points and types must be same.");

			Status status = GDIPlus.GdipCreatePath2 (pts, types, pts.Length, fillMode, out nativePath);
			GDIPlus.CheckStatus (status);
		}

 public RenderInfo(Mesh mesh, int subset, Matrix transform, NJS_MATERIAL material, Texture texture, FillMode fillMode, BoundingSphere bounds)
 {
     Mesh = mesh;
     Subset = subset;
     Transform = transform;
     Material = material;
     Texture = texture;
     FillMode = fillMode;
     Bounds = bounds;
 }

        public static List<List<Vector2>> Simplify(List<Vector2> polygon, FillMode fillMode, out PolyTree tree)
        {
            Clipper.Clear();
            Clipper.AddPath(polygon, PolyType.ptSubject, true);
            Clipper.AddPath(polygon, PolyType.ptClip, true);

            tree = new PolyTree();
            PolyFillType fillType = fillMode.ToPolyFillType();
            Clipper.Execute(ClipType.ctUnion, tree, fillType, fillType);
            return Clipper.ClosedPathsFromPolyTree(tree);
        }

 /// <summary>
 /// </summary>
 /// <param name="parent"> </param>
 /// <param name="title"> </param>
 public Version(Menu parent, string title)
 {
     Title = title;
     _parent = parent;
     if (parent != null)
         _parent.Versions.Add(this);
     _number = 0.0f;
     _items = new List<IOption>();
     _pages = new List<Page>();
     _fillMode = FillMode.TopToBottom;
 }

        public static List<List<Vector2>> Combine(List<List<Vector2>> subjectPolygons, List<List<Vector2>> clippingPolygons,
                                                  FillMode subjectFillMode, FillMode clipFillMode, CombineMode combineMode, out PolyTree tree)
        {
            Clipper.Clear();
            Clipper.AddPaths(subjectPolygons, PolyType.ptSubject, true);
            Clipper.AddPaths(clippingPolygons, PolyType.ptClip, true);

            tree = new PolyTree();
            Clipper.Execute(combineMode.ToClipType(), tree, subjectFillMode.ToPolyFillType(), clipFillMode.ToPolyFillType());
            return Clipper.ClosedPathsFromPolyTree(tree);
        }

		/// <summary>
		/// Creates a new instance of the rasterizer state.
		/// </summary>
		/// <param name="cullMode"></param>
		/// <param name="fillMode"></param>
		/// <param name="depthBias"></param>
		/// <param name="slopeDepthBias"></param>
		/// <returns></returns>
		public static RasterizerState Create ( CullMode cullMode, FillMode fillMode = FillMode.Solid, int depthBias = 0, float slopeDepthBias = 0 )
		{
			var rs = new RasterizerState();
			rs.CullMode			=	cullMode;
			rs.DepthBias		=	depthBias;
			rs.SlopeDepthBias	=	slopeDepthBias;
			rs.MsaaEnabled		=	true;
			rs.FillMode			=	fillMode;
			rs.DepthClipEnabled	=	true;
			rs.ScissorEnabled	=	false;
			return rs;
		}

        public static List<List<Vector2>> Outline(List<Vector2> polygon, FillMode fillMode, bool closed, StrokeStyle strokeStyle, float strokeWidth, out PolyTree tree)
        {
            List<List<Vector2>> simplified = Clipper.SimplifyPolygon(polygon, fillMode.ToPolyFillType());

            Offsetter.Clear();
            Offsetter.MiterLimit = strokeStyle.MiterLimit;
            Offsetter.AddPaths(simplified, (JoinType)strokeStyle.LineJoin, closed ? EndType.etClosedLine : strokeStyle.CapStyle.ToEndType());

            tree = new PolyTree();
            Offsetter.Execute(ref tree, strokeWidth / 2);
            return Clipper.ClosedPathsFromPolyTree(tree);
        }

	public GraphicsPath(Point[] pts, byte[] types, FillMode fillMode)
			{
				if(pts == null)
				{
					throw new ArgumentNullException("pts");
				}
				if(types == null)
				{
					throw new ArgumentNullException("types");
				}
				this.fillMode = fillMode;
				// TODO: convert the pts and types arrays
			}

 /// <summary>
 /// Sets default values for this instance.
 /// </summary>
 public void SetDefault()
 {
     CullMode = CullMode.Back;
     FillMode = FillMode.Solid;
     DepthClipEnable = true;
     FrontFaceCounterClockwise = false;
     ScissorTestEnable = false;
     MultiSampleAntiAlias = false;
     MultiSampleAntiAliasLine = false;
     DepthBias = 0;
     DepthBiasClamp = 0f;
     SlopeScaleDepthBias = 0f;
 }

        public static PolygonMode ConvertFillMode(FillMode fillMode)
        {
            // NOTE: Vulkan's PolygonMode.Point is not exposed

            switch (fillMode)
            {
                case FillMode.Solid:
                    return PolygonMode.Fill;
                case FillMode.Wireframe:
                    return PolygonMode.Line;
                default:
                    throw new ArgumentOutOfRangeException(nameof(fillMode));
            }
        }

        public Moving_Object(Graphics _Gmoving)
        {
            G_moving = _Gmoving;
            Moving_Matrix = new Matrix(1, 0, 0, 1, 0, 0);
            Robot_Center_Point_X = Robot_Width/2 + _Init_X;

            point1 = new Point(10, 10);
            point2 = new Point(10, 20);
            point3 = new Point(30, 15);
            curvePoints = new Point[3];
            curvePoints[0] = point1;
            curvePoints[1] = point2;
            curvePoints[2] = point3;
            newFillMode = FillMode.Winding;
        }

    public GraphicNode(String tag, String path, Guid modelGuid, Stencil stencil, Rectangle boundingRect,
      Double angle, Rectangle tagArea, Double tagAngle, Font tagFont, Boolean tagVisible, Double opacity,
      System.Drawing.Color fillColor, FillMode fillMode, bool mirrorX, bool mirrorY)
      : base(tag, tagArea, tagAngle, tagFont, tagVisible, opacity)
    {
      this.path = path;

      this.modelGuid = modelGuid;
      this.stencil = stencil;

      this.boundingRect = boundingRect;
      this.angle = angle;

      this.fillColor = fillColor;
      this.fillMode = fillMode;
      this.mirrorX = mirrorX;
      this.mirrorY = mirrorY;
    }

 /// <summary>
 /// Specifies the method used to determine which points are inside the geometry described by this geometry sink  and which points are outside.
 /// </summary>
 /// <param name="fillMode">The method used to determine whether a given point is part of the geometry.</param>
 /// <remarks>
 /// The fill mode defaults to <see cref="SharpDX.Direct2D1.FillMode.Alternate"/>. To set the fill mode, call <strong>SetFillMode</strong> before the first call to <strong>BeginFigure</strong>. Not doing will put the geometry sink in an error state.
 /// </remarks>
 public void SetFillMode(FillMode fillMode)
 {
     SetFillMode_(fillMode);
 }