C# Drawing a line from (bitmap image)dot to (bitmap image)dot.

See more:

C#

Bitmap

Dear reader,
I came here with a problem.
I've been working days on a code that draws a grid of dots (6 rows, 8 columns) on the form. It was very hard for me to understand how to get it drawn on the form as my knowledge with Graphics in C# is very poor, but working eventually.
What I'm trying and wanting to do next is to draw a line from a DOT to DOT on mouse clicks events. Unfortunately I couldn't came up with a good approach to do this.
I was thinking of creating a List<point> with a DOT as item, but didn't get any further. Could anyone pretty please help me out?
I added comments to make it easier for the reader to understand without causing any braindamage. Could you pretty please help me?

If so, see below for my code.
And thank you in advance!

Form1.cs:

public partial class Form1 : Form
    {
        private GridDrawing drawing;
        //private Point point1 = new Point(); //First point
        //private Point point2 = new Point(); //Second point
        ////True if point1 must be updated
        ////False if point2 must be updated
        //private bool firstPoint = true;
        private int sizeOfDot;
        private int rows;
        private int columns;
        public Form1()
        {
            InitializeComponent();
            sizeOfDot = 10;     //The size of the dot
            rows = 6;           //The amount of rows for the matrix
            columns = 8;        //The amount of columns for the matrix
            Paint += new PaintEventHandler(Form_Paint);             //Handle the Paint event
            SizeChanged += new EventHandler(Form1_SizeChanged);     //Handle the SizeChanged event to force redraw the form
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);     //to avoid flickering
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);    //to avoid flickering
        }
        private void Form_Paint(object sender, PaintEventArgs e)
        {
            e.Graphics.FillRectangle(Brushes.White, ClientRectangle);   //Fill the form in white
            drawing = new GridDrawing(this, rows, columns);             //Control, Rows, Columns
            foreach (var piece in drawing.Pieces)                           //Draws all the dots
            {
                e.Graphics.FillEllipse(Brushes.Black, (piece.Dot.X - sizeOfDot / 2),
                    (piece.Dot.Y - sizeOfDot / 2), sizeOfDot, sizeOfDot);   //Draws the dot
            }
        }
        private void startToolStripMenuItem_Click(object sender, EventArgs e)
        {
        }
        private void Form1_MouseDown(object sender, MouseEventArgs e)
        {
            //if (firstPoint)             //Update point1 or point2
            //{
            //    point1 = e.Location;
            //}
            //else
            //{
            //    point2 = e.Location;
            //}
            //firstPoint = !firstPoint;   //Change the bool value
            //Invalidate();               //ask to redraw
        }
        private void Form1_SizeChanged(object sender, EventArgs e)
        {
            Invalidate();
        }
    }

GridDrawing.cs:

public class GridDrawing
{
    private int columns;
    private int rows;
    private int sizeOfDot;
    private List<GridPiece> pieces;
    //// private Point position;
    //private Point point1; //point1 to start drawing line from
    //private Point point2; //point2 to end drawing line from
    /// <summary>
    /// Constructs a grid
    /// </summary>
    /// <param name="ctrl"></param>
    /// <param name="rows"></param>
    /// <param name="columns"></param>
    /// <param name="sizeOfDot"></param>
    public GridDrawing(Control ctrl, int rows, int columns)
    {
        this.rows = rows;               // The amount of rows in the matrix.
        this.columns = columns;         // The amount of columns in the matrix.
        this.pieces = new List<GridPiece>();                // Initializes the List GridPieces
        float xOffset = (float)ctrl.ClientRectangle.Width / (columns + 1);  // Floating Point offset for X
        float yOffset = (float)ctrl.ClientRectangle.Height / (rows + 1);    // Floating Point offset for Y
        //Generate the dots
        for (int i = 0; i < rows; i++)          //Matrix with 6 rows
        {
            for (int j = 0; j < columns; j++)   //Matrix with 8 columns
            {
                PointF dot = new PointF((j + 1) * xOffset, (i + 1) * yOffset);  // Center of the dot
                GridPiece p = new GridPiece(dot);  // Creates a piece
                pieces.Add(p);                     // Puts the piece that has to be drawn in the List<GridPiece>pieces
            }
        }
    }
    public List<GridPiece> Pieces   //Property List<GridPiece>pieces
    {
        get { return this.pieces; }
    }
}

GridPiece.cs:

public class GridPiece
{
    private PointF dot;
    /// <summary>
    /// Constructor of GriedPiece
    /// </summary>
    /// <param name="bmpPic"></param>
    /// <param name="position"></param>
    public GridPiece(PointF dot)
    {
        this.dot = dot;
    }
    public PointF Dot
    {
        get { return dot; }
    }
}

PS
Sorry if the comments aren't shown properly on one line.
This is how it looks like Example. The little dot on the right is the image thats been drawn as a grid.
Altho I'm not sure why the dots on the grid are bigger then the original file...

Edit:
The code has now been edited to what I have currently.