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