msi: Register dlls directly in the SelfRegModules and SelfUnregModules actions.
[wine] / dlls / cards / cards.c
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 }