[wxWidgets.git] / samples / forty / card.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        card.cpp
// Purpose:     Forty Thieves patience game
// Author:      Chris Breeze
// Modified by:
// Created:     21/07/97
// RCS-ID:      $Id$
// Copyright:   (c) 1993-1998 Chris Breeze
// Licence:   	wxWindows licence
//---------------------------------------------------------------------------
// Last modified: 22nd July 1998 - ported to wxWindows 2.0
/////////////////////////////////////////////////////////////////////////////
//+-------------------------------------------------------------+
//| Description
//|	A class for drawing playing cards.
//|	Currently assumes that the card symbols have been
//|	loaded into hbmap_symbols and the pictures for the
//|	Jack, Queen and King have been loaded into
//|	hbmap_pictures.
//+-------------------------------------------------------------+

#ifdef __GNUG__
#pragma implementation
#pragma interface
#endif

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "forty.h"
#include "card.h"

#ifdef __WXGTK__
#include "pictures.xpm"
#include "symbols.xbm"
#endif

wxBitmap* Card::m_pictureBmap = 0;
wxBitmap* Card::m_symbolBmap = 0;


//+-------------------------------------------------------------+
//| Card::Card()												|
//+-------------------------------------------------------------+
//| Description:												|
//|	Constructor for a playing card.								|
//|	Checks that the value is in the range 1..52 and then		|
//|	initialises the suit, colour, pipValue and wayUp.			|
//+-------------------------------------------------------------+
Card::Card(int value, WayUp way_up) :
	m_wayUp(way_up)
{
	if (!m_symbolBmap)
	{
#ifdef __WXMSW__
		m_symbolBmap = new wxBitmap("CardSymbols", wxBITMAP_TYPE_BMP_RESOURCE);
#else
		m_symbolBmap = new wxBitmap(Symbols_bits, Symbols_width, Symbols_height);
#endif
		if (!m_symbolBmap->Ok())
		{
			::wxMessageBox("Failed to load bitmap CardSymbols", "Error");
		}
	}
	if (!m_pictureBmap)
	{
#ifdef __WXMSW__
		m_pictureBmap = new wxBitmap("CardPictures", wxBITMAP_TYPE_BMP_RESOURCE);
#else
		m_pictureBmap = new wxBitmap(Pictures);
#endif
		if (!m_pictureBmap->Ok())
		{
			::wxMessageBox("Failed to load bitmap CardPictures", "Error");
		}
	}

    if (value >= 1 && value <= PackSize)
    {
		switch ((value - 1) / 13)
		{
		case 0:
			m_suit = clubs;
			m_colour = black;
			break;
		case 1:
			m_suit = diamonds;
			m_colour = red;
			break;
		case 2:
			m_suit = hearts;
			m_colour = red;
			break;
		case 3:
			m_suit = spades;
			m_colour = black;
			break;
		}
		m_pipValue = 1 + (value - 1) % 13;
		m_status = TRUE;
    }
    else
    {
        m_status = FALSE;
    }
} // Card::Card()


//+-------------------------------------------------------------+
//| Card::~Card()												|
//+-------------------------------------------------------------+
//| Description:												|
//|	Destructor - nothing to do at present.						|
//+-------------------------------------------------------------+
Card::~Card()
{
}


//+-------------------------------------------------------------+
//| Card::Erase()												|
//+-------------------------------------------------------------+
//| Description:												|
//|	Erase the card at (x, y) by drawing a rectangle in the		|
//|	background colour.											|
//+-------------------------------------------------------------+
void Card::Erase(wxDC& dc, int x, int y)
{
	wxPen* pen = wxThePenList->FindOrCreatePen(
						FortyApp::BackgroundColour(),
						1,
						wxSOLID
						);
	dc.SetPen(* pen);
	dc.SetBrush(FortyApp::BackgroundBrush());
	dc.DrawRectangle(x, y, CardWidth, CardHeight);
} // Card::Erase()


//+-------------------------------------------------------------+
//| Card::Draw()												|
//+-------------------------------------------------------------+
//| Description:												|
//|	Draw the card at (x, y).									|
//|	If the card is facedown draw the back of the card.			|
//|	If the card is faceup draw the front of the card.			|
//|	Cards are not held in bitmaps, instead they are drawn		|
//|	from their constituent parts when required.					|
//|	hbmap_symbols contains large and small suit symbols and		|
//|	pip values. These are copied to the appropriate part of		|
//|	the card. Picture cards use the pictures defined in			|
//|	hbmap_pictures. Note that only one picture is defined		|
//|	for the Jack, Queen and King, unlike a real pack where		|
//|	each suit is different.										|
//|																|
//| WARNING:													|
//|	The locations of these symbols is 'hard-wired' into the		|
//|	code. Editing the bitmaps or the numbers below will			|
//|	result in the wrong symbols being displayed.				|
//+-------------------------------------------------------------+
void Card::Draw(wxDC& dc, int x, int y)
{
	wxBrush backgroundBrush( dc.GetBackground() );
	dc.SetBrush(* wxWHITE_BRUSH);
	dc.SetPen(* wxBLACK_PEN);
	dc.DrawRoundedRectangle(x, y, CardWidth, CardHeight, 4);
	if (m_wayUp == facedown)
	{
		dc.SetBackground(* wxRED_BRUSH);
		dc.SetBackgroundMode(wxSOLID);
		wxBrush* brush = wxTheBrushList->FindOrCreateBrush(
							"BLACK", wxCROSSDIAG_HATCH
							);
		dc.SetBrush(* brush);

		dc.DrawRoundedRectangle(
				x + 4, y + 4,
				CardWidth - 8, CardHeight - 8,
				2
				);
	}
	else
	{
		wxMemoryDC memoryDC;
		memoryDC.SelectObject(* m_symbolBmap);

//		dc.SetBackgroundMode(wxTRANSPARENT);

		dc.SetTextBackground(*wxWHITE);
		switch (m_suit)
		{
		case spades:
		case clubs:
			dc.SetTextForeground(*wxBLACK);
			break;
		case diamonds:
		case hearts:
			dc.SetTextForeground(*wxRED);
			break;
		}
			// Draw the value
		dc.Blit(x + 3, y + 3, 6, 7,
				&memoryDC, 6 * (m_pipValue - 1), 36, wxCOPY);
		dc.Blit(x + CardWidth - 9, y + CardHeight - 11, 6, 7,
				&memoryDC, 6 * (m_pipValue - 1), 43, wxCOPY);

			// Draw the pips
		dc.Blit(x + 11, y + 3, 7, 7,
				&memoryDC, 7 * m_suit, 0, wxCOPY);
		dc.Blit(x + CardWidth - 17, y + CardHeight - 11, 7, 7,
				&memoryDC, 7 * m_suit, 7, wxCOPY);

		switch (m_pipValue)
		{
		case 1:
			dc.Blit(x - 5 + CardWidth / 2, y - 5 + CardHeight / 2, 11, 11,
	    		   &memoryDC, 11 * m_suit, 14, wxCOPY);
			break;

		case 3:
			dc.Blit(x - 5 + CardWidth / 2, y - 5 + CardHeight / 2, 11, 11,
			   &memoryDC, 11 * m_suit, 14, wxCOPY);
		case 2:
			dc.Blit(x - 5 + CardWidth / 2,
	    			y - 5 + CardHeight / 4, 11, 11,
	    	   		&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + CardWidth / 2,
				y - 5 + 3 * CardHeight / 4, 11, 11,
	    	   		&memoryDC, 11 * m_suit, 25, wxCOPY);
			break;

		case 5:
			dc.Blit(x - 5 + CardWidth / 2, y - 5 + CardHeight / 2, 11, 11,
			   &memoryDC, 11 * m_suit, 14, wxCOPY);
		case 4:
			dc.Blit(x - 5 +  CardWidth / 4,
				y - 5 + CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + CardWidth / 4,
				y - 5 + 3 * CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 5 + CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 5 + 3 * CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
			break;

		case 8:
			dc.Blit(x - 5 + 5 * CardWidth / 10,
				y - 5 + 5 * CardHeight / 8, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
		case 7:
			dc.Blit(x - 5 + 5 * CardWidth / 10,
				y - 5 + 3 * CardHeight / 8, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
		case 6:
			dc.Blit(x - 5 + CardWidth / 4,
				y - 5 + CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + CardWidth / 4,
				y - 5 + CardHeight / 2, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + CardWidth / 4,
				y - 5 + 3 * CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 5 + CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 5 + CardHeight / 2, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 5 + 3 * CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
			break;

		case 10:
			dc.Blit(x - 5 + CardWidth / 2,
				y - 5 + 2 * CardHeight / 3, 11, 11,
	    	   		&memoryDC, 11 * m_suit, 25, wxCOPY);
		case 9:
			dc.Blit(x - 5 + CardWidth / 4,
				y - 6 + CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + CardWidth / 4,
				y - 6 + 5 * CardHeight / 12, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + CardWidth / 4,
				y - 5 + 7 * CardHeight / 12, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
			dc.Blit(x - 5 + CardWidth / 4,
				y - 5 + 3 * CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);

			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 6 + CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 6 + 5 * CardHeight / 12, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 5 + 7 * CardHeight / 12, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
			dc.Blit(x - 5 + 3 * CardWidth / 4,
				y - 5 + 3 * CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
			dc.Blit(x - 5 + CardWidth / 2,
				y - 5 + CardHeight / 3, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			break;
		case 11:
		case 12:
		case 13:
			memoryDC.SelectObject(* m_pictureBmap);
			dc.Blit(x + 5, y - 5 + CardHeight / 4, 40, 45,
				&memoryDC, 40 * (m_pipValue - 11), 0, wxCOPY);
			memoryDC.SelectObject(* m_symbolBmap);
			dc.Blit(x + 32, y - 3 + CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 14, wxCOPY);
			dc.Blit(x + 7, y + 27 + CardHeight / 4, 11, 11,
				&memoryDC, 11 * m_suit, 25, wxCOPY);
			break;
		}

	}
	dc.SetBackground( backgroundBrush );
} // Card:Draw()


//+-------------------------------------------------------------+
//| Card::DrawNullCard()										|
//+-------------------------------------------------------------+
//| Description:												|
//|	Draws the outline of a card at (x, y).						|
//|	Used to draw place holders for empty piles of cards.		|
//+-------------------------------------------------------------+
void Card::DrawNullCard(wxDC& dc, int x, int y)
{
	wxPen* pen = wxThePenList->FindOrCreatePen(FortyApp::TextColour(), 1, wxSOLID);
	dc.SetBrush(FortyApp::BackgroundBrush());
	dc.SetPen(*pen);
	dc.DrawRoundedRectangle(x, y, CardWidth, CardHeight, 4);
} // Card::DrawNullCard()
Commit	Line	Data
63cafd27 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: card.cpp
	3	// Purpose: Forty Thieves patience game
	4	// Author: Chris Breeze
	5	// Modified by:
	6	// Created: 21/07/97
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1993-1998 Chris Breeze
	9	// Licence: wxWindows licence
	10	//---------------------------------------------------------------------------
	11	// Last modified: 22nd July 1998 - ported to wxWindows 2.0
	12	/////////////////////////////////////////////////////////////////////////////
	13	//+-------------------------------------------------------------+
e3e65dac RR	14	//\| Description
	15	//\| A class for drawing playing cards.
	16	//\| Currently assumes that the card symbols have been
	17	//\| loaded into hbmap_symbols and the pictures for the
	18	//\| Jack, Queen and King have been loaded into
	19	//\| hbmap_pictures.
63cafd27 JS	20	//+-------------------------------------------------------------+
	21
	22	#ifdef __GNUG__
	23	#pragma implementation
	24	#pragma interface
	25	#endif
	26
	27	// For compilers that support precompilation, includes "wx/wx.h".
	28	#include "wx/wxprec.h"
	29
	30	#ifdef __BORLANDC__
	31	#pragma hdrstop
	32	#endif
	33
	34	#ifndef WX_PRECOMP
	35	#include "wx/wx.h"
	36	#endif
	37
	38	#include <stdlib.h>
	39	#include <stdio.h>
	40	#include <string.h>
	41	#include "forty.h"
	42	#include "card.h"
	43
	44	#ifdef __WXGTK__
	45	#include "pictures.xpm"
	46	#include "symbols.xbm"
	47	#endif
	48
	49	wxBitmap* Card::m_pictureBmap = 0;
	50	wxBitmap* Card::m_symbolBmap = 0;
	51
	52
	53	//+-------------------------------------------------------------+
	54	//\| Card::Card() \|
	55	//+-------------------------------------------------------------+
	56	//\| Description: \|
	57	//\| Constructor for a playing card. \|
	58	//\| Checks that the value is in the range 1..52 and then \|
	59	//\| initialises the suit, colour, pipValue and wayUp. \|
	60	//+-------------------------------------------------------------+
	61	Card::Card(int value, WayUp way_up) :
	62	m_wayUp(way_up)
	63	{
	64	if (!m_symbolBmap)
	65	{
	66	#ifdef __WXMSW__
	67	m_symbolBmap = new wxBitmap("CardSymbols", wxBITMAP_TYPE_BMP_RESOURCE);
	68	#else
	69	m_symbolBmap = new wxBitmap(Symbols_bits, Symbols_width, Symbols_height);
	70	#endif
	71	if (!m_symbolBmap->Ok())
	72	{
	73	::wxMessageBox("Failed to load bitmap CardSymbols", "Error");
	74	}
	75	}
	76	if (!m_pictureBmap)
	77	{
	78	#ifdef __WXMSW__
	79	m_pictureBmap = new wxBitmap("CardPictures", wxBITMAP_TYPE_BMP_RESOURCE);
	80	#else
	81	m_pictureBmap = new wxBitmap(Pictures);
	82	#endif
	83	if (!m_pictureBmap->Ok())
84	{
85	::wxMessageBox("Failed to load bitmap CardPictures", "Error");
86	}
87	}
88
89	if (value >= 1 && value <= PackSize)
90	{
91	switch ((value - 1) / 13)
92	{
93	case 0:
94	m_suit = clubs;
95	m_colour = black;
96	break;
97	case 1:
98	m_suit = diamonds;
99	m_colour = red;
100	break;
101	case 2:
102	m_suit = hearts;
103	m_colour = red;
104	break;
105	case 3:
106	m_suit = spades;
107	m_colour = black;
108	break;
109	}
110	m_pipValue = 1 + (value - 1) % 13;
111	m_status = TRUE;
112	}
113	else
114	{
115	m_status = FALSE;
116	}
117	} // Card::Card()
118
119
120	//+-------------------------------------------------------------+
121	//\| Card::~Card() \|
122	//+-------------------------------------------------------------+
123	//\| Description: \|
124	//\| Destructor - nothing to do at present. \|
125	//+-------------------------------------------------------------+
126	Card::~Card()
127	{
128	}
129
130
131	//+-------------------------------------------------------------+
132	//\| Card::Erase() \|
133	//+-------------------------------------------------------------+
134	//\| Description: \|
135	//\| Erase the card at (x, y) by drawing a rectangle in the \|
136	//\| background colour. \|
137	//+-------------------------------------------------------------+
138	void Card::Erase(wxDC& dc, int x, int y)
139	{
140	wxPen* pen = wxThePenList->FindOrCreatePen(
16553659	141	FortyApp::BackgroundColour(),
63cafd27 JS	142	1,
	143	wxSOLID
	144	);
16553659	145	dc.SetPen(* pen);
63cafd27 JS	146	dc.SetBrush(FortyApp::BackgroundBrush());
	147	dc.DrawRectangle(x, y, CardWidth, CardHeight);
	148	} // Card::Erase()
	149
	150
	151	//+-------------------------------------------------------------+
	152	//\| Card::Draw() \|
	153	//+-------------------------------------------------------------+
	154	//\| Description: \|
	155	//\| Draw the card at (x, y). \|
	156	//\| If the card is facedown draw the back of the card. \|
	157	//\| If the card is faceup draw the front of the card. \|
	158	//\| Cards are not held in bitmaps, instead they are drawn \|
	159	//\| from their constituent parts when required. \|
	160	//\| hbmap_symbols contains large and small suit symbols and \|
	161	//\| pip values. These are copied to the appropriate part of \|
	162	//\| the card. Picture cards use the pictures defined in \|
	163	//\| hbmap_pictures. Note that only one picture is defined \|
	164	//\| for the Jack, Queen and King, unlike a real pack where \|
	165	//\| each suit is different. \|
	166	//\| \|
	167	//\| WARNING: \|
	168	//\| The locations of these symbols is 'hard-wired' into the \|
	169	//\| code. Editing the bitmaps or the numbers below will \|
	170	//\| result in the wrong symbols being displayed. \|
	171	//+-------------------------------------------------------------+
	172	void Card::Draw(wxDC& dc, int x, int y)
	173	{
f234c60c	174	wxBrush backgroundBrush( dc.GetBackground() );
16553659 JS	175	dc.SetBrush(* wxWHITE_BRUSH);
16553659 JS	176	dc.SetPen(* wxBLACK_PEN);
63cafd27 JS	177	dc.DrawRoundedRectangle(x, y, CardWidth, CardHeight, 4);
	178	if (m_wayUp == facedown)
	179	{
16553659	180	dc.SetBackground(* wxRED_BRUSH);
63cafd27 JS	181	dc.SetBackgroundMode(wxSOLID);
	182	wxBrush* brush = wxTheBrushList->FindOrCreateBrush(
	183	"BLACK", wxCROSSDIAG_HATCH
	184	);
16553659	185	dc.SetBrush(* brush);
63cafd27 JS	186
	187	dc.DrawRoundedRectangle(
	188	x + 4, y + 4,
	189	CardWidth - 8, CardHeight - 8,
	190	2
	191	);
	192	}
	193	else
	194	{
	195	wxMemoryDC memoryDC;
16553659	196	memoryDC.SelectObject(* m_symbolBmap);
63cafd27 JS	197
	198	// dc.SetBackgroundMode(wxTRANSPARENT);
	199
	200	dc.SetTextBackground(*wxWHITE);
	201	switch (m_suit)
	202	{
	203	case spades:
	204	case clubs:
	205	dc.SetTextForeground(*wxBLACK);
	206	break;
	207	case diamonds:
	208	case hearts:
	209	dc.SetTextForeground(*wxRED);
	210	break;
	211	}
	212	// Draw the value
	213	dc.Blit(x + 3, y + 3, 6, 7,
	214	&memoryDC, 6 * (m_pipValue - 1), 36, wxCOPY);
	215	dc.Blit(x + CardWidth - 9, y + CardHeight - 11, 6, 7,
	216	&memoryDC, 6 * (m_pipValue - 1), 43, wxCOPY);
	217
	218	// Draw the pips
	219	dc.Blit(x + 11, y + 3, 7, 7,
	220	&memoryDC, 7 * m_suit, 0, wxCOPY);
	221	dc.Blit(x + CardWidth - 17, y + CardHeight - 11, 7, 7,
	222	&memoryDC, 7 * m_suit, 7, wxCOPY);
	223
	224	switch (m_pipValue)
	225	{
	226	case 1:
	227	dc.Blit(x - 5 + CardWidth / 2, y - 5 + CardHeight / 2, 11, 11,
	228	&memoryDC, 11 * m_suit, 14, wxCOPY);
	229	break;
	230
	231	case 3:
	232	dc.Blit(x - 5 + CardWidth / 2, y - 5 + CardHeight / 2, 11, 11,
	233	&memoryDC, 11 * m_suit, 14, wxCOPY);
	234	case 2:
	235	dc.Blit(x - 5 + CardWidth / 2,
	236	y - 5 + CardHeight / 4, 11, 11,
	237	&memoryDC, 11 * m_suit, 14, wxCOPY);
	238	dc.Blit(x - 5 + CardWidth / 2,
	239	y - 5 + 3 * CardHeight / 4, 11, 11,
	240	&memoryDC, 11 * m_suit, 25, wxCOPY);
	241	break;
	242
	243	case 5:
	244	dc.Blit(x - 5 + CardWidth / 2, y - 5 + CardHeight / 2, 11, 11,
	245	&memoryDC, 11 * m_suit, 14, wxCOPY);
	246	case 4:
	247	dc.Blit(x - 5 + CardWidth / 4,
	248	y - 5 + CardHeight / 4, 11, 11,
	249	&memoryDC, 11 * m_suit, 14, wxCOPY);
	250	dc.Blit(x - 5 + CardWidth / 4,
	251	y - 5 + 3 * CardHeight / 4, 11, 11,
	252	&memoryDC, 11 * m_suit, 25, wxCOPY);
	253	dc.Blit(x - 5 + 3 * CardWidth / 4,
	254	y - 5 + CardHeight / 4, 11, 11,
	255	&memoryDC, 11 * m_suit, 14, wxCOPY);
	256	dc.Blit(x - 5 + 3 * CardWidth / 4,
	257	y - 5 + 3 * CardHeight / 4, 11, 11,
	258	&memoryDC, 11 * m_suit, 25, wxCOPY);
	259	break;
	260
261	case 8:
262	dc.Blit(x - 5 + 5 * CardWidth / 10,
263	y - 5 + 5 * CardHeight / 8, 11, 11,
264	&memoryDC, 11 * m_suit, 25, wxCOPY);
265	case 7:
266	dc.Blit(x - 5 + 5 * CardWidth / 10,
267	y - 5 + 3 * CardHeight / 8, 11, 11,
268	&memoryDC, 11 * m_suit, 14, wxCOPY);
269	case 6:
270	dc.Blit(x - 5 + CardWidth / 4,
271	y - 5 + CardHeight / 4, 11, 11,
272	&memoryDC, 11 * m_suit, 14, wxCOPY);
273	dc.Blit(x - 5 + CardWidth / 4,
274	y - 5 + CardHeight / 2, 11, 11,
275	&memoryDC, 11 * m_suit, 14, wxCOPY);
276	dc.Blit(x - 5 + CardWidth / 4,
277	y - 5 + 3 * CardHeight / 4, 11, 11,
278	&memoryDC, 11 * m_suit, 25, wxCOPY);
279	dc.Blit(x - 5 + 3 * CardWidth / 4,
280	y - 5 + CardHeight / 4, 11, 11,
281	&memoryDC, 11 * m_suit, 14, wxCOPY);
282	dc.Blit(x - 5 + 3 * CardWidth / 4,
283	y - 5 + CardHeight / 2, 11, 11,
284	&memoryDC, 11 * m_suit, 14, wxCOPY);
285	dc.Blit(x - 5 + 3 * CardWidth / 4,
286	y - 5 + 3 * CardHeight / 4, 11, 11,
287	&memoryDC, 11 * m_suit, 25, wxCOPY);
288	break;
289
290	case 10:
291	dc.Blit(x - 5 + CardWidth / 2,
292	y - 5 + 2 * CardHeight / 3, 11, 11,
293	&memoryDC, 11 * m_suit, 25, wxCOPY);
294	case 9:
295	dc.Blit(x - 5 + CardWidth / 4,
296	y - 6 + CardHeight / 4, 11, 11,
297	&memoryDC, 11 * m_suit, 14, wxCOPY);
298	dc.Blit(x - 5 + CardWidth / 4,
299	y - 6 + 5 * CardHeight / 12, 11, 11,
300	&memoryDC, 11 * m_suit, 14, wxCOPY);
301	dc.Blit(x - 5 + CardWidth / 4,
302	y - 5 + 7 * CardHeight / 12, 11, 11,
303	&memoryDC, 11 * m_suit, 25, wxCOPY);
304	dc.Blit(x - 5 + CardWidth / 4,
305	y - 5 + 3 * CardHeight / 4, 11, 11,
306	&memoryDC, 11 * m_suit, 25, wxCOPY);
307
308	dc.Blit(x - 5 + 3 * CardWidth / 4,
309	y - 6 + CardHeight / 4, 11, 11,
310	&memoryDC, 11 * m_suit, 14, wxCOPY);
311	dc.Blit(x - 5 + 3 * CardWidth / 4,
312	y - 6 + 5 * CardHeight / 12, 11, 11,
313	&memoryDC, 11 * m_suit, 14, wxCOPY);
314	dc.Blit(x - 5 + 3 * CardWidth / 4,
315	y - 5 + 7 * CardHeight / 12, 11, 11,
316	&memoryDC, 11 * m_suit, 25, wxCOPY);
317	dc.Blit(x - 5 + 3 * CardWidth / 4,
318	y - 5 + 3 * CardHeight / 4, 11, 11,
319	&memoryDC, 11 * m_suit, 25, wxCOPY);
320	dc.Blit(x - 5 + CardWidth / 2,
321	y - 5 + CardHeight / 3, 11, 11,
322	&memoryDC, 11 * m_suit, 14, wxCOPY);
323	break;
324	case 11:
325	case 12:
326	case 13:
16553659	327	memoryDC.SelectObject(* m_pictureBmap);
63cafd27 JS	328	dc.Blit(x + 5, y - 5 + CardHeight / 4, 40, 45,
63cafd27 JS	329	&memoryDC, 40 * (m_pipValue - 11), 0, wxCOPY);
16553659	330	memoryDC.SelectObject(* m_symbolBmap);
63cafd27 JS	331	dc.Blit(x + 32, y - 3 + CardHeight / 4, 11, 11,
	332	&memoryDC, 11 * m_suit, 14, wxCOPY);
	333	dc.Blit(x + 7, y + 27 + CardHeight / 4, 11, 11,
	334	&memoryDC, 11 * m_suit, 25, wxCOPY);
	335	break;
	336	}
	337
	338	}
f234c60c	339	dc.SetBackground( backgroundBrush );
63cafd27 JS	340	} // Card:Draw()
	341
	342
	343	//+-------------------------------------------------------------+
	344	//\| Card::DrawNullCard() \|
	345	//+-------------------------------------------------------------+
	346	//\| Description: \|
	347	//\| Draws the outline of a card at (x, y). \|
	348	//\| Used to draw place holders for empty piles of cards. \|
	349	//+-------------------------------------------------------------+
	350	void Card::DrawNullCard(wxDC& dc, int x, int y)
	351	{
16553659	352	wxPen* pen = wxThePenList->FindOrCreatePen(FortyApp::TextColour(), 1, wxSOLID);
63cafd27	353	dc.SetBrush(FortyApp::BackgroundBrush());
16553659	354	dc.SetPen(*pen);
63cafd27 JS	355	dc.DrawRoundedRectangle(x, y, CardWidth, CardHeight, 4);
	356	} // Card::DrawNullCard()
	357
	358