class DrawingPanel : public wxPanel { public: DrawingPanel(wxFrame* parent, std::vector>& gameBoard); ~DrawingPanel();

void CalculateCellSize(); void OnPaint(wxPaintEvent& event); wxPoint _point; void OnMouseUp(wxMouseEvent& event); void SetGridSize(int size); private: int gridSize = 15; int cellWidth; int cellHeight;

std::vector>& _gameBoard; };

DrawingPanel::DrawingPanel(wxFrame* parent, std::vector>& gameBoard) : wxPanel(parent, wxID_ANY, wxPoint(0, 0), wxSize(200, 200)), _gameBoard(gameBoard) { this->SetBackgroundStyle(wxBG_STYLE_PAINT);

this->Bind(wxEVT_PAINT, &DrawingPanel::OnPaint, this); _point.x = 100; _point.y = 100;

this->Bind(wxEVT_LEFT_UP, &DrawingPanel::OnMouseUp, this); CalculateCellSize(); } DrawingPanel::~DrawingPanel() { }

void DrawingPanel::CalculateCellSize() { wxSize panelSize = GetParent()->GetClientSize(); cellWidth = panelSize.GetWidth() / gridSize; cellHeight = panelSize.GetHeight() / gridSize; }

void DrawingPanel::OnPaint(wxPaintEvent& event) { wxAutoBufferedPaintDC dc(this); dc.Clear();

wxGraphicsContext* context = wxGraphicsContext::Create(dc); if (!context) { return; }

context->SetPen(*wxBLACK); context->SetBrush(*wxWHITE);

for (int row = 0; row < gridSize; row++) { for (int col = 0; col < gridSize; col++) { int x = col * cellWidth; int y = row * cellHeight; context->DrawRectangle(x, y, cellWidth, cellHeight); } }

}

void DrawingPanel::OnMouseUp(wxMouseEvent& event) { _point.x = event.GetX(); _point.y = event.GetY();

Refresh(); }

void DrawingPanel::SetGridSize(int size) { gridSize = size; CalculateCellSize(); // Recalculate cell size based on the new grid size }

class MainWindow : public wxFrame { private:

DrawingPanel* _drawingPanel = nullptr; wxBoxSizer* _sizer = nullptr;

std::vector> _gameBoard; int gridSize = 15; public: MainWindow(); ~MainWindow();

void OnSizeChanged(wxSizeEvent& event); void InitializeGameBoard();

wxDECLARE_EVENT_TABLE(); }; MainWindow::MainWindow() :wxFrame(nullptr, wxID_ANY, "Game of Life", wxPoint(0, 0), wxSize(200, 200)) { _drawingPanel = new DrawingPanel(this, _gameBoard);

_sizer = new wxBoxSizer(wxVERTICAL);

_sizer->Add(_drawingPanel, 1, wxEXPAND | wxALL);

Bind(wxEVT_SIZE, &MainWindow::OnSizeChanged, this);

SetSizer(_sizer); InitializeGameBoard(); } MainWindow::~MainWindow() {

} void MainWindow::OnSizeChanged(wxSizeEvent& event) { _drawingPanel->SetSize(event.GetSize()); _drawingPanel->Refresh(); }

void MainWindow::InitializeGameBoard() { _gameBoard.resize(gridSize); // Resize the game board vector to the grid size

for (int i = 0; i < gridSize; i++) { _gameBoard[i].resize(gridSize); // Resize each sub-vector to the grid size }

_drawingPanel->SetGridSize(gridSize); // Pass the grid size to the drawing panel }

Objective in C++

Give the drawing panel access to the game board and provide mouse interaction with the drawing panel.

Instructions

1. Now that there is a place to store whether a cell is dead or alive, the drawing panel needs access to the game board.
2. Add a std::vector>& to the drawing panel header file that will be used to store a reference to the game board stored in the main window.
3. It will be necessary to use constructor initialization in order to set the reference value. The game board should be passed along as an argument in the drawing panel constructor.

Mouse Interactions

1. it's time to add the ability to interact with the drawing panel with the mouse.
2. Start by creating new event handler method in the drawing panel header file that takes in a wxMouseEvent& variable as a parameter. This event handler will be called after a mouse button is clicked.
3. In the constructor for the drawing panel, call bind on the wxEVT_LEFT_UP event using something similar to this this->Bind(wxEVT_LEFT_UP, &DrawingPanel::OnMouseUp, this);
4. When the mouse event handler method is implemented, the wxMouseEvent arguments gives two important pieces of information. It has a method for GetX() and GetY(), which allows us to know the coordinates of where the click happened. With a little math, it can be figured out which box was clicked.
   1. Inside the handler method, call the GetX() and GetY() methods on the event argument and store them into separate variables.
   2. Next the cell width and the cell height is needed. This can be calculated in the same way that it is within the on paint handler using GetSize() and the grid size.
   3. The row and column that was clicked can be calculated by dividing the x coordinate of the click by the cell width and the y coordinate of the click by the cell height.
   4. Store each of those in a variable so that they can be used to access the game board and change the value of that cell.
5. Using the square bracket notation to access indices of the vector, use the values that were just calculated to find the correct item in the game board. If the value is true, it should become false. If it is false, it should become true.
   1. Since the game board is a vector of vectors, it will have two sets of square brackets. ex: variable[x][y].
6. Finally, call Refresh(); so that the onPaint event will fire.