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