|
0
|
1 /* Generic glyph data structures + display tables
|
|
|
2 Copyright (C) 1994 Board of Trustees, University of Illinois.
|
|
|
3 Copyright (C) 1995, 1996 Ben Wing
|
|
|
4
|
|
|
5 This file is part of XEmacs.
|
|
|
6
|
|
|
7 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
8 under the terms of the GNU General Public License as published by the
|
|
|
9 Free Software Foundation; either version 2, or (at your option) any
|
|
|
10 later version.
|
|
|
11
|
|
|
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with XEmacs; 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
|
|
|
22 /* Synched up with: Not in FSF. */
|
|
|
23
|
|
|
24 #ifndef _XEMACS_GLYPHS_H_
|
|
|
25 #define _XEMACS_GLYPHS_H_
|
|
|
26
|
|
|
27 #include "specifier.h"
|
|
|
28
|
|
|
29 /*****************************************************************************
|
|
|
30 * Image Instantiators *
|
|
|
31 *****************************************************************************/
|
|
|
32
|
|
|
33 struct image_instantiator_methods;
|
|
|
34
|
|
|
35 /* Remember the distinction between image instantiator formats and
|
|
|
36 image instance types. Here's an approximate mapping:
|
|
|
37
|
|
|
38 image instantiator format image instance type
|
|
|
39 ------------------------- -------------------
|
|
|
40 nothing nothing
|
|
|
41 string text
|
|
|
42 formatted-string text
|
|
|
43 xbm mono-pixmap, color-pixmap, pointer
|
|
|
44 xpm color-pixmap, mono-pixmap, pointer
|
|
|
45 xface mono-pixmap, color-pixmap, pointer
|
|
|
46 gif color-pixmap
|
|
|
47 jpeg color-pixmap
|
|
|
48 png color-pixmap
|
|
|
49 tiff color-pixmap
|
|
|
50 cursor-font pointer
|
|
|
51 font pointer
|
|
|
52 subwindow subwindow
|
|
|
53 inherit mono-pixmap
|
|
122
|
54 autodetect mono-pixmap, color-pixmap, pointer,
|
|
120
|
55 text
|
|
0
|
56 */
|
|
|
57
|
|
|
58 /* These are methods specific to a particular format of image instantiator
|
|
|
59 (e.g. xpm, string, etc.). */
|
|
|
60
|
|
185
|
61 typedef struct ii_keyword_entry ii_keyword_entry;
|
|
|
62 struct ii_keyword_entry
|
|
|
63 {
|
|
|
64 Lisp_Object keyword;
|
|
|
65 void (*validate) (Lisp_Object data);
|
|
|
66 int multiple_p;
|
|
|
67 };
|
|
|
68
|
|
|
69 typedef struct
|
|
|
70 {
|
|
|
71 Dynarr_declare (ii_keyword_entry);
|
|
|
72 } ii_keyword_entry_dynarr;
|
|
|
73
|
|
0
|
74 struct image_instantiator_methods
|
|
|
75 {
|
|
|
76 Lisp_Object symbol;
|
|
|
77
|
|
185
|
78 ii_keyword_entry_dynarr *keywords;
|
|
0
|
79 /* Implementation specific methods: */
|
|
|
80
|
|
|
81 /* Validate method: Given an instantiator vector, signal an error if
|
|
|
82 it's invalid for this image-instantiator format. Note that this
|
|
|
83 validation only occurs after all the keyword-specific validation
|
|
|
84 has already been performed. This is chiefly useful for making
|
|
|
85 sure that certain required keywords are present. */
|
|
|
86 void (*validate_method) (Lisp_Object instantiator);
|
|
|
87
|
|
|
88 /* Normalize method: Given an instantiator, convert it to the form
|
|
|
89 that should be used in a glyph, for devices of type CONSOLE_TYPE.
|
|
|
90 Signal an error if conversion fails. */
|
|
|
91 Lisp_Object (*normalize_method) (Lisp_Object instantiator,
|
|
|
92 Lisp_Object console_type);
|
|
|
93
|
|
|
94 /* Possible-dest-types method: Return a mask indicating what dest types
|
|
|
95 are compatible with this format. */
|
|
|
96 int (*possible_dest_types_method) (void);
|
|
|
97
|
|
|
98 /* Instantiate method: Given an instantiator and a partially
|
|
|
99 filled-in image instance, complete the filling-in. Return
|
|
|
100 non-zero if the instantiation succeeds, 0 if it fails.
|
|
|
101 This must be present. */
|
|
|
102 void (*instantiate_method) (Lisp_Object image_instance,
|
|
|
103 Lisp_Object instantiator,
|
|
|
104 Lisp_Object pointer_fg,
|
|
|
105 Lisp_Object pointer_bg,
|
|
124
|
106 int dest_mask,
|
|
|
107 Lisp_Object domain);
|
|
0
|
108 };
|
|
|
109
|
|
|
110 /***** Calling an image-instantiator method *****/
|
|
|
111
|
|
|
112 #define HAS_IIFORMAT_METH_P(mstruc, m) ((mstruc)->m##_method)
|
|
|
113 #define IIFORMAT_METH(mstruc, m, args) (((mstruc)->m##_method) args)
|
|
|
114
|
|
|
115 /* Call a void-returning specifier method, if it exists */
|
|
|
116 #define MAYBE_IIFORMAT_METH(mstruc, m, args) \
|
|
|
117 do { \
|
|
|
118 struct image_instantiator_methods *_maybe_iiformat_meth_mstruc = (mstruc); \
|
|
|
119 if (HAS_IIFORMAT_METH_P (_maybe_iiformat_meth_mstruc, m)) \
|
|
|
120 IIFORMAT_METH (_maybe_iiformat_meth_mstruc, m, args); \
|
|
|
121 } while (0)
|
|
|
122
|
|
|
123 MAC_DECLARE_EXTERN (struct image_instantiator_methods *,
|
|
|
124 MTiiformat_meth_or_given)
|
|
|
125
|
|
|
126 /* Call a specifier method, if it exists; otherwise return
|
|
|
127 the specified value */
|
|
|
128
|
|
|
129 #define IIFORMAT_METH_OR_GIVEN(mstruc, m, args, given) \
|
|
|
130 MAC_BEGIN \
|
|
|
131 MAC_DECLARE (struct image_instantiator_methods *, \
|
|
|
132 MTiiformat_meth_or_given, mstruc) \
|
|
|
133 HAS_IIFORMAT_METH_P (MTiiformat_meth_or_given, m) ? \
|
|
|
134 IIFORMAT_METH (MTiiformat_meth_or_given, m, args) : (given) \
|
|
|
135 MAC_END
|
|
|
136
|
|
|
137 /***** Defining new image-instantiator types *****/
|
|
|
138
|
|
185
|
139 #define DECLARE_IMAGE_INSTANTIATOR_FORMAT(format) \
|
|
0
|
140 extern struct image_instantiator_methods *format##_image_instantiator_methods
|
|
|
141
|
|
185
|
142 #define DEFINE_IMAGE_INSTANTIATOR_FORMAT(format) \
|
|
0
|
143 struct image_instantiator_methods *format##_image_instantiator_methods
|
|
|
144
|
|
|
145 #define INITIALIZE_IMAGE_INSTANTIATOR_FORMAT(format, obj_name) \
|
|
185
|
146 do { \
|
|
|
147 format##_image_instantiator_methods = \
|
|
|
148 xnew_and_zero (struct image_instantiator_methods); \
|
|
|
149 defsymbol (&Q##format, obj_name); \
|
|
|
150 format##_image_instantiator_methods->symbol = Q##format; \
|
|
|
151 format##_image_instantiator_methods->keywords = \
|
|
|
152 Dynarr_new (ii_keyword_entry); \
|
|
|
153 add_entry_to_image_instantiator_format_list \
|
|
|
154 (Q##format, format##_image_instantiator_methods); \
|
|
|
155 } while (0)
|
|
0
|
156
|
|
|
157 /* Declare that image-instantiator format FORMAT has method M; used in
|
|
|
158 initialization routines */
|
|
|
159 #define IIFORMAT_HAS_METHOD(format, m) \
|
|
|
160 (format##_image_instantiator_methods->m##_method = format##_##m)
|
|
|
161
|
|
|
162 /* Declare that KEYW is a valid keyword for image-instantiator format
|
|
|
163 FORMAT. VALIDATE_FUN if a function that returns whether the data
|
|
|
164 is valid. The keyword may not appear more than once. */
|
|
|
165 #define IIFORMAT_VALID_KEYWORD(format, keyw, validate_fun) \
|
|
|
166 do { \
|
|
|
167 struct ii_keyword_entry entry; \
|
|
|
168 \
|
|
|
169 entry.keyword = keyw; \
|
|
|
170 entry.validate = validate_fun; \
|
|
|
171 entry.multiple_p = 0; \
|
|
|
172 Dynarr_add (format##_image_instantiator_methods->keywords, \
|
|
|
173 entry); \
|
|
|
174 } while (0)
|
|
|
175
|
|
|
176 /* Same as IIFORMAT_VALID_KEYWORD except that the keyword may
|
|
|
177 appear multiple times. */
|
|
|
178 #define IIFORMAT_VALID_MULTI_KEYWORD(format, keyword, validate_fun) \
|
|
|
179 do { \
|
|
|
180 struct ii_keyword_entry entry; \
|
|
|
181 \
|
|
|
182 entry.keyword = keyword; \
|
|
|
183 entry.validate = validate_fun; \
|
|
|
184 entry.multiple_p = 1; \
|
|
|
185 Dynarr_add (format##_image_instantiator_methods->keywords, \
|
|
|
186 entry); \
|
|
|
187 } while (0)
|
|
|
188
|
|
|
189 extern Lisp_Object Q_data, Q_file;
|
|
|
190
|
|
|
191 void add_entry_to_image_instantiator_format_list (Lisp_Object symbol,
|
|
|
192 struct image_instantiator_methods *meths);
|
|
|
193 Lisp_Object find_keyword_in_vector (Lisp_Object vector,
|
|
|
194 Lisp_Object keyword);
|
|
|
195 Lisp_Object find_keyword_in_vector_or_given (Lisp_Object vector,
|
|
|
196 Lisp_Object keyword,
|
|
173
|
197 Lisp_Object default_);
|
|
0
|
198 void check_valid_string (Lisp_Object data);
|
|
|
199 void check_valid_int (Lisp_Object data);
|
|
|
200 DECLARE_DOESNT_RETURN (incompatible_image_types (Lisp_Object instantiator,
|
|
|
201 int given_dest_mask,
|
|
|
202 int desired_dest_mask));
|
|
|
203
|
|
|
204 /*****************************************************************************
|
|
|
205 * Image Specifier Object *
|
|
|
206 *****************************************************************************/
|
|
|
207
|
|
|
208 DECLARE_SPECIFIER_TYPE (image);
|
|
|
209 extern Lisp_Object Qimage;
|
|
|
210 #define XIMAGE_SPECIFIER(x) XSPECIFIER_TYPE (x, image)
|
|
|
211 #define XSETIMAGE_SPECIFIER(x, p) XSETSPECIFIER_TYPE (x, p, image)
|
|
|
212 #define IMAGE_SPECIFIERP(x) SPECIFIER_TYPEP (x, image)
|
|
|
213 #define CHECK_IMAGE_SPECIFIER(x) CHECK_SPECIFIER_TYPE (x, image)
|
|
|
214 #define CONCHECK_IMAGE_SPECIFIER(x) CONCHECK_SPECIFIER_TYPE (x, image)
|
|
|
215
|
|
|
216 void set_image_attached_to (Lisp_Object obj, Lisp_Object face_or_glyph,
|
|
|
217 Lisp_Object property);
|
|
|
218
|
|
|
219 struct image_specifier
|
|
|
220 {
|
|
|
221 int allowed;
|
|
|
222 Lisp_Object attachee; /* face or glyph this is attached to, or nil */
|
|
|
223 Lisp_Object attachee_property;/* property of that face or glyph */
|
|
|
224 };
|
|
|
225
|
|
|
226 #define IMAGE_SPECIFIER_DATA(g) (SPECIFIER_TYPE_DATA (g, image))
|
|
|
227 #define IMAGE_SPECIFIER_ALLOWED(g) (IMAGE_SPECIFIER_DATA (g)->allowed)
|
|
|
228 #define IMAGE_SPECIFIER_ATTACHEE(g) (IMAGE_SPECIFIER_DATA (g)->attachee)
|
|
|
229 #define IMAGE_SPECIFIER_ATTACHEE_PROPERTY(g) \
|
|
|
230 (IMAGE_SPECIFIER_DATA (g)->attachee_property)
|
|
|
231
|
|
|
232 #define XIMAGE_SPECIFIER_ALLOWED(g) \
|
|
|
233 IMAGE_SPECIFIER_ALLOWED (XIMAGE_SPECIFIER (g))
|
|
|
234
|
|
|
235 /*****************************************************************************
|
|
|
236 * Image Instance Object *
|
|
|
237 *****************************************************************************/
|
|
|
238
|
|
|
239 DECLARE_LRECORD (image_instance, struct Lisp_Image_Instance);
|
|
|
240 #define XIMAGE_INSTANCE(x) \
|
|
|
241 XRECORD (x, image_instance, struct Lisp_Image_Instance)
|
|
|
242 #define XSETIMAGE_INSTANCE(x, p) XSETRECORD (x, p, image_instance)
|
|
|
243 #define IMAGE_INSTANCEP(x) RECORDP (x, image_instance)
|
|
|
244 #define GC_IMAGE_INSTANCEP(x) GC_RECORDP (x, image_instance)
|
|
|
245 #define CHECK_IMAGE_INSTANCE(x) CHECK_RECORD (x, image_instance)
|
|
|
246 #define CONCHECK_IMAGE_INSTANCE(x) CONCHECK_RECORD (x, image_instance)
|
|
|
247
|
|
|
248 enum image_instance_type
|
|
|
249 {
|
|
|
250 IMAGE_UNKNOWN,
|
|
|
251 IMAGE_NOTHING,
|
|
|
252 IMAGE_TEXT,
|
|
|
253 IMAGE_MONO_PIXMAP,
|
|
|
254 IMAGE_COLOR_PIXMAP,
|
|
|
255 IMAGE_POINTER,
|
|
|
256 IMAGE_SUBWINDOW
|
|
|
257 };
|
|
|
258
|
|
|
259 #define IMAGE_NOTHING_MASK (1 << 0)
|
|
|
260 #define IMAGE_TEXT_MASK (1 << 1)
|
|
|
261 #define IMAGE_MONO_PIXMAP_MASK (1 << 2)
|
|
|
262 #define IMAGE_COLOR_PIXMAP_MASK (1 << 3)
|
|
|
263 #define IMAGE_POINTER_MASK (1 << 4)
|
|
|
264 #define IMAGE_SUBWINDOW_MASK (1 << 5)
|
|
|
265
|
|
|
266 extern Lisp_Object Qnothing_image_instance_p, Qtext_image_instance_p;
|
|
|
267 extern Lisp_Object Qmono_pixmap_image_instance_p;
|
|
|
268 extern Lisp_Object Qcolor_pixmap_image_instance_p;
|
|
|
269 extern Lisp_Object Qpointer_image_instance_p;
|
|
|
270 extern Lisp_Object Qsubwindow_image_instance_p;
|
|
|
271
|
|
|
272 #define IMAGE_INSTANCE_TYPE_P(ii, type) \
|
|
187
|
273 (IMAGE_INSTANCEP (ii) && XIMAGE_INSTANCE_TYPE (ii) == type)
|
|
0
|
274
|
|
187
|
275 #define NOTHING_IMAGE_INSTANCEP(ii) \
|
|
|
276 IMAGE_INSTANCE_TYPE_P (ii, IMAGE_NOTHING)
|
|
|
277 #define TEXT_IMAGE_INSTANCEP(ii) \
|
|
|
278 IMAGE_INSTANCE_TYPE_P (ii, IMAGE_TEXT)
|
|
|
279 #define MONO_PIXMAP_IMAGE_INSTANCEP(ii) \
|
|
|
280 IMAGE_INSTANCE_TYPE_P (ii, IMAGE_MONO_PIXMAP)
|
|
|
281 #define COLOR_PIXMAP_IMAGE_INSTANCEP(ii) \
|
|
|
282 IMAGE_INSTANCE_TYPE_P (ii, IMAGE_COLOR_PIXMAP)
|
|
|
283 #define POINTER_IMAGE_INSTANCEP(ii) \
|
|
|
284 IMAGE_INSTANCE_TYPE_P (ii, IMAGE_POINTER)
|
|
|
285 #define SUBWINDOW_IMAGE_INSTANCEP(ii) \
|
|
|
286 IMAGE_INSTANCE_TYPE_P (ii, IMAGE_SUBWINDOW)
|
|
0
|
287
|
|
187
|
288 #define CHECK_NOTHING_IMAGE_INSTANCE(x) do { \
|
|
|
289 CHECK_IMAGE_INSTANCE (x); \
|
|
|
290 if (!NOTHING_IMAGE_INSTANCEP (x)) \
|
|
|
291 x = wrong_type_argument (Qnothing_image_instance_p, (x)); \
|
|
|
292 } while (0)
|
|
0
|
293
|
|
187
|
294 #define CHECK_TEXT_IMAGE_INSTANCE(x) do { \
|
|
|
295 CHECK_IMAGE_INSTANCE (x); \
|
|
|
296 if (!TEXT_IMAGE_INSTANCEP (x)) \
|
|
|
297 x = wrong_type_argument (Qtext_image_instance_p, (x)); \
|
|
|
298 } while (0)
|
|
0
|
299
|
|
187
|
300 #define CHECK_MONO_PIXMAP_IMAGE_INSTANCE(x) do { \
|
|
|
301 CHECK_IMAGE_INSTANCE (x); \
|
|
|
302 if (!MONO_PIXMAP_IMAGE_INSTANCEP (x)) \
|
|
|
303 x = wrong_type_argument (Qmono_pixmap_image_instance_p, (x)); \
|
|
|
304 } while (0)
|
|
0
|
305
|
|
187
|
306 #define CHECK_COLOR_PIXMAP_IMAGE_INSTANCE(x) do { \
|
|
|
307 CHECK_IMAGE_INSTANCE (x); \
|
|
|
308 if (!COLOR_PIXMAP_IMAGE_INSTANCEP (x)) \
|
|
|
309 x = wrong_type_argument (Qcolor_pixmap_image_instance_p, (x)); \
|
|
|
310 } while (0)
|
|
0
|
311
|
|
187
|
312 #define CHECK_POINTER_IMAGE_INSTANCE(x) do { \
|
|
|
313 CHECK_IMAGE_INSTANCE (x); \
|
|
|
314 if (!POINTER_IMAGE_INSTANCEP (x)) \
|
|
|
315 x = wrong_type_argument (Qpointer_image_instance_p, (x)); \
|
|
|
316 } while (0)
|
|
|
317
|
|
|
318 #define CHECK_SUBWINDOW_IMAGE_INSTANCE(x) do { \
|
|
|
319 CHECK_IMAGE_INSTANCE (x); \
|
|
|
320 if (!SUBWINDOW_IMAGE_INSTANCEP (x)) \
|
|
|
321 x = wrong_type_argument (Qsubwindow_image_instance_p, (x)); \
|
|
|
322 } while (0)
|
|
0
|
323
|
|
|
324 struct Lisp_Image_Instance
|
|
|
325 {
|
|
|
326 struct lcrecord_header header;
|
|
|
327 Lisp_Object device;
|
|
|
328 Lisp_Object name;
|
|
|
329 enum image_instance_type type;
|
|
|
330 union
|
|
187
|
331 {
|
|
|
332 struct
|
|
0
|
333 {
|
|
187
|
334 Lisp_Object string;
|
|
|
335 } text;
|
|
|
336 struct
|
|
|
337 {
|
|
|
338 int width, height, depth;
|
|
|
339 Lisp_Object hotspot_x, hotspot_y; /* integer or Qnil */
|
|
|
340 Lisp_Object filename; /* string or Qnil */
|
|
|
341 Lisp_Object mask_filename; /* string or Qnil */
|
|
|
342 Lisp_Object fg, bg; /* foreground and background colors,
|
|
|
343 if this is a colorized mono-pixmap
|
|
|
344 or a pointer */
|
|
|
345 } pixmap; /* used for pointers as well */
|
|
|
346 struct
|
|
|
347 {
|
|
|
348 int dummy; /* #### fill in this structure */
|
|
|
349 } subwindow;
|
|
|
350 } u;
|
|
0
|
351
|
|
|
352 /* console-type- and image-type-specific data */
|
|
|
353 void *data;
|
|
|
354 };
|
|
|
355
|
|
|
356 #define IMAGE_INSTANCE_DEVICE(i) ((i)->device)
|
|
|
357 #define IMAGE_INSTANCE_NAME(i) ((i)->name)
|
|
|
358 #define IMAGE_INSTANCE_TYPE(i) ((i)->type)
|
|
|
359 #define IMAGE_INSTANCE_PIXMAP_TYPE_P(i) \
|
|
|
360 ((IMAGE_INSTANCE_TYPE (i) == IMAGE_MONO_PIXMAP) \
|
|
|
361 || (IMAGE_INSTANCE_TYPE (i) == IMAGE_COLOR_PIXMAP))
|
|
|
362
|
|
|
363 #define IMAGE_INSTANCE_TEXT_STRING(i) ((i)->u.text.string)
|
|
|
364
|
|
|
365 #define IMAGE_INSTANCE_PIXMAP_WIDTH(i) ((i)->u.pixmap.width)
|
|
|
366 #define IMAGE_INSTANCE_PIXMAP_HEIGHT(i) ((i)->u.pixmap.height)
|
|
|
367 #define IMAGE_INSTANCE_PIXMAP_DEPTH(i) ((i)->u.pixmap.depth)
|
|
|
368 #define IMAGE_INSTANCE_PIXMAP_FILENAME(i) ((i)->u.pixmap.filename)
|
|
|
369 #define IMAGE_INSTANCE_PIXMAP_MASK_FILENAME(i) ((i)->u.pixmap.mask_filename)
|
|
|
370 #define IMAGE_INSTANCE_PIXMAP_HOTSPOT_X(i) ((i)->u.pixmap.hotspot_x)
|
|
|
371 #define IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y(i) ((i)->u.pixmap.hotspot_y)
|
|
|
372 #define IMAGE_INSTANCE_PIXMAP_FG(i) ((i)->u.pixmap.fg)
|
|
|
373 #define IMAGE_INSTANCE_PIXMAP_BG(i) ((i)->u.pixmap.bg)
|
|
|
374
|
|
|
375 #define XIMAGE_INSTANCE_DEVICE(i) \
|
|
|
376 IMAGE_INSTANCE_DEVICE (XIMAGE_INSTANCE (i))
|
|
|
377 #define XIMAGE_INSTANCE_NAME(i) \
|
|
|
378 IMAGE_INSTANCE_NAME (XIMAGE_INSTANCE (i))
|
|
|
379 #define XIMAGE_INSTANCE_TYPE(i) \
|
|
|
380 IMAGE_INSTANCE_TYPE (XIMAGE_INSTANCE (i))
|
|
|
381
|
|
|
382 #define XIMAGE_INSTANCE_TEXT_STRING(i) \
|
|
|
383 IMAGE_INSTANCE_TEXT_STRING (XIMAGE_INSTANCE (i))
|
|
|
384
|
|
|
385 #define XIMAGE_INSTANCE_PIXMAP_WIDTH(i) \
|
|
|
386 IMAGE_INSTANCE_PIXMAP_WIDTH (XIMAGE_INSTANCE (i))
|
|
|
387 #define XIMAGE_INSTANCE_PIXMAP_HEIGHT(i) \
|
|
|
388 IMAGE_INSTANCE_PIXMAP_HEIGHT (XIMAGE_INSTANCE (i))
|
|
|
389 #define XIMAGE_INSTANCE_PIXMAP_DEPTH(i) \
|
|
|
390 IMAGE_INSTANCE_PIXMAP_DEPTH (XIMAGE_INSTANCE (i))
|
|
|
391 #define XIMAGE_INSTANCE_PIXMAP_FILENAME(i) \
|
|
|
392 IMAGE_INSTANCE_PIXMAP_FILENAME (XIMAGE_INSTANCE (i))
|
|
|
393 #define XIMAGE_INSTANCE_PIXMAP_MASK_FILENAME(i) \
|
|
|
394 IMAGE_INSTANCE_PIXMAP_MASK_FILENAME (XIMAGE_INSTANCE (i))
|
|
|
395 #define XIMAGE_INSTANCE_PIXMAP_HOTSPOT_X(i) \
|
|
|
396 IMAGE_INSTANCE_PIXMAP_HOTSPOT_X (XIMAGE_INSTANCE (i))
|
|
|
397 #define XIMAGE_INSTANCE_PIXMAP_HOTSPOT_Y(i) \
|
|
|
398 IMAGE_INSTANCE_PIXMAP_HOTSPOT_Y (XIMAGE_INSTANCE (i))
|
|
|
399 #define XIMAGE_INSTANCE_PIXMAP_FG(i) \
|
|
|
400 IMAGE_INSTANCE_PIXMAP_FG (XIMAGE_INSTANCE (i))
|
|
|
401 #define XIMAGE_INSTANCE_PIXMAP_BG(i) \
|
|
|
402 IMAGE_INSTANCE_PIXMAP_BG (XIMAGE_INSTANCE (i))
|
|
|
403
|
|
|
404 /*****************************************************************************
|
|
|
405 * Glyph Object *
|
|
|
406 *****************************************************************************/
|
|
|
407
|
|
|
408 enum glyph_type
|
|
|
409 {
|
|
|
410 GLYPH_UNKNOWN,
|
|
|
411 GLYPH_BUFFER,
|
|
|
412 GLYPH_POINTER,
|
|
|
413 GLYPH_ICON
|
|
|
414 };
|
|
|
415
|
|
|
416 struct Lisp_Glyph
|
|
|
417 {
|
|
|
418 struct lcrecord_header header;
|
|
|
419
|
|
|
420 enum glyph_type type;
|
|
|
421
|
|
|
422 /* specifiers: */
|
|
|
423 Lisp_Object image; /* the actual image */
|
|
|
424 Lisp_Object contrib_p; /* whether to figure into line height */
|
|
|
425 Lisp_Object baseline; /* percent above baseline */
|
|
|
426
|
|
|
427 Lisp_Object face; /* if non-nil, face to use when displaying */
|
|
|
428
|
|
|
429 Lisp_Object plist;
|
|
|
430 void (*after_change) (Lisp_Object glyph, Lisp_Object property,
|
|
|
431 Lisp_Object locale);
|
|
|
432 };
|
|
|
433
|
|
|
434 DECLARE_LRECORD (glyph, struct Lisp_Glyph);
|
|
|
435 #define XGLYPH(x) XRECORD (x, glyph, struct Lisp_Glyph)
|
|
|
436 #define XSETGLYPH(x, p) XSETRECORD (x, p, glyph)
|
|
|
437 #define GLYPHP(x) RECORDP (x, glyph)
|
|
|
438 #define GC_GLYPHP(x) GC_RECORDP (x, glyph)
|
|
|
439 #define CHECK_GLYPH(x) CHECK_RECORD (x, glyph)
|
|
|
440 #define CONCHECK_GLYPH(x) CONCHECK_RECORD (x, glyph)
|
|
|
441
|
|
|
442 extern Lisp_Object Qbuffer_glyph_p, Qpointer_glyph_p, Qicon_glyph_p;
|
|
|
443
|
|
187
|
444 #define CHECK_BUFFER_GLYPH(x) do { \
|
|
|
445 CHECK_GLYPH (x); \
|
|
|
446 if (XGLYPH (x)->type != GLYPH_BUFFER) \
|
|
|
447 x = wrong_type_argument (Qbuffer_glyph_p, (x)); \
|
|
|
448 } while (0)
|
|
0
|
449
|
|
187
|
450 #define CHECK_POINTER_GLYPH(x) do { \
|
|
|
451 CHECK_GLYPH (x); \
|
|
|
452 if (XGLYPH (x)->type != GLYPH_POINTER) \
|
|
|
453 x = wrong_type_argument (Qpointer_glyph_p, (x)); \
|
|
|
454 } while (0)
|
|
0
|
455
|
|
187
|
456 #define CHECK_ICON_GLYPH(x) do { \
|
|
|
457 CHECK_GLYPH (x); \
|
|
|
458 if (XGLYPH (x)->type != GLYPH_ICON) \
|
|
|
459 x = wrong_type_argument (Qicon_glyph_p, (x)); \
|
|
|
460 } while (0)
|
|
0
|
461
|
|
|
462 #define GLYPH_TYPE(g) ((g)->type)
|
|
|
463 #define GLYPH_IMAGE(g) ((g)->image)
|
|
|
464 #define GLYPH_CONTRIB_P(g) ((g)->contrib_p)
|
|
|
465 #define GLYPH_BASELINE(g) ((g)->baseline)
|
|
|
466 #define GLYPH_FACE(g) ((g)->face)
|
|
|
467
|
|
|
468 #define XGLYPH_TYPE(g) GLYPH_TYPE (XGLYPH (g))
|
|
|
469 #define XGLYPH_IMAGE(g) GLYPH_IMAGE (XGLYPH (g))
|
|
|
470 #define XGLYPH_CONTRIB_P(g) GLYPH_CONTRIB_P (XGLYPH (g))
|
|
|
471 #define XGLYPH_BASELINE(g) GLYPH_BASELINE (XGLYPH (g))
|
|
|
472 #define XGLYPH_FACE(g) GLYPH_FACE (XGLYPH (g))
|
|
|
473
|
|
|
474 extern Lisp_Object Vtruncation_glyph, Vcontinuation_glyph, Voctal_escape_glyph;
|
|
|
475 extern Lisp_Object Vcontrol_arrow_glyph, Vinvisible_text_glyph, Vhscroll_glyph;
|
|
|
476 extern Lisp_Object Vxemacs_logo;
|
|
|
477
|
|
|
478 unsigned short glyph_width (Lisp_Object glyph, Lisp_Object frame_face,
|
|
|
479 face_index window_findex,
|
|
|
480 Lisp_Object window);
|
|
|
481 unsigned short glyph_ascent (Lisp_Object glyph, Lisp_Object frame_face,
|
|
|
482 face_index window_findex,
|
|
|
483 Lisp_Object window);
|
|
|
484 unsigned short glyph_descent (Lisp_Object glyph,
|
|
|
485 Lisp_Object frame_face,
|
|
|
486 face_index window_findex,
|
|
|
487 Lisp_Object window);
|
|
|
488 unsigned short glyph_height (Lisp_Object glyph, Lisp_Object frame_face,
|
|
|
489 face_index window_findex,
|
|
|
490 Lisp_Object window);
|
|
|
491 Lisp_Object glyph_baseline (Lisp_Object glyph, Lisp_Object domain);
|
|
|
492 Lisp_Object glyph_face (Lisp_Object glyph, Lisp_Object domain);
|
|
|
493 int glyph_contrib_p (Lisp_Object glyph, Lisp_Object domain);
|
|
|
494 Lisp_Object glyph_image_instance (Lisp_Object glyph,
|
|
|
495 Lisp_Object domain,
|
|
|
496 Error_behavior errb, int no_quit);
|
|
|
497 void file_or_data_must_be_present (Lisp_Object instantiator);
|
|
|
498 void data_must_be_present (Lisp_Object instantiator);
|
|
|
499 Lisp_Object make_string_from_file (Lisp_Object file);
|
|
|
500 Lisp_Object tagged_vector_to_alist (Lisp_Object vector);
|
|
|
501 Lisp_Object alist_to_tagged_vector (Lisp_Object tag, Lisp_Object alist);
|
|
|
502 void string_instantiate (Lisp_Object image_instance, Lisp_Object instantiator,
|
|
|
503 Lisp_Object pointer_fg, Lisp_Object pointer_bg,
|
|
124
|
504 int dest_mask, Lisp_Object domain);
|
|
0
|
505 Lisp_Object allocate_glyph (enum glyph_type type,
|
|
|
506 void (*after_change) (Lisp_Object glyph,
|
|
|
507 Lisp_Object property,
|
|
|
508 Lisp_Object locale));
|
|
|
509
|
|
|
510 /*****************************************************************************
|
|
|
511 * Glyph Cachels *
|
|
|
512 *****************************************************************************/
|
|
|
513
|
|
185
|
514 typedef struct glyph_cachel glyph_cachel;
|
|
0
|
515 struct glyph_cachel
|
|
|
516 {
|
|
|
517 Lisp_Object glyph;
|
|
|
518
|
|
|
519 unsigned int updated :1;
|
|
|
520 unsigned short width;
|
|
|
521 unsigned short ascent;
|
|
|
522 unsigned short descent;
|
|
|
523 };
|
|
|
524
|
|
|
525 #define CONT_GLYPH_INDEX (glyph_index) 0
|
|
|
526 #define TRUN_GLYPH_INDEX (glyph_index) 1
|
|
|
527 #define HSCROLL_GLYPH_INDEX (glyph_index) 2
|
|
|
528 #define CONTROL_GLYPH_INDEX (glyph_index) 3
|
|
|
529 #define OCT_ESC_GLYPH_INDEX (glyph_index) 4
|
|
|
530 #define INVIS_GLYPH_INDEX (glyph_index) 5
|
|
|
531
|
|
|
532 #define GLYPH_CACHEL(window, index) \
|
|
|
533 Dynarr_atp (window->glyph_cachels, index)
|
|
|
534 #define GLYPH_CACHEL_GLYPH(window, index) \
|
|
|
535 Dynarr_atp (window->glyph_cachels, index)->glyph
|
|
|
536 #define GLYPH_CACHEL_WIDTH(window, index) \
|
|
|
537 Dynarr_atp (window->glyph_cachels, index)->width
|
|
|
538 #define GLYPH_CACHEL_ASCENT(window, index) \
|
|
|
539 Dynarr_atp (window->glyph_cachels, index)->ascent
|
|
|
540 #define GLYPH_CACHEL_DESCENT(window, index) \
|
|
|
541 Dynarr_atp (window->glyph_cachels, index)->descent
|
|
|
542
|
|
|
543 void mark_glyph_cachels (glyph_cachel_dynarr *elements,
|
|
|
544 void (*markobj) (Lisp_Object));
|
|
|
545 void mark_glyph_cachels_as_not_updated (struct window *w);
|
|
|
546 void reset_glyph_cachels (struct window *w);
|
|
|
547 #ifdef MEMORY_USAGE_STATS
|
|
|
548 int compute_glyph_cachel_usage (glyph_cachel_dynarr *glyph_cachels,
|
|
|
549 struct overhead_stats *ovstats);
|
|
|
550 #endif /* MEMORY_USAGE_STATS */
|
|
|
551
|
|
|
552 /*****************************************************************************
|
|
|
553 * Display Tables *
|
|
|
554 *****************************************************************************/
|
|
|
555
|
|
|
556 #define DISP_TABLE_SIZE 256
|
|
94
|
557 #define DISP_CHAR_ENTRY(dp, c) ((c < (dp)->size) ? (dp)->contents[c] : Qnil)
|
|
0
|
558
|
|
|
559 struct Lisp_Vector *get_display_table (struct window *, face_index);
|
|
|
560
|
|
|
561 #endif /* _XEMACS_GLYPHS_H_ */
|
