Mercurial > hg > xemacs-beta
annotate src/glyphs-shared.c @ 4882:eab9498ecc0e
merge most of rest of redisplay-x.c and redisplay-gtk.c into redisplay-xlike-inc.c
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-01-18 Ben Wing <ben@xemacs.org>
* redisplay-gtk.c:
* redisplay-gtk.c (gtk_bevel_area):
* redisplay-x.c:
* redisplay-x.c (THIS_IS_X):
* redisplay-xlike-inc.c:
* redisplay-xlike-inc.c (XLIKE_text_width_single_run):
* redisplay-xlike-inc.c (XLIKE_text_width):
* redisplay-xlike-inc.c (XLIKE_output_display_block):
* redisplay-xlike-inc.c (XLIKE_get_gc):
* redisplay-xlike-inc.c (XLIKE_output_string):
* redisplay-xlike-inc.c (XLIKE_OUTPUT_XLIKE_PIXMAP):
* redisplay-xlike-inc.c (XLIKE_output_pixmap):
* redisplay-xlike-inc.c (XLIKE_output_vertical_divider):
* redisplay-xlike-inc.c (XLIKE_output_blank):
* redisplay-xlike-inc.c (XLIKE_output_horizontal_line):
* redisplay-xlike-inc.c (XLIKE_clear_region):
* redisplay-xlike-inc.c (XLIKE_output_eol_cursor):
* redisplay-xlike-inc.c (XLIKE_clear_frame_window):
* redisplay-xlike-inc.c (XLIKE_clear_frame):
* redisplay-xlike-inc.c (XLIKE_flash):
* redisplay-xlike-inc.c (console_type_create_redisplay_XLIKE):
Move lots more code into redisplay-xlike-inc.c. Use macros to
isolate the code that differs among X vs. GTK, to reduce the need
for ifdefs in the middle of the code. Now, redisplay-x.c and
redisplay-gtk.c only contain a few functions whose implementation
is completely different from one to the other, or which are not
present at all in one of them.
GTK code not currently tested, but it has bitrotted somewhat
any. Doing this will help keep it less bitrotty.
* depend: Regenerate.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Mon, 18 Jan 2010 08:44:49 -0600 |
| parents | b3ea9c582280 |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 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 |
|
4834
b3ea9c582280
Use new cygwin_conv_path API with Cygwin 1.7 for converting names between Win32 and POSIX, UTF-8-aware, with attendant changes elsewhere
Ben Wing <ben@xemacs.org>
parents:
4226
diff
changeset
|
331 LISP_PATHNAME_CONVERT_OUT (filename, fileext); |
| 771 | 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 } |