|
608
|
1 /* Routines shared between window-system backends for glyph objects.
|
|
563
|
2 Copyright (C) 1993, 1994 Free Software Foundation, Inc.
|
|
4226
|
3 Copyright (C) 1995 Board of Trustees, University of Illinois
|
|
563
|
4 Copyright (C) 1995 Tinker Systems
|
|
771
|
5 Copyright (C) 1995, 1996, 2001 Ben Wing
|
|
563
|
6 Copyright (C) 1995 Sun Microsystems
|
|
4226
|
7 Copyright (C) 1998, 1999, 2000 Andy Piper
|
|
563
|
8
|
|
|
9 This file is part of XEmacs.
|
|
|
10
|
|
|
11 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
12 under the terms of the GNU General Public License as published by the
|
|
|
13 Free Software Foundation; either version 2, or (at your option) any
|
|
|
14 later version.
|
|
|
15
|
|
|
16 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
19 for more details.
|
|
|
20
|
|
|
21 You should have received a copy of the GNU General Public License
|
|
|
22 along with XEmacs; see the file COPYING. If not, write to
|
|
|
23 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
24 Boston, MA 02111-1307, USA. */
|
|
|
25
|
|
|
26 /* Synched up with: Not in FSF. */
|
|
|
27
|
|
|
28 /* taken from glyphs-*.c
|
|
|
29 HINT HINT HINT Bill Perry: Please put code here and avoid massive
|
|
|
30 duplication in *-gtk.c!!! */
|
|
|
31
|
|
|
32 #include <config.h>
|
|
|
33 #include "lisp.h"
|
|
|
34
|
|
800
|
35 #include "buffer.h"
|
|
563
|
36 #include "elhash.h"
|
|
800
|
37 #include "faces.h"
|
|
563
|
38 #include "frame.h"
|
|
800
|
39 #include "glyphs.h"
|
|
|
40 #include "imgproc.h"
|
|
563
|
41 #include "insdel.h"
|
|
800
|
42 #include "lstream.h"
|
|
563
|
43 #include "opaque.h"
|
|
|
44 #include "sysdep.h"
|
|
800
|
45 #include "window.h"
|
|
|
46
|
|
563
|
47 #include "sysfile.h"
|
|
|
48
|
|
|
49 Lisp_Object Q_resource_type, Q_resource_id;
|
|
|
50
|
|
|
51 void
|
|
|
52 shared_resource_validate (Lisp_Object instantiator)
|
|
|
53 {
|
|
|
54 if ((NILP (find_keyword_in_vector (instantiator, Q_file))
|
|
|
55 &&
|
|
|
56 NILP (find_keyword_in_vector (instantiator, Q_resource_id)))
|
|
|
57 ||
|
|
|
58 NILP (find_keyword_in_vector (instantiator, Q_resource_type)))
|
|
|
59 sferror ("Must supply :file, :resource-id and :resource-type",
|
|
|
60 instantiator);
|
|
|
61 }
|
|
|
62
|
|
|
63
|
|
|
64 Lisp_Object
|
|
|
65 shared_resource_normalize (Lisp_Object inst, Lisp_Object console_type,
|
|
2286
|
66 Lisp_Object UNUSED (dest_mask), Lisp_Object tag)
|
|
563
|
67 {
|
|
|
68 /* This function can call lisp */
|
|
|
69 Lisp_Object file = Qnil;
|
|
|
70 struct gcpro gcpro1, gcpro2;
|
|
|
71 Lisp_Object alist = Qnil;
|
|
|
72
|
|
|
73 GCPRO2 (file, alist);
|
|
|
74
|
|
|
75 file = potential_pixmap_file_instantiator (inst, Q_file, Q_data,
|
|
|
76 console_type);
|
|
|
77
|
|
4226
|
78 if (NILP (file)) /* normalization impossible for the console type */
|
|
|
79 RETURN_UNGCPRO (Qnil);
|
|
|
80
|
|
563
|
81 if (CONSP (file)) /* failure locating filename */
|
|
|
82 signal_double_image_error ("Opening pixmap file",
|
|
|
83 "no such file or directory",
|
|
|
84 Fcar (file));
|
|
|
85
|
|
4226
|
86 if (EQ (file, Qt)) /* no conversion necessary */
|
|
563
|
87 RETURN_UNGCPRO (inst);
|
|
|
88
|
|
|
89 alist = tagged_vector_to_alist (inst);
|
|
|
90
|
|
|
91 {
|
|
|
92 alist = remassq_no_quit (Q_file, alist);
|
|
|
93 alist = Fcons (Fcons (Q_file, file), alist);
|
|
|
94 }
|
|
|
95
|
|
|
96 {
|
|
|
97 Lisp_Object result = alist_to_tagged_vector (tag, alist);
|
|
|
98 free_alist (alist);
|
|
|
99 RETURN_UNGCPRO (result);
|
|
|
100 }
|
|
|
101 }
|
|
|
102
|
|
608
|
103 /* Originally from xmu.c, but is now shared across X11, GTK, and MSW. */
|
|
|
104 /*
|
|
|
105 * Based on an optimized version provided by Jim Becker, August 5, 1988.
|
|
|
106 */
|
|
|
107
|
|
|
108
|
|
|
109 #ifndef BitmapSuccess
|
|
|
110 #define BitmapSuccess 0
|
|
|
111 #define BitmapOpenFailed 1
|
|
|
112 #define BitmapFileInvalid 2
|
|
|
113 #define BitmapNoMemory 3
|
|
|
114 #endif
|
|
|
115
|
|
|
116 #define MAX_SIZE 255
|
|
|
117
|
|
|
118 /* shared data for the image read/parse logic */
|
|
|
119 static short hexTable[256]; /* conversion value */
|
|
|
120 static int hex_initialized; /* easier to fill in at run time */
|
|
|
121
|
|
|
122
|
|
|
123 /*
|
|
|
124 * Table index for the hex values. Initialized once, first time.
|
|
|
125 * Used for translation value or delimiter significance lookup.
|
|
|
126 */
|
|
|
127 static void initHexTable (void)
|
|
|
128 {
|
|
|
129 /*
|
|
|
130 * We build the table at run time for several reasons:
|
|
|
131 *
|
|
|
132 * 1. portable to non-ASCII machines.
|
|
|
133 * 2. still reentrant since we set the init flag after setting table.
|
|
|
134 * 3. easier to extend.
|
|
|
135 * 4. less prone to bugs.
|
|
|
136 */
|
|
|
137 hexTable['0'] = 0; hexTable['1'] = 1;
|
|
|
138 hexTable['2'] = 2; hexTable['3'] = 3;
|
|
|
139 hexTable['4'] = 4; hexTable['5'] = 5;
|
|
|
140 hexTable['6'] = 6; hexTable['7'] = 7;
|
|
|
141 hexTable['8'] = 8; hexTable['9'] = 9;
|
|
|
142 hexTable['A'] = 10; hexTable['B'] = 11;
|
|
|
143 hexTable['C'] = 12; hexTable['D'] = 13;
|
|
|
144 hexTable['E'] = 14; hexTable['F'] = 15;
|
|
|
145 hexTable['a'] = 10; hexTable['b'] = 11;
|
|
|
146 hexTable['c'] = 12; hexTable['d'] = 13;
|
|
|
147 hexTable['e'] = 14; hexTable['f'] = 15;
|
|
|
148
|
|
|
149 /* delimiters of significance are flagged w/ negative value */
|
|
|
150 hexTable[' '] = -1; hexTable[','] = -1;
|
|
|
151 hexTable['}'] = -1; hexTable['\n'] = -1;
|
|
|
152 hexTable['\t'] = -1;
|
|
|
153
|
|
|
154 hex_initialized = 1;
|
|
|
155 }
|
|
|
156
|
|
|
157 /*
|
|
|
158 * read next hex value in the input stream, return -1 if EOF
|
|
|
159 */
|
|
|
160 static int NextInt (FILE *fstream)
|
|
|
161 {
|
|
|
162 int ch;
|
|
|
163 int value = 0;
|
|
|
164 int gotone = 0;
|
|
|
165 int done = 0;
|
|
|
166
|
|
|
167 /* loop, accumulate hex value until find delimiter */
|
|
|
168 /* skip any initial delimiters found in read stream */
|
|
|
169
|
|
|
170 while (!done) {
|
|
|
171 ch = getc(fstream);
|
|
|
172 if (ch == EOF) {
|
|
|
173 value = -1;
|
|
|
174 done++;
|
|
|
175 } else {
|
|
|
176 /* trim high bits, check type and accumulate */
|
|
|
177 ch &= 0xff;
|
|
|
178 if (isascii(ch) && isxdigit(ch)) {
|
|
|
179 value = (value << 4) + hexTable[ch];
|
|
|
180 gotone++;
|
|
|
181 } else if ((hexTable[ch]) < 0 && gotone)
|
|
|
182 done++;
|
|
|
183 }
|
|
|
184 }
|
|
|
185 return value;
|
|
|
186 }
|
|
|
187
|
|
|
188
|
|
|
189 /*
|
|
|
190 * The data returned by the following routine is always in left-most byte
|
|
|
191 * first and left-most bit first. If it doesn't return BitmapSuccess then
|
|
|
192 * its arguments won't have been touched. This routine should look as much
|
|
|
193 * like the Xlib routine XReadBitmapfile as possible.
|
|
|
194 */
|
|
611
|
195 static int
|
|
2367
|
196 read_bitmap_data (FILE *fstream, int *width, int *height, Binbyte **datap,
|
|
611
|
197 int *x_hot, int *y_hot)
|
|
608
|
198 {
|
|
2367
|
199 Binbyte *data = NULL; /* working variable */
|
|
|
200 Ascbyte line[MAX_SIZE]; /* input line from file */
|
|
608
|
201 int size; /* number of bytes of data */
|
|
2367
|
202 Ascbyte name_and_type[MAX_SIZE]; /* an input line */
|
|
|
203 Ascbyte *type; /* for parsing */
|
|
608
|
204 int value; /* from an input line */
|
|
|
205 int version10p; /* boolean, old format */
|
|
|
206 int padding; /* to handle alignment */
|
|
|
207 int bytes_per_line; /* per scanline of data */
|
|
647
|
208 int ww = 0; /* width */
|
|
|
209 int hh = 0; /* height */
|
|
608
|
210 int hx = -1; /* x hotspot */
|
|
|
211 int hy = -1; /* y hotspot */
|
|
|
212
|
|
|
213 #ifndef Xmalloc
|
|
|
214 #define Xmalloc(size) malloc(size)
|
|
|
215 #endif
|
|
|
216
|
|
|
217 /* first time initialization */
|
|
|
218 if (!hex_initialized) initHexTable();
|
|
|
219
|
|
|
220 /* error cleanup and return macro */
|
|
|
221 #define RETURN(code) { if (data) free (data); return code; }
|
|
|
222
|
|
|
223 while (fgets(line, MAX_SIZE, fstream)) {
|
|
|
224 if (strlen(line) == MAX_SIZE-1) {
|
|
|
225 RETURN (BitmapFileInvalid);
|
|
|
226 }
|
|
|
227 if (sscanf(line,"#define %s %d",name_and_type,&value) == 2) {
|
|
|
228 if (!(type = strrchr(name_and_type, '_')))
|
|
|
229 type = name_and_type;
|
|
|
230 else
|
|
|
231 type++;
|
|
|
232
|
|
|
233 if (!strcmp("width", type))
|
|
647
|
234 ww = value;
|
|
608
|
235 if (!strcmp("height", type))
|
|
647
|
236 hh = value;
|
|
608
|
237 if (!strcmp("hot", type)) {
|
|
|
238 if (type-- == name_and_type || type-- == name_and_type)
|
|
|
239 continue;
|
|
|
240 if (!strcmp("x_hot", type))
|
|
|
241 hx = value;
|
|
|
242 if (!strcmp("y_hot", type))
|
|
|
243 hy = value;
|
|
|
244 }
|
|
|
245 continue;
|
|
|
246 }
|
|
|
247
|
|
|
248 if (sscanf(line, "static short %s = {", name_and_type) == 1)
|
|
|
249 version10p = 1;
|
|
|
250 else if (sscanf(line,"static unsigned char %s = {",name_and_type) == 1)
|
|
|
251 version10p = 0;
|
|
|
252 else if (sscanf(line, "static char %s = {", name_and_type) == 1)
|
|
|
253 version10p = 0;
|
|
|
254 else
|
|
|
255 continue;
|
|
|
256
|
|
|
257 if (!(type = strrchr(name_and_type, '_')))
|
|
|
258 type = name_and_type;
|
|
|
259 else
|
|
|
260 type++;
|
|
|
261
|
|
|
262 if (strcmp("bits[]", type))
|
|
|
263 continue;
|
|
|
264
|
|
|
265 if (!ww || !hh)
|
|
|
266 RETURN (BitmapFileInvalid);
|
|
|
267
|
|
|
268 if ((ww % 16) && ((ww % 16) < 9) && version10p)
|
|
|
269 padding = 1;
|
|
|
270 else
|
|
|
271 padding = 0;
|
|
|
272
|
|
|
273 bytes_per_line = (ww+7)/8 + padding;
|
|
|
274
|
|
|
275 size = bytes_per_line * hh;
|
|
2367
|
276 data = (Binbyte *) Xmalloc ((unsigned int) size);
|
|
608
|
277 if (!data)
|
|
|
278 RETURN (BitmapNoMemory);
|
|
|
279
|
|
|
280 if (version10p) {
|
|
2367
|
281 Binbyte *ptr;
|
|
608
|
282 int bytes;
|
|
|
283
|
|
|
284 for (bytes=0, ptr=data; bytes<size; (bytes += 2)) {
|
|
|
285 if ((value = NextInt(fstream)) < 0)
|
|
|
286 RETURN (BitmapFileInvalid);
|
|
|
287 *(ptr++) = value;
|
|
|
288 if (!padding || ((bytes+2) % bytes_per_line))
|
|
|
289 *(ptr++) = value >> 8;
|
|
|
290 }
|
|
|
291 } else {
|
|
2367
|
292 Binbyte *ptr;
|
|
608
|
293 int bytes;
|
|
|
294
|
|
|
295 for (bytes=0, ptr=data; bytes<size; bytes++, ptr++) {
|
|
|
296 if ((value = NextInt(fstream)) < 0)
|
|
|
297 RETURN (BitmapFileInvalid);
|
|
|
298 *ptr=value;
|
|
|
299 }
|
|
|
300 }
|
|
|
301 break;
|
|
|
302 } /* end while */
|
|
|
303
|
|
|
304 if (data == NULL) {
|
|
|
305 RETURN (BitmapFileInvalid);
|
|
|
306 }
|
|
|
307
|
|
|
308 *datap = data;
|
|
|
309 data = NULL;
|
|
|
310 *width = ww;
|
|
|
311 *height = hh;
|
|
|
312 if (x_hot) *x_hot = hx;
|
|
|
313 if (y_hot) *y_hot = hy;
|
|
|
314
|
|
|
315 RETURN (BitmapSuccess);
|
|
|
316 }
|
|
|
317
|
|
|
318
|
|
611
|
319 int
|
|
771
|
320 read_bitmap_data_from_file (Lisp_Object filename,
|
|
611
|
321 /* Remaining args are RETURNED */
|
|
647
|
322 int *width,
|
|
|
323 int *height,
|
|
2367
|
324 Binbyte **datap,
|
|
611
|
325 int *x_hot, int *y_hot)
|
|
608
|
326 {
|
|
771
|
327 FILE *fstream;
|
|
|
328 int status;
|
|
|
329 Extbyte *fileext;
|
|
608
|
330
|
|
771
|
331 LISP_STRING_TO_EXTERNAL (filename, fileext, Qnative);
|
|
|
332 if ((fstream = fopen (fileext, "r")) == NULL)
|
|
|
333 return BitmapOpenFailed;
|
|
|
334 status = read_bitmap_data (fstream, width, height, datap, x_hot, y_hot);
|
|
|
335 retry_fclose (fstream);
|
|
|
336 return status;
|
|
608
|
337 }
|
|
|
338
|
|
563
|
339 void
|
|
|
340 syms_of_glyphs_shared (void)
|
|
|
341 {
|
|
|
342 DEFKEYWORD (Q_resource_id);
|
|
|
343 DEFKEYWORD (Q_resource_type);
|
|
|
344 }
|
