home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / activexcontrol / basectl / card / carddraw.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-04  |  7.9 KB  |  272 lines
  1. //=--------------------------------------------------------------------------=
  2. // CardDraw.Cpp
  3. //=--------------------------------------------------------------------------=
  4. // Copyright  1996-1997  Microsoft Corporation.  All Rights Reserved.
  5. //
  6. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
  7. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
  8. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
  9. // PARTICULAR PURPOSE.
  10. //=--------------------------------------------------------------------------=
  11. //
  12. //
  13.  
  14. #include <windows.h>
  15.  
  16. extern HINSTANCE g_hInstance;
  17.  
  18. #include "Resource.H"
  19. #include "carddraw.h"
  20.  
  21. const POINT CCardDraw::CardBorder[9] = 
  22.         { { 0, 2 }, { 2, 0 }, 
  23.           { CardSizeX-3, 0 }, 
  24.           { CardSizeX-1, 2 }, 
  25.           { CardSizeX-1, CardSizeY-3 },
  26.           { CardSizeX-3, CardSizeY-1 }, 
  27.           { 2, CardSizeY-1 },
  28.           { 0, CardSizeY-3 }, { 0, 2 } };
  29.  
  30. const RECT CCardDraw::CardRect = { 0, 0, CardSizeX, CardSizeY };
  31.  
  32. CCardDraw::CCardDraw( int number )
  33. {
  34.     symsDc = symsiDc = centerDc = jokerDc = NULL;
  35.  
  36.     // Symbols bitmaps, used by all cards
  37.     if( number != DrawBack )
  38.     {
  39.         symsDc = CreateCompatibleDC( NULL );
  40.         symsMem = (HBITMAP) SelectObject( symsDc, 
  41.             LoadBitmap( g_hInstance, MAKEINTRESOURCE(IDB_SYMS) ) );
  42.         symsiDc = CreateCompatibleDC( symsDc );
  43.         symsiMem = (HBITMAP) SelectObject( symsiDc,
  44.             CreateCompatibleBitmap( symsiDc, SymsSizeX, SymsSizeY ) );
  45.         StretchBlt( symsiDc, SymsSizeX-1, SymsSizeY-1, -SymsSizeX, -SymsSizeY,
  46.             symsDc, 0, 0, SymsSizeX, SymsSizeY, SRCCOPY );
  47.     }
  48.  
  49.     // faces, used > 10
  50.     if( number > 10 && number != 14 ) 
  51.     {
  52.         centerDc = CreateCompatibleDC( NULL );
  53.         centerMem = (HBITMAP) SelectObject( centerDc, 
  54.             LoadBitmap( g_hInstance, MAKEINTRESOURCE(IDB_FACES)) );
  55.     }
  56.  
  57.     // joker
  58.     if( number >= 14 )
  59.     {    
  60.         jokerDc = CreateCompatibleDC( NULL );
  61.         jokerMem = (HBITMAP) SelectObject( jokerDc,
  62.              LoadBitmap( g_hInstance, MAKEINTRESOURCE(IDB_JOKER) ) );
  63.     }
  64. }
  65.  
  66. CCardDraw::~CCardDraw()
  67. {
  68.     HBITMAP tempMem;
  69.  
  70. #define freeDc( s ) \
  71.        if( s##Dc ) \
  72.       { tempMem = (HBITMAP) SelectObject( s##Dc, s##Mem ); \
  73.         DeleteObject( tempMem ); \
  74.         DeleteDC( s##Dc ); }
  75.  
  76.     freeDc( syms );
  77.     freeDc( symsi );
  78.     freeDc( joker );
  79.     freeDc( center );
  80.  
  81. #undef freeDc
  82. }
  83.     
  84. BOOL CCardDraw::DrawCard( HDC hdcMem, int suite, int number )
  85. {
  86.     int LocX, LocY;
  87.  
  88.     const static struct { unsigned char x, y; } LargeSymLoc[10][10] = 
  89.     { { {29,42} },
  90.       { {29,11}, {29,86} },
  91.       { {29,11}, {29,42}, {29,86} },
  92.       { {16,11}, {42,11}, {16,86}, {42,86} },
  93.       { {16,11}, {42,11}, {16,86}, {42,86}, {29,42} },
  94.       { {16,11}, {42,11}, {16,86}, {42,86}, {16,42}, {42,42} },
  95.       { {16,11}, {42,11}, {16,86}, {42,86}, {16,42}, {42,42}, {29,26} },
  96.       { {16,11}, {42,11}, {16,86}, {42,86}, {16,32}, {42,32}, {16,65}, {42,65} },
  97.       { {16,11}, {42,11}, {16,86}, {42,86}, {16,32}, {42,32}, {16,65}, {42,65}, {29,42} },
  98.       { {16,11}, {42,11}, {16,86}, {42,86}, {16,32}, {42,32}, {16,65}, {42,65}, {29,21}, {29,76} } };
  99.  
  100.     const static signed char LargeSymLoc9[] = { -2, -2, 3, 0 };
  101.  
  102. // Macros for working with the Sym DC's
  103. #define SymBitBltTop( x, y, dx, dy, sx, sy, copy ) \
  104.     BitBlt( hdcMem, x, y, dx, dy, symsDc, sx, sy, copy );
  105. #define SymBitBltBottom( x,y, dx, dy, sx, sy, copy ) \
  106.     BitBlt( hdcMem, CardSizeX - (x) - (dx), CardSizeY - (y) - (dy), \
  107.         dx, dy, symsiDc,    \
  108.         SymsSizeX - (sx) - (dx), SymsSizeY - (sy) - (dy), copy );
  109. #define SymBitBlt( x, y, dx, dy, sx, sy, copy ) \
  110.     { SymBitBltTop( x, y, dx, dy, sx, sy, copy ); \
  111.       SymBitBltBottom( x, y, dx, dy, sx, sy, copy ); }
  112. #define SymBitBltBottomNoTransX( x,y, dx, dy, sx, sy, copy ) \
  113.     BitBlt( hdcMem, x, y - (dy), \
  114.         dx, dy, symsiDc,    \
  115.         SymsSizeX - (sx) - (dx), SymsSizeY - (sy) - (dy), copy );
  116.  
  117.     if( suite < 0 ) 
  118.         return( DrawCardBack( hdcMem, -suite ) );
  119.  
  120.     // white middle
  121.     FillRect( hdcMem, &CardRect, (HBRUSH)GetStockObject(WHITE_BRUSH) );
  122.  
  123.     // set background color for monochrome bitmap blt's
  124.     SetTextColor( hdcMem, RGB((suite >= 3 ? 255:0),0,0) );
  125.  
  126.     // Joker
  127.     if( number == 14 )
  128.     {
  129.         static const RECT JokerCornerRect = 
  130.             { JokerCornerRectSX, JokerCornerRectSY,
  131.               CardSizeX - JokerCornerRectEX, CardSizeY - JokerCornerRectEY };
  132.  
  133.         SymBitBlt( JokerCornerX, JokerCornerY,
  134.                JokerCornerSizeX, JokerCornerSizeY, 
  135.                JokerCornerSrcX, JokerCornerSrcY, SRCCOPY );
  136.  
  137.         FillRect( hdcMem, &JokerCornerRect, 
  138.               (HBRUSH)GetStockObject(WHITE_BRUSH) );
  139.  
  140.         BitBlt( hdcMem, JokerX, JokerY,    JokerSizeX, JokerSizeY,
  141.                        jokerDc, 0, 0, SRCCOPY) ;
  142.     }
  143.  
  144.     if( number < 14 ) 
  145.     {                
  146.         long SrcY, SrcX;
  147.  
  148.         // fill number
  149.         LocX = (number > 10 ? 2 : 3 );
  150.         SrcY = (number & 0x8 ? NumberSizeY : 0);
  151.         SrcX = (number & 0x8 ? (number-8) : (number-1));
  152.         SymBitBlt( LocX, NumberY, 
  153.                NumberSizeX, 
  154.                NumberSizeY + ((number & 0x8) >> 2),
  155.                NumberSrcX + SrcX * NumberSizeX,
  156.                NumberSrcY + SrcY,
  157.                SRCCOPY );
  158.  
  159.         // Small symbols
  160.         SymBitBlt( LocX, SmallSymY,
  161.              SmallSymSizeX, SmallSymSizeY,
  162.              SmallSymSrcX + (suite-1) * SmallSymSizeX,
  163.              SmallSymSrcY, SRCCOPY );
  164.     }
  165.  
  166.     // center of card, symbols
  167.     if( number <= 10 )
  168.     {
  169.         for( int i = 0; i < number; i++ )
  170.         {
  171.             LocX = LargeSymLoc[number-1][i].x;
  172.             LocY = LargeSymLoc[number-1][i].y;
  173.             if( number == 9 && i == 8 )    // adjustment for 9
  174.                 LocY += LargeSymLoc9[suite-1];
  175.             if( LocY <= CardSizeY/2 ) 
  176.             {
  177.                 SymBitBltTop( LocX, LocY-1,
  178.                     LargeSymSizeX, LargeSymSizeY,
  179.                     LargeSymSrcX + (4-suite)*LargeSymSizeX,
  180.                     LargeSymSrcY, SRCAND );
  181.             }
  182.             else
  183.             {
  184.                 SymBitBltBottomNoTransX( LocX, LocY,
  185.                     LargeSymSizeX, LargeSymSizeY,
  186.                     LargeSymSrcX + (4-suite)*LargeSymSizeX,
  187.                     LargeSymSrcY, SRCAND );
  188.             }
  189.         }
  190.     }
  191.  
  192.     // center of card, face
  193.     if( number > 10 && number < 14 )
  194.     {
  195.         HPEN oldPen;
  196.         static const POINT centerBorder[] = 
  197.             { { PictX, PictY }, { PictX, PictY+PictSizeY+1 },
  198.               { PictX+PictSizeX+1, PictY+PictSizeY+1 },
  199.               { PictX+PictSizeX+1, PictY }, { PictX, PictY } };
  200.  
  201.         BitBlt( hdcMem, PictX+1, PictY+1, 
  202.                     PictSizeX, PictSizeY/2,
  203.                     centerDc,
  204.                     (number-11)*PictSizeX,
  205.                     (suite-1)*PictSizeY/2,
  206.                     SRCCOPY) ;
  207.         StretchBlt( hdcMem, PictX+PictSizeX, PictY+PictSizeY,
  208.             -PictSizeX, -PictSizeY/2,
  209.             centerDc,
  210.                     (number-11)*PictSizeX,
  211.                     (suite-1)*PictSizeY/2,
  212.             PictSizeX, PictSizeY/2, SRCCOPY );
  213.         oldPen = (HPEN) SelectObject( hdcMem, GetStockObject( BLACK_PEN ) );
  214.         Polyline( hdcMem, centerBorder, sizeof(centerBorder)/sizeof(POINT) );
  215.         SelectObject( hdcMem, oldPen );
  216.     }
  217.  
  218.     return( TRUE );
  219. }
  220.  
  221. BOOL CCardDraw::DrawCardBack( HDC hdcMem, int backnum )
  222. {
  223.     if( backnum >= 1 && backnum <= 12 )
  224.     {
  225.         HDC backDc;
  226.         HBITMAP backMem;
  227.         if( !(backDc = CreateCompatibleDC( NULL )) )
  228.             return( FALSE );
  229.         if( !(backMem = (HBITMAP) SelectObject( backDc,
  230.                 LoadBitmap( g_hInstance,
  231.                     MAKEINTRESOURCE(backnum+IDB_BACKBASE)))) )
  232.         {
  233.             DeleteDC( backDc );
  234.             return( FALSE );
  235.         }
  236.         BitBlt( hdcMem, 1, 1, CardSizeX-2, CardSizeY-2,
  237.                  backDc, 0, 0, SRCCOPY );
  238.         DeleteObject( backMem );
  239.         DeleteDC( backDc );
  240.     }
  241.     else
  242.     {
  243.         FillRect( hdcMem, &CardRect, 
  244.               (HBRUSH)GetStockObject(WHITE_BRUSH) );
  245.  
  246.         for( int x = 1; x < CardSizeX-1; x++ )
  247.             for( int y = 1; y < CardSizeY-1; y++ )
  248.             if( ((x+y-2) & 3) < 2 ) 
  249.                 SetPixelV( hdcMem, x, y, RGB( 0,0,128 ) );
  250.     }
  251.  
  252.     return( TRUE );
  253. }
  254.  
  255. HBITMAP CCardDraw::CreateDIBCard( HDC drawDc )
  256. {
  257.     void *bits;
  258.     static struct {
  259.         BITMAPINFOHEADER bi;
  260.         long colors[16];
  261.     } b = { { sizeof(b.bi), 
  262.           (((CardSizeX + 3)>>2)<<2),
  263.           CardSizeY, 1, 4, BI_RGB, 0, 0, 0, 16, 16 },
  264.         { 0x000000, 0x800000, 0x008000, 0x808000,
  265.           0x000080, 0x800080, 0x808080, 0xc0c0c0,
  266.           0x808080, 0xff0000, 0x00ff00, 0xffff00,
  267.               0x0000ff, 0xff00ff, 0x00ffff, 0xffffff } };
  268.  
  269.     return CreateDIBSection( drawDc, (BITMAPINFO *) &b,
  270.                  DIB_RGB_COLORS,     
  271.                  &bits, NULL, 0 );    
  272. }