public InterestPointDrawer(Bitmap background, SRegion[] regions)
     : base(background, regions)
 {
     Color c = Color.FromArgb(125, Color.Red);
     pen = new Pen(c);
     brush = new SolidBrush(c);
 }

        public ImageSplitter(Image source, string format, int sizeX, int sizeY, int marginX, int marginY, Color background, Brush foreground)
        {
            _sizeX = sizeX;
            _sizeY = sizeY;
            _source = source;
            _format = format;
            _marginX = marginX;
            _marginY = marginY;
            _background = background;

            _tileSizeX = _sizeX + 1;
            _tileSizeY = _sizeY + 1;
            _innerTilesX = (_source.Width - 1)/_sizeX;
            _innerTilesY = (_source.Height - 1)/_sizeY;
            _lastTileSizeX = (_source.Width - 1)%_sizeX + 1;
            _lastTileSizeY = (_source.Height - 1)%_sizeY + 1;
            _dirName = "out_" + _sizeX + "_" + _sizeY;

            _combinedBitmap = new Bitmap(
                _marginX + _innerTilesX * _tileSizeX + _lastTileSizeX,
                _marginY + _innerTilesY * _tileSizeY + _lastTileSizeY);

            _combinedG = Graphics.FromImage(_combinedBitmap);
            _foreground = foreground;
        }

		static protected void DrawBrick (Graphics graphics, Brush b1, Brush b2, Brush b3)
		{
			if (graphics == null) return;
			graphics.FillPolygon (b1, brickPoints1);
			graphics.FillPolygon (b2, brickPoints2);
			graphics.FillPolygon (b3, brickPoints3);
		}

 public static void FillRoundedRectangle(this Graphics g, Brush brush, RectangleF rect, float topLeftCorner, float topRightCorner, float bottomLeftCorner, float bottomRightCorner)
 {
     using(var gp = GraphicsUtility.GetRoundedRectangle(rect, topLeftCorner, topRightCorner, bottomLeftCorner, bottomRightCorner))
     {
         g.FillPath(brush, gp);
     }
 }

 private static void DrawStringML(this Graphics G, string Text, Font font, Brush brush, float x, ref float y, float mX)
 {
     string[] words = Text.Split(' ');
     float tempX = x;
     float totalSpace = mX - x;
     SizeF measureWord = new SizeF(0, font.GetHeight());
     float tempWordWidth = 0;
     foreach (string word in words)
     {
         //measure word width (based in font size)
         tempWordWidth = G.MeasureString(word + " ", font).Width;
         measureWord.Width += tempWordWidth;
         //check if the word fits in free line space
         //if not then change line
         if (measureWord.Width > totalSpace)
         {
             y += font.GetHeight();
             tempX = x;
             measureWord.Width = tempWordWidth;
         }
         G.DrawString(word + " ", font, brush, tempX, y);
         tempX += tempWordWidth;
     }
     y += font.GetHeight();
 }

 public void Draw(Graphics gr, Pen pen, Brush backgroundBrush, Pen forePen)
 {
     //draw minus
     gr.FillRectangle(backgroundBrush, rectangle);
     gr.DrawRectangle(pen, rectangle);
     gr.DrawLine(forePen, rectangle.Left + 2, rectangle.Top + rectangle.Height / 2, rectangle.Right - 2, rectangle.Top + rectangle.Height / 2);
 }

        public Surface()
        {
            ScreenRectangle = CaptureHelpers.GetScreenBounds();
            ScreenRectangle0Based = CaptureHelpers.ScreenToClient(ScreenRectangle);

            InitializeComponent();

            using (MemoryStream cursorStream = new MemoryStream(Resources.Crosshair))
            {
                Cursor = new Cursor(cursorStream);
            }

            DrawableObjects = new List<DrawableObject>();
            Config = new SurfaceOptions();
            timerStart = new Stopwatch();
            timerFPS = new Stopwatch();

            borderPen = new Pen(Color.Black);
            borderDotPen = new Pen(Color.White);
            borderDotPen.DashPattern = new float[] { 5, 5 };
            nodeBackgroundBrush = new SolidBrush(Color.White);
            textFont = new Font("Verdana", 16, FontStyle.Bold);
            infoFont = new Font("Verdana", 9);
            textBackgroundBrush = new SolidBrush(Color.FromArgb(75, Color.Black));
            textBackgroundPenWhite = new Pen(Color.FromArgb(50, Color.White));
            textBackgroundPenBlack = new Pen(Color.FromArgb(150, Color.Black));
            markerPen = new Pen(Color.FromArgb(200, Color.Red)) { DashStyle = DashStyle.Dash };
        }

 public static void FillRoundRectangle(Graphics g, Brush brush, Rectangle rect, int cornerRadius)
 {
     using (GraphicsPath path = CreateRoundedRectanglePath(rect, cornerRadius))
     {
         g.FillPath(brush, path);
     }
 }

 public Ellipse(Pen pen, Brush brush, Point start, Point end)
 {
     Pen = pen;
     Brush = brush;
     Start = start;
     End = end;
 }

        protected virtual void DrawRectangle(Pen outlinePen, Brush fillBrush)
        {
            if (fillBrush is LinearGradientBrush)
            {
                if ((rect.Width > 0) && (rect.Height > 0))
                {
                    fillBrush = new LinearGradientBrush(rect,
                          args.settings.PrimaryColor,
                          args.settings.SecondaryColor,
                          args.settings.GradiantStyle);
                    //outlinePen = new Pen(fillBrush, args.settings.Width);
                }
            }

            switch (args.settings.DrawMode)
            {
                case DrawMode.Outline:
                    g.DrawRectangle(outlinePen, rect);
                    break;

                case DrawMode.Filled:
                    g.FillRectangle(fillBrush, rect);
                    break;

                case DrawMode.Mixed:
                    g.FillRectangle(fillBrush, rect);
                    g.DrawRectangle(outlinePen, rect);
                    break;

                case DrawMode.MixedWithSolidOutline:
                    g.FillRectangle(fillBrush, rect);
                    g.DrawRectangle(outlinePen, rect);
                    break;
            }
        }

 public NodeCursor(GameUI myGameUI, int myDepth)
     : base(myGameUI, myDepth)
 {
     penCursorMini = new Pen(new SolidBrush(Color.FromArgb(180, Color.Wheat)), 2);
     brushCellMarker = new SolidBrush(Color.FromArgb(40, Color.Yellow));
     brushCursorMini = new SolidBrush(Color.FromArgb(200, Color.White));
 }

        public void WatermarkFileWithText(string inputFile, string outputFile, string text, Font font, int x, int y,
                                          bool renderOver,
                                          Brush under, Brush over, StringAlignment xAlignment,
                                          StringAlignment yAlignment)
        {
            Image imgPhoto = null;
            Image outputPhoto = null;
            try
            {
                try
                {
                    imgPhoto = Image.FromFile(inputFile);
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException("Failed to open file \"" + inputFile + "\"", ex);
                }

                WatermarkImageWithText(imgPhoto, ref outputPhoto, SmoothingMode.AntiAlias, text, font, x, y, renderOver,
                                       under, over, xAlignment, yAlignment);

                imgPhoto.Dispose();
                imgPhoto = null;

                outputPhoto.Save(outputFile, ImageFormat.Jpeg);
            }
            finally
            {
                if (imgPhoto != null) imgPhoto.Dispose();
                if (outputPhoto != null) outputPhoto.Dispose();
            }
        }

        public static void BuildStatusMessageCellPainting(DataGridViewCellPaintingEventArgs e, GitRevision revision, Brush foreBrush, Font rowFont)
        {
            if (revision.BuildStatus != null)
            {
                Brush buildStatusForebrush = foreBrush;

                switch (revision.BuildStatus.Status)
                {
                    case BuildInfo.BuildStatus.Success:
                        buildStatusForebrush = Brushes.DarkGreen;
                        break;
                    case BuildInfo.BuildStatus.Failure:
                        buildStatusForebrush = Brushes.DarkRed;
                        break;
                    case BuildInfo.BuildStatus.InProgress:
                        buildStatusForebrush = Brushes.Blue;
                        break;
                    case BuildInfo.BuildStatus.Unstable:
                        buildStatusForebrush = Brushes.OrangeRed;
                        break;
                    case BuildInfo.BuildStatus.Stopped:
                        buildStatusForebrush = Brushes.Gray;
                        break;
                }

                var text = (string)e.FormattedValue;
                e.Graphics.DrawString(text, rowFont, buildStatusForebrush, new PointF(e.CellBounds.Left, e.CellBounds.Top + 4));
            }
        }

        public static void BuildStatusImageColumnCellPainting(DataGridViewCellPaintingEventArgs e, GitRevision revision, Brush foreBrush, Font rowFont)
        {
            if (revision.BuildStatus != null)
            {
                Image buildStatusImage = null;

                switch (revision.BuildStatus.Status)
                {
                    case BuildInfo.BuildStatus.Success:
                        buildStatusImage = Resources.BuildSuccessful;
                        break;
                    case BuildInfo.BuildStatus.Failure:
                        buildStatusImage = Resources.BuildFailed;
                        break;
                    case BuildInfo.BuildStatus.Unknown:
                        buildStatusImage = Resources.BuildCancelled;
                        break;
                    case BuildInfo.BuildStatus.InProgress:
                        buildStatusImage = Resources.Icon_77;
                        break;
                    case BuildInfo.BuildStatus.Unstable:
                        buildStatusImage = Resources.bug;
                        break;
                    case BuildInfo.BuildStatus.Stopped:
                        buildStatusImage = Resources.BuildCancelled;
                        break;
                }

                if (buildStatusImage != null)
                {
                    e.Graphics.DrawImage(buildStatusImage, new Rectangle(e.CellBounds.Left, e.CellBounds.Top + 4, 16, 16));
                }
            }
        }

		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Updates the background brush.
		/// </summary>
		/// ------------------------------------------------------------------------------------
		private void UpdateBackgroundBrush()
		{
			if (m_BackBrush != null)
				m_BackBrush.Dispose();

			m_BackBrush = null;
		}

      public void SetPixelScaled(int x, int y, Brush brush, int scale = 1)
      {
        int bitmapX = x * scale;
        int bitmapY = y * scale;

        FillRect(bitmapX, bitmapY, scale, scale, brush);
      }

        public static void FillPill(Brush b, RectangleF rect, Graphics g)
        {
            if (rect.Width > rect.Height)
            {
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.FillEllipse(b, new RectangleF(rect.Left, rect.Top, rect.Height, rect.Height));
                g.FillEllipse(b, new RectangleF(rect.Left + rect.Width - rect.Height, rect.Top, rect.Height, rect.Height));

                var w = rect.Width - rect.Height;
                var l = rect.Left + ((rect.Height) / 2);
                g.FillRectangle(b, new RectangleF(l, rect.Top, w, rect.Height));
                g.SmoothingMode = SmoothingMode.Default;
            }
            else if (rect.Width < rect.Height)
            {
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.FillEllipse(b, new RectangleF(rect.Left, rect.Top, rect.Width, rect.Width));
                g.FillEllipse(b, new RectangleF(rect.Left, rect.Top + rect.Height - rect.Width, rect.Width, rect.Width));

                var t = rect.Top + (rect.Width / 2);
                var h = rect.Height - rect.Width;
                g.FillRectangle(b, new RectangleF(rect.Left, t, rect.Width, h));
                g.SmoothingMode = SmoothingMode.Default;
            }
            else if (rect.Width == rect.Height)
            {
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.FillEllipse(b, rect);
                g.SmoothingMode = SmoothingMode.Default;
            }
        }

 public DataPoint(string name, float value, Brush brush)
 {
     m_name = name;
     m_value = value;
     m_brush = brush;
     m_color = Color.Black;
 }

		protected void DoGraphics( ArrayList chains )
		{
			m_panelClip.Graphics.FillRectangle( Brushes.Black, m_panelClip.Rect );

			int w = 350;
			int h = 50;
			m_backBrush  = new SolidBrush( Color.FromArgb( 60, 60, 60 ) );
			

			string[] prefix = new string[]{"LongMethod", "TemporaryField", "MessageChains"};
			string[] baseCls = new string[]{"Detector", "Visualization", "Component", "Comparer"};

			int i = 0;

			MovieClip clip = m_panelClip.CreateSubMovieClip( 0, 0, w, h );
			foreach( string bass in baseCls)
			{
				CreateClassHier( clip, bass, prefix, 0, 0, w/4, h );
				i++;
			}
			MovieClip legend = clip.CreateSubMovieClip( (3*w)/4, 0, w/4, h );
			Brush[] brushes = new Brush[]{Brushes.LightGreen,Brushes.LightBlue, Brushes.LightPink};
			for( int d = 0; d < prefix.Length; d++ )
			{   // extra spacing in between disconnected chains?
				MovieClip index = legend.CreateSubMovieClip( 0, 0, w/4, h/3 );
				MovieClip dot = index.CreateSubMovieClip( 0, 0, 10, 10 );
				dot.Graphics.FillEllipse( brushes[d], 0, 0, 9, 9 );
				MovieClip text = index.CreateSubMovieClip( 10, 0, w/4 - 10, h/3 );
				text.LeftString( prefix[d], Brushes.White);
			}
			Space( 4, 1, legend.Children, w/4 );
			Space( 10, 10, clip.Children, this.Width );
		}

        public VideoRender(PictureBox view)
        {
            this.view = view;
			this.bufferContext = BufferedGraphicsManager.Current;
            this.foreground = new SolidBrush(Color.ForestGreen);
            this.background = new SolidBrush(Color.Black);
        }