git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	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 wxWidgets 2.0
	12	/////////////////////////////////////////////////////////////////////////////
	13	//+-------------------------------------------------------------+
	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.
	20	//+-------------------------------------------------------------+
	21
	22	// For compilers that support precompilation, includes "wx/wx.h".
	23	#include "wx/wxprec.h"
	24
	25	#ifdef __BORLANDC__
	26	#pragma hdrstop
	27	#endif
	28
	29	#ifndef WX_PRECOMP
	30	#include "wx/wx.h"
	31	#endif
	32
	33	#include <stdlib.h>
	34	#include <stdio.h>
	35	#include <string.h>
	36	#include "forty.h"
	37	#include "card.h"
	38
	39	#include "pictures.xpm"
	40	#include "symbols.xpm"
	41
	42	wxBitmap* Card::m_pictureBmap = 0;
	43	wxBitmap* Card::m_symbolBmap = 0;
	44
	45	double Card::m_scale = 1.0;
	46	int Card::m_width = 50;
	47	int Card::m_height = 70;
	48
	49	//+-------------------------------------------------------------+
	50	//\| Card::Card() \|
	51	//+-------------------------------------------------------------+
	52	//\| Description: \|
	53	//\| Constructor for a playing card. \|
	54	//\| Checks that the value is in the range 1..52 and then \|
	55	//\| initialises the suit, colour, pipValue and wayUp. \|
	56	//+-------------------------------------------------------------+
	57	Card::Card(int value, WayUp way_up) :
	58	m_wayUp(way_up)
	59	{
	60	if (!m_symbolBmap)
	61	{
	62	m_symbolBmap = new wxBitmap(symbols_xpm);
	63	if (!m_symbolBmap->IsOk())
	64	{
	65	::wxMessageBox(wxT("Failed to load bitmap CardSymbols"), wxT("Error"));
	66	}
	67	}
	68	if (!m_pictureBmap)
	69	{
	70	m_pictureBmap = new wxBitmap(Pictures);
	71	if (!m_pictureBmap->IsOk())
	72	{
	73	::wxMessageBox(wxT("Failed to load bitmap CardPictures"), wxT("Error"));
	74	}
	75	}
	76
	77	if (value >= 1 && value <= PackSize)
	78	{
	79	switch ((value - 1) / 13)
	80	{
	81	case 0:
	82	m_suit = clubs;
	83	m_colour = black;
	84	break;
	85	case 1:
	86	m_suit = diamonds;
	87	m_colour = red;
	88	break;
	89	case 2:
	90	m_suit = hearts;
	91	m_colour = red;
	92	break;
	93	case 3:
	94	m_suit = spades;
	95	m_colour = black;
	96	break;
	97	}
	98	m_pipValue = 1 + (value - 1) % 13;
	99	m_status = true;
	100	}
	101	else
	102	{
	103	m_status = false;
	104	}
	105	} // Card::Card()
	106
	107
	108	//+-------------------------------------------------------------+
	109	//\| Card::SetScale() \|
	110	//+-------------------------------------------------------------+
	111	//\| Description: \|
	112	//\| Scales the cards \|
	113	//+-------------------------------------------------------------+
	114	void Card::SetScale(double scale)
	115	{
	116	m_scale = scale;
	117	m_width = int(50*scale);
	118	m_height = int(70*scale);
	119	}
	120
	121	//+-------------------------------------------------------------+
	122	//\| Card::Erase() \|
	123	//+-------------------------------------------------------------+
	124	//\| Description: \|
	125	//\| Erase the card at (x, y) by drawing a rectangle in the \|
	126	//\| background colour. \|
	127	//+-------------------------------------------------------------+
	128	void Card::Erase(wxDC& dc, int x, int y)
	129	{
	130	wxPen* pen = wxThePenList->FindOrCreatePen(
	131	FortyApp::BackgroundColour(),
	132	1,
	133	wxSOLID
	134	);
	135	dc.SetPen(* pen);
	136	dc.SetBrush(FortyApp::BackgroundBrush());
	137	dc.DrawRectangle(x, y, m_width, m_height);
	138	} // Card::Erase()
	139
	140
	141	//+-------------------------------------------------------------+
	142	//\| Card::Draw() \|
	143	//+-------------------------------------------------------------+
	144	//\| Description: \|
	145	//\| Draw the card at (x, y). \|
	146	//\| If the card is facedown draw the back of the card. \|
	147	//\| If the card is faceup draw the front of the card. \|
	148	//\| Cards are not held in bitmaps, instead they are drawn \|
	149	//\| from their constituent parts when required. \|
	150	//\| hbmap_symbols contains large and small suit symbols and \|
	151	//\| pip values. These are copied to the appropriate part of \|
	152	//\| the card. Picture cards use the pictures defined in \|
	153	//\| hbmap_pictures. Note that only one picture is defined \|
	154	//\| for the Jack, Queen and King, unlike a real pack where \|
	155	//\| each suit is different. \|
	156	//\| \|
	157	//\| WARNING: \|
	158	//\| The locations of these symbols is 'hard-wired' into the \|
	159	//\| code. Editing the bitmaps or the numbers below will \|
	160	//\| result in the wrong symbols being displayed. \|
	161	//+-------------------------------------------------------------+
	162	void Card::Draw(wxDC& dc, int x, int y)
	163	{
	164	wxBrush backgroundBrush( dc.GetBackground() );
	165	dc.SetBrush(* wxWHITE_BRUSH);
	166	dc.SetPen(* wxBLACK_PEN);
	167	dc.DrawRoundedRectangle(x, y, m_width, m_height, 4);
	168	if (m_wayUp == facedown)
	169	{
	170	dc.SetBackground(* wxRED_BRUSH);
	171	dc.SetBackgroundMode(wxSOLID);
	172	wxBrush* brush = wxTheBrushList->FindOrCreateBrush(
	173	*wxBLACK, wxCROSSDIAG_HATCH
	174	);
	175	dc.SetBrush(* brush);
	176
	177	dc.DrawRoundedRectangle(
	178	x + 4, y + 4,
	179	m_width - 8, m_height - 8,
	180	2
	181	);
	182	}
	183	else
	184	{
	185	wxMemoryDC memoryDC;
	186
	187	memoryDC.SelectObject(*m_symbolBmap);
	188
	189	// dc.SetBackgroundMode(wxTRANSPARENT);
	190
	191	dc.SetTextBackground(*wxWHITE);
	192	switch (m_suit)
	193	{
	194	case spades:
	195	case clubs:
	196	dc.SetTextForeground(*wxBLACK);
	197	break;
	198	case diamonds:
	199	case hearts:
	200	dc.SetTextForeground(*wxRED);
	201	break;
	202	}
	203
	204	int symsize = 11;
	205	int sympos = 14;
	206	int sympos2 = 25;
	207	int symdist = 5;
	208	int symdist2 = 6;
	209
	210	int pipsize,pippos,valueheight,valuewidth;
	211	int valuepos;
	212	if (m_scale > 1.2)
	213	{
	214	pipsize = symsize;
	215	pippos = sympos;
	216	valueheight = 10;
	217	valuewidth = 9;
	218	valuepos = 50;
	219	}
	220	else
	221	{
	222	pipsize = 7;
	223	pippos = 0;
	224	valueheight = 7;
	225	valuewidth = 6;
	226	valuepos = 36;
	227	}
	228
	229	// Draw the value
	230	dc.Blit((wxCoord)(x + m_scale*3),
	231	(wxCoord)(y + m_scale*3),
	232	valuewidth,
	233	valueheight,
	234	&memoryDC,
	235	valuewidth * (m_pipValue - 1),
	236	valuepos,
	237	wxCOPY);
	238	dc.Blit((wxCoord)(x + m_width - m_scale*3 - valuewidth),
	239	(wxCoord)(y + m_height - valueheight - m_scale*3),
	240	valuewidth,
	241	valueheight,
	242	&memoryDC,
	243	valuewidth * (m_pipValue - 1),
	244	valuepos+valueheight,
	245	wxCOPY);
	246
	247	// Draw the pips
	248	dc.Blit((wxCoord)(x + m_scale*3 + valuewidth+2),
	249	(wxCoord)(y + m_scale*3),
	250	pipsize,
	251	pipsize,
	252	&memoryDC,
	253	pipsize * m_suit,
	254	pippos,
	255	wxCOPY);
	256	dc.Blit((wxCoord)(x + m_width - m_scale*3-valuewidth-pipsize-2),
	257	(wxCoord)(y + m_height - pipsize - m_scale*3),
	258	pipsize,
	259	pipsize,
	260	&memoryDC,
	261	pipsize * m_suit,
	262	pipsize+pippos,
	263	wxCOPY);
	264
	265	switch (m_pipValue)
	266	{
	267	case 1:
	268	dc.Blit((wxCoord)(x - symdist + m_width / 2),
	269	(wxCoord)(y - m_scale*5 + m_height / 2),
	270	symsize,
	271	symsize,
	272	&memoryDC,
	273	symsize * m_suit,
	274	sympos,
	275	wxCOPY);
	276	break;
	277
	278	case 3:
	279	dc.Blit((wxCoord)(x - symdist + m_width / 2),
	280	(wxCoord)(y - symdist + m_height / 2),
	281	symsize,
	282	symsize,
	283	&memoryDC,
	284	symsize * m_suit,
	285	sympos,
	286	wxCOPY);
	287	case 2:
	288	dc.Blit((wxCoord)(x - symdist + m_width / 2),
	289	(wxCoord)(y - symdist + m_height / 4),
	290	symsize,
	291	symsize,
	292	&memoryDC,
	293	symsize * m_suit,
	294	sympos,
	295	wxCOPY);
	296	dc.Blit((wxCoord)(x - symdist + m_width / 2),
	297	(wxCoord)(y - symdist + 3 * m_height / 4),
	298	symsize,
	299	symsize,
	300	&memoryDC,
	301	symsize * m_suit,
	302	sympos2,
	303	wxCOPY);
	304	break;
	305
	306	case 5:
	307	dc.Blit((wxCoord)(x - symdist + m_width / 2),
	308	(wxCoord)(y - symdist + m_height / 2),
	309	symsize,
	310	symsize,
	311	&memoryDC,
	312	symsize * m_suit,
	313	sympos,
	314	wxCOPY);
	315	case 4:
	316	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	317	(wxCoord)(y - symdist + m_height / 4),
	318	symsize,
	319	symsize,
	320	&memoryDC,
	321	symsize * m_suit,
	322	sympos,
	323	wxCOPY);
	324	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	325	(wxCoord)(y - symdist + 3 * m_height / 4),
	326	symsize,
	327	symsize,
	328	&memoryDC,
	329	symsize * m_suit,
	330	sympos2,
	331	wxCOPY);
	332	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	333	(wxCoord)(y - symdist + m_height / 4),
	334	symsize,
	335	symsize,
	336	&memoryDC,
	337	symsize * m_suit,
	338	sympos,
	339	wxCOPY);
	340	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	341	(wxCoord)(y - symdist + 3 * m_height / 4),
	342	symsize,
	343	symsize,
	344	&memoryDC,
	345	symsize * m_suit,
	346	sympos2,
	347	wxCOPY);
	348	break;
	349
	350	case 8:
	351	dc.Blit((wxCoord)(x - symdist + 5 * m_width / 10),
	352	(wxCoord)(y - symdist + 5 * m_height / 8),
	353	symsize,
	354	symsize,
	355	&memoryDC,
	356	symsize * m_suit,
	357	sympos2,
	358	wxCOPY);
	359	case 7:
	360	dc.Blit((wxCoord)(x - symdist + 5 * m_width / 10),
	361	(wxCoord)(y - symdist + 3 * m_height / 8),
	362	symsize,
	363	symsize,
	364	&memoryDC,
	365	symsize * m_suit,
	366	sympos,
	367	wxCOPY);
	368	case 6:
	369	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	370	(wxCoord)(y - symdist + m_height / 4),
	371	symsize,
	372	symsize,
	373	&memoryDC, symsize * m_suit, sympos, wxCOPY);
	374	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	375	(wxCoord)(y - symdist + m_height / 2),
	376	symsize,
	377	symsize,
	378	&memoryDC,
	379	symsize * m_suit,
	380	sympos,
	381	wxCOPY);
	382	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	383	(wxCoord)(y - symdist + 3 * m_height / 4),
	384	symsize,
	385	symsize,
	386	&memoryDC,
	387	symsize * m_suit,
	388	sympos2,
	389	wxCOPY);
	390	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	391	(wxCoord)(y - symdist + m_height / 4),
	392	symsize,
	393	symsize,
	394	&memoryDC,
	395	symsize * m_suit,
	396	sympos,
	397	wxCOPY);
	398	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	399	(wxCoord)(y - symdist + m_height / 2),
	400	symsize,
	401	symsize,
	402	&memoryDC,
	403	symsize * m_suit,
	404	sympos,
	405	wxCOPY);
	406	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	407	(wxCoord)(y - symdist + 3 * m_height / 4),
	408	symsize,
	409	symsize,
	410	&memoryDC,
	411	symsize * m_suit,
	412	sympos2,
	413	wxCOPY);
	414	break;
	415
	416	case 10:
	417	dc.Blit((wxCoord)(x - symdist + m_width / 2),
	418	(wxCoord)(y - symdist + 2 * m_height / 3),
	419	symsize,
	420	symsize,
	421	&memoryDC,
	422	symsize * m_suit,
	423	sympos2,
	424	wxCOPY);
	425	case 9:
	426	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	427	(wxCoord)(y - symdist2 + m_height / 4),
	428	symsize,
	429	symsize,
	430	&memoryDC,
	431	symsize * m_suit,
	432	sympos,
	433	wxCOPY);
	434	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	435	(wxCoord)(y - symdist2 + 5 * m_height / 12),
	436	symsize,
	437	symsize,
	438	&memoryDC,
	439	symsize * m_suit,
	440	sympos,
	441	wxCOPY);
	442	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	443	(wxCoord)(y - symdist + 7 * m_height / 12),
	444	symsize,
	445	symsize,
	446	&memoryDC,
	447	symsize * m_suit,
	448	sympos2,
	449	wxCOPY);
	450	dc.Blit((wxCoord)(x - symdist + m_width / 4),
	451	(wxCoord)(y - symdist + 3 * m_height / 4),
	452	symsize,
	453	symsize,
	454	&memoryDC,
	455	symsize * m_suit,
	456	sympos2,
	457	wxCOPY);
	458
	459	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	460	(wxCoord)(y - symdist2 + m_height / 4),
	461	symsize,
	462	symsize,
	463	&memoryDC,
	464	symsize * m_suit,
	465	sympos,
	466	wxCOPY);
	467	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	468	(wxCoord)(y - symdist2 + 5 * m_height / 12),
	469	symsize,
	470	symsize,
	471	&memoryDC,
	472	symsize * m_suit,
	473	sympos,
	474	wxCOPY);
	475	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	476	(wxCoord)(y - symdist + 7 * m_height / 12),
	477	symsize,
	478	symsize,
	479	&memoryDC,
	480	symsize * m_suit,
	481	sympos2,
	482	wxCOPY);
	483	dc.Blit((wxCoord)(x - symdist + 3 * m_width / 4),
	484	(wxCoord)(y - symdist + 3 * m_height / 4),
	485	symsize,
	486	symsize,
	487	&memoryDC,
	488	symsize * m_suit,
	489	sympos2,
	490	wxCOPY);
	491	dc.Blit((wxCoord)(x - symdist + m_width / 2),
	492	(wxCoord)(y - symdist + m_height / 3),
	493	symsize,
	494	symsize,
	495	&memoryDC,
	496	symsize * m_suit,
	497	sympos,
	498	wxCOPY);
	499	break;
	500	case 11:
	501	case 12:
	502	case 13:
	503	memoryDC.SelectObject(*m_pictureBmap);
	504	int picwidth = 40,picheight = 45;
	505	dc.Blit((wxCoord)(x + (m_width-picwidth)/2),
	506	(wxCoord)(y - picheight/2 + m_height/2),
	507	picwidth,
	508	picheight,
	509	&memoryDC,
	510	picwidth * (m_pipValue - 11),
	511	0,
	512	wxCOPY);
	513
	514	memoryDC.SelectObject(*m_symbolBmap);
	515	dc.Blit((wxCoord)(x + m_width-(m_width-picwidth)/2-symsize-3),
	516	(wxCoord)(y - picheight/2+m_height/2+1),
	517	symsize,
	518	symsize,
	519	&memoryDC,
	520	symsize * m_suit,
	521	sympos,
	522	wxCOPY);
	523	dc.Blit((wxCoord)(x + (m_width-picwidth)/2+2),
	524	(wxCoord)(y + picheight/2 + m_height/2-symsize),
	525	symsize,
	526	symsize,
	527	&memoryDC,
	528	symsize * m_suit,
	529	sympos2,
	530	wxCOPY);
	531	break;
	532	}
	533
	534	}
	535	dc.SetBackground( backgroundBrush );
	536	} // Card:Draw()
	537
	538
	539	//+-------------------------------------------------------------+
	540	//\| Card::DrawNullCard() \|
	541	//+-------------------------------------------------------------+
	542	//\| Description: \|
	543	//\| Draws the outline of a card at (x, y). \|
	544	//\| Used to draw place holders for empty piles of cards. \|
	545	//+-------------------------------------------------------------+
	546	void Card::DrawNullCard(wxDC& dc, int x, int y)
	547	{
	548	wxPen* pen = wxThePenList->FindOrCreatePen(FortyApp::TextColour(), 1, wxSOLID);
	549	dc.SetBrush(FortyApp::BackgroundBrush());
	550	dc.SetPen(*pen);
	551	dc.DrawRoundedRectangle(x, y, m_width, m_height, 4);
	552	} // Card::DrawNullCard()