/[CvsGraph]/cvsgraph/cvsgraph.c
ViewVC logotype

Diff of /cvsgraph/cvsgraph.c

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

revision 1.21, Mon Feb 18 01:31:34 2002 UTC revision 1.28, Sat Jul 20 20:41:40 2002 UTC
# Line 55  Line 55 
55    
56  /*#define DEBUG         1*/  /*#define DEBUG         1*/
57  /*#define NOGDFILL      1*/  /*#define NOGDFILL      1*/
58    /*#define DEBUG_IMAGEMAP        1*/
59    
60  #define LOOPSAFEGUARD   100     /* Max itterations in possible infinite loops */  #define LOOPSAFEGUARD   100     /* Max itterations in possible infinite loops */
61    
# Line 357  Line 358 
358  static delta_t *find_delta(delta_t **dl, int n, rev_t *r)  static delta_t *find_delta(delta_t **dl, int n, rev_t *r)
359  {  {
360          delta_t **d;          delta_t **d;
361            if(!n)
362                    return NULL;
363          d = bsearch(r, dl, n, sizeof(*dl), search_delta);          d = bsearch(r, dl, n, sizeof(*dl), search_delta);
364          if(!d)          if(!d)
365                  return NULL;                  return NULL;
# Line 376  Line 379 
379  static dtext_t *find_dtext(dtext_t **dl, int n, rev_t *r)  static dtext_t *find_dtext(dtext_t **dl, int n, rev_t *r)
380  {  {
381          dtext_t **d;          dtext_t **d;
382            if(!n)
383                    return NULL;
384          d = bsearch(r, dl, n, sizeof(*dl), search_dtext);          d = bsearch(r, dl, n, sizeof(*dl), search_dtext);
385          if(!d)          if(!d)
386                  return NULL;                  return NULL;
# Line 508  Line 513 
513          qsort(sdelta, nsdelta, sizeof(sdelta[0]), sort_delta);          qsort(sdelta, nsdelta, sizeof(sdelta[0]), sort_delta);
514    
515          /* Do the same for the delta text */          /* Do the same for the delta text */
516          nsdtext = rcs->dtexts->ndtexts;          if(rcs->dtexts)
517          sdtext = xmalloc(nsdtext * sizeof(sdtext[0]));          {
518          memcpy(sdtext, rcs->dtexts->dtexts, nsdtext * sizeof(sdtext[0]));                  nsdtext = rcs->dtexts->ndtexts;
519          qsort(sdtext, nsdtext, sizeof(sdtext[0]), sort_dtext);                  sdtext = xmalloc(nsdtext * sizeof(sdtext[0]));
520                    memcpy(sdtext, rcs->dtexts->dtexts, nsdtext * sizeof(sdtext[0]));
521                    qsort(sdtext, nsdtext, sizeof(sdtext[0]), sort_dtext);
522            }
523            else
524            {
525                    nsdtext = 0;
526                    sdtext = NULL;
527            }
528    
529          /* Start from the head of the trunk */          /* Start from the head of the trunk */
530          head = find_delta(sdelta, nsdelta, rcs->head);          head = find_delta(sdelta, nsdelta, rcs->head);
# Line 711  Line 724 
724                          else                          else
725                          {                          {
726                                  revision_t *rr = *r;                                  revision_t *rr = *r;
727                                  rr->tags = xrealloc(rr->tags, (rr->ntags+1)*sizeof(rr->tags[0]));                                  if(!conf.rev_maxtags || rr->ntags <= conf.rev_maxtags)
728                                  rr->tags[rr->ntags] = t;                                  {
729                                  rr->ntags++;                                          rr->tags = xrealloc(rr->tags, (rr->ntags+1)*sizeof(rr->tags[0]));
730                                            if(conf.rev_maxtags && rr->ntags == conf.rev_maxtags)
731                                            {
732                                                    rr->tags[rr->ntags] = xmalloc(sizeof(tag_t));
733                                                    rr->tags[rr->ntags]->tag = xstrdup("...");
734                                                    rr->tags[rr->ntags]->rev = t->rev;
735                                            }
736                                            else
737                                                    rr->tags[rr->ntags] = t;
738                                            rr->ntags++;
739                                    }
740                          }                          }
741                  }                  }
742          }          }
# Line 747  Line 770 
770          int l = strlen(s) + 1;          int l = strlen(s) + 1;
771          if(_nstring + l > _nastring)          if(_nstring + l > _nastring)
772          {          {
773                  _nastring += 128;                  _nastring += MAX(128, l);
774                  _string = xrealloc(_string, _nastring * sizeof(_string[0]));                  _string = xrealloc(_string, _nastring * sizeof(_string[0]));
775          }          }
776          memcpy(_string+_nstring, s, l);          memcpy(_string+_nstring, s, l);
# Line 792  Line 815 
815          xfree(buf);          xfree(buf);
816  }  }
817    
818    static void add_string_str_html(const char *s, int maxlen)
819    {
820            int l = 0;
821            char *str = xmalloc(6 * strlen(s) + 1); /* Should hold all char entity-expand */
822            char *cptr = str;
823            for(; *s; s++)
824            {
825                    if(maxlen && l > abs(maxlen))
826                    {
827                            cptr += sprintf(cptr, "...");
828                            break;
829                    }
830                    if(*s < 0x20)
831                    {
832                            if(*s == '\n')
833                            {
834                                    if(maxlen < 0)
835                                            *cptr++ = ' ';
836                                    else
837                                            cptr += sprintf(cptr, "<br>");
838                            }
839                    }
840                    else if(*s >= 0x7f)
841                            cptr += sprintf(cptr, "&#%d;", (int)(unsigned char)*s);
842                    else if(*s == '<')
843                            cptr += sprintf(cptr, "&lt;");
844                    else if(*s == '>')
845                            cptr += sprintf(cptr, "&gt;");
846                    else
847                            *cptr++ = *s;
848                    l++;
849            }
850            *cptr = '\0';
851            add_string_str(str);
852            xfree(str);
853    }
854    
855    static void add_string_str_len(const char *s, int maxlen)
856    {
857            int l = strlen(s);
858            char *str = xmalloc(l + 1 + 3);
859            strcpy(str, s);
860            if(maxlen < l)
861                    sprintf(&str[maxlen], "...");
862            add_string_str(str);
863            xfree(str);
864    }
865    
866  char *expand_string(const char *s, rcsfile_t *rcs, revision_t *r, rev_t *rev, rev_t *prev, tag_t *tag)  char *expand_string(const char *s, rcsfile_t *rcs, revision_t *r, rev_t *rev, rev_t *prev, tag_t *tag)
867  {  {
868          char nb[32];          char nb[32];
869          char nr[32];          char nr[32];
870          char *base;          char *base;
871            int l;
872            char ch;
873    
874          if(!s)          if(!s)
875                  return xstrdup("");                  return xstrdup("");
# Line 886  Line 959 
959                          case 'd': if(r && r->delta && r->delta->date) add_string_date(r->delta->date); break;                          case 'd': if(r && r->delta && r->delta->date) add_string_date(r->delta->date); break;
960                          case 's': if(r && r->delta && r->delta->state) add_string_str(r->delta->state); break;                          case 's': if(r && r->delta && r->delta->state) add_string_str(r->delta->state); break;
961                          case 'a': if(r && r->delta && r->delta->author) add_string_str(r->delta->author); break;                          case 'a': if(r && r->delta && r->delta->author) add_string_str(r->delta->author); break;
962                            case 'L':
963                            case 'l':
964                                    ch = *s;
965                                    l = 0;
966                                    if(s[1] == '[')
967                                    {
968                                            char *cptr = strchr(s, ']');
969                                            char *eptr;
970                                            if(cptr)
971                                            {
972                                                    l = strtol(&s[2], &eptr, 10);
973                                                    if(eptr != cptr)
974                                                            l = 0;
975                                                    else
976                                                            s = cptr;
977                                            }
978                                    }
979                                    if(!conf.parse_logs)
980                                            add_string_str("N/A");
981                                    else if(r && r->dtext && r->dtext->log)
982                                    {
983                                            if(ch == 'l')
984                                                    add_string_str_html(r->dtext->log, l);
985                                            else
986                                                    add_string_str_len(r->dtext->log, abs(l));
987                                    }
988                                    break;
989                          default:                          default:
990                                  add_string_ch('%');                                  add_string_ch('%');
991                                  add_string_ch(*s);                                  add_string_ch(*s);
# Line 935  Line 1035 
1035          }          }
1036          if(n > m)          if(n > m)
1037                  m = n;                  m = n;
1038          return m * f->gdfont->w;          return f->gdfont ? m * f->gdfont->w : m;
1039  }  }
1040    
1041  static int get_sheight(const char *s, font_t *f)  static int get_sheight(const char *s, font_t *f)
# Line 1053  Line 1153 
1153    
1154  static void draw_rev(gdImagePtr im, revision_t *r)  static void draw_rev(gdImagePtr im, revision_t *r)
1155  {  {
1156          int lx = r->cx - r->w/2;          int lx;
1157          int rx = lx + r->w;          int rx;
1158            int x2;
1159          int i;          int i;
1160          int ty = r->y;          int ty;
1161    
1162            if(conf.left_right)
1163            {
1164                    lx = r->cx;
1165                    rx = r->cx + r->w;
1166                    ty = r->y - r->h/2;
1167                    x2 = r->cx + r->w/2;
1168            }
1169            else
1170            {
1171                    lx = r->cx - r->w/2;
1172                    rx = lx + r->w;
1173                    ty = r->y;
1174                    x2 = r->cx;
1175            }
1176          draw_rbox(im, lx, ty, rx, ty+r->h, 0, &conf.rev_color, &conf.rev_bgcolor);          draw_rbox(im, lx, ty, rx, ty+r->h, 0, &conf.rev_color, &conf.rev_bgcolor);
1177          ty += conf.rev_tspace;          ty += conf.rev_tspace;
1178          draw_string(im, r->rev->rev, &conf.rev_font, r->cx, ty, ALIGN_HC, &conf.rev_color);          draw_string(im, r->rev->rev, &conf.rev_font, x2, ty, ALIGN_HC, &conf.rev_color);
1179          ty += get_sheight(r->rev->rev, &conf.rev_font);          ty += get_sheight(r->rev->rev, &conf.rev_font);
1180          draw_stringnl(im, r->revtext, &conf.rev_text_font, r->cx, ty, ALIGN_HC, &conf.rev_text_color);          draw_stringnl(im, r->revtext, &conf.rev_text_font, x2, ty, ALIGN_HC, &conf.rev_text_color);
1181          ty += get_sheight(r->revtext, &conf.rev_text_font);          ty += get_sheight(r->revtext, &conf.rev_text_font);
1182          for(i = 0; i < r->ntags; i++)          for(i = 0; i < r->ntags; i++)
1183          {          {
1184                  draw_string(im, r->tags[i]->tag, &conf.tag_font, r->cx, ty, ALIGN_HC, &conf.tag_color);                  draw_string(im, r->tags[i]->tag, &conf.tag_font, x2, ty, ALIGN_HC, &conf.tag_color);
1185                  ty += get_sheight(r->tags[i]->tag, &conf.tag_font) + conf.rev_separator;                  ty += get_sheight(r->tags[i]->tag, &conf.tag_font) + conf.rev_separator;
1186          }          }
1187  }  }
1188    
1189  static void draw_branch_box(gdImagePtr im, branch_t *b, int ypos)  static void draw_branch_box(gdImagePtr im, branch_t *b, int xp, int yp)
1190  {  {
1191          int lx = b->cx - b->w/2;          int lx;
1192          int rx = lx + b->w;          int rx;
1193          int i;          int i;
1194          int yy;          int yy;
1195            int x2;
1196    
1197          draw_rbox(im, lx, ypos, rx, ypos+b->h, 5, &conf.branch_color, &conf.branch_bgcolor);          if(conf.left_right)
1198            {
1199                    lx = b->cx;
1200                    rx = lx + b->w;
1201                    x2 = b->cx + b->w/2;
1202            }
1203            else
1204            {
1205                    lx = b->cx - b->w/2;
1206                    rx = lx + b->w;
1207                    x2 = b->cx;
1208            }
1209            draw_rbox(im, lx+xp, yp, rx+xp, yp+b->h, 5, &conf.branch_color, &conf.branch_bgcolor);
1210          yy = conf.branch_tspace;          yy = conf.branch_tspace;
1211          draw_string(im, b->branch->branch, &conf.branch_font, b->cx, ypos+yy, ALIGN_HC, &conf.branch_color);          draw_string(im, b->branch->branch, &conf.branch_font, x2+xp, yp+yy, ALIGN_HC, &conf.branch_color);
1212          yy += get_sheight(b->branch->branch, &conf.branch_font);          yy += get_sheight(b->branch->branch, &conf.branch_font);
1213          for(i = 0; i < b->ntags; i++)          for(i = 0; i < b->ntags; i++)
1214          {          {
1215                  draw_string(im, b->tags[i]->tag, &conf.branch_tag_font, b->cx, ypos+yy, ALIGN_HC, &conf.branch_tag_color);                  draw_string(im, b->tags[i]->tag, &conf.branch_tag_font, x2+xp, yp+yy, ALIGN_HC, &conf.branch_tag_color);
1216                  yy += get_sheight(b->tags[i]->tag, &conf.branch_font);                  yy += get_sheight(b->tags[i]->tag, &conf.branch_font);
1217          }          }
1218  }  }
1219    
1220  static void draw_branch(gdImagePtr im, branch_t *b)  static void draw_branch(gdImagePtr im, branch_t *b)
1221  {  {
1222          int yy;          int yy, xx;
1223          int i;          int i;
1224          int line[4];          int line[4];
1225          int l;          int l;
# Line 1101  Line 1230 
1230          line[1] = gdTransparent;          line[1] = gdTransparent;
1231          line[3] = conf.rev_color.id;          line[3] = conf.rev_color.id;
1232    
1233          draw_branch_box(im, b, b->y);          draw_branch_box(im, b, 0, conf.left_right ? b->y - b->h/2 : b->y);
1234    
1235          if(conf.upside_down)          if(conf.left_right)
1236          {          {
1237                  yy = b->y;                  if(conf.upside_down)
                 for(i = 0; i < b->nrevs; i++)  
1238                  {                  {
1239                          revision_t *r = b->revs[i];                          xx = b->cx;
1240                          gdImageSetStyle(im, line, r->stripped ? 4 : 1);                          for(i = 0; i < b->nrevs; i++)
1241                          gdImageLine(im, r->cx, yy, r->cx, r->y+r->h, gdStyled);                          {
1242                          for(sign = l = 1; l < conf.thick_lines; l++)                                  revision_t *r = b->revs[i];
1243                          {                                  gdImageSetStyle(im, line, r->stripped ? 4 : 1);
1244                                  int pp = (l+1)/2*sign;                                  gdImageLine(im, xx, r->y, r->cx+r->w, r->y, gdStyled);
1245                                  gdImageLine(im, r->cx+pp, yy, r->cx+pp, r->y+r->h, gdStyled);                                  for(sign = l = 1; l < conf.thick_lines; l++)
1246                                  sign *= -1;                                  {
1247                                            int pp = (l+1)/2*sign;
1248                                            gdImageLine(im, xx, r->y+pp, r->cx+r->w, r->y+pp, gdStyled);
1249                                            sign *= -1;
1250                                    }
1251                                    draw_rev(im, r);
1252                                    xx = r->cx;
1253                            }
1254                            if(conf.branch_dupbox)
1255                            {
1256                                    i = b->cx - b->tw + b->w;
1257                                    gdImageLine(im, xx, b->y, i+b->w, b->y, conf.rev_color.id);
1258                                    for(sign = l = 1; l < conf.thick_lines; l++)
1259                                    {
1260                                            int pp = (l+1)/2*sign;
1261                                            gdImageLine(im, xx, b->y+pp, i+b->w, b->y+pp, conf.rev_color.id);
1262                                            sign *= -1;
1263                                    }
1264                                    draw_branch_box(im, b, i - b->cx, b->y - b->h/2);
1265                          }                          }
                         draw_rev(im, r);  
                         yy = r->y;  
1266                  }                  }
1267                  if(conf.branch_dupbox)                  else
1268                  {                  {
1269                          i = b->y - b->th + b->h;                          xx = b->cx + b->w;
1270                          gdImageLine(im, b->cx, yy, b->cx, i, conf.rev_color.id);                          for(i = 0; i < b->nrevs; i++)
                         for(sign = l = 1; l < conf.thick_lines; l++)  
1271                          {                          {
1272                                  int pp = (l+1)/2*sign;                                  revision_t *r = b->revs[i];
1273                                  gdImageLine(im, b->cx+pp, yy, b->cx+pp, i, conf.rev_color.id);                                  gdImageSetStyle(im, line, r->stripped ? 4 : 1);
1274                                  sign *= -1;                                  gdImageLine(im, xx, r->y, r->cx, r->y, gdStyled);
1275                                    for(sign = l = 1; l < conf.thick_lines; l++)
1276                                    {
1277                                            int pp = (l+1)/2*sign;
1278                                            gdImageLine(im, xx, r->y+pp, r->cx, r->y+pp, gdStyled);
1279                                            sign *= -1;
1280                                    }
1281                                    draw_rev(im, r);
1282                                    xx = r->cx + r->w;
1283                            }
1284                            if(conf.branch_dupbox)
1285                            {
1286                                    i = b->cx + b->tw - b->w;
1287                                    gdImageLine(im, xx, b->y, i, b->y, conf.rev_color.id);
1288                                    for(sign = l = 1; l < conf.thick_lines; l++)
1289                                    {
1290                                            int pp = (l+1)/2*sign;
1291                                            gdImageLine(im, xx, b->y+pp, i, b->y+pp, conf.rev_color.id);
1292                                            sign *= -1;
1293                                    }
1294                                    draw_branch_box(im, b, i - b->cx, b->y - b->h/2);
1295                          }                          }
                         draw_branch_box(im, b, i);  
1296                  }                  }
1297          }          }
1298          else          else
1299          {          {
1300                  yy = b->y + b->h;                  if(conf.upside_down)
                 for(i = 0; i < b->nrevs; i++)  
1301                  {                  {
1302                          revision_t *r = b->revs[i];                          yy = b->y;
1303                          gdImageSetStyle(im, line, r->stripped ? 4 : 1);                          for(i = 0; i < b->nrevs; i++)
1304                          gdImageLine(im, r->cx, yy, r->cx, r->y, gdStyled);                          {
1305                          for(sign = l = 1; l < conf.thick_lines; l++)                                  revision_t *r = b->revs[i];
1306                                    gdImageSetStyle(im, line, r->stripped ? 4 : 1);
1307                                    gdImageLine(im, r->cx, yy, r->cx, r->y+r->h, gdStyled);
1308                                    for(sign = l = 1; l < conf.thick_lines; l++)
1309                                    {
1310                                            int pp = (l+1)/2*sign;
1311                                            gdImageLine(im, r->cx+pp, yy, r->cx+pp, r->y+r->h, gdStyled);
1312                                            sign *= -1;
1313                                    }
1314                                    draw_rev(im, r);
1315                                    yy = r->y;
1316                            }
1317                            if(conf.branch_dupbox)
1318                          {                          {
1319                                  int pp = (l+1)/2*sign;                                  i = b->y - b->th + b->h;
1320                                  gdImageLine(im, r->cx+pp, yy, r->cx+pp, r->y, gdStyled);                                  gdImageLine(im, b->cx, yy, b->cx, i, conf.rev_color.id);
1321                                  sign *= -1;                                  for(sign = l = 1; l < conf.thick_lines; l++)
1322                                    {
1323                                            int pp = (l+1)/2*sign;
1324                                            gdImageLine(im, b->cx+pp, yy, b->cx+pp, i, conf.rev_color.id);
1325                                            sign *= -1;
1326                                    }
1327                                    draw_branch_box(im, b, 0, i);
1328                          }                          }
                         draw_rev(im, r);  
                         yy = r->y + r->h;  
1329                  }                  }
1330                  if(conf.branch_dupbox)                  else
1331                  {                  {
1332                          i = b->y + b->th - b->h;                          yy = b->y + b->h;
1333                          gdImageLine(im, b->cx, yy, b->cx, i, conf.rev_color.id);                          for(i = 0; i < b->nrevs; i++)
1334                          for(sign = l = 1; l < conf.thick_lines; l++)                          {
1335                          {                                  revision_t *r = b->revs[i];
1336                                  int pp = (l+1)/2*sign;                                  gdImageSetStyle(im, line, r->stripped ? 4 : 1);
1337                                  gdImageLine(im, b->cx+pp, yy, b->cx+pp, i, conf.rev_color.id);                                  gdImageLine(im, r->cx, yy, r->cx, r->y, gdStyled);
1338                                  sign *= -1;                                  for(sign = l = 1; l < conf.thick_lines; l++)
1339                                    {
1340                                            int pp = (l+1)/2*sign;
1341                                            gdImageLine(im, r->cx+pp, yy, r->cx+pp, r->y, gdStyled);
1342                                            sign *= -1;
1343                                    }
1344                                    draw_rev(im, r);
1345                                    yy = r->y + r->h;
1346                            }
1347                            if(conf.branch_dupbox)
1348                            {
1349                                    i = b->y + b->th - b->h;
1350                                    gdImageLine(im, b->cx, yy, b->cx, i, conf.rev_color.id);
1351                                    for(sign = l = 1; l < conf.thick_lines; l++)
1352                                    {
1353                                            int pp = (l+1)/2*sign;
1354                                            gdImageLine(im, b->cx+pp, yy, b->cx+pp, i, conf.rev_color.id);
1355                                            sign *= -1;
1356                                    }
1357                                    draw_branch_box(im, b, 0, i);
1358                          }                          }
                         draw_branch_box(im, b, i);  
1359                  }                  }
1360          }          }
1361  }  }
# Line 1174  Line 1369 
1369          int y1 = r->y + r->h/2;          int y1 = r->y + r->h/2;
1370          int x2 = b->cx;          int x2 = b->cx;
1371          int y2 = b->y;          int y2 = b->y;
1372          if(conf.upside_down)  
1373                  y2 += b->h;          if(conf.left_right)
1374            {
1375                    x2 = r->cx + r->w/2;
1376                    y2 = r->y + r->h/2 + 3;
1377                    x1 = b->cx;
1378                    y1 = b->y;
1379                    if(conf.upside_down)
1380                            x1 += b->w;
1381            }
1382            else
1383            {
1384                    x1 = r->cx + r->w/2 + 2;
1385                    y1 = r->y + r->h/2;
1386                    x2 = b->cx;
1387                    y2 = b->y;
1388                    if(conf.upside_down)
1389                            y2 += b->h;
1390            }
1391          gdImageLine(im, x1, y1, x2, y1, conf.branch_color.id);          gdImageLine(im, x1, y1, x2, y1, conf.branch_color.id);
1392          gdImageLine(im, x2, y1, x2, y2, conf.branch_color.id);          gdImageLine(im, x2, y1, x2, y2, conf.branch_color.id);
1393          for(sign = l = 1; l < conf.thick_lines; l++)          for(sign = l = 1; l < conf.thick_lines; l++)
1394          {          {
1395                  int pp = (l+1)/2*sign;                  int pp = (l+1)/2*sign;
1396                  gdImageLine(im, x1, y1+pp, x2-pp, y1+pp, conf.branch_color.id);                  gdImageLine(im, x1, y1+pp, x2, y1+pp, conf.branch_color.id);
1397                  gdImageLine(im, x2+pp, y1-pp, x2+pp, y2, conf.branch_color.id);                  gdImageLine(im, x2+pp, y1, x2+pp, y2, conf.branch_color.id);
1398                  sign *= -1;                  sign *= -1;
1399          }          }
1400  }  }
# Line 1301  Line 1513 
1513          }          }
1514  }  }
1515    
1516    static void initial_reposition_branch_lr(revision_t *r, int *y, int *h)
1517    {
1518            int i, j;
1519            for(j = 0; j < r->nbranches; j++)
1520            {
1521                    branch_t *b = r->branches[j];
1522                    *y += *h + conf.rev_minline + b->th/2 - b->y;
1523                    *h = b->th/2;
1524                    move_branch(b, r->cx + r->w/2 + conf.branch_connect, *y);
1525                    *y = b->y;
1526                    /* Recurse to move branches of branched revisions */
1527                    for(i = b->nrevs-1; i >= 0; i--)
1528                    {
1529                            initial_reposition_branch(b->revs[i], y, h);
1530                    }
1531            }
1532    }
1533    
1534  static void rect_union(int *x, int *y, int *w, int *h, branch_t *b)  static void rect_union(int *x, int *y, int *w, int *h, branch_t *b)
1535  {  {
1536          int x1 = *x;          int x1 = *x;
1537          int x2 = x1 + *w;          int x2 = x1 + *w;
1538          int y1 = *y;          int y1 = *y;
1539          int y2 = y1 + *h;          int y2 = y1 + *h;
1540          int xx1 = b->cx - b->tw/2;          int xx1;
1541          int xx2 = xx1 + b->tw;          int xx2;
1542          int yy1 = b->y;          int yy1;
1543          int yy2 = yy1 + b->th;          int yy2;
1544    
1545            if(conf.left_right)
1546            {
1547                    xx1 = b->cx;
1548                    yy1 = b->y - b->th/2;
1549            }
1550            else
1551            {
1552                    xx1 = b->cx - b->tw/2;
1553                    yy1 = b->y;
1554            }
1555            xx2 = xx1 + b->tw;
1556            yy2 = yy1 + b->th;
1557    
1558          x1 = MIN(x1, xx1);          x1 = MIN(x1, xx1);
1559          x2 = MAX(x2, xx2);          x2 = MAX(x2, xx2);
1560          y1 = MIN(y1, yy1);          y1 = MIN(y1, yy1);
# Line 1329  Line 1573 
1573          return !(bt > bottom || bb < top || br >= left);          return !(bt > bottom || bb < top || br >= left);
1574  }  }
1575    
1576    static int branch_intersects_lr(int left, int right, int top, branch_t *b)
1577    {
1578            int bt = b->y + b->th/2;
1579            int bl = b->cx - conf.branch_connect - conf.branch_margin/2;
1580            int br = b->cx + b->tw + conf.branch_margin/2;
1581            return !(bl > right || br < left || bt >= top);
1582    }
1583    
1584  static int kern_branch(rcsfile_t *rcs, branch_t *b)  static int kern_branch(rcsfile_t *rcs, branch_t *b)
1585  {  {
1586          int left = b->cx - b->tw/2;          int left = b->cx - b->tw/2;
# Line 1357  Line 1609 
1609          return 0;          return 0;
1610  }  }
1611    
1612    static int kern_branch_lr(rcsfile_t *rcs, branch_t *b)
1613    {
1614            int top = b->y - b->th/2;
1615            int left = b->cx - conf.branch_connect - conf.branch_margin/2;
1616            int right = b->cx + b->tw + conf.branch_margin/2;
1617            int i;
1618            int ypos = 0;
1619    
1620            for(i = 0; i < rcs->nbranches; i++)
1621            {
1622                    branch_t *bp = rcs->branches[i];
1623                    if(bp == b)
1624                            continue;
1625                    if(branch_intersects_lr(left, right, top, bp))
1626                    {
1627                            int m = bp->y + bp->th/2 + conf.branch_margin;
1628                            if(m > ypos)
1629                                    ypos = m;
1630                    }
1631            }
1632            if(ypos && (b->y - b->th/2) - ypos > 0)
1633            {
1634                    move_branch(b, 0, ypos - (b->y - b->th/2));
1635                    return 1;
1636            }
1637            return 0;
1638    }
1639    
1640  static int kern_tree(rcsfile_t *rcs)  static int kern_tree(rcsfile_t *rcs)
1641  {  {
1642          int i;          int i;
# Line 1368  Line 1648 
1648                  moved = 0;                  moved = 0;
1649                  for(i = 1; i < rcs->nbranches; i++)                  for(i = 1; i < rcs->nbranches; i++)
1650                  {                  {
1651                          moved += kern_branch(rcs, rcs->branches[i]);                          if(conf.left_right)
1652                                    moved += kern_branch_lr(rcs, rcs->branches[i]);
1653                            else
1654                                    moved += kern_branch(rcs, rcs->branches[i]);
1655                  }                  }
1656                  totalmoved += moved;                  totalmoved += moved;
1657  #ifdef DEBUG  #ifdef DEBUG
# Line 1455  Line 1738 
1738  {  {
1739          int i, j;          int i, j;
1740  #ifdef DEBUG  #ifdef DEBUG
1741  //      fprintf(stderr, "move_yr_branch: b=%s, dy=%d\n", b->branch->branch, dy);  /*      fprintf(stderr, "move_yr_branch: b=%s, dy=%d\n", b->branch->branch, dy);*/
1742  #endif  #endif
1743          b->y += dy;          b->y += dy;
1744          for(i = 0; i < b->nrevs; i++)          for(i = 0; i < b->nrevs; i++)
# Line 1464  Line 1747 
1747                  for(j = 0; j < b->revs[i]->nbranches; j++)                  for(j = 0; j < b->revs[i]->nbranches; j++)
1748                  {                  {
1749  #ifdef DEBUG  #ifdef DEBUG
1750  //                      fprintf(stderr, ".");  /*                      fprintf(stderr, ".");*/
1751  #endif  #endif
1752                          move_yr_branch(b->revs[i]->branches[j], dy);                          move_yr_branch(b->revs[i]->branches[j], dy);
1753                  }                  }
# Line 1747  Line 2030 
2030                                          i = 0 - 1;      /* -1 for the i++ of the loop */                                          i = 0 - 1;      /* -1 for the i++ of the loop */
2031                                          safeguard--;    /* Prevent infinite loop, just in case */                                          safeguard--;    /* Prevent infinite loop, just in case */
2032                                  }                                  }
2033                                  //return;                                  /*return;*/
2034                          }                          }
2035                  }                  }
2036          }          }
# Line 1823  Line 2106 
2106                  h += conf.branch_tspace + conf.branch_bspace;                  h += conf.branch_tspace + conf.branch_bspace;
2107                  bp->w = w;                  bp->w = w;
2108                  bp->h = h;                  bp->h = h;
2109                  for(j = 0; j < bp->nrevs; j++)                  if(conf.left_right)
2110                  {                  {
2111                          if(bp->revs[j]->w > w)                          for(j = 0; j < bp->nrevs; j++)
2112                                  w = bp->revs[j]->w;                          {
2113                          h += bp->revs[j]->h + conf.rev_minline;                                  if(bp->revs[j]->h > h)
2114                                            h = bp->revs[j]->h;
2115                                    w += bp->revs[j]->w + conf.rev_minline;
2116                            }
2117                            if(conf.branch_dupbox)
2118                                    w += bp->w + conf.rev_minline;
2119                    }
2120                    else
2121                    {
2122                            for(j = 0; j < bp->nrevs; j++)
2123                            {
2124                                    if(bp->revs[j]->w > w)
2125                                            w = bp->revs[j]->w;
2126                                    h += bp->revs[j]->h + conf.rev_minline;
2127                            }
2128                            if(conf.branch_dupbox)
2129                                    h += bp->h + conf.rev_minline;
2130                  }                  }
                 if(conf.branch_dupbox)  
                         h += bp->h + conf.rev_minline;  
2131                  bp->th = h;                  bp->th = h;
2132                  bp->tw = w;                  bp->tw = w;
2133          }          }
2134    
2135          /* Calculate the relative positions of revs in a branch */          /* Calculate the relative positions of revs in a branch */
2136          for(i = 0; i < rcs->nbranches; i++)          if(conf.left_right)
2137          {          {
2138                  branch_t *b = rcs->branches[i];                  for(i = 0; i < rcs->nbranches; i++)
2139                  x = b->tw/2;                  {
2140                  y = b->h;                          branch_t *b = rcs->branches[i];
2141                  b->cx = x;                          y = b->th/2;
2142                  b->y = 0;                          x = b->w;
2143                  for(j = 0; j < b->nrevs; j++)                          b->y = y;
2144                            b->cx = 0;
2145                            for(j = 0; j < b->nrevs; j++)
2146                            {
2147                                    x += conf.rev_minline;
2148                                    b->revs[j]->y = y;
2149                                    b->revs[j]->cx = x;
2150                                    x += b->revs[j]->w;
2151                            }
2152                    }
2153            }
2154            else
2155            {
2156                    for(i = 0; i < rcs->nbranches; i++)
2157                  {                  {
2158                          y += conf.rev_minline;                          branch_t *b = rcs->branches[i];
2159                          b->revs[j]->cx = x;                          x = b->tw/2;
2160                          b->revs[j]->y = y;                          y = b->h;
2161                          y += b->revs[j]->h;                          b->cx = x;
2162                            b->y = 0;
2163                            for(j = 0; j < b->nrevs; j++)
2164                            {
2165                                    y += conf.rev_minline;
2166                                    b->revs[j]->cx = x;
2167                                    b->revs[j]->y = y;
2168                                    y += b->revs[j]->h;
2169                            }
2170                  }                  }
2171          }          }
2172    
2173          /* Initially reposition the branches from bottom to top progressively right */          /* Initially reposition the branches from bottom to top progressively right */
2174          x = rcs->branches[0]->cx;          if(conf.left_right)
         w2 = rcs->branches[0]->tw / 2;  
         for(i = rcs->branches[0]->nrevs-1; i >= 0; i--)  
2175          {          {
2176                  initial_reposition_branch(rcs->branches[0]->revs[i], &x, &w2);                  x = rcs->branches[0]->y;
2177                    w2 = rcs->branches[0]->th / 2;
2178                    for(i = rcs->branches[0]->nrevs-1; i >= 0; i--)
2179                    {
2180                            initial_reposition_branch_lr(rcs->branches[0]->revs[i], &x, &w2);
2181                    }
2182            }
2183            else
2184            {
2185                    x = rcs->branches[0]->cx;
2186                    w2 = rcs->branches[0]->tw / 2;
2187                    for(i = rcs->branches[0]->nrevs-1; i >= 0; i--)
2188                    {
2189                            initial_reposition_branch(rcs->branches[0]->revs[i], &x, &w2);
2190                    }
2191          }          }
2192    
2193          /* Initially move branches left if there is room */          /* Initially move branches left if there is room */
2194          kern_tree(rcs);          kern_tree(rcs);
2195    
2196          /* Try to kern the branches more by expanding the inter-revision spacing */          /* Try to kern the branches more by expanding the inter-revision spacing */
2197          if(conf.auto_stretch)          if(conf.auto_stretch && !conf.left_right)
2198                  auto_stretch(rcs);                  auto_stretch(rcs);
2199    
2200          /* Move everything w.r.t. the top-left margin */          /* Move everything w.r.t. the top-left margin */
# Line 1872  Line 2202 
2202                  move_branch(rcs->branches[i], conf.margin_left, conf.margin_top);                  move_branch(rcs->branches[i], conf.margin_left, conf.margin_top);
2203    
2204          /* Calculate overall image size */          /* Calculate overall image size */
2205          x = rcs->branches[0]->cx - rcs->branches[0]->tw/2;          if(conf.left_right)
2206          y = rcs->branches[0]->y;          {
2207                    x = rcs->branches[0]->cx;
2208                    y = rcs->branches[0]->y - rcs->branches[0]->th/2;
2209            }
2210            else
2211            {
2212                    x = rcs->branches[0]->cx - rcs->branches[0]->tw/2;
2213                    y = rcs->branches[0]->y;
2214            }
2215          w = rcs->branches[0]->tw;          w = rcs->branches[0]->tw;
2216          h = rcs->branches[0]->th;          h = rcs->branches[0]->th;
2217          for(i = 1; i < rcs->nbranches; i++)          for(i = 1; i < rcs->nbranches; i++)
# Line 1884  Line 2222 
2222          /* Flip the entire tree */          /* Flip the entire tree */
2223          if(conf.upside_down)          if(conf.upside_down)
2224          {          {
2225                  y += rcs->th;                  if(conf.left_right)
                 for(i = 0; i < rcs->nbranches; i++)  
2226                  {                  {
2227                          branch_t *b = rcs->branches[i];                          x += rcs->tw;
2228                          for(j = 0; j < b->nrevs; j++)                          for(i = 0; i < rcs->nbranches; i++)
2229                            {
2230                                    branch_t *b = rcs->branches[i];
2231                                    for(j = 0; j < b->nrevs; j++)
2232                                    {
2233                                            revision_t *r = b->revs[j];
2234                                            r->cx = x - r->cx - r->w + conf.margin_left;
2235                                    }
2236                                    b->cx = x - b->cx - b->w + conf.margin_left;
2237                            }
2238                    }
2239                    else
2240                    {
2241                            y += rcs->th;
2242                            for(i = 0; i < rcs->nbranches; i++)
2243                          {                          {
2244                                  revision_t *r = b->revs[j];                                  branch_t *b = rcs->branches[i];
2245                                  r->y = y - r->y - r->h + conf.margin_top;                                  for(j = 0; j < b->nrevs; j++)
2246                                    {
2247                                            revision_t *r = b->revs[j];
2248                                            r->y = y - r->y - r->h + conf.margin_top;
2249                                    }
2250                                    b->y = y - b->y - b->h + conf.margin_top;
2251                          }                          }
                         b->y = y - b->y - b->h + conf.margin_top;  
2252                  }                  }
2253          }          }
2254  }  }
# Line 1903  Line 2258 
2258   * Imagemap functions   * Imagemap functions
2259   **************************************************************************   **************************************************************************
2260   */   */
2261  void make_imagemap(rcsfile_t *rcs, FILE *fp)  void make_imagemap(rcsfile_t *rcs, FILE *fp, gdImagePtr im)
2262  {  {
2263          int i, j;          int i, j;
2264          fprintf(fp, "<map name=\"%s\">\n", conf.map_name);          fprintf(fp, "<map name=\"%s\">\n", conf.map_name);
# Line 1913  Line 2268 
2268                  tag_t *tag = b->ntags ? b->tags[0] : NULL;                  tag_t *tag = b->ntags ? b->tags[0] : NULL;
2269                  char *bhref = expand_string(conf.map_branch_href, rcs, NULL, b->branch, NULL, tag);                  char *bhref = expand_string(conf.map_branch_href, rcs, NULL, b->branch, NULL, tag);
2270                  char *balt = expand_string(conf.map_branch_alt, rcs, NULL, b->branch, NULL, tag);                  char *balt = expand_string(conf.map_branch_alt, rcs, NULL, b->branch, NULL, tag);
2271                    int x1;
2272                    int x2;
2273                    int y1;
2274                    int y2;
2275    
2276                    if(conf.left_right)
2277                    {
2278                            x1 = b->cx;
2279                            y1 = b->y - b->h/2;
2280                            x2 = b->cx + b->w;
2281                            y2 = b->y + b->h/2;
2282                    }
2283                    else
2284                    {
2285                            x1 = b->cx - b->w/2;
2286                            y1 = b->y;
2287                            x2 = b->cx + b->w/2;
2288                            y2 = b->y + b->h;
2289                    }
2290                  fprintf(fp, "\t<area shape=\"rect\" %s coords=\"%d,%d,%d,%d\" %s>\n",                  fprintf(fp, "\t<area shape=\"rect\" %s coords=\"%d,%d,%d,%d\" %s>\n",
2291                                  bhref,                                  bhref, x1, y1, x2, y2, balt);
2292                                  b->cx - b->w/2, b->y, b->cx + b->w/2, b->y + b->h,                  if(im)
2293                                  balt);                  {
2294                            gdImageFilledRectangle(im, x1-2, y1-2, x1+2, y1+2, conf.title_color.id);
2295                            gdImageFilledRectangle(im, x2-2, y2-2, x2+2, y2+2, conf.tag_color.id);
2296                            gdImageLine(im, x1, y1, x2, y2, conf.title_color.id);
2297                    }
2298                  for(j = 0; j < b->nrevs; j++)                  for(j = 0; j < b->nrevs; j++)
2299                  {                  {
2300                          revision_t *r = b->revs[j];                          revision_t *r = b->revs[j];
2301                          revision_t* r1;                          revision_t* r1;
2302                          int xoff;                          int xoff = 1;
2303                          int x1;                          int yoff = 1;
                         int x2;  
                         int y1;  
                         int y2;  
2304                          char *href;                          char *href;
2305                          char *alt;                          char *alt;
2306    
2307                          tag = r->ntags ? r->tags[0] : NULL;                          tag = r->ntags ? r->tags[0] : NULL;
2308                          href = expand_string(conf.map_rev_href, rcs, r, r->rev, NULL, tag);                          href = expand_string(conf.map_rev_href, rcs, r, r->rev, NULL, tag);
2309                          alt = expand_string(conf.map_rev_alt, rcs, r, r->rev, NULL, tag);                          alt = expand_string(conf.map_rev_alt, rcs, r, r->rev, NULL, tag);
2310                            if(conf.left_right)
2311                            {
2312                                    x1 = r->cx;
2313                                    y1 = r->y - r->h/2;
2314                                    x2 = r->cx + r->w;
2315                                    y2 = r->y + r->h/2;
2316                            }
2317                            else
2318                            {
2319                                    x1 = r->cx - r->w/2;
2320                                    y1 = r->y;
2321                                    x2 = r->cx + r->w/2;
2322                                    y2 = r->y + r->h;
2323                            }
2324                          fprintf(fp, "\t<area shape=\"rect\" %s coords=\"%d,%d,%d,%d\" %s>\n",                          fprintf(fp, "\t<area shape=\"rect\" %s coords=\"%d,%d,%d,%d\" %s>\n",
2325                                  href,                                  href, x1, y1, x2, y2, alt);
2326                                  r->cx - r->w/2, r->y, r->cx + r->w/2, r->y + r->h,                          if(im)
2327                                  alt);                          {
2328                                    gdImageFilledRectangle(im, x1-2, y1-2, x1+2, y1+2, conf.title_color.id);
2329                                    gdImageFilledRectangle(im, x2-2, y2-2, x2+2, y2+2, conf.tag_color.id);
2330                                    gdImageLine(im, x1, y1, x2, y2, conf.title_color.id);
2331                            }
2332                          xfree(href);                          xfree(href);
2333                          xfree(alt);                          xfree(alt);
2334                          if(j > 0 || b->branchpoint)                          if(j > 0 || b->branchpoint)
# Line 1943  Line 2336 
2336                                  if(j > 0)                                  if(j > 0)
2337                                  {                                  {
2338                                          r1 = b->revs[j-1];                                          r1 = b->revs[j-1];
2339                                          xoff = MIN(r->w, r1->w)/4;                                          if(conf.left_right)
2340                                          y1 = conf.upside_down ? r1->y : r1->y + r1->h;                                          {
2341                                                    yoff = MIN(r->h, r1->h)/4;
2342                                                    x1 = conf.upside_down ? r1->cx : r1->cx + r1->w;
2343                                            }
2344                                            else
2345                                            {
2346                                                    xoff = MIN(r->w, r1->w)/4;
2347                                                    y1 = conf.upside_down ? r1->y : r1->y + r1->h;
2348                                            }
2349                                  }                                  }
2350                                  else                                  else
2351                                  {                                  {
2352                                          r1 = b->branchpoint;                                          r1 = b->branchpoint;
2353                                          xoff = MIN(r->w, b->w)/4;                                          if(conf.left_right)
2354                                          y1 = conf.upside_down ? b->y : b->y + b->h;                                          {
2355                                                    yoff = MIN(r->h, b->h)/4;
2356                                                    x1 = conf.upside_down ? b->cx : b->cx + b->w;
2357                                            }
2358                                            else
2359                                            {
2360                                                    xoff = MIN(r->w, b->w)/4;
2361                                                    y1 = conf.upside_down ? b->y : b->y + b->h;
2362                                            }
2363                                    }
2364                                    if(conf.left_right)
2365                                    {
2366                                            y1 = r->y - yoff;
2367                                            y2 = r->y + yoff;
2368                                            x2 = conf.upside_down ? r->cx + r->w : r->cx;
2369                                            yoff = 0;
2370                                    }
2371                                    else
2372                                    {
2373                                            x1 = r->cx - xoff;
2374                                            x2 = r->cx + xoff;
2375                                            y2 = conf.upside_down ? r->y + r->h : r->y;
2376                                            xoff = 0;
2377                                    }
2378                                    if(x1 > x2)
2379                                    {
2380                                            int tt = x1;
2381                                            x1 = x2;
2382                                            x2 = tt;
2383                                    }
2384                                    if(y1 > y2)
2385                                    {
2386                                            int tt = y1;
2387                                            y1 = y2;
2388                                            y2 = tt;
2389                                  }                                  }
                                 x1 = r->cx - xoff;  
                                 x2 = r->cx + xoff;  
                                 y2 = conf.upside_down ? r->y + r->h : r->y;  
2390                                  href = expand_string(conf.map_diff_href, rcs, r, r->rev, r1->rev, tag);                                  href = expand_string(conf.map_diff_href, rcs, r, r->rev, r1->rev, tag);
2391                                  alt = expand_string(conf.map_diff_alt, rcs, r, r->rev, r1->rev, tag);                                  alt = expand_string(conf.map_diff_alt, rcs, r, r->rev, r1->rev, tag);
2392                                  fprintf(fp, "\t<area shape=\"rect\" %s coords=\"%d,%d,%d,%d\" %s>\n",                                  fprintf(fp, "\t<area shape=\"rect\" %s coords=\"%d,%d,%d,%d\" %s>\n",
2393                                          href,                                          href,
2394                                          x1, y1 + 1, x2, y2 - 1,                                          x1+xoff, y1+yoff, x2-xoff, y2-yoff,
2395                                          alt);                                          alt);
2396                                    if(im)
2397                                    {
2398                                            gdImageFilledRectangle(im, x1-2, y1-2, x1+2, y1+2, conf.title_color.id);
2399                                            gdImageFilledRectangle(im, x2-2, y2-2, x2+2, y2+2, conf.tag_color.id);
2400                                            gdImageLine(im, x1, y1, x2, y2, conf.title_color.id);
2401                                    }
2402                                  xfree(href);                                  xfree(href);
2403                                  xfree(alt);                                  xfree(alt);
2404                          }                          }
2405                  }                  }
2406                  if(conf.branch_dupbox)                  if(conf.branch_dupbox)
2407                  {                  {
2408                          int y;                          if(conf.left_right)
2409                          if(conf.upside_down)                          {
2410                                  y = b->y + b->h - b->th;                                  x1 = conf.upside_down ? b->cx + b->w - b->tw : b->cx - b->w + b->tw;
2411                                    y1 = b->y - b->h/2;
2412                                    x2 = x1 + b->w;
2413                                    y2 = b->y + b->h/2;
2414                            }
2415                          else                          else
2416                                  y = b->y - b->h + b->th;                          {
2417                                    x1 = b->cx - b->w/2;
2418                                    y1 = conf.upside_down ? b->y + b->h - b->th : b->y - b->h + b->th;
2419                                    x2 = b->cx + b->w/2;
2420                                    y2 = y1 + b->h;
2421                            }
2422                          fprintf(fp, "\t<area shape=\"rect\" %s coords=\"%d,%d,%d,%d\" %s>\n",                          fprintf(fp, "\t<area shape=\"rect\" %s coords=\"%d,%d,%d,%d\" %s>\n",
2423                                          bhref,                                          bhref, x1, y1, x2, y2, balt);
2424                                          b->cx - b->w/2, y, b->cx + b->w/2, y + b->h,                          if(im)
2425                                          balt);                          {
2426                                    gdImageFilledRectangle(im, x1-2, y1-2, x1+2, y1+2, conf.title_color.id);
2427                                    gdImageFilledRectangle(im, x2-2, y2-2, x2+2, y2+2, conf.tag_color.id);
2428                                    gdImageLine(im, x1, y1, x2, y2, conf.title_color.id);
2429                            }
2430                  }                  }
2431                  xfree(bhref);                  xfree(bhref);
2432                  xfree(balt);                  xfree(balt);
# Line 2010  Line 2461 
2461          "  -[0-9] <txt> Use <txt> for expansion\n"          "  -[0-9] <txt> Use <txt> for expansion\n"
2462          ;          ;
2463    
2464  #define VERSION_STR     "1.2.0"  #define VERSION_STR     "1.3.0"
2465  #define NOTICE_STR      "Copyright (c) 2001,2002 B.Stultiens"  #define NOTICE_STR      "Copyright (c) 2001,2002 B.Stultiens"
2466    
2467  static void append_slash(char **path)  static void append_slash(char **path)
# Line 2248  Line 2699 
2699          {          {
2700                  /* Create an image */                  /* Create an image */
2701                  im = make_image(rcs);                  im = make_image(rcs);
2702    #ifdef DEBUG_IMAGEMAP
2703                    {
2704                            FILE *nulfile = fopen("/dev/null", "w");
2705                            make_imagemap(rcs, nulfile, im);
2706                            fclose(nulfile);
2707                    }
2708    #endif
2709                  switch(conf.image_type)                  switch(conf.image_type)
2710                  {                  {
2711  #ifdef HAVE_IMAGE_GIF  #ifdef HAVE_IMAGE_GIF
# Line 2280  Line 2737 
2737          else          else
2738          {          {
2739                  /* Create an imagemap */                  /* Create an imagemap */
2740                  make_imagemap(rcs, fp);                  make_imagemap(rcs, fp, NULL);
2741          }          }
2742    
2743          /* Also create imagemap to file if requested */          /* Also create imagemap to file if requested */
# Line 2292  Line 2749 
2749                          perror(imgmapfile);                          perror(imgmapfile);
2750                          return 1;                          return 1;
2751                  }                  }
2752                  make_imagemap(rcs, ifp);                  make_imagemap(rcs, ifp, NULL);
2753                  fclose(ifp);                  fclose(ifp);
2754          }          }
2755    

Legend:
Removed from v.1.21  
changed lines
  Added in v.1.28

  ViewVC Help
Powered by ViewVC 1.1.0 with CvsGraph 1.7.0