renaming and moving samples around

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@5300 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

demos/bombs/Makefile.in

@@ -0,0 +1,21 @@
+#
+# File:		Makefile.in
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+# Copyright:	(c) 1998 Julian Smart
+#
+# "%W% %G%"
+#
+# Makefile for bombs example (UNIX).
+
+top_srcdir = @top_srcdir@
+top_builddir = ../..
+program_dir = samples/bombs
+
+PROGRAM=bombs
+
+OBJECTS = bombs.o bombs1.o game.o
+
+include ../../src/makeprog.env
+

demos/bombs/bombs.cpp

@@ -0,0 +1,252 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        bombs.cpp
+// Purpose:     Bombs game
+// Author:      P. Foggia 1996
+// Modified by:
+// Created:     1996
+// RCS-ID:      $Id$
+// Copyright:   (c) 1996 P. Foggia
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+#ifndef  WX_PRECOMP
+  #include "wx/wx.h"
+#endif //precompiled headers
+
+#include "bombs.h"
+
+#include <time.h>
+#include <stdlib.h>
+
+#if defined(__WXGTK__) || defined(__WXMOTIF__)
+#include "bombs.xpm"
+#endif
+
+IMPLEMENT_APP(AppClass)
+
+// Called to initialize the program
+bool AppClass::OnInit()
+{
+  srand((unsigned)time(NULL));
+
+  // Initialize all the top-level window members to NULL.
+  BombsFrame = NULL;
+  level=IDM_EASY;
+
+  BombsFrame = 
+    new BombsFrameClass(NULL, "wxBombs", wxPoint(155, 165), wxSize(300, 300), wxMINIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION);
+
+  int xmax=BombsFrame->BombsCanvas->field_width*BombsFrame->BombsCanvas->x_cell*X_UNIT;
+  int ymax=BombsFrame->BombsCanvas->field_height*BombsFrame->BombsCanvas->y_cell*Y_UNIT;
+  BombsFrame->SetClientSize(xmax, ymax);
+
+  return TRUE;
+}
+
+BEGIN_EVENT_TABLE(BombsFrameClass, wxFrame)
+    EVT_MENU(IDM_EASY, BombsFrameClass::OnEasy)
+    EVT_MENU(IDM_MEDIUM, BombsFrameClass::OnMedium)
+    EVT_MENU(IDM_DIFFICULT, BombsFrameClass::OnDifficult)
+    EVT_MENU(IDM_EXIT, BombsFrameClass::OnExit)
+    EVT_MENU(IDM_ABOUT, BombsFrameClass::OnAbout)
+    EVT_MENU(IDM_RESTART, BombsFrameClass::OnRestart)
+    EVT_CLOSE(BombsFrameClass::OnCloseWindow)
+END_EVENT_TABLE()
+
+BombsFrameClass::BombsFrameClass(wxFrame *parent, const wxString& title, const wxPoint& pos, const wxSize& size, long style):
+  wxFrame(parent, -1, title, pos, size, style)
+{
+  // Initialize child subwindow members.
+  BombsCanvas = NULL;
+
+  SetIcon(wxICON(bombs));
+
+  CreateStatusBar();
+  
+  // Create a menu bar for the frame
+  wxMenuBar *menuBar1 = new wxMenuBar;
+  wxMenu *menu1 = new wxMenu;
+  menu1->Append(IDM_EXIT, "E&xit"); // , "Quit the program");
+  menu1->AppendSeparator();
+  menu1->Append(IDM_ABOUT, "&About..."); // , "Infos on wxBombs");
+  menuBar1->Append(menu1, "&File");
+  wxMenu *menu2 = new wxMenu;
+  menu2->Append(IDM_RESTART, "&Restart"); // , "Clear the play field");
+  menu2->AppendSeparator();
+  menu2->Append(IDM_EASY, "&Easy", wxEmptyString, TRUE); // "10x10 play field", TRUE);
+  menu2->Append(IDM_MEDIUM, "&Medium", wxEmptyString, TRUE); // "15x15 play field", TRUE);
+  menu2->Append(IDM_DIFFICULT, "&Difficult", wxEmptyString, TRUE); // "25x20 play field", TRUE);
+  menuBar1->Append(menu2, "&Game");
+  SetMenuBar(menuBar1);
+  menuBar=menuBar1;
+  menuBar->Check(wxGetApp().level, TRUE);
+
+  // Create child subwindows.
+  BombsCanvas = new BombsCanvasClass(this);
+
+  // Ensure the subwindows get resized o.k.
+//  OnSize(width, height);
+
+  // Centre frame on the screen.
+  Centre(wxBOTH);
+
+  // Show the frame.
+  Show(TRUE);
+}
+
+BombsFrameClass::~BombsFrameClass(void)
+{
+}
+
+void BombsFrameClass::OnCloseWindow(wxCloseEvent& event)
+{
+  this->Destroy();
+}
+
+void BombsFrameClass::OnExit(wxCommandEvent& event)
+{
+    this->Destroy();
+}
+
+void BombsFrameClass::OnRestart(wxCommandEvent& event)
+{
+    BombsCanvas->UpdateFieldSize();
+    int xmax=BombsCanvas->field_width*BombsCanvas->x_cell*X_UNIT;
+    int ymax=BombsCanvas->field_height*BombsCanvas->y_cell*Y_UNIT;
+    wxGetApp().BombsFrame->SetClientSize(xmax, ymax);
+}
+
+void BombsFrameClass::OnAbout(wxCommandEvent& event)
+{
+    wxMessageBox("wxBombs (c) 1996 by P. Foggia\n<foggia@amalfi.dis.unina.it>", "About wxBombs");
+}
+
+void BombsFrameClass::OnEasy(wxCommandEvent& event)
+{
+    menuBar->Check(wxGetApp().level, FALSE);
+    wxGetApp().level=IDM_EASY;
+    menuBar->Check(wxGetApp().level, TRUE);
+}
+
+void BombsFrameClass::OnMedium(wxCommandEvent& event)
+{
+    menuBar->Check(wxGetApp().level, FALSE);
+    wxGetApp().level=IDM_MEDIUM;
+    menuBar->Check(wxGetApp().level, TRUE);
+}
+
+void BombsFrameClass::OnDifficult(wxCommandEvent& event)
+{
+    menuBar->Check(wxGetApp().level, FALSE);
+    wxGetApp().level=IDM_DIFFICULT;
+    menuBar->Check(wxGetApp().level, TRUE);
+}
+
+BEGIN_EVENT_TABLE(BombsCanvasClass, wxWindow)
+    EVT_PAINT(BombsCanvasClass::OnPaint)
+    EVT_MOUSE_EVENTS(BombsCanvasClass::OnEvent)
+END_EVENT_TABLE()
+
+BombsCanvasClass::BombsCanvasClass(wxFrame *parent, const wxPoint& pos, const wxSize& size, long style):
+  wxWindow(parent, -1, pos, size, style)
+{ 
+  int sx, sy;
+  wxClientDC dc(this);
+  wxFont font= BOMBS_FONT;
+  dc.SetFont(font);
+
+  long chw, chh;
+  char buf[]="M";
+
+  dc.GetTextExtent(buf, &chw, &chh);
+  dc.SetFont(wxNullFont);
+
+  dc.SetMapMode(wxMM_METRIC);
+
+  int xcm = dc.LogicalToDeviceX(10.0);
+  int ycm = dc.LogicalToDeviceY(10.0);
+    // To have a square cell, there must be :
+    //    sx*ycm == sy*xcm
+  if (chw*ycm < chh*xcm)
+    { sy=chh;
+      sx=chh*xcm/ycm;
+    }
+  else
+    { sx=chw;
+      sy=chw*ycm/xcm;
+    }
+  x_cell = (sx+3+X_UNIT)/X_UNIT;
+  y_cell = (sy+3+Y_UNIT)/Y_UNIT;
+  dc.SetMapMode(wxMM_TEXT);
+  bmp=NULL;
+  UpdateFieldSize();
+}
+
+BombsCanvasClass::~BombsCanvasClass(void)
+{
+  if (bmp)
+    delete bmp;
+}
+
+// Called when canvas needs to be repainted.
+void BombsCanvasClass::OnPaint(wxPaintEvent& event)
+{
+  wxPaintDC dc(this);
+
+  // Insert your drawing code here.
+  if (!bmp)
+    { bmp=new wxBitmap(field_width*x_cell*X_UNIT+1,
+                       field_height*y_cell*Y_UNIT+1);
+      if (bmp)
+        { wxMemoryDC memDC;
+          memDC.SelectObject(* bmp);
+          DrawField(&memDC, 0, 0, field_width-1, field_height-1);
+          memDC.SelectObject(wxNullBitmap);
+        }
+    }
+  if (bmp)
+    { wxMemoryDC memDC;
+      memDC.SelectObject(* bmp);
+      dc.Blit(0, 0, field_width*x_cell*X_UNIT+1,
+                          field_height*y_cell*Y_UNIT+1,
+                    &memDC, 0, 0, wxCOPY);
+      memDC.SelectObject(wxNullBitmap);
+    }
+  else
+    DrawField(& dc, 0, 0, field_width-1, field_height-1);
+}
+
+// Updates the field size depending on wxGetApp().level and
+// redraws the canvas
+void BombsCanvasClass::UpdateFieldSize()
+  { field_width=20;
+    field_height=20;
+
+    switch(wxGetApp().level)
+      { case IDM_EASY:
+          field_width=10;
+          field_height=10;
+          break;
+        case IDM_MEDIUM:
+          field_width=15;
+          field_height=15;
+          break;
+        case IDM_DIFFICULT:
+          field_width=25;
+          field_height=20;
+          break;
+      }
+    wxGetApp().Game.Init(field_width, field_height);
+
+    if (bmp)
+      delete bmp;
+    bmp=NULL;
+    
+    wxWindow::Refresh();
+  }

demos/bombs/bombs.def

@@ -0,0 +1,14 @@
+; bombs
+; Generated by wxBuilder
+;
+NAME          bombsapp
+DESCRIPTION   'A wxWindows application'
+;
+EXETYPE      WINDOWS
+STUB         'WINSTUB.EXE'
+;
+CODE         PRELOAD MOVEABLE DISCARDABLE
+DATA         PRELOAD MOVEABLE MULTIPLE
+;
+HEAPSIZE     1024
+STACKSIZE    8192

demos/bombs/bombs.h

@@ -0,0 +1,119 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        bombs.h
+// Purpose:     Bombs game
+// Author:      P. Foggia 1996
+// Modified by:
+// Created:     1996
+// RCS-ID:      $Id$
+// Copyright:   (c) 1996 P. Foggia
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _INC_BOMBS_H
+#define _INC_BOMBS_H
+
+#include "game.h"
+
+/*
+ * Forward declarations of all top-level window classes.
+ */
+class  BombsFrameClass;
+class  AboutFrameClass;
+
+/*
+ * Class representing the entire Application
+ */
+class AppClass: public wxApp
+{
+ public:
+  BombsFrameClass *BombsFrame;
+  int level;
+  BombsGame Game;
+
+  bool OnInit();
+};
+
+DECLARE_APP(AppClass)
+
+class BombsCanvasClass;
+
+class BombsFrameClass: public wxFrame
+{
+ private:
+ protected:
+ public:
+  // Subwindows for reference within the program.
+  BombsCanvasClass *BombsCanvas;
+  wxMenuBar *menuBar;
+
+  // Constructor and destructor
+  BombsFrameClass(wxFrame *parent, const wxString& title, const wxPoint& pos, const wxSize& size, long style);
+  ~BombsFrameClass(void);
+
+ void OnCloseWindow(wxCloseEvent& event);
+ void OnExit(wxCommandEvent& event);
+ void OnRestart(wxCommandEvent& event);
+ void OnAbout(wxCommandEvent& event);
+ void OnEasy(wxCommandEvent& event);
+ void OnMedium(wxCommandEvent& event);
+ void OnDifficult(wxCommandEvent& event);
+
+DECLARE_EVENT_TABLE()
+};
+
+/* Menu identifiers
+ */
+// File
+#define BOMBSFRAMECLASS_FILE 1
+// E&xit
+#define IDM_EXIT 2
+// About...
+#define IDM_ABOUT 3
+// Game
+#define BOMBSFRAMECLASS_GAME 4
+// &Restart
+#define IDM_RESTART 5
+// &Easy
+#define IDM_EASY 6
+// &Medium
+#define IDM_MEDIUM 7
+// &Difficult
+#define IDM_DIFFICULT 8
+
+class BombsCanvasClass: public wxWindow
+{
+ private:
+ protected:
+ public:
+   int field_width, field_height;
+   int x_cell, y_cell;
+   wxBitmap *bmp;
+  // Constructor and destructor
+  BombsCanvasClass(wxFrame *parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0);
+  ~BombsCanvasClass(void);
+
+ void OnPaint(wxPaintEvent& event);
+ void DrawField(wxDC *, int xc1, int yc1, int xc2, int yc2);
+ void Refresh(int xc1, int yc1, int xc2, int yc2);
+ void OnEvent(wxMouseEvent& event);
+ void UpdateFieldSize();
+
+DECLARE_EVENT_TABLE()
+};
+
+/* Menu identifiers
+ */
+
+/* The following sizes should probably be redefined */
+/* dimensions of a scroll unit, in pixels */
+#define X_UNIT 4
+#define Y_UNIT 4
+
+/* the dimensions of a cell, in scroll units are in
+ * BombsCanvasClass::x_cell and y_cell
+ */
+
+#define BOMBS_FONT wxFont(14, wxROMAN, wxNORMAL, wxNORMAL)
+
+#endif /* mutual exclusion */
+

demos/bombs/bombs.rc

@@ -0,0 +1,3 @@
+bombs ICON "bombs.ico"
+
+#include "wx/msw/wx.rc"

demos/bombs/bombs.xpm

@@ -0,0 +1,44 @@
+/* XPM */
+static char *bombs_xpm[] = {
+/* columns rows colors chars-per-pixel */
+"32 32 6 1",
+"  c Black",
+". c Blue",
+"X c #00bf00",
+"o c Red",
+"O c Yellow",
+"+ c Gray100",
+/* pixels */
+"                                ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+" oooooo +++++++++++++++++++++++ ",
+"                                ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++ .... ",
+" ++++++ ++++++++++++++++++      ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++ ++++++++++++++++++ ++++ ",
+" ++++++                    ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+" ++++++ OOOOOOOOOOOO XXXXX ++++ ",
+"                                "
+};

demos/bombs/bombs1.cpp

@@ -0,0 +1,204 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        bombs1.cpp
+// Purpose:     Bombs game
+// Author:      P. Foggia 1996
+// Modified by:
+// Created:     1996
+// RCS-ID:      $Id$
+// Copyright:   (c) 1996 P. Foggia
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+ * implementation of the methods DrawField and OnEvent of the
+ * class BombsCanvas
+ */
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+#ifndef  WX_PRECOMP
+  #include "wx/wx.h"
+#endif //precompiled headers
+
+#include "bombs.h"
+
+/*--------  BombCanvasClass::DrawField(dc, xc1, yc1, xc2, yc2)  -------*/
+/* Draws the field on the device context dc                            */
+/* xc1,yc1 etc. are the (inclusive) limits of the area to be drawn,    */
+/* expressed in cells.                                                 */
+/*---------------------------------------------------------------------*/
+void BombsCanvasClass::DrawField(wxDC *dc, int xc1, int yc1, int xc2, int yc2)
+{ int x,y,xmax,ymax;
+  char buf[2];
+  long chw, chh;
+
+  wxColour *wxBlack = wxTheColourDatabase->FindColour("BLACK");
+  wxColour *wxWhite = wxTheColourDatabase->FindColour("WHITE");
+  wxColour *wxRed = wxTheColourDatabase->FindColour("RED");
+  wxColour *wxBlue = wxTheColourDatabase->FindColour("BLUE");
+  wxColour *wxGrey = wxTheColourDatabase->FindColour("LIGHT GREY");
+  wxColour *wxGreen = wxTheColourDatabase->FindColour("GREEN");
+
+  wxPen *blackPen = wxThePenList->FindOrCreatePen(*wxBlack, 1, wxSOLID);
+  wxPen *redPen = wxThePenList->FindOrCreatePen(*wxRed, 1, wxSOLID);
+  wxPen *bluePen = wxThePenList->FindOrCreatePen(*wxBlue, 1, wxSOLID);
+  wxBrush *whiteBrush = wxTheBrushList->FindOrCreateBrush(*wxWhite, wxSOLID);
+  wxBrush *greyBrush = wxTheBrushList->FindOrCreateBrush(*wxGrey, wxSOLID);
+  wxBrush *redBrush = wxTheBrushList->FindOrCreateBrush(*wxRed, wxSOLID);
+
+  xmax=field_width*x_cell*X_UNIT;
+  ymax=field_height*y_cell*Y_UNIT;
+
+
+  dc->SetPen(* blackPen);
+  for(x=xc1; x<=xc2; x++)
+    dc->DrawLine(x*x_cell*X_UNIT, 0, x*x_cell*X_UNIT, ymax);
+  for(y=xc1; y<=yc2; y++)
+    dc->DrawLine(0, y*y_cell*Y_UNIT, xmax, y*y_cell*Y_UNIT);
+
+
+  wxFont font= BOMBS_FONT;
+  dc->SetFont(font); 
+
+  buf[1]='\0';
+  for(x=xc1; x<=xc2; x++)
+    for(y=yc1; y<=yc2; y++)
+      { if (wxGetApp().Game.IsMarked(x,y))
+          { dc->SetPen(* blackPen);
+            dc->SetBrush(* greyBrush);
+            dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
+                               x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
+            *buf='M';
+            if (!wxGetApp().Game.IsHidden(x,y) && wxGetApp().Game.IsBomb(x,y))
+              dc->SetTextForeground(*wxBlue);
+            else
+              dc->SetTextForeground(*wxRed);
+            dc->SetTextBackground(*wxGrey);
+            dc->GetTextExtent(buf, &chw, &chh);
+            dc->DrawText( buf,
+                  x*x_cell*X_UNIT + (x_cell*X_UNIT-chw)/2,
+                  y*y_cell*Y_UNIT + (y_cell*Y_UNIT-chh)/2
+                );
+            if (!wxGetApp().Game.IsHidden(x,y) && wxGetApp().Game.IsBomb(x,y))
+              { dc->SetPen(*redPen);
+                dc->DrawLine(x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
+                             (x+1)*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT);
+                dc->DrawLine(x*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT,
+                             (x+1)*x_cell*X_UNIT, y*y_cell*Y_UNIT);
+              }
+          }
+        else if (wxGetApp().Game.IsHidden(x,y))
+          { dc->SetPen(*blackPen);
+            dc->SetBrush(*greyBrush);
+            dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
+                               x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
+          }
+        else if (wxGetApp().Game.IsBomb(x,y))
+          { dc->SetPen(* blackPen);
+            dc->SetBrush(* redBrush);
+            dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
+                               x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
+            *buf='B';
+            dc->SetTextForeground(* wxBlack);
+            dc->SetTextBackground(* wxRed);
+            dc->GetTextExtent(buf, &chw, &chh);
+            dc->DrawText( buf,
+                  x*x_cell*X_UNIT + (x_cell*X_UNIT-chw)/2,
+                  y*y_cell*Y_UNIT + (y_cell*Y_UNIT-chh)/2
+                );
+            if (wxGetApp().Game.IsExploded(x,y))
+              { dc->SetPen(* bluePen);
+                dc->DrawLine(x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
+                             (x+1)*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT);
+                dc->DrawLine(x*x_cell*X_UNIT, (y+1)*y_cell*Y_UNIT,
+                             (x+1)*x_cell*X_UNIT, y*y_cell*Y_UNIT);
+              }
+          }
+        else   // Display a digit
+          { dc->SetPen(* blackPen);
+            dc->SetBrush(* whiteBrush);
+            dc->DrawRectangle( x*x_cell*X_UNIT, y*y_cell*Y_UNIT,
+                               x_cell*X_UNIT+1, y_cell*Y_UNIT+1);
+            *buf = (wxGetApp().Game.Get(x,y) & BG_MASK) + '0';
+            dc->GetTextExtent(buf, &chw, &chh);
+            switch(*buf)
+              { case '0': dc->SetTextForeground(* wxGreen); break;
+                case '1': dc->SetTextForeground(* wxBlue); break;
+                default:  dc->SetTextForeground(* wxBlack); break;
+              }
+            dc->SetTextBackground(* wxWhite);
+            dc->DrawText( buf,
+                  x*x_cell*X_UNIT + (x_cell*X_UNIT-chw)/2,
+                  y*y_cell*Y_UNIT + (y_cell*Y_UNIT-chh)/2
+                );
+          }
+      }
+  dc->SetFont(wxNullFont);
+
+  if (wxGetApp().BombsFrame)
+    { char buf[80];
+      sprintf(buf, "%d bombs  %d remaining cells",
+              wxGetApp().Game.GetBombs(), wxGetApp().Game.GetRemainingCells());
+      wxGetApp().BombsFrame->SetStatusText(buf, 0);
+    }
+}
+
+/*--------  BombCanvasClass::Refresh(xc1, yc1, xc2, yc2)  -------------*/
+/* Refreshes the field image                                           */
+/* xc1,yc1 etc. are the (inclusive) limits of the area to be drawn,    */
+/* expressed in cells.                                                 */
+/*---------------------------------------------------------------------*/
+void BombsCanvasClass::Refresh(int xc1, int yc1, int xc2, int yc2)
+  {
+    wxClientDC dc(this);
+    DrawField(& dc, xc1, yc1, xc2, yc2);
+    if (bmp)
+      { wxMemoryDC memDC;
+        memDC.SelectObject(* bmp);
+        DrawField(&memDC, xc1, yc1, xc2, yc2);
+        memDC.SelectObject(wxNullBitmap);
+      }
+  }
+
+// Called when the canvas receives a mouse event.
+void BombsCanvasClass::OnEvent(wxMouseEvent& event)
+{
+  wxCoord fx, fy;
+  event.GetPosition(&fx, &fy);
+  int x = fx/(x_cell*X_UNIT);
+  int y = fy/(y_cell*Y_UNIT);
+  if (x<field_width && y<field_height)
+    { if ( (event.RightDown() || (event.LeftDown() && event.ShiftDown()))
+           && (wxGetApp().Game.IsHidden(x,y)
+               || wxGetApp().Game.GetRemainingCells()==0))
+        { wxGetApp().Game.Mark(x,y);
+          Refresh(x, y, x, y);
+          return;
+        }
+      else if (event.LeftDown() && wxGetApp().Game.IsHidden(x,y)
+               && !wxGetApp().Game.IsMarked(x,y))
+        { wxGetApp().Game.Unhide(x,y);
+          Refresh(x, y, x, y);
+          if (wxGetApp().Game.IsBomb(x,y) || wxGetApp().Game.GetRemainingCells()==0)
+            { wxBell();
+              if (!wxGetApp().Game.IsBomb(x,y))
+                { wxMessageBox("Nice! You found all the bombs!", "wxWin Bombs",
+                             wxOK|wxCENTRE, wxGetApp().BombsFrame);
+                }
+              else // x,y is a bomb
+                { wxGetApp().Game.Explode(x, y);
+                }
+              for(x=0; x<field_width; x++)
+                for(y=0; y<field_height; y++)
+                  wxGetApp().Game.Unhide(x,y);
+              Refresh(0, 0, field_width-1, field_height-1);
+            }
+          return;
+        }
+    }
+}
+

demos/bombs/descrip.mms

@@ -0,0 +1,32 @@
+#*****************************************************************************
+#                                                                            *
+# Make file for VMS                                                          *
+# Author : J.Jansen (joukj@hrem.stm.tudelft.nl)                              *
+# Date : 10 November 1999                                                     *
+#                                                                            *
+#*****************************************************************************
+.first
+	define wx [--.include.wx]
+
+.ifdef __WXMOTIF__
+CXX_DEFINE = /define=(__WXMOTIF__=1)
+.else
+CXX_DEFINE =
+.endif
+
+.suffixes : .cpp
+
+.cpp.obj :
+	cxx $(CXXFLAGS)$(CXX_DEFINE) $(MMS$TARGET_NAME).cpp
+
+all :
+	$(MMS)$(MMSQUALIFIERS) game.exe
+
+game.exe : game.obj bombs1.obj bombs.obj
+.ifdef __WXMOTIF__
+	cxxlink game,bombs1,bombs,[--.lib]vms/opt
+.endif
+
+game.obj : game.cpp
+bombs1.obj : bombs1.cpp
+bombs.obj : bombs.cpp

demos/bombs/game.cpp

@@ -0,0 +1,105 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        bombs1.cpp
+// Purpose:     Implementation of the class BombsGame
+// Author:      P. Foggia 1996
+// Modified by:
+// Created:     1996
+// RCS-ID:      $Id$
+// Copyright:   (c) 1996 P. Foggia
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "wx/wxprec.h"
+
+#ifndef  WX_PRECOMP
+  #include "wx/wx.h"
+#endif //precompiled headers
+
+#include "game.h"
+#include <stdlib.h>
+#include <limits.h>
+
+#define PROB 0.2
+
+#ifndef RAND_MAX
+#define RAND_MAX INT_MAX
+#endif
+
+
+/*--------------------  BombsGame::~BombsGame()  ---------------------*/
+/*--------------------------------------------------------------------*/
+BombsGame::~BombsGame()
+  { if (field)
+      free(field);
+  }
+
+/*------------------  int BombsGame::Init(width,height)  -------------------*/
+/* Initialize the play field.   Returns 0 on failure                        */
+/*--------------------------------------------------------------------------*/
+int BombsGame::Init(int aWidth, int aHeight)
+  { int x, y;
+    int xx, yy;
+
+    if (field)
+      free(field);
+    field=(short *)malloc(aWidth*aHeight*sizeof(short));
+    if (!field)
+      { width=height=0;
+        return 0;
+      }
+    width=aWidth;
+    height=aHeight;
+
+    for(x=0; x<width; x++)
+      for(y=0; y<height; y++)
+        { field[x+y*width] = ((float)rand()/RAND_MAX <PROB)?
+                             BG_HIDDEN | BG_BOMB :
+                             BG_HIDDEN;
+        }
+
+    bombs=0;
+    for(x=0; x<width; x++)
+      for(y=0; y<height; y++)
+        if (field[x+y*width] & BG_BOMB)
+          { bombs++;
+            for(xx=x-1; xx<=x+1; xx++)
+              if (xx>=0 && xx<width)
+                for(yy=y-1; yy<=y+1; yy++)
+                  if (yy>=0 && yy<height && (yy!=y || xx!=x))
+                    field[xx+yy*width]++;
+          }
+    normal_cells=height*width-bombs;
+    return 1;
+  }
+
+/*----------------------  BombsGame::Mark(x,y)  -------------------------*/
+/* Marks/unmarks a cell                                                  */
+/*-----------------------------------------------------------------------*/
+void BombsGame::Mark(int x, int y)
+  {
+      field[x+y*width] ^= BG_MARKED;
+  }
+
+/*-------------------  BombsGame::Unhide(x,y)  ------------------------*/
+/* Unhides a cell                                                      */
+/*---------------------------------------------------------------------*/
+void BombsGame::Unhide(int x, int y)
+  { if (!IsHidden(x,y))
+      return;
+    field[x+y*width] &= ~BG_HIDDEN;
+    if (!IsBomb(x,y))
+      normal_cells--;
+  }
+
+/*-------------------  BombsGame::Explode(x,y)  ------------------------*/
+/* Makes a cell exploded                                                */
+/*----------------------------------------------------------------------*/
+void BombsGame::Explode(int x, int y)
+  {
+    field[x+y*width] |= BG_EXPLODED;
+  }
+

demos/bombs/game.h

@@ -0,0 +1,42 @@
+//---------------------------------------------------------------
+// game.h
+// Definition of the class BombsGame, containing the data for a
+// playfield
+//---------------------------------------------------------------
+#ifndef GAME_H
+#define GAME_H
+
+#define BG_HIDDEN   0x100
+#define BG_BOMB     0x200
+#define BG_MARKED   0x400
+#define BG_EXPLODED 0x800
+#define BG_MASK     0x0FF
+
+
+#include <stddef.h>
+
+class BombsGame
+  { protected:
+      int width,height;
+      short *field;
+      int bombs,normal_cells;
+    public:
+      BombsGame() { width=height=0; field=NULL; };
+      ~BombsGame();
+      int Init(int width, int height);
+      int GetWidth() { return width; };
+      int GetHeight() { return height; };
+      int Get(int x, int y) { return field[x+y*width]; };
+      void Mark(int x, int y);
+      void Unhide(int x, int y);
+      void Explode(int x, int y);
+      int IsHidden(int x, int y) { return Get(x,y) & BG_HIDDEN; };
+      int IsMarked(int x, int y) { return Get(x,y) & BG_MARKED; };
+      int IsBomb(int x, int y) { return Get(x,y) & BG_BOMB; };
+      int IsExploded(int x, int y) { return Get(x,y) & BG_EXPLODED; };
+      int GetBombs() { return bombs; };
+      int GetRemainingCells() { return normal_cells; };
+  };
+
+#endif /* def GAME_H */
+

demos/bombs/makefile.b32

@@ -0,0 +1,16 @@
+#
+# File:		makefile.b32
+# Author:	Julian Smart
+# Created:	1999
+# Updated:	
+# Copyright:
+#
+# Makefile : Builds sample for 32-bit BC++
+
+WXDIR = $(WXWIN)
+
+TARGET=bombs
+OBJECTS = $(TARGET).obj bombs1.obj game.obj
+
+!include $(WXDIR)\src\makeprog.b32
+

demos/bombs/makefile.bcc

@@ -0,0 +1,19 @@
+#
+# File:		makefile.bcc
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+#
+# Builds a BC++ 16-bit sample
+
+!if "$(WXWIN)" == ""
+!error You must define the WXWIN variable in autoexec.bat, e.g. WXWIN=c:\wx
+!endif
+
+WXDIR = $(WXWIN)
+
+TARGET=bombs
+OBJECTS=$(TARGET).obj bombs1.obj game.obj
+
+!include $(WXDIR)\src\makeprog.bcc
+

demos/bombs/makefile.dos

@@ -0,0 +1,17 @@
+#
+# File:		makefile.dos
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+#
+# Makefile : Builds 16-bit sample, VC++ 1.5
+# Use FINAL=1 argument to nmake to build final version with no debugging
+# info
+
+WXDIR = $(WXWIN)
+
+TARGET=bombs
+OBJECTS = $(TARGET).obj bombs1.obj game.obj
+
+!include $(WXDIR)\src\makeprog.msc
+

demos/bombs/makefile.g95

@@ -0,0 +1,16 @@
+#
+# File:         makefile.g95
+# Author:       Julian Smart
+# Created:      1999
+# Updated:
+# Copyright:    (c) Julian Smart, 1999
+#
+# Makefile for wxWindows sample (Cygwin/Mingw32).
+
+WXDIR = ../..
+
+TARGET=bombs
+OBJECTS = $(TARGET).o bombs1.o game.o
+
+include $(WXDIR)/src/makeprog.g95
+

demos/bombs/makefile.unx

@@ -0,0 +1,35 @@
+#
+# File:		Makefile for samples
+# Author:	Robert Roebling
+# Created:	1999
+# Updated:	
+# Copyright:	(c) 1998 Robert Roebling
+#
+# This makefile requires a Unix version of wxWindows
+# to be installed on your system. This is most often
+# done typing "make install" when using the complete
+# sources of wxWindows or by installing the two
+# RPM packages wxGTK.XXX.rpm and wxGTK-devel.XXX.rpm
+# under Linux.
+#
+
+CC = gcc
+
+PROGRAM = bombs
+
+OBJECTS = $(PROGRAM).o game.o bombs1.o
+
+# implementation
+
+.SUFFIXES:	.o .cpp
+
+.cpp.o :
+	$(CC) -c `wx-config --cflags` -o $@ $<
+
+all:    $(PROGRAM)
+
+$(PROGRAM):	$(OBJECTS)
+	$(CC) -o $(PROGRAM) $(OBJECTS) `wx-config --libs`
+
+clean: 
+	rm -f *.o $(PROGRAM)

demos/bombs/makefile.vc

@@ -0,0 +1,18 @@
+#
+# File:		makefile.vc
+# Author:	Julian Smart
+# Created:	1999
+# Updated:	
+# Copyright:	(c) Julian Smart
+#
+# Makefile : Builds sample (VC++, WIN32)
+# Use FINAL=1 argument to nmake to build final version with no debug info.
+
+# Set WXDIR for your system
+WXDIR = $(WXWIN)
+
+PROGRAM=bombs
+OBJECTS = $(PROGRAM).obj bombs1.obj game.obj
+
+!include $(WXDIR)\src\makeprog.vc
+

demos/bombs/makefile.wat

@@ -0,0 +1,15 @@
+#
+# Makefile for WATCOM
+#
+# Created by Julian Smart, January 1999
+# 
+#
+
+WXDIR = $(%WXWIN)
+
+PROGRAM = bombs
+OBJECTS = $(PROGRAM).obj bombs1.obj game.obj
+
+!include $(WXDIR)\src\makeprog.wat
+
+

demos/bombs/readme.txt

@@ -0,0 +1,78 @@
+                    wxWin Bombs
+                 by Pasquale Foggia
+
+1. The aim of the program
+wxWin Bombs is the wxWin implementation of the minesweeper game you find
+under MSWindows 3.1+. Later the rules of the game will be explained for
+the lucky ones of you that have never used Windows.
+
+2. Installation
+If you are reading this file, I suppose you have succesfully unpacked the
+files in a directory of your hard disk :-). You should already have
+installed wxWin on your system.
+Now you have to modify makefile.bcc
+(if a Windows user) or makefile.unx (if you use a real OS) setting the 
+proper values for the directories. Finally, you have to run:
+  make -f makefile.bcc
+for Windows (nmake if you use a MicroSoft compiler), or:
+  make -f makefile.unx xview
+for Unix+xview and
+  make -f makefile.unx motif
+for Unix+motif
+
+If you are lucky, you will find the bombs executable, ready to be run.
+
+3. Test
+Bombs has been tested under the following platforms:
+  PC + MSWindos 3.1 + wxWin 1.60 + Borland C 3.1
+  Sun SPARCstation 20 + SunOS + xview + wxWin 1.63 + gcc 2.3.3
+and all seems to work fine.
+
+4. The author
+This program has been developed by Pasquale Foggia, a PhD student 
+in Computer Engineering at the "Federico II" University of Naples, Italy.
+You can contacting him using the following address:
+  foggia@amalfi.dis.unina.it
+
+5. Disclaimer
+This program is freeware. You can do everything you want with it, including
+copying and modifying, without the need of a permission from the author.
+On the other hand, this program is provided AS IS, with NO KIND OF WARRANTY.
+The author will be in NO CASE responsible for damages directly or indirectly 
+caused by this program. Use it AT YOUR OWN RISK, or don't use it at all. 
+
+6. The rules of the game
+Your aim is to discover all the bombs in a mined field. If you click with
+the left mouse button on a cell containing a bomb, your game ends. 
+Otherwise, the number of bombs in the 8 neighbour cells will be displayed. 
+When you have clicked all the cells without a bomb, you win.
+You can also use the right button (or left button+shift) to mark a cell
+you think hides a bomb, in order to not click it accidentally.
+
+7. Concluding remarks
+I hope someone of you will enjoy this program. However, I enjoyed writing
+it (thanks to Julian Smart and all the other wxWin developers).   
+In the near future I plan to implement under wxWin the great 'empire'
+(is there someone that still remember it?), IMHO one of the most addictive
+strategy games. If someone is interested, please contact me by e-mail.
+I beg you pardon for my approximative english.
+
+						Pasquale Foggia
+						foggia@amalfi.dis.unina.it
+
+
+------
+A note from Julian Smart: Many thanks to Pasquale for the contribution.
+I've taken the liberty of making a few changes.
+
+1) I've made the status line have a single field so that you
+can see the 'cells remaining' message properly.
+
+2) I've changed the title from "wxWin Bombs" (which, as a statement,
+is an unfortunate reflection of the reality of earlier versions of
+wxWindows :-)) to wxBombs.
+
+3) Added SetClientData to resize the window on Restart; eliminated
+scrollbars; made the frame unresizeable.
+
+4) Added makefile.dos for VC++ 1.x, makefile.wat for Watcom C++.