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
 289     panel2->SetSizer( sizer2 );
 290     panel2->SetAutoLayout( TRUE );
 291     sizer2->Fit( panel2 );
 292
 293     sizer3->Add( panel1, 1, wxGROW );
 294     sizer3->Add( panel2, 0, wxGROW );
 295     SetSizer( sizer3 );
 296     SetAutoLayout( TRUE );
 297     sizer3->Fit( this );
 298
 299     // set minimum frame size
 300     sizer3->SetSizeHints( this );
 301
 302     // navigator frame
 303     m_navigator = new LifeNavigator(this);
 304 }
 305
 306 LifeFrame::~LifeFrame()
 307 {
 308     delete m_timer;
 309 }
 310
 311 void LifeFrame::UpdateInfoText()
 312 {
 313     wxString msg;
 314
 315     msg.Printf(_(" Generation: %u (T: %u ms),  Population: %u "),
 316                m_tics,
 317                m_topspeed? 0 : m_interval,
 318                m_life->GetNumCells());
 319     m_text->SetLabel(msg);
 320 }
 321
 322 // Enable or disable tools and menu entries according to the current
 323 // state. See also wxEVT_UPDATE_UI events for a slightly different
 324 // way to do this.
 325 void LifeFrame::UpdateUI()
 326 {
 327     // start / stop
 328     GetToolBar()->EnableTool(ID_START, !m_running);
 329     GetToolBar()->EnableTool(ID_STOP,  m_running);
 330     GetMenuBar()->GetMenu(2)->Enable(ID_START, !m_running);
 331     GetMenuBar()->GetMenu(2)->Enable(ID_STEP,  !m_running);
 332     GetMenuBar()->GetMenu(2)->Enable(ID_STOP,  m_running);
 333
 334     // zooming
 335     int cellsize = m_canvas->GetCellSize();
 336     GetToolBar()->EnableTool(ID_ZOOMIN,  cellsize < 32);
 337     GetToolBar()->EnableTool(ID_ZOOMOUT, cellsize > 1);
 338     GetMenuBar()->GetMenu(1)->Enable(ID_ZOOMIN,  cellsize < 32);
 339     GetMenuBar()->GetMenu(1)->Enable(ID_ZOOMOUT, cellsize > 1);
 340 }
 341
 342 // event handlers
 343 void LifeFrame::OnMenu(wxCommandEvent& event)
 344 {
 345     switch (event.GetId())
 346     {
 347         case ID_START   : OnStart(); break;
 348         case ID_STEP    : OnStep(); break;
 349         case ID_STOP    : OnStop(); break;
 350         case ID_SHOWNAV :
 351         {
 352             bool checked = GetMenuBar()->GetMenu(1)->IsChecked(ID_SHOWNAV);
 353             m_navigator->Show(checked);
 354             break;
 355         }
 356         case ID_TOPSPEED:
 357         {
 358             m_running = TRUE;
 359             m_topspeed = TRUE;
 360             UpdateUI();
 361             while (m_running && m_topspeed)
 362             {
 363                 OnStep();
 364                 wxYield();
 365             }
 366             break;
 367         }
 368         case ID_RESET:
 369         {
 370             // stop if it was running
 371             OnStop();
 372             m_life->Clear();
 373             m_canvas->Recenter(0, 0);
 374             m_tics = 0;
 375             UpdateInfoText();
 376             break;
 377         }
 378         case ID_ABOUT:
 379         {
 380             LifeAboutDialog dialog(this);
 381             dialog.ShowModal();
 382             break;
 383         }
 384         case ID_EXIT :
 385         {
 386             // TRUE is to force the frame to close
 387             Close(TRUE);
 388             break;
 389         }
 390     }
 391 }
 392
 393 void LifeFrame::OnClose(wxCloseEvent& WXUNUSED(event))
 394 {
 395     // Stop if it was running; this is absolutely needed because
 396     // the frame won't be actually destroyed until there are no
 397     // more pending events, and this in turn won't ever happen
 398     // if the timer is running faster than the window can redraw.
 399     OnStop();
 400     Destroy();
 401 }
 402
 403 void LifeFrame::OnSamples(wxCommandEvent& WXUNUSED(event))
 404 {
 405     // stop if it was running
 406     OnStop();
 407
 408     // dialog box
 409     LifeSamplesDialog dialog(this);
 410
 411     if (dialog.ShowModal() == wxID_OK)
 412     {
 413         const LifeShape shape = dialog.GetShape();
 414
 415         // put the shape
 416         m_life->Clear();
 417         m_life->SetShape(shape);
 418
 419         // recenter canvas
 420         m_canvas->Recenter(0, 0);
 421         m_tics = 0;
 422         UpdateInfoText();
 423     }
 424 }
 425
 426 void LifeFrame::OnZoom(wxCommandEvent& event)
 427 {
 428     int cellsize = m_canvas->GetCellSize();
 429
 430     if ((event.GetId() == ID_ZOOMIN) && cellsize < 32)
 431     {
 432         m_canvas->SetCellSize(cellsize * 2);
 433         UpdateUI();
 434     }
 435     else if ((event.GetId() == ID_ZOOMOUT) && cellsize > 1)
 436     {
 437         m_canvas->SetCellSize(cellsize / 2);
 438         UpdateUI();
 439     }
 440 }
 441
 442 void LifeFrame::OnNavigate(wxCommandEvent& event)
 443 {
 444     Cell c;
 445
 446     switch (event.GetId())
 447     {
 448         case ID_NORTH:  c = m_life->FindNorth(); break;
 449         case ID_SOUTH:  c = m_life->FindSouth(); break;
 450         case ID_WEST:   c = m_life->FindWest(); break;
 451         case ID_EAST:   c = m_life->FindEast(); break;
 452         case ID_CENTER: c = m_life->FindCenter(); break;
 453         case ID_ORIGIN: c.i = c.j = 0; break;
 454     }
 455
 456     m_canvas->Recenter(c.i, c.j);
 457 }
 458
 459 void LifeFrame::OnSlider(wxScrollEvent& event)
 460 {
 461     m_interval = event.GetPosition() * 100;
 462
 463     if (m_running)
 464     {
 465         OnStop();
 466         OnStart();
 467     }
 468
 469     UpdateInfoText();
 470 }
 471
 472 void LifeFrame::OnTimer(wxTimerEvent& WXUNUSED(event))
 473 {
 474     OnStep();
 475 }
 476
 477 void LifeFrame::OnStart()
 478 {
 479     if (!m_running)
 480     {
 481         m_timer->Start(m_interval);
 482         m_running = TRUE;
 483         UpdateUI();
 484     }
 485 }
 486
 487 void LifeFrame::OnStop()
 488 {
 489     if (m_running)
 490     {
 491         m_timer->Stop();
 492         m_running = FALSE;
 493         m_topspeed = FALSE;
 494         UpdateUI();
 495     }
 496 }
 497
 498 void LifeFrame::OnStep()
 499 {
 500     if (m_life->NextTic())
 501         m_tics++;
 502     else
 503         OnStop();
 504
 505     m_canvas->DrawChanged();
 506     UpdateInfoText();
 507 }
 508
 509
 510 // --------------------------------------------------------------------------
 511 // LifeNavigator miniframe
 512 // --------------------------------------------------------------------------
 513
 514 LifeNavigator::LifeNavigator(wxWindow *parent)
 515              : wxMiniFrame(parent, -1,
 516                            _("Navigation"),
 517                            wxDefaultPosition,
 518                            wxDefaultSize,
 519                            wxCAPTION | wxSIMPLE_BORDER)
 520 {
 521     wxPanel    *panel  = new wxPanel(this, -1);
 522     wxBoxSizer *sizer1 = new wxBoxSizer(wxVERTICAL);
 523     wxBoxSizer *sizer2 = new wxBoxSizer(wxHORIZONTAL);
 524
 525     // create bitmaps and masks for the buttons
 526     wxBitmap
 527         bmpn = wxBITMAP(north),
 528         bmpw = wxBITMAP(west),
 529         bmpc = wxBITMAP(center),
 530         bmpe = wxBITMAP(east),
 531         bmps = wxBITMAP(south);
 532
 533 #ifdef __WXMSW__
 534     bmpn.SetMask(new wxMask(bmpn, *wxLIGHT_GREY));
 535     bmpw.SetMask(new wxMask(bmpw, *wxLIGHT_GREY));
 536     bmpc.SetMask(new wxMask(bmpc, *wxLIGHT_GREY));
 537     bmpe.SetMask(new wxMask(bmpe, *wxLIGHT_GREY));
 538     bmps.SetMask(new wxMask(bmps, *wxLIGHT_GREY));
 539 #endif
 540
 541     // create the buttons and attach tooltips to them
 542     wxBitmapButton
 543         *bn = new wxBitmapButton(panel, ID_NORTH,  bmpn),
 544         *bw = new wxBitmapButton(panel, ID_WEST ,  bmpw),
 545         *bc = new wxBitmapButton(panel, ID_CENTER, bmpc),
 546         *be = new wxBitmapButton(panel, ID_EAST ,  bmpe),
 547         *bs = new wxBitmapButton(panel, ID_SOUTH,  bmps);
 548
 549 #if wxUSE_TOOLTIPS
 550     bn->SetToolTip(_("Find northernmost cell"));
 551     bw->SetToolTip(_("Find westernmost cell"));
 552     bc->SetToolTip(_("Find center of mass"));
 553     be->SetToolTip(_("Find easternmost cell"));
 554     bs->SetToolTip(_("Find southernmost cell"));
 555 #endif
 556
 557     // add buttons to sizers
 558     sizer2->Add( bw, 0, wxCENTRE | wxWEST,  4 );
 559     sizer2->Add( bc, 0, wxCENTRE);
 560     sizer2->Add( be, 0, wxCENTRE | wxEAST,  4 );
 561     sizer1->Add( bn, 0, wxCENTRE | wxNORTH, 4 );
 562     sizer1->Add( sizer2 );
 563     sizer1->Add( bs, 0, wxCENTRE | wxSOUTH, 4 );
 564
 565     // set the miniframe size
 566     panel->SetSizer(sizer1);
 567     panel->SetAutoLayout(TRUE);
 568     sizer1->Fit(this);
 569     sizer1->SetSizeHints(this);
 570
 571     // move it to a sensible position
 572     wxRect parentRect = parent->GetRect();
 573     wxSize childSize  = GetSize();
 574     int x = parentRect.GetX() +
 575             parentRect.GetWidth();
 576     int y = parentRect.GetY() +
 577             (parentRect.GetHeight() - childSize.GetHeight()) / 4;
 578     Move(x, y);
 579
 580     // done
 581     Show(TRUE);
 582 }
 583
 584 void LifeNavigator::OnClose(wxCloseEvent& event)
 585 {
 586     if (event.CanVeto())
 587         event.Veto();
 588     else
 589         Destroy();
 590 }
 591
 592
 593 // --------------------------------------------------------------------------
 594 // LifeCanvas
 595 // --------------------------------------------------------------------------
 596
 597 // canvas constructor
 598 LifeCanvas::LifeCanvas(wxWindow *parent, Life *life, bool interactive)
 599           : wxWindow(parent, -1, wxPoint(0, 0), wxSize(100, 100),
 600             wxSUNKEN_BORDER)
 601 {
 602     m_life        = life;
 603     m_interactive = interactive;
 604     m_cellsize    = 8;
 605     m_status      = MOUSE_NOACTION;
 606     m_viewportX   = 0;
 607     m_viewportY   = 0;
 608     m_viewportH   = 0;
 609     m_viewportW   = 0;
 610
 611     if (m_interactive)
 612         SetCursor(*wxCROSS_CURSOR);
 613
 614     // reduce flicker if wxEVT_ERASE_BACKGROUND is not available
 615     SetBackgroundColour(*wxWHITE);
 616 }
 617
 618 LifeCanvas::~LifeCanvas()
 619 {
 620     delete m_life;
 621 }
 622
 623 // recenter at the given position
 624 void LifeCanvas::Recenter(wxInt32 i, wxInt32 j)
 625 {
 626     m_viewportX = i - m_viewportW / 2;
 627     m_viewportY = j - m_viewportH / 2;
 628
 629     // redraw everything
 630     Refresh(FALSE);
 631 }
 632
 633 // set the cell size and refresh display
 634 void LifeCanvas::SetCellSize(int cellsize)
 635 {
 636     m_cellsize = cellsize;
 637
 638     // find current center
 639     wxInt32 cx = m_viewportX + m_viewportW / 2;
 640     wxInt32 cy = m_viewportY + m_viewportH / 2;
 641
 642     // get current canvas size and adjust viewport accordingly
 643     int w, h;
 644     GetClientSize(&w, &h);
 645     m_viewportW = (w + m_cellsize - 1) / m_cellsize;
 646     m_viewportH = (h + m_cellsize - 1) / m_cellsize;
 647
 648     // recenter
 649     m_viewportX = cx - m_viewportW / 2;
 650     m_viewportY = cy - m_viewportH / 2;
 651
 652     // adjust scrollbars
 653     if (m_interactive)
 654     {
 655         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 656         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 657         m_thumbX = m_viewportW;
 658         m_thumbY = m_viewportH;
 659     }
 660
 661     Refresh(FALSE);
 662 }
 663
 664 // draw a cell
 665 void LifeCanvas::DrawCell(wxInt32 i, wxInt32 j, bool alive)
 666 {
 667     wxClientDC dc(this);
 668
 669     dc.SetPen(alive? *wxBLACK_PEN : *wxWHITE_PEN);
 670     dc.SetBrush(alive? *wxBLACK_BRUSH : *wxWHITE_BRUSH);
 671
 672     dc.BeginDrawing();
 673     DrawCell(i, j, dc);
 674     dc.EndDrawing();
 675 }
 676
 677 void LifeCanvas::DrawCell(wxInt32 i, wxInt32 j, wxDC &dc)
 678 {
 679     wxCoord x = CellToX(i);
 680     wxCoord y = CellToY(j);
 681
 682     // if cellsize is 1 or 2, there will be no grid
 683     switch (m_cellsize)
 684     {
 685         case 1:
 686             dc.DrawPoint(x, y);
 687             break;
 688         case 2:
 689             dc.DrawRectangle(x, y, 2, 2);
 690             break;
 691         default:
 692             dc.DrawRectangle(x + 1, y + 1, m_cellsize - 1, m_cellsize - 1);
 693     }
 694 }
 695
 696 // draw all changed cells
 697 void LifeCanvas::DrawChanged()
 698 {
 699     wxClientDC dc(this);
 700
 701     size_t ncells;
 702     Cell *cells;
 703     bool done = FALSE;
 704
 705     m_life->BeginFind(m_viewportX,
 706                       m_viewportY,
 707                       m_viewportX + m_viewportW,
 708                       m_viewportY + m_viewportH,
 709                       TRUE);
 710
 711     dc.BeginDrawing();
 712
 713     if (m_cellsize == 1)
 714     {
 715         dc.SetPen(*wxBLACK_PEN);
 716     }
 717     else
 718     {
 719         dc.SetPen(*wxTRANSPARENT_PEN);
 720         dc.SetBrush(*wxBLACK_BRUSH);
 721     }
 722     dc.SetLogicalFunction(wxINVERT);
 723
 724     while (!done)
 725     {
 726         done = m_life->FindMore(&cells, &ncells);
 727
 728         for (size_t m = 0; m < ncells; m++)
 729             DrawCell(cells[m].i, cells[m].j, dc);
 730     }
 731     dc.EndDrawing();
 732 }
 733
 734 // event handlers
 735 void LifeCanvas::OnPaint(wxPaintEvent& event)
 736 {
 737     wxPaintDC dc(this);
 738     wxRect  rect = GetUpdateRegion().GetBox();
 739     wxCoord x, y, w, h;
 740     wxInt32 i0, j0, i1, j1;
 741
 742     // find damaged area
 743     x = rect.GetX();
 744     y = rect.GetY();
 745     w = rect.GetWidth();
 746     h = rect.GetHeight();
 747
 748     i0 = XToCell(x);
 749     j0 = YToCell(y);
 750     i1 = XToCell(x + w - 1);
 751     j1 = YToCell(y + h - 1);
 752
 753     size_t ncells;
 754     Cell *cells;
 755     bool done = FALSE;
 756
 757     m_life->BeginFind(i0, j0, i1, j1, FALSE);
 758     done = m_life->FindMore(&cells, &ncells);
 759
 760     // erase all damaged cells and draw the grid
 761     dc.BeginDrawing();
 762     dc.SetBrush(*wxWHITE_BRUSH);
 763
 764     if (m_cellsize <= 2)
 765     {
 766        // no grid
 767        dc.SetPen(*wxWHITE_PEN);
 768        dc.DrawRectangle(x, y, w, h);
 769     }
 770     else
 771     {
 772         x = CellToX(i0);
 773         y = CellToY(j0);
 774         w = CellToX(i1 + 1) - x + 1;
 775         h = CellToY(j1 + 1) - y + 1;
 776
 777         dc.SetPen(*wxLIGHT_GREY_PEN);
 778         for (wxInt32 yy = y; yy <= (y + h - m_cellsize); yy += m_cellsize)
 779             dc.DrawRectangle(x, yy, w, m_cellsize + 1);
 780         for (wxInt32 xx = x; xx <= (x + w - m_cellsize); xx += m_cellsize)
 781             dc.DrawLine(xx, y, xx, y + h);
 782     }
 783
 784     // draw all alive cells
 785     dc.SetPen(*wxBLACK_PEN);
 786     dc.SetBrush(*wxBLACK_BRUSH);
 787
 788     while (!done)
 789     {
 790         for (size_t m = 0; m < ncells; m++)
 791             DrawCell(cells[m].i, cells[m].j, dc);
 792
 793         done = m_life->FindMore(&cells, &ncells);
 794     }
 795
 796     // last set
 797     for (size_t m = 0; m < ncells; m++)
 798         DrawCell(cells[m].i, cells[m].j, dc);
 799
 800     dc.EndDrawing();
 801 }
 802
 803 void LifeCanvas::OnMouse(wxMouseEvent& event)
 804 {
 805     if (!m_interactive)
 806         return;
 807
 808     // which cell are we pointing at?
 809     wxInt32 i = XToCell( event.GetX() );
 810     wxInt32 j = YToCell( event.GetY() );
 811
 812     // set statusbar text
 813     wxString msg;
 814     msg.Printf(_("Cell: (%d, %d)"), i, j);
 815     ((LifeFrame *) wxGetApp().GetTopWindow())->SetStatusText(msg, 1);
 816
 817     // button pressed?
 818     if (!event.LeftIsDown())
 819     {
 820         m_status = MOUSE_NOACTION;
 821         return;
 822     }
 823
 824     // button just pressed?
 825     if (m_status == MOUSE_NOACTION)
 826     {
 827         // yes, update status and toggle this cell
 828         m_status = (m_life->IsAlive(i, j)? MOUSE_ERASING : MOUSE_DRAWING);
 829
 830         m_mi = i;
 831         m_mj = j;
 832         m_life->SetCell(i, j, m_status == MOUSE_DRAWING);
 833         DrawCell(i, j, m_status == MOUSE_DRAWING);
 834     }
 835     else if ((m_mi != i) || (m_mj != j))
 836     {
 837         bool alive = (m_status == MOUSE_DRAWING);
 838
 839         // prepare DC and pen + brush to optimize drawing
 840         wxClientDC dc(this);
 841         dc.SetPen(alive? *wxBLACK_PEN : *wxWHITE_PEN);
 842         dc.SetBrush(alive? *wxBLACK_BRUSH : *wxWHITE_BRUSH);
 843         dc.BeginDrawing();
 844
 845         // draw a line of cells using Bresenham's algorithm
 846         wxInt32 d, ii, jj, di, ai, si, dj, aj, sj;
 847         di = i - m_mi;
 848         ai = abs(di) << 1;
 849         si = (di < 0)? -1 : 1;
 850         dj = j - m_mj;
 851         aj = abs(dj) << 1;
 852         sj = (dj < 0)? -1 : 1;
 853
 854         ii = m_mi;
 855         jj = m_mj;
 856
 857         if (ai > aj)
 858         {
 859             // iterate over i
 860             d = aj - (ai >> 1);
 861
 862             while (ii != i)
 863             {
 864                 m_life->SetCell(ii, jj, alive);
 865                 DrawCell(ii, jj, dc);
 866                 if (d >= 0)
 867                 {
 868                     jj += sj;
 869                     d  -= ai;
 870                 }
 871                 ii += si;
 872                 d  += aj;
 873             }
 874         }
 875         else
 876         {
 877             // iterate over j
 878             d = ai - (aj >> 1);
 879
 880             while (jj != j)
 881             {
 882                 m_life->SetCell(ii, jj, alive);
 883                 DrawCell(ii, jj, dc);
 884                 if (d >= 0)
 885                 {
 886                     ii += si;
 887                     d  -= aj;
 888                 }
 889                 jj += sj;
 890                 d  += ai;
 891             }
 892         }
 893
 894         // last cell
 895         m_life->SetCell(ii, jj, alive);
 896         DrawCell(ii, jj, dc);
 897         m_mi = ii;
 898         m_mj = jj;
 899
 900         dc.EndDrawing();
 901     }
 902
 903     ((LifeFrame *) wxGetApp().GetTopWindow())->UpdateInfoText();
 904 }
 905
 906 void LifeCanvas::OnSize(wxSizeEvent& event)
 907 {
 908     // find center
 909     wxInt32 cx = m_viewportX + m_viewportW / 2;
 910     wxInt32 cy = m_viewportY + m_viewportH / 2;
 911
 912     // get new size
 913     wxCoord w = event.GetSize().GetX();
 914     wxCoord h = event.GetSize().GetY();
 915     m_viewportW = (w + m_cellsize - 1) / m_cellsize;
 916     m_viewportH = (h + m_cellsize - 1) / m_cellsize;
 917
 918     // recenter
 919     m_viewportX = cx - m_viewportW / 2;
 920     m_viewportY = cy - m_viewportH / 2;
 921
 922     // scrollbars
 923     if (m_interactive)
 924     {
 925         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 926         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 927         m_thumbX = m_viewportW;
 928         m_thumbY = m_viewportH;
 929     }
 930
 931     // allow default processing
 932     event.Skip();
 933 }
 934
 935 void LifeCanvas::OnScroll(wxScrollWinEvent& event)
 936 {
 937     WXTYPE type = event.GetEventType();
 938     int pos     = event.GetPosition();
 939     int orient  = event.GetOrientation();
 940
 941     // calculate scroll increment
 942     int scrollinc = 0;
 943     switch (type)
 944     {
 945         case wxEVT_SCROLLWIN_TOP:
 946         {
 947             if (orient == wxHORIZONTAL)
 948                 scrollinc = -m_viewportW;
 949             else
 950                 scrollinc = -m_viewportH;
 951             break;
 952         }
 953         case wxEVT_SCROLLWIN_BOTTOM:
 954         {
 955             if (orient == wxHORIZONTAL)
 956                 scrollinc = m_viewportW;
 957             else
 958                 scrollinc = m_viewportH;
 959             break;
 960         }
 961         case wxEVT_SCROLLWIN_LINEUP:   scrollinc = -1; break;
 962         case wxEVT_SCROLLWIN_LINEDOWN: scrollinc = +1; break;
 963         case wxEVT_SCROLLWIN_PAGEUP:   scrollinc = -10; break;
 964         case wxEVT_SCROLLWIN_PAGEDOWN: scrollinc = +10; break;
 965         case wxEVT_SCROLLWIN_THUMBTRACK:
 966         {
 967             if (orient == wxHORIZONTAL)
 968             {
 969                 scrollinc = pos - m_thumbX;
 970                 m_thumbX = pos;
 971             }
 972             else
 973             {
 974                 scrollinc = pos - m_thumbY;
 975                 m_thumbY = pos;
 976             }
 977             break;
 978         }
 979         case wxEVT_SCROLLWIN_THUMBRELEASE:
 980         {
 981             m_thumbX = m_viewportW;
 982             m_thumbY = m_viewportH;
 983         }
 984     }
 985
 986 #if defined(__WXGTK__) || defined(__WXMOTIF__) // what about Motif?
 987     // wxGTK updates the thumb automatically (wxMSW doesn't); reset it back
 988     if (type != wxEVT_SCROLLWIN_THUMBTRACK)
 989     {
 990         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 991         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 992     }
 993 #endif
 994
 995     if (scrollinc == 0) return;
 996
 997     // scroll the window and adjust the viewport
 998     if (orient == wxHORIZONTAL)
 999     {
1000         m_viewportX += scrollinc;
1001         ScrollWindow( -m_cellsize * scrollinc, 0, (const wxRect *) NULL);
1002     }
1003     else
1004     {
1005         m_viewportY += scrollinc;
1006         ScrollWindow( 0, -m_cellsize * scrollinc, (const wxRect *) NULL);
1007     }
1008 }
1009
1010 void LifeCanvas::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
1011 {
1012     // do nothing. I just don't want the background to be erased, you know.
1013 }
1014
1015