demos/life/life.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        life.cpp
   3 // Purpose:     The game of Life, created by J. H. Conway
   4 // Author:      Guillermo Rodriguez Garcia, <guille@iies.es>
   5 // Modified by:
   6 // Created:     Jan/2000
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000, Guillermo Rodriguez Garcia
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ==========================================================================
  13 // headers, declarations, constants
  14 // ==========================================================================
  15
  16 #ifdef __GNUG__
  17     #pragma implementation "life.h"
  18 #endif
  19
  20 // For compilers that support precompilation, includes "wx/wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/wx.h"
  29 #endif
  30
  31 #include "wx/statline.h"
  32
  33 #include "life.h"
  34 #include "game.h"
  35 #include "dialogs.h"
  36
  37 // --------------------------------------------------------------------------
  38 // resources
  39 // --------------------------------------------------------------------------
  40
  41 #if defined(__WXGTK__) || defined(__WXMOTIF__)
  42     // application icon
  43     #include "mondrian.xpm"
  44
  45     // bitmap buttons for the toolbar
  46     #include "bitmaps/reset.xpm"
  47     #include "bitmaps/play.xpm"
  48     #include "bitmaps/stop.xpm"
  49     #include "bitmaps/zoomin.xpm"
  50     #include "bitmaps/zoomout.xpm"
  51
  52     // navigator
  53     #include "bitmaps/north.xpm"
  54     #include "bitmaps/south.xpm"
  55     #include "bitmaps/east.xpm"
  56     #include "bitmaps/west.xpm"
  57     #include "bitmaps/center.xpm"
  58 #endif
  59
  60 // --------------------------------------------------------------------------
  61 // constants
  62 // --------------------------------------------------------------------------
  63
  64 // IDs for the controls and the menu commands
  65 enum
  66 {
  67     // timer
  68     ID_TIMER = 1001,
  69
  70     // menu items and toolbar buttons
  71     ID_RESET,
  72     ID_SAMPLES,
  73     ID_ABOUT,
  74     ID_EXIT,
  75     ID_START,
  76     ID_STEP,
  77     ID_STOP,
  78     ID_ZOOMIN,
  79     ID_ZOOMOUT,
  80     ID_TOPSPEED,
  81
  82     // speed selection slider
  83     ID_SLIDER,
  84
  85     // navigation
  86     ID_SHOWNAV,
  87     ID_ORIGIN,
  88     ID_CENTER,
  89     ID_NORTH,
  90     ID_SOUTH,
  91     ID_EAST,
  92     ID_WEST,
  93 };
  94
  95 // --------------------------------------------------------------------------
  96 // event tables and other macros for wxWindows
  97 // --------------------------------------------------------------------------
  98
  99 // Event tables
 100 BEGIN_EVENT_TABLE(LifeFrame, wxFrame)
 101     EVT_MENU            (ID_SAMPLES,  LifeFrame::OnSamples)
 102     EVT_MENU            (ID_RESET,    LifeFrame::OnMenu)
 103     EVT_MENU            (ID_ABOUT,    LifeFrame::OnMenu)
 104     EVT_MENU            (ID_EXIT,     LifeFrame::OnMenu)
 105     EVT_MENU            (ID_START,    LifeFrame::OnMenu)
 106     EVT_MENU            (ID_STEP,     LifeFrame::OnMenu)
 107     EVT_MENU            (ID_STOP,     LifeFrame::OnMenu)
 108     EVT_MENU            (ID_TOPSPEED, LifeFrame::OnMenu)
 109     EVT_MENU            (ID_SHOWNAV,  LifeFrame::OnMenu)
 110     EVT_MENU            (ID_ORIGIN,   LifeFrame::OnNavigate)
 111     EVT_BUTTON          (ID_CENTER,   LifeFrame::OnNavigate)
 112     EVT_BUTTON          (ID_NORTH,    LifeFrame::OnNavigate)
 113     EVT_BUTTON          (ID_SOUTH,    LifeFrame::OnNavigate)
 114     EVT_BUTTON          (ID_EAST,     LifeFrame::OnNavigate)
 115     EVT_BUTTON          (ID_WEST,     LifeFrame::OnNavigate)
 116     EVT_MENU            (ID_ZOOMIN,   LifeFrame::OnZoom)
 117     EVT_MENU            (ID_ZOOMOUT,  LifeFrame::OnZoom)
 118     EVT_COMMAND_SCROLL  (ID_SLIDER,   LifeFrame::OnSlider)
 119     EVT_TIMER           (ID_TIMER,    LifeFrame::OnTimer)
 120     EVT_CLOSE           (             LifeFrame::OnClose)
 121 END_EVENT_TABLE()
 122
 123 BEGIN_EVENT_TABLE(LifeNavigator, wxMiniFrame)
 124     EVT_CLOSE           (             LifeNavigator::OnClose)
 125 END_EVENT_TABLE()
 126
 127 BEGIN_EVENT_TABLE(LifeCanvas, wxWindow)
 128     EVT_PAINT           (             LifeCanvas::OnPaint)
 129     EVT_SCROLLWIN       (             LifeCanvas::OnScroll)
 130     EVT_SIZE            (             LifeCanvas::OnSize)
 131     EVT_MOUSE_EVENTS    (             LifeCanvas::OnMouse)
 132     EVT_ERASE_BACKGROUND(             LifeCanvas::OnEraseBackground)
 133 END_EVENT_TABLE()
 134
 135
 136 // Create a new application object
 137 IMPLEMENT_APP(LifeApp)
 138
 139
 140 // ==========================================================================
 141 // implementation
 142 // ==========================================================================
 143
 144 // some shortcuts
 145 #define ADD_TOOL(id, bmp, tooltip, help)     \
 146     toolBar->AddTool(id, bmp, wxNullBitmap, FALSE, -1, -1, (wxObject *)0, tooltip, help)
 147
 148
 149 // --------------------------------------------------------------------------
 150 // LifeApp
 151 // --------------------------------------------------------------------------
 152
 153 // 'Main program' equivalent: the program execution "starts" here
 154 bool LifeApp::OnInit()
 155 {
 156     // create the main application window
 157     LifeFrame *frame = new LifeFrame();
 158
 159     // show it and tell the application that it's our main window
 160     frame->Show(TRUE);
 161     SetTopWindow(frame);
 162
 163     // enter the main message loop and run the app
 164     return TRUE;
 165 }
 166
 167 // --------------------------------------------------------------------------
 168 // LifeFrame
 169 // --------------------------------------------------------------------------
 170
 171 // frame constructor
 172 LifeFrame::LifeFrame() : wxFrame((wxFrame *)0, -1, _("Life!"), wxPoint(200, 200))
 173 {
 174     // frame icon
 175     SetIcon(wxICON(mondrian));
 176
 177     // menu bar
 178     wxMenu *menuFile = new wxMenu("", wxMENU_TEAROFF);
 179     wxMenu *menuView = new wxMenu("", wxMENU_TEAROFF);
 180     wxMenu *menuGame = new wxMenu("", wxMENU_TEAROFF);
 181
 182     menuFile->Append(ID_RESET, _("Reset"), _("Start a new game"));
 183     menuFile->Append(ID_SAMPLES, _("Sample game..."), _("Select a sample configuration"));
 184     menuFile->AppendSeparator();
 185     menuFile->Append(ID_ABOUT, _("&About...\tCtrl-A"), _("Show about dialog"));
 186     menuFile->AppendSeparator();
 187     menuFile->Append(ID_EXIT, _("E&xit\tAlt-X"), _("Quit this program"));
 188
 189     menuView->Append(ID_SHOWNAV, _("Navigation toolbox"), _("Show or hide toolbox"), TRUE);
 190     menuView->Check (ID_SHOWNAV, TRUE);
 191     menuView->AppendSeparator();
 192     menuView->Append(ID_ORIGIN, _("Absolute origin"), _("Go to (0, 0)"));
 193     menuView->Append(ID_CENTER, _("Center of mass"), _("Find center of mass"));
 194     menuView->Append(ID_NORTH, _("North"), _("Find northernmost cell"));
 195     menuView->Append(ID_SOUTH, _("South"), _("Find southernmost cell"));
 196     menuView->Append(ID_EAST, _("East"), _("Find easternmost cell"));
 197     menuView->Append(ID_WEST, _("West"), _("Find westernmost cell"));
 198     menuView->AppendSeparator();
 199     menuView->Append(ID_ZOOMIN, _("Zoom &in\tCtrl-I"));
 200     menuView->Append(ID_ZOOMOUT, _("Zoom &out\tCtrl-O"));
 201
 202     menuGame->Append(ID_START, _("&Start\tCtrl-S"), _("Start"));
 203     menuGame->Append(ID_STEP, _("&Next\tCtrl-N"), _("Single step"));
 204     menuGame->Append(ID_STOP, _("S&top\tCtrl-T"), _("Stop"));
 205     menuGame->Enable(ID_STOP, FALSE);
 206     menuGame->AppendSeparator();
 207     menuGame->Append(ID_TOPSPEED, _("Top speed!"), _("Go as fast as possible"));
 208
 209     wxMenuBar *menuBar = new wxMenuBar();
 210     menuBar->Append(menuFile, _("&File"));
 211     menuBar->Append(menuView, _("&View"));
 212     menuBar->Append(menuGame, _("&Game"));
 213     SetMenuBar(menuBar);
 214
 215     // tool bar
 216     wxBitmap tbBitmaps[5];
 217
 218     tbBitmaps[0] = wxBITMAP(reset);
 219     tbBitmaps[1] = wxBITMAP(play);
 220     tbBitmaps[2] = wxBITMAP(stop);
 221     tbBitmaps[3] = wxBITMAP(zoomin);
 222     tbBitmaps[4] = wxBITMAP(zoomout);
 223
 224     wxToolBar *toolBar = CreateToolBar();
 225     toolBar->SetMargins(5, 5);
 226     toolBar->SetToolBitmapSize(wxSize(16, 16));
 227     ADD_TOOL(ID_RESET, tbBitmaps[0], _("Reset"), _("Start a new game"));
 228     ADD_TOOL(ID_START, tbBitmaps[1], _("Start"), _("Start"));
 229     ADD_TOOL(ID_STOP, tbBitmaps[2], _("Stop"), _("Stop"));
 230     toolBar->AddSeparator();
 231     ADD_TOOL(ID_ZOOMIN, tbBitmaps[3], _("Zoom in"), _("Zoom in"));
 232     ADD_TOOL(ID_ZOOMOUT, tbBitmaps[4], _("Zoom out"), _("Zoom out"));
 233     toolBar->Realize();
 234     toolBar->EnableTool(ID_STOP, FALSE);    // must be after Realize() !
 235
 236     // status bar
 237     CreateStatusBar(2);
 238     SetStatusText(_("Welcome to Life!"));
 239
 240     // game and timer
 241     m_life     = new Life();
 242     m_timer    = new wxTimer(this, ID_TIMER);
 243     m_running  = FALSE;
 244     m_topspeed = FALSE;
 245     m_interval = 500;
 246     m_tics     = 0;
 247
 248     // We use two different panels to reduce flicker in wxGTK, because
 249     // some widgets (like wxStaticText) don't have their own X11 window,
 250     // and thus updating the text would result in a refresh of the canvas
 251     // if they belong to the same parent.
 252
 253     wxPanel *panel1 = new wxPanel(this, -1);
 254     wxPanel *panel2 = new wxPanel(this, -1);
 255
 256     // canvas
 257     m_canvas = new LifeCanvas(panel1, m_life);
 258
 259     // info panel
 260     m_text = new wxStaticText(panel2, -1,
 261         wxEmptyString,
 262         wxDefaultPosition,
 263         wxDefaultSize,
 264         wxALIGN_CENTER | wxST_NO_AUTORESIZE);
 265
 266     wxSlider *slider = new wxSlider(panel2, ID_SLIDER,
 267         5, 1, 10,
 268         wxDefaultPosition,
 269         wxSize(200, -1),
 270         wxSL_HORIZONTAL | wxSL_AUTOTICKS);
 271
 272     UpdateInfoText();
 273
 274     // component layout
 275     wxBoxSizer *sizer1 = new wxBoxSizer(wxVERTICAL);
 276     wxBoxSizer *sizer2 = new wxBoxSizer(wxVERTICAL);
 277     wxBoxSizer *sizer3 = new wxBoxSizer(wxVERTICAL);
 278
 279     sizer1->Add( new wxStaticLine(panel1, -1), 0, wxGROW );
 280     sizer1->Add( m_canvas, 1, wxGROW | wxALL, 2 );
 281     sizer1->Add( new wxStaticLine(panel1, -1), 0, wxGROW );
 282     panel1->SetSizer( sizer1 );
 283     panel1->SetAutoLayout( TRUE );
 284     sizer1->Fit( panel1 );
 285
 286     sizer2->Add( m_text, 0, wxGROW | wxTOP, 4 );
 287     sizer2->Add( slider, 0, wxCENTRE | wxALL, 4 );
 288     panel2->SetSizer( sizer2 );
 289     panel2->SetAutoLayout( TRUE );
 290     sizer2->Fit( panel2 );
 291
 292     sizer3->Add( panel1, 1, wxGROW );
 293     sizer3->Add( panel2, 0, wxGROW );
 294     SetSizer( sizer3 );
 295     SetAutoLayout( TRUE );
 296     sizer3->Fit( this );
 297
 298     // set minimum frame size
 299     sizer3->SetSizeHints( this );
 300
 301     // navigator frame
 302     m_navigator = new LifeNavigator(this);
 303 }
 304
 305 LifeFrame::~LifeFrame()
 306 {
 307     delete m_timer;
 308 }
 309
 310 void LifeFrame::UpdateInfoText()
 311 {
 312     wxString msg;
 313
 314     msg.Printf(_(" Generation: %u (T: %u ms),  Population: %u "),
 315                m_tics,
 316                m_topspeed? 0 : m_interval,
 317                m_life->GetNumCells());
 318     m_text->SetLabel(msg);
 319 }
 320
 321 // Enable or disable tools and menu entries according to the current
 322 // state. See also wxEVT_UPDATE_UI events for a slightly different
 323 // way to do this.
 324 void LifeFrame::UpdateUI()
 325 {
 326     // start / stop
 327     GetToolBar()->EnableTool(ID_START, !m_running);
 328     GetToolBar()->EnableTool(ID_STOP,  m_running);
 329     GetMenuBar()->GetMenu(2)->Enable(ID_START, !m_running);
 330     GetMenuBar()->GetMenu(2)->Enable(ID_STEP,  !m_running);
 331     GetMenuBar()->GetMenu(2)->Enable(ID_STOP,  m_running);
 332
 333     // zooming
 334     int cellsize = m_canvas->GetCellSize();
 335     GetToolBar()->EnableTool(ID_ZOOMIN,  cellsize < 32);
 336     GetToolBar()->EnableTool(ID_ZOOMOUT, cellsize > 1);
 337     GetMenuBar()->GetMenu(1)->Enable(ID_ZOOMIN,  cellsize < 32);
 338     GetMenuBar()->GetMenu(1)->Enable(ID_ZOOMOUT, cellsize > 1);
 339 }
 340
 341 // event handlers
 342 void LifeFrame::OnMenu(wxCommandEvent& event)
 343 {
 344     switch (event.GetId())
 345     {
 346         case ID_START   : OnStart(); break;
 347         case ID_STEP    : OnStep(); break;
 348         case ID_STOP    : OnStop(); break;
 349         case ID_SHOWNAV :
 350         {
 351             bool checked = GetMenuBar()->GetMenu(1)->IsChecked(ID_SHOWNAV);
 352             m_navigator->Show(checked);
 353             break;
 354         }
 355         case ID_TOPSPEED:
 356         {
 357             m_running = TRUE;
 358             m_topspeed = TRUE;
 359             UpdateUI();
 360             while (m_running && m_topspeed)
 361             {
 362                 OnStep();
 363                 wxYield();
 364             }
 365             break;
 366         }
 367         case ID_RESET:
 368         {
 369             // stop if it was running
 370             OnStop();
 371             m_life->Clear();
 372             m_canvas->Recenter(0, 0);
 373             m_tics = 0;
 374             UpdateInfoText();
 375             break;
 376         }
 377         case ID_ABOUT:
 378         {
 379             LifeAboutDialog dialog(this);
 380             dialog.ShowModal();
 381             break;
 382         }
 383         case ID_EXIT :
 384         {
 385             // TRUE is to force the frame to close
 386             Close(TRUE);
 387             break;
 388         }
 389     }
 390 }
 391
 392 void LifeFrame::OnClose(wxCloseEvent& WXUNUSED(event))
 393 {
 394     // Stop if it was running; this is absolutely needed because
 395     // the frame won't be actually destroyed until there are no
 396     // more pending events, and this in turn won't ever happen
 397     // if the timer is running faster than the window can redraw.
 398     OnStop();
 399     Destroy();
 400 }
 401
 402 void LifeFrame::OnSamples(wxCommandEvent& WXUNUSED(event))
 403 {
 404     // stop if it was running
 405     OnStop();
 406
 407     // dialog box
 408     LifeSamplesDialog dialog(this);
 409
 410     if (dialog.ShowModal() == wxID_OK)
 411     {
 412         const LifeShape shape = dialog.GetShape();
 413
 414         // put the shape
 415         m_life->Clear();
 416         m_life->SetShape(shape);
 417
 418         // recenter canvas
 419         m_canvas->Recenter(0, 0);
 420         m_tics = 0;
 421         UpdateInfoText();
 422     }
 423 }
 424
 425 void LifeFrame::OnZoom(wxCommandEvent& event)
 426 {
 427     int cellsize = m_canvas->GetCellSize();
 428
 429     if ((event.GetId() == ID_ZOOMIN) && cellsize < 32)
 430     {
 431         m_canvas->SetCellSize(cellsize * 2);
 432         UpdateUI();
 433     }
 434     else if ((event.GetId() == ID_ZOOMOUT) && cellsize > 1)
 435     {
 436         m_canvas->SetCellSize(cellsize / 2);
 437         UpdateUI();
 438     }
 439 }
 440
 441 void LifeFrame::OnNavigate(wxCommandEvent& event)
 442 {
 443     Cell c;
 444
 445     switch (event.GetId())
 446     {
 447         case ID_NORTH:  c = m_life->FindNorth(); break;
 448         case ID_SOUTH:  c = m_life->FindSouth(); break;
 449         case ID_WEST:   c = m_life->FindWest(); break;
 450         case ID_EAST:   c = m_life->FindEast(); break;
 451         case ID_CENTER: c = m_life->FindCenter(); break;
 452         case ID_ORIGIN: c.i = c.j = 0; break;
 453     }
 454
 455     m_canvas->Recenter(c.i, c.j);
 456 }
 457
 458 void LifeFrame::OnSlider(wxScrollEvent& event)
 459 {
 460     m_interval = event.GetPosition() * 100;
 461
 462     if (m_running)
 463     {
 464         OnStop();
 465         OnStart();
 466     }
 467
 468     UpdateInfoText();
 469 }
 470
 471 void LifeFrame::OnTimer(wxTimerEvent& WXUNUSED(event))
 472 {
 473     OnStep();
 474 }
 475
 476 void LifeFrame::OnStart()
 477 {
 478     if (!m_running)
 479     {
 480         m_timer->Start(m_interval);
 481         m_running = TRUE;
 482         UpdateUI();
 483     }
 484 }
 485
 486 void LifeFrame::OnStop()
 487 {
 488     if (m_running)
 489     {
 490         m_timer->Stop();
 491         m_running = FALSE;
 492         m_topspeed = FALSE;
 493         UpdateUI();
 494     }
 495 }
 496
 497 void LifeFrame::OnStep()
 498 {
 499     if (m_life->NextTic())
 500         m_tics++;
 501     else
 502         OnStop();
 503
 504     m_canvas->DrawChanged();
 505     UpdateInfoText();
 506 }
 507
 508
 509 // --------------------------------------------------------------------------
 510 // LifeNavigator miniframe
 511 // --------------------------------------------------------------------------
 512
 513 LifeNavigator::LifeNavigator(wxWindow *parent)
 514              : wxMiniFrame(parent, -1,
 515                            _("Navigation"),
 516                            wxDefaultPosition,
 517                            wxDefaultSize,
 518                            wxCAPTION | wxSIMPLE_BORDER)
 519 {
 520     wxPanel    *panel  = new wxPanel(this, -1);
 521     wxBoxSizer *sizer1 = new wxBoxSizer(wxVERTICAL);
 522     wxBoxSizer *sizer2 = new wxBoxSizer(wxHORIZONTAL);
 523
 524     // create bitmaps and masks for the buttons
 525     wxBitmap
 526         bmpn = wxBITMAP(north),
 527         bmpw = wxBITMAP(west),
 528         bmpc = wxBITMAP(center),
 529         bmpe = wxBITMAP(east),
 530         bmps = wxBITMAP(south);
 531
 532 #ifdef __WXMSW__
 533     bmpn.SetMask(new wxMask(bmpn, *wxLIGHT_GREY));
 534     bmpw.SetMask(new wxMask(bmpw, *wxLIGHT_GREY));
 535     bmpc.SetMask(new wxMask(bmpc, *wxLIGHT_GREY));
 536     bmpe.SetMask(new wxMask(bmpe, *wxLIGHT_GREY));
 537     bmps.SetMask(new wxMask(bmps, *wxLIGHT_GREY));
 538 #endif
 539
 540     // create the buttons and attach tooltips to them
 541     wxBitmapButton
 542         *bn = new wxBitmapButton(panel, ID_NORTH,  bmpn),
 543         *bw = new wxBitmapButton(panel, ID_WEST ,  bmpw),
 544         *bc = new wxBitmapButton(panel, ID_CENTER, bmpc),
 545         *be = new wxBitmapButton(panel, ID_EAST ,  bmpe),
 546         *bs = new wxBitmapButton(panel, ID_SOUTH,  bmps);
 547
 548 #if wxUSE_TOOLTIPS
 549     bn->SetToolTip(_("Find northernmost cell"));
 550     bw->SetToolTip(_("Find westernmost cell"));
 551     bc->SetToolTip(_("Find center of mass"));
 552     be->SetToolTip(_("Find easternmost cell"));
 553     bs->SetToolTip(_("Find southernmost cell"));
 554 #endif
 555
 556     // add buttons to sizers
 557     sizer2->Add( bw, 0, wxCENTRE | wxWEST,  4 );
 558     sizer2->Add( bc, 0, wxCENTRE);
 559     sizer2->Add( be, 0, wxCENTRE | wxEAST,  4 );
 560     sizer1->Add( bn, 0, wxCENTRE | wxNORTH, 4 );
 561     sizer1->Add( sizer2 );
 562     sizer1->Add( bs, 0, wxCENTRE | wxSOUTH, 4 );
 563
 564     // set the miniframe size
 565     panel->SetSizer(sizer1);
 566     panel->SetAutoLayout(TRUE);
 567     sizer1->Fit(this);
 568     sizer1->SetSizeHints(this);
 569
 570     // move it to a sensible position
 571     wxRect parentRect = parent->GetRect();
 572     wxSize childSize  = GetSize();
 573     int x = parentRect.GetX() +
 574             parentRect.GetWidth();
 575     int y = parentRect.GetY() +
 576             (parentRect.GetHeight() - childSize.GetHeight()) / 4;
 577     Move(x, y);
 578
 579     // done
 580     Show(TRUE);
 581 }
 582
 583 void LifeNavigator::OnClose(wxCloseEvent& event)
 584 {
 585     if (event.CanVeto())
 586         event.Veto();
 587     else
 588         Destroy();
 589 }
 590
 591
 592 // --------------------------------------------------------------------------
 593 // LifeCanvas
 594 // --------------------------------------------------------------------------
 595
 596 // canvas constructor
 597 LifeCanvas::LifeCanvas(wxWindow *parent, Life *life, bool interactive)
 598           : wxWindow(parent, -1, wxPoint(0, 0), wxSize(100, 100),
 599             wxSUNKEN_BORDER)
 600 {
 601     m_life        = life;
 602     m_interactive = interactive;
 603     m_cellsize    = 8;
 604     m_status      = MOUSE_NOACTION;
 605     m_viewportX   = 0;
 606     m_viewportY   = 0;
 607     m_viewportH   = 0;
 608     m_viewportW   = 0;
 609
 610     if (m_interactive)
 611         SetCursor(*wxCROSS_CURSOR);
 612
 613     // reduce flicker if wxEVT_ERASE_BACKGROUND is not available
 614     SetBackgroundColour(*wxWHITE);
 615 }
 616
 617 LifeCanvas::~LifeCanvas()
 618 {
 619     delete m_life;
 620 }
 621
 622 // recenter at the given position
 623 void LifeCanvas::Recenter(wxInt32 i, wxInt32 j)
 624 {
 625     m_viewportX = i - m_viewportW / 2;
 626     m_viewportY = j - m_viewportH / 2;
 627
 628     // redraw everything
 629     Refresh(FALSE);
 630 }
 631
 632 // set the cell size and refresh display
 633 void LifeCanvas::SetCellSize(int cellsize)
 634 {
 635     m_cellsize = cellsize;
 636
 637     // find current center
 638     wxInt32 cx = m_viewportX + m_viewportW / 2;
 639     wxInt32 cy = m_viewportY + m_viewportH / 2;
 640
 641     // get current canvas size and adjust viewport accordingly
 642     int w, h;
 643     GetClientSize(&w, &h);
 644     m_viewportW = (w + m_cellsize - 1) / m_cellsize;
 645     m_viewportH = (h + m_cellsize - 1) / m_cellsize;
 646
 647     // recenter
 648     m_viewportX = cx - m_viewportW / 2;
 649     m_viewportY = cy - m_viewportH / 2;
 650
 651     // adjust scrollbars
 652     if (m_interactive)
 653     {
 654         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 655         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 656         m_thumbX = m_viewportW;
 657         m_thumbY = m_viewportH;
 658     }
 659
 660     Refresh(FALSE);
 661 }
 662
 663 // draw a cell
 664 void LifeCanvas::DrawCell(wxInt32 i, wxInt32 j, bool alive)
 665 {
 666     wxClientDC dc(this);
 667
 668     dc.SetPen(alive? *wxBLACK_PEN : *wxWHITE_PEN);
 669     dc.SetBrush(alive? *wxBLACK_BRUSH : *wxWHITE_BRUSH);
 670
 671     dc.BeginDrawing();
 672     DrawCell(i, j, dc);
 673     dc.EndDrawing();
 674 }
 675
 676 void LifeCanvas::DrawCell(wxInt32 i, wxInt32 j, wxDC &dc)
 677 {
 678     wxCoord x = CellToX(i);
 679     wxCoord y = CellToY(j);
 680
 681     // if cellsize is 1 or 2, there will be no grid
 682     switch (m_cellsize)
 683     {
 684         case 1:
 685             dc.DrawPoint(x, y);
 686             break;
 687         case 2:
 688             dc.DrawRectangle(x, y, 2, 2);
 689             break;
 690         default:
 691             dc.DrawRectangle(x + 1, y + 1, m_cellsize - 1, m_cellsize - 1);
 692     }
 693 }
 694
 695 // draw all changed cells
 696 void LifeCanvas::DrawChanged()
 697 {
 698     wxClientDC dc(this);
 699
 700     size_t ncells;
 701     Cell *cells;
 702     bool done = FALSE;
 703
 704     m_life->BeginFind(m_viewportX,
 705                       m_viewportY,
 706                       m_viewportX + m_viewportW,
 707                       m_viewportY + m_viewportH,
 708                       TRUE);
 709
 710     dc.BeginDrawing();
 711
 712     if (m_cellsize == 1)
 713     {
 714         dc.SetPen(*wxBLACK_PEN);
 715     }
 716     else
 717     {
 718         dc.SetPen(*wxTRANSPARENT_PEN);
 719         dc.SetBrush(*wxBLACK_BRUSH);
 720     }
 721     dc.SetLogicalFunction(wxINVERT);
 722
 723     while (!done)
 724     {
 725         done = m_life->FindMore(&cells, &ncells);
 726
 727         for (size_t m = 0; m < ncells; m++)
 728             DrawCell(cells[m].i, cells[m].j, dc);
 729     }
 730     dc.EndDrawing();
 731 }
 732
 733 // event handlers
 734 void LifeCanvas::OnPaint(wxPaintEvent& event)
 735 {
 736     wxPaintDC dc(this);
 737     wxRect  rect = GetUpdateRegion().GetBox();
 738     wxCoord x, y, w, h;
 739     wxInt32 i0, j0, i1, j1;
 740
 741     // find damaged area
 742     x = rect.GetX();
 743     y = rect.GetY();
 744     w = rect.GetWidth();
 745     h = rect.GetHeight();
 746
 747     i0 = XToCell(x);
 748     j0 = YToCell(y);
 749     i1 = XToCell(x + w - 1);
 750     j1 = YToCell(y + h - 1);
 751
 752     size_t ncells;
 753     Cell *cells;
 754     bool done = FALSE;
 755
 756     m_life->BeginFind(i0, j0, i1, j1, FALSE);
 757     done = m_life->FindMore(&cells, &ncells);
 758
 759     // erase all damaged cells and draw the grid
 760     dc.BeginDrawing();
 761     dc.SetBrush(*wxWHITE_BRUSH);
 762
 763     if (m_cellsize <= 2)
 764     {
 765        // no grid
 766        dc.SetPen(*wxWHITE_PEN);
 767        dc.DrawRectangle(x, y, w, h);
 768     }
 769     else
 770     {
 771         x = CellToX(i0);
 772         y = CellToY(j0);
 773         w = CellToX(i1 + 1) - x + 1;
 774         h = CellToY(j1 + 1) - y + 1;
 775
 776         dc.SetPen(*wxLIGHT_GREY_PEN);
 777         for (wxInt32 yy = y; yy <= (y + h - m_cellsize); yy += m_cellsize)
 778             dc.DrawRectangle(x, yy, w, m_cellsize + 1);
 779         for (wxInt32 xx = x; xx <= (x + w - m_cellsize); xx += m_cellsize)
 780             dc.DrawLine(xx, y, xx, y + h);
 781     }
 782
 783     // draw all alive cells
 784     dc.SetPen(*wxBLACK_PEN);
 785     dc.SetBrush(*wxBLACK_BRUSH);
 786
 787     while (!done)
 788     {
 789         for (size_t m = 0; m < ncells; m++)
 790             DrawCell(cells[m].i, cells[m].j, dc);
 791
 792         done = m_life->FindMore(&cells, &ncells);
 793     }
 794
 795     // last set
 796     for (size_t m = 0; m < ncells; m++)
 797         DrawCell(cells[m].i, cells[m].j, dc);
 798
 799     dc.EndDrawing();
 800 }
 801
 802 void LifeCanvas::OnMouse(wxMouseEvent& event)
 803 {
 804     if (!m_interactive)
 805         return;
 806
 807     // which cell are we pointing at?
 808     wxInt32 i = XToCell( event.GetX() );
 809     wxInt32 j = YToCell( event.GetY() );
 810
 811     // set statusbar text
 812     wxString msg;
 813     msg.Printf(_("Cell: (%d, %d)"), i, j);
 814     ((LifeFrame *) wxGetApp().GetTopWindow())->SetStatusText(msg, 1);
 815
 816     // button pressed?
 817     if (!event.LeftIsDown())
 818     {
 819         m_status = MOUSE_NOACTION;
 820         return;
 821     }
 822
 823     // button just pressed?
 824     if (m_status == MOUSE_NOACTION)
 825     {
 826         // yes, update status and toggle this cell
 827         m_status = (m_life->IsAlive(i, j)? MOUSE_ERASING : MOUSE_DRAWING);
 828
 829         m_mi = i;
 830         m_mj = j;
 831         m_life->SetCell(i, j, m_status == MOUSE_DRAWING);
 832         DrawCell(i, j, m_status == MOUSE_DRAWING);
 833     }
 834     else if ((m_mi != i) || (m_mj != j))
 835     {
 836         bool alive = (m_status == MOUSE_DRAWING);
 837
 838         // prepare DC and pen + brush to optimize drawing
 839         wxClientDC dc(this);
 840         dc.SetPen(alive? *wxBLACK_PEN : *wxWHITE_PEN);
 841         dc.SetBrush(alive? *wxBLACK_BRUSH : *wxWHITE_BRUSH);
 842         dc.BeginDrawing();
 843
 844         // draw a line of cells using Bresenham's algorithm
 845         wxInt32 d, ii, jj, di, ai, si, dj, aj, sj;
 846         di = i - m_mi;
 847         ai = abs(di) << 1;
 848         si = (di < 0)? -1 : 1;
 849         dj = j - m_mj;
 850         aj = abs(dj) << 1;
 851         sj = (dj < 0)? -1 : 1;
 852
 853         ii = m_mi;
 854         jj = m_mj;
 855
 856         if (ai > aj)
 857         {
 858             // iterate over i
 859             d = aj - (ai >> 1);
 860
 861             while (ii != i)
 862             {
 863                 m_life->SetCell(ii, jj, alive);
 864                 DrawCell(ii, jj, dc);
 865                 if (d >= 0)
 866                 {
 867                     jj += sj;
 868                     d  -= ai;
 869                 }
 870                 ii += si;
 871                 d  += aj;
 872             }
 873         }
 874         else
 875         {
 876             // iterate over j
 877             d = ai - (aj >> 1);
 878
 879             while (jj != j)
 880             {
 881                 m_life->SetCell(ii, jj, alive);
 882                 DrawCell(ii, jj, dc);
 883                 if (d >= 0)
 884                 {
 885                     ii += si;
 886                     d  -= aj;
 887                 }
 888                 jj += sj;
 889                 d  += ai;
 890             }
 891         }
 892
 893         // last cell
 894         m_life->SetCell(ii, jj, alive);
 895         DrawCell(ii, jj, dc);
 896         m_mi = ii;
 897         m_mj = jj;
 898
 899         dc.EndDrawing();
 900     }
 901
 902     ((LifeFrame *) wxGetApp().GetTopWindow())->UpdateInfoText();
 903 }
 904
 905 void LifeCanvas::OnSize(wxSizeEvent& event)
 906 {
 907     // find center
 908     wxInt32 cx = m_viewportX + m_viewportW / 2;
 909     wxInt32 cy = m_viewportY + m_viewportH / 2;
 910
 911     // get new size
 912     wxCoord w = event.GetSize().GetX();
 913     wxCoord h = event.GetSize().GetY();
 914     m_viewportW = (w + m_cellsize - 1) / m_cellsize;
 915     m_viewportH = (h + m_cellsize - 1) / m_cellsize;
 916
 917     // recenter
 918     m_viewportX = cx - m_viewportW / 2;
 919     m_viewportY = cy - m_viewportH / 2;
 920
 921     // scrollbars
 922     if (m_interactive)
 923     {
 924         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 925         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 926         m_thumbX = m_viewportW;
 927         m_thumbY = m_viewportH;
 928     }
 929
 930     // allow default processing
 931     event.Skip();
 932 }
 933
 934 void LifeCanvas::OnScroll(wxScrollWinEvent& event)
 935 {
 936     WXTYPE type = event.GetEventType();
 937     int pos     = event.GetPosition();
 938     int orient  = event.GetOrientation();
 939
 940     // calculate scroll increment
 941     int scrollinc = 0;
 942     switch (type)
 943     {
 944         case wxEVT_SCROLLWIN_TOP:
 945         {
 946             if (orient == wxHORIZONTAL)
 947                 scrollinc = -m_viewportW;
 948             else
 949                 scrollinc = -m_viewportH;
 950             break;
 951         }
 952         case wxEVT_SCROLLWIN_BOTTOM:
 953         {
 954             if (orient == wxHORIZONTAL)
 955                 scrollinc = m_viewportW;
 956             else
 957                 scrollinc = m_viewportH;
 958             break;
 959         }
 960         case wxEVT_SCROLLWIN_LINEUP:   scrollinc = -1; break;
 961         case wxEVT_SCROLLWIN_LINEDOWN: scrollinc = +1; break;
 962         case wxEVT_SCROLLWIN_PAGEUP:   scrollinc = -10; break;
 963         case wxEVT_SCROLLWIN_PAGEDOWN: scrollinc = +10; break;
 964         case wxEVT_SCROLLWIN_THUMBTRACK:
 965         {
 966             if (orient == wxHORIZONTAL)
 967             {
 968                 scrollinc = pos - m_thumbX;
 969                 m_thumbX = pos;
 970             }
 971             else
 972             {
 973                 scrollinc = pos - m_thumbY;
 974                 m_thumbY = pos;
 975             }
 976             break;
 977         }
 978         case wxEVT_SCROLLWIN_THUMBRELEASE:
 979         {
 980             m_thumbX = m_viewportW;
 981             m_thumbY = m_viewportH;
 982         }
 983     }
 984
 985 #if defined(__WXGTK__) || defined(__WXMOTIF__) // what about Motif?
 986     // wxGTK updates the thumb automatically (wxMSW doesn't); reset it back
 987     if (type != wxEVT_SCROLLWIN_THUMBTRACK)
 988     {
 989         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 990         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 991     }
 992 #endif
 993
 994     if (scrollinc == 0) return;
 995
 996     // scroll the window and adjust the viewport
 997     if (orient == wxHORIZONTAL)
 998     {
 999         m_viewportX += scrollinc;
1000         ScrollWindow( -m_cellsize * scrollinc, 0, (const wxRect *) NULL);
1001     }
1002     else
1003     {
1004         m_viewportY += scrollinc;
1005         ScrollWindow( 0, -m_cellsize * scrollinc, (const wxRect *) NULL);
1006     }
1007 }
1008
1009 void LifeCanvas::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
1010 {
1011     // do nothing. I just don't want the background to be erased, you know.
1012 }
1013
1014