[CRT] spawn: define a unicode environment when needed
[reactos.git] / sdk / lib / 3rdparty / cardlib / cardrgndraw.cpp
1 //
2 // CardLib - CardRegion drawing support
3 //
4 // Freeware
5 // Copyright J Brown 2001
6 //
7
8 #include "cardlib.h"
9
10 HPALETTE UseNicePalette(HDC hdc, HPALETTE hPalette);
11 void PaintRect(HDC hdc, RECT *rect, COLORREF colour);
12 void CardBlt(HDC hdc, int x, int y, int nCardNum);
13 void DrawCard(HDC hdc, int x, int y, HDC hdcSource, int width, int height);
14
15 //
16 // Draw specified card at position x, y
17 // xoff - source offset from left of card
18 // yoff - source offset from top of card
19 // width - width to draw
20 // height - height to draw
21 //
22 void CardBlt(HDC hdc, int x, int y, int nCardNum)//, int xoff, int yoff, int width, int height)
23 {
24 int sx = nCardNum * __cardwidth;
25 int sy = 0;
26 int width = __cardwidth;
27 int height = __cardheight;
28
29 //draw main center band
30 BitBlt(hdc, x+2, y, width - 4, height, __hdcCardBitmaps, sx+2, sy+0, SRCCOPY);
31
32 //draw the two bits to the left
33 BitBlt(hdc, x, y+2, 1, height - 4, __hdcCardBitmaps, sx+0, sy+2, SRCCOPY);
34 BitBlt(hdc, x+1, y+1, 1, height - 2, __hdcCardBitmaps, sx+1, sy+1, SRCCOPY);
35
36 //draw the two bits to the right
37 BitBlt(hdc, x+width-2, y+1, 1, height - 2, __hdcCardBitmaps, sx+width-2, sy+1, SRCCOPY);
38 BitBlt(hdc, x+width-1, y+2, 1, height - 4, __hdcCardBitmaps, sx+width-1, sy+2, SRCCOPY);
39 }
40
41 //
42 // Draw a shape this this:
43 //
44 // ++++++++++++
45 // ++++++++++++++
46 // ++ ++
47 //
48 void DrawHorzCardStrip(HDC hdc, int x, int y, int nCardNum, int height, BOOL fDrawTips)
49 {
50 int sx = nCardNum * __cardwidth;
51 int sy = 0;
52 int one = 1;
53 int two = 2;
54 BOOL tips = fDrawTips ? FALSE : TRUE;
55
56 if(height == 0) return;
57
58 if(height < 0)
59 {
60 sy = sy + __cardheight;
61 y -= height;
62 one = -one;
63 two = -two;
64 }
65
66 // draw the main vertical band
67 //
68 BitBlt(hdc, x + 2, y, __cardwidth - 4, height, __hdcCardBitmaps, sx+2, sy, SRCCOPY);
69
70 //if(height <= 1) return;
71
72 // draw the "lips" at the left and right
73 BitBlt(hdc, x+1, y+one, 1, height-one*tips, __hdcCardBitmaps, sx+1, sy+one, SRCCOPY);
74 BitBlt(hdc, x+__cardwidth-2, y+one, 1, height-one*tips, __hdcCardBitmaps, sx+__cardwidth-2, sy+one, SRCCOPY);
75
76 //if(height <= 2) return;
77
78 // draw the outer-most lips
79 BitBlt(hdc, x, y+two, 1, height-two*tips, __hdcCardBitmaps, sx, sy+two, SRCCOPY);
80 BitBlt(hdc, x+__cardwidth-1, y+two, 1, height-two*tips, __hdcCardBitmaps, sx+__cardwidth-1, sy+two, SRCCOPY);
81 }
82
83 //
84 // Draw a shape like this:
85 //
86 // +++
87 // +++
88 // +++
89 // +++
90 // +++
91 // +++
92 // +++
93 // +++
94 // +++
95 // +++
96 //
97 //
98 void DrawVertCardStrip(HDC hdc, int x, int y, int nCardNum, int width, BOOL fDrawTips)
99 {
100 int sx = nCardNum * __cardwidth;
101 int sy = 0;
102 int one = 1;
103 int two = 2;
104 BOOL tips = fDrawTips ? FALSE : TRUE;
105
106 if(width == 0) return;
107
108
109 if(width < 0)
110 {
111 sx = sx + __cardwidth;
112 x -= width;
113 one = -1;
114 two = -2;
115 }
116
117 // draw the main vertical band
118 //
119 BitBlt(hdc, x, y + 2, width, __cardheight - 4, __hdcCardBitmaps, sx, sy+2, SRCCOPY);
120
121 //if(width <= 1) return;
122
123 // draw the "lips" at the top and bottom
124 BitBlt(hdc, x+one, y+1, width-one*tips, 1, __hdcCardBitmaps, sx+one, sy + 1, SRCCOPY);
125 BitBlt(hdc, x+one, y+__cardheight-2, width-one*tips, 1, __hdcCardBitmaps, sx+one, sy + __cardheight-2, SRCCOPY);
126
127 //if(width <= 2) return;
128
129 // draw the outer-most lips
130 BitBlt(hdc, x+two, y, width-two*tips, 1, __hdcCardBitmaps, sx+two, sy, SRCCOPY);
131 BitBlt(hdc, x+two, y+__cardheight-1, width-two*tips, 1, __hdcCardBitmaps, sx+two, sy + __cardheight-1, SRCCOPY);
132 }
133
134 //
135 // xdir - <0 or >0
136 // ydir - <0 or >0
137 //
138 void DrawCardCorner(HDC hdc, int x, int y, int cardval, int xdir, int ydir)
139 {
140 int sx = cardval * __cardwidth;
141 int sy = 0;
142
143 HDC hdcSource = __hdcCardBitmaps;
144
145 if(xdir < 0)
146 {
147 x += __cardwidth + xdir - 1;
148 sx += __cardwidth + xdir - 1;
149 }
150 else
151 {
152 x += xdir;
153 sx += xdir;
154 }
155
156 if(ydir < 0)
157 {
158 y += __cardheight + ydir - 1;
159 sy += __cardheight + ydir - 1;
160 }
161 else
162 {
163 y += ydir;
164 sy += ydir;
165 }
166
167 //convert x,y directions to -1, +1
168 xdir = xdir < 0 ? -1 : 1;
169 ydir = ydir < 0 ? -1 : 1;
170
171 SetPixel(hdc, x+xdir, y , GetPixel(hdcSource, sx+xdir, sy));
172 SetPixel(hdc, x, y, GetPixel(hdcSource, sx, sy));
173 SetPixel(hdc, x, y+ydir, GetPixel(hdcSource, sx, sy+ydir));
174
175 }
176
177 //
178 // Draw a card (i.e. miss out the corners)
179 //
180 void DrawCard(HDC hdc, int x, int y, HDC hdcDragCard, int width, int height)
181 {
182 //draw main center band
183 BitBlt(hdc, x+2, y, width - 4, height, hdcDragCard, 2, 0, SRCCOPY);
184
185 //draw the two bits to the left
186 BitBlt(hdc, x, y+2, 1, height - 4, hdcDragCard, 0, 2, SRCCOPY);
187 BitBlt(hdc, x+1, y+1, 1, height - 2, hdcDragCard, 1, 1, SRCCOPY);
188
189 //draw the two bits to the right
190 BitBlt(hdc, x+width-2, y+1, 1, height - 2, hdcDragCard, width-2, 1, SRCCOPY);
191 BitBlt(hdc, x+width-1, y+2, 1, height - 4, hdcDragCard, width-1, 2, SRCCOPY);
192 }
193
194 //
195 // Clip a card SHAPE - basically any rectangle
196 // with rounded corners
197 //
198 int ClipCard(HDC hdc, int x, int y, int width, int height)
199 {
200 ExcludeClipRect(hdc, x+2, y, x+2+width-4, y+ height);
201 ExcludeClipRect(hdc, x, y+2, x+1, y+2+height-4);
202 ExcludeClipRect(hdc, x+1, y+1, x+2, y+1+height-2);
203 ExcludeClipRect(hdc, x+width-2, y+1, x+width-2+1, y+1+height-2);
204 ExcludeClipRect(hdc, x+width-1, y+2, x+width-1+1, y+2+height-4);
205 return 0;
206 }
207
208 void CardRegion::Clip(HDC hdc)
209 {
210 int numtoclip;
211
212 if(fVisible == false)
213 return;
214
215 Update(); //Update this stack's size+card count
216 numtoclip = nNumApparentCards;
217
218 //if we are making this stack flash on/off, then only
219 //clip the stack for drawing if the flash is in its ON state
220 if(nFlashCount != 0)
221 {
222 if(fFlashVisible == FALSE)
223 numtoclip = 0;
224 }
225
226 //if offset along a diagonal
227 if(xoffset != 0 && yoffset != 0 && cardstack.NumCards() != 0)
228 {
229 for(int j = 0; j < numtoclip; j ++)
230 {
231 ClipCard(hdc, xpos + xoffset * j, ypos + yoffset * j, __cardwidth, __cardheight);
232 }
233 }
234 //otherwise if just offset along a horizontal/vertical axis
235 else
236 {
237 if(yoffset < 0 && numtoclip > 0)
238 {
239 ClipCard(hdc, xpos, ypos-((numtoclip-1)*-yoffset), width, height);
240 }
241 else if(xoffset < 0 && numtoclip > 0)
242 {
243 ClipCard(hdc, xpos-((numtoclip-1)*-xoffset), ypos, width, height);
244 }
245 else
246 {
247 ClipCard(hdc, xpos, ypos, width, height);
248 }
249 }
250
251 }
252
253 void CardRegion::Render(HDC hdc)
254 {
255 int cardnum = 0;
256 int numtodraw;
257 BOOL fDrawTips;
258
259 Update(); //Update this stack's card count + size
260
261 numtodraw = nNumApparentCards;
262
263 if(nFlashCount != 0)
264 {
265 if(fFlashVisible == false)
266 numtodraw = 0;
267 }
268
269 if(fVisible == 0) return;
270
271 cardnum = cardstack.NumCards() - numtodraw;
272 int counter;
273
274 for(counter = 0; counter < numtodraw; counter++)
275 {
276 int cardval;
277
278 int x = xoffset * counter + xpos;
279 int y = yoffset * counter + ypos;
280
281 //if about to draw last card, then actually draw the top card
282 if(counter == numtodraw - 1) cardnum = cardstack.NumCards() - 1;
283
284 Card card = cardstack.cardlist[cardnum];
285 cardval = card.Idx();
286
287 if(card.FaceDown())
288 cardval = nBackCardIdx; //card-back
289
290 //only draw the visible part of the card
291 if(counter < numtodraw - 1)
292 {
293 if(yoffset != 0 && xoffset != 0)
294 fDrawTips = FALSE;
295 else
296 fDrawTips = TRUE;
297
298 if((yoffset != 0 && abs(xoffset) == 1) || (xoffset != 0 && abs(yoffset) == 1))
299 fDrawTips = TRUE;
300
301 //draw horizontal strips
302 if(yoffset > 0)
303 {
304 DrawHorzCardStrip(hdc, x, y, cardval, yoffset, fDrawTips);
305 }
306 else if(yoffset < 0)
307 {
308 DrawHorzCardStrip(hdc, x, y+__cardheight+yoffset, cardval, yoffset, fDrawTips);
309 }
310
311 //draw some vertical bars
312 if(xoffset > 0)
313 {
314 DrawVertCardStrip(hdc, x, y, cardval, xoffset, fDrawTips);
315 }
316 else if(xoffset < 0)
317 {
318 DrawVertCardStrip(hdc, x+__cardwidth+xoffset, y, cardval, xoffset, fDrawTips);
319 }
320
321 if(yoffset != 0 && xoffset != 0)//fDrawTips == FALSE)
322 {
323 //if we didn't draw any tips, then this is a 2-dim stack
324 //(i.e, it goes at a diagonal).
325 //in this case, we need to fill in the small triangle in
326 //each corner!
327 DrawCardCorner(hdc, x, y, cardval, xoffset, yoffset);
328 }
329 }
330 //if the top card, draw the whole thing
331 else
332 {
333 CardBlt(hdc, x, y, cardval);
334 }
335
336 cardnum ++;
337
338 } //end of index
339
340 if(counter == 0) //if the cardstack is empty, then draw it that way
341 {
342 int x = xpos;
343 int y = ypos;
344
345 switch(uEmptyImage)
346 {
347 default:
348 case CS_EI_NONE:
349 //this wipes the RECT variable, so watch out!
350 //SetRect(&rect, x, y, x+__cardwidth, y+__cardheight);
351 //PaintRect(hdc, &rect, MAKE_PALETTERGB(crBackgnd));
352 parentWnd.PaintCardRgn(hdc, x, y, __cardwidth, __cardheight, x, y);
353 break;
354
355 case CS_EI_SUNK:
356 DrawCard(hdc, x, y, __hdcPlaceHolder, __cardwidth, __cardheight);
357 break;
358
359 case CS_EI_CIRC:
360 case CS_EI_X:
361 CardBlt(hdc, x, y, uEmptyImage);
362 break;
363 }
364
365 }
366
367 return;
368 }
369
370 int calc_offset(int offset, int numcards, int numtodrag, int realvisible)
371 {
372 if(offset >= 0)
373 return -offset * numcards;
374 else
375 return -offset * (numtodrag) +
376 -offset * (realvisible - 1);
377 }
378
379 void CardRegion::PrepareDragBitmaps(int numtodrag)
380 {
381 RECT rect;
382 HDC hdc;
383 int icard;
384 int numcards = cardstack.NumCards();
385 int xoff, yoff;
386
387 if(nThreedCount > 1)
388 {
389 PrepareDragBitmapsThreed(numtodrag);
390 return;
391 }
392
393 //work out how big the bitmaps need to be
394 nDragCardWidth = (numtodrag - 1) * abs(xoffset) + __cardwidth;
395 nDragCardHeight = (numtodrag - 1) * abs(yoffset) + __cardheight;
396
397 //Create bitmap for the back-buffer
398 hdc = GetDC(NULL);
399 hdcBackGnd = CreateCompatibleDC(hdc);
400 hbmBackGnd = CreateCompatibleBitmap(hdc, nDragCardWidth, nDragCardHeight);
401 SelectObject(hdcBackGnd, hbmBackGnd);
402
403 //Create bitmap for the drag-image
404 hdcDragCard = CreateCompatibleDC(hdc);
405 hbmDragCard = CreateCompatibleBitmap(hdc, nDragCardWidth, nDragCardHeight);
406 SelectObject(hdcDragCard, hbmDragCard);
407 ReleaseDC(NULL, hdc);
408
409 UseNicePalette(hdcBackGnd, __hPalette);
410 UseNicePalette(hdcDragCard, __hPalette);
411
412 int realvisible = numcards / nThreedCount;
413
414 //if(numcards > 0 && realvisible == 0) realvisible = 1;
415 int iwhichcard = numcards - 1;
416 if(nThreedCount == 1) iwhichcard = 0;
417
418 //grab the first bit of background so we can prep the back buffer; do this by
419 //rendering the card stack (minus the card we are dragging) to the temporary
420 //background buffer, so it appears if we have lifted the card from the stack
421 //PaintRect(hdcBackGnd, &rect, crBackgnd);
422 SetRect(&rect, 0, 0, nDragCardWidth, nDragCardHeight);
423
424 xoff = calc_offset(xoffset, numcards, numtodrag, realvisible);
425 yoff = calc_offset(yoffset, numcards, numtodrag, realvisible);
426
427 parentWnd.PaintCardRgn(hdcBackGnd, 0, 0, nDragCardWidth, nDragCardHeight, xpos - xoff, ypos - yoff);
428
429 //
430 // Render the cardstack into the back-buffer. The stack
431 // has already had the dragcards removed, so just draw
432 // what is left
433 //
434 for(icard = 0; icard < realvisible; icard++)
435 {
436 Card card = cardstack.cardlist[iwhichcard];
437 int nCardVal;
438
439 nCardVal = card.FaceUp() ? card.Idx() : nBackCardIdx;
440
441 xoff = xoffset * icard + calc_offset(xoffset, numcards, numtodrag, realvisible);//- xoffset * ((numcards+numtodrag) / nThreedCount - numtodrag);
442 yoff = yoffset * icard + calc_offset(yoffset, numcards, numtodrag, realvisible);//- yoffset * ((numcards+numtodrag) / nThreedCount - numtodrag);
443
444 CardBlt(hdcBackGnd, xoff, yoff, nCardVal);
445 iwhichcard++;
446 }
447
448 //
449 // If there are no cards under this one, just draw the place holder
450 //
451 if(numcards == 0)
452 {
453 int xoff = 0, yoff = 0;
454
455 if(xoffset < 0) xoff = nDragCardWidth - __cardwidth;
456 if(yoffset < 0) yoff = nDragCardHeight - __cardheight;
457
458 switch(uEmptyImage)
459 {
460 case CS_EI_NONE:
461 //No need to draw anything: We already cleared the
462 //back-buffer before the main loop..
463
464 //SetRect(&rc, xoff, yoff, xoff+ __cardwidth, yoff + __cardheight);
465 //PaintRect(hdcBackGnd, &rc, MAKE_PALETTERGB(crBackgnd));
466 //parentWnd.PaintCardRgn(hdcBackGnd, xoff, yoff, __cardwidth, __cardheight, xpos, ypos);// + xoff, ypos + yoff);
467 break;
468
469 case CS_EI_SUNK:
470 DrawCard(hdcBackGnd, xoff, yoff, __hdcPlaceHolder, __cardwidth, __cardheight);
471 break;
472
473 case CS_EI_CIRC:
474 case CS_EI_X:
475 CardBlt(hdc, xoff, yoff, uEmptyImage);
476 break;
477 }
478 }
479
480 //
481 // now render the drag-cards into the dragcard image
482 //
483 PaintRect(hdcDragCard, &rect, crBackgnd);
484
485 for(icard = 0; icard < numtodrag; icard++)
486 {
487 int nCardVal;
488
489 if(xoffset >= 0) xoff = xoffset * icard;
490 else xoff = -xoffset * (numtodrag - icard - 1);
491
492 if(yoffset >= 0) yoff = yoffset * icard;
493 else yoff = -yoffset * (numtodrag - icard - 1);
494
495 Card card = dragstack.cardlist[icard];
496
497 nCardVal = card.FaceUp() ? card.Idx() : nBackCardIdx;
498
499 CardBlt(hdcDragCard, xoff, yoff, nCardVal);
500 }
501 }
502
503 void CardRegion::PrepareDragBitmapsThreed(int numtodrag)
504 {
505 RECT rect;
506 HDC hdc;
507 int icard;
508 int numunder = 0;
509 int iwhichcard;
510
511 int numcards = cardstack.NumCards();
512
513 //work out how big the bitmaps need to be
514 nDragCardWidth = (numtodrag - 1) * abs(xoffset) + __cardwidth;
515 nDragCardHeight = (numtodrag - 1) * abs(yoffset) + __cardheight;
516
517 //Create bitmap for the back-buffer
518 hdc = GetDC(NULL);
519 hdcBackGnd = CreateCompatibleDC(hdc);
520 hbmBackGnd = CreateCompatibleBitmap(hdc, nDragCardWidth, nDragCardHeight);
521 SelectObject(hdcBackGnd, hbmBackGnd);
522
523 //create bitmap for the drag-image
524 hdcDragCard = CreateCompatibleDC(hdc);
525 hbmDragCard = CreateCompatibleBitmap(hdc, nDragCardWidth, nDragCardHeight);
526 SelectObject(hdcDragCard, hbmDragCard);
527 ReleaseDC(NULL, hdc);
528
529 UseNicePalette(hdcBackGnd, __hPalette);
530 UseNicePalette(hdcDragCard, __hPalette);
531
532 //grab the first bit of background so we can prep the back buffer; do this by
533 //rendering the card stack (minus the card we are dragging) to the temporary
534 //background buffer, so it appears if we have lifted the card from the stack
535 //--SetRect(&rect, 0, 0, nDragCardWidth, nDragCardHeight);
536 //--PaintRect(hdcBackGnd, &rect, crBackgnd);
537
538 int threedadjust = numcards % nThreedCount == 0;
539
540 numunder = CalcApparentCards(numcards);
541 iwhichcard = (numcards+numtodrag) - numunder - 1;
542 if(nThreedCount == 1) iwhichcard = 0;
543
544 int xoff = calc_offset(xoffset, numunder, numtodrag, numunder);
545 int yoff = calc_offset(yoffset, numunder, numtodrag, numunder);
546
547 parentWnd.PaintCardRgn(hdcBackGnd, 0,0, nDragCardWidth,nDragCardHeight, xpos - xoff,ypos - yoff);
548
549 //
550 // Render the cardstack into the back-buffer. The stack
551 // has already had the dragcards removed, so just draw
552 // what is left
553 //
554 for(icard = 0; icard < numunder; icard++)
555 {
556 Card card = cardstack.cardlist[iwhichcard];
557 int nCardVal = card.FaceUp() ? card.Idx() : nBackCardIdx;
558
559 CardBlt(hdcBackGnd,
560 xoffset * icard - xoffset*(numunder-numtodrag+threedadjust),
561 yoffset * icard - yoffset*(numunder-numtodrag+threedadjust),
562 nCardVal);
563
564 iwhichcard++;
565 }
566
567 //
568 // If there are no cards under this one, just draw the place holder
569 //
570 if(numcards == 0)
571 {
572 switch(uEmptyImage)
573 {
574 case CS_EI_NONE:
575 //no need! we've already cleared the whole
576 //back-buffer before the main loop!
577 //SetRect(&rect, 0, 0, __cardwidth, __cardheight);
578 //PaintRect(hdcBackGnd, &rect, MAKE_PALETTERGB(crBackgnd));
579 break;
580
581 case CS_EI_SUNK:
582 DrawCard(hdcBackGnd, 0, 0, __hdcPlaceHolder, __cardwidth, __cardheight);
583 break;
584
585 case CS_EI_CIRC:
586 case CS_EI_X:
587 CardBlt(hdc, 0, 0, uEmptyImage);
588 break;
589 }
590 }
591
592 //
593 // now render the drag-cards into the dragcard image
594 //
595 PaintRect(hdcDragCard, &rect, crBackgnd);
596
597 for(icard = 0; icard < numtodrag; icard++)
598 {
599 Card card = dragstack.cardlist[icard];
600 int nCardVal = card.FaceUp() ? card.Idx() : nBackCardIdx;
601
602 CardBlt(hdcDragCard, xoffset * icard, yoffset * icard, nCardVal);
603 }
604 }
605
606 void CardRegion::ReleaseDragBitmaps(void)
607 {
608 //SelectObject(hdcBackGnd, hOld1);
609 DeleteObject(hbmBackGnd);
610 DeleteDC(hdcBackGnd);
611
612 //SelectObject(hdcDragCard, hOld2);
613 DeleteObject(hbmDragCard);
614 DeleteDC(hdcDragCard);
615 }
616
617
618 void CardRegion::Redraw()
619 {
620 HDC hdc = GetDC((HWND)parentWnd);
621
622 Update();
623 Render(hdc);
624
625 ReleaseDC((HWND)parentWnd, hdc);
626 }