home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / xfedor.zip / XFree86 / src / xfedor / filer.c < prev    next >
C/C++ Source or Header  |  1999-03-02  |  16KB  |  497 lines
  1. /* Copyright 1989 GROUPE BULL -- See licence conditions in file COPYRIGHT */
  2. #include <stdio.h>
  3. #include <string.h>
  4. extern char * getenv() ;
  5.  
  6.  
  7. #include "clientimage.h"                /* ClientImage */
  8. #include "fedor.h"              /* fedchar + BdfHeader */
  9.  
  10. extern fedchar chartab[MAXFONTCARD] ;
  11. extern fedchar extratab[MAXFONTCARD] ;
  12. extern int maxup, maxdown, maxhsize, maxhadj ;  /* pour SauveFont */
  13. extern nf_font ;
  14. extern CurColor ;
  15. extern int Prem, PremExtra ;
  16. extern char * homedir ;       /* initialiser dans bitmap */
  17. extern int UnixFileNameMode ; /* 0 ou 1, initialiser dans main */
  18.  
  19. void Init_filer() ;
  20. int GetFont() ;
  21. int SauveFont() ;
  22. int GetExtraFont() ;
  23. static int prefix() ;
  24. static int ReadFont() ;
  25.  
  26. char FileName[256];
  27. char ExtraName[256];
  28. BdfHeader header ;
  29. BdfHeader xeader ;      /* ExtraFont header */
  30.  
  31.         /** LOCAL */
  32.  
  33. static FILE * pF ;      /* pour lire et ecrire */
  34. static char * dirbdf ;
  35. static char * newdirbdf ;
  36.  
  37.  
  38. void Init_filer()
  39. {
  40.     if ((dirbdf = getenv("BDF"))==0)
  41.       if (UnixFileNameMode) dirbdf = "." ; else dirbdf = "" ;
  42.     if (UnixFileNameMode) {
  43.        newdirbdf = (char *)malloc(strlen(dirbdf)+2);
  44.        strcpy(newdirbdf,dirbdf);
  45.        newdirbdf[strlen(dirbdf)] = '/' ;
  46.        newdirbdf[strlen(dirbdf)+1] = '\0' ;
  47.        dirbdf = newdirbdf ;
  48.     }
  49. }
  50.  
  51.  
  52. int GetFont(name)
  53.         char * name ;
  54. {
  55.         int rep ;
  56.  
  57.         rep = ReadFont(name,chartab,&header,&Prem);
  58.         if (rep == 1) {
  59.                 strcpy(FileName,name);
  60.                 ShowHeader() ;
  61.                 if (FontMax_Resize() != 2) {
  62.                   /* genere un resize diminuant qui ne fera pas d'expose ou
  63.                      pas de resize du tout */
  64.                   w_cacher(nf_font) ;
  65.                   w_montrer(nf_font) ;  /* hack ? */
  66.                 }
  67.         }
  68.         return rep ;
  69. }
  70.  
  71.  
  72. int SauveFont()
  73. /* a partir de chartab[0..MAXFONTCARD-1], de header,
  74.    on ecrit un FileName format bdf */
  75. /* rend 0 si c'est ok */
  76. {
  77.         int i ;
  78.         int nchars ;
  79.         char  filename[138] ;
  80.         int bytesperrow ;
  81.         unsigned char * vidmem ;
  82.         int vidwidth ;
  83.  
  84.  
  85.         if (strcmp( FileName, "No File") == 0) return -1 ;
  86.  
  87.         if (*FileName == '~')
  88.         {
  89.             strcpy(filename,homedir);
  90.             strcat(filename,(FileName+1));
  91.         } else
  92.         if (index(FileName,'/') != NULL) strcpy(filename,FileName);
  93.         else {
  94.                 strcpy(filename,dirbdf);
  95.                 strcat(filename,FileName);
  96.         }
  97.  
  98.         if (!Extension(filename,".bdf")) strcat(filename,".bdf");
  99.  
  100.         if ((pF = fopen( filename, "w")) == NULL) return -1 ;
  101.  
  102.         fprintf(pF,"STARTFONT 2.1\n");
  103.         fprintf(pF,"FONT %s\n",header.FamilyName);
  104.         fprintf(pF,"SIZE %d %d %d\n",header.Size,header.Resol,header.Resol);
  105.         fprintf(pF,"FONTBOUNDINGBOX %d %d %d %d\n",
  106.                   maxhsize,(maxdown-maxup),maxhadj,-maxdown);
  107.         fprintf(pF,"STARTPROPERTIES %d\n",header.nprops);
  108.         for (i=header.nprops-1; i >= 0; i--)
  109.                 if (prefix(header.Properties[i],"FONT_ASCENT"))
  110.                         fprintf(pF,"FONT_ASCENT %d\n",-maxup); else
  111.                 if (prefix(header.Properties[i],"FONT_DESCENT"))
  112.                         fprintf(pF,"FONT_DESCENT %d\n",maxdown); else
  113.                 fprintf(pF,"%s",header.Properties[i]);
  114.         fprintf(pF,"ENDPROPERTIES\n");
  115.         nchars = 0 ;
  116.         for (i=0; i<MAXFONTCARD; i++)
  117.                 if (chartab[i].hsize>0) nchars++ ;
  118.         fprintf(pF,"CHARS %d\n",nchars);
  119.         for (i=0 ;i<MAXFONTCARD; i++) {
  120.           int row, bh ;
  121.           int ix ;
  122.           if (chartab[i].hsize>0) {
  123.                 fprintf(pF,"STARTCHAR %s\n",chartab[i].name);
  124.                 fprintf(pF,"ENCODING %d\n",i);
  125.                 fprintf(pF,"SWIDTH %d %d\n",chartab[i].vadj,0);
  126.                 fprintf(pF,"DWIDTH %d %d\n",chartab[i].hincr,chartab[i].vincr);
  127.                 fprintf(pF,"BBX %d %d %d %d\n",
  128.                                 chartab[i].hsize,
  129.                                 (bh=chartab[i].down - chartab[i].up),
  130.                                 chartab[i].hadj,
  131.                                 -chartab[i].down);
  132.                 fprintf(pF,"BITMAP\n");
  133.                 Rast_Mem(chartab[i].image,
  134.                          chartab[i].hsize,
  135.                          chartab[i].down - chartab[i].up,
  136.                          &vidmem,&vidwidth) ;
  137.                 bytesperrow = (((chartab[i].hsize)+7)>>3) ;
  138.                                 /* nb d'octet par ligne (pad 8) */
  139.                 for (row=0; row < bh;row++) {
  140.                         for (ix=0 ; ix < bytesperrow ; ix++) {
  141.                                 fprintf(pF,"%.2X",*(vidmem++));
  142.                               }
  143.                         vidmem += (vidwidth - bytesperrow) ;
  144.                         fprintf(pF,"\n");
  145.                 }
  146.                 fprintf(pF,"ENDCHAR\n");
  147.             }
  148.         }
  149.         fprintf(pF,"ENDFONT\n");
  150.  
  151.         fclose(pF);
  152.         return 0 ;
  153. }
  154.  
  155. /************************************************/
  156. /************************************************/
  157.  
  158. int Extension(filename, extent)   /* use also in bitmap.c */
  159. /* rend 1 si extent est l'extension de filename, 0 sinon */
  160.         char * filename, * extent ;
  161. { char * s ;
  162.         if (( s = (char*)rindex(filename,'.'))==NULL) return 0 ; else
  163.            return(strcmp(extent,s)==0)?1:0 ;
  164. }
  165.  
  166. /*
  167.  * return 1 if str is a prefix of buf
  168.  */
  169. static int prefix(buf, str)
  170.     char *buf, *str;
  171. {
  172.     return strncmp(buf, str, strlen(str))? 0:1;
  173. }
  174.  
  175.  
  176. static int fatal(msg, p1, p2, p3, p4)
  177.     char *msg;
  178. {
  179.     fprintf(stderr,"xfedor: ");
  180.     fprintf(stderr, msg, p1, p2, p3, p4);
  181.     fprintf(stderr,"\n");
  182.     fclose(pF);
  183.     return -1 ;
  184. }
  185.  
  186. /*
  187.  * read the next line and keep a count for error messages
  188.  */
  189. static char *
  190. getline(s)
  191.     char *s;
  192. {
  193.     s = fgets(s,256,pF);
  194.     while (s) {
  195.         int len = strlen(s);
  196.         if (len && s[len-1] == '\015')
  197.             s[--len] = '\0';
  198.         if ((len==0) || (prefix(s, "COMMENT"))) {
  199.             s = fgets(s,256,pF);
  200.         } else break;
  201.     }
  202.     return(s);
  203. }
  204.  
  205.  
  206. /*
  207.  * make a byte from the first two hex characters in s
  208.  * the byte is bitmap_bit_order MSBFirst
  209.  */
  210. static unsigned char
  211. hexbyte(s)
  212.     char *s;
  213. {
  214.     unsigned char b = 0;
  215.     register char c;
  216.     int i;
  217.  
  218.     for (i=2; i; i--) {
  219.         c = *s++;
  220.         if ((c >= '0') && (c <= '9'))
  221.             b = (b<<4) + (c - '0');
  222.         else if ((c >= 'A') && (c <= 'F'))
  223.             b = (b<<4) + 10 + (c - 'A');
  224.         else if ((c >= 'a') && (c <= 'f'))
  225.             b = (b<<4) + 10 + (c - 'a');
  226.         else
  227.             return 0; /* bad data */
  228.     }
  229.     return b;
  230. }
  231.  
  232.  
  233. /************************************************/
  234. /************************************************/
  235.  
  236. static int ReadFont(name,tabchar,head,pprem)
  237. /* lit le fichier  au format BDF name et
  238.    rempli le tableau tabchar[MAXFONTCARD] de fedchar, et
  239.    initialise de BdfHeader head */
  240. /* rend 1 en cas de succes, 0 si rien, -1 sinon */
  241.  
  242.         char * name ;
  243.         fedchar * tabchar ;
  244.         BdfHeader * head ;
  245.         int * pprem ;
  246.  
  247. {       int i ;
  248.         char filename[128] ;    /* nom absolu */
  249.         char linebuf[256] ;
  250.         char namebuf[100];
  251.         int yRes ;
  252.         int nchars;
  253.         int first = 1 ;
  254.  
  255.         if (*name=='\0') return 0;
  256.  
  257.         if (strcmp(name,"initfont") == 0 ) {
  258.                 for (i=0 ; i<MAXFONTCARD ; i++ )
  259.                     if (tabchar[i].hsize > 0) {
  260.                         tabchar[i].up = 0 ;
  261.                         tabchar[i].down = 0 ;
  262.                         tabchar[i].hsize = 0 ;
  263.                         tabchar[i].hincr = 0 ;
  264.                         tabchar[i].hadj = 0 ;
  265.                         *tabchar[i].name = '\0' ;
  266.  
  267.                         Rast_Free(&tabchar[i].image) ;
  268.                     }
  269.                 /* initialise header */
  270.                 strcpy(head->FamilyName,"xfedor");
  271.                 head->nprops = 2 ;
  272.                 strcpy(head->Properties[0],"FONT_ASCENT 20\n");
  273.                 strcpy(head->Properties[1],"FONT_DESCENT 12\n");
  274.                 head->Size = 32 ;
  275.                 head->Resol= 72 ;
  276.  
  277.                 strcpy(FileName,"No File");
  278.                 return 1 ;
  279.         }
  280.  
  281.  
  282.     if (*name == '~')
  283.         {
  284.             strcpy(filename,homedir);
  285.             strcat(filename,(name+1));
  286.         } else
  287.     if (index(name,'/') != NULL) strcpy(filename,name);
  288.     else {
  289.             strcpy(filename,dirbdf);
  290.             strcat(filename,name);
  291.         }
  292.  
  293.     if (!Extension(filename,".bdf")) strcat(filename,".bdf");
  294.  
  295.     if ((pF = fopen( filename, "r")) == NULL) return fatal("Can't open file %s", filename);
  296.  
  297.     getline(linebuf);
  298.     if ((sscanf(linebuf, "STARTFONT %s", namebuf) != 1) ||
  299.         strcmp(namebuf, "2.1"))  return fatal("bad 'STARTFONT 2.1'");
  300.  
  301.     getline(linebuf);
  302.     if (sscanf(linebuf, "FONT %s", head->FamilyName) != 1)
  303.         return fatal("bad 'FONT'");
  304.  
  305.     getline(linebuf);
  306.     if (!prefix(linebuf, "SIZE"))
  307.         return fatal("missing 'SIZE'");
  308.     if ((sscanf(linebuf, "SIZE %d%d%d",
  309.                          &head->Size, &head->Resol, &yRes) != 3))
  310.         return fatal("bad 'SIZE'");
  311.     if (head->Resol != yRes)
  312.         return fatal("x and y resolution must be equal");
  313.  
  314.     getline(linebuf);
  315.     if (!prefix(linebuf, "FONTBOUNDINGBOX"))
  316.         return fatal("missing 'FONTBOUNDINGBOX'");
  317.  
  318.     getline(linebuf);
  319.     if (prefix(linebuf, "STARTPROPERTIES")) {
  320.         int nprops;
  321.         int prop_fontasc, prop_fontdesc ;
  322.  
  323.         prop_fontasc = -1 ;
  324.         prop_fontdesc = -1 ;
  325.  
  326.         sscanf(linebuf, "%*s%d", &nprops);
  327.         if (nprops > 50) return fatal("Too Many Properties : %d",nprops);
  328.         head->nprops = nprops ;
  329.  
  330.         getline(linebuf);
  331.         while((nprops-- > 0) && !prefix(linebuf, "ENDPROPERTIES")) {
  332.             if (prefix(linebuf,"FONT_ASCENT"))
  333.                 prop_fontasc = nprops ; else
  334.             if (prefix(linebuf,"FONT_DESCENT"))
  335.                 prop_fontdesc = nprops ;
  336.             strncpy(head->Properties[nprops],linebuf,80);
  337.  
  338.             getline(linebuf);
  339.         }
  340.         if (!prefix(linebuf, "ENDPROPERTIES"))
  341.             return fatal("missing 'ENDPROPERTIES'");
  342.         if ((prop_fontasc == -1) || (prop_fontdesc==-1))
  343.             return fatal("missing 'FONT_ASCENT' or 'FONT_DESCENT' properties?");
  344.         if (nprops != -1)
  345.             return fatal("%d too few properties", nprops+1);
  346.  
  347.     } else { /* no properties */
  348.         return fatal("missing 'PROPERTIES'");
  349.     }
  350.  
  351.     getline(linebuf);
  352.     if (!prefix(linebuf, "CHARS"))
  353.         return fatal("missing 'CHARS'");
  354.     sscanf(linebuf, "%*s%d", &nchars);
  355.     if (nchars > MAXFONTCARD) return fatal("Too Many Chars : %d",nchars);
  356.  
  357.         /* on reinitialise la tabchar avant de le remplir partiellement */
  358.         for (i=0 ; i<MAXFONTCARD ; i++ )
  359.             if (tabchar[i].hsize > 0) {
  360.                         tabchar[i].up = 0 ;
  361.                         tabchar[i].down = 0 ;
  362.                         tabchar[i].hsize = 0 ;
  363.                         tabchar[i].hincr = 0 ;
  364.                         tabchar[i].hadj = 0 ;
  365.                         *tabchar[i].name = '\0' ;
  366.  
  367.                         Rast_Free(&tabchar[i].image) ;
  368.                 }
  369.  
  370.     getline(linebuf);
  371.     while ((nchars-- > 0) && prefix(linebuf, "STARTCHAR"))  {
  372.         char    charName[50];
  373.         int     enc, enc2;      /* encoding */
  374.         int     t ;
  375.         int     wx;     /* x component of width */
  376.         int     wy;     /* y component of width */
  377.         int     bw;     /* bounding-box width */
  378.         int     bh;     /* bounding-box height */
  379.         int     bl;     /* bounding-box left */
  380.         int     bb;     /* bounding-box bottom */
  381.         int     bytesperrow, row, ix, vidwidth ;
  382.         char    * p, * vidmem, *mem;
  383.         char    buff[50];
  384.  
  385.         if (sscanf(linebuf, "STARTCHAR %s", charName) != 1)
  386.             return fatal("bad character name");
  387.  
  388.         getline( linebuf);
  389.         if ((t=sscanf(linebuf, "ENCODING %d %d", &enc, &enc2)) < 1)
  390.             return fatal("bad 'ENCODING'");
  391.         if ((enc < -1) || ((t == 2) && (enc2 < -1)))
  392.             fatal("bad ENCODING value");
  393.         if (t == 2 && enc == -1)
  394.             enc = enc2;
  395.         if (enc == -1) {
  396.             do {
  397.                 char *s = getline(linebuf);
  398.                 if (!s)
  399.                     return fatal("Unexpected EOF");
  400.             } while (!prefix(linebuf, "ENDCHAR"));
  401.             getline(linebuf);
  402.             continue;
  403.         }
  404.         if (enc >= MAXFONTCARD)
  405.             return fatal("'%s' has encoding(=%d) too large", charName, enc);
  406.         strncpy(tabchar[enc].name,charName,20);
  407.         if (first) {
  408.           *pprem = enc ;
  409.           first = 0 ;
  410.         }
  411.         getline( linebuf);
  412.         if (!prefix(linebuf, "SWIDTH"))
  413.             return fatal("bad 'SWIDTH'");
  414.         sscanf( linebuf, "SWIDTH %d %d", &wx, &wy);
  415.         tabchar[enc].vadj = wx; /* pour le stocker */
  416.  
  417.         getline( linebuf);
  418.         if (!prefix(linebuf, "DWIDTH"))
  419.             return fatal("bad 'DWIDTH'");
  420.         sscanf( linebuf, "DWIDTH %d %d", &wx, &wy);
  421.         tabchar[enc].hincr = wx ;
  422.         tabchar[enc].vincr = wy ;/* pour le stocker */
  423.  
  424.         getline( linebuf);
  425.         if (!prefix(linebuf, "BBX"))
  426.             return fatal("bad 'BBX'");
  427.         sscanf( linebuf, "BBX %d %d %d %d", &bw, &bh, &bl, &bb);
  428.         tabchar[enc].up = -(bh + bb) ;
  429.         tabchar[enc].down = -bb ;
  430.         tabchar[enc].hadj = bl;
  431.         tabchar[enc].hsize = bw ;
  432.  
  433.         getline( linebuf);
  434.         if (prefix(linebuf, "ATTRIBUTES"))
  435.             getline( linebuf);
  436.  
  437.         if (!prefix(linebuf, "BITMAP"))
  438.             return fatal("missing 'BITMAP'");
  439.  
  440.         bytesperrow = (((bw)+7)>>3) ;   /* nb d'octet par ligne (<pad 8) */
  441.  
  442.         if (tabchar[enc].image != 0) Rast_Free(&tabchar[enc].image) ;
  443.  
  444.         /* alloc du plan pour ce bitmap bdf */
  445.         mem = vidmem = ( char *) malloc (bytesperrow*
  446.                                    (tabchar[enc].down-tabchar[enc].up)) ;
  447.         /* transfert de l'image vers vidmem : pad 8 */
  448.         for (row=0; row < bh; row++) {
  449.             getline(linebuf);
  450.             p = linebuf ;
  451.             for ( ix=0; ix < bytesperrow ; ix++)
  452.             {
  453.                 *vidmem++ = hexbyte(p);
  454.                 p += 2;
  455.             }
  456.         }
  457.  
  458.         /* fonction de conversion vidmem vers ClientImage :
  459.            on recupere une image issue du bitmap bdf monochrome */
  460.         Rast_Put(&tabchar[enc].image,mem,
  461.                  tabchar[enc].hsize,tabchar[enc].down-tabchar[enc].up);
  462.  
  463.  
  464.         getline( linebuf);
  465.         if (!prefix(linebuf, "ENDCHAR")) {
  466.             sprintf(buff,"%d missing 'ENDCHAR'",enc);
  467.             return fatal(buff);
  468.           }
  469.  
  470.         getline( linebuf);              /* get STARTCHAR or ENDFONT */
  471.     }
  472.  
  473.     if (!prefix(linebuf, "ENDFONT"))
  474.         return fatal("missing 'ENDFONT'");
  475.     if (nchars != -1)
  476.         return fatal("%d too few characters", nchars+1);
  477.  
  478.         fclose(pF);
  479.         return 1 ;
  480. }
  481.  
  482.  
  483. /************************************************/
  484. /************************************************/
  485. int GetExtraFont(name)
  486.         char * name ;
  487. {
  488.         int rep ;
  489.  
  490.         rep = ReadFont(name,extratab,&xeader,&PremExtra);
  491.         if (rep == 1) {
  492.                 strcpy(ExtraName,name);
  493.                 Extra_Resize() ;
  494.         }
  495.         return rep ;
  496. }
  497.