src/ftxfont.c

   1 /* ftxfont.c -- FreeType font driver on X (without using XFT).
   2    Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
   3    Copyright (C) 2006, 2007, 2008
   4      National Institute of Advanced Industrial Science and Technology (AIST)
   5      Registration Number H13PRO009
   6
   7 This file is part of GNU Emacs.
   8
   9 GNU Emacs is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GNU Emacs is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU Emacs; see the file COPYING.  If not, write to
  21 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, USA.  */
  23
  24 #include <config.h>
  25 #include <stdio.h>
  26 #include <X11/Xlib.h>
  27
  28 #include "lisp.h"
  29 #include "dispextern.h"
  30 #include "xterm.h"
  31 #include "frame.h"
  32 #include "blockinput.h"
  33 #include "character.h"
  34 #include "charset.h"
  35 #include "fontset.h"
  36 #include "font.h"
  37
  38 /* FTX font driver.  */
  39
  40 static Lisp_Object Qftx;
  41
  42 /* Prototypes for helper function.  */
  43 static GC *ftxfont_get_gcs P_ ((FRAME_PTR, unsigned long, unsigned long));
  44 static int ftxfont_draw_bitmap P_ ((FRAME_PTR, GC, GC *, struct font *,
  45                                     unsigned, int, int, XPoint *, int, int *,
  46                                     int));
  47 static void ftxfont_draw_backgrond P_ ((FRAME_PTR, struct font *, GC,
  48                                         int, int, int));
  49
  50 struct ftxfont_frame_data
  51 {
  52   /* Background and foreground colors.  */
  53   XColor colors[2];
  54   /* GCs interporationg the above colors.  gcs[0] is for a color
  55    closest to BACKGROUND, and gcs[5] is for a color closest to
  56    FOREGROUND.  */
  57   GC gcs[6];
  58   struct ftxfont_frame_data *next;
  59 };
  60
  61
  62 /* Return an array of 6 GCs for antialiasing.  */
  63
  64 static GC *
  65 ftxfont_get_gcs (f, foreground, background)
  66      FRAME_PTR f;
  67      unsigned long foreground, background;
  68 {
  69   XColor color;
  70   XGCValues xgcv;
  71   int i;
  72   struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
  73   struct ftxfont_frame_data *prev = NULL, *this = NULL, *new;
  74
  75   if (data)
  76     {
  77       for (this = data; this; prev = this, this = this->next)
  78         {
  79           if (this->colors[0].pixel < background)
  80             continue;
  81           if (this->colors[0].pixel > background)
  82             break;
  83           if (this->colors[1].pixel < foreground)
  84             continue;
  85           if (this->colors[1].pixel > foreground)
  86             break;
  87           return this->gcs;
  88         }
  89     }
  90
  91   new = malloc (sizeof (struct ftxfont_frame_data));
  92   if (! new)
  93     return NULL;
  94   new->next = this;
  95   if (prev)
  96     {
  97       prev->next = new;
  98     }
  99   else if (font_put_frame_data (f, &ftxfont_driver, new) < 0)
 100     {
 101       free (new);
 102       return NULL;
 103     }
 104
 105   new->colors[0].pixel = background;
 106   new->colors[1].pixel = foreground;
 107
 108   BLOCK_INPUT;
 109   XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), new->colors, 2);
 110   for (i = 1; i < 7; i++)
 111     {
 112       /* Interpolate colors linearly.  Any better algorithm?  */
 113       color.red
 114         = (new->colors[1].red * i + new->colors[0].red * (8 - i)) / 8;
 115       color.green
 116         = (new->colors[1].green * i + new->colors[0].green * (8 - i)) / 8;
 117       color.blue
 118         = (new->colors[1].blue * i + new->colors[0].blue * (8 - i)) / 8;
 119       if (! x_alloc_nearest_color (f, FRAME_X_COLORMAP (f), &color))
 120         break;
 121       xgcv.foreground = color.pixel;
 122       new->gcs[i - 1] = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 123                                    GCForeground, &xgcv);
 124     }
 125   UNBLOCK_INPUT;
 126
 127   if (i < 7)
 128     {
 129       BLOCK_INPUT;
 130       for (i--; i >= 0; i--)
 131         XFreeGC (FRAME_X_DISPLAY (f), new->gcs[i]);
 132       UNBLOCK_INPUT;
 133       if (prev)
 134         prev->next = new->next;
 135       else if (data)
 136         font_put_frame_data (f, &ftxfont_driver, new->next);
 137       free (new);
 138       return NULL;
 139     }
 140   return new->gcs;
 141 }
 142
 143 static int
 144 ftxfont_draw_bitmap (f, gc_fore, gcs, font, code, x, y, p, size, n, flush)
 145      FRAME_PTR f;
 146      GC gc_fore, *gcs;
 147      struct font *font;
 148      unsigned code;
 149      int x, y;
 150      XPoint *p;
 151      int size, *n;
 152      int flush;
 153 {
 154   struct font_bitmap bitmap;
 155   unsigned char *b;
 156   int i, j;
 157
 158   if (ftfont_driver.get_bitmap (font, code, &bitmap, size > 0x100 ? 1 : 8) < 0)
 159     return 0;
 160   if (size > 0x100)
 161     {
 162       for (i = 0, b = bitmap.buffer; i < bitmap.rows;
 163            i++, b += bitmap.pitch)
 164         {
 165           for (j = 0; j < bitmap.width; j++)
 166             if (b[j / 8] & (1 << (7 - (j % 8))))
 167               {
 168                 p[n[0]].x = x + bitmap.left + j;
 169                 p[n[0]].y = y - bitmap.top + i;
 170                 if (++n[0] == size)
 171                   {
 172                     XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 173                                  gc_fore, p, size, CoordModeOrigin);
 174                     n[0] = 0;
 175                   }
 176               }
 177         }
 178       if (flush && n[0] > 0)
 179         XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 180                      gc_fore, p, n[0], CoordModeOrigin);
 181     }
 182   else
 183     {
 184       for (i = 0, b = bitmap.buffer; i < bitmap.rows;
 185            i++, b += bitmap.pitch)
 186         {
 187           for (j = 0; j < bitmap.width; j++)
 188             {
 189               int idx = (bitmap.bits_per_pixel == 1
 190                          ? ((b[j / 8] & (1 << (7 - (j % 8)))) ? 6 : -1)
 191                          : (b[j] >> 5) - 1);
 192
 193               if (idx >= 0)
 194                 {
 195                   XPoint *pp = p + size * idx;
 196
 197                   pp[n[idx]].x = x + bitmap.left + j;
 198                   pp[n[idx]].y = y - bitmap.top + i;
 199                   if (++(n[idx]) == size)
 200                     {
 201                       XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 202                                    idx == 6 ? gc_fore : gcs[idx], pp, size,
 203                                    CoordModeOrigin);
 204                       n[idx] = 0;
 205                     }
 206                 }
 207             }
 208         }
 209       if (flush)
 210         {
 211           for (i = 0; i < 6; i++)
 212             if (n[i] > 0)
 213               XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 214                            gcs[i], p + 0x100 * i, n[i], CoordModeOrigin);
 215           if (n[6] > 0)
 216             XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 217                          gc_fore, p + 0x600, n[6], CoordModeOrigin);
 218         }
 219     }
 220
 221   if (ftfont_driver.free_bitmap)
 222     ftfont_driver.free_bitmap (font, &bitmap);
 223
 224   return bitmap.advance;
 225 }
 226
 227 static void
 228 ftxfont_draw_backgrond (f, font, gc, x, y, width)
 229      FRAME_PTR f;
 230      struct font *font;
 231      GC gc;
 232      int x, y, width;
 233 {
 234   XGCValues xgcv;
 235
 236   XGetGCValues (FRAME_X_DISPLAY (f), gc,
 237                 GCForeground | GCBackground, &xgcv);
 238   XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.background);
 239   XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
 240                   x, y - font->ascent, width, y + font->descent);
 241   XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.foreground);
 242 }
 243
 244 /* Prototypes for font-driver methods.  */
 245 static Lisp_Object ftxfont_list P_ ((Lisp_Object, Lisp_Object));
 246 static Lisp_Object ftxfont_match P_ ((Lisp_Object, Lisp_Object));
 247 static struct font *ftxfont_open P_ ((FRAME_PTR, Lisp_Object, int));
 248 static void ftxfont_close P_ ((FRAME_PTR, struct font *));
 249 static int ftxfont_draw P_ ((struct glyph_string *, int, int, int, int, int));
 250
 251 struct font_driver ftxfont_driver;
 252
 253 static Lisp_Object
 254 ftxfont_list (frame, spec)
 255      Lisp_Object frame;
 256      Lisp_Object spec;
 257 {
 258   Lisp_Object val = ftfont_driver.list (frame, spec);
 259
 260   if (! NILP (val))
 261     {
 262       int i;
 263
 264       for (i = 0; i < ASIZE (val); i++)
 265         ASET (AREF (val, i), FONT_TYPE_INDEX, Qftx);
 266     }
 267   return val;
 268 }
 269
 270 static Lisp_Object
 271 ftxfont_match (frame, spec)
 272      Lisp_Object frame;
 273      Lisp_Object spec;
 274 {
 275   Lisp_Object entity = ftfont_driver.match (frame, spec);
 276
 277   if (VECTORP (entity))
 278     ASET (entity, FONT_TYPE_INDEX, Qftx);
 279   return entity;
 280 }
 281
 282 static struct font *
 283 ftxfont_open (f, entity, pixel_size)
 284      FRAME_PTR f;
 285      Lisp_Object entity;
 286      int pixel_size;
 287 {
 288   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
 289   struct font *font;
 290   XFontStruct *xfont = malloc (sizeof (XFontStruct));
 291
 292   if (! xfont)
 293     return NULL;
 294   font = ftfont_driver.open (f, entity, pixel_size);
 295   if (! font)
 296     {
 297       free (xfont);
 298       return NULL;
 299     }
 300   xfont->fid = (Font) 0;
 301   xfont->ascent = font->ascent;
 302   xfont->descent = font->descent;
 303   xfont->max_bounds.width = font->font.size;
 304   xfont->min_bounds.width = font->min_width;
 305   font->font.font = xfont;
 306   font->driver = &ftxfont_driver;
 307
 308   dpyinfo->n_fonts++;
 309
 310   /* Set global flag fonts_changed_p to non-zero if the font loaded
 311      has a character with a smaller width than any other character
 312      before, or if the font loaded has a smaller height than any other
 313      font loaded before.  If this happens, it will make a glyph matrix
 314      reallocation necessary.  */
 315   if (dpyinfo->n_fonts == 1)
 316     {
 317       dpyinfo->smallest_font_height = font->font.height;
 318       dpyinfo->smallest_char_width = font->min_width;
 319       fonts_changed_p = 1;
 320     }
 321   else
 322     {
 323       if (dpyinfo->smallest_font_height > font->font.height)
 324         dpyinfo->smallest_font_height = font->font.height, fonts_changed_p |= 1;
 325       if (dpyinfo->smallest_char_width > font->min_width)
 326         dpyinfo->smallest_char_width = font->min_width, fonts_changed_p |= 1;
 327     }
 328
 329   if (fonts_changed_p)
 330     {
 331       if (dpyinfo->smallest_font_height == 0)
 332         dpyinfo->smallest_font_height = 1;
 333       if (dpyinfo->smallest_char_width == 0)
 334         dpyinfo->smallest_char_width = 1;
 335     }
 336
 337   return font;
 338 }
 339
 340 static void
 341 ftxfont_close (f, font)
 342      FRAME_PTR f;
 343      struct font *font;
 344 {
 345   ftfont_driver.close (f, font);
 346   FRAME_X_DISPLAY_INFO (f)->n_fonts--;
 347 }
 348
 349 static int
 350 ftxfont_draw (s, from, to, x, y, with_background)
 351      struct glyph_string *s;
 352      int from, to, x, y, with_background;
 353 {
 354   FRAME_PTR f = s->f;
 355   struct face *face = s->face;
 356   struct font *font = (struct font *) s->font_info;
 357   XPoint p[0x700];
 358   int n[7];
 359   unsigned *code;
 360   int len = to - from;
 361   int i;
 362   GC *gcs;
 363   int xadvance;
 364
 365   n[0] = n[1] = n[2] = n[3] = n[4] = n[5] = n[6] = 0;
 366
 367   BLOCK_INPUT;
 368   if (with_background)
 369     ftxfont_draw_backgrond (f, font, s->gc, x, y, s->width);
 370   code = alloca (sizeof (unsigned) * len);
 371   for (i = 0; i < len; i++)
 372     code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
 373                | XCHAR2B_BYTE2 (s->char2b + from + i));
 374
 375   if (face->gc == s->gc)
 376     {
 377       gcs = ftxfont_get_gcs (f, face->foreground, face->background);
 378     }
 379   else
 380     {
 381       XGCValues xgcv;
 382       unsigned long mask = GCForeground | GCBackground;
 383
 384       XGetGCValues (FRAME_X_DISPLAY (f), s->gc, mask, &xgcv);
 385       gcs = ftxfont_get_gcs (f, xgcv.foreground, xgcv.background);
 386     }
 387
 388   if (gcs)
 389     {
 390       if (s->num_clips)
 391         for (i = 0; i < 6; i++)
 392           XSetClipRectangles (FRAME_X_DISPLAY (f), gcs[i], 0, 0,
 393                               s->clip, s->num_clips, Unsorted);
 394
 395       for (i = 0; i < len; i++)
 396         {
 397           xadvance = ftxfont_draw_bitmap (f, s->gc, gcs, font, code[i], x, y,
 398                                           p, 0x100, n, i + 1 == len);
 399           x += (s->padding_p ? 1 : xadvance);
 400         }
 401       if (s->num_clips)
 402         for (i = 0; i < 6; i++)
 403           XSetClipMask (FRAME_X_DISPLAY (f), gcs[i], None);
 404     }
 405   else
 406     {
 407       /* We can't draw with antialiasing.
 408          s->gc should already have a proper clipping setting. */
 409       for (i = 0; i < len; i++)
 410         {
 411           xadvance = ftxfont_draw_bitmap (f, s->gc, NULL, font, code[i], x, y,
 412                                           p, 0x700, n, i + 1 == len);
 413           x += (s->padding_p ? 1 : xadvance);
 414         }
 415     }
 416
 417   UNBLOCK_INPUT;
 418
 419   return len;
 420 }
 421
 422 static int
 423 ftxfont_end_for_frame (f)
 424      FRAME_PTR f;
 425 {
 426   struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
 427
 428   BLOCK_INPUT;
 429   while (data)
 430     {
 431       struct ftxfont_frame_data *next = data->next;
 432       int i;
 433
 434       for (i = 0; i < 6; i++)
 435         XFreeGC (FRAME_X_DISPLAY (f), data->gcs[i]);
 436       free (data);
 437       data = next;
 438     }
 439   UNBLOCK_INPUT;
 440   font_put_frame_data (f, &ftxfont_driver, NULL);
 441   return 0;
 442 }
 443
 444 \f
 445
 446 void
 447 syms_of_ftxfont ()
 448 {
 449   DEFSYM (Qftx, "ftx");
 450
 451   ftxfont_driver = ftfont_driver;
 452   ftxfont_driver.type = Qftx;
 453   ftxfont_driver.list = ftxfont_list;
 454   ftxfont_driver.match = ftxfont_match;
 455   ftxfont_driver.open = ftxfont_open;
 456   ftxfont_driver.close = ftxfont_close;
 457   ftxfont_driver.draw = ftxfont_draw;
 458   ftxfont_driver.end_for_frame = ftxfont_end_for_frame;
 459   register_font_driver (&ftxfont_driver, NULL);
 460 }
 461
 462 /* arch-tag: 59bd3469-5330-413f-b29d-1aa36492abe8
 463    (do not change this comment) */