home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / gdi / textfx / fx.c next >
C/C++ Source or Header  |  1997-10-05  |  13KB  |  321 lines
  1. /*****************************************************************************\
  2. *       This is a part of the Microsoft Source Code Samples.
  3. *       Copyright (C) 1992-1997 Microsoft Corporation.
  4. *       All rights reserved.
  5. *       This source code is only intended as a supplement to
  6. *       Microsoft Development Tools and/or WinHelp documentation.
  7. *       See these sources for detailed information regarding the
  8. *       Microsoft samples programs.
  9. \*****************************************************************************/
  10. /*****************************************************************************
  11.  *                                                                             *
  12.  *    FX.C                                                                      *
  13.  *                                                                             *
  14.  *    PURPOSE:  Routines for rendering text with stange effects                *
  15.  *                                                                             *
  16.  *                                                                             *
  17.  *    FillOut               - Converts an array of line segments into an array of *
  18.  *                       all the points in the segments                         *
  19.  *                                                                             *
  20.  *    RenderPathPoints   - Renders the outline of points returned from GetPath * 
  21.  *                                                                             *
  22.  *    RenderAndFillPath  - Renders the points returned from GetPath as a       *
  23.  *                       filled polygon                                         *
  24.  *                                                                             *
  25.  *    TextEffect         - Draws a string of text between two guide lines      *
  26.  *                                                                             *
  27.  *****************************************************************************/
  28.  
  29. #include <windows.h>
  30. #include "fx.h"
  31.  
  32. // This structure is used by FillOut for passing data into LineDDA
  33. typedef struct tagSEG {
  34.   DWORD dwPos;
  35.   LPPOINT lpPoints; 
  36. } PTS;
  37.  
  38. /**********************************************************************
  39.  *                                                                    *
  40.  * AddSegment - used with LineDDA to add points from a line segment   *
  41.  *    to an array containing all the points on a set of line segments *
  42.  *                                                                    *
  43.  *********************************************************************/
  44. VOID CALLBACK AddSegment(int x, int y, PTS *pts)
  45. {
  46.    pts->lpPoints[pts->dwPos].x = x;
  47.    pts->lpPoints[pts->dwPos].y = y;
  48.    pts->dwPos++;
  49. } 
  50.  
  51. /**********************************************************************
  52.  *                                                                    *
  53.  * CountPoints - used with LineDDA to determine the number of points  *
  54.  *    needed to store all the points on a set of line segments        *
  55.  *                                                                    *
  56.  *********************************************************************/
  57. VOID CALLBACK CountPoints(int x, int y, LPDWORD lpdwNumPts)
  58. {
  59.    (*lpdwNumPts)++;
  60.  
  61.    UNREFERENCED_PARAMETER(x);
  62.    UNREFERENCED_PARAMETER(y);
  63. } 
  64.  
  65.  
  66. /**********************************************************************
  67.  *                                                                    *
  68.  * FUNCTION:  FillOut(LPPOINT, LPDWORD)                               *
  69.  *                                                                      *
  70.  * PURPOSE:   Converts an array of line segments into an array of all *
  71.  *            of the points comprising the line segments.             *
  72.  *                                                                    *
  73.  *********************************************************************/
  74. BOOL FillOut(LPPOINT *lpPoints, LPDWORD lpdwNumPts)
  75. {
  76.    DWORD i;
  77.    LPPOINT lpPts = *lpPoints;
  78.    PTS pts;
  79.    DWORD dwNumPts = 0;
  80.  
  81.    // Make sure we have at least two points
  82.    if (*lpdwNumPts < 2) {
  83.      MessageBox(NULL, "You need at least two points for a guide line.", "Not enough points!", MB_ICONSTOP);
  84.      *lpdwNumPts = 0;
  85.      return FALSE;
  86.    }
  87.  
  88.    // Find out how namy points are on the segments
  89.    for (i=0; i<*lpdwNumPts - 1; i++) 
  90.      LineDDA(lpPts[i].x, lpPts[i].y, lpPts[i+1].x, lpPts[i+1].y, (LINEDDAPROC)CountPoints, (LPARAM)&dwNumPts);
  91.    
  92.    // If there are too many points, print an anoying message so the user doesnt do it again
  93.    if (dwNumPts > MAXFILLPOINTS) {
  94.      MessageBox(NULL, "Make your guide lines a bit shorter please!", "Too many points!", MB_ICONSTOP);
  95.      *lpdwNumPts = 0;
  96.      return FALSE;  // Bail
  97.    }
  98.    
  99.    // Allocate memory for the the points and initialize our "last point" index
  100.    pts.lpPoints = (LPPOINT)GlobalAlloc(GPTR, dwNumPts * sizeof(POINT));
  101.    pts.dwPos = 0;
  102.                                                                     
  103.    // Convert the segments to points
  104.    for (i=0; i<*lpdwNumPts - 1; i++) 
  105.      LineDDA(lpPts[i].x, lpPts[i].y, lpPts[i+1].x, lpPts[i+1].y, (LINEDDAPROC)AddSegment, (LPARAM)&pts);
  106.    
  107.    // Get rid of the original array of segments...
  108.    GlobalFree(lpPts);
  109.  
  110.    // ... and replace it with the new points
  111.    *lpPoints = pts.lpPoints;
  112.    *lpdwNumPts = pts.dwPos;
  113.    
  114.    // Check to see if anything hit the fan
  115.    if (!pts.dwPos)
  116.      return FALSE;
  117.  
  118.    return TRUE;  
  119. }
  120.  
  121. /**********************************************************************
  122.  *                                                                    *
  123.  * FUNCTION:  PolyDraw95(HDC, LPPOINT, LPBYTE, int)                   *
  124.  *                                                                      *
  125.  * PURPOSE:   Draws the points returned from a call to GetPath()      *
  126.  *            to an HDC                                               *
  127.  *                                                                    *
  128.  * NOTES:     This function is similar to the Windows NT function     *
  129.  *            PolyDraw which draws a set of line segments and BΘzier  *
  130.  *            curves.  Since PolyDraw is not supported on Windows 95  *
  131.  *            this PolyDraw95 is used instead.                        *  
  132.  *                                                                    *
  133.  *********************************************************************/
  134. BOOL PolyDraw95(HDC  hdc,              // handle of a device context 
  135.                 CONST LPPOINT lppt,       // address of array of points 
  136.                 CONST LPBYTE lpbTypes, // address of line and curve identifiers  
  137.                 int  cCount)            // count of points 
  138. {
  139.   int i;
  140.   
  141.   for (i=0; i<cCount; i++) 
  142.     switch (lpbTypes[i]) {
  143.       case PT_MOVETO : 
  144.          MoveToEx(hdc, lppt[i].x, lppt[i].y, NULL); 
  145.          break;
  146.       
  147.       case PT_LINETO | PT_CLOSEFIGURE:
  148.       case PT_LINETO : 
  149.          LineTo(hdc, lppt[i].x, lppt[i].y); 
  150.          break;
  151.       
  152.       case PT_BEZIERTO | PT_CLOSEFIGURE:
  153.       case PT_BEZIERTO :
  154.          PolyBezierTo(hdc, &lppt[i], 3);
  155.          i+=2;
  156.          break;
  157.    }
  158.  
  159.    return TRUE;
  160. }  
  161.  
  162.  
  163. /**********************************************************************
  164.  *                                                                    *
  165.  * FUNCTION:  RenderPathPoints(HDC, LPPOINT, LPBYTE, int, BOOL)          *
  166.  *                                                                      *
  167.  * PURPOSE:   Renders the points returned from a call to GetPath()    *
  168.  *            by converting them back into a path and calling either  *
  169.  *            FillPath or StrokePath to display them.                 *
  170.  *                                                                    *
  171.  * NOTE:      The R2_MERGEPENNOT is used here so that things like the *
  172.  *            inside of and "a" or an "o" get painted correctly when  *
  173.  *            using FillPath.                                         *
  174.  *                                                                    *
  175.  *********************************************************************/
  176. BOOL RenderPathPoints(HDC hDC, LPPOINT lpPoints, LPBYTE lpTypes, int iNumPts, BOOL bOutline)
  177. {
  178.   BeginPath(hDC); // Draw into a path so that we can use FillPath()
  179.  
  180.   PolyDraw95(hDC, lpPoints, lpTypes, iNumPts);
  181.  
  182.   CloseFigure(hDC);
  183.   EndPath(hDC);   
  184.  
  185.   // Draw the path
  186.   if (bOutline)  
  187.     StrokePath(hDC); // As an outline
  188.   else 
  189.       {              // As solid figures
  190.         int iROP2 = SetROP2(hDC, R2_MERGEPENNOT);
  191.         HPEN hPen = SelectObject(hDC, GetStockObject(NULL_PEN)); // Just say "no" to outlines
  192.         HBRUSH hBrush = SelectObject(hDC, GetStockObject(BLACK_BRUSH)); // Paint It Black
  193.  
  194.         FillPath(hDC);  
  195.  
  196.         // Restore the DC to its previous state
  197.         SetROP2(hDC, iROP2);        
  198.         SelectObject(hDC, hPen);
  199.         SelectObject(hDC, hBrush);
  200.       } 
  201.   
  202.   return TRUE;
  203. }
  204.  
  205.  
  206. /**********************************************************************
  207.  *                                                                    *
  208.  * FUNCTION:  GetRealTextExtent(LPPOINT, int, LPSIZE)                 *
  209.  *                                                                      *
  210.  * PURPOSE:   Makes sure that the extents in a SIZE are large enough  *
  211.  *            to bound the points in an array.                        *
  212.  *                                                                    *
  213.  * NOTES:     Why not just use GetTextExtentPoint32?  Well, the text  *
  214.  *            extents returned by GetTextExtentPoint32 dont include   *
  215.  *            the overhang of an italics character into the next      *
  216.  *            cell.  This function expands the extents to include     *
  217.  *            the greatest x, and y extents of the string data.       *
  218.  *                                                                    *
  219.  *********************************************************************/
  220. void GetRealTextExtent(LPPOINT lpPoints, int iNumPts, LPSIZE size)
  221. {
  222.   int i;
  223.  
  224.   for (i=0; i<iNumPts; i++) {
  225.     if (lpPoints[i].x > size->cx) size->cx = lpPoints[i].x;
  226.     if (lpPoints[i].y > size->cy) size->cy = lpPoints[i].y;
  227.   }
  228. }
  229.  
  230. /**********************************************************************
  231.  *                                                                    *
  232.  * FUNCTION:  TextEffect(HDC, LPPOINT, LPPOINT, DWORD, DWORD,         *
  233.  *                            LPSTR, BOOL)                            *
  234.  *                                                                      *
  235.  * PURPOSE:   Draws a string of text in the currently selected font   *
  236.  *            using two arrays of points as guide lines for orienting *
  237.  *            the text.  The text can be displayed either as outlines *
  238.  *            or as filled characters.                                *
  239.  *                                                                    *
  240.  *********************************************************************/
  241. BOOL TextEffect(HDC hDC,            // DC to display into
  242.                 LPPOINT lpTop,      // Top guide line
  243.                 LPPOINT lpBot,         // Bottom guide line
  244.                 DWORD dwTopPts,     // Number of points in top guide
  245.                 DWORD dwBotPts,     // Number of points in bottom guide
  246.                 LPSTR szText,         // Text string to apply effects to
  247.                 BOOL bOutlineOnly)  // Print as outline or as solid text
  248. {
  249.    LPPOINT lpPoints;          // Path data points
  250.    LPBYTE lpTypes;              // Path data types
  251.    int i, iNumPts;
  252.    SIZE size;                  // Text size info
  253.    float fXScale, fYScale;      // Scaling values
  254.    int iTopInd, iBotInd;      // Guide array indices
  255.  
  256.    // Set to transparent so we dont get an outline around the text string
  257.    SetBkMode(hDC, TRANSPARENT);
  258.       
  259.    // Output the text into a path
  260.    BeginPath(hDC);
  261.    TextOut(hDC, 0, 0, szText, strlen(szText));
  262.    EndPath(hDC);    
  263.       
  264.    // How many points are in the path
  265.    iNumPts = GetPath(hDC, NULL, NULL, 0);
  266.    if (iNumPts == -1) return FALSE;
  267.  
  268.    // Allocate room for the points
  269.    lpPoints = (LPPOINT)GlobalAlloc(GPTR, sizeof(POINT) * iNumPts);
  270.    if (!lpPoints) return FALSE;
  271.  
  272.    // Allocate room for the point types
  273.    lpTypes = GlobalAlloc(GPTR, iNumPts);
  274.    if (!lpTypes) {
  275.      GlobalFree(lpPoints);
  276.        return FALSE;
  277.    }
  278.    
  279.    // Get the points and types from the current path
  280.    iNumPts = GetPath(hDC, lpPoints, lpTypes, iNumPts);
  281.  
  282.    // Even more error checking
  283.    if (iNumPts == -1) {
  284.      GlobalFree(lpTypes);
  285.      GlobalFree(lpPoints);
  286.      return FALSE;
  287.    }
  288.    
  289.    //Get extents of the text string for scaling purposes  
  290.    GetTextExtentPoint32(hDC, szText, strlen(szText), &size);
  291.  
  292.    // OK, but lets make sure our extents are big enough (handle italics fonts)
  293.    GetRealTextExtent(lpPoints, iNumPts, &size);
  294.    
  295.    // Relocate the points in the path based on the guide lines
  296.    for (i=0; i < iNumPts; i++) {
  297.         // How far along is this point on the x-axis
  298.      fXScale = (float)lpPoints[i].x / (float)size.cx;
  299.  
  300.      // What point on the top guide does this coorespond to
  301.      iTopInd = (int)(fXScale * (dwTopPts-1));
  302.      // What point on the bottom guide does this coorespond to
  303.      iBotInd = (int)(fXScale * (dwBotPts-1));
  304.  
  305.      // How far along is this point on the y-axis
  306.      fYScale = (float)lpPoints[i].y / (float)size.cy;
  307.  
  308.      // Scale the points to their new locations
  309.      lpPoints[i].x = (int)((lpBot[iBotInd].x * fYScale) + (lpTop[iTopInd].x * (1.0f-fYScale)));
  310.      lpPoints[i].y = (int)((lpBot[iBotInd].y * fYScale) + (lpTop[iTopInd].y * (1.0f-fYScale)));
  311.    }
  312.  
  313.    // Draw the new path 
  314.    RenderPathPoints(hDC, lpPoints, lpTypes, iNumPts, bOutlineOnly);
  315.    
  316.    GlobalFree(lpPoints);
  317.    GlobalFree(lpTypes);
  318.  
  319.    return TRUE;
  320. }
  321.