public HatchBrush(HatchStyle hatchStyle, Color foreColor, Color backColor)
 {
     this.hatchStyle = hatchStyle;
     this.foreCol = foreColor;
     this.backCol = backColor;
     base.native = LibIGraph.CreateBrush_Hatch(hatchStyle, foreCol.ToArgb(), backCol.ToArgb());
 }

 protected void FillImageByHatch(Image img, HatchStyle s)
 {
     Graphics g = Graphics.FromImage(img);
     HatchBrush brush = new HatchBrush(s, Color.Black, Color.White);
     g.FillRectangle(brush, new Rectangle(0, 0, img.Width, img.Height));
     g.Dispose();
 }

 public Captcha(int Width, int Height, HatchStyle TextStyle = HatchStyle.NarrowHorizontal, HatchStyle BackStyle = HatchStyle.DottedGrid)
 {
     this.Width = Width;
     this.Height = Height;
     this.TextStyle = TextStyle;
     this.BackStyle = BackStyle;
 }

 public GBrush(BrushStyle aStyle, HatchStyle hatchStyle, Colorref aColor, Guid uniqueID)
 {
     BrushStyle = aStyle;
     HatchStyle = hatchStyle;
     Color = aColor;
     UniqueID = uniqueID;
 }

 public GradientStyle(HatchStyle hatch, Color fore, Color back)
 {
     Type = GradientType.HatchStyleGradient;
     FirstColor = fore;
     SecondColor = back;
     Hatch = hatch;
 }

		public HatchBrush(HatchStyle style, Color foreground, Color background)
		{
			_hatchStyle = style;
			_foregroundColor = foreground;
			_backgroundColor = background;
			throw new NotImplementedException();
		}

	// Constructor.
	public DrawingHatchBrush(HatchStyle style,
							 System.Drawing.Color foreColor,
							 System.Drawing.Color backColor) : base (foreColor)
			{
				this.style = style;
				this.foreColor = foreColor;
				this.backColor = backColor;
			}

        public HatchBrush(HatchStyle hatchstyle, Color foreColor, Color backColor) 
        {
            IntPtr brush = IntPtr.Zero;
            int status = SafeNativeMethods.Gdip.GdipCreateHatchBrush(unchecked((int) hatchstyle), foreColor.ToArgb(), backColor.ToArgb(), out brush);
            
            if (status != SafeNativeMethods.Gdip.Ok)
                throw SafeNativeMethods.Gdip.StatusException(status);

            SetNativeBrushInternal(brush);
        }

 /// <summary>
 /// Initializes a new instance of the <c>HatchPattern</c> class.
 /// </summary>
 /// <param name="name">Pattern name, always stored as uppercase.</param>
 /// <param name="description">Description of the pattern (optional, this information is not saved in the dxf file). By default it will use the supplied name.</param>
 public HatchPattern(string name, string description = null)
 {
     this.name = name.ToUpper();
     this.description = string.IsNullOrEmpty(description) ? name : description;
     this.style = HatchStyle.Normal;
     this.fill = this.name == "SOLID" ? HatchFillType.SolidFill : HatchFillType.PatternFill;
     this.type = HatchType.UserDefined;
     this.origin = Vector2.Zero;
     this.angle = 0.0;
     this.scale = 1.0;
     this.lineDefinitions = new List<HatchPatternLineDefinition>();
 }

    void SetDataSource(HatchStyle selected)
    {
      this.BeginUpdate();

      Items.Clear();
      foreach (HatchStyle o in Enum.GetValues(typeof(HatchStyle)))
        Items.Add(o);

      SelectedItem = selected;

      this.EndUpdate();
    }

        /// <summary>
        /// Constructor that takes a HatchStyle, BackColor and ForeColor as arguments.
        /// </summary>
        /// <param name="hs">HatchStyle to be used in the instance created.</param>
        /// <param name="cBack">BackColor to be used in the instance created.</param>
        /// <param name="cFore">ForeColor to be used in the instance created.</param>
        public EditorHatchStyleUI(HatchStyle hs, Color cBack, Color cFore)
        {
            InitializeComponent();

            AddHatchStylesToListBox();

            hsHatchStyle = hs;

            cHatchStyleBackColor = cBack;
            cHatchStyleForeColor = cFore;

            this.Width = 224;
        }

        public GDIBrush(BrushStyle aStyle, HatchStyle hatchStyle, Colorref colorref, Guid uniqueID)
            : base(true, uniqueID)
        {
            fBrushStyle = aStyle;
            fHatchStyle = hatchStyle;
            fColor = colorref;

            fLogBrush = new LOGBRUSH32();

            // Make sure to mask off the high order byte
            // or GDI will draw in black
            fLogBrush.lbColor = colorref & 0x00ffffff;
            fLogBrush.lbHatch = (int)hatchStyle;
            fLogBrush.lbStyle = (int)aStyle;

            IntPtr brushHandle = GDI32.CreateBrushIndirect(ref fLogBrush);

            SetHandle(brushHandle);
        }

	// Get the bitmap corresponding to a particular hatch style.
	private static IntPtr GetBitmap(HatchStyle style)
	{
		IntPtr bitmap;

		// See if we have a cached bitmap for this style.
		if(((int)style) >= 0 && ((int)style) <= 52)
		{
			if (hatchBitmaps == null)
			{
				hatchBitmaps = new IntPtr[53];
			}
			bitmap = hatchBitmaps[(int)style];
			if (bitmap != IntPtr.Zero)
			{
				return bitmap;
			}
		}
		else
		{
			return IntPtr.Zero;
		}

		// Get the raw bits for the hatch bitmap.
		byte[] bits = GetBits(style);
		if(bits == null)
		{
			return IntPtr.Zero;
		}

		// Create the bitmap, cache it for later, and then return it.
		Array.Reverse(bits);
		bitmap = Win32.Api.CreateBitmap(16, 16, 1, 1, bits);
		hatchBitmaps[(int)style] = bitmap;
		return bitmap;
				
	}

		internal extern static IntPtr Win32CreateHatchBrush(HatchStyle fnStyle, IntPtr color);

 public override void CalculateValues()
 {
     foreach (string name in Properties.Keys)
     {
         string value = Properties[name];
         switch (name)
         {
             case "background-color":
                 _backgroundColor = ParseColor(value);
                 break;
             case "shape":
                 _shape = (ShapeStyle)Enum.Parse(typeof(ShapeStyle), value);
                 break;
             case "color":
                 _foregroundColor = ParseColor(value);
                 break;
             case "border-style":
                 _borderStyle = (BorderStyle)Enum.Parse(typeof(BorderStyle), value);
                 break;
             case "border-width":
                 _borderWidth = float.Parse(value, CultureInfo.InvariantCulture);
                 break;
             case "border-color":
                 _borderColor = ParseColor(value);
                 break;
             case "fill-style":
                 _fillStyle = (FillStyle)Enum.Parse(typeof(FillStyle), value);
                 break;
             case "hatch-style":
                 _hatchStyle = (HatchStyle)Enum.Parse(typeof(HatchStyle), value);
                 break;
             case "width":
                 _width = float.Parse(value, CultureInfo.InvariantCulture);
                 break;
             case "height":
                 _height = float.Parse(value, CultureInfo.InvariantCulture);
                 break;
             case "alpha":
                 _alpha = int.Parse(value, CultureInfo.InvariantCulture);
                 break;
         }
     }
 }

 public static extern IntPtr CreateBrush_Hatch(HatchStyle hatchStyle, int foreCol, int backCol);

 void ComboBoxStyleSelectedIndexChanged(object sender, EventArgs e)
 {
     String type = comboBoxStyle.SelectedItem.ToString();
     style = (HatchStyle)Enum.Parse( typeof(HatchStyle), type);
 }

		static internal extern Status GdipGetHatchStyle (IntPtr brush, out HatchStyle hatchstyle);

		static internal extern Status GdipCreateHatchBrush (HatchStyle hatchstyle, int foreColor, int backColor, out IntPtr brush);

 float getLineWidth(HatchStyle hbr)
 {
     return hatches_const[(int)hbr][2];
 }