1: /* Header for composite sequence handler. 2: Copyright (C) 2001, 2002, 2003, 2004, 2005, 3: 2006, 2007 Free Software Foundation, Inc. 4: Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 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 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 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 iff 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 iff 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) */