445 |
{ FRBITS (zv_bits), 8, 3, ALIGN_BITMAP_TOP, 0 }, |
{ FRBITS (zv_bits), 8, 3, ALIGN_BITMAP_TOP, 0 }, |
446 |
}; |
}; |
447 |
|
|
448 |
static struct fringe_bitmap *fringe_bitmaps[MAX_FRINGE_BITMAPS]; |
static struct fringe_bitmap **fringe_bitmaps; |
449 |
static unsigned fringe_faces[MAX_FRINGE_BITMAPS]; |
static unsigned *fringe_faces; |
450 |
|
static int max_fringe_bitmaps; |
451 |
|
|
452 |
static int max_used_fringe_bitmap = MAX_STANDARD_FRINGE_BITMAPS; |
static int max_used_fringe_bitmap = MAX_STANDARD_FRINGE_BITMAPS; |
453 |
|
|
454 |
/* Return 1 if FRINGE_ID is a valid fringe bitmap id. */ |
|
455 |
|
/* Lookup bitmap number for symbol BITMAP. |
456 |
|
Return 0 if not a bitmap. */ |
457 |
|
|
458 |
int |
int |
459 |
valid_fringe_bitmap_p (bitmap) |
lookup_fringe_bitmap (bitmap) |
460 |
Lisp_Object bitmap; |
Lisp_Object bitmap; |
461 |
{ |
{ |
462 |
int bn; |
int bn; |
463 |
|
|
464 |
|
bitmap = Fget (bitmap, Qfringe); |
465 |
if (!INTEGERP (bitmap)) |
if (!INTEGERP (bitmap)) |
466 |
return 0; |
return 0; |
467 |
|
|
468 |
bn = XINT (bitmap); |
bn = XINT (bitmap); |
469 |
return (bn >= NO_FRINGE_BITMAP |
if (bn > NO_FRINGE_BITMAP |
470 |
&& bn < max_used_fringe_bitmap |
&& bn < max_used_fringe_bitmap |
471 |
&& (bn < MAX_STANDARD_FRINGE_BITMAPS |
&& (bn < MAX_STANDARD_FRINGE_BITMAPS |
472 |
|| fringe_bitmaps[bn] != NULL)); |
|| fringe_bitmaps[bn] != NULL)) |
473 |
|
return bn; |
474 |
|
|
475 |
|
return 0; |
476 |
} |
} |
477 |
|
|
478 |
/* Get fringe bitmap name for bitmap number BN. |
/* Get fringe bitmap name for bitmap number BN. |
508 |
} |
} |
509 |
|
|
510 |
|
|
|
/* Resolve a BITMAP parameter. |
|
|
|
|
|
An INTEGER, corresponding to a bitmap number. |
|
|
A STRING which is interned to a symbol. |
|
|
A SYMBOL which has a fringe property which is a bitmap number. |
|
|
*/ |
|
|
|
|
|
static int |
|
|
resolve_fringe_bitmap (bitmap, namep) |
|
|
Lisp_Object bitmap; |
|
|
Lisp_Object *namep; |
|
|
{ |
|
|
if (namep) |
|
|
*namep = Qnil; |
|
|
|
|
|
if (STRINGP (bitmap)) |
|
|
bitmap = intern (SDATA (bitmap)); |
|
|
|
|
|
if (SYMBOLP (bitmap)) |
|
|
{ |
|
|
if (namep) |
|
|
*namep = bitmap; |
|
|
bitmap = Fget (bitmap, Qfringe); |
|
|
} |
|
|
|
|
|
if (valid_fringe_bitmap_p (bitmap)) |
|
|
{ |
|
|
if (namep && NILP (*namep)) |
|
|
*namep = get_fringe_bitmap_name (XINT (bitmap)); |
|
|
return XINT (bitmap); |
|
|
} |
|
|
|
|
|
return -1; |
|
|
} |
|
|
|
|
|
|
|
511 |
/* Draw the bitmap WHICH in one of the left or right fringes of |
/* Draw the bitmap WHICH in one of the left or right fringes of |
512 |
window W. ROW is the glyph row for which to display the bitmap; it |
window W. ROW is the glyph row for which to display the bitmap; it |
513 |
determines the vertical position at which the bitmap has to be |
determines the vertical position at which the bitmap has to be |
1039 |
} |
} |
1040 |
|
|
1041 |
|
|
1042 |
void |
/* Free resources used by a user-defined bitmap. */ |
1043 |
|
|
1044 |
|
int |
1045 |
destroy_fringe_bitmap (n) |
destroy_fringe_bitmap (n) |
1046 |
int n; |
int n; |
1047 |
{ |
{ |
1052 |
fbp = &fringe_bitmaps[n]; |
fbp = &fringe_bitmaps[n]; |
1053 |
if (*fbp && (*fbp)->dynamic) |
if (*fbp && (*fbp)->dynamic) |
1054 |
{ |
{ |
1055 |
if (rif->destroy_fringe_bitmap) |
if (rif && rif->destroy_fringe_bitmap) |
1056 |
rif->destroy_fringe_bitmap (n); |
rif->destroy_fringe_bitmap (n); |
1057 |
xfree (*fbp); |
xfree (*fbp); |
1058 |
*fbp = NULL; |
*fbp = NULL; |
1072 |
Lisp_Object bitmap; |
Lisp_Object bitmap; |
1073 |
{ |
{ |
1074 |
int n; |
int n; |
|
Lisp_Object sym; |
|
1075 |
|
|
1076 |
n = resolve_fringe_bitmap (bitmap, &sym); |
CHECK_SYMBOL (bitmap); |
1077 |
if (n < 0) |
n = lookup_fringe_bitmap (bitmap); |
1078 |
|
if (!n) |
1079 |
return Qnil; |
return Qnil; |
1080 |
|
|
1081 |
destroy_fringe_bitmap (n); |
destroy_fringe_bitmap (n); |
1082 |
|
|
1083 |
if (SYMBOLP (sym)) |
if (n >= MAX_STANDARD_FRINGE_BITMAPS) |
1084 |
{ |
{ |
1085 |
Vfringe_bitmaps = Fdelq (sym, Vfringe_bitmaps); |
Vfringe_bitmaps = Fdelq (bitmap, Vfringe_bitmaps); |
1086 |
/* It would be better to remove the fringe property. */ |
/* It would be better to remove the fringe property. */ |
1087 |
Fput (sym, Qfringe, Qnil); |
Fput (bitmap, Qfringe, Qnil); |
1088 |
} |
} |
1089 |
|
|
1090 |
return Qnil; |
return Qnil; |
1091 |
} |
} |
1092 |
|
|
1159 |
{ |
{ |
1160 |
destroy_fringe_bitmap (which); |
destroy_fringe_bitmap (which); |
1161 |
|
|
1162 |
if (rif->define_fringe_bitmap) |
if (rif && rif->define_fringe_bitmap) |
1163 |
rif->define_fringe_bitmap (which, fb->bits, fb->height, fb->width); |
rif->define_fringe_bitmap (which, fb->bits, fb->height, fb->width); |
1164 |
|
|
1165 |
fringe_bitmaps[which] = fb; |
fringe_bitmaps[which] = fb; |
1190 |
unsigned short *b; |
unsigned short *b; |
1191 |
struct fringe_bitmap fb, *xfb; |
struct fringe_bitmap fb, *xfb; |
1192 |
int fill1 = 0, fill2 = 0; |
int fill1 = 0, fill2 = 0; |
|
Lisp_Object sym; |
|
1193 |
|
|
1194 |
n = resolve_fringe_bitmap (bitmap, &sym); |
CHECK_SYMBOL (bitmap); |
|
|
|
|
if (NILP (sym) || INTEGERP (sym)) |
|
|
sym = wrong_type_argument (Qsymbolp, bitmap); |
|
1195 |
|
|
1196 |
if (!STRINGP (bits) && !VECTORP (bits)) |
if (!STRINGP (bits) && !VECTORP (bits)) |
1197 |
bits = wrong_type_argument (Qstringp, bits); |
bits = wrong_type_argument (Qstringp, bits); |
1244 |
else if (!NILP (align) && !EQ (align, Qcenter)) |
else if (!NILP (align) && !EQ (align, Qcenter)) |
1245 |
error ("Bad align argument"); |
error ("Bad align argument"); |
1246 |
|
|
1247 |
if (n < 0) |
n = lookup_fringe_bitmap (bitmap); |
1248 |
|
if (!n) |
1249 |
{ |
{ |
1250 |
if (max_used_fringe_bitmap < MAX_FRINGE_BITMAPS) |
if (max_used_fringe_bitmap < max_fringe_bitmaps) |
1251 |
n = max_used_fringe_bitmap++; |
n = max_used_fringe_bitmap++; |
1252 |
else |
else |
1253 |
{ |
{ |
1254 |
for (n = MAX_STANDARD_FRINGE_BITMAPS; |
for (n = MAX_STANDARD_FRINGE_BITMAPS; |
1255 |
n < MAX_FRINGE_BITMAPS; |
n < max_fringe_bitmaps; |
1256 |
n++) |
n++) |
1257 |
if (fringe_bitmaps[n] == NULL) |
if (fringe_bitmaps[n] == NULL) |
1258 |
break; |
break; |
1259 |
if (n == MAX_FRINGE_BITMAPS) |
|
1260 |
error ("Cannot define more fringe bitmaps"); |
if (n == max_fringe_bitmaps) |
1261 |
|
{ |
1262 |
|
if ((max_fringe_bitmaps + 20) > MAX_FRINGE_BITMAPS) |
1263 |
|
error ("No free fringe bitmap slots"); |
1264 |
|
|
1265 |
|
i = max_fringe_bitmaps; |
1266 |
|
max_fringe_bitmaps += 20; |
1267 |
|
fringe_bitmaps |
1268 |
|
= ((struct fringe_bitmap **) |
1269 |
|
xrealloc (fringe_bitmaps, max_fringe_bitmaps * sizeof (struct fringe_bitmap *))); |
1270 |
|
fringe_faces |
1271 |
|
= (unsigned *) xrealloc (fringe_faces, max_fringe_bitmaps * sizeof (unsigned)); |
1272 |
|
|
1273 |
|
for (; i < max_fringe_bitmaps; i++) |
1274 |
|
{ |
1275 |
|
fringe_bitmaps[i] = NULL; |
1276 |
|
fringe_faces[i] = FRINGE_FACE_ID; |
1277 |
|
} |
1278 |
|
} |
1279 |
} |
} |
1280 |
|
|
1281 |
Vfringe_bitmaps = Fcons (sym, Vfringe_bitmaps); |
Vfringe_bitmaps = Fcons (bitmap, Vfringe_bitmaps); |
1282 |
Fput (sym, Qfringe, make_number (n)); |
Fput (bitmap, Qfringe, make_number (n)); |
1283 |
} |
} |
1284 |
|
|
1285 |
fb.dynamic = 1; |
fb.dynamic = 1; |
1307 |
|
|
1308 |
init_fringe_bitmap (n, xfb, 0); |
init_fringe_bitmap (n, xfb, 0); |
1309 |
|
|
1310 |
return sym; |
return bitmap; |
1311 |
} |
} |
1312 |
|
|
1313 |
DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face, |
DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face, |
1317 |
(bitmap, face) |
(bitmap, face) |
1318 |
Lisp_Object bitmap, face; |
Lisp_Object bitmap, face; |
1319 |
{ |
{ |
1320 |
int bn; |
int n; |
1321 |
int face_id; |
int face_id; |
1322 |
|
|
1323 |
bn = resolve_fringe_bitmap (bitmap, 0); |
CHECK_SYMBOL (bitmap); |
1324 |
if (bn < 0) |
n = lookup_fringe_bitmap (bitmap); |
1325 |
|
if (!n) |
1326 |
error ("Undefined fringe bitmap"); |
error ("Undefined fringe bitmap"); |
1327 |
|
|
1328 |
if (!NILP (face)) |
if (!NILP (face)) |
1334 |
else |
else |
1335 |
face_id = FRINGE_FACE_ID; |
face_id = FRINGE_FACE_ID; |
1336 |
|
|
1337 |
fringe_faces [bn] = face_id; |
fringe_faces[n] = face_id; |
1338 |
|
|
1339 |
return Qnil; |
return Qnil; |
1340 |
} |
} |
1423 |
{ |
{ |
1424 |
int i; |
int i; |
1425 |
|
|
1426 |
bzero (fringe_bitmaps, sizeof fringe_bitmaps); |
max_fringe_bitmaps = MAX_STANDARD_FRINGE_BITMAPS + 20; |
1427 |
for (i = 0; i < MAX_FRINGE_BITMAPS; i++) |
|
1428 |
fringe_faces[i] = FRINGE_FACE_ID; |
fringe_bitmaps |
1429 |
|
= (struct fringe_bitmap **) xmalloc (max_fringe_bitmaps * sizeof (struct fringe_bitmap *)); |
1430 |
|
fringe_faces |
1431 |
|
= (unsigned *) xmalloc (max_fringe_bitmaps * sizeof (unsigned)); |
1432 |
|
|
1433 |
|
for (i = 0; i < max_fringe_bitmaps; i++) |
1434 |
|
{ |
1435 |
|
fringe_bitmaps[i] = NULL; |
1436 |
|
fringe_faces[i] = FRINGE_FACE_ID; |
1437 |
|
} |
1438 |
} |
} |
1439 |
|
|
1440 |
#ifdef HAVE_NTGUI |
#ifdef HAVE_NTGUI |
1444 |
{ |
{ |
1445 |
enum fringe_bitmap_type bt; |
enum fringe_bitmap_type bt; |
1446 |
|
|
1447 |
|
if (!rif) |
1448 |
|
return; |
1449 |
|
|
1450 |
for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++) |
for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++) |
1451 |
{ |
{ |
1452 |
struct fringe_bitmap *fb = &standard_bitmaps[bt]; |
struct fringe_bitmap *fb = &standard_bitmaps[bt]; |
1460 |
/* Destroy row bitmaps. */ |
/* Destroy row bitmaps. */ |
1461 |
int bt; |
int bt; |
1462 |
|
|
1463 |
|
if (!rif) |
1464 |
|
return; |
1465 |
|
|
1466 |
for (bt = NO_FRINGE_BITMAP + 1; bt < max_used_fringe_bitmap; bt++) |
for (bt = NO_FRINGE_BITMAP + 1; bt < max_used_fringe_bitmap; bt++) |
1467 |
rif->destroy_fringe_bitmap (bt); |
rif->destroy_fringe_bitmap (bt); |
1468 |
} |
} |