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 of the License, or
  12 (at your option) 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.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <X11/Xlib.h>
  25
  26 #include "lisp.h"
  27 #include "dispextern.h"
  28 #include "xterm.h"
  29 #include "frame.h"
  30 #include "blockinput.h"
  31 #include "character.h"
  32 #include "charset.h"
  33 #include "fontset.h"
  34 #include "font.h"
  35
  36 /* FTX font driver.  */
  37
  38 static Lisp_Object Qftx;
  39
  40 /* Prototypes for helper function.  */
  41 static GC *ftxfont_get_gcs P_ ((FRAME_PTR, unsigned long, unsigned long));
  42 static int ftxfont_draw_bitmap P_ ((FRAME_PTR, GC, GC *, struct font *,
  43                                     unsigned, int, int, XPoint *, int, int *,
  44                                     int));
  45 static void ftxfont_draw_backgrond P_ ((FRAME_PTR, struct font *, GC,
  46                                         int, int, int));
  47
  48 struct ftxfont_frame_data
  49 {
  50   /* Background and foreground colors.  */
  51   XColor colors[2];
  52   /* GCs interporationg the above colors.  gcs[0] is for a color
  53    closest to BACKGROUND, and gcs[5] is for a color closest to
  54    FOREGROUND.  */
  55   GC gcs[6];
  56   struct ftxfont_frame_data *next;
  57 };
  58
  59
  60 /* Return an array of 6 GCs for antialiasing.  */
  61
  62 static GC *
  63 ftxfont_get_gcs (f, foreground, background)
  64      FRAME_PTR f;
  65      unsigned long foreground, background;
  66 {
  67   XColor color;
  68   XGCValues xgcv;
  69   int i;
  70   struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
  71   struct ftxfont_frame_data *prev = NULL, *this = NULL, *new;
  72
  73   if (data)
  74     {
  75       for (this = data; this; prev = this, this = this->next)
  76         {
  77           if (this->colors[0].pixel < background)
  78             continue;
  79           if (this->colors[0].pixel > background)
  80             break;
  81           if (this->colors[1].pixel < foreground)
  82             continue;
  83           if (this->colors[1].pixel > foreground)
  84             break;
  85           return this->gcs;
  86         }
  87     }
  88
  89   new = malloc (sizeof (struct ftxfont_frame_data));
  90   if (! new)
  91     return NULL;
  92   new->next = this;
  93   if (prev)
  94     {
  95       prev->next = new;
  96     }
  97   else if (font_put_frame_data (f, &ftxfont_driver, new) < 0)
  98     {
  99       free (new);
 100       return NULL;
 101     }
 102
 103   new->colors[0].pixel = background;
 104   new->colors[1].pixel = foreground;
 105
 106   BLOCK_INPUT;
 107   XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), new->colors, 2);
 108   for (i = 1; i < 7; i++)
 109     {
 110       /* Interpolate colors linearly.  Any better algorithm?  */
 111       color.red
 112         = (new->colors[1].red * i + new->colors[0].red * (8 - i)) / 8;
 113       color.green
 114         = (new->colors[1].green * i + new->colors[0].green * (8 - i)) / 8;
 115       color.blue
 116         = (new->colors[1].blue * i + new->colors[0].blue * (8 - i)) / 8;
 117       if (! x_alloc_nearest_color (f, FRAME_X_COLORMAP (f), &color))
 118         break;
 119       xgcv.foreground = color.pixel;
 120       new->gcs[i - 1] = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 121                                    GCForeground, &xgcv);
 122     }
 123   UNBLOCK_INPUT;
 124
 125   if (i < 7)
 126     {
 127       BLOCK_INPUT;
 128       for (i--; i >= 0; i--)
 129         XFreeGC (FRAME_X_DISPLAY (f), new->gcs[i]);
 130       UNBLOCK_INPUT;
 131       if (prev)
 132         prev->next = new->next;
 133       else if (data)
 134         font_put_frame_data (f, &ftxfont_driver, new->next);
 135       free (new);
 136       return NULL;
 137     }
 138   return new->gcs;
 139 }
 140
 141 static int
 142 ftxfont_draw_bitmap (f, gc_fore, gcs, font, code, x, y, p, size, n, flush)
 143      FRAME_PTR f;
 144      GC gc_fore, *gcs;
 145      struct font *font;
 146      unsigned code;
 147      int x, y;
 148      XPoint *p;
 149      int size, *n;
 150      int flush;
 151 {
 152   struct font_bitmap bitmap;
 153   unsigned char *b;
 154   int i, j;
 155
 156   if (ftfont_driver.get_bitmap (font, code, &bitmap, size > 0x100 ? 1 : 8) < 0)
 157     return 0;
 158   if (size > 0x100)
 159     {
 160       for (i = 0, b = bitmap.buffer; i < bitmap.rows;
 161            i++, b += bitmap.pitch)
 162         {
 163           for (j = 0; j < bitmap.width; j++)
 164             if (b[j / 8] & (1 << (7 - (j % 8))))
 165               {
 166                 p[n[0]].x = x + bitmap.left + j;
 167                 p[n[0]].y = y - bitmap.top + i;
 168                 if (++n[0] == size)
 169                   {
 170                     XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 171                                  gc_fore, p, size, CoordModeOrigin);
 172                     n[0] = 0;
 173                   }
 174               }
 175         }
 176       if (flush && n[0] > 0)
 177         XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 178                      gc_fore, p, n[0], CoordModeOrigin);
 179     }
 180   else
 181     {
 182       for (i = 0, b = bitmap.buffer; i < bitmap.rows;
 183            i++, b += bitmap.pitch)
 184         {
 185           for (j = 0; j < bitmap.width; j++)
 186             {
 187               int idx = (bitmap.bits_per_pixel == 1
 188                          ? ((b[j / 8] & (1 << (7 - (j % 8)))) ? 6 : -1)
 189                          : (b[j] >> 5) - 1);
 190
 191               if (idx >= 0)
 192                 {
 193                   XPoint *pp = p + size * idx;
 194
 195                   pp[n[idx]].x = x + bitmap.left + j;
 196                   pp[n[idx]].y = y - bitmap.top + i;
 197                   if (++(n[idx]) == size)
 198                     {
 199                       XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 200                                    idx == 6 ? gc_fore : gcs[idx], pp, size,
 201                                    CoordModeOrigin);
 202                       n[idx] = 0;
 203                     }
 204                 }
 205             }
 206         }
 207       if (flush)
 208         {
 209           for (i = 0; i < 6; i++)
 210             if (n[i] > 0)
 211               XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 212                            gcs[i], p + 0x100 * i, n[i], CoordModeOrigin);
 213           if (n[6] > 0)
 214             XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 215                          gc_fore, p + 0x600, n[6], CoordModeOrigin);
 216         }
 217     }
 218
 219   if (ftfont_driver.free_bitmap)
 220     ftfont_driver.free_bitmap (font, &bitmap);
 221
 222   return bitmap.advance;
 223 }
 224
 225 static void
 226 ftxfont_draw_backgrond (f, font, gc, x, y, width)
 227      FRAME_PTR f;
 228      struct font *font;
 229      GC gc;
 230      int x, y, width;
 231 {
 232   XGCValues xgcv;
 233
 234   XGetGCValues (FRAME_X_DISPLAY (f), gc,
 235                 GCForeground | GCBackground, &xgcv);
 236   XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.background);
 237   XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
 238                   x, y - font->ascent, width, y + font->descent);
 239   XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.foreground);
 240 }
 241
 242 /* Prototypes for font-driver methods.  */
 243 static Lisp_Object ftxfont_list P_ ((Lisp_Object, Lisp_Object));
 244 static Lisp_Object ftxfont_match P_ ((Lisp_Object, Lisp_Object));
 245 static Lisp_Object ftxfont_open P_ ((FRAME_PTR, Lisp_Object, int));
 246 static void ftxfont_close P_ ((FRAME_PTR, struct font *));
 247 static int ftxfont_draw P_ ((struct glyph_string *, int, int, int, int, int));
 248
 249 struct font_driver ftxfont_driver;
 250
 251 static Lisp_Object
 252 ftxfont_list (frame, spec)
 253      Lisp_Object frame;
 254      Lisp_Object spec;
 255 {
 256   Lisp_Object list = ftfont_driver.list (frame, spec), tail;
 257
 258   for (tail = list; CONSP (tail); tail = XCDR (tail))
 259     ASET (XCAR (tail), FONT_TYPE_INDEX, Qftx);
 260   return list;
 261 }
 262
 263 static Lisp_Object
 264 ftxfont_match (frame, spec)
 265      Lisp_Object frame;
 266      Lisp_Object spec;
 267 {
 268   Lisp_Object entity = ftfont_driver.match (frame, spec);
 269
 270   if (VECTORP (entity))
 271     ASET (entity, FONT_TYPE_INDEX, Qftx);
 272   return entity;
 273 }
 274
 275 static Lisp_Object
 276 ftxfont_open (f, entity, pixel_size)
 277      FRAME_PTR f;
 278      Lisp_Object entity;
 279      int pixel_size;
 280 {
 281   Lisp_Object font_object;
 282   struct font *font;
 283
 284   font_object = ftfont_driver.open (f, entity, pixel_size);
 285   if (NILP (font_object))
 286     return Qnil;
 287   font = XFONT_OBJECT (font_object);
 288   font->driver = &ftxfont_driver;
 289   return font_object;
 290 }
 291
 292 static void
 293 ftxfont_close (f, font)
 294      FRAME_PTR f;
 295      struct font *font;
 296 {
 297   ftfont_driver.close (f, font);
 298 }
 299
 300 static int
 301 ftxfont_draw (s, from, to, x, y, with_background)
 302      struct glyph_string *s;
 303      int from, to, x, y, with_background;
 304 {
 305   FRAME_PTR f = s->f;
 306   struct face *face = s->face;
 307   struct font *font = s->font;
 308   XPoint p[0x700];
 309   int n[7];
 310   unsigned *code;
 311   int len = to - from;
 312   int i;
 313   GC *gcs;
 314   int xadvance;
 315
 316   n[0] = n[1] = n[2] = n[3] = n[4] = n[5] = n[6] = 0;
 317
 318   BLOCK_INPUT;
 319   if (with_background)
 320     ftxfont_draw_backgrond (f, font, s->gc, x, y, s->width);
 321   code = alloca (sizeof (unsigned) * len);
 322   for (i = 0; i < len; i++)
 323     code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
 324                | XCHAR2B_BYTE2 (s->char2b + from + i));
 325
 326   if (face->gc == s->gc)
 327     {
 328       gcs = ftxfont_get_gcs (f, face->foreground, face->background);
 329     }
 330   else
 331     {
 332       XGCValues xgcv;
 333       unsigned long mask = GCForeground | GCBackground;
 334
 335       XGetGCValues (FRAME_X_DISPLAY (f), s->gc, mask, &xgcv);
 336       gcs = ftxfont_get_gcs (f, xgcv.foreground, xgcv.background);
 337     }
 338
 339   if (gcs)
 340     {
 341       if (s->num_clips)
 342         for (i = 0; i < 6; i++)
 343           XSetClipRectangles (FRAME_X_DISPLAY (f), gcs[i], 0, 0,
 344                               s->clip, s->num_clips, Unsorted);
 345
 346       for (i = 0; i < len; i++)
 347         {
 348           xadvance = ftxfont_draw_bitmap (f, s->gc, gcs, font, code[i], x, y,
 349                                           p, 0x100, n, i + 1 == len);
 350           x += (s->padding_p ? 1 : xadvance);
 351         }
 352       if (s->num_clips)
 353         for (i = 0; i < 6; i++)
 354           XSetClipMask (FRAME_X_DISPLAY (f), gcs[i], None);
 355     }
 356   else
 357     {
 358       /* We can't draw with antialiasing.
 359          s->gc should already have a proper clipping setting. */
 360       for (i = 0; i < len; i++)
 361         {
 362           xadvance = ftxfont_draw_bitmap (f, s->gc, NULL, font, code[i], x, y,
 363                                           p, 0x700, n, i + 1 == len);
 364           x += (s->padding_p ? 1 : xadvance);
 365         }
 366     }
 367
 368   UNBLOCK_INPUT;
 369
 370   return len;
 371 }
 372
 373 static int
 374 ftxfont_end_for_frame (f)
 375      FRAME_PTR f;
 376 {
 377   struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
 378
 379   BLOCK_INPUT;
 380   while (data)
 381     {
 382       struct ftxfont_frame_data *next = data->next;
 383       int i;
 384
 385       for (i = 0; i < 6; i++)
 386         XFreeGC (FRAME_X_DISPLAY (f), data->gcs[i]);
 387       free (data);
 388       data = next;
 389     }
 390   UNBLOCK_INPUT;
 391   font_put_frame_data (f, &ftxfont_driver, NULL);
 392   return 0;
 393 }
 394
 395 \f
 396
 397 void
 398 syms_of_ftxfont ()
 399 {
 400   DEFSYM (Qftx, "ftx");
 401
 402   ftxfont_driver = ftfont_driver;
 403   ftxfont_driver.type = Qftx;
 404   ftxfont_driver.list = ftxfont_list;
 405   ftxfont_driver.match = ftxfont_match;
 406   ftxfont_driver.open = ftxfont_open;
 407   ftxfont_driver.close = ftxfont_close;
 408   ftxfont_driver.draw = ftxfont_draw;
 409   ftxfont_driver.end_for_frame = ftxfont_end_for_frame;
 410   register_font_driver (&ftxfont_driver, NULL);
 411 }
 412
 413 /* arch-tag: 59bd3469-5330-413f-b29d-1aa36492abe8
 414    (do not change this comment) */