src/xfaces.c

   1 /* "Face" primitives.
   2    Copyright (C) 1993, 1994 Free Software Foundation.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* This is derived from work by Lucid (some parts very loosely so).  */
  21
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24
  25 #include <config.h>
  26 #include "lisp.h"
  27
  28 #ifdef HAVE_FACES
  29
  30 #ifdef HAVE_X_WINDOWS
  31 #include "xterm.h"
  32 #endif
  33 #ifdef MSDOS
  34 #include "dosfns.h"
  35 #endif
  36 #include "buffer.h"
  37 #include "dispextern.h"
  38 #include "frame.h"
  39 #include "blockinput.h"
  40 #include "window.h"
  41 #include "intervals.h"
  42
  43 #ifdef HAVE_X_WINDOWS
  44 /* Compensate for bug in Xos.h on some systems, on which it requires
  45    time.h.  On some such systems, Xos.h tries to redefine struct
  46    timeval and struct timezone if USG is #defined while it is
  47    #included.  */
  48 #ifdef XOS_NEEDS_TIME_H
  49
  50 #include <time.h>
  51 #undef USG
  52 #include <X11/Xos.h>
  53 #define USG
  54 #define __TIMEVAL__
  55
  56 #else
  57
  58 #include <X11/Xos.h>
  59
  60 #endif
  61 #endif /* HAVE_X_WINDOWS */
  62 \f
  63 /* An explanation of the face data structures.  */
  64
  65 /* ========================= Face Data Structures =========================
  66
  67    Let FACE-NAME be a symbol naming a face.
  68
  69    Let FACE-VECTOR be (assq FACE-NAME (frame-face-alist FRAME))
  70    FACE-VECTOR is either nil, or a vector of the form
  71        [face NAME ID FONT FOREGROUND BACKGROUND BACKGROUND-PIXMAP UNDERLINE-P]
  72    where
  73        face is the symbol `face',
  74        NAME is the symbol with which this vector is associated (a backpointer),
  75        ID is the face ID, an integer used internally by the C code to identify
  76            the face,
  77        FONT, FOREGROUND, and BACKGROUND are strings naming the fonts and colors
  78            to use with the face,
  79        BACKGROUND-PIXMAP is the name of an x bitmap filename, which we don't
  80            use right now, and
  81        UNDERLINE-P is non-nil if the face should be underlined.
  82    If any of these elements are nil, that parameter is considered
  83    unspecified; parameters from faces specified by lower-priority
  84    overlays or text properties, or the parameters of the frame itself,
  85    can show through.  (lisp/faces.el maintains these lists.)
  86
  87    (assq FACE-NAME global-face-data) returns a vector describing the
  88    global parameters for that face.
  89
  90    Let PARAM-FACE be FRAME->display.x->param_faces[Faref (FACE-VECTOR, 2)].
  91    PARAM_FACE is a struct face whose members are the Xlib analogues of
  92    the parameters in FACE-VECTOR.  If an element of FACE-VECTOR is
  93    nil, then the corresponding member of PARAM_FACE is FACE_DEFAULT.
  94    These faces are called "parameter faces", because they're the ones
  95    lisp manipulates to control what gets displayed.  Elements 0 and 1
  96    of FRAME->display.x->param_faces are special - they describe the
  97    default and mode line faces.  None of the faces in param_faces have
  98    GC's.  (See src/dispextern.h for the definiton of struct face.
  99    lisp/faces.el maintains the isomorphism between face_alist and
 100    param_faces.)
 101
 102    The functions compute_char_face and compute_glyph_face find and
 103    combine the parameter faces associated with overlays and text
 104    properties.  The resulting faces are called "computed faces"; none
 105    of their members are FACE_DEFAULT; they are completely specified.
 106    They then call intern_compute_face to search
 107    FRAME->display.x->computed_faces for a matching face, add one if
 108    none is found, and return the index into
 109    FRAME->display.x->computed_faces.  FRAME's glyph matrices use these
 110    indices to record the faces of the matrix characters, and the X
 111    display hooks consult compute_faces to decide how to display these
 112    characters.  Elements 0 and 1 of computed_faces always describe the
 113    default and mode-line faces.
 114
 115    Each computed face belongs to a particular frame.
 116
 117    Computed faces have graphics contexts some of the time.
 118    intern_face builds a GC for a specified computed face
 119    if it doesn't have one already.
 120    clear_face_cache clears out the GCs of all computed faces.
 121    This is done from time to time so that we don't hold on to
 122    lots of GCs that are no longer needed.
 123
 124    Constraints:
 125
 126    Symbols naming faces must have associations on all frames; for any
 127    FRAME, for all FACE-NAME, if (assq FACE-NAME (frame-face-alist
 128    FRAME)) is non-nil, it must be non-nil for all frames.
 129
 130    Analogously, indices into param_faces must be valid on all frames;
 131    if param_faces[i] is a non-zero face pointer on one frame, then it
 132    must be filled in on all frames.  Code assumes that face ID's can
 133    be used on any frame.
 134
 135    Some subtleties:
 136
 137    Why do we keep param_faces and computed_faces separate?
 138    computed_faces contains an element for every combination of facial
 139    parameters we have ever displayed.  indices into param_faces have
 140    to be valid on all frames.  If they were the same array, then that
 141    array would grow very large on all frames, because any facial
 142    combination displayed on any frame would need to be a valid entry
 143    on all frames.  */
 144 \f
 145 /* Definitions and declarations.  */
 146
 147 /* The number of face-id's in use (same for all frames).  */
 148 int next_face_id;
 149
 150 /* The number of the face to use to indicate the region.  */
 151 int region_face;
 152
 153 /* This is what appears in a slot in a face to signify that the face
 154    does not specify that display aspect.  */
 155 #define FACE_DEFAULT (~0)
 156
 157 Lisp_Object Qface, Qmouse_face;
 158 Lisp_Object Qpixmap_spec_p;
 159
 160 int face_name_id_number ( /* FRAME_PTR, Lisp_Object name */ );
 161
 162 struct face *intern_face ( /* FRAME_PTR, struct face * */ );
 163 static int new_computed_face ( /* FRAME_PTR, struct face * */ );
 164 static int intern_computed_face ( /* FRAME_PTR, struct face * */ );
 165 static void ensure_face_ready ( /* FRAME_PTR, int id */ );
 166 void recompute_basic_faces ( /* FRAME_PTR f */ );
 167 \f
 168 /* Allocating, copying, and comparing struct faces.  */
 169
 170 /* Allocate a new face */
 171 static struct face *
 172 allocate_face ()
 173 {
 174   struct face *result = (struct face *) xmalloc (sizeof (struct face));
 175   bzero (result, sizeof (struct face));
 176   result->font = (XFontStruct *) FACE_DEFAULT;
 177   result->foreground = FACE_DEFAULT;
 178   result->background = FACE_DEFAULT;
 179   result->stipple = FACE_DEFAULT;
 180   return result;
 181 }
 182
 183 /* Make a new face that's a copy of an existing one.  */
 184 static struct face *
 185 copy_face (face)
 186      struct face *face;
 187 {
 188   struct face *result = allocate_face ();
 189
 190   result->font = face->font;
 191   result->foreground = face->foreground;
 192   result->background = face->background;
 193   result->stipple = face->stipple;
 194   result->underline = face->underline;
 195   result->pixmap_h = face->pixmap_h;
 196   result->pixmap_w = face->pixmap_w;
 197
 198   return result;
 199 }
 200
 201 static int
 202 face_eql (face1, face2)
 203      struct face *face1, *face2;
 204 {
 205   return (   face1->font       == face2->font
 206           && face1->foreground == face2->foreground
 207           && face1->background == face2->background
 208           && face1->stipple    == face2->stipple
 209           && face1->underline  == face2->underline);
 210 }
 211 \f
 212 /* Managing graphics contexts of faces.  */
 213
 214 #ifdef HAVE_X_WINDOWS
 215 /* Given a computed face, construct its graphics context if necessary.  */
 216
 217 struct face *
 218 intern_face (f, face)
 219      struct frame *f;
 220      struct face *face;
 221 {
 222   GC gc;
 223   XGCValues xgcv;
 224   unsigned long mask;
 225
 226   if (face->gc)
 227     return face;
 228
 229   BLOCK_INPUT;
 230
 231   if (face->foreground != FACE_DEFAULT)
 232     xgcv.foreground = face->foreground;
 233   else
 234     xgcv.foreground = f->display.x->foreground_pixel;
 235
 236   if (face->background != FACE_DEFAULT)
 237     xgcv.background = face->background;
 238   else
 239     xgcv.background = f->display.x->background_pixel;
 240
 241   if (face->font && (int) face->font != FACE_DEFAULT)
 242     xgcv.font = face->font->fid;
 243   else
 244     xgcv.font = f->display.x->font->fid;
 245
 246   xgcv.graphics_exposures = 0;
 247
 248   mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
 249   if (face->stipple && face->stipple != FACE_DEFAULT)
 250     {
 251       xgcv.fill_style = FillStippled;
 252       xgcv.stipple = x_bitmap_pixmap (f, face->stipple);
 253       mask |= GCFillStyle | GCStipple;
 254     }
 255
 256   gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 257                   mask, &xgcv);
 258
 259   face->gc = gc;
 260
 261   UNBLOCK_INPUT;
 262
 263   return face;
 264 }
 265
 266 /* Clear out all graphics contexts for all computed faces
 267    except for the default and mode line faces.
 268    This should be done from time to time just to avoid
 269    keeping too many graphics contexts that are no longer needed.  */
 270
 271 void
 272 clear_face_cache ()
 273 {
 274   Lisp_Object tail, frame;
 275
 276   BLOCK_INPUT;
 277   FOR_EACH_FRAME (tail, frame)
 278     {
 279       FRAME_PTR f = XFRAME (frame);
 280       if (FRAME_X_P (f))
 281         {
 282           int i;
 283           Display *dpy = FRAME_X_DISPLAY (f);
 284
 285           for (i = 2; i < FRAME_N_COMPUTED_FACES (f); i++)
 286             {
 287               struct face *face = FRAME_COMPUTED_FACES (f) [i];
 288               if (face->gc)
 289                 XFreeGC (dpy, face->gc);
 290               face->gc = 0;
 291             }
 292         }
 293     }
 294
 295   UNBLOCK_INPUT;
 296 }
 297 \f
 298 /* Allocating, freeing, and duplicating fonts, colors, and pixmaps.
 299
 300    These functions operate on param faces only.
 301    Computed faces get their fonts, colors and pixmaps
 302    by merging param faces.  */
 303
 304 static XFontStruct *
 305 load_font (f, name)
 306      struct frame *f;
 307      Lisp_Object name;
 308 {
 309   XFontStruct *font;
 310
 311   if (NILP (name))
 312     return (XFontStruct *) FACE_DEFAULT;
 313
 314   CHECK_STRING (name, 0);
 315   BLOCK_INPUT;
 316   font = XLoadQueryFont (FRAME_X_DISPLAY (f), (char *) XSTRING (name)->data);
 317   UNBLOCK_INPUT;
 318
 319   if (! font)
 320     Fsignal (Qerror, Fcons (build_string ("undefined font"),
 321                             Fcons (name, Qnil)));
 322   return font;
 323 }
 324
 325 static void
 326 unload_font (f, font)
 327      struct frame *f;
 328      XFontStruct *font;
 329 {
 330   if (!font || font == ((XFontStruct *) FACE_DEFAULT))
 331     return;
 332
 333   BLOCK_INPUT;
 334   XFreeFont (FRAME_X_DISPLAY (f), font);
 335   UNBLOCK_INPUT;
 336 }
 337
 338 static unsigned long
 339 load_color (f, name)
 340      struct frame *f;
 341      Lisp_Object name;
 342 {
 343   Display *dpy = FRAME_X_DISPLAY (f);
 344   Colormap cmap;
 345   XColor color;
 346   int result;
 347
 348   if (NILP (name))
 349     return FACE_DEFAULT;
 350
 351   cmap = DefaultColormapOfScreen (DefaultScreenOfDisplay (dpy));
 352
 353   CHECK_STRING (name, 0);
 354   BLOCK_INPUT;
 355   result = XParseColor (dpy, cmap, (char *) XSTRING (name)->data, &color);
 356   UNBLOCK_INPUT;
 357   if (! result)
 358     Fsignal (Qerror, Fcons (build_string ("undefined color"),
 359                             Fcons (name, Qnil)));
 360   BLOCK_INPUT;
 361   result = XAllocColor (dpy, cmap, &color);
 362   UNBLOCK_INPUT;
 363   if (! result)
 364     Fsignal (Qerror, Fcons (build_string ("X server cannot allocate color"),
 365                             Fcons (name, Qnil)));
 366   return (unsigned long) color.pixel;
 367 }
 368
 369 static void
 370 unload_color (f, pixel)
 371      struct frame *f;
 372      unsigned long pixel;
 373 {
 374   Colormap cmap;
 375   Display *dpy = FRAME_X_DISPLAY (f);
 376   if (pixel == FACE_DEFAULT
 377       || pixel == BLACK_PIX_DEFAULT
 378       || pixel == WHITE_PIX_DEFAULT)
 379     return;
 380   cmap = DefaultColormapOfScreen (DefaultScreenOfDisplay (dpy));
 381   BLOCK_INPUT;
 382   XFreeColors (dpy, cmap, &pixel, 1, 0);
 383   UNBLOCK_INPUT;
 384 }
 385
 386 DEFUN ("pixmap-spec-p", Fpixmap_spec_p, Spixmap_spec_p, 1, 1, 0,
 387   "Return t if ARG is a valid pixmap specification.")
 388   (arg)
 389      Lisp_Object arg;
 390 {
 391   Lisp_Object height, width;
 392
 393   return ((STRINGP (arg)
 394            || (CONSP (arg)
 395                && CONSP (Fcdr (arg))
 396                && CONSP (Fcdr (Fcdr (arg)))
 397                && NILP (Fcdr (Fcdr (Fcdr (arg))))
 398                && INTEGERP (width = Fcar (arg))
 399                && INTEGERP (height = Fcar (Fcdr (arg)))
 400                && STRINGP (Fcar (Fcdr (Fcdr (arg))))
 401                && XINT (width) > 0
 402                && XINT (height) > 0
 403                /* The string must have enough bits for width * height.  */
 404                && (XINT (width) * XINT (height)
 405                    <= (XSTRING (Fcar (Fcdr (Fcdr (arg))))->size
 406                        * (INTBITS / sizeof (int))))))
 407           ? Qt : Qnil);
 408 }
 409
 410 /* Load a bitmap according to NAME (which is either a file name
 411    or a pixmap spec).  Return the bitmap_id (see xfns.c)
 412    or get an error if NAME is invalid.
 413
 414    Store the bitmap width in *W_PTR and height in *H_PTR.  */
 415
 416 static long
 417 load_pixmap (f, name, w_ptr, h_ptr)
 418      FRAME_PTR *f;
 419      Lisp_Object name;
 420      unsigned int *w_ptr, *h_ptr;
 421 {
 422   int bitmap_id;
 423   Lisp_Object tem;
 424
 425   if (NILP (name))
 426     return FACE_DEFAULT;
 427
 428   tem = Fpixmap_spec_p (name);
 429   if (NILP (tem))
 430     wrong_type_argument (Qpixmap_spec_p, name);
 431
 432   BLOCK_INPUT;
 433
 434   if (CONSP (name))
 435     {
 436       /* Decode a bitmap spec into a bitmap.  */
 437
 438       int h, w;
 439       Lisp_Object bits;
 440
 441       w = XINT (Fcar (name));
 442       h = XINT (Fcar (Fcdr (name)));
 443       bits = Fcar (Fcdr (Fcdr (name)));
 444
 445       bitmap_id = x_create_bitmap_from_data (f, XSTRING (bits)->data,
 446                                              w, h);
 447     }
 448   else
 449     {
 450       /* It must be a string -- a file name.  */
 451       bitmap_id = x_create_bitmap_from_file (f, name);
 452     }
 453   UNBLOCK_INPUT;
 454
 455   if (! bitmap_id)
 456     Fsignal (Qerror, Fcons (build_string ("undefined bitmap"),
 457                             Fcons (name, Qnil)));
 458
 459   *w_ptr = x_bitmap_width (f, bitmap_id);
 460   *h_ptr = x_bitmap_height (f, bitmap_id);
 461
 462   return bitmap_id;
 463 }
 464
 465 #else /* !HAVE_X_WINDOWS */
 466
 467 /* Stubs for MSDOS when not under X.  */
 468
 469 struct face *
 470 intern_face (f, face)
 471      struct frame *f;
 472      struct face *face;
 473 {
 474   return face;
 475 }
 476
 477 void
 478 clear_face_cache ()
 479 {
 480   /* No action.  */
 481 }
 482
 483 static void
 484 build_face (f, face)
 485      struct frame *f;
 486      struct face *face;
 487 {
 488   face->gc = 1;
 489 }
 490
 491 #ifdef MSDOS
 492 unsigned long
 493 load_color (f, name)
 494      FRAME_PTR f;
 495      Lisp_Object name;
 496 {
 497   Lisp_Object result;
 498
 499   if (NILP (name))
 500     return FACE_DEFAULT;
 501
 502   CHECK_STRING (name, 0);
 503   result = call1 (Qmsdos_color_translate, name);
 504   if (INTEGERP (result))
 505     return XINT (result);
 506   else
 507     Fsignal (Qerror, Fcons (build_string ("undefined color"),
 508                             Fcons (name, Qnil)));
 509 }
 510 #endif
 511 #endif /* !HAVE_X_WINDOWS */
 512
 513 \f
 514 /* Managing parameter face arrays for frames. */
 515
 516 void
 517 init_frame_faces (f)
 518      FRAME_PTR f;
 519 {
 520   ensure_face_ready (f, 0);
 521   ensure_face_ready (f, 1);
 522
 523   FRAME_N_COMPUTED_FACES (f) = 0;
 524   FRAME_SIZE_COMPUTED_FACES (f) = 0;
 525
 526   new_computed_face (f, FRAME_PARAM_FACES (f)[0]);
 527   new_computed_face (f, FRAME_PARAM_FACES (f)[1]);
 528   recompute_basic_faces (f);
 529
 530 #ifdef MULTI_FRAME
 531   /* Find another X frame.  */
 532   {
 533     Lisp_Object tail, frame, result;
 534
 535     result = Qnil;
 536     FOR_EACH_FRAME (tail, frame)
 537       if (FRAME_X_P (XFRAME (frame))
 538           && XFRAME (frame) != f)
 539         {
 540           result = frame;
 541           break;
 542         }
 543
 544     /* If we didn't find any X frames other than f, then we don't need
 545        any faces other than 0 and 1, so we're okay.  Otherwise, make
 546        sure that all faces valid on the selected frame are also valid
 547        on this new frame.  */
 548     if (FRAMEP (result))
 549       {
 550         int i;
 551         int n_faces = FRAME_N_PARAM_FACES (XFRAME (result));
 552         struct face **faces = FRAME_PARAM_FACES (XFRAME (result));
 553
 554         for (i = 2; i < n_faces; i++)
 555           if (faces[i])
 556             ensure_face_ready (f, i);
 557       }
 558   }
 559 #endif /* MULTI_FRAME */
 560 }
 561
 562
 563 /* Called from Fdelete_frame.  */
 564
 565 void
 566 free_frame_faces (f)
 567      struct frame *f;
 568 {
 569   Display *dpy = FRAME_X_DISPLAY (f);
 570   int i;
 571
 572   BLOCK_INPUT;
 573
 574   for (i = 0; i < FRAME_N_PARAM_FACES (f); i++)
 575     {
 576       struct face *face = FRAME_PARAM_FACES (f) [i];
 577       if (face)
 578         {
 579           unload_font (f, face->font);
 580           unload_color (f, face->foreground);
 581           unload_color (f, face->background);
 582           x_destroy_bitmap (f, face->stipple);
 583           xfree (face);
 584         }
 585     }
 586   xfree (FRAME_PARAM_FACES (f));
 587   FRAME_PARAM_FACES (f) = 0;
 588   FRAME_N_PARAM_FACES (f) = 0;
 589
 590   /* All faces in FRAME_COMPUTED_FACES use resources copied from
 591      FRAME_PARAM_FACES; we can free them without fuss.
 592      But we do free the GCs and the face objects themselves.  */
 593   for (i = 0; i < FRAME_N_COMPUTED_FACES (f); i++)
 594     {
 595       struct face *face = FRAME_COMPUTED_FACES (f) [i];
 596       if (face)
 597         {
 598           if (face->gc)
 599             XFreeGC (dpy, face->gc);
 600           xfree (face);
 601         }
 602     }
 603   xfree (FRAME_COMPUTED_FACES (f));
 604   FRAME_COMPUTED_FACES (f) = 0;
 605   FRAME_N_COMPUTED_FACES (f) = 0;
 606
 607   UNBLOCK_INPUT;
 608 }
 609 \f
 610 /* Interning faces in a frame's face array.  */
 611
 612 static int
 613 new_computed_face (f, new_face)
 614      struct frame *f;
 615      struct face *new_face;
 616 {
 617   int i = FRAME_N_COMPUTED_FACES (f);
 618
 619   if (i >= FRAME_SIZE_COMPUTED_FACES (f))
 620     {
 621       int new_size = i + 32;
 622
 623       FRAME_COMPUTED_FACES (f)
 624         = (struct face **) (FRAME_SIZE_COMPUTED_FACES (f) == 0
 625                             ? xmalloc (new_size * sizeof (struct face *))
 626                             : xrealloc (FRAME_COMPUTED_FACES (f),
 627                                         new_size * sizeof (struct face *)));
 628       FRAME_SIZE_COMPUTED_FACES (f) = new_size;
 629     }
 630
 631   i = FRAME_N_COMPUTED_FACES (f)++;
 632   FRAME_COMPUTED_FACES (f)[i] = copy_face (new_face);
 633   return i;
 634 }
 635
 636
 637 /* Find a match for NEW_FACE in a FRAME's computed face array, and add
 638    it if we don't find one.  */
 639 static int
 640 intern_computed_face (f, new_face)
 641      struct frame *f;
 642      struct face *new_face;
 643 {
 644   int len = FRAME_N_COMPUTED_FACES (f);
 645   int i;
 646
 647   /* Search for a computed face already on F equivalent to FACE.  */
 648   for (i = 0; i < len; i++)
 649     {
 650       if (! FRAME_COMPUTED_FACES (f)[i])
 651         abort ();
 652       if (face_eql (new_face, FRAME_COMPUTED_FACES (f)[i]))
 653         return i;
 654     }
 655
 656   /* We didn't find one; add a new one.  */
 657   return new_computed_face (f, new_face);
 658 }
 659
 660 /* Make parameter face id ID valid on frame F.  */
 661
 662 static void
 663 ensure_face_ready (f, id)
 664      struct frame *f;
 665      int id;
 666 {
 667   if (FRAME_N_PARAM_FACES (f) <= id)
 668     {
 669       int n = id + 10;
 670       int i;
 671       if (!FRAME_N_PARAM_FACES (f))
 672         FRAME_PARAM_FACES (f)
 673           = (struct face **) xmalloc (sizeof (struct face *) * n);
 674       else
 675         FRAME_PARAM_FACES (f)
 676           = (struct face **) xrealloc (FRAME_PARAM_FACES (f),
 677                                        sizeof (struct face *) * n);
 678
 679       bzero (FRAME_PARAM_FACES (f) + FRAME_N_PARAM_FACES (f),
 680              (n - FRAME_N_PARAM_FACES (f)) * sizeof (struct face *));
 681       FRAME_N_PARAM_FACES (f) = n;
 682     }
 683
 684   if (FRAME_PARAM_FACES (f) [id] == 0)
 685     FRAME_PARAM_FACES (f) [id] = allocate_face ();
 686 }
 687 \f
 688 #ifdef HAVE_X_WINDOWS
 689 /* Return non-zero if FONT1 and FONT2 have the same width.
 690    We do not check the height, because we can now deal with
 691    different heights.
 692    We assume that they're both character-cell fonts.  */
 693
 694 int
 695 same_size_fonts (font1, font2)
 696      XFontStruct *font1, *font2;
 697 {
 698   XCharStruct *bounds1 = &font1->min_bounds;
 699   XCharStruct *bounds2 = &font2->min_bounds;
 700
 701   return (bounds1->width == bounds2->width);
 702 }
 703
 704 /* Update the line_height of frame F according to the biggest font in
 705    any face.  Return nonzero if if line_height changes.  */
 706
 707 int
 708 frame_update_line_height (f)
 709      FRAME_PTR f;
 710 {
 711   int i;
 712   int biggest = FONT_HEIGHT (f->display.x->font);
 713
 714   for (i = 0; i < f->display.x->n_param_faces; i++)
 715     if (f->display.x->param_faces[i] != 0
 716         && f->display.x->param_faces[i]->font != (XFontStruct *) FACE_DEFAULT)
 717       {
 718         int height = FONT_HEIGHT (f->display.x->param_faces[i]->font);
 719         if (height > biggest)
 720           biggest = height;
 721       }
 722
 723   if (biggest == f->display.x->line_height)
 724     return 0;
 725
 726   f->display.x->line_height = biggest;
 727   return 1;
 728 }
 729 #endif /* not HAVE_X_WINDOWS */
 730 \f
 731 /* Modify face TO by copying from FROM all properties which have
 732    nondefault settings.  */
 733
 734 static void
 735 merge_faces (from, to)
 736      struct face *from, *to;
 737 {
 738   /* Only merge the font if it's the same width as the base font.
 739      Otherwise ignore it, since we can't handle it properly.  */
 740   if (from->font != (XFontStruct *) FACE_DEFAULT
 741       && same_size_fonts (from->font, to->font))
 742     to->font = from->font;
 743   if (from->foreground != FACE_DEFAULT)
 744     to->foreground = from->foreground;
 745   if (from->background != FACE_DEFAULT)
 746     to->background = from->background;
 747   if (from->stipple != FACE_DEFAULT)
 748     {
 749       to->stipple = from->stipple;
 750       to->pixmap_h = from->pixmap_h;
 751       to->pixmap_w = from->pixmap_w;
 752     }
 753   if (from->underline)
 754     to->underline = from->underline;
 755 }
 756
 757 /* Set up the basic set of facial parameters, based on the frame's
 758    data; all faces are deltas applied to this.  */
 759
 760 static void
 761 compute_base_face (f, face)
 762      FRAME_PTR f;
 763      struct face *face;
 764 {
 765   face->gc = 0;
 766   face->foreground = FRAME_FOREGROUND_PIXEL (f);
 767   face->background = FRAME_BACKGROUND_PIXEL (f);
 768   face->font = FRAME_FONT (f);
 769   face->stipple = 0;
 770   face->underline = 0;
 771 }
 772
 773 /* Return the face ID to use to display a special glyph which selects
 774    FACE_CODE as the face ID, assuming that ordinarily the face would
 775    be CURRENT_FACE.  F is the frame.  */
 776
 777 int
 778 compute_glyph_face (f, face_code, current_face)
 779      struct frame *f;
 780      int face_code, current_face;
 781 {
 782   struct face face;
 783
 784   face = *FRAME_COMPUTED_FACES (f)[current_face];
 785
 786   if (face_code >= 0 && face_code < FRAME_N_PARAM_FACES (f)
 787       && FRAME_PARAM_FACES (f) [face_code] != 0)
 788     merge_faces (FRAME_PARAM_FACES (f) [face_code], &face);
 789
 790   return intern_computed_face (f, &face);
 791 }
 792
 793 /* Return the face ID to use to display a special glyph which selects
 794    FACE_CODE as the face ID, assuming that ordinarily the face would
 795    be CURRENT_FACE.  F is the frame.  */
 796
 797 int
 798 compute_glyph_face_1 (f, face_name, current_face)
 799      struct frame *f;
 800      Lisp_Object face_name;
 801      int current_face;
 802 {
 803   struct face face;
 804
 805   face = *FRAME_COMPUTED_FACES (f)[current_face];
 806
 807   if (!NILP (face_name))
 808     {
 809       int facecode = face_name_id_number (f, face_name);
 810       if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
 811           && FRAME_PARAM_FACES (f) [facecode] != 0)
 812         merge_faces (FRAME_PARAM_FACES (f) [facecode], &face);
 813     }
 814
 815   return intern_computed_face (f, &face);
 816 }
 817 \f
 818 /* Return the face ID associated with a buffer position POS.
 819    Store into *ENDPTR the position at which a different face is needed.
 820    This does not take account of glyphs that specify their own face codes.
 821    F is the frame in use for display, and W is a window displaying
 822    the current buffer.
 823
 824    REGION_BEG, REGION_END delimit the region, so it can be highlighted.
 825
 826    LIMIT is a position not to scan beyond.  That is to limit
 827    the time this function can take.
 828
 829    If MOUSE is nonzero, use the character's mouse-face, not its face.  */
 830
 831 int
 832 compute_char_face (f, w, pos, region_beg, region_end, endptr, limit, mouse)
 833      struct frame *f;
 834      struct window *w;
 835      int pos;
 836      int region_beg, region_end;
 837      int *endptr;
 838      int limit;
 839      int mouse;
 840 {
 841   struct face face;
 842   Lisp_Object prop, position;
 843   int i, j, noverlays;
 844   int facecode;
 845   Lisp_Object *overlay_vec;
 846   Lisp_Object frame;
 847   int endpos;
 848   Lisp_Object propname;
 849
 850   /* W must display the current buffer.  We could write this function
 851      to use the frame and buffer of W, but right now it doesn't.  */
 852   if (XBUFFER (w->buffer) != current_buffer)
 853     abort ();
 854
 855   XSETFRAME (frame, f);
 856
 857   endpos = ZV;
 858   if (pos < region_beg && region_beg < endpos)
 859     endpos = region_beg;
 860
 861   XSETFASTINT (position, pos);
 862
 863   if (mouse)
 864     propname = Qmouse_face;
 865   else
 866     propname = Qface;
 867
 868   prop = Fget_text_property (position, propname, w->buffer);
 869
 870   {
 871     Lisp_Object limit1, end;
 872
 873     XSETFASTINT (limit1, (limit < endpos ? limit : endpos));
 874     end = Fnext_single_property_change (position, propname, w->buffer, limit1);
 875     if (INTEGERP (end))
 876       endpos = XINT (end);
 877   }
 878
 879   {
 880     int next_overlay;
 881     int len;
 882
 883     /* First try with room for 40 overlays.  */
 884     len = 40;
 885     overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
 886
 887     noverlays = overlays_at (pos, 0, &overlay_vec, &len, &next_overlay, NULL);
 888
 889     /* If there are more than 40,
 890        make enough space for all, and try again.  */
 891     if (noverlays > len)
 892       {
 893         len = noverlays;
 894         overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
 895         noverlays = overlays_at (pos, 0, &overlay_vec, &len,
 896                                  &next_overlay, NULL);
 897       }
 898
 899     if (next_overlay < endpos)
 900       endpos = next_overlay;
 901   }
 902
 903   *endptr = endpos;
 904
 905   /* Optimize the default case.  */
 906   if (noverlays == 0 && NILP (prop)
 907       && !(pos >= region_beg && pos < region_end))
 908     return 0;
 909
 910   compute_base_face (f, &face);
 911
 912   if (CONSP (prop))
 913     {
 914       /* We have a list of faces, merge them in reverse order */
 915       Lisp_Object length = Flength (prop);
 916       int len = XINT (length);
 917       Lisp_Object *faces;
 918
 919       /* Put them into an array */
 920       faces = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
 921       for (j = 0; j < len; j++)
 922         {
 923           faces[j] = Fcar (prop);
 924           prop = Fcdr (prop);
 925         }
 926       /* So that we can merge them in the reverse order */
 927       for (j = len - 1; j >= 0; j--)
 928         {
 929           facecode = face_name_id_number (f, faces[j]);
 930           if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
 931               && FRAME_PARAM_FACES (f) [facecode] != 0)
 932             merge_faces (FRAME_PARAM_FACES (f) [facecode], &face);
 933         }
 934     }
 935   else if (!NILP (prop))
 936     {
 937       facecode = face_name_id_number (f, prop);
 938       if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
 939           && FRAME_PARAM_FACES (f) [facecode] != 0)
 940         merge_faces (FRAME_PARAM_FACES (f) [facecode], &face);
 941     }
 942
 943   noverlays = sort_overlays (overlay_vec, noverlays, w);
 944
 945   /* Now merge the overlay data in that order.  */
 946   for (i = 0; i < noverlays; i++)
 947     {
 948       prop = Foverlay_get (overlay_vec[i], propname);
 949       if (CONSP (prop))
 950         {
 951           /* We have a list of faces, merge them in reverse order */
 952           Lisp_Object length = Flength (prop);
 953           int len = XINT (length);
 954           Lisp_Object *faces;
 955           int i;
 956
 957           /* Put them into an array */
 958           faces = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
 959           for (j = 0; j < len; j++)
 960             {
 961               faces[j] = Fcar (prop);
 962               prop = Fcdr (prop);
 963             }
 964           /* So that we can merge them in the reverse order */
 965           for (j = len - 1; j >= 0; j--)
 966             {
 967               facecode = face_name_id_number (f, faces[j]);
 968               if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
 969                   && FRAME_PARAM_FACES (f) [facecode] != 0)
 970                 merge_faces (FRAME_PARAM_FACES (f) [facecode], &face);
 971             }
 972         }
 973       else if (!NILP (prop))
 974         {
 975           Lisp_Object oend;
 976           int oendpos;
 977
 978           facecode = face_name_id_number (f, prop);
 979           if (facecode >= 0 && facecode < FRAME_N_PARAM_FACES (f)
 980               && FRAME_PARAM_FACES (f) [facecode] != 0)
 981             merge_faces (FRAME_PARAM_FACES (f)[facecode], &face);
 982
 983           oend = OVERLAY_END (overlay_vec[i]);
 984           oendpos = OVERLAY_POSITION (oend);
 985           if (oendpos < endpos)
 986             endpos = oendpos;
 987         }
 988     }
 989
 990   if (pos >= region_beg && pos < region_end)
 991     {
 992       if (region_end < endpos)
 993         endpos = region_end;
 994       if (region_face >= 0 && region_face < next_face_id)
 995         merge_faces (FRAME_PARAM_FACES (f)[region_face], &face);
 996     }
 997
 998   *endptr = endpos;
 999
1000   return intern_computed_face (f, &face);
1001 }
1002 \f
1003 /* Recompute the GC's for the default and modeline faces.
1004    We call this after changing frame parameters on which those GC's
1005    depend.  */
1006
1007 void
1008 recompute_basic_faces (f)
1009      FRAME_PTR f;
1010 {
1011   /* If the frame's faces haven't been initialized yet, don't worry about
1012      this stuff.  */
1013   if (FRAME_N_PARAM_FACES (f) < 2)
1014     return;
1015
1016   BLOCK_INPUT;
1017
1018   if (FRAME_DEFAULT_FACE (f)->gc)
1019     XFreeGC (FRAME_X_DISPLAY (f), FRAME_DEFAULT_FACE (f)->gc);
1020   if (FRAME_MODE_LINE_FACE (f)->gc)
1021     XFreeGC (FRAME_X_DISPLAY (f), FRAME_MODE_LINE_FACE (f)->gc);
1022
1023   compute_base_face (f, FRAME_DEFAULT_FACE (f));
1024   compute_base_face (f, FRAME_MODE_LINE_FACE (f));
1025
1026   merge_faces (FRAME_DEFAULT_PARAM_FACE (f), FRAME_DEFAULT_FACE (f));
1027   merge_faces (FRAME_MODE_LINE_PARAM_FACE (f), FRAME_MODE_LINE_FACE (f));
1028
1029   intern_face (f, FRAME_DEFAULT_FACE (f));
1030   intern_face (f, FRAME_MODE_LINE_FACE (f));
1031
1032   UNBLOCK_INPUT;
1033 }
1034
1035
1036 \f
1037 /* Lisp interface. */
1038
1039 DEFUN ("frame-face-alist", Fframe_face_alist, Sframe_face_alist, 1, 1, 0,
1040        "")
1041      (frame)
1042      Lisp_Object frame;
1043 {
1044   CHECK_FRAME (frame, 0);
1045   return XFRAME (frame)->face_alist;
1046 }
1047
1048 DEFUN ("set-frame-face-alist", Fset_frame_face_alist, Sset_frame_face_alist,
1049        2, 2, 0, "")
1050      (frame, value)
1051      Lisp_Object frame, value;
1052 {
1053   CHECK_FRAME (frame, 0);
1054   XFRAME (frame)->face_alist = value;
1055   return value;
1056 }
1057
1058
1059 DEFUN ("make-face-internal", Fmake_face_internal, Smake_face_internal, 1, 1, 0,
1060   "Create face number FACE-ID on all frames.")
1061   (face_id)
1062      Lisp_Object face_id;
1063 {
1064   Lisp_Object rest, frame;
1065   int id = XINT (face_id);
1066
1067   CHECK_NUMBER (face_id, 0);
1068   if (id < 0 || id >= next_face_id)
1069     error ("Face id out of range");
1070
1071   FOR_EACH_FRAME (rest, frame)
1072     {
1073       if (FRAME_X_P (XFRAME (frame)))
1074         ensure_face_ready (XFRAME (frame), id);
1075     }
1076   return Qnil;
1077 }
1078
1079
1080 DEFUN ("set-face-attribute-internal", Fset_face_attribute_internal,
1081        Sset_face_attribute_internal, 4, 4, 0, "")
1082      (face_id, attr_name, attr_value, frame)
1083      Lisp_Object face_id, attr_name, attr_value, frame;
1084 {
1085   struct face *face;
1086   struct frame *f;
1087   int magic_p;
1088   int id;
1089   int garbaged = 0;
1090
1091   CHECK_FRAME (frame, 0);
1092   CHECK_NUMBER (face_id, 0);
1093   CHECK_SYMBOL (attr_name, 0);
1094
1095   f = XFRAME (frame);
1096   id = XINT (face_id);
1097   if (id < 0 || id >= next_face_id)
1098     error ("Face id out of range");
1099
1100   if (! FRAME_X_P (f))
1101     return Qnil;
1102
1103   ensure_face_ready (f, id);
1104   face = FRAME_PARAM_FACES (f) [XFASTINT (face_id)];
1105
1106   if (EQ (attr_name, intern ("font")))
1107     {
1108 #if defined (MSDOS) && !defined (HAVE_X_WINDOWS)
1109       face->font = 0; /* The one and only font.  */
1110 #else
1111       XFontStruct *font = load_font (f, attr_value);
1112       if (face->font != f->display.x->font)
1113         unload_font (f, face->font);
1114       face->font = font;
1115       if (frame_update_line_height (f))
1116         x_set_window_size (f, 0, f->width, f->height);
1117       /* Must clear cache, since it might contain the font
1118          we just got rid of.  */
1119       garbaged = 1;
1120 #endif
1121     }
1122   else if (EQ (attr_name, intern ("foreground")))
1123     {
1124       unsigned long new_color = load_color (f, attr_value);
1125       unload_color (f, face->foreground);
1126       face->foreground = new_color;
1127       garbaged = 1;
1128     }
1129   else if (EQ (attr_name, intern ("background")))
1130     {
1131       unsigned long new_color = load_color (f, attr_value);
1132       unload_color (f, face->background);
1133 #if defined (MSDOS) && !defined (HAVE_X_WINDOWS)
1134       new_color &= ~8;  /* Bright would give blinking characters.  */
1135 #endif
1136       face->background = new_color;
1137       garbaged = 1;
1138     }
1139   else if (EQ (attr_name, intern ("background-pixmap")))
1140     {
1141       unsigned int w, h;
1142       unsigned long new_pixmap = load_pixmap (f, attr_value, &w, &h);
1143       x_destroy_bitmap (f, face->stipple);
1144       face->stipple = new_pixmap;
1145       face->pixmap_w = w;
1146       face->pixmap_h = h;
1147       garbaged = 1;
1148     }
1149   else if (EQ (attr_name, intern ("underline")))
1150     {
1151       int new = !NILP (attr_value);
1152       face->underline = new;
1153     }
1154   else
1155     error ("unknown face attribute");
1156
1157   if (id == 0 || id == 1)
1158     recompute_basic_faces (f);
1159
1160   /* We must redraw the frame whenever any face font or color changes,
1161      because it's possible that a merged (display) face
1162      contains the font or color we just replaced.
1163      And we must inhibit any Expose events until the redraw is done,
1164      since they would try to use the invalid display faces.  */
1165   if (garbaged)
1166     SET_FRAME_GARBAGED (f);
1167
1168   return Qnil;
1169 }
1170
1171 DEFUN ("internal-next-face-id", Finternal_next_face_id, Sinternal_next_face_id,
1172   0, 0, 0, "")
1173   ()
1174 {
1175   return make_number (next_face_id++);
1176 }
1177
1178 /* Return the face id for name NAME on frame FRAME.
1179    (It should be the same for all frames,
1180    but it's as easy to use the "right" frame to look it up
1181    as to use any other one.)  */
1182
1183 int
1184 face_name_id_number (f, name)
1185      FRAME_PTR f;
1186      Lisp_Object name;
1187 {
1188   Lisp_Object tem;
1189
1190   tem = Fcdr (assq_no_quit (name, f->face_alist));
1191   if (NILP (tem))
1192     return 0;
1193   CHECK_VECTOR (tem, 0);
1194   tem = XVECTOR (tem)->contents[2];
1195   CHECK_NUMBER (tem, 0);
1196   return XINT (tem);
1197 }
1198 \f
1199 /* Emacs initialization.  */
1200
1201 void
1202 syms_of_xfaces ()
1203 {
1204   Qface = intern ("face");
1205   staticpro (&Qface);
1206   Qmouse_face = intern ("mouse-face");
1207   staticpro (&Qmouse_face);
1208   Qpixmap_spec_p = intern ("pixmap-spec-p");
1209   staticpro (&Qpixmap_spec_p);
1210
1211   DEFVAR_INT ("region-face", &region_face,
1212     "Face number to use to highlight the region\n\
1213 The region is highlighted with this face\n\
1214 when Transient Mark mode is enabled and the mark is active.");
1215
1216 #ifdef HAVE_X_WINDOWS
1217   defsubr (&Spixmap_spec_p);
1218 #endif
1219   defsubr (&Sframe_face_alist);
1220   defsubr (&Sset_frame_face_alist);
1221   defsubr (&Smake_face_internal);
1222   defsubr (&Sset_face_attribute_internal);
1223   defsubr (&Sinternal_next_face_id);
1224 }
1225
1226 #endif /* HAVE_FACES */