private TextPaint getPaint(IBrush brush)
		{
			TextPaint paint = ((AndroidBrush)brush).InnerBrush;
			paint.SetTypeface(((AndroidFont)_config.Font).InnerFont);
			paint.TextSize = _config.Font.SizeInPoints;
			return paint;
		}

 protected virtual void OnValuesChanged(IBrush brush)
 {
     if (ValuesChanged != null)
     {
         ValuesChanged(this, brush);
     }
 }

        /// <summary>
        /// Creates a Direct2D brush wrapper for a Avalonia brush.
        /// </summary>
        /// <param name="brush">The avalonia brush.</param>
        /// <param name="destinationSize">The size of the brush's target area.</param>
        /// <returns>The Direct2D brush wrapper.</returns>
        public BrushImpl CreateBrush(IBrush brush, Size destinationSize)
        {
            var solidColorBrush = brush as Avalonia.Media.ISolidColorBrush;
            var linearGradientBrush = brush as Avalonia.Media.LinearGradientBrush;
            var radialGradientBrush = brush as Avalonia.Media.RadialGradientBrush;
            var imageBrush = brush as Avalonia.Media.ImageBrush;
            var visualBrush = brush as Avalonia.Media.VisualBrush;

            if (solidColorBrush != null)
            {
                return new SolidColorBrushImpl(solidColorBrush, _renderTarget);
            }
            else if (linearGradientBrush != null)
            {
                return new LinearGradientBrushImpl(linearGradientBrush, _renderTarget, destinationSize);
            }
            else if (radialGradientBrush != null)
            {
                return new RadialGradientBrushImpl(radialGradientBrush, _renderTarget, destinationSize);
            }
            else if (imageBrush != null)
            {
                return new TileBrushImpl(imageBrush, _renderTarget, destinationSize);
            }
            else if (visualBrush != null)
            {
                return new TileBrushImpl(visualBrush, _renderTarget, destinationSize);
            }
            else
            {
                return new SolidColorBrushImpl((Avalonia.Media.SolidColorBrush)null, _renderTarget);
            }
        }

        public FontChooserControl(IBrush brush)
            : base(brush)
        {
            InitializeComponent();

            FontPicker.Items.Clear();
            FontPicker.Items.AddRange(FontFamily.Families.Select(x => x.Name).OfType<object>().ToArray());
            FontPicker.SelectedItem = GetFontFamily().Name;
        }

        public PGDIRenderer(GDIContext gdi)
        {
            Graphics = new GDIRenderer(gdi);

            HollowBrush = new GDIBrush(BrushStyle.Hollow, HatchStyle.Horizontal, (Colorref)0, Guid.NewGuid());

            Graphics.UseDefaultPen();
            Graphics.UseDefaultBrush();
        }

        public PaintTool(DrawWindow parent, IBrush brush)
        {
            _parent = parent;
            _brush = brush;

            var map = _parent.TilerMap;

            if (_brush == null)
                _brush = new NormalBrush(map != null ? map.TileResolution : 1, TileTexture.None);
        }

        public override void SetBrush(IBrush brush)
        {
            if (brush.BrushStyle == BrushStyle.Hollow)
            {
                Graphics.SetBrush(HollowBrush);
                return;
            }

            Graphics.UseDefaultBrush();
            Graphics.SetDefaultBrushColor(brush.Color);
        }

        public void SetBrush(IBrush brush)
        {
            // Only allow normal brushes
            var b = brush as NormalBrush;
            if (b == null)
            {
                var map = _parent.TilerMap;
                b = new NormalBrush(map != null ? map.TileResolution : 1, TileTexture.None);
            }

            _brush = b;
        }

        IRenderBucket IRenderer.this[IBrush brush]
        {
            get
            {
                IRenderBucket bucket;
                var exists = _renderBuckets.TryGetValue(brush, out bucket);
                if (!exists)
                {
                    bucket = new PreTransformedRenderBucket();
                    _renderBuckets.Add(brush, bucket);
                }

                return bucket;
            }
        }

		private void drawString(Graphics gfx, IBrush ibrush, float x, float y)
		{
			Brush brush = getBrush(ibrush);
			if (brush == null)
				return;
			Font font = getFont(_config.Font);
			if (_maxWidth == int.MaxValue)
			{
                gfx.DrawString(_text, font, brush, x, y, StringFormat.GenericTypographic);                
			}
			else
			{
				alignWrap();
				gfx.DrawString(_text, font, brush, new RectangleF(x, y, _maxWidth, _height),
					_wrapFormat);
			}
		}

        public void DrawGeometry(IBrush brush, Pen pen, Geometry geometry)
        {
            var impl = ((StreamGeometryImpl)geometry.PlatformImpl);
            var size = geometry.Bounds.Size;

            using (var fill = brush != null ? CreatePaint(brush, size) : default(PaintWrapper))
            using (var stroke = pen?.Brush != null ? CreatePaint(pen, size) : default(PaintWrapper))
            {
                if (fill.Paint != null)
                {
                    Canvas.DrawPath(impl.EffectivePath, fill.Paint);
                }
                if (stroke.Paint != null)
                {
                    Canvas.DrawPath(impl.EffectivePath, stroke.Paint);
                }
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Pen"/> class.
 /// </summary>
 /// <param name="brush">The brush used to draw.</param>
 /// <param name="thickness">The stroke thickness.</param>
 /// <param name="dashStyle">The dash style.</param>
 /// <param name="dashCap">The dash cap.</param>
 /// <param name="startLineCap">The start line cap.</param>
 /// <param name="endLineCap">The end line cap.</param>
 /// <param name="lineJoin">The line join.</param>
 /// <param name="miterLimit">The miter limit.</param>
 public Pen(
     IBrush brush, 
     double thickness = 1.0,
     DashStyle dashStyle = null, 
     PenLineCap dashCap = PenLineCap.Flat, 
     PenLineCap startLineCap = PenLineCap.Flat, 
     PenLineCap endLineCap = PenLineCap.Flat, 
     PenLineJoin lineJoin = PenLineJoin.Miter, 
     double miterLimit = 10.0)
 {
     Brush = brush;
     Thickness = thickness;
     DashCap = dashCap;
     StartLineCap = startLineCap;
     EndLineCap = endLineCap;
     LineJoin = lineJoin;
     MiterLimit = miterLimit;
     DashStyle = dashStyle;
 }

		public AGSTextConfig(IBrush brush = null, IFont font = null, IBrush outlineBrush = null, float outlineWidth = 0f,
			IBrush shadowBrush = null, float shadowOffsetX = 0f, float shadowOffsetY = 0f, 
			Alignment alignment = Alignment.TopLeft, AutoFit autoFit = AutoFit.NoFitting,
			float paddingLeft = 2f, float paddingRight = 2f, float paddingTop = 2f, float paddingBottom = 2f)
		{
			Brush = brush ?? Hooks.BrushLoader.LoadSolidBrush(Colors.White);
			Font = font ?? AGSGameSettings.DefaultTextFont;
			OutlineBrush = outlineBrush ?? Hooks.BrushLoader.LoadSolidBrush(Colors.White);
            OutlineWidth = outlineWidth;
			ShadowBrush = shadowBrush;
			ShadowOffsetX = shadowOffsetX;
			ShadowOffsetY = shadowOffsetY;
			Alignment = alignment;
			AutoFit = autoFit;
			PaddingLeft = paddingLeft;
			PaddingRight = paddingRight;
			PaddingTop = paddingTop;
			PaddingBottom = paddingBottom;
		}

    public void PaintTile(Point tileID, IBrush brush)
    {
        if (brush == null)
        {
            Debug.Log("Array doesn't exist");
            return;
        }

        var applyList = new HashSet<Texture2D>();

        // How far we travel
        var right = brush.BrushSize.X / 2;
        var left = (brush.BrushSize.X - 1) / 2;
        var up = brush.BrushSize.Y / 2;
        var down = (brush.BrushSize.Y - 1) / 2;

        for (var y = -down; y <= up; y++)
        {
            for (var x = -left; x <= right; x++)
            {
                var tid = new Point(tileID.X + x, tileID.Y + y);

                var data = brush.GetBrush(x, y);

                var changedTexture = ChangeTile(tid, data);
                if (changedTexture != null)
                    applyList.Add(changedTexture);
            }
        }

        // Apply any changes
        foreach (var texture in applyList)
        {
            texture.Apply();
        }
    }

        public override void Render(DrawingContext context)
        {
            var selectionStart = SelectionStart;
            var selectionEnd = SelectionEnd;

            if (selectionStart != selectionEnd)
            {
                var start = Math.Min(selectionStart, selectionEnd);
                var length = Math.Max(selectionStart, selectionEnd) - start;

                // issue #600: set constaint before any FormattedText manipulation
                //             see base.Render(...) implementation
                FormattedText.Constraint = Bounds.Size;

                var rects = FormattedText.HitTestTextRange(start, length);

                if (_highlightBrush == null)
                {
                    _highlightBrush = (IBrush)this.FindStyleResource("HighlightBrush");
                }

                foreach (var rect in rects)
                {
                    context.FillRectangle(_highlightBrush, rect);
                }
            }

            base.Render(context);

            if (selectionStart == selectionEnd)
            {                
                var backgroundColor = (((Control)TemplatedParent).GetValue(BackgroundProperty) as SolidColorBrush)?.Color;
                var caretBrush = Brushes.Black;

                if(backgroundColor.HasValue)
                {
                    byte red = (byte)~(backgroundColor.Value.R);
                    byte green = (byte)~(backgroundColor.Value.G);
                    byte blue = (byte)~(backgroundColor.Value.B);

                    caretBrush = new SolidColorBrush(Color.FromRgb(red, green, blue));
                }
                
                if (_caretBlink)
                {
                    var charPos = FormattedText.HitTestTextPosition(CaretIndex);
                    var x = Math.Floor(charPos.X) + 0.5;
                    var y = Math.Floor(charPos.Y) + 0.5;
                    var b = Math.Ceiling(charPos.Bottom) - 0.5;

                    context.DrawLine(
                        new Pen(caretBrush, 1),
                        new Point(x, y),
                        new Point(x, b));
                }
            }
        }

 private void ValuesChanged(IBrush brush)
 {
     if (BrushManager.CurrentBrush == brush) _updatePreview = true;
 }

        public void SetForegroundBrush(IBrush brush, int startIndex, int length)
        {
            var key = new FBrushRange(startIndex, length);
            int index = _foregroundBrushes.FindIndex(v => v.Key.Equals(key));

            if (index > -1)
            {
                _foregroundBrushes.RemoveAt(index);
            }

            if (brush != null)
            {
                _foregroundBrushes.Insert(0, new KeyValuePair<FBrushRange, IBrush>(key, brush));
            }
        }

 /// <summary>
 /// Sets the foreground brush for the specified text range.
 /// </summary>
 /// <param name="brush">The brush.</param>
 /// <param name="startIndex">The start of the text range.</param>
 /// <param name="length">The length of the text range.</param>
 public void SetForegroundBrush(IBrush brush, int startIndex, int length)
 {
     CheckDisposed();
     PlatformImpl.SetForegroundBrush(brush, startIndex, length);
 }

 public void PushOpacityMask(IBrush mask, Rect bounds)
 {
     Canvas.SaveLayer(new SKPaint());
     maskStack.Push(CreatePaint(mask, bounds.Size));
 }

 public void DrawText(IBrush foreground, Point origin, FormattedText text)
 {
     using (var paint = CreatePaint(foreground, text.Measure()))
     {
         var textImpl = text.PlatformImpl as FormattedTextImpl;
         textImpl.Draw(this, Canvas, origin.ToSKPoint(), paint);
     }
 }