home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / CVTICONS.ZIP / CVTICONS.C < prev    next >
C/C++ Source or Header  |  1991-09-14  |  25KB  |  715 lines
  1. /*****************************************************************************
  2.  
  3.   CvtIcons.exe Copyright @ 1991 Jay Giganti All Rights Reserved
  4.  
  5.               All Options are Mutually Exclusive
  6.  
  7.          x : Extracts Icons from Windows ICO file(s)
  8.          w : Converts ICO files from PM to Windows
  9.          p : Converts ICO files from Windows to PM
  10.          ? : Displays this screen
  11.  
  12.         Usage CVTICONS -option File (Wild Cards Accepted)
  13.  
  14.         examples cvticons -x c:\windows\*.*
  15.                  cvticons -p *.ico
  16.  
  17.         example 1 : will extract all icons from the files in c:\windows
  18.                     directory and will create them in your current directory
  19.  
  20.         example 2 : will convert all ICO files in your current directory
  21.                     into ICP files in the PM format in your current directory
  22.         
  23. This program currently does three things.
  24. Extracts Icons:
  25.   It will extract Icons from windows EXE and DLL files.  It scans through
  26.   these files and will create a file with and extension of .ICO based upon
  27.   2 things.  First it will look in the resource table for any Names, if it
  28.   finds a name it will use up to 8 characters of it to create the file
  29.   name.  If There were no names found in the resource table, or there were
  30.   more icons than names, (ie -- several Icons in one directory entry) then
  31.   the icon name will containg the first 5 characters if the program it is
  32.   stripping it from, and then append a 3 digit number,m thus you can process
  33.   a file with up 1000 icons in it.  
  34.   side note:  I stripped a file form the MS-DOS program  under windows and
  35.               found a 64x64 OS/2 1.1 icon format.
  36.  
  37. Converts Icons To PM Format:
  38.   This will translate an ICO file into a PM format.  It creates the file
  39.   with an .ICP extension.  Currently I will only copy one Icon from each ICO
  40.   file, since this is how I write them.  If Needed I will add multiple
  41.   icons per ICO file handling.  The format for the icon will be written
  42.   in its current dimensions, ie: a 32x32 stays 32x32. Under OS/2 1.2 it
  43.   seems that if they are not 64x64 then it is not in a device independent (DI)
  44.   format, thus when loaded into the Icon Editor, you are told the It has
  45.   created on for you, if you save the file, then this 64x64 DI format will
  46.   be written to disk along with the origional 32x32 format.  I have the Icon
  47.   Editor do all translation.  In the furture I might do the streching required
  48.   to create a 64x64 bitmap and thus the resulting PM file will be smaller 
  49.   and the icon editor won't complain.  The reason it would be smaller is 
  50.   because there would only be one format stored in it.
  51.  
  52. Converts Icons To Windows 3.0 Format:
  53.   This will translate a PM Icon file into a Windows format.  It will translate
  54.   all Icons in the file, as long as they are <= 32x32.  I might add the
  55.   functionality to squeeze 64x64 to 32x32 but the Icon edititor does a good
  56.   job.  Thus if you have a 64x64 then select a VGA type and it will be 
  57.   converted to a 32x32 format which I can read and save in a file.  The
  58.   file will be named with the filename and the extensions .ICW. If there
  59.   is more than one Icon which is <= 32x32 then the next filename will be
  60.   created with the first 6 characters of the filename plus a 2 digit number
  61.   and then .ICW appended to it.
  62.  
  63.   In the future I will port this to a Windows and PM app but this does the
  64.   job for now.  It is a dos program.  Also I will probably add the ability
  65.   to read and write multiple icons per ICO file, and the ability to extract
  66.   icons from windows files and convert them directly to PM format.  Currently
  67.   you have to extract and then convert.  I also will probably add the ability
  68.   to extract Icons from OS/2 files.  Until then I hope this utility helps.
  69.  
  70. ****************************************************************************/
  71.  
  72. #include <stdio.h>
  73. #include <stdlib.h>
  74. #include <io.h>
  75. #include <fcntl.h>
  76. #include <string.h>
  77. #include <malloc.h>
  78. #include <ctype.h>
  79. #include <conio.h>
  80. #include <sys\types.h>
  81. #include <sys\stat.h>
  82. #include "stdefs.h"
  83. #include "newexe.h"
  84. #include "rsrcico.h"
  85. #include "rsrcbmp.h"
  86. #include "cvticons.h"
  87. #include "os2defs.h"
  88.  
  89. extern int  GetOpt(int nArgc, char **szArgv, char *szOpts);
  90. extern int  gnOptInd;
  91. extern char *gszOptArg;
  92.  
  93.                 /* Global Variables */
  94. static short gfhInFile;
  95. static short gfhOutFile;
  96. static char  gIconNames[1000][9];
  97. static WORD  gwNames;
  98. static char  gszFileName[13];
  99. /***************************************************************************
  100.    Main -- Entry point
  101. ****************************************************************************/
  102. short main(short nArgc, char **szArgv)
  103. {
  104.   int         nCntr;
  105.   BYTE        Flag = NONE;
  106.   char        *Name;
  107.   
  108.   if (nArgc < 2)
  109.     DisplayUsage();
  110.   
  111.   nCntr = GetOpt(nArgc, szArgv, "?pwx");
  112.   switch(nCntr)
  113.   {
  114.     case 'x' :
  115.       Flag = EXTRACT;
  116.       break;
  117.  
  118.     case 'p' :
  119.       Flag = TO_PM;
  120.       break;
  121.            
  122.     case 'w' :
  123.       Flag = TO_WIN;
  124.       break;
  125.     
  126.     case '?' :
  127.       DisplayUsage();
  128.   }     
  129.   if (Flag == NONE)
  130.   {
  131.     DisplayUsage();
  132.     return 0;
  133.   }
  134.   for(nCntr = 0; gnOptInd < nArgc; ++gnOptInd)
  135.   {    
  136.     if (nCntr++ == 23)
  137.     {
  138.       printf("\t\t\t==> Hit Any Key To Continue <==");
  139.       (void) getche();
  140.       printf("\n\n");
  141.       nCntr = 0;
  142.     }    
  143.     gfhInFile = open(szArgv[gnOptInd], O_BINARY | O_RDONLY); 
  144.     if (gfhInFile == -1)
  145.     {
  146.       printf("Could Not Open File\n");
  147.       continue;
  148.     }
  149.     Name = GetFileName(szArgv[gnOptInd]);
  150.     strcpy(gszFileName, Name);
  151.     printf("%-12s : ", gszFileName);
  152.     switch (Flag)
  153.     {
  154.       case EXTRACT:
  155.         ExtractFileInfo();
  156.         break;
  157.         
  158.       case TO_PM:
  159.         ConvertToPM();
  160.         break;
  161.         
  162.       default:
  163.         ConvertToWin();
  164.         break;
  165.     }
  166.     close(gfhInFile);
  167.   }
  168.   return 0;
  169. }
  170. /***************************************************************************/
  171. /* Get File Name : Gets Just the Filename -- Strips Drive and Directory    */
  172. /***************************************************************************/
  173. void GetFileName(char *FullName)
  174. {
  175.   char *pCh;
  176.   
  177.   pCh = FullName;
  178.   while (*pCh != '\0')
  179.     ++pCh;
  180.   --pCh;           
  181.                     /* Locate Start Of File Name */
  182.   while (pCh > FullName && *pCh != '\\' && *pCh != ':' && *pCh != '/')
  183.     --pCh;
  184.   if (pCh > FullName)
  185.     ++pCh;         /* Move To Right Of Pathname Separator */
  186.  
  187.   return pCh;
  188. }
  189.  
  190. /***************************************************************************/
  191. /* Fatal -- issues a diagnostic message and terminates               */
  192. /***************************************************************************/
  193. void Fatal(char *szMesg)
  194. {
  195.   strcat(szMesg, "\n");
  196.   fputs("Error : ", stderr);
  197.   fputs(szMesg, stderr);
  198.   exit(2);
  199. }
  200. /***************************************************************************/
  201. /***************************************************************************/
  202. void DisplayUsage(void)
  203. {
  204.   printf("\n\n\n\t      -- CvtIcons : Copyright @ 1991 Jay Giganti --\n\n");
  205.   printf("\tExtracts Icons from EXE & DLL Window Files Creating ICO files\n");
  206.   printf("\tConverts Icons between Windows and Program Manager formats\n");
  207.   printf("\tCreates the ICO file name from entry in the resource table\n");
  208.   printf("\n\tCurrently Only 1 Icon per WIN ICO File will be converted\n");
  209.   printf("\tWhen Converting, the new file will be created with an\n");
  210.   printf("\tExtension of either ICP or ICW; depending on option\n");
  211.   printf("\tAn Icons dimensions, in PM format, must be 32x32 or less\n\n");
  212.   printf("\n\t\t    All Options are Mutually Exclusive\n\n");
  213.   printf("\t\tx : Extracts Icons from Windows ICO file(s)\n");
  214.   printf("\t\tw : Converts ICO files from PM to Windows\n");
  215.   printf("\t\tp : Converts ICO files from Windows to PM\n");
  216.   printf("\t\t? : Displays this screen\n");
  217.   printf("\n\t      Usage CVTICONS -option File (Wild Cards Accepted)\n");
  218.   exit(1);
  219. }
  220. /***************************************************************************/
  221. /***************************************************************************/
  222. void ExtractFileInfo(void)
  223. {
  224.   OLDEXEHDR OldHdr;
  225.   NEWEXEHDR NewHdr;
  226.   BYTE      byBits;
  227.   
  228.   switch(byBits = GetFileType(&OldHdr))
  229.   {      
  230.     case DOS:
  231.       printf("Is A Non Windows Application\n");
  232.       return;
  233.  
  234.     case WIN:
  235.       lseek(gfhInFile, OldHdr.dwNewExeOfs, SEEK_SET);
  236.       read(gfhInFile, (PSTR) &NewHdr, sizeof(NewHdr));
  237.       if ((NewHdr.bySigByte1 != 'N') || (NewHdr.bySigByte2 != 'E'))
  238.       {
  239.         printf("Has An Improper Signature for a Windows App\n");
  240.         return;
  241.       }
  242.       ProcessResources(NewHdr.wResourceOfs + OldHdr.dwNewExeOfs,
  243.                    NewHdr.wResidentOfs - NewHdr.wResourceOfs);
  244.       break;          
  245.  
  246.     default :
  247.       printf("Is An Unknown file format\n");
  248.       return;
  249.   }
  250. }
  251. /***************************************************************************/
  252. /***************************************************************************/
  253. BYTE GetFileType(OLDEXEHDR *Hdr)
  254. {
  255.   read(gfhInFile, (PSTR)Hdr, sizeof *(Hdr));
  256.   if((Hdr->bySigByte1 != 'M') || (Hdr->bySigByte2 != 'Z'))
  257.     return 0;
  258.   if(Hdr->wRelocOfs == 0x40)
  259.     return WIN;
  260.   else
  261.     return DOS;
  262. }
  263. /***************************************************************************/
  264. /***************************************************************************/
  265. void ProcessResources(DWORD dwOfs, WORD wSize)
  266. {
  267.   RSRCTBL    rt;
  268.   WORD       wShiftCount;
  269.   WORD       wBits;
  270.   RSRCENTRY  *re;
  271.   long         lOfs;
  272.   BYTE       bHasIcons;
  273.   
  274.   bHasIcons = FALSE;
  275.   if (wSize)
  276.   {
  277.     lseek(gfhInFile, dwOfs, SEEK_SET);
  278.     read(gfhInFile, &rt, sizeof(rt));
  279.     wShiftCount = rt.wShiftCount;
  280.     while (rt.wType != 0)
  281.     {      
  282.       if ((re =(RSRCENTRY *)malloc(rt.wFollowing*sizeof(RSRCENTRY))) == NULL)
  283.     Fatal("Unable to allocate memory for Resource Entries");
  284.       read(gfhInFile, re, sizeof(RSRCENTRY) * rt.wFollowing);
  285.       wBits = rt.wType & 0x7FFF;
  286.       if (wBits == RS_ICON || wBits == RS_RESNAMES)
  287.       {
  288.         lOfs = tell(gfhInFile);
  289.         if (wBits == RS_ICON)
  290.         {
  291.           bHasIcons = TRUE;
  292.           if (rt.wFollowing > 1)
  293.             printf("Processing %u Icons\n", rt.wFollowing);
  294.           else
  295.             printf("Processing %u Icon\n", rt.wFollowing);          
  296.           ProcessIcons(rt.wFollowing, wShiftCount, re);
  297.         }
  298.         else
  299.         {
  300.           GetResourceNames((long)((long)re->wOffset << wShiftCount));
  301.           if(gwNames == 1)
  302.             printf("Located 1 Name - ");
  303.           if(gwNames > 1)
  304.             printf("Located %d Names - ", gwNames);
  305.         }
  306.         lseek(gfhInFile, lOfs, SEEK_SET);
  307.       }
  308.       free(re);
  309.       read(gfhInFile, &rt, sizeof(rt));
  310.     }
  311.     if (!bHasIcons)
  312.       printf("Does Not Contain Any Icons\n");
  313.   }
  314.   else
  315.     printf("Does Not Contain Any Resources\n");
  316. }
  317. /***************************************************************************/
  318. /***************************************************************************/
  319. void ProcessIcons(WORD wEntries,  WORD wShiftCount, RSRCENTRY *re)
  320. { 
  321.   ICOHDR    icoHdr;
  322.   char      szFileName[13];
  323.   char      szBuf[4];
  324.   RSRCENTRY *pre;
  325.   PSTR      pRsrc;
  326.   long      lOfs;  
  327.   WORD      wSize;
  328.   WORD      wCntr;
  329.   char      *pExt;
  330.   int       nEnd;
  331.     
  332.   icoHdr.wReserved = 0x0000;
  333.   icoHdr.wType     = 0x0001;
  334.   icoHdr.wCount    = 0x0001;
  335.   wSize            = sizeof(BITMAPINFOHEADER);  
  336.   if ((pRsrc = (PSTR)malloc(wSize)) == NULL)
  337.     Fatal("Unable to allocate memory for Resource Entry");
  338.     
  339.   for (wCntr = 0; wCntr < wEntries; wCntr++)
  340.   {
  341.     pre  = (re + wCntr);                     /*Set to curent Resource entry */
  342.     lOfs = (long)pre->wOffset << wShiftCount;/*Calculate offset to seek to  */
  343.     lseek(gfhInFile, lOfs,  SEEK_SET);  
  344.     read(gfhInFile,  pRsrc, wSize);
  345.     if (wCntr >= gwNames)
  346.     {
  347.       pExt = strrchr(gszFileName, '.');
  348.       nEnd = strlen(gszFileName) - strlen(pExt);
  349.       if (nEnd > 5)
  350.         nEnd = 5;
  351.       strncpy(szFileName, gszFileName, nEnd);
  352.       szFileName[nEnd] = '\0';
  353.       sprintf(szBuf, "%.3d", wCntr);
  354.       strcat(szFileName, szBuf);
  355.     }
  356.     else
  357.       strcpy(szFileName, gIconNames[wCntr]);
  358.     strcat(szFileName, ".ICO");
  359.     if ((gfhOutFile= open(szFileName, O_BINARY | O_CREAT | O_TRUNC | O_WRONLY,
  360.          S_IREAD  | S_IWRITE)) == -1)
  361.     {
  362.       printf("Could Not Create file %s\n", szFileName);
  363.       Fatal("File IO Error");
  364.     }
  365.     write(gfhOutFile, (PSTR)&icoHdr, sizeof(icoHdr));
  366.     WriteIconDIB((PBITMAPINFOHEADER)pRsrc);
  367.     close(gfhOutFile);
  368.   }
  369.   free(pRsrc);
  370. }
  371. /***************************************************************************/
  372. /***************************************************************************/
  373. void GetResourceNames(long lOfs)
  374. {
  375.   RESNAMES ResNames;
  376.   char     Buff[3];
  377.   WORD     wNbr,
  378.            wLen,
  379.            wCntr = 0;
  380.   char     Name[100];
  381.   
  382.   lseek(gfhInFile, lOfs, SEEK_SET);
  383.   gwNames = 0;
  384.   read(gfhInFile, &ResNames, sizeof(ResNames));
  385.   while (ResNames.wLen)
  386.   {
  387.     wCntr++;
  388.     ResNames.wLen -= 8;
  389.     read(gfhInFile, Buff, 2);
  390.     wNbr = *(WORD *)Buff;
  391.     if (!(ResNames.wType & 0x8000))
  392.       read(gfhInFile, Buff, 1);
  393.     read(gfhInFile, &Name, ResNames.wLen + 1);
  394.     if ((ResNames.wType & 0x7FFF) == RS_ICONDIR)
  395.     { 
  396.       wLen = strlen(Name);
  397.       if (wLen > 8)
  398.         wLen = 8;
  399.       strncpy(gIconNames[gwNames], Name, wLen);
  400.       gIconNames[gwNames][wLen] = '\0';
  401.       if (gwNames++ == 1000)
  402.         Fatal("To Many Icons In This File");
  403.     }    
  404.     read(gfhInFile, &ResNames, sizeof (RESNAMES));
  405.   }
  406. }
  407. /***************************************************************************/
  408. /***************************************************************************/
  409. void WriteIconDIB(PBITMAPINFOHEADER pRsrc)
  410. {
  411.   RGBQUAD  *pRgb;
  412.   WORD     wSize;
  413.   PSTR     pImage;
  414.   ICODIR   icoDir;
  415.   WORD     wColors;
  416.   WORD     wXORSize;
  417.   WORD     wANDSize;
  418.   
  419.   if (pRsrc->biSize != sizeof(BITMAPINFOHEADER))
  420.     printf("Conatins An Old Icon Format\n");
  421.   else
  422.   {
  423.     wColors = DIBNumColors((WORD)pRsrc->biClrUsed,pRsrc->biBitCount);
  424.     icoDir.byWidth     = (BYTE)pRsrc->biWidth;
  425.     icoDir.byHeight    = (BYTE)pRsrc->biHeight / 2;
  426.     icoDir.byColors    = (BYTE)wColors;
  427.     icoDir.byReserved1 = 0x00;               
  428.     icoDir.wReserved2  = (WORD)pRsrc->biPlanes;
  429.     icoDir.wReserved3  = (WORD)pRsrc->biBitCount;
  430.     wANDSize           = (WORD)(icoDir.byWidth * (icoDir.byHeight / 2)) >> 3;
  431.     if (pRsrc->biBitCount > 1)
  432.       wXORSize         = wANDSize * pRsrc->biBitCount;
  433.     else
  434.       wXORSize         = wANDSize * pRsrc->biPlanes;
  435.     pRsrc->biSizeImage = (long)(wANDSize +  wXORSize); 
  436.     icoDir.dwDIBSize   = pRsrc->biSizeImage + pRsrc->biSize + 
  437.                          wColors * sizeof(RGBQUAD);
  438.     icoDir.dwDIBOfs    = sizeof(ICOHDR) + sizeof(ICODIR);    
  439.     pRsrc->biClrUsed   = wColors;
  440.     write(gfhOutFile, (PSTR)&icoDir, sizeof(ICODIR));
  441.     write(gfhOutFile, (PSTR)pRsrc, (WORD)pRsrc->biSize);
  442.     wSize = (WORD)pRsrc->biClrUsed * sizeof(RGBQUAD);
  443.     if ((pRgb = (RGBQUAD *)malloc(wSize)) == NULL)
  444.       Fatal("Unable to allocate memory for Color Table");
  445.     read (gfhInFile, (PSTR)pRgb, wSize);
  446.     write(gfhOutFile, (PSTR)pRgb, wSize);
  447.     free(pRgb);
  448.     if ((pImage = (PSTR)malloc((WORD)pRsrc->biSizeImage)) == NULL)
  449.       Fatal("Unable to allocate memory for Icon Image");
  450.     read (gfhInFile, pImage, (WORD)pRsrc->biSizeImage);
  451.     write(gfhOutFile, pImage, (WORD)pRsrc->biSizeImage);
  452.     free(pImage);
  453.   }
  454. }
  455. /***************************************************************************/
  456. /***************************************************************************/
  457. WORD DIBNumColors(WORD wClrUsed, WORD wBitCount)
  458. {
  459.   if(wClrUsed)
  460.     return wClrUsed;
  461.  
  462.   switch(wBitCount)
  463.   {
  464.     case 1  : return   2;
  465.     case 3  : return   8;
  466.     case 4  : return  16;
  467.     case 8  : return 256;
  468.     default : return  16;
  469.   }
  470. }
  471. /***************************************************************************/
  472. /***************************************************************************/
  473. void ConvertToPM(void)
  474. {
  475.   char                  szFileName[13];
  476.   int                   nLen;
  477.   ICOHDR                icoHdr;
  478.   BITMAPINFOHEADER      Bmi;
  479.   ICODIR                icoDir;
  480.   PSTR                  pXORBits;
  481.   PSTR                  pANDBits;
  482.   RGBQUAD               *pRGB;
  483.   WORD                  wANDSize;
  484.   WORD                  wXORSize;
  485.   WORD                  wSize;
  486.   BITMAPARRAYFILEHEADER bafhHdr;
  487.   OS2_BITMAPFILEHEADER  bfhHdr;
  488.   WORD                  wColors;
  489.   char                  MonoRGBDefaults[]= {0x00,0x00,0x00,0xFF,0xFF,0xFF};
  490.   WORD                  wCntr;
  491.   
  492.   
  493.   read(gfhInFile, (PSTR)&icoHdr, sizeof(icoHdr));
  494.   if (icoHdr.wReserved != 0x0000 && icoHdr.wType != 0x0001)
  495.   {
  496.     printf("Invalid Windows ICO File Format\n");
  497.     return;
  498.   }
  499.   nLen = strlen(gszFileName);
  500.   if (nLen > 12)
  501.     nLen = 12;
  502.   strncpy(szFileName, gszFileName, nLen);
  503.   szFileName[nLen - 1] = 'P';
  504.   szFileName[nLen]     = '\0';
  505.   if ((gfhOutFile = open(szFileName, O_BINARY | O_CREAT | O_TRUNC | O_WRONLY,
  506.                                      S_IREAD  | S_IWRITE)) == -1)
  507.   {
  508.     printf("Could Not Create file %s\n", szFileName);
  509.     Fatal("File IO Error");
  510.   }
  511.   if (icoHdr.wCount > 1)
  512.     printf("%d Images Found : Only Writing 1 - ", icoHdr.wCount);  
  513.   printf("Converting To File %s\n", szFileName);
  514.   
  515.   read(gfhInFile, (PSTR)&icoDir, sizeof(icoDir));  
  516.   lseek(gfhInFile, icoDir.dwDIBOfs, SEEK_SET);
  517.   read(gfhInFile, (PSTR)&Bmi, sizeof(Bmi));
  518.   wColors = DIBNumColors((WORD)Bmi.biClrUsed, Bmi.biBitCount);
  519.   wSize   = wColors * sizeof(RGBQUAD);
  520.   if ((pRGB = (RGBQUAD *)malloc(wSize)) == NULL)
  521.     Fatal("Unable To Allocate Color Table");
  522.   read(gfhInFile, (PSTR)pRGB, wSize);
  523.   wANDSize = (WORD)(Bmi.biWidth * (Bmi.biHeight / 2)) >> 3;
  524.   if (Bmi.biBitCount > 1)
  525.     wXORSize = wANDSize * Bmi.biBitCount;
  526.   else
  527.     wXORSize = wANDSize * Bmi.biPlanes;
  528.   
  529.   if ((pXORBits = (PSTR) malloc(wXORSize)) == NULL)
  530.     Fatal("Unable To Allocate Memory For XOR Bit Map");
  531.   if ((pANDBits = (PSTR) malloc(wANDSize)) == NULL)
  532.     Fatal("Unable To Allocate Memory For AND Bit Map");    
  533.   read(gfhInFile, pXORBits, wXORSize); 
  534.   read(gfhInFile, pANDBits, wANDSize);  
  535.     
  536.   bafhHdr.usType            = BFT_BITMAPARRAY;
  537.   bafhHdr.cbSize            = sizeof(bafhHdr);
  538.   bafhHdr.offNext           = 0L;
  539.   bafhHdr.cxDisplay         = 0;
  540.   bafhHdr.cyDisplay         = 0;
  541.   bafhHdr.bfh.usType        = BFT_COLORICON;
  542.   bafhHdr.bfh.cbSize        = sizeof(bafhHdr.bfh);
  543.   bafhHdr.bfh.xHotspot      = 0;
  544.   bafhHdr.bfh.yHotspot      = 0;
  545.   bafhHdr.bfh.offBits       = sizeof(bafhHdr) + sizeof(bfhHdr) + 
  546.                               (2  +  wColors) * sizeof(RGB);
  547.   bafhHdr.bfh.bmp.cbFix     = sizeof(bafhHdr.bfh.bmp);
  548.   bafhHdr.bfh.bmp.cx        = (WORD)Bmi.biWidth;
  549.   bafhHdr.bfh.bmp.cy        = (WORD)Bmi.biHeight;
  550.   bafhHdr.bfh.bmp.cPlanes   = 1;
  551.   bafhHdr.bfh.bmp.cBitCount = 1;
  552.   
  553.   bfhHdr.usType        = BFT_COLORICON;
  554.   bfhHdr.cbSize        = sizeof(bfhHdr);
  555.   bfhHdr.xHotspot      = 0;
  556.   bfhHdr.yHotspot      = 0;
  557.   bfhHdr.offBits       = bafhHdr.bfh.offBits  + wANDSize * 2;
  558.  
  559.   bfhHdr.bmp.cbFix     = sizeof(bfhHdr.bmp);
  560.   bfhHdr.bmp.cx        = (WORD)Bmi.biWidth;
  561.   bfhHdr.bmp.cy        = (WORD)Bmi.biHeight / 2;
  562.   bfhHdr.bmp.cPlanes   = 1;
  563.   if (Bmi.biBitCount > 1)
  564.     bfhHdr.bmp.cBitCount = Bmi.biBitCount;
  565.   else
  566.     bfhHdr.bmp.cBitCount = Bmi.biPlanes;
  567.   
  568.   write(gfhOutFile, (PSTR)&bafhHdr,         sizeof(bafhHdr));
  569.   write(gfhOutFile, (PSTR)MonoRGBDefaults,  sizeof(MonoRGBDefaults));
  570.   write(gfhOutFile, (PSTR)&bfhHdr,          sizeof(bfhHdr));
  571.   for (wCntr = 0; wCntr < wColors; wCntr++)
  572.     write(gfhOutFile, (PSTR)(pRGB + wCntr), sizeof(RGB)); 
  573.   write(gfhOutFile, pANDBits, wANDSize);
  574.   write(gfhOutFile, pANDBits, wANDSize);
  575.   write(gfhOutFile, pXORBits, wXORSize);
  576.   free(pANDBits);
  577.   free(pXORBits);
  578.   free(pRGB);  
  579.   close(gfhOutFile);
  580. }
  581.  
  582. /***************************************************************************/
  583. /***************************************************************************/
  584. void ConvertToWin(void)
  585. {
  586.   BITMAPARRAYFILEHEADER bafh;
  587.   OS2_BITMAPFILEHEADER  bfh;
  588.   BYTE                  Done = FALSE;
  589.   char                  szFileName[13];
  590.   int                   nLen;
  591.   ICOHDR                icoHdr;
  592.   BITMAPINFOHEADER      Bmi;
  593.   ICODIR                icoDir;
  594.   PSTR                  pXORBits;
  595.   PSTR                  pANDBits;
  596.   RGB                   *pRGB;
  597.   WORD                  wANDSize;
  598.   WORD                  wXORSize;
  599.   WORD                  wSize;
  600.   WORD                  wColors;
  601.   WORD                  wCntr;
  602.   RGBQUAD               RGBQ;
  603.   WORD                  wIndex = 0;
  604.   char                  szBuf[3];
  605.   char                  *pExt;
  606.   
  607.   printf("Dimensions: ");
  608.   bafh.offNext = 0L;
  609.   while(!Done)
  610.   {    
  611.     lseek(gfhInFile, bafh.offNext, SEEK_SET);
  612.     read(gfhInFile, (PSTR)&bafh, sizeof(bafh));     
  613.     if (bafh.usType != 0x4142)
  614.     {
  615.       printf("Invalid PM ICO Format\n");
  616.       return;
  617.     }
  618.     wSize = 2 * sizeof(RGB);
  619.     lseek(gfhInFile, (long)wSize, SEEK_CUR);
  620.     read(gfhInFile, (PSTR)&bfh, sizeof(bfh));
  621.     printf("%.2dx%.2d", bfh.bmp.cx, bfh.bmp.cy);
  622.     if (bfh.bmp.cx <= 32 && bfh.bmp.cy <= 32)
  623.     {
  624.       printf("* ");
  625.       icoHdr.wReserved = 0x0000;
  626.       icoHdr.wType     = 0x0001;
  627.       icoHdr.wCount    = 0x0001;
  628.       if (wIndex++ == 0)
  629.       {
  630.         nLen = strlen(gszFileName);
  631.         if (nLen > 12)          
  632.           nLen = 12;
  633.         strncpy(szFileName, gszFileName, nLen);        
  634.         szFileName[nLen - 1] = 'W';
  635.         szFileName[nLen]     = '\0';
  636.       }
  637.       else
  638.       {
  639.         pExt = strrchr(gszFileName, '.');
  640.         nLen = strlen(gszFileName) - strlen(pExt);
  641.         if (nLen > 6)
  642.           nLen = 6;
  643.         strncpy(szFileName, gszFileName, nLen);
  644.         szFileName[nLen] = '\0';
  645.         sprintf(szBuf, "%.2d", wIndex);
  646.         strcat(szFileName, szBuf);
  647.         strcat(szFileName, ".ICW");
  648.       }        
  649.       if ((gfhOutFile= open(szFileName, O_BINARY| O_CREAT| O_TRUNC| O_WRONLY,
  650.                                         S_IREAD | S_IWRITE)) == -1)
  651.       {
  652.         printf("Could Not Create file %s\n", szFileName);
  653.         Fatal("File IO Error");
  654.       }
  655.       write(gfhOutFile, (PSTR)&icoHdr, sizeof(icoHdr));
  656.       Bmi.biSize          = sizeof(Bmi);
  657.       Bmi.biWidth         = (DWORD)bafh.bfh.bmp.cx;
  658.       Bmi.biHeight        = (DWORD)bafh.bfh.bmp.cy;
  659.       Bmi.biPlanes        = bfh.bmp.cPlanes;
  660.       Bmi.biBitCount      = bfh.bmp.cBitCount;
  661.       Bmi.biCompression   = 0L;
  662.       Bmi.biXPelsPerMeter = 0L;
  663.       Bmi.biYPelsPerMeter = 0L;
  664.       wColors             = DIBNumColors(0, Bmi.biBitCount);
  665.       Bmi.biClrUsed       = wColors;
  666.       Bmi.biClrImportant  = 0;      
  667.       icoDir.byWidth      = (BYTE)Bmi.biWidth;
  668.       icoDir.byHeight     = (BYTE)Bmi.biHeight;
  669.       icoDir.byColors     = (BYTE)Bmi.biClrUsed;
  670.       icoDir.byReserved1  = 0x00;               
  671.       icoDir.wReserved2   = Bmi.biPlanes;
  672.       icoDir.wReserved3   = Bmi.biBitCount;
  673.       wANDSize            = (WORD)(bfh.bmp.cx * bfh.bmp.cy) >> 3;
  674.       if (Bmi.biBitCount > 1)
  675.         wXORSize          = wANDSize * Bmi.biBitCount;
  676.       else
  677.         wXORSize          = wANDSize * Bmi.biPlanes;
  678.       Bmi.biSizeImage     = (long)(wANDSize +  wXORSize); 
  679.       icoDir.dwDIBSize    = Bmi.biSizeImage + Bmi.biSize + wColors 
  680.                           * sizeof(RGBQUAD);
  681.       icoDir.dwDIBOfs     = sizeof(ICOHDR) + sizeof(ICODIR);
  682.       write(gfhOutFile, (PSTR)&icoDir, sizeof(ICODIR));
  683.       write(gfhOutFile, (PSTR)&Bmi, sizeof(Bmi));
  684.       wSize = wColors * sizeof(RGB);
  685.       if ((pRGB = (RGB *)malloc(wSize)) == NULL)
  686.         Fatal("Unable to allocate memory for Color Table");
  687.       read (gfhInFile, (PSTR)pRGB, wSize);
  688.       for (wCntr = 0; wCntr < wColors; wCntr++)
  689.       {
  690.         memcpy((PSTR)&RGBQ, (pRGB + wCntr), sizeof(RGB));
  691.         RGBQ.rgbReserved = 0x00;
  692.         write(gfhOutFile, (PSTR)&RGBQ, sizeof(RGBQ));
  693.       }      
  694.       free(pRGB);
  695.       if ((pANDBits = (PSTR)malloc(wANDSize)) == NULL)
  696.         Fatal("Unable to allocate memory for AND Bits");
  697.       if ((pXORBits = (PSTR)malloc(wXORSize)) == NULL)
  698.         Fatal("Unable to allocate memory for XOR Bits");      
  699.       lseek(gfhInFile, bafh.bfh.offBits, SEEK_SET);      
  700.       read(gfhInFile, pANDBits, wANDSize);
  701.       lseek(gfhInFile, bfh.offBits, SEEK_SET);
  702.       read(gfhInFile, pXORBits, wXORSize);
  703.       write(gfhOutFile, pXORBits, wXORSize);
  704.       write(gfhOutFile, pANDBits, wANDSize);
  705.       free(pXORBits);
  706.       free(pANDBits);
  707.       close(gfhOutFile);
  708.     }
  709.     else
  710.       printf(" ");
  711.    if (!bafh.offNext)
  712.      Done = TRUE;
  713.   }
  714.   printf("\n");
  715. }