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     bn->SetToolTip(_("Find northernmost cell"));
 549     bw->SetToolTip(_("Find westernmost cell"));
 550     bc->SetToolTip(_("Find center of mass"));
 551     be->SetToolTip(_("Find easternmost cell"));
 552     bs->SetToolTip(_("Find southernmost cell"));
 553
 554     // add buttons to sizers
 555     sizer2->Add( bw, 0, wxCENTRE | wxWEST,  4 );
 556     sizer2->Add( bc, 0, wxCENTRE);
 557     sizer2->Add( be, 0, wxCENTRE | wxEAST,  4 );
 558     sizer1->Add( bn, 0, wxCENTRE | wxNORTH, 4 );
 559     sizer1->Add( sizer2 );
 560     sizer1->Add( bs, 0, wxCENTRE | wxSOUTH, 4 );
 561
 562     // set the miniframe size
 563     panel->SetSizer(sizer1);
 564     panel->SetAutoLayout(TRUE);
 565     sizer1->Fit(this);
 566     sizer1->SetSizeHints(this);
 567
 568     // move it to a sensible position
 569     wxRect parentRect = parent->GetRect();
 570     wxSize childSize  = GetSize();
 571     int x = parentRect.GetX() +
 572             parentRect.GetWidth();
 573     int y = parentRect.GetY() +
 574             (parentRect.GetHeight() - childSize.GetHeight()) / 4;
 575     Move(x, y);
 576
 577     // done
 578     Show(TRUE);
 579 }
 580
 581 void LifeNavigator::OnClose(wxCloseEvent& event)
 582 {
 583     if (event.CanVeto())
 584         event.Veto();
 585     else
 586         Destroy();
 587 }
 588
 589
 590 // --------------------------------------------------------------------------
 591 // LifeCanvas
 592 // --------------------------------------------------------------------------
 593
 594 // canvas constructor
 595 LifeCanvas::LifeCanvas(wxWindow *parent, Life *life, bool interactive)
 596           : wxWindow(parent, -1, wxPoint(0, 0), wxSize(100, 100),
 597             wxSUNKEN_BORDER)
 598 {
 599     m_life        = life;
 600     m_interactive = interactive;
 601     m_cellsize    = 8;
 602     m_status      = MOUSE_NOACTION;
 603     m_viewportX   = 0;
 604     m_viewportY   = 0;
 605     m_viewportH   = 0;
 606     m_viewportW   = 0;
 607
 608     if (m_interactive)
 609         SetCursor(*wxCROSS_CURSOR);
 610
 611     // reduce flicker if wxEVT_ERASE_BACKGROUND is not available
 612     SetBackgroundColour(*wxWHITE);
 613 }
 614
 615 LifeCanvas::~LifeCanvas()
 616 {
 617     delete m_life;
 618 }
 619
 620 // recenter at the given position
 621 void LifeCanvas::Recenter(wxInt32 i, wxInt32 j)
 622 {
 623     m_viewportX = i - m_viewportW / 2;
 624     m_viewportY = j - m_viewportH / 2;
 625
 626     // redraw everything
 627     Refresh(FALSE);
 628 }
 629
 630 // set the cell size and refresh display
 631 void LifeCanvas::SetCellSize(int cellsize)
 632 {
 633     m_cellsize = cellsize;
 634
 635     // find current center
 636     wxInt32 cx = m_viewportX + m_viewportW / 2;
 637     wxInt32 cy = m_viewportY + m_viewportH / 2;
 638
 639     // get current canvas size and adjust viewport accordingly
 640     int w, h;
 641     GetClientSize(&w, &h);
 642     m_viewportW = (w + m_cellsize - 1) / m_cellsize;
 643     m_viewportH = (h + m_cellsize - 1) / m_cellsize;
 644
 645     // recenter
 646     m_viewportX = cx - m_viewportW / 2;
 647     m_viewportY = cy - m_viewportH / 2;
 648
 649     // adjust scrollbars
 650     if (m_interactive)
 651     {
 652         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 653         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 654         m_thumbX = m_viewportW;
 655         m_thumbY = m_viewportH;
 656     }
 657
 658     Refresh(FALSE);
 659 }
 660
 661 // draw a cell
 662 void LifeCanvas::DrawCell(wxInt32 i, wxInt32 j, bool alive)
 663 {
 664     wxClientDC dc(this);
 665
 666     dc.SetPen(alive? *wxBLACK_PEN : *wxWHITE_PEN);
 667     dc.SetBrush(alive? *wxBLACK_BRUSH : *wxWHITE_BRUSH);
 668
 669     dc.BeginDrawing();
 670     DrawCell(i, j, dc);
 671     dc.EndDrawing();
 672 }
 673
 674 void LifeCanvas::DrawCell(wxInt32 i, wxInt32 j, wxDC &dc)
 675 {
 676     wxCoord x = CellToX(i);
 677     wxCoord y = CellToY(j);
 678
 679     // if cellsize is 1 or 2, there will be no grid
 680     switch (m_cellsize)
 681     {
 682         case 1:
 683             dc.DrawPoint(x, y);
 684             break;
 685         case 2:
 686             dc.DrawRectangle(x, y, 2, 2);
 687             break;
 688         default:
 689             dc.DrawRectangle(x + 1, y + 1, m_cellsize - 1, m_cellsize - 1);
 690     }
 691 }
 692
 693 // draw all changed cells
 694 void LifeCanvas::DrawChanged()
 695 {
 696     wxClientDC dc(this);
 697
 698     size_t ncells;
 699     Cell *cells;
 700     bool done = FALSE;
 701
 702     m_life->BeginFind(m_viewportX,
 703                       m_viewportY,
 704                       m_viewportX + m_viewportW,
 705                       m_viewportY + m_viewportH,
 706                       TRUE);
 707
 708     dc.BeginDrawing();
 709
 710     if (m_cellsize == 1)
 711     {
 712         dc.SetPen(*wxBLACK_PEN);
 713     }
 714     else
 715     {
 716         dc.SetPen(*wxTRANSPARENT_PEN);
 717         dc.SetBrush(*wxBLACK_BRUSH);
 718     }
 719     dc.SetLogicalFunction(wxINVERT);
 720
 721     while (!done)
 722     {
 723         done = m_life->FindMore(&cells, &ncells);
 724
 725         for (size_t m = 0; m < ncells; m++)
 726             DrawCell(cells[m].i, cells[m].j, dc);
 727     }
 728     dc.EndDrawing();
 729 }
 730
 731 // event handlers
 732 void LifeCanvas::OnPaint(wxPaintEvent& event)
 733 {
 734     wxPaintDC dc(this);
 735     wxRect  rect = GetUpdateRegion().GetBox();
 736     wxCoord x, y, w, h;
 737     wxInt32 i0, j0, i1, j1;
 738
 739     // find damaged area
 740     x = rect.GetX();
 741     y = rect.GetY();
 742     w = rect.GetWidth();
 743     h = rect.GetHeight();
 744
 745     i0 = XToCell(x);
 746     j0 = YToCell(y);
 747     i1 = XToCell(x + w - 1);
 748     j1 = YToCell(y + h - 1);
 749
 750     size_t ncells;
 751     Cell *cells;
 752     bool done = FALSE;
 753
 754     m_life->BeginFind(i0, j0, i1, j1, FALSE);
 755     done = m_life->FindMore(&cells, &ncells);
 756
 757     // erase all damaged cells and draw the grid
 758     dc.BeginDrawing();
 759     dc.SetBrush(*wxWHITE_BRUSH);
 760
 761     if (m_cellsize <= 2)
 762     {
 763        // no grid
 764        dc.SetPen(*wxWHITE_PEN);
 765        dc.DrawRectangle(x, y, w, h);
 766     }
 767     else
 768     {
 769         x = CellToX(i0);
 770         y = CellToY(j0);
 771         w = CellToX(i1 + 1) - x + 1;
 772         h = CellToY(j1 + 1) - y + 1;
 773
 774         dc.SetPen(*wxLIGHT_GREY_PEN);
 775         for (wxInt32 yy = y; yy <= (y + h - m_cellsize); yy += m_cellsize)
 776             dc.DrawRectangle(x, yy, w, m_cellsize + 1);
 777         for (wxInt32 xx = x; xx <= (x + w - m_cellsize); xx += m_cellsize)
 778             dc.DrawLine(xx, y, xx, y + h);
 779     }
 780
 781     // draw all alive cells
 782     dc.SetPen(*wxBLACK_PEN);
 783     dc.SetBrush(*wxBLACK_BRUSH);
 784
 785     while (!done)
 786     {
 787         for (size_t m = 0; m < ncells; m++)
 788             DrawCell(cells[m].i, cells[m].j, dc);
 789
 790         done = m_life->FindMore(&cells, &ncells);
 791     }
 792
 793     // last set
 794     for (size_t m = 0; m < ncells; m++)
 795         DrawCell(cells[m].i, cells[m].j, dc);
 796
 797     dc.EndDrawing();
 798 }
 799
 800 void LifeCanvas::OnMouse(wxMouseEvent& event)
 801 {
 802     if (!m_interactive)
 803         return;
 804
 805     // which cell are we pointing at?
 806     wxInt32 i = XToCell( event.GetX() );
 807     wxInt32 j = YToCell( event.GetY() );
 808
 809     // set statusbar text
 810     wxString msg;
 811     msg.Printf(_("Cell: (%d, %d)"), i, j);
 812     ((LifeFrame *) wxGetApp().GetTopWindow())->SetStatusText(msg, 1);
 813
 814     // button pressed?
 815     if (!event.LeftIsDown())
 816     {
 817         m_status = MOUSE_NOACTION;
 818         return;
 819     }
 820
 821     // button just pressed?
 822     if (m_status == MOUSE_NOACTION)
 823     {
 824         // yes, update status and toggle this cell
 825         m_status = (m_life->IsAlive(i, j)? MOUSE_ERASING : MOUSE_DRAWING);
 826
 827         m_mi = i;
 828         m_mj = j;
 829         m_life->SetCell(i, j, m_status == MOUSE_DRAWING);
 830         DrawCell(i, j, m_status == MOUSE_DRAWING);
 831     }
 832     else if ((m_mi != i) || (m_mj != j))
 833     {
 834         bool alive = (m_status == MOUSE_DRAWING);
 835
 836         // prepare DC and pen + brush to optimize drawing
 837         wxClientDC dc(this);
 838         dc.SetPen(alive? *wxBLACK_PEN : *wxWHITE_PEN);
 839         dc.SetBrush(alive? *wxBLACK_BRUSH : *wxWHITE_BRUSH);
 840         dc.BeginDrawing();
 841
 842         // draw a line of cells using Bresenham's algorithm
 843         wxInt32 d, ii, jj, di, ai, si, dj, aj, sj;
 844         di = i - m_mi;
 845         ai = abs(di) << 1;
 846         si = (di < 0)? -1 : 1;
 847         dj = j - m_mj;
 848         aj = abs(dj) << 1;
 849         sj = (dj < 0)? -1 : 1;
 850
 851         ii = m_mi;
 852         jj = m_mj;
 853
 854         if (ai > aj)
 855         {
 856             // iterate over i
 857             d = aj - (ai >> 1);
 858
 859             while (ii != i)
 860             {
 861                 m_life->SetCell(ii, jj, alive);
 862                 DrawCell(ii, jj, dc);
 863                 if (d >= 0)
 864                 {
 865                     jj += sj;
 866                     d  -= ai;
 867                 }
 868                 ii += si;
 869                 d  += aj;
 870             }
 871         }
 872         else
 873         {
 874             // iterate over j
 875             d = ai - (aj >> 1);
 876
 877             while (jj != j)
 878             {
 879                 m_life->SetCell(ii, jj, alive);
 880                 DrawCell(ii, jj, dc);
 881                 if (d >= 0)
 882                 {
 883                     ii += si;
 884                     d  -= aj;
 885                 }
 886                 jj += sj;
 887                 d  += ai;
 888             }
 889         }
 890
 891         // last cell
 892         m_life->SetCell(ii, jj, alive);
 893         DrawCell(ii, jj, dc);
 894         m_mi = ii;
 895         m_mj = jj;
 896
 897         dc.EndDrawing();
 898     }
 899
 900     ((LifeFrame *) wxGetApp().GetTopWindow())->UpdateInfoText();
 901 }
 902
 903 void LifeCanvas::OnSize(wxSizeEvent& event)
 904 {
 905     // find center
 906     wxInt32 cx = m_viewportX + m_viewportW / 2;
 907     wxInt32 cy = m_viewportY + m_viewportH / 2;
 908
 909     // get new size
 910     wxCoord w = event.GetSize().GetX();
 911     wxCoord h = event.GetSize().GetY();
 912     m_viewportW = (w + m_cellsize - 1) / m_cellsize;
 913     m_viewportH = (h + m_cellsize - 1) / m_cellsize;
 914
 915     // recenter
 916     m_viewportX = cx - m_viewportW / 2;
 917     m_viewportY = cy - m_viewportH / 2;
 918
 919     // scrollbars
 920     if (m_interactive)
 921     {
 922         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 923         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 924         m_thumbX = m_viewportW;
 925         m_thumbY = m_viewportH;
 926     }
 927
 928     // allow default processing
 929     event.Skip();
 930 }
 931
 932 void LifeCanvas::OnScroll(wxScrollWinEvent& event)
 933 {
 934     WXTYPE type = event.GetEventType();
 935     int pos     = event.GetPosition();
 936     int orient  = event.GetOrientation();
 937
 938     // calculate scroll increment
 939     int scrollinc = 0;
 940     switch (type)
 941     {
 942         case wxEVT_SCROLLWIN_TOP:
 943         {
 944             if (orient == wxHORIZONTAL)
 945                 scrollinc = -m_viewportW;
 946             else
 947                 scrollinc = -m_viewportH;
 948             break;
 949         }
 950         case wxEVT_SCROLLWIN_BOTTOM:
 951         {
 952             if (orient == wxHORIZONTAL)
 953                 scrollinc = m_viewportW;
 954             else
 955                 scrollinc = m_viewportH;
 956             break;
 957         }
 958         case wxEVT_SCROLLWIN_LINEUP:   scrollinc = -1; break;
 959         case wxEVT_SCROLLWIN_LINEDOWN: scrollinc = +1; break;
 960         case wxEVT_SCROLLWIN_PAGEUP:   scrollinc = -10; break;
 961         case wxEVT_SCROLLWIN_PAGEDOWN: scrollinc = +10; break;
 962         case wxEVT_SCROLLWIN_THUMBTRACK:
 963         {
 964             if (orient == wxHORIZONTAL)
 965             {
 966                 scrollinc = pos - m_thumbX;
 967                 m_thumbX = pos;
 968             }
 969             else
 970             {
 971                 scrollinc = pos - m_thumbY;
 972                 m_thumbY = pos;
 973             }
 974             break;
 975         }
 976         case wxEVT_SCROLLWIN_THUMBRELEASE:
 977         {
 978             m_thumbX = m_viewportW;
 979             m_thumbY = m_viewportH;
 980         }
 981     }
 982
 983 #ifdef __WXGTK__ // what about Motif?
 984     // wxGTK updates the thumb automatically (wxMSW doesn't); reset it back
 985     if (type != wxEVT_SCROLLWIN_THUMBTRACK)
 986     {
 987         SetScrollbar(wxHORIZONTAL, m_viewportW, m_viewportW, 3 * m_viewportW);
 988         SetScrollbar(wxVERTICAL,   m_viewportH, m_viewportH, 3 * m_viewportH);
 989     }
 990 #endif
 991
 992     if (scrollinc == 0) return;
 993
 994     // scroll the window and adjust the viewport
 995     if (orient == wxHORIZONTAL)
 996     {
 997         m_viewportX += scrollinc;
 998         ScrollWindow( -m_cellsize * scrollinc, 0, (const wxRect *) NULL);
 999     }
1000     else
1001     {
1002         m_viewportY += scrollinc;
1003         ScrollWindow( 0, -m_cellsize * scrollinc, (const wxRect *) NULL);
1004     }
1005 }
1006
1007 void LifeCanvas::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
1008 {
1009     // do nothing. I just don't want the background to be erased, you know.
1010 }
1011
1012