lisp/international/fontset.el

   1 ;;; fontset.el --- Commands for handling fontset.
   2
   3 ;; Copyright (C) 1995 Free Software Foundation, Inc.
   4 ;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
   5
   6 ;; Keywords: mule, multilingual, fontset
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  24
  25 ;;; Code:
  26
  27 ;; Set default REGISTRY property of charset to find an appropriate
  28 ;; font for each charset.  This is used to generate a font name in a
  29 ;; fontset.  If the value contains a character `-', the string before
  30 ;; that is embeded in `CHARSET_REGISTRY' field, and the string after
  31 ;; that is embeded in `CHARSET_ENCODING' field.  If the value does not
  32 ;; contain `-', the whole string is embeded in `CHARSET_REGISTRY'
  33 ;; field, and a wild card character `*' is embeded in
  34 ;; `CHARSET_ENCODING' field.
  35
  36 (defvar x-charset-registries
  37   '((ascii . "ISO8859-1")
  38     (latin-iso8859-1 . "ISO8859-1")
  39     (latin-iso8859-2 . "ISO8859-2")
  40     (latin-iso8859-3 . "ISO8859-3")
  41     (latin-iso8859-4 . "ISO8859-4")
  42     (thai-tis620 . "TIS620")
  43     (greek-iso8859-7 . "ISO8859-7")
  44     (arabic-iso8859-6 . "ISO8859-6")
  45     (hebrew-iso8859-8 . "ISO8859-8")
  46     (katakana-jisx0201 . "JISX0201")
  47     (latin-jisx0201 . "JISX0201")
  48     (cyrillic-iso8859-5 . "ISO8859-5")
  49     (latin-iso8859-9 . "ISO8859-9")
  50     (japanese-jisx0208-1978 . "JISX0208.1978")
  51     (chinese-gb2312 . "GB2312")
  52     (japanese-jisx0208 . "JISX0208.1983")
  53     (korean-ksc5601 . "KSC5601")
  54     (japanese-jisx0212 . "JISX0212")
  55     (chinese-cns11643-1 . "CNS11643.1992-1")
  56     (chinese-cns11643-2 . "CNS11643.1992-2")
  57     (chinese-cns11643-3 . "CNS11643.1992-3")
  58     (chinese-cns11643-4 . "CNS11643.1992-4")
  59     (chinese-cns11643-5 . "CNS11643.1992-5")
  60     (chinese-cns11643-6 . "CNS11643.1992-6")
  61     (chinese-cns11643-7 . "CNS11643.1992-7")
  62     (chinese-big5-1 . "Big5")
  63     (chinese-big5-2 . "Big5")
  64     (chinese-sisheng . "sisheng_cwnn")
  65     (vietnamese-viscii-lower . "VISCII1.1")
  66     (vietnamese-viscii-upper . "VISCII1.1")
  67     (arabic-digit . "MuleArabic-0")
  68     (arabic-1-column . "MuleArabic-1")
  69     (arabic-2-column . "MuleArabic-2")
  70     (ipa . "MuleIPA")
  71     (ethiopic . "Ethiopic-Unicode")
  72     (ascii-right-to-left . "ISO8859-1")
  73     (indian-is13194 . "IS13194-Devanagari")
  74     (indian-2-column . "MuleIndian-2")
  75     (indian-1-column . "MuleIndian-1")
  76     (lao . "lao.mule-1")
  77     (tibetan . "Mule.Tibetan-0")
  78     (tibetan-1-column . "Mule.Tibetan-1")
  79     ))
  80
  81 (let ((l x-charset-registries))
  82   (while l
  83     (condition-case nil
  84         (put-charset-property (car (car l)) 'x-charset-registry (cdr (car l)))
  85       (error nil))
  86     (setq l (cdr l))))
  87
  88 ;; Set arguments in `font-encoding-alist' (which see).
  89 (defun set-font-encoding (pattern charset encoding)
  90   (let ((slot (assoc pattern font-encoding-alist)))
  91     (if slot
  92         (let ((place (assq charset (cdr slot))))
  93           (if place
  94               (setcdr place encoding)
  95             (setcdr slot (cons (cons charset encoding) (cdr slot)))))
  96       (setq font-encoding-alist
  97             (cons (list pattern (cons charset encoding)) font-encoding-alist)))
  98     ))
  99
 100 (set-font-encoding "ISO8859-1" 'ascii 0)
 101 (set-font-encoding "JISX0201" 'latin-jisx0201 0)
 102
 103 ;; Setting for suppressing XLoadQueryFont on big fonts.
 104 (setq x-pixel-size-width-font-regexp
 105       "gb2312\\|jisx0208\\|ksc5601\\|cns11643\\|big5")
 106
 107 ;;; XLFD (X Logical Font Description) format handler.
 108
 109 ;; Define XLFD's field index numbers.           ; field name
 110 (defconst xlfd-regexp-foundry-subnum 0)         ; FOUNDRY
 111 (defconst xlfd-regexp-family-subnum 1)          ; FAMILY_NAME
 112 (defconst xlfd-regexp-weight-subnum 2)          ; WEIGHT_NAME
 113 (defconst xlfd-regexp-slant-subnum 3)           ; SLANT
 114 (defconst xlfd-regexp-swidth-subnum 4)          ; SETWIDTH_NAME
 115 (defconst xlfd-regexp-adstyle-subnum 5)         ; ADD_STYLE_NAME
 116 (defconst xlfd-regexp-pixelsize-subnum 6)       ; PIXEL_SIZE
 117 (defconst xlfd-regexp-pointsize-subnum 7)       ; POINT_SIZE
 118 (defconst xlfd-regexp-resx-subnum 8)            ; RESOLUTION_X
 119 (defconst xlfd-regexp-resy-subnum 9)            ; RESOLUTION_Y
 120 (defconst xlfd-regexp-spacing-subnum 10)        ; SPACING
 121 (defconst xlfd-regexp-avgwidth-subnum 11)       ; AVERAGE_WIDTH
 122 (defconst xlfd-regexp-registry-subnum 12)       ; CHARSET_REGISTRY
 123 (defconst xlfd-regexp-encoding-subnum 13)       ; CHARSET_ENCODING
 124
 125 ;; Regular expression matching against a fontname which conforms to
 126 ;; XLFD (X Logical Font Description).  All fields in XLFD should be
 127 ;; not be omitted (but can be a wild card) to be matched.
 128 (defconst xlfd-tight-regexp
 129   "^\
 130 -\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)\
 131 -\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)\
 132 -\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)$")
 133
 134 ;; List of field numbers of XLFD whose values are numeric.
 135 (defconst xlfd-regexp-numeric-subnums
 136   (list xlfd-regexp-pixelsize-subnum    ;6
 137         xlfd-regexp-pointsize-subnum    ;7
 138         xlfd-regexp-resx-subnum         ;8
 139         xlfd-regexp-resy-subnum         ;9
 140         xlfd-regexp-avgwidth-subnum     ;11
 141         ))
 142
 143 (defun x-decompose-font-name (pattern)
 144   "Decompose PATTERN into XLFD's fields and return vector of the fields.
 145 The length of the vector is 14.
 146
 147 If PATTERN doesn't conform to XLFD, try to get a full XLFD name from
 148 X server and use the information of the full name to decompose
 149 PATTERN.  If no full XLFD name is gotten, return nil."
 150   (let (xlfd-fields fontname)
 151     (if (string-match xlfd-tight-regexp pattern)
 152         (let ((i 0))
 153           (setq xlfd-fields (make-vector 14 nil))
 154           (while (< i 14)
 155             (aset xlfd-fields i (match-string (1+ i) pattern))
 156             (setq i (1+ i)))
 157           xlfd-fields)
 158       (setq fontname (condition-case nil
 159                          (x-resolve-font-name pattern)
 160                        (error)))
 161       (if (and fontname
 162                (string-match xlfd-tight-regexp fontname))
 163           (let ((len (length pattern))
 164                 (i 0)
 165                 l)
 166             (setq xlfd-fields (make-vector 14 nil))
 167             (while (< i 14)
 168               (aset xlfd-fields i
 169                     (cons (match-beginning (1+ i))
 170                           (match-string (1+ i) fontname)))
 171               (setq i (1+ i)))
 172             (setq i 0)
 173             (while (< i len)
 174               (let ((ch (aref pattern i)))
 175                 (if (= ch ??)
 176                     (setq pattern (concat (substring pattern 0 i)
 177                                           "\\(.\\)"
 178                                           (substring pattern (1+ i)))
 179                           len (+ len 4)
 180                           i (+ i 4))
 181                   (if (= ch ?*)
 182                       (setq pattern (concat (substring pattern 0 i)
 183                                             "\\(.*\\)"
 184                                             (substring pattern (1+ i)))
 185                             len (+ len 5)
 186                             i (+ i 5))
 187                     (setq i (1+ i))))))
 188             (string-match pattern fontname)
 189             (setq l (cdr (cdr (match-data))))
 190             (setq i 0)
 191             (while (< i 14)
 192               (if (or (null l) (< (car (aref xlfd-fields i)) (car l)))
 193                   (progn
 194                     (aset xlfd-fields i (cdr (aref xlfd-fields i)))
 195                     (setq i (1+ i)))
 196                 (if (< (car (aref xlfd-fields i)) (car (cdr l)))
 197                     (progn
 198                       (aset xlfd-fields i nil)
 199                       (setq i (1+ i)))
 200                   (setq l (cdr (cdr l))))))
 201             xlfd-fields)))))
 202
 203 ;; Replace consecutive wild-cards (`*') in NAME to one.
 204 ;; Ex. (x-reduce-font-name "-*-*-*-iso8859-1") => "-*-iso8859-1"
 205 (defsubst x-reduce-font-name (name)
 206   (while (string-match "-\\*-\\(\\*-\\)+" name)
 207     (setq name (replace-match "-*-" t t name)))
 208   name)
 209
 210 (defun x-compose-font-name (xlfd-fields &optional reduce)
 211   "Compose X's fontname from FIELDS.
 212 FIELDS is a vector of XLFD fields.
 213 If a field is nil, wild-card letter `*' is embedded.
 214 Optional argument REDUCE non-nil means consecutive wild-cards are
 215 reduced to be one."
 216   (let ((name
 217          (concat "-" (mapconcat (lambda (x) (or x "*")) xlfd-fields "-"))))
 218     (if reduce
 219         (x-reduce-font-name name)
 220       name)))
 221
 222 (defun x-complement-fontset-spec (xlfd-fields fontlist)
 223   "Complement FONTLIST for all charsets based on XLFD-FIELDS and return it.
 224 XLFD-FIELDS is a vector of XLFD (X Logical Font Description) fields.
 225 FONTLIST is an alist of cons of charset and fontname.
 226
 227 Fontnames for charsets not listed in FONTLIST are generated from
 228 XLFD-FIELDS and a property of x-charset-register of each charset
 229 automatically."
 230   (let ((charsets charset-list)
 231         (loose-xlfd-fields (copy-sequence xlfd-fields)))
 232     (aset loose-xlfd-fields xlfd-regexp-pixelsize-subnum nil)
 233     (aset loose-xlfd-fields xlfd-regexp-pointsize-subnum nil)
 234     (aset loose-xlfd-fields xlfd-regexp-resx-subnum nil)
 235     (aset loose-xlfd-fields xlfd-regexp-resy-subnum nil)
 236     (aset loose-xlfd-fields xlfd-regexp-spacing-subnum nil)
 237     (aset loose-xlfd-fields xlfd-regexp-avgwidth-subnum nil)
 238     (while charsets
 239       (let ((charset (car charsets)))
 240         (if (null (assq charset fontlist))
 241             (let ((registry (get-charset-property charset
 242                                                   'x-charset-registry))
 243                   registry-val encoding-val fontname loose-fontname)
 244               (if (string-match "-" registry)
 245                   ;; REGISTRY contains `CHARSET_ENCODING' field.
 246                   (setq registry-val (substring registry 0 (match-beginning 0))
 247                         encoding-val (substring registry (match-end 0)))
 248                 (setq registry-val (concat registry "*")
 249                       encoding-val "*"))
 250               (aset xlfd-fields xlfd-regexp-registry-subnum registry-val)
 251               (aset xlfd-fields xlfd-regexp-encoding-subnum encoding-val)
 252               (aset loose-xlfd-fields xlfd-regexp-registry-subnum registry-val)
 253               (aset loose-xlfd-fields xlfd-regexp-encoding-subnum encoding-val)
 254               (setq fontname (x-compose-font-name xlfd-fields t))
 255               (setq fontlist (cons (cons charset fontname) fontlist))
 256               (or (assoc fontname alternative-fontname-alist)
 257                   (setq alternative-fontname-alist
 258                         (cons (list
 259                                fontname
 260                                (x-compose-font-name loose-xlfd-fields t)
 261                                (concat "*-" registry-val "-" encoding-val))
 262                               alternative-fontname-alist)))
 263               )))
 264       (setq charsets (cdr charsets))))
 265   fontlist)
 266
 267 ;; Return a list to be appended to `x-fixed-font-alist' when
 268 ;; `mouse-set-font' is called.
 269 (defun generate-fontset-menu ()
 270   (let ((fontsets global-fontset-alist)
 271         fontset-name
 272         l)
 273     (while fontsets
 274       (setq fontset-name (car (car fontsets)) fontsets (cdr fontsets))
 275       (if (string-match "fontset-\\([^-]+\\)" fontset-name)
 276           ;; This fontset has a nickname.  Just show it.
 277           (let ((nickname (match-string 1 fontset-name)))
 278             (setq l (cons (list (concat ".." nickname) fontset-name) l)))
 279         (setq l (cons (list fontset-name fontset-name) l))))
 280     (cons "Fontset" l)))
 281
 282 (defun fontset-plain-name (fontset)
 283   "Return a plain and descriptive name of FONTSET."
 284   (let ((xlfd-fields (x-decompose-font-name fontset)))
 285     (if xlfd-fields
 286         (let ((weight (aref xlfd-fields xlfd-regexp-weight-subnum))
 287               (slant  (aref xlfd-fields xlfd-regexp-slant-subnum))
 288               (swidth (aref xlfd-fields xlfd-regexp-swidth-subnum))
 289               (size   (aref xlfd-fields xlfd-regexp-pixelsize-subnum))
 290               name)
 291           (if (> (string-to-int size) 0)
 292               (setq name (format "%s " size))
 293             (setq name ""))
 294           (if (string-match "bold\\|demibold" weight)
 295               (setq name (concat name weight " ")))
 296           (cond ((string= slant "i")
 297                  (setq name (concat name "italic ")))
 298                 ((string= slant "o")
 299                  (setq name (concat name "slant ")))
 300                 ((string= slant "ri")
 301                  (setq name (concat name "reverse italic ")))
 302                 ((string= slant "ro")
 303                  (setq name (concat name "reverse slant "))))
 304           (if (= (length name) 0)
 305               ;; No descriptive fields found.
 306               fontset
 307             name))
 308       fontset)))
 309
 310 (defun create-fontset-from-fontset-spec (fontset-spec)
 311   "Create a fontset from fontset specification string FONTSET-SPEC.
 312 FONTSET-SPEC is a string of the format:
 313         FONTSET-NAME,CHARSET-NAME0:FONT-NAME0,CHARSET-NAME1:FONT-NAME1, ...
 314 Any number of SPACE, TAB, and NEWLINE can be put before and after commas."
 315   (if (string-match "[^,]+" fontset-spec)
 316       (let* ((idx2 (match-end 0))
 317              (name (match-string 0 fontset-spec))
 318              fontlist charset xlfd-fields)
 319         (while (string-match "[, \t\n]*\\([^:]+\\):\\([^,]+\\)"
 320                              fontset-spec idx2)
 321           (setq idx2 (match-end 0))
 322           (setq charset (intern (match-string 1 fontset-spec)))
 323           (if (charsetp charset)
 324               (setq fontlist (cons (cons charset (match-string 2 fontset-spec))
 325                                    fontlist))))
 326         (if (setq xlfd-fields (x-decompose-font-name name))
 327             ;; If NAME conforms to XLFD, complement FONTLIST for
 328             ;; charsets not specified in FONTSET-SPEC.
 329             (setq fontlist
 330                   (x-complement-fontset-spec xlfd-fields fontlist)))
 331         (new-fontset name fontlist))))
 332
 333 \f
 334 ;; Create default fontset from 16 dots fonts which are the most widely
 335 ;; installed fonts.
 336 (defvar default-fontset-spec
 337   "-*-fixed-medium-r-normal-*-16-*-*-*-*-*-fontset-default,
 338         chinese-gb2312:-*-medium-r-normal-*-16-*-gb2312*-*,
 339         korean-ksc5601:-*-medium-r-normal-*-16-*-ksc5601*-*,
 340         chinese-cns11643-1:-*-medium-r-normal-*-16-*-cns11643*-1,
 341         chinese-cns11643-2:-*-medium-r-normal-*-16-*-cns11643*-2,
 342         chinese-cns11643-3:-*-medium-r-normal-*-16-*-cns11643*-3,
 343         chinese-cns11643-4:-*-medium-r-normal-*-16-*-cns11643*-4,
 344         chinese-cns11643-5:-*-medium-r-normal-*-16-*-cns11643*-5,
 345         chinese-cns11643-6:-*-medium-r-normal-*-16-*-cns11643*-6,
 346         chinese-cns11643-7:-*-medium-r-normal-*-16-*-cns11643*-7"
 347   "String of fontset spec of a default fontset.
 348 See the documentation of `create-fontset-from-fontset-spec' for the format.")
 349
 350 ;; Create fontsets from X resources of the name `fontset-N (class
 351 ;; Fontset-N)' where N is integer 0, 1, ...
 352 ;; The values of the resources the string of the same format as
 353 ;; `default-fontset-spec'.
 354
 355 (defun create-fontset-from-x-resource ()
 356   (let ((idx 0)
 357         fontset-spec)
 358     (while (setq fontset-spec (x-get-resource (concat "fontset-" idx)
 359                                               (concat "Fontset-" idx)))
 360       (create-fontset-from-fontset-spec fontset-spec)
 361       (setq idx (1+ idx)))))
 362
 363 (defsubst fontset-list ()
 364   "Returns a list of all defined fontset names."
 365   (mapcar 'car global-fontset-alist))
 366
 367 ;;
 368 (provide 'fontset)
 369
 370 ;;; fontset.el ends here