Return to fontload.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / fontedit

Annotation of mstools/samples/sdktools/fontedit/fontload.c, revision 1.1

1.1     ! root        1: #include "windows.h"
        !             2: #include <windowsx.h>
        !             3: #include "fontedit.h"
        !             4: #include "fcntl.h"
        !             5: #include "memory.h"
        !             6: #include "stdio.h"
        !             7: #include "commdlg.h"
        !             8: 
        !             9: 
        !            10: /****************************************************************************/
        !            11: /*              Shared Variables                                            */
        !            12: /****************************************************************************/
        !            13: extern CHAR *PASCAL VerifyHeaderContents();/* checks integrity of header */
        !            14: 
        !            15: extern FontHeaderType font;             /* Structure of Font File Header */
        !            16: extern LONG lSizeOfOldGlyph20;          /* Old packed 2.0 glyph info size. */
        !            17: extern LONG lSizeOfOldGlyph30;                 /* Old packed 3.0 glyph info size. */
        !            18: extern LONG lSizeOfOldFontHeader;       /* Old packed font header size. */
        !            19: extern LONG lSizeOfOldFontHeader30;     /* Old 3.0 packed font header size. */
        !            20: extern CHAR szFaceName[];               /* Face Name of Font */
        !            21: extern DWORD offsets[];                 /* Offsets Table */
        !            22: 
        !            23: extern BOOL fReadOnly;
        !            24: extern BOOL fChanged;                   /* Note if we did anything */
        !            25: extern BOOL fLoaded;                    /* Set if a font is loaded */
        !            26: extern INT iFontFormatPrev;             /* Set to the id of prev.font format */
        !            27: extern INT iFontFormat;             /* Set to the id of current font format */
        !            28: 
        !            29: extern HWND hFont;                      /* Handle to Show window */
        !            30: extern HWND hBox;                       /* Handle to Edit Window */
        !            31: extern HDC hMemDC;                      /* Handle to Memory Display Context */
        !            32: extern HBITMAP hBitmap;                 /* Handle to our work bit map */
        !            33: extern CHAR matBox [wBoxLim] [kBoxLim]; /* array to hold Box */
        !            34: 
        !            35: extern CHAR *vrgsz[];                   /* string table */
        !            36: extern OFSTRUCT ofstrFile;
        !            37: extern BOOL NewFile;                    /* flag indicating if file was opened
        !            38:                                            by selecting NEW on menu */
        !            39: FontHeaderType fontBuffer;          /* temporary buffer of Font File Header */
        !            40: WORD cHeader, cTable;
        !            41: HFILE nNewFile;                          /* NT file handle */
        !            42: 
        !            43: 
        !            44: /****************************************************************************/
        !            45: /*              Local Variables                                             */
        !            46: /****************************************************************************/
        !            47: 
        !            48: DWORD Proport(DWORD, DWORD, DWORD, DWORD);  /* Reproportions a value */
        !            49: 
        !            50: CHAR  *lpFontBody = NULL;  /* Pointer to Font Body */
        !            51: CHAR  *lpWork = NULL;      /* Pointer to Work Area */
        !            52: HDC hNewMemDC;
        !            53: HDC hBoxMemDC;
        !            54: HBITMAP hNewBitmap;
        !            55: HBITMAP hBoxBitmap;
        !            56: HCURSOR hOldCursor = NULL;      /* Holds Arrow while we show Hourglass */
        !            57: HCURSOR hHourGlass = NULL;
        !            58: DWORD oldMode;                   /* For StretchBltMode */
        !            59: BYTE  *lp1,  *lp2;    /* Pointers to bitmaps in format N */
        !            60: 
        !            61: FontHeader30  font30;
        !            62: 
        !            63: #define ALPHA_CNT        26
        !            64: #define TOTAL_WEIGHTS  1000
        !            65: #define FSF_FIXED             0x0001
        !            66: #define FSF_PROPORTIONAL      0x0002
        !            67: 
        !            68: SHORT widthweights[ALPHA_CNT + 1] =
        !            69:         {
        !            70:                  64,        /* a
        !            71:                  14,        /* b     */
        !            72:                  27,        /* c     */
        !            73:                  35,        /* d     */
        !            74:                 100,        /* e     */
        !            75:                  20,        /* f     */
        !            76:                  14,        /* g     */
        !            77:                  42,        /* h     */
        !            78:                  63,        /* i     */
        !            79:                  3 ,        /* j     */
        !            80:                  6 ,        /* k     */
        !            81:                  35,        /* l     */
        !            82:                  20,        /* m     */
        !            83:                  56,        /* n     */
        !            84:                  56,        /* o     */
        !            85:                  17,        /* p     */
        !            86:                  4 ,        /* q     */
        !            87:                  49,        /* r     */
        !            88:                  56,        /* s     */
        !            89:                  71,        /* t     */
        !            90:                  31,        /* u     */
        !            91:                  10,        /* v     */
        !            92:                  18,        /* w     */
        !            93:                  3 ,        /* x     */
        !            94:                  18,        /* y     */
        !            95:                  2 ,        /* z     */
        !            96:                 166,        /* space, must be last, to use with the following
        !            97:                                code */
        !            98:         };
        !            99: 
        !           100: /****************************************************************************/
        !           101: /*              Local Functions                                             */
        !           102: /****************************************************************************/
        !           103: 
        !           104: VOID NewAverage(VOID);
        !           105: BOOL GetNewMap(DWORD, DWORD);
        !           106: VOID UseNewMap(VOID);
        !           107: VOID ShrinkFont(DWORD, DWORD);
        !           108: 
        !           109: /****************************************************************************
        !           110:  * WORD ConvertToBitmapFormat(width, phase, height)
        !           111:  *
        !           112:  * purpose  : Takes a part of the font file and converts it to a string of
        !           113:  *            bytes for a single scan of bitmap for a character.
        !           114:  *
        !           115:  * params   : WORD width : width of the character in pixels(bits)
        !           116:  *            WORD phase : current deviation from byte alignment (pixels)
        !           117:  *            WORD height: height of character(pixels)
        !           118:  *
        !           119:  * returns  : WORD phase : new deviation from byte alignment (pixels)
        !           120:  *
        !           121:  * side effects : modifies pointers lp1 and lp2 (pointing to work space and
        !           122:  *                font body respectively)
        !           123:  *
        !           124:  ****************************************************************************/
        !           125: DWORD PASCAL
        !           126: ConvertToBitmapFormat(
        !           127:      DWORD width,     /* width of the character in pixels(bits) */
        !           128:      DWORD phase,     /* current deviation from byte alignment (pixels) */
        !           129:      DWORD height     /* height of character(pixels) */
        !           130:      )
        !           131: {
        !           132:       INT w;
        !           133:       WORD j;
        !           134: 
        !           135:       /* in the font file format characters are stored consecutively in
        !           136:          column-major ordering (columns of char 1 followed by columns of char
        !           137:          2 ... etc.). lp2 points to start of columns of current character.
        !           138:          lp1 points to start of row of bitmap for character. */
        !           139: 
        !           140:       for (w = width; w > 0; w -= 8){
        !           141:           if (phase == 0){
        !           142:           /*  easy case */
        !           143:               *lp1++ = *lp2;
        !           144: 
        !           145:               if (w < 8)
        !           146:                   phase = w;
        !           147:           }
        !           148:           else{
        !           149: 
        !           150:               --lp1;
        !           151:               j = (WORD)*lp1;
        !           152:               j <<= 8;
        !           153:               j |= (((WORD)*lp2) << (8 - phase));
        !           154:               *lp1++ = (BYTE)(j >> 8);
        !           155:               *lp1++ = (BYTE)j;
        !           156:               if (w < 8){
        !           157:                   phase += w;
        !           158:                   if (phase <= 8)
        !           159:                       lp1--;          /* back up pointer */
        !           160:                   phase &= 7;
        !           161:               }
        !           162:           }
        !           163:           lp2 += height;          /* move to next column */
        !           164:       }
        !           165:       return phase;
        !           166: }
        !           167: 
        !           168: /****************************************************************************
        !           169:  * char * VerifyTableContents()
        !           170:  *
        !           171:  * purpose  : scan the offsets table of file just read and check if
        !           172:  *            width and offsets lie within limits
        !           173:  *
        !           174:  * params    : none
        !           175:  *
        !           176:  * returns   : char * szError : ptr to Error message if table not OK
        !           177:  *                              NULL otherwise
        !           178:  *
        !           179:  * side effects : none
        !           180:  *
        !           181:  ****************************************************************************/
        !           182: CHAR * PASCAL
        !           183: VerifyTableContents(
        !           184:     VOID
        !           185:     )
        !           186: {
        !           187:         PBYTE            pjGlyphData;
        !           188:      GLYPHINFO_20 gi2T20;        /* temp ptr to a 2.0 style table*/
        !           189:      GLYPHINFO_30 gi3T30;        /* temp ptr to a 2.0 style table*/
        !           190:      INT i;
        !           191: 
        !           192:      /* separate loops written for the 2.0 and 3.0 font processing because
        !           193:         a single loop would involve too many checks (of font type) within
        !           194:         the loop and slow down processing  */
        !           195:      if (iFontFormat == ID_FORMAT2){
        !           196:          pjGlyphData = (lpFontBody +1);
        !           197: 
        !           198:                /* view table as 2.0 table */
        !           199: 
        !           200:          /* check that each and every width and offset lie within limits */
        !           201: 
        !           202:          for (i=0; i < (fontBuffer.LastChar - fontBuffer.FirstChar + 1); i++) {
        !           203: 
        !           204:                          vGlyphInfo20FromBuffer (pjGlyphData, &gi2T20);
        !           205: 
        !           206:               if (gi2T20.GIwidth > 64)
        !           207:                   return vszTableWidthsBad;
        !           208: 
        !           209:               if ((gi2T20.GIoffset > (UINT)WORD_LIMIT) ||
        !           210:                   (gi2T20.GIoffset < 0) )
        !           211:                   return vszTableOffsetsBad;
        !           212: 
        !           213:                          pjGlyphData += lSizeOfOldGlyph20;
        !           214:          }
        !           215:      }
        !           216:      else{
        !           217: 
        !           218:          pjGlyphData = lpFontBody;
        !           219: 
        !           220:             /* view table as 3.0 table */
        !           221:          /* check that each and every width and offset lie within limits */
        !           222: 
        !           223:          for (i=0; i< (fontBuffer.LastChar - fontBuffer.FirstChar +1); i++) {
        !           224: 
        !           225:                          vGlyphInfo30FromBuffer (pjGlyphData, &gi3T30);
        !           226: 
        !           227:               if (gi3T30.GIwidth > 64)
        !           228:                   return vszTableWidthsBad;
        !           229: 
        !           230:               if (gi3T30.GIoffset < (DWORD)0)
        !           231:                   return vszTableOffsetsBad;
        !           232: 
        !           233:                          pjGlyphData += lSizeOfOldGlyph30;
        !           234:          }
        !           235:      }
        !           236:      return NULL;
        !           237: }
        !           238: 
        !           239: /****************************************************************************
        !           240:  * char * FontLoad()
        !           241:  *
        !           242:  * purpose: reads in the specified font file and creates a work bitmap for
        !           243:  *          the editor. Also creates a local bitmap-offset table for easy
        !           244:  *          access to the characters in the bitmap
        !           245:  *
        !           246:  * params : pszFileName - File Name to open.
        !           247:  *
        !           248:  * returns: ptr to NULL string if Open goes off OK
        !           249:  *          ptr to error message string otherwise
        !           250:  *
        !           251:  * side effects: lots
        !           252:  *
        !           253:  ****************************************************************************/
        !           254: CHAR *
        !           255: FontLoad(
        !           256:     CHAR               *pszFileName,
        !           257:        OFSTRUCT        *pofsReOpenInfo
        !           258:     )
        !           259: {
        !           260: 
        !           261:     CHAR  *lpFontBodySav = NULL;  /* local pointer to font body */
        !           262:     DWORD len, fontlen;               /* length of font body (bytes)*/
        !           263:        UINT i;
        !           264:     INT mf;                      /* menu function ID */
        !           265:     DWORD iWorkLen;                   /* length of work area (bytes) */
        !           266:     HDC hDC;
        !           267:     CHAR * pszError;                   /* error msg if header is messed up */
        !           268: 
        !           269:     DWORD row, height, width,phase;
        !           270:     DWORD offset;
        !           271:     GLYPHINFO_20 gi2GlyphTable20;    /* Pointer into 2.0 style offsets table */
        !           272:     GLYPHINFO_30 gi3GlyphTable30;    /* Pointer into 3.0 style offsets table */
        !           273:        PBYTE   pjGlyphData;                     /* Pointer to Glyph information buffer. */
        !           274: 
        !           275:     BYTE  cDummy [CCHEXTRA];         /* dummy buffer for unneeded 3.0 header
        !           276:                                     * info
        !           277:                                     */
        !           278: 
        !           279:     /* Put up an hourglass ... this may take a while */
        !           280:     if (!hHourGlass)
        !           281:         hHourGlass = LoadCursor(NULL, IDC_WAIT);        /* Get Hourglass */
        !           282:     hOldCursor = SetCursor(hHourGlass);         /* Show hourglass */
        !           283: 
        !           284:     /* open file for read. */
        !           285:        nNewFile = (HFILE)OpenFile (pszFileName, pofsReOpenInfo, OF_READ);
        !           286:        
        !           287:        if (nNewFile < 0) {
        !           288: 
        !           289:                return vszErrorOpeningFile;
        !           290:        }
        !           291: 
        !           292:        //- ReadFile:  Here is where we need to make some adjustments in order to
        !           293:        //- read the file in to a new DWORD aligned format.
        !           294:        {
        !           295:                BYTE    jBuffer [200];
        !           296: 
        !           297: 
        !           298:                /* Read the header */
        !           299:                if (_lread ((HFILE) nNewFile, (LPSTR)&jBuffer, lSizeOfOldFontHeader) !=
        !           300:                                (UINT)lSizeOfOldFontHeader) {
        !           301: 
        !           302:                        _lclose((HFILE)nNewFile);
        !           303:                        return vszErrorReadingHdr;
        !           304:                }
        !           305: 
        !           306:                //
        !           307:                // Call conversion routine to give us a properly aligned buffer.
        !           308:                //
        !           309: 
        !           310:                vFontStructFromBuffer (
        !           311:                                 (PBYTE)&jBuffer,
        !           312:                                 &fontBuffer
        !           313:                                );
        !           314: 
        !           315:        }
        !           316: 
        !           317:     /* Check the version number -- make sure it's a font */
        !           318:     switch (fontBuffer.Version)
        !           319:         {
        !           320:         case 0x200:
        !           321:                 iFontFormat = ID_FORMAT2;
        !           322:                 break;
        !           323:         case 0x300:        /* added 1/19/88 */
        !           324:                 iFontFormat = ID_FORMAT3;
        !           325:                 /* read in the extra fields into a dummy buffer ... they don't
        !           326:                  * mean anything to us  at this stage.
        !           327:                  */
        !           328:                 if ((_lread((HFILE)nNewFile, (LPSTR)cDummy, CCHEXTRA))
        !           329:                             != CCHEXTRA){
        !           330:                     _lclose((HFILE)nNewFile);
        !           331:                     return vszErrorReadingHdr;
        !           332:                 }
        !           333: 
        !           334:                 break;
        !           335:         default:                /* Anything else -- toughies */
        !           336:                 _lclose((HFILE)nNewFile);
        !           337:                 return vszUnknownFormat;
        !           338:         }
        !           339: 
        !           340:     /* check if contents of font header are sensible. If not,
        !           341:        give an error message and quit */
        !           342: 
        !           343:     if ((pszError = VerifyHeaderContents()) != NULL) {
        !           344: 
        !           345:                _lclose((HFILE)nNewFile);
        !           346:         return pszError;
        !           347:        }
        !           348: 
        !           349:     /* Ready to load -- Check if we will be overwriting */
        !           350:     if (fLoaded)
        !           351:        {
        !           352:         DeleteGlobalBitmap();
        !           353:         fLoaded = FALSE;
        !           354:        }
        !           355: 
        !           356:     /* Allocate space for font body and Face Name and read them in */
        !           357:     len= (fontBuffer.Size - lSizeOfOldFontHeader);  /* Compute size */
        !           358: 
        !           359:     if ((lpFontBody = (LPSTR)GlobalAlloc(GMEM_ZEROINIT, (LONG)len)) == 0) {
        !           360: 
        !           361:                _lclose((HFILE)nNewFile);
        !           362:         return vszNotEnoughMem;                       /* Get Handle to space */
        !           363:        }
        !           364: 
        !           365:     if (iFontFormat == ID_FORMAT3)
        !           366:         fontlen = len - CCHEXTRA;
        !           367:     else
        !           368:         fontlen = len;
        !           369: 
        !           370:     lpFontBodySav = lpFontBody;                    /* save ptr to font body */
        !           371:     while (fontlen >= (DWORD)SEGMENT_SIZE) {
        !           372: 
        !           373:         /*  file read method if font file size is 64k bytes or greater.
        !           374:             file is read in in chunks of 65536 (SEGMENT_SIZE), taking care to
        !           375:             position buffer ptr at 64k boundary each time */
        !           376: 
        !           377:         /* First read in the maximum number of bytes _lread can read (65534) */
        !           378:         if ((_lread((HFILE)nNewFile, lpFontBodySav, WORD_LIMIT)) == WORD_LIMIT) {
        !           379: 
        !           380:             lpFontBodySav += WORD_LIMIT; /* buffer ptr moved up by 64k bytes */
        !           381:             fontlen -= WORD_LIMIT;     /* fontlen = no of bytes left to read */
        !           382: 
        !           383:                } else {
        !           384: 
        !           385:                        GlobalFree (lpFontBody);
        !           386:                        _lclose((HFILE)nNewFile);
        !           387:             return vszErrorReadingBody;
        !           388:                }
        !           389: 
        !           390:         /* read in an additional two bytes to reach end of segment */
        !           391:         if ((_lread((HFILE)nNewFile, lpFontBodySav, 2)) == 2) {
        !           392: 
        !           393:             lpFontBodySav += 2; /* buffer ptr moved up by 2 bytes */
        !           394:             fontlen -= 2;       /* fontlen = no of bytes left to read */
        !           395: 
        !           396:         } else {
        !           397: 
        !           398:                        GlobalFree (lpFontBody);
        !           399:                        _lclose((HFILE)nNewFile);
        !           400:             return vszErrorReadingBody;
        !           401:         }
        !           402:        }
        !           403: 
        !           404:     /* read the partially filled segment  */
        !           405:     if ((_lread((HFILE)nNewFile, lpFontBodySav, (DWORD)fontlen)) != (UINT) fontlen) {
        !           406: 
        !           407:         GlobalFree (lpFontBody);
        !           408:         _lclose((HFILE)nNewFile);
        !           409:         return vszErrorReadingBody;
        !           410:        }
        !           411: 
        !           412:     /* Close the file */
        !           413:     _lclose((HFILE)nNewFile);
        !           414: 
        !           415:     /* check if the offset table entries are within allowable limits.
        !           416:        If not give an error message, clean up and quit */
        !           417:     if ((pszError = VerifyTableContents()) != NULL) {
        !           418: 
        !           419:         GlobalFree (lpFontBody);
        !           420:         return pszError;
        !           421:        }
        !           422: 
        !           423:     /* now that everything has been checked, move buffer to font */
        !           424:     font = fontBuffer;
        !           425: 
        !           426:     /* Make local copies of FaceName and Device Name */
        !           427:     if (font.Face){
        !           428: 
        !           429:         lstrcpy((LPSTR)szFaceName, lpFontBody + font.Face -
        !           430:                                          (iFontFormat == ID_FORMAT2 ?
        !           431:                                                     lSizeOfOldFontHeader   :
        !           432:                                                     lSizeOfOldFontHeader30-1));
        !           433:     } else {
        !           434: 
        !           435:         lstrcpy((LPSTR)szFaceName, (LPSTR)"");
        !           436:        }
        !           437: 
        !           438:     for (i = 0; i <= 256; i++)      /* Zero offsets Table for below */
        !           439:         offsets[i] = 0;
        !           440: 
        !           441:     /* compute work space needed if a 3.0 file. This has to be done since
        !           442:        3.0 files are compressed versions of 2.0 files and may need a
        !           443:        work bitmap bigger than the actual font body size */
        !           444: 
        !           445:     if (iFontFormat == ID_FORMAT3) {
        !           446: 
        !           447:         cTable = (WORD) (6 * (font.LastChar - font.FirstChar + 2));
        !           448:         iWorkLen = 0;
        !           449: 
        !           450:         pjGlyphData = lpFontBody;
        !           451: 
        !           452:         /* work bitmap size = sum of sizes of all characters in font */
        !           453: 
        !           454:         for (i = font.FirstChar; i <= font.LastChar; i++) {
        !           455: 
        !           456:                         vGlyphInfo30FromBuffer (pjGlyphData, &gi3GlyphTable30);
        !           457: 
        !           458:              iWorkLen += ((gi3GlyphTable30.GIwidth +7) >> 3) * font.PixHeight;
        !           459: 
        !           460:                         pjGlyphData += lSizeOfOldGlyph30;
        !           461:                }
        !           462: 
        !           463:     } else { /* 2.0 file */
        !           464: 
        !           465:         cTable = (WORD)(4 * (font.LastChar - font.FirstChar + 2));
        !           466:            /* compute table length */
        !           467:         iWorkLen = len;  /* work space for a 2.0 file is the same as the
        !           468:                              length of the font body */
        !           469:     }
        !           470: 
        !           471:        //- Add some extra space for dword alignment.
        !           472:        iWorkLen += (font.PixHeight * sizeof (DWORD));
        !           473:       /* Get work space */
        !           474: 
        !           475:     if ((lpWork = (LPSTR)GlobalAlloc (GMEM_ZEROINIT, (LONG)iWorkLen)) == 0) {
        !           476: 
        !           477:         GlobalFree (lpFontBody);
        !           478:         return vszNotEnoughMem;
        !           479:     }
        !           480: 
        !           481:        lp1 = lpWork;
        !           482: 
        !           483:     height = (DWORD) font.PixHeight;
        !           484:     offset = 0;
        !           485:     /* put the font file into bitmap format */
        !           486:     if (iFontFormat == ID_FORMAT2){         /* table in 2.0 format */
        !           487:         for (row = 0; row < height; row++){
        !           488: 
        !           489:              /* view table as a 2.0 style table */
        !           490:              pjGlyphData = lpFontBody + 1;
        !           491: 
        !           492:              phase = 0;
        !           493: 
        !           494:              for (i = 0; i < (UINT)(font.LastChar - font.FirstChar + 1); i++) {
        !           495: 
        !           496:                                vGlyphInfo20FromBuffer (pjGlyphData, &gi2GlyphTable20);
        !           497: 
        !           498:                 width = (DWORD) gi2GlyphTable20.GIwidth;
        !           499: 
        !           500:                 /* size of each table element = 4bytes */
        !           501:                 lp2 = lpFontBody + (gi2GlyphTable20.GIoffset -
        !           502:                                                        lSizeOfOldFontHeader) + row;
        !           503: 
        !           504:                                pjGlyphData += lSizeOfOldGlyph20;
        !           505: 
        !           506:                 /* offset ends up as the sum of the widths */
        !           507:                 if (row == 0)              /* Once is enough */
        !           508:                                                offsets[i + font.FirstChar + 1] = offset += width;
        !           509: 
        !           510:                 /* create a single scan of bitmap for character */
        !           511:                 phase = ConvertToBitmapFormat (width, phase, height);
        !           512:              }
        !           513:              if ((lp1 - lpWork) & 1)
        !           514:                  *lp1++ = 0;             /* Round lp1 up to Word Boundary */
        !           515: #ifdef DWORDROUND
        !           516:              if ((lp1 - lpWork) & 2) {
        !           517:                  *lp1++ = 0;             /* Round lp1 up to DWord Boundary */
        !           518:                  *lp1++ = 0;             /* Round lp1 up to DWord Boundary */
        !           519:                         }
        !           520: #endif
        !           521:              //if (((offset + 7) >> 3) & 1)
        !           522:                  //*lp1++ = 0;             /* Round lp1 up to Word Boundary */
        !           523:              //if (((offset + 7) >> 3) & 2) {
        !           524:                  //*lp1++ = 0;             /* Round lp1 up to DWord Boundary */
        !           525:                  //*lp1++ = 0;             /* Round lp1 up to DWord Boundary */
        !           526:                         //}
        !           527:         }
        !           528:     }
        !           529:      /* separate loops written for the 2.0 and 3.0 font processing because
        !           530:         a single loop would involve too many checks (of font type) within
        !           531:         the loop and slow down processing  */
        !           532:     else {                                 /* table in 3.0 format */
        !           533: 
        !           534:         for (row = 0; row < height; row++){
        !           535: 
        !           536:              phase = 0;
        !           537:              /* view table as a 3.0 style table */
        !           538:              pjGlyphData = lpFontBody;
        !           539: 
        !           540:              for (i = 0; i < (UINT)(font.LastChar - font.FirstChar + 1); i++) {
        !           541: 
        !           542:                                vGlyphInfo30FromBuffer (pjGlyphData, &gi3GlyphTable30);
        !           543: 
        !           544:                 width = gi3GlyphTable30.GIwidth;
        !           545: 
        !           546:                   /* size of each table element = 6bytes */
        !           547:                 lp2 = lpFontBody + (gi3GlyphTable30.GIoffset -
        !           548:                                                lSizeOfOldFontHeader30 +1) + row;
        !           549: 
        !           550:                                pjGlyphData += lSizeOfOldGlyph30;
        !           551: 
        !           552:                  /* offset ends up as the sum of the widths */
        !           553:                 if (row == 0)              /* Once is enough */
        !           554:                     offsets[i + font.FirstChar + 1] = offset += width;
        !           555: 
        !           556:                  /* create a single scan of bitmap for character */
        !           557:                 phase = ConvertToBitmapFormat (width, phase, height);
        !           558:              }
        !           559:              if ((lp1 - lpWork) & 1)
        !           560:                  *lp1++ = 0;             /* Round lp1 up to Word Boundary */
        !           561: #ifdef DWORDROUND
        !           562:              if ((lp1 - lpWork) & 2) {
        !           563:                  *lp1++ = 0;             /* Round lp1 up to DWord Boundary */
        !           564:                  *lp1++ = 0;             /* Round lp1 up to DWord Boundary */
        !           565:                         }
        !           566: #endif
        !           567:         }
        !           568:     }
        !           569:     font.WidthBytes = (WORD) (((offset + 15) >> 4) << 1);
        !           570:        /* fixup NEWFON error */
        !           571: 
        !           572:     GlobalFree(lpFontBody);
        !           573:     lpFontBody = lpWork;          /* So that below we free the other buffer */
        !           574:     /* Create a WINDOWS bitmap to move the font definition bits into */
        !           575: 
        !           576:     hDC = GetDC (hFont);                         /* DC to be compatible with */
        !           577:     hBitmap = CreateBitmap(
        !           578:                     (INT)font.WidthBytes << 3, /* Width of font in pixels */
        !           579:                     (INT)font.PixHeight,
        !           580:                     1, 1, (LPBYTE)NULL);
        !           581:     hMemDC = CreateCompatibleDC(hDC);           /* Create a DC */
        !           582:     SelectObject(hMemDC, hBitmap);              /* Relate the two of them */
        !           583:     ReleaseDC(hFont, hDC);                      /* Done with font DC */
        !           584: 
        !           585:     /* Move the bits in */
        !           586:     SetBitmapBits(hBitmap,
        !           587:           (DWORD)font.WidthBytes * (DWORD)font.PixHeight,(CHAR  *)lpWork);
        !           588: 
        !           589:     /* Free up the space we loaded the file into */
        !           590:     GlobalFree(lpFontBody);
        !           591:     fLoaded = TRUE;
        !           592:     {
        !           593:         HMENU hMenu;
        !           594: 
        !           595:         hMenu = GetMenu(hBox);  /* Gray menu if no clipboard bitmap */
        !           596:         mf = (font.Family & 1) ? MF_ENABLED : MF_GRAYED;
        !           597:         EnableMenuItem(hMenu, FONT_SAVE, MF_ENABLED);
        !           598:         EnableMenuItem(hMenu, FONT_SAVEAS, MF_ENABLED);
        !           599:         EnableMenuItem(hMenu, 1, MF_BYPOSITION | MF_ENABLED);
        !           600:         EnableMenuItem(hMenu, 2, MF_BYPOSITION | MF_ENABLED);
        !           601:         EnableMenuItem(hMenu, 3, MF_BYPOSITION | MF_ENABLED);
        !           602:         EnableMenuItem(hMenu, 4, MF_BYPOSITION | mf);
        !           603:         EnableMenuItem(hMenu, 5, MF_BYPOSITION | MF_ENABLED);
        !           604:         EnableMenuItem(hMenu, 6, MF_BYPOSITION | MF_ENABLED);
        !           605:         DrawMenuBar(hBox);
        !           606:     }
        !           607:     SetCursor(hOldCursor);              /* Restore regular cursor */
        !           608:     return "";
        !           609: }
        !           610: 
        !           611: /**************************************
        !           612:  * compares nBytes bytes of s1 and s2 *
        !           613:  **************************************/
        !           614: BOOL
        !           615: ByteCompare (
        !           616:     CHAR  *s1,
        !           617:     CHAR  *s2,
        !           618:     DWORD nBytes
        !           619:     )
        !           620: {
        !           621:     for ( ; nBytes > 0; nBytes--)
        !           622:         if (*s1++ != *s2++)
        !           623:             return FALSE;
        !           624:     return TRUE;
        !           625: }
        !           626: 
        !           627: /***********************************
        !           628:  * copies nBytes bytes of s2 to s1 *
        !           629:  ***********************************/
        !           630: BOOL
        !           631: ByteCopy(
        !           632:     CHAR  *s1,
        !           633:     CHAR  *s2,
        !           634:     LONG  nBytes
        !           635:     )
        !           636: {
        !           637:     for ( ; nBytes > 0; nBytes--)
        !           638:         *s1++ = *s2++;
        !           639:     return TRUE;
        !           640: }
        !           641: 
        !           642: /****************************************************************************
        !           643:  * VOID ConvertToFileFormat(width, phase, height)
        !           644:  *
        !           645:  * purpose  : Takes a part of the bitmap (corresponding to a single character)
        !           646:  *            and converts it to a string of bytes in the font file format
        !           647:  *
        !           648:  * params   : WORD width :  width of the character in pixels(bits)
        !           649:  *            WORD phase :  current deviation from byte alignment (pixels)
        !           650:  *            WORD height:  height of character(pixels)
        !           651:  *
        !           652:  * returns:   WORD phase :  new deviation from byte alignment (pixels)
        !           653:  *
        !           654:  * side effects : modifies pointers lp1 and lp2 (pointing to font body and work
        !           655:  *                space respectively)
        !           656:  *
        !           657:  ****************************************************************************/
        !           658: DWORD PASCAL
        !           659: ConvertToFileFormat(
        !           660:      DWORD width,
        !           661:      DWORD phase,
        !           662:      DWORD height
        !           663:      )
        !           664: {
        !           665:       INT w;
        !           666: 
        !           667:       for (w = width; w > 0; w -= 8){  /* for each byte of font */
        !           668:            if (phase == 0){             /* easy case */
        !           669: 
        !           670:                BYTE b;
        !           671: 
        !           672:                b = *lp1++;
        !           673:                if (w < 8){
        !           674: 
        !           675:                    phase = (DWORD) w;
        !           676:                    b >>= 8 - w;    /* Clear left side bits */
        !           677:                    b <<= 8 - w;
        !           678:                }
        !           679:                *lp2 = b;
        !           680:            }
        !           681:            else{
        !           682: 
        !           683:                DWORD j;
        !           684: 
        !           685:                lp1--;          /* Re-read byte prevously read */
        !           686:                //j = (DWORD) ((BYTE)*lp1++ << 8) | ((BYTE)*lp1++);
        !           687:                j = (DWORD)((BYTE)*lp1++ << 8);
        !           688:                j |= (DWORD) ((BYTE)*lp1++);
        !           689:                if (w < 8){
        !           690: 
        !           691:                    j >>= 16 - phase - (w & 7);  /* shove it right */
        !           692:                    j <<= 8 - (w & 7); /* Left justify in low byte */
        !           693:                    phase += (DWORD) w;
        !           694:                    if (phase <=  8)
        !           695:                        lp1--;         /* back up pointer */
        !           696:                    phase &= 7;
        !           697:                }
        !           698:                else
        !           699:                    j >>= 8 - phase;
        !           700:                *lp2 = (BYTE)j;
        !           701:            }
        !           702:            lp2 += height;          /* move to next column */
        !           703:        }
        !           704:        return phase;
        !           705: }
        !           706: 
        !           707: /****************************************************************************
        !           708:  * char * FontSave()
        !           709:  *
        !           710:  * purpose: saves the work bitmap in the required font file format (2.0 or
        !           711:  *          3.0 and cleans up
        !           712:  *
        !           713:  * params : none
        !           714:  *
        !           715:  * returns: ptr to a NULL string if Save goes off OK
        !           716:  *          ptr to error message string otherwise
        !           717:  *
        !           718:  * side effects: lots
        !           719:  *
        !           720:  ****************************************************************************/
        !           721: 
        !           722: CHAR *
        !           723: FontSave(
        !           724:        CHAR            *pszFileName,
        !           725:        OFSTRUCT        *pofsReOpenInfo
        !           726:     )
        !           727: {
        !           728:     DWORD bytecount;       /* number of bytes returned by lwrite */
        !           729:     DWORD size;            /* total size of font */
        !           730: 
        !           731:     WORD height, row;
        !           732:     DWORD i, fontlen;
        !           733:     DWORD cBody, cFont,cFontsav, cFace;
        !           734:     CHAR                       *lpFont;          /* ponter to font body */
        !           735:     CHAR * sz;
        !           736:     DWORD iMax;
        !           737:     WORD widthsav;
        !           738:        PBYTE                   pjGlyphData;
        !           739:        PBYTE                   pjGlyphSave;
        !           740:     GLYPHINFO_20       gi2GlyphTable20;    /* 2.0 style Glyph data struct */
        !           741:     GLYPHINFO_30       gi3GlyphTable30;    /* 3.0 style Glyph data struct */
        !           742: 
        !           743:     NewAverage(); /* force ave width to be recomputed 8/17/87 BobM */
        !           744: 
        !           745:     /* reset file pointer */
        !           746:        nNewFile = (HFILE)OpenFile (pszFileName, pofsReOpenInfo, OF_WRITE | OF_REOPEN);
        !           747: 
        !           748:        if (nNewFile < (HFILE) 0) {
        !           749: 
        !           750:                return vszErrorOpeningFile;
        !           751:        }
        !           752: 
        !           753:     /* Put up an houglass ... this may take a while */
        !           754:     if (!hHourGlass)
        !           755:         hHourGlass = LoadCursor (NULL, IDC_WAIT);        /* Get Hourglass */
        !           756:     hOldCursor = SetCursor (hHourGlass);         /* Show hourglass */
        !           757: 
        !           758:     height = font.PixHeight;
        !           759:     cBody = (DWORD)height * (DWORD)font.WidthBytes;
        !           760: 
        !           761:     /* Recompute file size and update header */
        !           762:     if (iFontFormat == ID_FORMAT2)
        !           763:        cHeader = (WORD)(lSizeOfOldFontHeader +1);
        !           764:     else
        !           765:        cHeader = (WORD)(lSizeOfOldFontHeader30 - 1);
        !           766: 
        !           767:     /* if of 2.0 type, check if size will exceed 64kbytes. If yes, saving
        !           768:        in 2.0 format will result in loss of information (because offset table
        !           769:        of 2.0 file is composed of 16bit words). Warn user and ask if file can
        !           770:        be saved as a 3.0 file */
        !           771: 
        !           772:     if (iFontFormat == ID_FORMAT2)
        !           773:     {  
        !           774:                if (((DWORD)cHeader + (DWORD)(lSizeOfOldGlyph20 * (font.LastChar -
        !           775:                        font.FirstChar+2)) + (DWORD)cBody) >= WORD_LIMIT)
        !           776:                if (MessageBox(hBox, vszTooBigFor20, vszWarning,
        !           777:                               IDOK | IDCANCEL |IDNO) == IDYES)
        !           778:                     iFontFormat = ID_FORMAT3;
        !           779:        }
        !           780: 
        !           781:        if (iFontFormat == ID_FORMAT2) {
        !           782: 
        !           783:                /* allocate space for a 2.0 style offsets table */
        !           784:                cTable = (WORD)(lSizeOfOldGlyph20 *
        !           785:                                (font.LastChar - font.FirstChar + 2));
        !           786: 
        !           787:        } else {
        !           788: 
        !           789:                /* allocate space for a 3.0 style offsets table */
        !           790:                cTable = (WORD)(lSizeOfOldGlyph30 *
        !           791:                                (font.LastChar - font.FirstChar + 2));
        !           792:        }
        !           793: 
        !           794:        pjGlyphData = (LPSTR)GlobalAlloc (GMEM_ZEROINIT, (DWORD)cTable);
        !           795: 
        !           796:        if (pjGlyphData == 0) {
        !           797: 
        !           798:                _lclose((HFILE)nNewFile);
        !           799:                return vszNotEnoughMem;
        !           800:        }
        !           801: 
        !           802:        pjGlyphSave = pjGlyphData;
        !           803: 
        !           804:     size = cHeader + cTable;
        !           805:     iMax = font.LastChar - font.FirstChar + 1;
        !           806: 
        !           807:     /* create offsets table of font file */
        !           808:     for (i = 0; i <= iMax; i++){
        !           809: 
        !           810:          DWORD width, charSize;
        !           811: 
        !           812:          width = offsets[i + font.FirstChar + 1] - offsets[i + font.FirstChar];
        !           813: 
        !           814:          if (i == iMax) {
        !           815:              width = 8;      /* Sentinal blank */
        !           816:                 }
        !           817: 
        !           818:          if (iFontFormat == ID_FORMAT2){
        !           819: 
        !           820:             gi2GlyphTable20.GIwidth  = (SHORT)width;
        !           821:             gi2GlyphTable20.GIoffset = (SHORT)size;
        !           822: 
        !           823:                        vBufferFromGlyphInfo20 (&gi2GlyphTable20, pjGlyphData);
        !           824: 
        !           825:                        pjGlyphData += lSizeOfOldGlyph20;
        !           826: 
        !           827:          } else {
        !           828: 
        !           829:             gi3GlyphTable30.GIwidth  = (SHORT)width;
        !           830:             gi3GlyphTable30.GIoffset = (INT)size;
        !           831: 
        !           832:                        vBufferFromGlyphInfo30 (&gi3GlyphTable30, pjGlyphData);
        !           833: 
        !           834:                        pjGlyphData += lSizeOfOldGlyph30;
        !           835:          }
        !           836: 
        !           837:          charSize = height * ((width + 7) >> 3);  /* size in bytes */
        !           838: 
        !           839:          if ((size + charSize) < size){           /* Overflow? */
        !           840: 
        !           841:              GlobalFree (pjGlyphData);
        !           842:              _lclose((HFILE)nNewFile);
        !           843:              return vszFileTooLarge;
        !           844: 
        !           845:          }
        !           846:          size += charSize;
        !           847:     }
        !           848: 
        !           849:     /* Update stuff in the header */
        !           850: 
        !           851:     font.Face = (DWORD)size;
        !           852:     cFace = (WORD)lstrlen (szFaceName) + 1;   /* Allow for \0 */
        !           853:     size += cFace;
        !           854:     font.Size = (DWORD)size;                                /* new file size */
        !           855:     font.BitsOffset = (DWORD)(cHeader + cTable);
        !           856:     font.Device = (DWORD)NULL;                   /* Device Name must be NULL */
        !           857:     cFontsav = size - cHeader - cTable;
        !           858:     cFont =cFontsav;
        !           859: 
        !           860:        /* alloc extra byte for lp1 in case it needs it */
        !           861:     if (!(lpFontBody = (LPSTR)GlobalAlloc (GMEM_ZEROINIT, (LONG)cBody +
        !           862:                        height * 4))) {
        !           863: 
        !           864:                _lclose((HFILE)nNewFile);
        !           865:         return vszNotEnoughMem;
        !           866:        }
        !           867: 
        !           868:     GetBitmapBits (hBitmap, (DWORD)cBody, lpFontBody);
        !           869: 
        !           870:     /* save current WidthBytes */
        !           871:     widthsav = font.WidthBytes;
        !           872: 
        !           873:     /*  MD - reset WidthBytes from computed width */
        !           874:     font.WidthBytes = (WORD) (cFont - cFace)/ height;
        !           875: 
        !           876:     /* Allocate a block to put bitmap into */
        !           877:     if ((lpFont = lpWork = GlobalAlloc (GMEM_ZEROINIT,(LONG)cFont)) == 0)
        !           878:        {
        !           879:         GlobalFree (lpFontBody);
        !           880:                _lclose((HFILE)nNewFile);
        !           881:         return vszNotEnoughMem;
        !           882:        }
        !           883: 
        !           884:     lp1 = lpFontBody;
        !           885: 
        !           886:     /* convert bitmap to file format */
        !           887:     if (iFontFormat == ID_FORMAT2){   /* offsets table in 2.0 format */
        !           888:         INT nChars;
        !           889:         nChars =  font.LastChar - font.FirstChar +1;
        !           890: 
        !           891:         for (row = 0; row < height; row++){
        !           892: 
        !           893:             DWORD phase;
        !           894: 
        !           895:             phase = 0;
        !           896: 
        !           897:             pjGlyphData = pjGlyphSave;
        !           898: 
        !           899:             for (i = 0; i < (DWORD) nChars; i++) {
        !           900: 
        !           901:                 INT width;
        !           902: 
        !           903:                                vGlyphInfo20FromBuffer (pjGlyphData, &gi2GlyphTable20);
        !           904: 
        !           905:                 width = gi2GlyphTable20.GIwidth;
        !           906: 
        !           907:                 lp2 = (BYTE  *)(lpWork + (gi2GlyphTable20.GIoffset -
        !           908:                                                cHeader - cTable + row));
        !           909: 
        !           910:                                pjGlyphData += lSizeOfOldGlyph20;
        !           911: 
        !           912:                 phase = ConvertToFileFormat (width, phase, height);
        !           913:             }
        !           914:             if ((lp1 - lpWork) & 1)
        !           915:                  lp1++;             /* Round lp1 up to Word Boundary */
        !           916: #ifdef DWORDROUND
        !           917:             if ((lp1 - lpWork) & 2) {
        !           918:                  lp1++;             /* Round lp1 up to DWord Boundary */
        !           919:                  lp1++;             /* Round lp1 up to DWord Boundary */
        !           920:                        }
        !           921: #endif
        !           922:             //if(((offsets[font.LastChar + 1] + 7) >> 3) & 1)
        !           923:                 //lp1++;          /* Round lp1 up to Word Boundary */
        !           924:         }
        !           925:     }
        !           926:      /* separate loops written for the 2.0 and 3.0 font processing because
        !           927:         a single loop would involve too many checks (of font type) within
        !           928:         the loop and slow down processing  */
        !           929:     else{  /* table in 3.0 format */
        !           930: 
        !           931:         INT nChars;
        !           932:         nChars =  font.LastChar - font.FirstChar +1;
        !           933:         for (row = 0; row < height; row++){
        !           934: 
        !           935:             DWORD phase;
        !           936: 
        !           937:             phase = 0;
        !           938:                        pjGlyphData = pjGlyphSave;
        !           939: 
        !           940:             for (i = 0; i < (DWORD) nChars; i++) {
        !           941: 
        !           942:                 INT width;
        !           943: 
        !           944:                                vGlyphInfo30FromBuffer (pjGlyphData, &gi3GlyphTable30);
        !           945: 
        !           946:                 width = gi3GlyphTable30.GIwidth;
        !           947: 
        !           948:                 lp2 = (BYTE  *)(lpWork + (gi3GlyphTable30.GIoffset -
        !           949:                                                cHeader - cTable + row));
        !           950: 
        !           951:                                pjGlyphData += lSizeOfOldGlyph30;
        !           952: 
        !           953:                 phase = ConvertToFileFormat (width, phase, height);
        !           954:             }
        !           955:             if ((lp1 - lpWork) & 1)
        !           956:                  lp1++;             /* Round lp1 up to Word Boundary */
        !           957: #ifdef DWORDROUND
        !           958:             if ((lp1 - lpWork) & 2) {
        !           959:                  lp1++;             /* Round lp1 up to DWord Boundary */
        !           960:                  lp1++;             /* Round lp1 up to DWord Boundary */
        !           961:                        }
        !           962: #endif
        !           963:             //if(((offsets[font.LastChar + 1] + 7) >> 3) & 1)
        !           964:                 //lp1++;          /* Round lp1 up to Word Boundary */
        !           965:         }
        !           966:     }
        !           967: 
        !           968:        /* Restore start of data. */
        !           969:        pjGlyphData = pjGlyphSave;
        !           970: 
        !           971:     lp2 -= height - 1;              /* Back up to start of character */
        !           972:     for (i = 0; i < height; i++)
        !           973:          *lp2++ = 0;             /* Fill in guaranteed blank character */
        !           974: 
        !           975:     font.Version = 0x200;
        !           976: 
        !           977:     /******  code for compaction in 3.0 fmt borrowed from CMPCTFON ******/
        !           978:     if (iFontFormat== ID_FORMAT3){
        !           979:         DWORD iDefBitmapSize = 0;     /* size of default char */
        !           980:         DWORD cch = 0;                /* count of number of default char */
        !           981: #if 0
        !           982:         GLYPHINFO_30  *cur_char;  /* current element of offset table */
        !           983:         GLYPHINFO_30  *move_char;
        !           984:             /* element from which moving is to be done */
        !           985:         LONG iDefBitmapOffset;        /* offset of default char */
        !           986:         INT iDefBitmapWidth;          /* width of default char */
        !           987:         static LONG iEndOfBitmaps;    /* address of end of font body */
        !           988:         INT iFirstC;                  /* first char in font */
        !           989:         INT iLastC;                   /* last char in font */
        !           990:         INT i,j;
        !           991:         WORD width;
        !           992:         CHAR  *rgbFont;         /* pointer to font body */
        !           993:         DWORD Offset;
        !           994: 
        !           995:         GDI seems to understand compressed 2.0 external formats but not
        !           996:         compressed 3.0 formats, and this is causing it to crash loading a 3.0
        !           997:         format compressed font. Since compression does not affect the
        !           998:         validity of the font, This code is disabled temporarily till
        !           999:         this problem is verified. Again, the font is perfectly usable in this
        !          1000:         form, though a trifle bigger than desired -  LR 20/26/90
        !          1001: 
        !          1002: 
        !          1003:                Note that this will now not work after the conversion to NT.
        !          1004:                the glyph table needs to accessed as above.  t-davema 8/20/91
        !          1005: 
        !          1006:         iFirstC = font.FirstChar & 0x0ff;
        !          1007:         iLastC  = font.LastChar & 0x0ff;
        !          1008: 
        !          1009:         iEndOfBitmaps = (LONG)font.BitsOffset+((LONG)font.WidthBytes *
        !          1010:                 (LONG)font.PixHeight);
        !          1011:         rgbFont = (CHAR  *)lpFont;   /* start of font body */
        !          1012:         cur_char =(GLYPHINFO_30  *) lpTable; /* start of offset table */
        !          1013: 
        !          1014:         /* calculate some parameters for the default char */
        !          1015:         iDefBitmapOffset = cur_char[font.DefaultChar].GIoffset;
        !          1016:         iDefBitmapWidth  = cur_char[font.DefaultChar].GIwidth;
        !          1017:         iDefBitmapSize   = (DWORD)cur_char[font.DefaultChar+1].GIoffset
        !          1018:                                            - (DWORD)iDefBitmapOffset;
        !          1019: 
        !          1020:         /* scan the font body via the offsets table. If a default char
        !          1021:            is recognised, move all the bytes to it's right left by the
        !          1022:            size of the default char.Make all offset table entries of default
        !          1023:            char point to one image of the char (the earliest occuring image) */
        !          1024:         for (i = iFirstC; i <= iLastC; ++i) {
        !          1025: 
        !          1026:             /* important: Check for limiting conditions (in case break char
        !          1027:                was modified?)*/
        !          1028:             if (cur_char->GIoffset == iDefBitmapOffset){
        !          1029:                 cur_char++;
        !          1030:                 continue;
        !          1031:             }
        !          1032: 
        !          1033:             Offset = cur_char->GIoffset -cHeader -cTable;
        !          1034:             /* proceed to compare images only if widths are equal */
        !          1035:             if ((cur_char->GIwidth  == iDefBitmapWidth) &&
        !          1036:                 (ByteCompare (&rgbFont [Offset],
        !          1037:                 &rgbFont[iDefBitmapOffset-cHeader-cTable],
        !          1038:                                 (DWORD)iDefBitmapSize) == TRUE)){
        !          1039: 
        !          1040:                 /* set offset to earliest occurence of the default char */
        !          1041:                 if (cur_char->GIoffset <  iDefBitmapOffset){
        !          1042:                     iDefBitmapOffset = cur_char->GIoffset;
        !          1043:                 }
        !          1044:                 else    {
        !          1045:                     if (i != iLastC){
        !          1046:                         /* move bytes to right of default char left by the
        !          1047:                            size of the char */
        !          1048:                         ByteCopy (&rgbFont [ Offset],
        !          1049:                                   &rgbFont [ Offset+ iDefBitmapSize],
        !          1050:                                   (LONG)(iEndOfBitmaps -
        !          1051:                                   ((cur_char + 1)->GIoffset)));
        !          1052: 
        !          1053:                         /* correct the offset table entries */
        !          1054:                         move_char = cur_char + 1;
        !          1055:                         for (j=i; j < iLastC; ++j){
        !          1056:                              move_char->GIoffset -= (LONG)iDefBitmapSize;
        !          1057:                              move_char++;
        !          1058:                         }
        !          1059:                     }
        !          1060:                     iEndOfBitmaps -= iDefBitmapSize;
        !          1061:                     /* move End-of-font to the left */
        !          1062:                     cur_char->GIoffset = iDefBitmapOffset;
        !          1063:                     /* point offset of cuurent char to default char */
        !          1064:                     cch++;
        !          1065:                 }
        !          1066:             }
        !          1067:             cur_char++;
        !          1068:         }
        !          1069: #endif
        !          1070:         /* recalculate some font attributes */
        !          1071:         lp2   -= (cch * iDefBitmapSize + height);
        !          1072:         for (i = 0; i < height; i++)
        !          1073:             *lp2++ = 0;             /* Fill in guaranteed blank character */
        !          1074: 
        !          1075:         cFont -= cch * iDefBitmapSize;
        !          1076:         font.WidthBytes = (WORD) (cFont - cFace)/ height;
        !          1077:         font.Size = (DWORD) (cFont + cHeader + cTable);
        !          1078:         font.Face = font.Size - cFace ;
        !          1079:         font.Version = 0x300;
        !          1080: 
        !          1081:         /* copy info into 3.0 (new) format header and set the additional
        !          1082:            fields */
        !          1083:         ByteCopy ((LPSTR)&font30, (LPSTR)&font, (DWORD)sizeof (font));
        !          1084:         font30.fsFlags        = 0;
        !          1085:         font30.fsFlags = (font.Family & 1 ? FSF_PROPORTIONAL : FSF_FIXED);
        !          1086:         font30.fsAspace       = 0;
        !          1087:         font30.fsBspace       = 0;
        !          1088:         font30.fsCspace       = 0;
        !          1089:         font30.fsColorPointer = 0L;
        !          1090:         for (i = 0; i < 4 ; i++)
        !          1091:             font30.fsReserved[i] = 0L;
        !          1092:     }
        !          1093: 
        !          1094:     /* Add the FaceName, if any, to the end of the bitmap */
        !          1095:     lstrcpy((LPSTR)lp2, (LPSTR)szFaceName);
        !          1096: 
        !          1097:        /*
        !          1098:         * Again we need to do some tricky things to get the header output
        !          1099:         * correct.  We want to run it through the conversion backwards until
        !          1100:         * we get the packed structure.
        !          1101:         */
        !          1102:        {
        !          1103:                BYTE jOutputBuffer [sizeof (font30)];
        !          1104: 
        !          1105:                if (iFontFormat == ID_FORMAT2) {
        !          1106: 
        !          1107:                        vBufferFromFontStruct (&font, (PBYTE)&jOutputBuffer);
        !          1108: 
        !          1109:                } else {
        !          1110: 
        !          1111:                        vBufferFromFont30Struct (&font30, (PBYTE)&jOutputBuffer);
        !          1112:                }
        !          1113: 
        !          1114:                bytecount = _lwrite((HFILE)nNewFile, (PBYTE)&jOutputBuffer, (DWORD)cHeader);
        !          1115:        }
        !          1116: 
        !          1117:     /* Write out Header Information */
        !          1118:     if (bytecount == cHeader) {
        !          1119: 
        !          1120:             /* Write out OffsetsTable */
        !          1121:          if (cTable == 0 || (_lwrite((HFILE)nNewFile, pjGlyphData, (DWORD)cTable)
        !          1122:                                == (UINT)cTable)){
        !          1123:               /* Write out Body */
        !          1124:               fontlen = cFont;
        !          1125:               while (fontlen >= SEGMENT_SIZE){
        !          1126: 
        !          1127:                  /* file write method if font size is 64k or greater
        !          1128:                  file is written in chunks of 65536 bytes (SEGMENT_SIZE)-lr */
        !          1129: 
        !          1130:                  /* First write as many bytes as _lwrite will allow(65534) */
        !          1131:                   if (_lwrite((HFILE)nNewFile, (CHAR  *)lpFont, WORD_LIMIT) ==
        !          1132:                         WORD_LIMIT){
        !          1133:                       fontlen -= WORD_LIMIT;
        !          1134:                             /* fontlen = no of bytes left to write*/
        !          1135:                       lpFont+= WORD_LIMIT; /* buffer ptr moved up by 64k */
        !          1136:                   }
        !          1137:                   else
        !          1138:                       sz = vszErrorWritingBody;
        !          1139: 
        !          1140:                   /* write the two bytes remaining in the segment */
        !          1141:                   if (_lwrite((HFILE)nNewFile, (CHAR  *)lpFont, 2) == 2){
        !          1142:                       fontlen -= 2;  /* fontlen = no of bytes left to write*/
        !          1143:                       lpFont+= 2;    /* buffer ptr moved up by 2 */
        !          1144:                   }
        !          1145:                   else
        !          1146:                       sz = vszErrorWritingBody;
        !          1147:               }
        !          1148:               /* segment only partially filled. Write the remaining bytes */
        !          1149:               if (_lwrite((HFILE)nNewFile, (CHAR  *)lpFont, (DWORD)fontlen) ==
        !          1150:                     (UINT) fontlen){
        !          1151:                    fChanged = FALSE;
        !          1152:                    sz= "";
        !          1153:               }
        !          1154:               else
        !          1155:                   sz = vszErrorWritingBody;
        !          1156:          }
        !          1157:          else
        !          1158:              sz = vszErrorWritingOffsets;
        !          1159:     }
        !          1160:     else
        !          1161:          sz = vszErrorWritingHdr;
        !          1162: 
        !          1163:     /* hack: Restore saved value of widthbytes, eliminating a variety
        !          1164:        of minor scrolling problems that follow after a File/Save */
        !          1165:     font.WidthBytes = widthsav;
        !          1166: 
        !          1167:     _lclose((HFILE)nNewFile);
        !          1168: 
        !          1169:        /* Tidy up */
        !          1170: 
        !          1171:     GlobalFree(lpFontBody);
        !          1172:     GlobalFree(pjGlyphData);
        !          1173:     GlobalFree(lpWork);
        !          1174: 
        !          1175:     SetCursor(hOldCursor);              /* Restore regular cursor */
        !          1176: 
        !          1177:     return sz;
        !          1178: }
        !          1179: 
        !          1180: /****************************************************************************
        !          1181:  * BOOL ResizeWidths(wChar)
        !          1182:  *
        !          1183:  * params : WORD wChar : new width of a single character
        !          1184:  *
        !          1185:  * purpose: resize work bitmap according to new character width by stretching/
        !          1186:  *          compressing all characters as neccesary
        !          1187:  *
        !          1188:  * returns: none
        !          1189:  *
        !          1190:  * side effects: Work bitmap changes.Some header info (regarding font dimensions
        !          1191:  *               altered as well
        !          1192:  ****************************************************************************/
        !          1193: 
        !          1194: 
        !          1195: BOOL
        !          1196: ResizeWidths(
        !          1197:     DWORD wChar
        !          1198:     )
        !          1199: {
        !          1200:     DWORD width;
        !          1201:     DWORD offset, i;
        !          1202: 
        !          1203:     /* Create a new bitmap to move the font definition bits into */
        !          1204:     width = (font.LastChar - font.FirstChar + 1) * wChar; /* In pixels */
        !          1205:     width = (width + 15) >> 4 << 1;     /* In even bytes */
        !          1206:     if (!GetNewMap(width, font.PixHeight))
        !          1207:         return (FALSE);
        !          1208: 
        !          1209:     /* Move the bits in */
        !          1210:     offset = 0;
        !          1211:     oldMode = SetStretchBltMode(hNewMemDC, COLORONCOLOR);
        !          1212:     for (i = font.FirstChar; i <= font.LastChar; i++)
        !          1213:         {
        !          1214: 
        !          1215:         StretchBlt(hNewMemDC, offset, 0,
        !          1216:                 wChar, font.PixHeight,                  /* New character */
        !          1217:                 hMemDC, offsets[i], 0,
        !          1218:                 font.PixWidth, font.PixHeight,          /* Old character */
        !          1219:                 SRCCOPY);
        !          1220:         offsets[i] = offset;
        !          1221:         offset += wChar;
        !          1222:         }
        !          1223:     SetStretchBltMode(hNewMemDC, oldMode);
        !          1224:     offsets[font.LastChar + 1] = offset;
        !          1225: 
        !          1226:     UseNewMap();                /* Switch Pointers and release the space */
        !          1227: 
        !          1228:     font.HorizRes = (WORD) Proport(font.HorizRes, wChar, font.PixWidth, 999);
        !          1229:     font.WidthBytes = (WORD) width;            /* Misc. ajustments */
        !          1230:     font.PixWidth = font.AvgWidth = (font.MaxWidth = (WORD) wChar);
        !          1231: 
        !          1232:     return (TRUE);
        !          1233: }
        !          1234: 
        !          1235: 
        !          1236: /****************************************************************************
        !          1237:  * BOOL SpreadWidths(wChar)
        !          1238:  *
        !          1239:  * purpose: spread/compress work bitmap (with variable width characters)
        !          1240:  *          in proportion with the maximum character width
        !          1241:  *
        !          1242:  * params : WORD wChar : new width of a character
        !          1243:  *
        !          1244:  * returns: none
        !          1245:  *
        !          1246:  * side effects: Work bitmap changes.Some header info (regarding font dimensions
        !          1247:  *               altered as well
        !          1248:  ****************************************************************************/
        !          1249: 
        !          1250: BOOL
        !          1251: SpreadWidths(
        !          1252:     DWORD wChar
        !          1253:     )
        !          1254: {
        !          1255:     DWORD offset, i;
        !          1256:     DWORD width, oldWidth, newWidths[257];
        !          1257: 
        !          1258:     /* Create a new bitmap to move the font definition bits into */
        !          1259:     width = 0;          /* Compute the new width */
        !          1260:     for (i = (DWORD) font.FirstChar; i <= (DWORD) font.LastChar; i++)
        !          1261:         {
        !          1262:         oldWidth = offsets[i + 1] - offsets[i];
        !          1263:         /* Compute new width to nearest whole number */
        !          1264:         newWidths[i] = Proport(oldWidth, wChar, font.MaxWidth, wBoxLim - 1);
        !          1265:         width += newWidths[i];
        !          1266:         }
        !          1267:     width = (width + 15) >> 4 << 1;     /* In even bytes */
        !          1268:     if (!GetNewMap(width, font.PixHeight))
        !          1269:         return(FALSE);
        !          1270: 
        !          1271:     /* Move the bits in */
        !          1272:     offset = 0;
        !          1273:     oldMode = SetStretchBltMode(hNewMemDC, COLORONCOLOR);
        !          1274:     for (i = font.FirstChar; i <= font.LastChar; i++)
        !          1275:         {
        !          1276:         oldWidth = offsets[i + 1] - offsets[i];
        !          1277:         StretchBlt(hNewMemDC, offset, 0,
        !          1278:                 newWidths[i], font.PixHeight,           /* New character */
        !          1279:                 hMemDC, offsets[i], 0,
        !          1280:                 oldWidth, font.PixHeight,               /* Old character */
        !          1281:                 SRCCOPY);
        !          1282:         offsets[i] = offset;
        !          1283:         offset += newWidths[i];
        !          1284:         }
        !          1285:     SetStretchBltMode(hNewMemDC, oldMode);
        !          1286:     offsets[font.LastChar + 1] = offset;
        !          1287: 
        !          1288:     UseNewMap();                /* Switch Pointers and release the space */
        !          1289:     font.HorizRes = (WORD) Proport(font.HorizRes, wChar, font.MaxWidth, 999);
        !          1290:     font.WidthBytes = (WORD) width;            /* Misc. ajustments */
        !          1291:     font.MaxWidth = (WORD) wChar;
        !          1292:     NewAverage();                       /* Compute new average width */
        !          1293: 
        !          1294:     return (TRUE);
        !          1295: }
        !          1296: 
        !          1297: 
        !          1298: /****************************************************************************
        !          1299:  * NewAverage()
        !          1300:  *
        !          1301:  * purpose: recalculate average width of a character in font
        !          1302:  *
        !          1303:  * params : none
        !          1304:  *
        !          1305:  * returns: none
        !          1306:  *
        !          1307:  * side effects: alters the average width parameter in font header
        !          1308:  *
        !          1309:  ****************************************************************************/
        !          1310: VOID
        !          1311: NewAverage(
        !          1312:     VOID
        !          1313:     )
        !          1314: {
        !          1315: #ifdef FOO
        !          1316:     WORD i, totalwidth;
        !          1317:     /* 12/23/85 -- use weighted avg of lower case letters (mikecr) */
        !          1318: 
        !          1319:     /* width of the space */
        !          1320:     totalwidth = (offsets[' ' + 1] - offsets[' ']) * widthweights[ALPHA_CNT];
        !          1321: 
        !          1322:     for (i = 0; i < ALPHA_CNT; i++)
        !          1323:             totalwidth += (offsets['a' + i + 1] - offsets['a' + i]) *
        !          1324:             widthweights[i];
        !          1325: 
        !          1326:     font.AvgWidth = totalwidth / TOTAL_WEIGHTS;
        !          1327: 
        !          1328:     /* round up if necessary */
        !          1329:     if (totalwidth % TOTAL_WEIGHTS >= (TOTAL_WEIGHTS >> 1))
        !          1330:             font.AvgWidth++;
        !          1331: 
        !          1332: #endif
        !          1333: 
        !          1334:     /* lets do a simple average here */
        !          1335:     font.AvgWidth = (WORD) (((offsets[font.LastChar+1] -
        !          1336:             offsets[font.FirstChar]) + (font.LastChar - font.FirstChar)/2) /
        !          1337:             (font.LastChar - font.FirstChar + 1));
        !          1338: 
        !          1339:     if (font.AvgWidth == 0) {
        !          1340:        font.AvgWidth++;
        !          1341:     }
        !          1342: }
        !          1343: 
        !          1344: 
        !          1345: /****************************************************************************
        !          1346:  * BOOL ResizeBody(width, height)
        !          1347:  *
        !          1348:  * purpose: adjust work bitmap according to new specified dimensions
        !          1349:  *
        !          1350:  * params : WORD width  : new width of font in pixels
        !          1351:  *          WORD height : new height of font in pixels
        !          1352:  *
        !          1353:  * returns: none
        !          1354:  *
        !          1355:  * side effects: Work bitmap changes.Some header info (regarding font dimensions
        !          1356:  *               altered as well
        !          1357:  ****************************************************************************/
        !          1358: 
        !          1359: BOOL
        !          1360: ResizeBody(
        !          1361:     DWORD width,
        !          1362:     DWORD height
        !          1363:     )
        !          1364: {
        !          1365: 
        !          1366:     /* Create a new bitmap to move the font definition bits into */
        !          1367:     if (!GetNewMap(width, height))
        !          1368:         return(FALSE);
        !          1369: 
        !          1370:     /* Move the bits in */
        !          1371:     oldMode = SetStretchBltMode(hNewMemDC, COLORONCOLOR);
        !          1372:     StretchBlt(hNewMemDC, 0, 0,
        !          1373:             width << 3, height,         /* New Char. */
        !          1374:             hMemDC, 0, 0,
        !          1375:             width << 3, font.PixHeight, /* Old Char. */
        !          1376:             SRCCOPY);
        !          1377:     SetStretchBltMode(hNewMemDC, oldMode);
        !          1378: 
        !          1379:     UseNewMap();                /* Switch Pointers and release the space */
        !          1380: 
        !          1381:     font.ExtLeading = (WORD) Proport(font.ExtLeading, height, font.PixHeight, 999);
        !          1382:     font.IntLeading = (WORD) Proport(font.IntLeading, height, font.PixHeight, 999);
        !          1383:     font.Ascent = (WORD) Proport(font.Ascent, height, font.PixHeight, 32);
        !          1384:     font.VertRes = (WORD) Proport(font.VertRes, height, font.PixHeight, 999);
        !          1385:     font.Points = (WORD) Proport(font.Points, height, font.PixHeight, 999);
        !          1386:     font.PixHeight = (WORD) height;            /* Fix misc. header values */
        !          1387:     font.WidthBytes = (WORD) width;
        !          1388: 
        !          1389:     return (TRUE);
        !          1390: }
        !          1391: 
        !          1392: 
        !          1393: /****************************************************************************
        !          1394:  * BOOL NewFirstChar(first)
        !          1395:  *
        !          1396:  * purpose: redefines first character in font and resizes work bitmap
        !          1397:  *          accordingly
        !          1398:  *
        !          1399:  * params : WORD first : new first character to be defined
        !          1400:  *
        !          1401:  * returns: none
        !          1402:  *
        !          1403:  * side effects: Work bitmap changes.Some header info (regarding font dimensions
        !          1404:  *               altered as well
        !          1405:  ****************************************************************************/
        !          1406: 
        !          1407: BOOL
        !          1408: NewFirstChar(
        !          1409:     DWORD first
        !          1410:     )
        !          1411: {
        !          1412:     DWORD  width, wDefault;
        !          1413:     DWORD offset, i;
        !          1414:     INT dw;
        !          1415: 
        !          1416:     if (first > font.FirstChar)         /* Smaller? */
        !          1417:         {
        !          1418:         ShrinkFont(first, font.LastChar);
        !          1419:         font.FirstChar = (BYTE) first;
        !          1420:         /*return(FALSE);*/
        !          1421:         return(TRUE);
        !          1422:         }
        !          1423: 
        !          1424:     /* If not smaller we must pad with the default character */
        !          1425:     wDefault = offsets[font.DefaultChar + 1] - offsets[font.DefaultChar];
        !          1426:     dw = wDefault * (font.FirstChar - first);           /* Extra width */
        !          1427:     width = offsets[font.LastChar + 1] + dw;    /* New width (pixels) */
        !          1428:     width = (width + 15) >> 4 << 1;             /* Width - even bytes */
        !          1429:     if (!GetNewMap(width, font.PixHeight))
        !          1430:         return(FALSE);           /* New work area */
        !          1431: 
        !          1432:     /* Move it in in two parts */
        !          1433:     /* First move in default characters */
        !          1434:     offset = 0;
        !          1435:     for (i = first; i < font.FirstChar; i++)
        !          1436:         {
        !          1437:         BitBlt(hNewMemDC, offset, 0,
        !          1438:                 wDefault, font.PixHeight,
        !          1439:                 hMemDC, offsets[font.DefaultChar], 0,
        !          1440:                 SRCCOPY);
        !          1441:         offsets[i] = offset;
        !          1442:         offset += wDefault;
        !          1443:         }
        !          1444:     /* Now move in the rest */
        !          1445:     BitBlt(hNewMemDC, offset, 0,
        !          1446:             offsets[font.LastChar + 1], font.PixHeight,
        !          1447:             hMemDC, 0, 0,
        !          1448:             SRCCOPY);
        !          1449: 
        !          1450:     UseNewMap();                /* Switch Pointers and release the space */
        !          1451: 
        !          1452:     /* Now fix up offsets table */
        !          1453:     for (i = font.FirstChar; i <= (DWORD)(font.LastChar + 1); i++)
        !          1454:         offsets[i] = offsets[i] + dw;           /* Shift the rest right */
        !          1455:     font.WidthBytes = (WORD) width;
        !          1456:     font.FirstChar = (BYTE) first;
        !          1457: 
        !          1458:     return (TRUE);
        !          1459: }
        !          1460: 
        !          1461: 
        !          1462: /****************************************************************************
        !          1463:  * ShrinkFont(first, last)
        !          1464:  *
        !          1465:  * purpose:  redefine the first and last charcter in the font and shrink
        !          1466:  *           work bitmap accordingly
        !          1467:  *
        !          1468:  * params :  WORD first : new first character to be defined
        !          1469:  *           WORD last  : new last character  "  "   "
        !          1470:  *
        !          1471:  * returns:  none
        !          1472:  *
        !          1473:  * side effects: Work bitmap changes.Some header info (regarding font dimensions
        !          1474:  *               altered as well
        !          1475:  ****************************************************************************/
        !          1476: 
        !          1477: VOID
        !          1478: ShrinkFont(
        !          1479:     DWORD first,
        !          1480:     DWORD last
        !          1481:     )
        !          1482: {
        !          1483:     DWORD width, widthPixels;
        !          1484:     DWORD i;
        !          1485:     INT dw;
        !          1486: 
        !          1487:     dw = offsets[first] - offsets[font.FirstChar];      /* left shift if any */
        !          1488:     widthPixels = offsets[last + 1] - offsets[first];   /* Width in pixels */
        !          1489:     width = (widthPixels + 15) >> 4 << 1;               /* Width - even bytes */
        !          1490:     if (!GetNewMap(width, font.PixHeight))
        !          1491:         return;           /* New work area.*/
        !          1492: 
        !          1493:     /* Now move the font into the reduced space */
        !          1494: 
        !          1495:     BitBlt(hNewMemDC, 0, 0,
        !          1496:             widthPixels, font.PixHeight,
        !          1497:             hMemDC, offsets[first], 0,
        !          1498:             SRCCOPY);
        !          1499: 
        !          1500:     UseNewMap();                /* Switch Pointers and release the space */
        !          1501: 
        !          1502:     if (dw)                             /* Ajust offsets */
        !          1503:         {
        !          1504:         for (i = first; i <= last + 1; i++)
        !          1505:             offsets[i] -= dw;
        !          1506:         }
        !          1507: 
        !          1508:     font.WidthBytes = (WORD) width;
        !          1509: 
        !          1510: }
        !          1511: 
        !          1512: 
        !          1513: /****************************************************************************
        !          1514:  * BOOL NewLastChar(last)
        !          1515:  *
        !          1516:  * purpose:  redefines the last character in the font
        !          1517:  *
        !          1518:  * params :  WORD last : number of character to be made the last character
        !          1519:  *
        !          1520:  * returns:  none
        !          1521:  *
        !          1522:  * side effects: Work bitmap changes.Some header info (regarding font dimensions
        !          1523:  *               altered as well
        !          1524:  *
        !          1525:  ****************************************************************************/
        !          1526: 
        !          1527: BOOL
        !          1528: NewLastChar(
        !          1529:     DWORD last
        !          1530:     )
        !          1531: {
        !          1532:     DWORD  width, wDefault;
        !          1533:     DWORD offset, i;
        !          1534:     INT dw;
        !          1535: 
        !          1536:     if (last < font.LastChar)           /* Smaller? */
        !          1537:         {
        !          1538:         ShrinkFont(font.FirstChar, last);
        !          1539:         font.LastChar = (BYTE) last;
        !          1540:         return(FALSE);
        !          1541:         }
        !          1542: 
        !          1543:     /* If not smaller we must pad with the default character */
        !          1544:     wDefault = offsets[font.DefaultChar + 1] - offsets[font.DefaultChar];
        !          1545:     dw = wDefault * (last - font.LastChar);             /* Extra width */
        !          1546:     offset = offsets[font.LastChar + 1];        /* Current end */
        !          1547:     width = offset + dw;                        /* New width (pixels) */
        !          1548:     width = (width + 15) >> 4 << 1;             /* Width - even bytes */
        !          1549:     if (!GetNewMap(width, font.PixHeight))
        !          1550:         return(FALSE);           /* New work area */
        !          1551: 
        !          1552:     /* Move it in in two parts */
        !          1553:     /* First move in the existing font */
        !          1554:     BitBlt(hNewMemDC, 0, 0,
        !          1555:             offset, font.PixHeight,
        !          1556:             hMemDC, 0, 0,
        !          1557:             SRCCOPY);
        !          1558:     /* Then move in default characters */
        !          1559:     for (i = font.LastChar + 1; i <= last;)
        !          1560:         {
        !          1561:         BitBlt(hNewMemDC, offset, 0,
        !          1562:                 wDefault, font.PixHeight,
        !          1563:                 hMemDC, offsets[font.DefaultChar], 0,
        !          1564:                 SRCCOPY);
        !          1565:         offset += wDefault;
        !          1566:         offsets[++i] = offset;
        !          1567:         }
        !          1568: 
        !          1569:     UseNewMap();                /* Switch Pointers and release the space */
        !          1570: 
        !          1571:     font.WidthBytes = (WORD) width;
        !          1572:     font.LastChar = (BYTE) last;
        !          1573: 
        !          1574:     return (TRUE);
        !          1575: }
        !          1576: 
        !          1577: 
        !          1578: /****************************************************************************
        !          1579:  * BOOL CharWidth(iChar, wBox)
        !          1580:  *
        !          1581:  * purpose: resizes selected char according to new dimensions. (only for
        !          1582:  *          variable pitch)
        !          1583:  *
        !          1584:  * params : BYTE iChar : character to resize
        !          1585:  *          WORD wBox  : new width of char in pixels
        !          1586:  *
        !          1587:  * returns: none
        !          1588:  *
        !          1589:  * side effects: work bitmap pixel values and header info(regarding font
        !          1590:  *               dimensions) altered
        !          1591:  *
        !          1592:  ****************************************************************************/
        !          1593: 
        !          1594: BOOL
        !          1595: CharWidth(
        !          1596:     BYTE iChar,                             /* Character to change */
        !          1597:     DWORD wBox                               /* New width */
        !          1598:     )
        !          1599: {
        !          1600:     DWORD  width, nChars;
        !          1601:     DWORD  w1, w2, i;
        !          1602:     INT dw;
        !          1603: 
        !          1604:     nChars = font.LastChar - font.FirstChar + 1;        /* Character count */
        !          1605:     dw = wBox - (offsets[iChar + 1] - offsets[iChar]);  /* Width change */
        !          1606:     width = offsets[font.LastChar + 1] + dw;            /* New width (pixels) */
        !          1607:     width = (width + 15) >> 4 << 1;                     /* Width - even bytes */
        !          1608:     if (!GetNewMap(width, font.PixHeight))
        !          1609:         return(FALSE);                   /* New work area */
        !          1610: 
        !          1611:     /* Move it in in two parts */
        !          1612:     /* First move up to and including iChar */
        !          1613:     w1 = offsets[iChar + 1];            /* Width (in pixels) to move */
        !          1614:     BitBlt(hNewMemDC, 0, 0,
        !          1615:             w1 + dw, font.PixHeight,
        !          1616:             hMemDC, 0, 0,
        !          1617:             SRCCOPY);
        !          1618:     /* Now move in the rest */
        !          1619:     if (iChar < (BYTE) font.LastChar)        /* Part to right of elision */
        !          1620:         {
        !          1621:         w2 = offsets[font.LastChar + 1] - offsets[iChar + 1];
        !          1622:         BitBlt(hNewMemDC, offsets[iChar] + wBox, 0,
        !          1623:                 w2, font.PixHeight,
        !          1624:                 hMemDC, offsets[iChar + 1], 0,
        !          1625:                 SRCCOPY);
        !          1626:         }
        !          1627: 
        !          1628:     UseNewMap();                /* Switch Pointers and release the space */
        !          1629: 
        !          1630:     /* Now fix up offsets table */
        !          1631:     for (i = iChar + 1;                         /* Where changes start */
        !          1632:         i <= (DWORD)(font.LastChar + 1); i++)            /* Ajust offsets */
        !          1633:         offsets[i] = offsets[i] + dw;           /*  .. by adding dw */
        !          1634:     font.WidthBytes = (WORD) width;
        !          1635:     NewAverage();
        !          1636: 
        !          1637:     return (TRUE);
        !          1638: }
        !          1639: 
        !          1640: /****************************************************************************
        !          1641:  * BoxToClipboard(ptA, width, height)
        !          1642:  *
        !          1643:  * purpose: write char (or part of it) to clipboard
        !          1644:  *
        !          1645:  * params : POINT ptA    : upper left coordinate
        !          1646:  *          DWORD width  : width of char in pixels
        !          1647:  *          DWORD height : height of char in pixels
        !          1648:  * returns: none
        !          1649:  *
        !          1650:  * side effects: none
        !          1651:  *
        !          1652:  ****************************************************************************/
        !          1653: VOID
        !          1654: BoxToClipboard(
        !          1655:     POINT ptA,                               /* Upper left point */
        !          1656:     DWORD width,
        !          1657:     DWORD height                      /* Size */
        !          1658:     )
        !          1659: {
        !          1660:     HDC hDC;
        !          1661:     DWORD x, y;
        !          1662: 
        !          1663:     hDC = GetDC(hFont);                         /* DC to be compatible with */
        !          1664:     hNewBitmap = CreateBitmap(
        !          1665:                     width, height,
        !          1666:                     1, 1, (LPBYTE)NULL);
        !          1667:     hNewMemDC = CreateCompatibleDC(hDC);                /* Create a DC */
        !          1668:     SelectObject(hNewMemDC, hNewBitmap);                /* Relate them */
        !          1669:     ReleaseDC(hFont, hDC);                      /* Done with font DC */
        !          1670: 
        !          1671:     for (x = 0; x < width; x++)
        !          1672:         for (y = 0; y < height; y++)
        !          1673:             SetPixel(hNewMemDC, x, y, matBox[x + ptA.x][y + ptA.y] == TRUE ?
        !          1674:             BLACK : WHITE);
        !          1675: 
        !          1676:     /* Now wake up Clipboard and empty it */
        !          1677:     if (!OpenClipboard(hFont))
        !          1678:         ErrorBox(hBox, vszCannotOpenClip); // , vszCopyingToClip);
        !          1679:     else        /* Ok: We got the Clipboard */
        !          1680:         {
        !          1681:         EmptyClipboard();
        !          1682:         SetClipboardData(CF_BITMAP, hNewBitmap);        /* Tell Clipboard */
        !          1683:         }
        !          1684: 
        !          1685:     /* Tidy things up */
        !          1686:     CloseClipboard();
        !          1687:     DeleteDC(hNewMemDC);
        !          1688: }
        !          1689: 
        !          1690: 
        !          1691: /****************************************************************************
        !          1692:  * WORD ClipboardToBox(ptA, width, height, fFit)
        !          1693:  *
        !          1694:  * purpose: copies char (or part of char ) from clipboard to work bitmap
        !          1695:  *          stretching it if need be
        !          1696:  *
        !          1697:  * params : PIONT ptA    : upper left coordinate
        !          1698:  *          DWORD width  : width of char in pixels
        !          1699:  *          DWORD height : height of char in pixels
        !          1700:  *          BOOL fFit   : flag to indicate if default width is to be used
        !          1701:  * returns: none
        !          1702:  *
        !          1703:  * side effects: pixel values of bitmap may change for char
        !          1704:  *
        !          1705:  ****************************************************************************/
        !          1706: 
        !          1707: DWORD
        !          1708: ClipboardToBox(
        !          1709:     POINT ptA,                               /* Upper left point */
        !          1710:     DWORD width,
        !          1711:     DWORD height,                     /* Size */
        !          1712:     BOOL fFit                               /* Use default width if TRUE */
        !          1713:     )
        !          1714: {
        !          1715:     BITMAP bitmap;
        !          1716:     HDC hDC;
        !          1717:     DWORD x, y;
        !          1718:     HANDLE hT;
        !          1719: 
        !          1720:     if (!OpenClipboard(hFont)) {
        !          1721:         ErrorBox(hBox, vszCannotOpenClip);
        !          1722:         return 0;
        !          1723:     }
        !          1724:     hNewBitmap = GetClipboardData(CF_BITMAP);
        !          1725: 
        !          1726:     /* Check if we got something like a character */
        !          1727:     if (GetObject(hNewBitmap, sizeof(BITMAP), (LPSTR)&bitmap) != sizeof(BITMAP))
        !          1728:         {   /* What did we get */
        !          1729:         ErrorBox(hBox, vszErrorClip);
        !          1730:         CloseClipboard();
        !          1731:         return 0;
        !          1732:     }
        !          1733: 
        !          1734: 
        !          1735:     if (fFit && ((WORD)bitmap.bmWidth <= font.MaxWidth))
        !          1736:         width = bitmap.bmWidth;
        !          1737: 
        !          1738:     hDC = GetDC(hFont);                         /* DC to be compatible with */
        !          1739:     hBoxBitmap = CreateBitmap(
        !          1740:                     width, height,
        !          1741:                     1, 1, (LPBYTE)NULL);
        !          1742:     hBoxMemDC = CreateCompatibleDC(hDC);                /* Create a DC */
        !          1743:     hT = SelectObject(hBoxMemDC, hBoxBitmap);           /* Relate them */
        !          1744:     if (hT == NULL || hDC == NULL || hBoxBitmap == NULL || hBoxMemDC == NULL) {
        !          1745:         ErrorBox(hBox, vszErrorClip);
        !          1746:        CloseClipboard();
        !          1747:        DeleteDC(hBoxMemDC);
        !          1748:        DeleteObject(hBoxBitmap);
        !          1749:         return 0;
        !          1750:     }
        !          1751: 
        !          1752:     /* Get a DC to relate to the Bitmap we just got */
        !          1753:     hNewMemDC = CreateCompatibleDC(hDC);                /* Create a DC */
        !          1754:     hT = SelectObject(hNewMemDC, hNewBitmap);           /* Relate them */
        !          1755:     ReleaseDC(hFont, hDC);                      /* Done with font DC */
        !          1756:     if (hT == NULL || hNewMemDC == NULL) {
        !          1757:         ErrorBox(hBox, vszErrorClip);
        !          1758:        CloseClipboard();
        !          1759:        DeleteDC(hNewMemDC);
        !          1760:        DeleteDC(hBoxMemDC);
        !          1761:        DeleteObject(hBoxBitmap);
        !          1762:         return 0;
        !          1763:     }
        !          1764: 
        !          1765:     /* Now StretchBlt whatever was on the clipboard into the character */
        !          1766:     oldMode = SetStretchBltMode(hBoxMemDC, COLORONCOLOR);
        !          1767:     fFit = StretchBlt(hBoxMemDC, 0, 0, width, height,
        !          1768:                 hNewMemDC, 0, 0, bitmap.bmWidth, bitmap.bmHeight, SRCCOPY);
        !          1769:     if (!fFit || !oldMode) {
        !          1770:         ErrorBox(hBox, vszErrorClip);
        !          1771:        CloseClipboard();
        !          1772:        DeleteDC(hNewMemDC);
        !          1773:        DeleteDC(hBoxMemDC);
        !          1774:        DeleteObject(hBoxBitmap);
        !          1775:         return 0;
        !          1776:     }
        !          1777:     (void)SetStretchBltMode(hBoxMemDC, oldMode);
        !          1778:     for (x = 0; x < width; x++)
        !          1779:         for (y = 0; y < height; y++)
        !          1780:             matBox[x + ptA.x] [y + ptA.y] = (CHAR)(GetPixel(hBoxMemDC, x, y) ?
        !          1781:                 0 : 1);
        !          1782:     /* Tidy things up */
        !          1783:     DeleteDC(hNewMemDC);
        !          1784:     DeleteDC(hBoxMemDC);
        !          1785:     DeleteObject(hBoxBitmap);
        !          1786:     CloseClipboard();
        !          1787:     return(width);
        !          1788: }
        !          1789: 
        !          1790: 
        !          1791: /****************************************************************************
        !          1792:  * ToClipboard(iChar, width, height)
        !          1793:  *
        !          1794:  * purpose: write char in edit box to clipboard
        !          1795:  *
        !          1796:  * params : BYTE iChar  : number of char to be copied to clipboard
        !          1797:  *          DWORD width  : width of char in pixels
        !          1798:  *          DWORD height : height of char in pixels
        !          1799:  *
        !          1800:  * returns: none
        !          1801:  *
        !          1802:  * side effects: none
        !          1803:  *
        !          1804:  ****************************************************************************/
        !          1805: 
        !          1806: VOID
        !          1807: ToClipboard(
        !          1808:     BYTE iChar,
        !          1809:     DWORD width,             /* Here in Pixels */
        !          1810:     DWORD height             /* Also in Pixels */
        !          1811:     )
        !          1812: {
        !          1813:     HDC hDC;
        !          1814: 
        !          1815:     hDC = GetDC(hFont);                         /* DC to be compatible with */
        !          1816:     hNewBitmap = CreateBitmap(
        !          1817:                     width,                      /* Width of font in pixels */
        !          1818:                     height,
        !          1819:                     1, 1, (LPBYTE)NULL);
        !          1820:     hNewMemDC = CreateCompatibleDC(hDC);                /* Create a DC */
        !          1821:     SelectObject(hNewMemDC, hNewBitmap);                /* Relate them */
        !          1822:     ReleaseDC(hFont, hDC);                      /* Done with font DC */
        !          1823: 
        !          1824:     BitBlt(hNewMemDC, 0, 0, width, height,      /* Move Character in */
        !          1825:             hMemDC, offsets[iChar], 0, NOTSRCCOPY);
        !          1826: 
        !          1827:     /* Now wake up Clipboard and empty it */
        !          1828:     if (!OpenClipboard(hFont))
        !          1829:         ErrorBox(hBox, vszCannotOpenClip); // , vszCopyingToClip);
        !          1830:     else        /* Ok: We got the Clipboard */
        !          1831:         {
        !          1832:         EmptyClipboard();
        !          1833:         SetClipboardData(CF_BITMAP, hNewBitmap);        /* Tell Clipboard */
        !          1834:         }
        !          1835: 
        !          1836:     /* Tidy things up */
        !          1837:     CloseClipboard();
        !          1838:     DeleteDC(hNewMemDC);
        !          1839: }
        !          1840: 
        !          1841: 
        !          1842: /****************************************************************************
        !          1843:  * GetNewMap(width, height)
        !          1844:  *
        !          1845:  * purpose: create new bitmap of the given width and height.
        !          1846:  *
        !          1847:  * params : WORD width  : width of bitmap in pixels
        !          1848:  *          WORD height : height of bitmap in pixels
        !          1849:  *
        !          1850:  * returns: TRUE if successful, FALSE otherwise
        !          1851:  *
        !          1852:  * side effects: Handle and DC values of new DC assigned
        !          1853:  *
        !          1854:  ****************************************************************************/
        !          1855: 
        !          1856: BOOL
        !          1857: GetNewMap(
        !          1858:     DWORD width,
        !          1859:     DWORD height              /* New size */
        !          1860:     )
        !          1861: {
        !          1862:     HDC hDC;
        !          1863: 
        !          1864:     if (height==0) /* Check if something stupid is happening */
        !          1865:         height=font.PixHeight; /* Fix it */
        !          1866: 
        !          1867:     /* Put up an houglass ... this may take a while */
        !          1868:     if (!hHourGlass)
        !          1869:         hHourGlass = LoadCursor(NULL, IDC_WAIT);        /* Get Hourglass */
        !          1870:     hOldCursor = SetCursor(hHourGlass);         /* Show hourglass */
        !          1871: 
        !          1872:     /* Create a new bitmap to move the font definition bits into */
        !          1873:     hDC = GetDC(hFont);                         /* DC to be compatible with */
        !          1874:     hNewBitmap = CreateBitmap(
        !          1875:                     width << 3,                 /* Width of font in pixels */
        !          1876:                     height,
        !          1877:                     1, 1, (LPBYTE)NULL);
        !          1878:     if (!hNewBitmap)
        !          1879:         {
        !          1880:         ErrorBox(hBox, vszNotEnoughMem); // , vszAllocatingSpace);
        !          1881:         ReleaseDC(hFont, hDC);    /* bug# 2380 */
        !          1882:         return FALSE;
        !          1883:         }
        !          1884: 
        !          1885:     hNewMemDC = CreateCompatibleDC(hDC);                /* Create a DC */
        !          1886:     SelectObject(hNewMemDC, hNewBitmap);                /* Relate them */
        !          1887:     ReleaseDC(hFont, hDC);                      /* Done with font DC */
        !          1888:     PatBlt(hNewMemDC, 0, 0, width << 3, height, BLACKNESS);     /* Clear it */
        !          1889:     return TRUE;
        !          1890: }
        !          1891: 
        !          1892: 
        !          1893: /****************************************************************************
        !          1894:  * UseNewMap()
        !          1895:  *
        !          1896:  * params : none
        !          1897:  *
        !          1898:  * purpose: discard old bitmap and replace it with new one
        !          1899:  *
        !          1900:  * returns: none
        !          1901:  *
        !          1902:  * side effects: Handle to old bitmap and handle to old bitmap DC replaced
        !          1903:  *               by those of new bitmap respectively
        !          1904:  *
        !          1905:  ****************************************************************************/
        !          1906: 
        !          1907: VOID
        !          1908: UseNewMap(
        !          1909:     VOID
        !          1910:     )
        !          1911: {
        !          1912:     DeleteDC(hMemDC);
        !          1913:     DeleteObject(hBitmap);              /* Release old space */
        !          1914:     hBitmap = hNewBitmap;
        !          1915:     hMemDC = hNewMemDC;              /* Release old space */
        !          1916:     SetCursor(hOldCursor);              /* Restore regular cursor */
        !          1917: }
        !          1918: 
        !          1919: 
        !          1920: 
        !          1921: VOID
        !          1922: DeleteGlobalBitmap(
        !          1923:     VOID
        !          1924:     )
        !          1925: {
        !          1926:     if (hMemDC)
        !          1927:         DeleteDC(hMemDC);
        !          1928:     if (hBitmap)
        !          1929:         DeleteObject(hBitmap);
        !          1930: }
        !          1931: 
        !          1932: 
        !          1933: DWORD
        !          1934: Proport(
        !          1935:     DWORD value,
        !          1936:     DWORD top,
        !          1937:     DWORD bottom,
        !          1938:     DWORD limit
        !          1939:     )
        !          1940:     /* Reproportion a value by the ratio top/bottom to the nearest integer
        !          1941:      * and make sure we are still in range */
        !          1942: {
        !          1943:     return min(limit, (DWORD)((1 + 2 * value * top) / (2 * bottom)));
        !          1944: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.