[bpt/emacs.git] / src / composite.h

/* Header for composite sequence handler.
   Copyright (C) 1999 Electrotechnical Laboratory, JAPAN.
   Licensed to the Free Software Foundation.

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

#ifndef EMACS_COMPOSITE_H
#define EMACS_COMPOSITE_H

/* Methods to display a sequence of components a composition.  */
enum composition_method {
  /* The first two are actually not methods, but used in code
     conversion to specify the current composing status.  */
  COMPOSITION_DISABLED,		/* Never handle composition data */
  COMPOSITION_NO,		/* Not processing composition data */
  /* Compose relatively without alternate characters.  */
  COMPOSITION_RELATIVE,
  /* Compose by specified composition rule.  This is not used in Emacs
     21 but we need it to decode files saved in the older versions of
     Emacs.  */
  COMPOSITION_WITH_RULE,
  /* Compose relatively with alternate characters.  */
  COMPOSITION_WITH_ALTCHARS,
  /* Compose by specified composition rule with alternate characters.  */
  COMPOSITION_WITH_RULE_ALTCHARS
};

/* Maximum number of compoments a single composition can have.  */
#define MAX_COMPOSITION_COMPONENTS 16

/* These macros access information about a composition that
   has `composition' property PROP.  PROP is:
	((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
   or
	(COMPOSITION-ID . (LENGTH COMPONENTS . MODIFICATION-FUNC))
   They don't check validity of PROP.  */

/* Temporary variable used only in the following macros.  */
extern Lisp_Object composition_temp;

/* Return 1 iff the composition is already registered.  */
#define COMPOSITION_REGISTERD_P(prop) INTEGERP (XCAR (prop))

/* Return ID number of the already registered composition.  */
#define COMPOSITION_ID(prop) XINT (XCAR (prop))

/* Return length of the composition.  */
#define COMPOSITION_LENGTH(prop)	\
  (COMPOSITION_REGISTERD_P (prop)	\
   ? XINT (XCAR (XCDR (prop)))		\
   : XINT (XCAR (XCAR (prop))))

/* Return components of the composition.  */
#define COMPOSITION_COMPONENTS(prop)	\
  (COMPOSITION_REGISTERD_P (prop)	\
   ? XCAR (XCDR (XCDR (prop)))		\
   : XCDR (XCAR (prop)))

/* Return modification function of the composition.  */
#define COMPOSITION_MODIFICATION_FUNC(prop)	\
  (COMPOSITION_REGISTERD_P (prop)		\
   ? XCDR (XCDR (XCDR (prop)))			\
   : XCDR (prop))

/* Return the method of composition.  */
#define COMPOSITION_METHOD(prop)					\
  (COMPOSITION_REGISTERD_P (prop)					\
   ? composition_table[COMPOSITION_ID (prop)]->method			\
   : (composition_temp = XCDR (XCAR (prop)),				\
      (NILP (composition_temp)						\
       ? COMPOSITION_RELATIVE						\
       : ((INTEGERP (composition_temp) || STRINGP (composition_temp))	\
	  ? COMPOSITION_WITH_ALTCHARS					\
	  : COMPOSITION_WITH_RULE_ALTCHARS))))

/* Return 1 iff the composition is valid.  It is valid if length of
   the composition equals to (END - START).  */
#define COMPOSITION_VALID_P(start, end, prop)				      \
  (CONSP (prop)								      \
   && (COMPOSITION_REGISTERD_P (prop)					      \
       ? (COMPOSITION_ID (prop) >= 0					      \
	  && COMPOSITION_ID (prop) <= n_compositions			      \
	  && CONSP (XCDR (prop)))					      \
       : (composition_temp = XCAR (prop),				      \
	  (CONSP (composition_temp)					      \
	   && (composition_temp = XCDR (composition_temp),		      \
	       (NILP (composition_temp) || STRINGP (composition_temp)	      \
		|| VECTORP (composition_temp) || CONSP (composition_temp))))))\
   && (end - start) == COMPOSITION_LENGTH (prop))

/* Return the Nth glyph of composition specified by CMP.  CMP is a
   pointer to `struct composition'. */
#define COMPOSITION_GLYPH(cmp, n)					\
  XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)		\
			  ->key_and_value)				\
		 ->contents[cmp->hash_index * 2])			\
	->contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS	\
		  ? (n) * 2 : (n)])

/* Return the encoded composition rule to compose the Nth glyph of
   rule-base composition specified by CMP.  CMP is a pointer to
   `struct composition'. */
#define COMPOSITION_RULE(cmp, n)				\
  XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)	\
			  ->key_and_value)			\
		 ->contents[cmp->hash_index * 2])		\
	->contents[(n) * 2 - 1])

/* Decode encoded composition rule RULE_CODE into GREF (global
   reference point code) and NREF (new reference point code).  Don't
   check RULE_CODE, always set GREF and NREF to valid values.  */
#define COMPOSITION_DECODE_RULE(rule_code, gref, nref)	\
  do {							\
    gref = (rule_code) / 12;				\
    if (gref > 12) gref = 11;				\
    nref = (rule_code) % 12;				\
  } while (0)

/* Return encoded composition rule for the pair of global reference
   point GREF and new reference point NREF.  If arguments are invalid,
   return -1. */
#define COMPOSITION_ENCODE_RULE(gref, nref)		\
  ((unsigned) (gref) < 12 && (unsigned) (nref) < 12	\
   ? (gref) * 12 + (nref) : -1)

/* Data structure that records information about a composition
   currently used in some buffers or strings.

   When a composition is assigned an ID number (by
   get_composition_id), this structure is allocated for the
   composition and linked in composition_table[ID].  

   Identical compositions appearing at different places have the same
   ID, and thus share the same instance of this structure.  */

struct composition {
  /* How many columns the overall glyphs occupy on the screen.  This
     gives an approximate value for column calculation in
     Fcurrent_column, and etc.  */
  unsigned char width;

  /* Number of glyphs of the composition components.  */
  unsigned char glyph_len;

  /* Width, ascent, and descent pixels of the composition.  */
  short pixel_width, ascent, descent;

  /* Method of the composition.  */
  enum composition_method method;

  /* Index to the composition hash table.  */
  int hash_index;

  /* For which font we have calculated the remaining members.  The
     actual type is device dependent.  */
  void *font;

  /* Pointer to an array of x-offset and y-offset (by pixels) of
     glyphs.  This points to a sufficient memory space (sizeof (int) *
     glyph_len * 2) that is allocated when the composition is
     registered in composition_table.  X-offset and Y-offset of Nth
     glyph are (2N)th and (2N+1)th elements respectively.  */
  short *offsets;
};

/* Table of pointers to the structure `composition' indexed by
   COMPOSITION-ID.  */
extern struct composition **composition_table;
/* Number of the currently registered compositions.  */
extern int n_compositions;

/* Mask bits for CHECK_MASK arg to update_compositions.
   For a change in the region FROM and TO, check compositions ... */
#define CHECK_HEAD	1	/* adjacent to FROM */
#define CHECK_TAIL	2	/* adjacent to TO */
#define CHECK_INSIDE	4	/* between FROM and TO */
#define CHECK_BORDER	(CHECK_HEAD | CHECK_TAIL)
#define CHECK_ALL	(CHECK_BORDER | CHECK_INSIDE)

extern Lisp_Object Qcomposition;
extern Lisp_Object composition_hash_table;

extern int get_composition_id P_ ((int, int, int, Lisp_Object, Lisp_Object));
extern int find_composition P_ ((int, int, int *, int *, Lisp_Object *,
				 Lisp_Object));
extern void update_compositions P_ ((int, int, int));
extern void make_composition_value_copy P_ ((Lisp_Object));
extern void compose_region P_ ((int, int, Lisp_Object, Lisp_Object,
				Lisp_Object));
extern void syms_of_composition P_ ((void));
extern void compose_text P_ ((int, int, Lisp_Object, Lisp_Object,
			      Lisp_Object));
extern void compose_chars_in_text P_ ((int, int, Lisp_Object));

#endif /* not EMACS_COMPOSITE_H */
Commit	Line	Data
ca4c9455 KH	1	/* Header for composite sequence handler.
	2	Copyright (C) 1999 Electrotechnical Laboratory, JAPAN.
	3	Licensed to the Free Software Foundation.
	4
	5	This file is part of GNU Emacs.
	6
	7	GNU Emacs is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
	11
	12	GNU Emacs is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GNU Emacs; see the file COPYING. If not, write to
	19	the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
	21
15a10ef1 KH	22	#ifndef EMACS_COMPOSITE_H
15a10ef1 KH	23	#define EMACS_COMPOSITE_H
ca4c9455 KH	24
	25	/* Methods to display a sequence of components a composition. */
	26	enum composition_method {
	27	/* The first two are actually not methods, but used in code
	28	conversion to specify the current composing status. */
	29	COMPOSITION_DISABLED, /* Never handle composition data */
	30	COMPOSITION_NO, /* Not processing composition data */
	31	/* Compose relatively without alternate characters. */
	32	COMPOSITION_RELATIVE,
	33	/* Compose by specified composition rule. This is not used in Emacs
	34	21 but we need it to decode files saved in the older versions of
	35	Emacs. */
	36	COMPOSITION_WITH_RULE,
	37	/* Compose relatively with alternate characters. */
	38	COMPOSITION_WITH_ALTCHARS,
	39	/* Compose by specified composition rule with alternate characters. */
	40	COMPOSITION_WITH_RULE_ALTCHARS
	41	};
	42
	43	/* Maximum number of compoments a single composition can have. */
	44	#define MAX_COMPOSITION_COMPONENTS 16
	45
	46	/* These macros access information about a composition that
	47	has `composition' property PROP. PROP is:
	48	((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
	49	or
	50	(COMPOSITION-ID . (LENGTH COMPONENTS . MODIFICATION-FUNC))
	51	They don't check validity of PROP. */
	52
	53	/* Temporary variable used only in the following macros. */
	54	extern Lisp_Object composition_temp;
	55
	56	/* Return 1 iff the composition is already registered. */
	57	#define COMPOSITION_REGISTERD_P(prop) INTEGERP (XCAR (prop))
	58
	59	/* Return ID number of the already registered composition. */
	60	#define COMPOSITION_ID(prop) XINT (XCAR (prop))
	61
	62	/* Return length of the composition. */
	63	#define COMPOSITION_LENGTH(prop) \
	64	(COMPOSITION_REGISTERD_P (prop) \
	65	? XINT (XCAR (XCDR (prop))) \
	66	: XINT (XCAR (XCAR (prop))))
	67
	68	/* Return components of the composition. */
	69	#define COMPOSITION_COMPONENTS(prop) \
	70	(COMPOSITION_REGISTERD_P (prop) \
	71	? XCAR (XCDR (XCDR (prop))) \
	72	: XCDR (XCAR (prop)))
	73
	74	/* Return modification function of the composition. */
	75	#define COMPOSITION_MODIFICATION_FUNC(prop) \
	76	(COMPOSITION_REGISTERD_P (prop) \
	77	? XCDR (XCDR (XCDR (prop))) \
	78	: XCDR (prop))
	79
	80	/* Return the method of composition. */
	81	#define COMPOSITION_METHOD(prop) \
	82	(COMPOSITION_REGISTERD_P (prop) \
	83	? composition_table[COMPOSITION_ID (prop)]->method \
	84	: (composition_temp = XCDR (XCAR (prop)), \
	85	(NILP (composition_temp) \
	86	? COMPOSITION_RELATIVE \
	87	: ((INTEGERP (composition_temp) \|\| STRINGP (composition_temp)) \
88	? COMPOSITION_WITH_ALTCHARS \
89	: COMPOSITION_WITH_RULE_ALTCHARS))))
90
91	/* Return 1 iff the composition is valid. It is valid if length of
92	the composition equals to (END - START). */
93	#define COMPOSITION_VALID_P(start, end, prop) \
94	(CONSP (prop) \
95	&& (COMPOSITION_REGISTERD_P (prop) \
96	? (COMPOSITION_ID (prop) >= 0 \
97	&& COMPOSITION_ID (prop) <= n_compositions \
98	&& CONSP (XCDR (prop))) \
99	: (composition_temp = XCAR (prop), \
100	(CONSP (composition_temp) \
101	&& (composition_temp = XCDR (composition_temp), \
102	(NILP (composition_temp) \|\| STRINGP (composition_temp) \
103	\|\| VECTORP (composition_temp) \|\| CONSP (composition_temp))))))\
104	&& (end - start) == COMPOSITION_LENGTH (prop))
105
106	/* Return the Nth glyph of composition specified by CMP. CMP is a
107	pointer to `struct composition'. */
108	#define COMPOSITION_GLYPH(cmp, n) \
109	XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \
110	->key_and_value) \
111	->contents[cmp->hash_index * 2]) \
112	->contents[cmp->method == COMPOSITION_WITH_RULE_ALTCHARS \
113	? (n) * 2 : (n)])
114
115	/* Return the encoded composition rule to compose the Nth glyph of
116	rule-base composition specified by CMP. CMP is a pointer to
117	`struct composition'. */
118	#define COMPOSITION_RULE(cmp, n) \
119	XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table) \
120	->key_and_value) \
121	->contents[cmp->hash_index * 2]) \
122	->contents[(n) * 2 - 1])
123
124	/* Decode encoded composition rule RULE_CODE into GREF (global
125	reference point code) and NREF (new reference point code). Don't
126	check RULE_CODE, always set GREF and NREF to valid values. */
127	#define COMPOSITION_DECODE_RULE(rule_code, gref, nref) \
128	do { \
129	gref = (rule_code) / 12; \
130	if (gref > 12) gref = 11; \
131	nref = (rule_code) % 12; \
132	} while (0)
133
134	/* Return encoded composition rule for the pair of global reference
135	point GREF and new reference point NREF. If arguments are invalid,
136	return -1. */
137	#define COMPOSITION_ENCODE_RULE(gref, nref) \
138	((unsigned) (gref) < 12 && (unsigned) (nref) < 12 \
139	? (gref) * 12 + (nref) : -1)
140
141	/* Data structure that records information about a composition
142	currently used in some buffers or strings.
143
144	When a composition is assigned an ID number (by
145	get_composition_id), this structure is allocated for the
146	composition and linked in composition_table[ID].
147
148	Identical compositions appearing at different places have the same
149	ID, and thus share the same instance of this structure. */
150
151	struct composition {
152	/* How many columns the overall glyphs occupy on the screen. This
153	gives an approximate value for column calculation in
154	Fcurrent_column, and etc. */
155	unsigned char width;
156
157	/* Number of glyphs of the composition components. */
158	unsigned char glyph_len;
159
51e31f7a KH	160	/* Width, ascent, and descent pixels of the composition. */
	161	short pixel_width, ascent, descent;
	162
ca4c9455 KH	163	/* Method of the composition. */
	164	enum composition_method method;
	165
	166	/* Index to the composition hash table. */
	167	int hash_index;
	168
	169	/* For which font we have calculated the remaining members. The
	170	actual type is device dependent. */
	171	void *font;
	172
	173	/* Pointer to an array of x-offset and y-offset (by pixels) of
	174	glyphs. This points to a sufficient memory space (sizeof (int) *
	175	glyph_len * 2) that is allocated when the composition is
	176	registered in composition_table. X-offset and Y-offset of Nth
	177	glyph are (2N)th and (2N+1)th elements respectively. */
	178	short *offsets;
ca4c9455 KH	179	};
	180
	181	/* Table of pointers to the structure `composition' indexed by
	182	COMPOSITION-ID. */
	183	extern struct composition **composition_table;
	184	/* Number of the currently registered compositions. */
	185	extern int n_compositions;
	186
	187	/* Mask bits for CHECK_MASK arg to update_compositions.
	188	For a change in the region FROM and TO, check compositions ... */
	189	#define CHECK_HEAD 1 /* adjacent to FROM */
	190	#define CHECK_TAIL 2 /* adjacent to TO */
	191	#define CHECK_INSIDE 4 /* between FROM and TO */
	192	#define CHECK_BORDER (CHECK_HEAD \| CHECK_TAIL)
	193	#define CHECK_ALL (CHECK_BORDER \| CHECK_INSIDE)
	194
	195	extern Lisp_Object Qcomposition;
	196	extern Lisp_Object composition_hash_table;
	197
	198	extern int get_composition_id P_ ((int, int, int, Lisp_Object, Lisp_Object));
	199	extern int find_composition P_ ((int, int, int , int , Lisp_Object *,
	200	Lisp_Object));
	201	extern void update_compositions P_ ((int, int, int));
4a8c194f	202	extern void make_composition_value_copy P_ ((Lisp_Object));
ca4c9455 KH	203	extern void compose_region P_ ((int, int, Lisp_Object, Lisp_Object,
ca4c9455 KH	204	Lisp_Object));
f9beddb2 DL	205	extern void syms_of_composition P_ ((void));
	206	extern void compose_text P_ ((int, int, Lisp_Object, Lisp_Object,
	207	Lisp_Object));
c9a7baee	208	extern void compose_chars_in_text P_ ((int, int, Lisp_Object));
ca4c9455	209
15a10ef1	210	#endif /* not EMACS_COMPOSITE_H */