// -*- c++ -*-
 
 
// PCF File Format from /xc/lib/font/bitmap/pcfread.c,pcfwrite.c
 
 
// miscellaneous definition ///////////////////////////////////////////////////
 
/* Type names are 'TypeSize_Endien'.
 * name  Type  Size(bits) Endien
 * --------------- --------------- --------------- -------
 * char8  char  8  none
 * bool8  bool  8  none
 * int32_little int  32  big
 * type32_little type32  32  big
 * format32_little format32 32  big
 * etc.
 * In the *SECTION*, the endieness is determined by the format.byte
 */
 
 
enum type32 {
  PCF_PROPERTIES = (1 << 0),
  PCF_ACCELERATORS = (1 << 1),
  PCF_METRICS  = (1 << 2),
  PCF_BITMAPS  = (1 << 3),
  PCF_INK_METRICS = (1 << 4),
  PCF_BDF_ENCODINGS = (1 << 5),
  PCF_SWIDTHS  = (1 << 6),
  PCF_GLYPH_NAMES = (1 << 7),
  PCF_BDF_ACCELERATORS = (1 << 8),
};
 
struct format32 {
  uint32 format:24; // format                                << 8
  uint32 dummy:2; // = 0 padding                           << 6
  uint32 scan:2;  // bitmap scan unit is (1 << scan) bytes << 4
  uint32 bit:1;  // 0:LSBbit first, 1:MSBit first         << 3
  uint32 byte:1;  // 0:LSByte first, 1:MSByte first        << 2
  uint32 glyph:2; // glyph pad is (1 << glyph) bytes       << 0
};
// format32.format is one of the followings
#define PCF_DEFAULT_FORMAT     0
#define PCF_INKBOUNDS          2
#define PCF_ACCEL_W_INKBOUNDS  1
#define PCF_COMPRESSED_METRICS 1
 
struct metric_t
{
  int16 leftSideBearing;
  int16 rightSideBearing;
  int16 characterWidth;
  int16 ascent;
  int16 descent;
  int16 attributes;
};
struct compressedMetric_t
{
  uint8 leftSideBearing; // - 0x80 == metric_t.leftSideBearing
  uint8 rightSideBearing; // - 0x80 == metric_t.rightSideBearing
  uint8 characterWidth;  // - 0x80 == metric_t.characterWidth
  uint8 ascent;   // - 0x80 == metric_t.ascent
  uint8 descent;  // - 0x80 == metric_t.descent
};
 
#define GLYPHPADOPTIONS 4 // 1, 2, 4, or 8
 
#define MAKE_CHARCODE(row,col) (row * 256 + col)
 
 
// begining of the PCF file ///////////////////////////////////////////////////
 
// table of contents
char8[4] version = { 'p', 'c', 'f', 1 };
int32_little nTables;
struct table_t { // sections
  type32_little type; // type of this section
  format32_little format; // format of this section
  int32_little size; // size of this section
  int32_little offset; // offset of this section from the begining of the file
}  tables[nTables];
 
/*** SECTION ***/
// properties section (tables[i].type = PCF_PROPERTIES)
format32_little format;  // format.id = PCF_DEFAULT_FORMAT
int32  nProps;
struct {
  int32  name;  // offset from &string[0]
  bool8  isStringProp; // is this property is string ?
  int32  value;  // isStringProp ? offset from &string[0]
}  props[nProps];
byte8  dummy[3 - ((sizeof(props) + 3) % 4)]; // padding
int32  stringSize;
char8  string[stringSize]; // pointed by property_t.{name,value}
 
/*** SECTION ***/
// old accelerators section (tables[i].type = PCF_ACCELERATORS)
/* if PCF_BDF_ACCELERATORS section exists, this section is omitted. */
format32_little format;  // format.id = PCF_DEFAULT_FORMAT
//    //              or PCF_ACCEL_W_INKBOUNDS
bool8  noOverlap;
bool8  constantMetrics;
bool8  terminalFont;
bool8  constantWidth;
bool8  inkInside;
bool8  inkMetrics;
bool8  drawDirection;
bool8  dummy;  // padding
int32  fontAscent;
int32  fontDescent;
int32  maxOverlap;
metric_t minBounds;
metric_t maxBounds;
#if format.id == PCF_ACCEL_W_INKBOUNDS
metric_t ink_minBounds;
metric_t ink_maxBounds;
#endif
 
/*** SECTION ***/
// metrics section (tables[i].type = PCF_METRICS)
format32_little format;  // format.id = PCF_DEFAULT_FORMAT
//    //          or PCF_COMPRESSEDMETRICS
#if format.id == PCF_DEFAULT_FORMAT
int32  nMetrics;
metric_t metrics[nMetrics];
#else
int16  nMetrics;
compressedMetric_t cmetrics[nMetrics];
#end
 
/*** SECTION ***/
// bitmaps section (tables[i].type = PCF_BITMAPS)
format32_little format;  // format.id = PCF_DEFAULT_FORMAT
int32  nBitmaps; // == nMetrics
uint32  bitmapOffsets[nBitmaps];
uint32  bitmapSizes[GLYPHPADOPTIONS];
byte8  bitmaps[bitmapSizes[format.glyph]];
/* if (format.bit != THIS_MACHINE.bit)
 *   BitOrderInvert(bitmaps, sizeof(bitmaps));
 * if ((format.bit == format.byte) !=  
 *     (THIS_MACHINE.bit == THIS_MACHINE.byte)) {
 *   switch (1 << (THIS_MACHINE.bit == THIS_MACHINE.byte ?
 *                 format.scan : THIS_MACHINE.scan)) {
 *     case 1: break;
 *     case 2: TwoByteSwap(bitmaps, sizeof(bitmaps)); break;
 *     case 4: FourByteSwap(bitmaps, sizeof(bitmaps)); break;
 *   }
 * } */
/* each line of the bitmaps is aligned by 1<<format.glyph bytes. */
 
/*** SECTION ***/
// ink metrics secion (tables[i].type = PCF_INK_METRICS)
/* this section may be omitted */
/* same as PCF_METRICS */
 
/*** SECTION ***/
// encodings section (tables[i].type = PCF_BDF_ENCODINGS)
format32_little format;  // format.id = PCF_DEFAULT_FORMAT
int16  firstCol;
int16  lastCol;
int16  firstRow;
int16  lastRow;
int16  defaultCh; // default char or NO_SUCH_CHAR (= -1)
int16  encodings[n];
/*            |0 firstCol  lastCol 255
 * row\column |v v         v       v
 * -----------+---------------------
 *         0->|
 *  firstRow->|A B C D E F G H
 *            |I J K L M N O P
 *            |Q R S T U V W X
 *   lastRow->|Y Z a b c d e f
 *       255->|
 *
 * The charcode MAKE_CHARCODE(firstCol, firstRow)'s metrics is metrics[B].
 * And, encodings = { B,C,D,E,F,G, J,K,L,M,N,O, R,S,T,U,V,W, Z,a,b,c,d,e, };
 * If Z == 0xffff, then the charcode MAKE_CHARCODE(firstCol, lastRow) does not
 * exist. */
 
/*** SECTION ***/
// swidths section (tables[i].type = PCF_SWIDTHS)
/* this section may be omitted */
format32_little format;  // format.id = PCF_DEFAULT_FORMAT
int32  nSwidths; // == nMetrics
int32  swidths[nSwidths];
 
/*** SECTION ***/
// glyph names section (tables[i].type = PCF_GLYPH_NAMES)
/* this section may be omitted */
format32_little format;  // format.id = PCF_DEFAULT_FORMAT
int32  nGlyphNames; // == nMetrics
int32  glyphNameOffsets[nGlyphNames]; // offset from &glyph_names[0]
int32  glyphNamesSize;
char8  glyphNames[glyphNamesSize];    // pointed by glyphNameOffsets[]
 
/*** SECTION ***/
// BDF style accelerators section (tables[i].type = PCF_BDF_ACCELERATORS)
/* if PCF_ACCELERATORS section exists, this section is omitted. */
/* same as PCF_ACCELERATORS */
 
// end of the PCF file ////////////////////////////////////////////////////////