1 /*
2 * Cards dll implementation
3 *
4 * Copyright (C) 2004 Sami Nopanen
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "wingdi.h"
29
30 #include "cards.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(cards);
34
35
36 void WINAPI cdtTerm(void);
37
38
39 static HINSTANCE hInst;
40 static int cardWidth;
41 static int cardHeight;
42 static HBITMAP cardBitmaps[CARD_MAX + 1];
43
44
45 /***********************************************************************
46 * Initializes the cards.dll library. Loads the card bitmaps from the
47 * resources, and initializes the card size variables.
48 */
49 BOOL WINAPI cdtInit(int *width, int *height)
50 {
51 BITMAP bm;
52 int i;
53
54 TRACE("(%p, %p)\n", width, height);
55
56 for(i = 0; i <= CARD_MAX; i++)
57 cardBitmaps[i] = 0;
58
59 for(i = 0; i <= CARD_MAX; i++)
60 {
61 cardBitmaps[i] = LoadBitmapA(hInst, MAKEINTRESOURCEA(i));
62 if(cardBitmaps[i] == 0)
63 {
64 cdtTerm();
65 return FALSE;
66 }
67 }
68
69 GetObjectA(cardBitmaps[0], sizeof(BITMAP), &bm);
70 *width = cardWidth = bm.bmWidth;
71 *height = cardHeight = bm.bmHeight;
72 return TRUE;
73 }
74
75 static DWORD do_blt(HDC hdc, int x, int y, int dx, int dy, HDC hMemoryDC, DWORD rasterOp )
76 {
77 if((cardWidth == dx) && (cardHeight == dy))
78 return BitBlt(hdc, x, y, cardWidth, cardHeight, hMemoryDC, 0, 0, rasterOp);
79 return StretchBlt(hdc, x, y, dx, dy, hMemoryDC, 0, 0, cardWidth, cardHeight, rasterOp);
80 }
81
82 /***********************************************************************
83 * Draw a card. Unlike cdtDrawCard, this version allows you to stretch
84 * card bitmaps to the size you specify (dx, dy). See cdtDraw for info
85 * on card, mode and color parameters.
86 */
87 BOOL WINAPI cdtDrawExt(HDC hdc, int x, int y, int dx, int dy, int card, int mode, DWORD color)
88 {
89 HDC hMemoryDC;
90 HBITMAP hCardBitmap;
91 HGDIOBJ result;
92 DWORD rasterOp = SRCCOPY;
93 BOOL roundCornersFlag;
94 BOOL eraseFlag = FALSE;
95 BOOL drawFlag = TRUE;
96
97 TRACE("(%p, %d, %d, %d, %d, %d, %d, %d)\n", hdc, x, y, dx, dy, card, mode, color);
98
99 roundCornersFlag = !(mode & MODEFLAG_DONT_ROUND_CORNERS) &&
100 (dx == cardWidth) && (dy == cardHeight);
101 mode &= ~MODEFLAG_DONT_ROUND_CORNERS;
102
103 if((card < 0) || (card > CARD_MAX))
104 {
105 FIXME("Unexpected card: %d\n", card);
106 return FALSE;
107 }
108
109 if((mode < MODE_FACEUP) || (mode > MODE_DECKO))
110 {
111 FIXME("Unexpected mode: %d\n", mode);
112 return FALSE;
113 }
114
115 switch(mode)
116 {
117 case MODE_FACEUP:
118 break;
119 case MODE_FACEDOWN:
120 break;
121 case MODE_HILITE:
122 rasterOp = NOTSRCCOPY;
123 break;
124 case MODE_GHOST:
125 card = CARD_FREE_MASK;
126 eraseFlag = TRUE;
127 rasterOp = SRCAND;
128 break;
129 case MODE_REMOVE:
130 eraseFlag = TRUE;
131 drawFlag = FALSE;
132 break;
133 case MODE_INVISIBLEGHOST:
134 card = CARD_FREE_MASK;
135 rasterOp = SRCAND;
136 break;
137 case MODE_DECKX:
138 card = CARD_BACK_THE_X;
139 break;
140 case MODE_DECKO:
141 card = CARD_BACK_THE_O;
142 break;
143 }
144
145 hMemoryDC = CreateCompatibleDC(hdc);
146 if(hMemoryDC == 0)
147 return FALSE;
148
149 if(eraseFlag)
150 {
151 HBRUSH hBrush;
152 RECT rect;
153 hBrush = CreateSolidBrush(color);
154 rect.left = x;
155 rect.top = y;
156 rect.right = x + cardWidth - 1;
157 rect.bottom = y + cardHeight - 1;
158 FillRect(hdc, &rect, hBrush);
159 }
160
161 if(drawFlag)
162 {
163 hCardBitmap = cardBitmaps[card];
164 if(hCardBitmap == 0)
165 return FALSE;
166
167 result = SelectObject(hMemoryDC, hCardBitmap);
168 if((result == 0) || (result == HGDI_ERROR))
169 {
170 DeleteDC(hMemoryDC);
171 return FALSE;
172 }
173
174 SetBkColor(hdc, color);
175
176 if(roundCornersFlag)
177 {
178 /* NOTE: native uses Get/SetPixel for corners, but that really
179 * hurts on X11 since it needs a server round-trip for each pixel.
180 * So we use a clip region instead. */
181 HRGN saved = CreateRectRgn( 0, 0, 0, 0 );
182 HRGN line = CreateRectRgn( x + 2, y, x + dx - 2, y + 1 );
183 HRGN clip = CreateRectRgn( x, y + 2, x + dx, y + dy - 2 );
184
185 CombineRgn( clip, clip, line, RGN_OR );
186 SetRectRgn( line, x + 1, y + 1, x + dx - 1, y + 2 );
187 CombineRgn( clip, clip, line, RGN_OR );
188 SetRectRgn( line, x + 1, y + dy - 2, x + dx - 1, y + dy - 1 );
189 CombineRgn( clip, clip, line, RGN_OR );
190 SetRectRgn( line, x + 2, y + dy - 1, x + dx - 2, y + dy );
191 CombineRgn( clip, clip, line, RGN_OR );
192 DeleteObject( line );
193
194 if (!GetClipRgn( hdc, saved ))
195 {
196 DeleteObject( saved );
197 saved = 0;
198 }
199 ExtSelectClipRgn( hdc, clip, RGN_AND );
200 DeleteObject( clip );
201
202 do_blt(hdc, x, y, dx, dy, hMemoryDC, rasterOp);
203
204 SelectClipRgn( hdc, saved );
205 if (saved) DeleteObject( saved );
206 }
207 else
208 do_blt(hdc, x, y, dx, dy, hMemoryDC, rasterOp);
209 }
210
211 DeleteDC(hMemoryDC);
212
213 return TRUE;
214 }
215
216
217 /***********************************************************************
218 * Draws a card at position x, y in its default size (as returned by
219 * cdtInit.
220 *
221 * Mode controls how the card gets drawn:
222 * MODE_FACEUP ; draw card facing up
223 * MODE_FACEDOWN ; draw card facing down
224 * MODE_HILITE ; draw face up, with NOTSRCCOPY
225 * MODE_GHOST ; draw 'ghost' card
226 * MODE_REMOVE ; draw with background color
227 * MODE_INVISIBLEGHOST ; draw 'ghost' card, without clearing background
228 * MODE_DECKX ; draw X
229 * MODE_DECKO ; draw O
230 *
231 * The card parameter defines the card graphic to be drawn. If we are
232 * drawing fronts of cards, card should have a value from 0 through 51
233 * to represent the card face. If we are drawing card backs, 53 through
234 * 68 represent different card backs.
235 *
236 * When drawing card faces, two lowest bits represent the card suit
237 * (clubs, diamonds, hearts, spades), and the bits above that define the
238 * card value (ace, 2, ..., king). That is,
239 * card = face * 4 + suit.
240 *
241 * Color parameter defines the background color, used when drawing some
242 * card backs.
243 */
244 BOOL WINAPI cdtDraw(HDC hdc, int x, int y, int card, int mode, DWORD color)
245 {
246 TRACE("(%p, %d, %d, %d, %d, %d)\n", hdc, x, y, card, mode, color);
247
248 return cdtDrawExt(hdc, x, y, cardWidth, cardHeight, card, mode, color);
249 }
250
251
252 /***********************************************************************
253 * Animates the card backs, e.g. blinking lights on the robot, the sun
254 * donning sunglasses, bats flying across the caste, etc.. Works only
255 * for cards of normal size (as drawn with cdtDraw). To draw frames of
256 * the card back animation, start with frame = 0, and increment the
257 * frame by one, until cdtAnimate returns FALSE (to indicate that we
258 * have gone through all frames of animation).
259 */
260 BOOL WINAPI cdtAnimate(HDC hdc, int cardback, int x, int y, int frame)
261 {
262 TRACE("(%p, %d, %d, %d, %d)\n", hdc, cardback, x, y, frame);
263 FIXME("Implement me.\n");
264
265 return FALSE;
266 }
267
268
269 /***********************************************************************
270 * Frees resources reserved by cdtInitialize.
271 */
272 void WINAPI cdtTerm(void)
273 {
274 int i;
275
276 TRACE("()\n");
277
278 for(i = 0; i <= CARD_MAX; i++)
279 {
280 if(cardBitmaps[i] != 0)
281 DeleteObject(cardBitmaps[i]);
282 cardBitmaps[i] = 0;
283 }
284 }
285
286
287 /***********************************************************************
288 * DllMain.
289 */
290 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
291 {
292 switch (reason)
293 {
294 case DLL_PROCESS_ATTACH:
295 hInst = inst;
296 DisableThreadLibraryCalls( inst );
297 break;
298 case DLL_PROCESS_DETACH:
299 break;
300 }
301 return TRUE;
302 }
303
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.