src/ftxfont.c

   1 /* ftxfont.c -- FreeType font driver on X (without using XFT).
   2    Copyright (C) 2006-2014 Free Software Foundation, Inc.
   3    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
   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 struct font_driver ftxfont_driver;
  41
  42 struct ftxfont_frame_data
  43 {
  44   /* Background and foreground colors.  */
  45   XColor colors[2];
  46   /* GCs interpolating the above colors.  gcs[0] is for a color
  47    closest to BACKGROUND, and gcs[5] is for a color closest to
  48    FOREGROUND.  */
  49   GC gcs[6];
  50   struct ftxfont_frame_data *next;
  51 };
  52
  53
  54 /* Return an array of 6 GCs for antialiasing.  */
  55
  56 static GC *
  57 ftxfont_get_gcs (struct frame *f, unsigned long foreground, unsigned long background)
  58 {
  59   XColor color;
  60   XGCValues xgcv;
  61   int i;
  62   struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
  63   struct ftxfont_frame_data *prev = NULL, *this = NULL, *new;
  64
  65   if (data)
  66     {
  67       for (this = data; this; prev = this, this = this->next)
  68         {
  69           if (this->colors[0].pixel < background)
  70             continue;
  71           if (this->colors[0].pixel > background)
  72             break;
  73           if (this->colors[1].pixel < foreground)
  74             continue;
  75           if (this->colors[1].pixel > foreground)
  76             break;
  77           return this->gcs;
  78         }
  79     }
  80
  81   new = xmalloc_unsafe (sizeof *new);
  82   if (! new)
  83     return NULL;
  84   new->next = this;
  85   if (prev)
  86     {
  87       prev->next = new;
  88     }
  89   else if (font_put_frame_data (f, &ftxfont_driver, new) < 0)
  90     {
  91       xfree (new);
  92       return NULL;
  93     }
  94
  95   new->colors[0].pixel = background;
  96   new->colors[1].pixel = foreground;
  97
  98   block_input ();
  99   XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), new->colors, 2);
 100   for (i = 1; i < 7; i++)
 101     {
 102       /* Interpolate colors linearly.  Any better algorithm?  */
 103       color.red
 104         = (new->colors[1].red * i + new->colors[0].red * (8 - i)) / 8;
 105       color.green
 106         = (new->colors[1].green * i + new->colors[0].green * (8 - i)) / 8;
 107       color.blue
 108         = (new->colors[1].blue * i + new->colors[0].blue * (8 - i)) / 8;
 109       if (! x_alloc_nearest_color (f, FRAME_X_COLORMAP (f), &color))
 110         break;
 111       xgcv.foreground = color.pixel;
 112       new->gcs[i - 1] = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 113                                    GCForeground, &xgcv);
 114     }
 115   unblock_input ();
 116
 117   if (i < 7)
 118     {
 119       block_input ();
 120       for (i--; i >= 0; i--)
 121         XFreeGC (FRAME_X_DISPLAY (f), new->gcs[i]);
 122       unblock_input ();
 123       if (prev)
 124         prev->next = new->next;
 125       else if (data)
 126         font_put_frame_data (f, &ftxfont_driver, new->next);
 127       xfree (new);
 128       return NULL;
 129     }
 130   return new->gcs;
 131 }
 132
 133 static int
 134 ftxfont_draw_bitmap (struct frame *f, GC gc_fore, GC *gcs, struct font *font,
 135                      unsigned int code, int x, int y, XPoint *p, int size,
 136                      int *n, bool flush)
 137 {
 138   struct font_bitmap bitmap;
 139   unsigned char *b;
 140   int i, j;
 141
 142   if (ftfont_driver.get_bitmap (font, code, &bitmap, size > 0x100 ? 1 : 8) < 0)
 143     return 0;
 144   if (size > 0x100)
 145     {
 146       for (i = 0, b = bitmap.buffer; i < bitmap.rows;
 147            i++, b += bitmap.pitch)
 148         {
 149           for (j = 0; j < bitmap.width; j++)
 150             if (b[j / 8] & (1 << (7 - (j % 8))))
 151               {
 152                 p[n[0]].x = x + bitmap.left + j;
 153                 p[n[0]].y = y - bitmap.top + i;
 154                 if (++n[0] == size)
 155                   {
 156                     XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 157                                  gc_fore, p, size, CoordModeOrigin);
 158                     n[0] = 0;
 159                   }
 160               }
 161         }
 162       if (flush && n[0] > 0)
 163         XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 164                      gc_fore, p, n[0], CoordModeOrigin);
 165     }
 166   else
 167     {
 168       for (i = 0, b = bitmap.buffer; i < bitmap.rows;
 169            i++, b += bitmap.pitch)
 170         {
 171           for (j = 0; j < bitmap.width; j++)
 172             {
 173               int idx = (bitmap.bits_per_pixel == 1
 174                          ? ((b[j / 8] & (1 << (7 - (j % 8)))) ? 6 : -1)
 175                          : (b[j] >> 5) - 1);
 176
 177               if (idx >= 0)
 178                 {
 179                   XPoint *pp = p + size * idx;
 180
 181                   pp[n[idx]].x = x + bitmap.left + j;
 182                   pp[n[idx]].y = y - bitmap.top + i;
 183                   if (++(n[idx]) == size)
 184                     {
 185                       XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 186                                    idx == 6 ? gc_fore : gcs[idx], pp, size,
 187                                    CoordModeOrigin);
 188                       n[idx] = 0;
 189                     }
 190                 }
 191             }
 192         }
 193       if (flush)
 194         {
 195           for (i = 0; i < 6; i++)
 196             if (n[i] > 0)
 197               XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 198                            gcs[i], p + 0x100 * i, n[i], CoordModeOrigin);
 199           if (n[6] > 0)
 200             XDrawPoints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 201                          gc_fore, p + 0x600, n[6], CoordModeOrigin);
 202         }
 203     }
 204
 205   if (ftfont_driver.free_bitmap)
 206     ftfont_driver.free_bitmap (font, &bitmap);
 207
 208   return bitmap.advance;
 209 }
 210
 211 static void
 212 ftxfont_draw_background (struct frame *f, struct font *font, GC gc, int x, int y,
 213                          int width)
 214 {
 215   XGCValues xgcv;
 216
 217   XGetGCValues (FRAME_X_DISPLAY (f), gc,
 218                 GCForeground | GCBackground, &xgcv);
 219   XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.background);
 220   XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
 221                   x, y - FONT_BASE (font), width, FONT_HEIGHT (font));
 222   XSetForeground (FRAME_X_DISPLAY (f), gc, xgcv.foreground);
 223 }
 224
 225 static Lisp_Object
 226 ftxfont_list (struct frame *f, Lisp_Object spec)
 227 {
 228   Lisp_Object list = ftfont_driver.list (f, spec), tail;
 229
 230   for (tail = list; CONSP (tail); tail = XCDR (tail))
 231     ASET (XCAR (tail), FONT_TYPE_INDEX, Qftx);
 232   return list;
 233 }
 234
 235 static Lisp_Object
 236 ftxfont_match (struct frame *f, Lisp_Object spec)
 237 {
 238   Lisp_Object entity = ftfont_driver.match (f, spec);
 239
 240   if (VECTORP (entity))
 241     ASET (entity, FONT_TYPE_INDEX, Qftx);
 242   return entity;
 243 }
 244
 245 static Lisp_Object
 246 ftxfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
 247 {
 248   Lisp_Object font_object;
 249   struct font *font;
 250
 251   font_object = ftfont_driver.open (f, entity, pixel_size);
 252   if (NILP (font_object))
 253     return Qnil;
 254   font = XFONT_OBJECT (font_object);
 255   font->driver = &ftxfont_driver;
 256   return font_object;
 257 }
 258
 259 static void
 260 ftxfont_close (struct font *font)
 261 {
 262   ftfont_driver.close (font);
 263 }
 264
 265 static int
 266 ftxfont_draw (struct glyph_string *s, int from, int to, int x, int y,
 267               bool with_background)
 268 {
 269   struct frame *f = s->f;
 270   struct face *face = s->face;
 271   struct font *font = s->font;
 272   XPoint p[0x700];
 273   int n[7];
 274   unsigned *code;
 275   int len = to - from;
 276   int i;
 277   GC *gcs;
 278   int xadvance;
 279
 280   n[0] = n[1] = n[2] = n[3] = n[4] = n[5] = n[6] = 0;
 281
 282   block_input ();
 283   if (with_background)
 284     ftxfont_draw_background (f, font, s->gc, x, y, s->width);
 285   code = alloca (sizeof (unsigned) * len);
 286   for (i = 0; i < len; i++)
 287     code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
 288                | XCHAR2B_BYTE2 (s->char2b + from + i));
 289
 290   if (face->gc == s->gc)
 291     {
 292       gcs = ftxfont_get_gcs (f, face->foreground, face->background);
 293     }
 294   else
 295     {
 296       XGCValues xgcv;
 297       unsigned long mask = GCForeground | GCBackground;
 298
 299       XGetGCValues (FRAME_X_DISPLAY (f), s->gc, mask, &xgcv);
 300       gcs = ftxfont_get_gcs (f, xgcv.foreground, xgcv.background);
 301     }
 302
 303   if (gcs)
 304     {
 305       if (s->num_clips)
 306         for (i = 0; i < 6; i++)
 307           XSetClipRectangles (FRAME_X_DISPLAY (f), gcs[i], 0, 0,
 308                               s->clip, s->num_clips, Unsorted);
 309
 310       for (i = 0; i < len; i++)
 311         {
 312           xadvance = ftxfont_draw_bitmap (f, s->gc, gcs, font, code[i], x, y,
 313                                           p, 0x100, n, i + 1 == len);
 314           x += (s->padding_p ? 1 : xadvance);
 315         }
 316       if (s->num_clips)
 317         for (i = 0; i < 6; i++)
 318           XSetClipMask (FRAME_X_DISPLAY (f), gcs[i], None);
 319     }
 320   else
 321     {
 322       /* We can't draw with antialiasing.
 323          s->gc should already have a proper clipping setting. */
 324       for (i = 0; i < len; i++)
 325         {
 326           xadvance = ftxfont_draw_bitmap (f, s->gc, NULL, font, code[i], x, y,
 327                                           p, 0x700, n, i + 1 == len);
 328           x += (s->padding_p ? 1 : xadvance);
 329         }
 330     }
 331
 332   unblock_input ();
 333
 334   return len;
 335 }
 336
 337 static int
 338 ftxfont_end_for_frame (struct frame *f)
 339 {
 340   struct ftxfont_frame_data *data = font_get_frame_data (f, &ftxfont_driver);
 341
 342   block_input ();
 343   while (data)
 344     {
 345       struct ftxfont_frame_data *next = data->next;
 346       int i;
 347
 348       for (i = 0; i < 6; i++)
 349         XFreeGC (FRAME_X_DISPLAY (f), data->gcs[i]);
 350       xfree (data);
 351       data = next;
 352     }
 353   unblock_input ();
 354   font_put_frame_data (f, &ftxfont_driver, NULL);
 355   return 0;
 356 }
 357
 358 \f
 359
 360 void
 361 syms_of_ftxfont (void)
 362 {
 363   DEFSYM (Qftx, "ftx");
 364
 365   ftxfont_driver = ftfont_driver;
 366   ftxfont_driver.type = Qftx;
 367   ftxfont_driver.list = ftxfont_list;
 368   ftxfont_driver.match = ftxfont_match;
 369   ftxfont_driver.open = ftxfont_open;
 370   ftxfont_driver.close = ftxfont_close;
 371   ftxfont_driver.draw = ftxfont_draw;
 372   ftxfont_driver.end_for_frame = ftxfont_end_for_frame;
 373   register_font_driver (&ftxfont_driver, NULL);
 374 }