| 1 | /* Header for composite sequence handler. |
| 2 | Copyright (C) 2001, 2002, 2003, 2004, 2005, |
| 3 | 2006, 2007, 2008 Free Software Foundation, Inc. |
| 4 | Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 |
| 5 | National Institute of Advanced Industrial Science and Technology (AIST) |
| 6 | Registration Number H14PRO021 |
| 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 3, 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 |
| 22 | the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| 23 | Boston, MA 02110-1301, USA. */ |
| 24 | |
| 25 | #ifndef EMACS_COMPOSITE_H |
| 26 | #define EMACS_COMPOSITE_H |
| 27 | |
| 28 | /* Methods to display a sequence of components a composition. */ |
| 29 | enum composition_method { |
| 30 | /* The first two are actually not methods, but used in code |
| 31 | conversion to specify the current composing status. */ |
| 32 | COMPOSITION_DISABLED, /* Never handle composition data */ |
| 33 | COMPOSITION_NO, /* Not processing composition data */ |
| 34 | /* Compose relatively without alternate characters. */ |
| 35 | COMPOSITION_RELATIVE, |
| 36 | /* Compose by specified composition rule. This is not used in Emacs |
| 37 | 21 but we need it to decode files saved in the older versions of |
| 38 | Emacs. */ |
| 39 | COMPOSITION_WITH_RULE, |
| 40 | /* Compose relatively with alternate characters. */ |
| 41 | COMPOSITION_WITH_ALTCHARS, |
| 42 | /* Compose by specified composition rule with alternate characters. */ |
| 43 | COMPOSITION_WITH_RULE_ALTCHARS |
| 44 | }; |
| 45 | |
| 46 | /* Maximum number of compoments a single composition can have. */ |
| 47 | #define MAX_COMPOSITION_COMPONENTS 16 |
| 48 | |
| 49 | /* These macros access information about a composition that |
| 50 | has `composition' property PROP. PROP is: |
| 51 | ((LENGTH . COMPONENTS) . MODIFICATION-FUNC) |
| 52 | or |
| 53 | (COMPOSITION-ID . (LENGTH COMPONENTS . MODIFICATION-FUNC)) |
| 54 | They don't check validity of PROP. */ |
| 55 | |
| 56 | /* Temporary variable used only in the following macros. */ |
| 57 | extern Lisp_Object composition_temp; |
| 58 | |
| 59 | /* Return 1 if the composition is already registered. */ |
| 60 | #define COMPOSITION_REGISTERD_P(prop) INTEGERP (XCAR (prop)) |
| 61 | |
| 62 | /* Return ID number of the already registered composition. */ |
| 63 | #define COMPOSITION_ID(prop) XINT (XCAR (prop)) |
| 64 | |
| 65 | /* Return length of the composition. */ |
| 66 | #define COMPOSITION_LENGTH(prop) \ |
| 67 | (COMPOSITION_REGISTERD_P (prop) \ |
| 68 | ? XINT (XCAR (XCDR (prop))) \ |
| 69 | : XINT (XCAR (XCAR (prop)))) |
| 70 | |
| 71 | /* Return components of the composition. */ |
| 72 | #define COMPOSITION_COMPONENTS(prop) \ |
| 73 | (COMPOSITION_REGISTERD_P (prop) \ |
| 74 | ? XCAR (XCDR (XCDR (prop))) \ |
| 75 | : XCDR (XCAR (prop))) |
| 76 | |
| 77 | /* Return modification function of the composition. */ |
| 78 | #define COMPOSITION_MODIFICATION_FUNC(prop) \ |
| 79 | (COMPOSITION_REGISTERD_P (prop) \ |
| 80 | ? XCDR (XCDR (XCDR (prop))) \ |
| 81 | : CONSP (prop) ? XCDR (prop) : Qnil) |
| 82 | |
| 83 | /* Return the method of composition. */ |
| 84 | #define COMPOSITION_METHOD(prop) \ |
| 85 | (COMPOSITION_REGISTERD_P (prop) \ |
| 86 | ? composition_table[COMPOSITION_ID (prop)]->method \ |
| 87 | : (composition_temp = XCDR (XCAR (prop)), \ |
| 88 | (NILP (composition_temp) \ |
| 89 | ? COMPOSITION_RELATIVE \ |
| 90 | : ((INTEGERP (composition_temp) || STRINGP (composition_temp)) \ |
| 91 | ? COMPOSITION_WITH_ALTCHARS \ |
| 92 | : COMPOSITION_WITH_RULE_ALTCHARS)))) |
| 93 | |
| 94 | /* Return 1 if the composition is valid. It is valid if length of |
| 95 | the composition equals to (END - START). */ |
| 96 | #define COMPOSITION_VALID_P(start, end, prop) \ |
| 97 | (CONSP (prop) \ |
| 98 | && (COMPOSITION_REGISTERD_P (prop) \ |
| 99 | ? (COMPOSITION_ID (prop) >= 0 \ |
| 100 | && COMPOSITION_ID (prop) <= n_compositions \ |
| 101 | && CONSP (XCDR (prop))) \ |
| 102 | : (composition_temp = XCAR (prop), \ |
| 103 | (CONSP (composition_temp) \ |
| 104 | && (composition_temp = XCDR (composition_temp), \ |
| 105 | (NILP (composition_temp) \ |
| 106 | || STRINGP (composition_temp) \ |
| 107 | || VECTORP (composition_temp) \ |
| 108 | || INTEGERP (composition_temp) \ |
| 109 | || CONSP (composition_temp)))))) \ |
| 110 | && (end - start) == COMPOSITION_LENGTH (prop)) |
| 111 | |
| 112 | /* Return the Nth glyph of composition specified by CMP. CMP is a |
| 113 | pointer to `struct composition'. */ |
| 114 | #define COMPOSITION_GLYPH(cmp, n) \ |
| 115 | XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \ |
| 116 | ->key_and_value) \ |
| 117 | ->contents[cmp->hash_index * 2]) \ |
| 118 | ->contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS \ |
| 119 | ? (n) * 2 : (n)]) |
| 120 | |
| 121 | /* Return the encoded composition rule to compose the Nth glyph of |
| 122 | rule-base composition specified by CMP. CMP is a pointer to |
| 123 | `struct composition'. */ |
| 124 | #define COMPOSITION_RULE(cmp, n) \ |
| 125 | XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \ |
| 126 | ->key_and_value) \ |
| 127 | ->contents[cmp->hash_index * 2]) \ |
| 128 | ->contents[(n) * 2 - 1]) |
| 129 | |
| 130 | /* Decode encoded composition rule RULE_CODE into GREF (global |
| 131 | reference point code) and NREF (new reference point code). Don't |
| 132 | check RULE_CODE, always set GREF and NREF to valid values. */ |
| 133 | #define COMPOSITION_DECODE_RULE(rule_code, gref, nref) \ |
| 134 | do { \ |
| 135 | gref = (rule_code) / 12; \ |
| 136 | if (gref > 12) gref = 11; \ |
| 137 | nref = (rule_code) % 12; \ |
| 138 | } while (0) |
| 139 | |
| 140 | /* Return encoded composition rule for the pair of global reference |
| 141 | point GREF and new reference point NREF. If arguments are invalid, |
| 142 | return -1. */ |
| 143 | #define COMPOSITION_ENCODE_RULE(gref, nref) \ |
| 144 | ((unsigned) (gref) < 12 && (unsigned) (nref) < 12 \ |
| 145 | ? (gref) * 12 + (nref) : -1) |
| 146 | |
| 147 | /* Data structure that records information about a composition |
| 148 | currently used in some buffers or strings. |
| 149 | |
| 150 | When a composition is assigned an ID number (by |
| 151 | get_composition_id), this structure is allocated for the |
| 152 | composition and linked in composition_table[ID]. |
| 153 | |
| 154 | Identical compositions appearing at different places have the same |
| 155 | ID, and thus share the same instance of this structure. */ |
| 156 | |
| 157 | struct composition { |
| 158 | /* Number of glyphs of the composition components. */ |
| 159 | unsigned glyph_len; |
| 160 | |
| 161 | /* Width, ascent, and descent pixels of the composition. */ |
| 162 | short pixel_width, ascent, descent; |
| 163 | |
| 164 | /* How many columns the overall glyphs occupy on the screen. This |
| 165 | gives an approximate value for column calculation in |
| 166 | Fcurrent_column, and etc. */ |
| 167 | unsigned short width; |
| 168 | |
| 169 | /* Method of the composition. */ |
| 170 | enum composition_method method; |
| 171 | |
| 172 | /* Index to the composition hash table. */ |
| 173 | int hash_index; |
| 174 | |
| 175 | /* For which font we have calculated the remaining members. The |
| 176 | actual type is device dependent. */ |
| 177 | void *font; |
| 178 | |
| 179 | /* Pointer to an array of x-offset and y-offset (by pixels) of |
| 180 | glyphs. This points to a sufficient memory space (sizeof (int) * |
| 181 | glyph_len * 2) that is allocated when the composition is |
| 182 | registered in composition_table. X-offset and Y-offset of Nth |
| 183 | glyph are (2N)th and (2N+1)th elements respectively. */ |
| 184 | short *offsets; |
| 185 | }; |
| 186 | |
| 187 | /* Table of pointers to the structure `composition' indexed by |
| 188 | COMPOSITION-ID. */ |
| 189 | extern struct composition **composition_table; |
| 190 | /* Number of the currently registered compositions. */ |
| 191 | extern int n_compositions; |
| 192 | |
| 193 | /* Mask bits for CHECK_MASK arg to update_compositions. |
| 194 | For a change in the region FROM and TO, check compositions ... */ |
| 195 | #define CHECK_HEAD 1 /* adjacent to FROM */ |
| 196 | #define CHECK_TAIL 2 /* adjacent to TO */ |
| 197 | #define CHECK_INSIDE 4 /* between FROM and TO */ |
| 198 | #define CHECK_BORDER (CHECK_HEAD | CHECK_TAIL) |
| 199 | #define CHECK_ALL (CHECK_BORDER | CHECK_INSIDE) |
| 200 | |
| 201 | extern Lisp_Object Qcomposition; |
| 202 | extern Lisp_Object composition_hash_table; |
| 203 | |
| 204 | extern int get_composition_id P_ ((int, int, int, Lisp_Object, Lisp_Object)); |
| 205 | extern int find_composition P_ ((int, int, int *, int *, Lisp_Object *, |
| 206 | Lisp_Object)); |
| 207 | extern void update_compositions P_ ((int, int, int)); |
| 208 | extern void make_composition_value_copy P_ ((Lisp_Object)); |
| 209 | extern void compose_region P_ ((int, int, Lisp_Object, Lisp_Object, |
| 210 | Lisp_Object)); |
| 211 | extern void syms_of_composite P_ ((void)); |
| 212 | extern void compose_text P_ ((int, int, Lisp_Object, Lisp_Object, |
| 213 | Lisp_Object)); |
| 214 | |
| 215 | #endif /* not EMACS_COMPOSITE_H */ |
| 216 | |
| 217 | /* arch-tag: 59524d89-c645-47bd-b5e6-65e861690118 |
| 218 | (do not change this comment) */ |