/[emacs]/emacs/src/fringe.c
ViewVC logotype

Diff of /emacs/src/fringe.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.10.2.2 by miles, Wed Sep 29 07:22:18 2004 UTC revision 1.10.2.3 by miles, Thu Sep 30 01:20:35 2004 UTC
# Line 445  struct fringe_bitmap standard_bitmaps[MA Line 445  struct fringe_bitmap standard_bitmaps[MA
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.
# Line 501  get_fringe_bitmap_name (bn) Line 508  get_fringe_bitmap_name (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
# Line 1068  compute_fringe_widths (f, redraw) Line 1039  compute_fringe_widths (f, redraw)
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  {  {
# Line 1079  destroy_fringe_bitmap (n) Line 1052  destroy_fringe_bitmap (n)
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;
# Line 1099  If BITMAP overrides a standard fringe bi Line 1072  If BITMAP overrides a standard fringe bi
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    
# Line 1185  init_fringe_bitmap (which, fb, once_p) Line 1159  init_fringe_bitmap (which, fb, once_p)
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;
# Line 1216  If BITMAP already exists, the existing d Line 1190  If BITMAP already exists, the existing d
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);
# Line 1274  If BITMAP already exists, the existing d Line 1244  If BITMAP already exists, the existing d
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;
# Line 1318  If BITMAP already exists, the existing d Line 1307  If BITMAP already exists, the existing d
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,
# Line 1328  If FACE is nil, reset face to default fr Line 1317  If FACE is nil, reset face to default fr
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))
# Line 1344  If FACE is nil, reset face to default fr Line 1334  If FACE is nil, reset face to default fr
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  }  }
# Line 1433  init_fringe () Line 1423  init_fringe ()
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
# Line 1445  w32_init_fringe () Line 1444  w32_init_fringe ()
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];
# Line 1458  w32_reset_fringes () Line 1460  w32_reset_fringes ()
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  }  }

Legend:
Removed from v.1.10.2.2  
changed lines
  Added in v.1.10.2.3

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26