/// <summary>
 /// Initializes a new instance of the <see cref="XLinearGradientBrush"/> class.
 /// </summary>
 public XLinearGradientBrush(XPoint point1, XPoint point2, XColor color1, XColor color2)
 {
   this.point1 = point1;
   this.point2 = point2;
   this.color1 = color1;
   this.color2 = color2;
 }

 internal XPen(XColor color, double width, bool immutable)
 {
   this.color = color;
   this.width = width;
   this.lineJoin = XLineJoin.Miter;
   this.lineCap = XLineCap.Flat;
   this.dashStyle = XDashStyle.Solid;
   this.dashOffset = 0f;
   this.immutable = immutable;
 }

 internal XPen(XColor color, double width, bool immutable)
 {
     _color = color;
     _width = width;
     _lineJoin = XLineJoin.Miter;
     _lineCap = XLineCap.Flat;
     _dashStyle = XDashStyle.Solid;
     _dashOffset = 0f;
     _immutable = immutable;
 }

 public int SetBackgroundColor(XColor color)
 {
     return XSetWindowBackground (display.Handle, Handle, color.Pixel);
 }

 public int SetForeground(XColor foreground)
 {
     return XSetForeground (display.Handle, Handle, foreground.Pixel);
 }

 public int SetBackground(XColor background)
 {
     return XSetBackground (display.Handle, Handle, background.Pixel);
 }

 private static void DrawRectangle(XGraphics gfx,
     XColor backColor, XColor borderColor,
     XPen borderPen,
     int width, int height,
     int x, int y)
 {
     gfx.DrawRectangle(borderPen, x, y, width, height);
 }

 internal XSolidBrush(XColor color, bool immutable)
 {
     _color = color;
     _immutable = immutable;
 }

 public ColorItem(XColor color, string name)
 {
     Color = color;
     Name = name;
 }

        public void WorldColors(World world, out XColor penColorOut, out XColor brushColorOut)
        {
            Color penColor = Color.Empty;
            Color brushColor = Color.Empty;

            if (showWorldDetailColors)
            {
                if (world.IsAg && world.IsRi)
                {
                    penColor = brushColor = Color.Gold;
                }
                else if (world.IsAg)
                {
                    penColor = brushColor = Color.Green;
                }
                else if (world.IsRi)
                {
                    penColor = brushColor = Color.Purple;
                }
                else if (world.IsIn)
                {
                    penColor = brushColor = Color.FromArgb(0x88, 0x88, 0x88); // Gray
                }
                else if (world.Atmosphere > 10)
                {
                    penColor = brushColor = Color.FromArgb(0xcc, 0x66, 0x26); // Rust
                }
                else if (world.IsVa)
                {
                    brushColor = Color.Black;
                    penColor = Color.White;
                }
                else if (world.WaterPresent)
                {
                    brushColor = worldWater.fillColor;
                    penColor = worldWater.pen.color;
                }
                else
                {
                    brushColor = worldNoWater.fillColor;
                    penColor = worldNoWater.pen.color;
                }
            }
            else
            {
                // Classic colors

                // World disc
                brushColor = (world.WaterPresent) ? worldWater.fillColor : worldNoWater.fillColor;
                penColor = (world.WaterPresent) ? worldWater.pen.color : worldNoWater.pen.color;
            }

            penColorOut = penColor.IsEmpty ? XColor.Empty : penColor;
            brushColorOut = brushColor.IsEmpty ? XColor.Empty : brushColor;
        }

 /// <summary>
 /// Creates an XColor structure from the specified alpha value and color.
 /// </summary>
 public static XColor FromArgb(int alpha, XColor color)
 {
   color.A = ((byte)alpha) / 255.0;
   return color;
 }

 internal XSolidBrush(XColor color, bool immutable)
 {
   this.color = color;
   this.immutable = immutable;
 }

    //public void Flush();
    //public void Flush(FlushIntention intention);

    #region Drawing

    // ----- Clear --------------------------------------------------------------------------------

    /// <summary>
    /// Fills the entire drawing surface with the specified color. The functions works only if
    /// the current transformation is identity, i.e. the function should be called only immediately
    /// after the XGraphics object was created.
    /// </summary>
    public void Clear(XColor color)
    {
      if (this.drawGraphics)
      {
#if GDI
        if (this.targetContext == XGraphicTargetContext.GDI)
          this.gfx.Clear(color.ToGdiColor());
#endif
#if WPF
        if (this.targetContext == XGraphicTargetContext.WPF)
        {
          Rect rc = new Rect();
          rc.Width = rc.Height = 10000;
          this.dc.DrawRectangle(new SolidColorBrush(color.ToWpfColor()), null, rc);
        }
#endif
      }

      if (this.renderer != null)
        this.renderer.Clear(color);
    }

        private static void DrawBadgeElement(Badge badge, XGraphics gfx)
        {
            var color = ConverterManager.HexToColorConverter(badge.ForegroundColor);
            XColor borderColor = new XColor { R = color.R, G = color.G, B = color.B };
            color = ConverterManager.HexToColorConverter(badge.BackgroundColor);
            XColor backColor = new XColor { R = color.R, G = color.G, B = color.B };
            color = ConverterManager.HexToColorConverter(badge.FontColor);
            XColor fontColor = new XColor { R = color.R, G = color.G, B = color.B };
            XPen pen = new XPen(borderColor, double.Parse(badge.BorderWidth.ToString()));

            DrawRectangle(gfx, backColor, borderColor, pen, badge.Width, badge.Height, badge.PositionX1, badge.PositionY1);
            DrawText(gfx, badge.Value, badge.Font, badge.FontStyle, badge.FontSize, badge.FontColor, badge.Width, badge.Height, badge.PositionX1, badge.PositionY1);
        }

		public XColor( XColor xc )
		{
			color = xc.color;
		}

		internal extern static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot);

 public int SetWindowBorder(XColor color)
 {
     return XSetWindowBorder (display.Handle, Handle, color.Pixel);
 }

		internal extern static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color);

		internal extern static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def);

		IntPtr GetReversibleControlGC (Control control, int line_width)
		{
			XGCValues	gc_values;
			IntPtr		gc;

			gc_values = new XGCValues();

			gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors;
			gc_values.line_width = line_width;
			gc_values.foreground = XBlackPixel(DisplayHandle, ScreenNo);

			// This logic will give us true rubber bands: (libsx, SANE_XOR)
			//mask = foreground ^ background; 
			//XSetForeground(DisplayHandle, gc, 0xffffffff);
			//XSetBackground(DisplayHandle, gc, background);
			//XSetFunction(DisplayHandle,   gc, GXxor);
			//XSetPlaneMask(DisplayHandle,  gc, mask);


			gc = XCreateGC(DisplayHandle, control.Handle, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCLineWidth | GCFunction.GCForeground)), ref gc_values);
			uint foreground;
			uint background;

			XColor xcolor = new XColor();

			xcolor.red = (ushort)(control.ForeColor.R * 257);
			xcolor.green = (ushort)(control.ForeColor.G * 257);
			xcolor.blue = (ushort)(control.ForeColor.B * 257);
			XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
			foreground = (uint)xcolor.pixel.ToInt32();

			xcolor.red = (ushort)(control.BackColor.R * 257);
			xcolor.green = (ushort)(control.BackColor.G * 257);
			xcolor.blue = (ushort)(control.BackColor.B * 257);
			XAllocColor(DisplayHandle, DefaultColormap, ref xcolor);
			background = (uint)xcolor.pixel.ToInt32();

			uint mask = foreground ^ background; 

			XSetForeground(DisplayHandle, gc, (UIntPtr)0xffffffff);
			XSetBackground(DisplayHandle, gc, (UIntPtr)background);
			XSetFunction(DisplayHandle,   gc, GXFunction.GXxor);
			XSetPlaneMask(DisplayHandle,  gc, (IntPtr)mask);

			return gc;
		}