src/mesa/drivers/x11/xfonts.c

   1
   2 /*
   3  * Mesa 3-D graphics library
   4  * Version:  3.5
   5  *
   6  * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27 /* xfonts.c -- glXUseXFont() for Mesa written by
  28  * Copyright (C) 1995 Thorsten.Ohl @ Physik.TH-Darmstadt.de
  29  */
  30
  31 #ifdef __VMS
  32 #include <GL/vms_x_fix.h>
  33 #endif
  34
  35 #include "glxheader.h"
  36 #include "context.h"
  37 #include "imports.h"
  38 #include "xfonts.h"
  39
  40
  41 /* Some debugging info.  */
  42
  43 #ifdef DEBUG
  44 #undef _R
  45 #undef _G
  46 #undef _B
  47 #include <ctype.h>
  48
  49 int debug_xfonts = 0;
  50
  51 static void
  52 dump_char_struct (XCharStruct *ch, char *prefix)
  53 {
  54   printf ("%slbearing = %d, rbearing = %d, width = %d\n",
  55           prefix, ch->lbearing, ch->rbearing, ch->width);
  56   printf ("%sascent = %d, descent = %d, attributes = %u\n",
  57           prefix, ch->ascent, ch->descent, (unsigned int) ch->attributes);
  58 }
  59
  60 static void
  61 dump_font_struct (XFontStruct *font)
  62 {
  63   printf ("ascent = %d, descent = %d\n", font->ascent, font->descent);
  64   printf ("char_or_byte2 = (%u,%u)\n",
  65           font->min_char_or_byte2, font->max_char_or_byte2);
  66   printf ("byte1 = (%u,%u)\n", font->min_byte1, font->max_byte1);
  67   printf ("all_chars_exist = %s\n", font->all_chars_exist ? "True" :
  68 "False");
  69   printf ("default_char = %c (\\%03o)\n",
  70           (char) (isprint (font->default_char) ? font->default_char : ' '),
  71           font->default_char);
  72   dump_char_struct (&font->min_bounds, "min> ");
  73   dump_char_struct (&font->max_bounds, "max> ");
  74 #if 0
  75   for (c = font->min_char_or_byte2; c <= font->max_char_or_byte2; c++)
  76     {
  77       char prefix[8];
  78       sprintf (prefix, "%d> ", c);
  79       dump_char_struct (&font->per_char[c], prefix);
  80     }
  81 #endif
  82 }
  83
  84 static void
  85 dump_bitmap (unsigned int width, unsigned int height, GLubyte *bitmap)
  86 {
  87   unsigned int x, y;
  88
  89   printf ("    ");
  90   for (x = 0; x < 8*width; x++)
  91     printf ("%o", 7 - (x % 8));
  92   putchar ('\n');
  93   for (y = 0; y < height; y++)
  94     {
  95       printf ("%3o:", y);
  96       for (x = 0; x < 8*width; x++)
  97         putchar ((bitmap[width*(height - y - 1) + x/8] & (1 << (7 - (x %
  98 8))))
  99                  ? '*' : '.');
 100       printf ("   ");
 101       for (x = 0; x < width; x++)
 102         printf ("0x%02x, ", bitmap[width*(height - y - 1) + x]);
 103       putchar ('\n');
 104     }
 105 }
 106 #endif /* DEBUG */
 107
 108
 109 /* Implementation.  */
 110
 111 /* Fill a BITMAP with a character C from thew current font
 112    in the graphics context GC.  WIDTH is the width in bytes
 113    and HEIGHT is the height in bits.
 114
 115    Note that the generated bitmaps must be used with
 116
 117         glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
 118         glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
 119         glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
 120         glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
 121         glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
 122         glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 123
 124    Possible optimizations:
 125
 126      * use only one reusable pixmap with the maximum dimensions.
 127      * draw the entire font into a single pixmap (careful with
 128        proportional fonts!).
 129 */
 130
 131
 132 /*
 133  * Generate OpenGL-compatible bitmap.
 134  */
 135 static void
 136 fill_bitmap (Display *dpy, Window win, GC gc,
 137              unsigned int width, unsigned int height,
 138              int x0, int y0, unsigned int c, GLubyte *bitmap)
 139 {
 140   XImage *image;
 141   unsigned int x, y;
 142   Pixmap pixmap;
 143   XChar2b char2b;
 144
 145   pixmap = XCreatePixmap (dpy, win, 8*width, height, 1);
 146   XSetForeground(dpy, gc, 0);
 147   XFillRectangle (dpy, pixmap, gc, 0, 0, 8*width, height);
 148   XSetForeground(dpy, gc, 1);
 149
 150   char2b.byte1 = (c >> 8) & 0xff;
 151   char2b.byte2 = (c & 0xff);
 152
 153   XDrawString16 (dpy, pixmap, gc, x0, y0, &char2b, 1);
 154
 155   image = XGetImage (dpy, pixmap, 0, 0, 8*width, height, 1, XYPixmap);
 156   if (image) {
 157     /* Fill the bitmap (X11 and OpenGL are upside down wrt each other).  */
 158     for (y = 0; y < height; y++)
 159       for (x = 0; x < 8*width; x++)
 160         if (XGetPixel (image, x, y))
 161           bitmap[width*(height - y - 1) + x/8] |= (1 << (7 - (x % 8)));
 162     XDestroyImage (image);
 163   }
 164
 165   XFreePixmap (dpy, pixmap);
 166 }
 167
 168 /*
 169  * determine if a given glyph is valid and return the
 170  * corresponding XCharStruct.
 171  */
 172 static XCharStruct *isvalid(XFontStruct *fs, unsigned int which)
 173 {
 174   unsigned int  rows,pages;
 175   unsigned int byte1 = 0,byte2 = 0;
 176   int           i,valid = 1;
 177
 178   rows = fs->max_byte1 - fs->min_byte1 + 1;
 179   pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
 180
 181   if (rows == 1) {
 182     /* "linear" fonts */
 183     if ((fs->min_char_or_byte2 > which) ||
 184         (fs->max_char_or_byte2 < which)) valid = 0;
 185   } else {
 186     /* "matrix" fonts */
 187     byte2 = which & 0xff;
 188     byte1 = which >> 8;
 189     if ((fs->min_char_or_byte2 > byte2) ||
 190         (fs->max_char_or_byte2 < byte2) ||
 191         (fs->min_byte1 > byte1) ||
 192         (fs->max_byte1 < byte1)) valid = 0;
 193   }
 194
 195   if (valid) {
 196     if (fs->per_char) {
 197       if (rows == 1) {
 198         /* "linear" fonts */
 199         return(fs->per_char + (which-fs->min_char_or_byte2) );
 200       } else {
 201         /* "matrix" fonts */
 202         i = ((byte1 - fs->min_byte1) * pages) +
 203              (byte2 - fs->min_char_or_byte2);
 204         return(fs->per_char + i);
 205       }
 206     } else {
 207         return(&fs->min_bounds);
 208     }
 209   }
 210   return(NULL);
 211 }
 212
 213
 214 void Fake_glXUseXFont( Font font, int first, int count, int listbase )
 215 {
 216   Display *dpy;
 217   Window win;
 218   Pixmap pixmap;
 219   GC gc;
 220   XGCValues values;
 221   unsigned long valuemask;
 222   XFontStruct *fs;
 223   GLint swapbytes, lsbfirst, rowlength;
 224   GLint skiprows, skippixels, alignment;
 225   unsigned int max_width, max_height, max_bm_width, max_bm_height;
 226   GLubyte *bm;
 227   int i;
 228
 229   dpy = glXGetCurrentDisplay();
 230   if (!dpy)
 231      return;  /* I guess glXMakeCurrent wasn't called */
 232   win = RootWindow(dpy, DefaultScreen(dpy));
 233
 234   fs = XQueryFont (dpy, font);
 235   if (!fs) {
 236       _mesa_error(NULL, GL_INVALID_VALUE,
 237                "Couldn't get font structure information");
 238       return;
 239   }
 240
 241   /* Allocate a bitmap that can fit all characters.  */
 242   max_width = fs->max_bounds.rbearing - fs->min_bounds.lbearing;
 243   max_height = fs->max_bounds.ascent + fs->max_bounds.descent;
 244   max_bm_width = (max_width + 7) / 8;
 245   max_bm_height = max_height;
 246
 247   bm = (GLubyte *) MALLOC((max_bm_width * max_bm_height) * sizeof
 248 (GLubyte));
 249   if (!bm) {
 250       XFreeFontInfo( NULL, fs, 1 );
 251       _mesa_error(NULL, GL_OUT_OF_MEMORY,
 252                 "Couldn't allocate bitmap in glXUseXFont()");
 253       return;
 254   }
 255
 256 #if 0
 257   /* get the page info */
 258   pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
 259   firstchar = (fs->min_byte1 << 8) + fs->min_char_or_byte2;
 260   lastchar = (fs->max_byte1 << 8) + fs->max_char_or_byte2;
 261   rows = fs->max_byte1 - fs->min_byte1 + 1;
 262   unsigned int first_char, last_char, pages, rows;
 263 #endif
 264
 265   /* Save the current packing mode for bitmaps.  */
 266   glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
 267   glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
 268   glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
 269   glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
 270   glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
 271   glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
 272
 273   /* Enforce a standard packing mode which is compatible with
 274      fill_bitmap() from above.  This is actually the default mode,
 275      except for the (non)alignment.  */
 276   glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
 277   glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
 278   glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
 279   glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
 280   glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
 281   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 282
 283   pixmap = XCreatePixmap (dpy, win, 10, 10, 1);
 284   values.foreground = BlackPixel (dpy, DefaultScreen (dpy));
 285   values.background = WhitePixel (dpy, DefaultScreen (dpy));
 286   values.font = fs->fid;
 287   valuemask = GCForeground | GCBackground | GCFont;
 288   gc = XCreateGC (dpy, pixmap, valuemask, &values);
 289   XFreePixmap (dpy, pixmap);
 290
 291 #ifdef DEBUG
 292   if (debug_xfonts)
 293     dump_font_struct (fs);
 294 #endif
 295
 296   for (i = 0; i < count; i++)
 297     {
 298       unsigned int width, height, bm_width, bm_height;
 299       GLfloat x0, y0, dx, dy;
 300       XCharStruct *ch;
 301       int x, y;
 302       unsigned int c = first + i;
 303       int list = listbase + i;
 304       int valid;
 305
 306       /* check on index validity and get the bounds */
 307       ch = isvalid(fs, c);
 308       if (!ch) {
 309         ch = &fs->max_bounds;
 310         valid = 0;
 311       } else {
 312         valid = 1;
 313       }
 314
 315 #ifdef DEBUG
 316       if (debug_xfonts) {
 317           char s[7];
 318           sprintf (s, isprint (c) ? "%c> " : "\\%03o> ", c);
 319           dump_char_struct (ch, s);
 320       }
 321 #endif
 322
 323       /* glBitmap()' parameters:
 324          straight from the glXUseXFont(3) manpage.  */
 325       width = ch->rbearing - ch->lbearing;
 326       height = ch->ascent + ch->descent;
 327       x0 = - ch->lbearing;
 328       y0 = ch->descent - 0;  /* XXX used to subtract 1 here */
 329                              /* but that caused a conformace failure */
 330       dx = ch->width;
 331       dy = 0;
 332
 333       /* X11's starting point.  */
 334       x = - ch->lbearing;
 335       y = ch->ascent;
 336
 337       /* Round the width to a multiple of eight.  We will use this also
 338          for the pixmap for capturing the X11 font.  This is slightly
 339          inefficient, but it makes the OpenGL part real easy.  */
 340       bm_width = (width + 7) / 8;
 341       bm_height = height;
 342
 343       glNewList (list, GL_COMPILE);
 344         if (valid && (bm_width > 0) && (bm_height > 0)) {
 345
 346             MEMSET (bm, '\0', bm_width * bm_height);
 347             fill_bitmap (dpy, win, gc, bm_width, bm_height, x, y, c, bm);
 348
 349             glBitmap (width, height, x0, y0, dx, dy, bm);
 350 #ifdef DEBUG
 351             if (debug_xfonts) {
 352                 printf ("width/height = %u/%u\n", width, height);
 353                 printf ("bm_width/bm_height = %u/%u\n", bm_width,
 354 bm_height);
 355                 dump_bitmap (bm_width, bm_height, bm);
 356               }
 357 #endif
 358           } else {
 359             glBitmap (0, 0, 0.0, 0.0, dx, dy, NULL);
 360           }
 361       glEndList ();
 362     }
 363
 364   FREE(bm);
 365   XFreeFontInfo( NULL, fs, 1 );
 366   XFreeGC (dpy, gc);
 367
 368   /* Restore saved packing modes.  */
 369   glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
 370   glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
 371   glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
 372   glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
 373   glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
 374   glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
 375 }