/[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.24, Thu Jul 18 12:07:11 2002 UTC revision 1.25, Thu Jul 18 15:26:34 2002 UTC
# Line 1142  Line 1142 
1142    
1143  static void draw_rev(gdImagePtr im, revision_t *r)  static void draw_rev(gdImagePtr im, revision_t *r)
1144  {  {
1145          int lx = r->cx - r->w/2;          int lx;
1146          int rx = lx + r->w;          int rx;
1147            int x2;
1148          int i;          int i;
1149          int ty = r->y;          int ty;
1150    
1151            if(conf.left_right)
1152            {
1153                    lx = r->cx;
1154                    rx = r->cx + r->w;
1155                    ty = r->y - r->h/2;
1156                    x2 = r->cx + r->w/2;
1157            }
1158            else
1159            {
1160                    lx = r->cx - r->w/2;
1161                    rx = lx + r->w;
1162                    ty = r->y;
1163                    x2 = r->cx;
1164            }
1165          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);
1166          ty += conf.rev_tspace;          ty += conf.rev_tspace;
1167          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);
1168          ty += get_sheight(r->rev->rev, &conf.rev_font);          ty += get_sheight(r->rev->rev, &conf.rev_font);
1169          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);
1170          ty += get_sheight(r->revtext, &conf.rev_text_font);          ty += get_sheight(r->revtext, &conf.rev_text_font);
1171          for(i = 0; i < r->ntags; i++)          for(i = 0; i < r->ntags; i++)
1172          {          {
1173                  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);
1174                  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;
1175          }          }
1176  }  }
1177    
1178  static void draw_branch_box(gdImagePtr im, branch_t *b, int ypos)  static void draw_branch_box(gdImagePtr im, branch_t *b, int ypos)
1179  {  {
1180          int lx = b->cx - b->w/2;          int lx;
1181          int rx = lx + b->w;          int rx;
1182          int i;          int i;
1183          int yy;          int yy;
1184            int x2;
1185    
1186            if(conf.left_right)
1187            {
1188                    lx = b->cx;
1189                    rx = lx + b->w;
1190                    x2 = b->cx + b->w/2;
1191            }
1192            else
1193            {
1194                    lx = b->cx - b->w/2;
1195                    rx = lx + b->w;
1196                    x2 = b->cx;
1197            }
1198          draw_rbox(im, lx, ypos, rx, ypos+b->h, 5, &conf.branch_color, &conf.branch_bgcolor);          draw_rbox(im, lx, ypos, rx, ypos+b->h, 5, &conf.branch_color, &conf.branch_bgcolor);
1199          yy = conf.branch_tspace;          yy = conf.branch_tspace;
1200          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, ypos+yy, ALIGN_HC, &conf.branch_color);
1201          yy += get_sheight(b->branch->branch, &conf.branch_font);          yy += get_sheight(b->branch->branch, &conf.branch_font);
1202          for(i = 0; i < b->ntags; i++)          for(i = 0; i < b->ntags; i++)
1203          {          {
1204                  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, ypos+yy, ALIGN_HC, &conf.branch_tag_color);
1205                  yy += get_sheight(b->tags[i]->tag, &conf.branch_font);                  yy += get_sheight(b->tags[i]->tag, &conf.branch_font);
1206          }          }
1207  }  }
1208    
1209  static void draw_branch(gdImagePtr im, branch_t *b)  static void draw_branch(gdImagePtr im, branch_t *b)
1210  {  {
1211          int yy;          int yy, xx;
1212          int i;          int i;
1213          int line[4];          int line[4];
1214          int l;          int l;
# Line 1190  Line 1219 
1219          line[1] = gdTransparent;          line[1] = gdTransparent;
1220          line[3] = conf.rev_color.id;          line[3] = conf.rev_color.id;
1221    
1222          draw_branch_box(im, b, b->y);          draw_branch_box(im, b, conf.left_right ? b->y - b->h/2 : b->y);
1223    
1224          if(conf.upside_down)          if(conf.left_right)
1225          {          {
1226                  yy = b->y;                  if(conf.upside_down)
                 for(i = 0; i < b->nrevs; i++)  
1227                  {                  {
1228                          revision_t *r = b->revs[i];                          xx = b->cx;
1229                          gdImageSetStyle(im, line, r->stripped ? 4 : 1);                          for(i = 0; i < b->nrevs; i++)
1230                          gdImageLine(im, r->cx, yy, r->cx, r->y+r->h, gdStyled);                          {
1231                          for(sign = l = 1; l < conf.thick_lines; l++)                                  revision_t *r = b->revs[i];
1232                          {                                  gdImageSetStyle(im, line, r->stripped ? 4 : 1);
1233                                  int pp = (l+1)/2*sign;                                  gdImageLine(im, xx, r->y, r->cx+r->w, r->y, gdStyled);
1234                                  gdImageLine(im, r->cx+pp, yy, r->cx+pp, r->y+r->h, gdStyled);                                  for(sign = l = 1; l < conf.thick_lines; l++)
1235                                  sign *= -1;                                  {
1236                                            int pp = (l+1)/2*sign;
1237                                            gdImageLine(im, xx, r->y+pp, r->cx+r->w, r->y+pp, gdStyled);
1238                                            sign *= -1;
1239                                    }
1240                                    draw_rev(im, r);
1241                                    xx = r->cx;
1242                            }
1243                            if(conf.branch_dupbox)
1244                            {
1245                                    i = b->cx - b->tw + b->w;
1246                                    gdImageLine(im, xx, b->y, i, b->y, conf.rev_color.id);
1247                                    for(sign = l = 1; l < conf.thick_lines; l++)
1248                                    {
1249                                            int pp = (l+1)/2*sign;
1250                                            gdImageLine(im, xx, b->y+pp, i, b->y+pp, conf.rev_color.id);
1251                                            sign *= -1;
1252                                    }
1253                                    draw_branch_box(im, b, i);
1254                          }                          }
                         draw_rev(im, r);  
                         yy = r->y;  
1255                  }                  }
1256                  if(conf.branch_dupbox)                  else
1257                  {                  {
1258                          i = b->y - b->th + b->h;                          xx = b->cx + b->w;
1259                          gdImageLine(im, b->cx, yy, b->cx, i, conf.rev_color.id);                          for(i = 0; i < b->nrevs; i++)
1260                          for(sign = l = 1; l < conf.thick_lines; l++)                          {
1261                          {                                  revision_t *r = b->revs[i];
1262                                  int pp = (l+1)/2*sign;                                  gdImageSetStyle(im, line, r->stripped ? 4 : 1);
1263                                  gdImageLine(im, b->cx+pp, yy, b->cx+pp, i, conf.rev_color.id);                                  gdImageLine(im, xx, r->y, r->cx, r->y, gdStyled);
1264                                  sign *= -1;                                  for(sign = l = 1; l < conf.thick_lines; l++)
1265                                    {
1266                                            int pp = (l+1)/2*sign;
1267                                            gdImageLine(im, xx, r->y+pp, r->cx, r->y+pp, gdStyled);
1268                                            sign *= -1;
1269                                    }
1270                                    draw_rev(im, r);
1271                                    xx = r->cx + r->w;
1272                            }
1273                            if(conf.branch_dupbox)
1274                            {
1275                                    i = b->cx + b->tw - b->w;
1276                                    gdImageLine(im, xx, b->y, i, b->y, conf.rev_color.id);
1277                                    for(sign = l = 1; l < conf.thick_lines; l++)
1278                                    {
1279                                            int pp = (l+1)/2*sign;
1280                                            gdImageLine(im, xx, b->y+pp, i, b->y+pp, conf.rev_color.id);
1281                                            sign *= -1;
1282                                    }
1283                                    draw_branch_box(im, b, i);
1284                          }                          }
                         draw_branch_box(im, b, i);  
1285                  }                  }
1286          }          }
1287          else          else
1288          {          {
1289                  yy = b->y + b->h;                  if(conf.upside_down)
                 for(i = 0; i < b->nrevs; i++)  
1290                  {                  {
1291                          revision_t *r = b->revs[i];                          yy = b->y;
1292                          gdImageSetStyle(im, line, r->stripped ? 4 : 1);                          for(i = 0; i < b->nrevs; i++)
1293                          gdImageLine(im, r->cx, yy, r->cx, r->y, gdStyled);                          {
1294                          for(sign = l = 1; l < conf.thick_lines; l++)                                  revision_t *r = b->revs[i];
1295                          {                                  gdImageSetStyle(im, line, r->stripped ? 4 : 1);
1296                                  int pp = (l+1)/2*sign;                                  gdImageLine(im, r->cx, yy, r->cx, r->y+r->h, gdStyled);
1297                                  gdImageLine(im, r->cx+pp, yy, r->cx+pp, r->y, gdStyled);                                  for(sign = l = 1; l < conf.thick_lines; l++)
1298                                  sign *= -1;                                  {
1299                                            int pp = (l+1)/2*sign;
1300                                            gdImageLine(im, r->cx+pp, yy, r->cx+pp, r->y+r->h, gdStyled);
1301                                            sign *= -1;
1302                                    }
1303                                    draw_rev(im, r);
1304                                    yy = r->y;
1305                            }
1306                            if(conf.branch_dupbox)
1307                            {
1308                                    i = b->y - b->th + b->h;
1309                                    gdImageLine(im, b->cx, yy, b->cx, i, conf.rev_color.id);
1310                                    for(sign = l = 1; l < conf.thick_lines; l++)
1311                                    {
1312                                            int pp = (l+1)/2*sign;
1313                                            gdImageLine(im, b->cx+pp, yy, b->cx+pp, i, conf.rev_color.id);
1314                                            sign *= -1;
1315                                    }
1316                                    draw_branch_box(im, b, i);
1317                          }                          }
                         draw_rev(im, r);  
                         yy = r->y + r->h;  
1318                  }                  }
1319                  if(conf.branch_dupbox)                  else
1320                  {                  {
1321                          i = b->y + b->th - b->h;                          yy = b->y + b->h;
1322                          gdImageLine(im, b->cx, yy, b->cx, i, conf.rev_color.id);                          for(i = 0; i < b->nrevs; i++)
1323                          for(sign = l = 1; l < conf.thick_lines; l++)                          {
1324                          {                                  revision_t *r = b->revs[i];
1325                                  int pp = (l+1)/2*sign;                                  gdImageSetStyle(im, line, r->stripped ? 4 : 1);
1326                                  gdImageLine(im, b->cx+pp, yy, b->cx+pp, i, conf.rev_color.id);                                  gdImageLine(im, r->cx, yy, r->cx, r->y, gdStyled);
1327                                  sign *= -1;                                  for(sign = l = 1; l < conf.thick_lines; l++)
1328                                    {
1329                                            int pp = (l+1)/2*sign;
1330                                            gdImageLine(im, r->cx+pp, yy, r->cx+pp, r->y, gdStyled);
1331                                            sign *= -1;
1332                                    }
1333                                    draw_rev(im, r);
1334                                    yy = r->y + r->h;
1335                            }
1336                            if(conf.branch_dupbox)
1337                            {
1338                                    i = b->y + b->th - b->h;
1339                                    gdImageLine(im, b->cx, yy, b->cx, i, conf.rev_color.id);
1340                                    for(sign = l = 1; l < conf.thick_lines; l++)
1341                                    {
1342                                            int pp = (l+1)/2*sign;
1343                                            gdImageLine(im, b->cx+pp, yy, b->cx+pp, i, conf.rev_color.id);
1344                                            sign *= -1;
1345                                    }
1346                                    draw_branch_box(im, b, i);
1347                          }                          }
                         draw_branch_box(im, b, i);  
1348                  }                  }
1349          }          }
1350  }  }
# Line 1263  Line 1358 
1358          int y1 = r->y + r->h/2;          int y1 = r->y + r->h/2;
1359          int x2 = b->cx;          int x2 = b->cx;
1360          int y2 = b->y;          int y2 = b->y;
1361          if(conf.upside_down)  
1362                  y2 += b->h;          if(conf.left_right)
1363            {
1364                    x2 = r->cx + r->w/2;
1365                    y2 = r->y + r->h/2 + 2;
1366                    x1 = b->cx;
1367                    y1 = b->y;
1368                    if(conf.upside_down)
1369                            x1 += b->w;
1370            }
1371            else
1372            {
1373                    x1 = r->cx + r->w/2 + 2;
1374                    y1 = r->y + r->h/2;
1375                    x2 = b->cx;
1376                    y2 = b->y;
1377                    if(conf.upside_down)
1378                            y2 += b->h;
1379            }
1380          gdImageLine(im, x1, y1, x2, y1, conf.branch_color.id);          gdImageLine(im, x1, y1, x2, y1, conf.branch_color.id);
1381          gdImageLine(im, x2, y1, x2, y2, conf.branch_color.id);          gdImageLine(im, x2, y1, x2, y2, conf.branch_color.id);
1382          for(sign = l = 1; l < conf.thick_lines; l++)          for(sign = l = 1; l < conf.thick_lines; l++)
# Line 1390  Line 1502 
1502          }          }
1503  }  }
1504    
1505    static void initial_reposition_branch_lr(revision_t *r, int *y, int *h)
1506    {
1507            int i, j;
1508            for(j = 0; j < r->nbranches; j++)
1509            {
1510                    branch_t *b = r->branches[j];
1511                    *y += *h + conf.rev_minline + b->th/2 - b->y;
1512                    *h = b->th/2;
1513                    move_branch(b, r->cx + r->w/2 + conf.branch_connect, *y);
1514                    *y = b->y;
1515                    /* Recurse to move branches of branched revisions */
1516                    for(i = b->nrevs-1; i >= 0; i--)
1517                    {
1518                            initial_reposition_branch(b->revs[i], y, h);
1519                    }
1520            }
1521    }
1522    
1523  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)
1524  {  {
1525          int x1 = *x;          int x1 = *x;
1526          int x2 = x1 + *w;          int x2 = x1 + *w;
1527          int y1 = *y;          int y1 = *y;
1528          int y2 = y1 + *h;          int y2 = y1 + *h;
1529          int xx1 = b->cx - b->tw/2;          int xx1;
1530          int xx2 = xx1 + b->tw;          int xx2;
1531          int yy1 = b->y;          int yy1;
1532          int yy2 = yy1 + b->th;          int yy2;
1533    
1534            if(conf.left_right)
1535            {
1536                    xx1 = b->cx;
1537                    yy1 = b->y - b->th/2;
1538            }
1539            else
1540            {
1541                    xx1 = b->cx - b->tw/2;
1542                    yy1 = b->y;
1543            }
1544            xx2 = xx1 + b->tw;
1545            yy2 = yy1 + b->th;
1546    
1547          x1 = MIN(x1, xx1);          x1 = MIN(x1, xx1);
1548          x2 = MAX(x2, xx2);          x2 = MAX(x2, xx2);
1549          y1 = MIN(y1, yy1);          y1 = MIN(y1, yy1);
# Line 1418  Line 1562 
1562          return !(bt > bottom || bb < top || br >= left);          return !(bt > bottom || bb < top || br >= left);
1563  }  }
1564    
1565    static int branch_intersects_lr(int left, int right, int top, branch_t *b)
1566    {
1567            int bt = b->y + b->th/2;
1568            int bl = b->cx - conf.branch_connect - conf.branch_margin/2;
1569            int br = b->cx + b->tw + conf.branch_margin/2;
1570            return !(bl > right || br < left || bt >= top);
1571    }
1572    
1573  static int kern_branch(rcsfile_t *rcs, branch_t *b)  static int kern_branch(rcsfile_t *rcs, branch_t *b)
1574  {  {
1575          int left = b->cx - b->tw/2;          int left = b->cx - b->tw/2;
# Line 1446  Line 1598 
1598          return 0;          return 0;
1599  }  }
1600    
1601    static int kern_branch_lr(rcsfile_t *rcs, branch_t *b)
1602    {
1603            int top = b->y - b->th/2;
1604            int left = b->cx - conf.branch_connect - conf.branch_margin/2;
1605            int right = b->cx + b->tw + conf.branch_margin/2;
1606            int i;
1607            int ypos = 0;
1608    
1609            for(i = 0; i < rcs->nbranches; i++)
1610            {
1611                    branch_t *bp = rcs->branches[i];
1612                    if(bp == b)
1613                            continue;
1614                    if(branch_intersects_lr(left, right, top, bp))
1615                    {
1616                            int m = bp->y + bp->th/2 + conf.branch_margin;
1617                            if(m > ypos)
1618                                    ypos = m;
1619                    }
1620            }
1621            if(ypos && (b->y - b->th/2) - ypos > 0)
1622            {
1623                    move_branch(b, 0, ypos - (b->y - b->th/2));
1624                    return 1;
1625            }
1626            return 0;
1627    }
1628    
1629  static int kern_tree(rcsfile_t *rcs)  static int kern_tree(rcsfile_t *rcs)
1630  {  {
1631          int i;          int i;
# Line 1457  Line 1637 
1637                  moved = 0;                  moved = 0;
1638                  for(i = 1; i < rcs->nbranches; i++)                  for(i = 1; i < rcs->nbranches; i++)
1639                  {                  {
1640                          moved += kern_branch(rcs, rcs->branches[i]);                          if(conf.left_right)
1641                                    moved += kern_branch_lr(rcs, rcs->branches[i]);
1642                            else
1643                                    moved += kern_branch(rcs, rcs->branches[i]);
1644                  }                  }
1645                  totalmoved += moved;                  totalmoved += moved;
1646  #ifdef DEBUG  #ifdef DEBUG
# Line 1912  Line 2095 
2095                  h += conf.branch_tspace + conf.branch_bspace;                  h += conf.branch_tspace + conf.branch_bspace;
2096                  bp->w = w;                  bp->w = w;
2097                  bp->h = h;                  bp->h = h;
2098                  for(j = 0; j < bp->nrevs; j++)                  if(conf.left_right)
2099                  {                  {
2100                          if(bp->revs[j]->w > w)                          for(j = 0; j < bp->nrevs; j++)
2101                                  w = bp->revs[j]->w;                          {
2102                          h += bp->revs[j]->h + conf.rev_minline;                                  if(bp->revs[j]->h > h)
2103                                            h = bp->revs[j]->h;
2104                                    w += bp->revs[j]->w + conf.rev_minline;
2105                            }
2106                            if(conf.branch_dupbox)
2107                                    w += bp->w + conf.rev_minline;
2108                    }
2109                    else
2110                    {
2111                            for(j = 0; j < bp->nrevs; j++)
2112                            {
2113                                    if(bp->revs[j]->w > w)
2114                                            w = bp->revs[j]->w;
2115                                    h += bp->revs[j]->h + conf.rev_minline;
2116                            }
2117                            if(conf.branch_dupbox)
2118                                    h += bp->h + conf.rev_minline;
2119                  }                  }
                 if(conf.branch_dupbox)  
                         h += bp->h + conf.rev_minline;  
2120                  bp->th = h;                  bp->th = h;
2121                  bp->tw = w;                  bp->tw = w;
2122          }          }
2123    
2124          /* Calculate the relative positions of revs in a branch */          /* Calculate the relative positions of revs in a branch */
2125          for(i = 0; i < rcs->nbranches; i++)          if(conf.left_right)
2126          {          {
2127                  branch_t *b = rcs->branches[i];                  for(i = 0; i < rcs->nbranches; i++)
                 x = b->tw/2;  
                 y = b->h;  
                 b->cx = x;  
                 b->y = 0;  
                 for(j = 0; j < b->nrevs; j++)  
2128                  {                  {
2129                          y += conf.rev_minline;                          branch_t *b = rcs->branches[i];
2130                          b->revs[j]->cx = x;                          y = b->th/2;
2131                          b->revs[j]->y = y;                          x = b->w;
2132                          y += b->revs[j]->h;                          b->y = y;
2133                            b->cx = 0;
2134                            for(j = 0; j < b->nrevs; j++)
2135                            {
2136                                    x += conf.rev_minline;
2137                                    b->revs[j]->y = y;
2138                                    b->revs[j]->cx = x;
2139                                    x += b->revs[j]->w;
2140                            }
2141                    }
2142            }
2143            else
2144            {
2145                    for(i = 0; i < rcs->nbranches; i++)
2146                    {
2147                            branch_t *b = rcs->branches[i];
2148                            x = b->tw/2;
2149                            y = b->h;
2150                            b->cx = x;
2151                            b->y = 0;
2152                            for(j = 0; j < b->nrevs; j++)
2153                            {
2154                                    y += conf.rev_minline;
2155                                    b->revs[j]->cx = x;
2156                                    b->revs[j]->y = y;
2157                                    y += b->revs[j]->h;
2158                            }
2159                  }                  }
2160          }          }
2161    
2162          /* Initially reposition the branches from bottom to top progressively right */          /* Initially reposition the branches from bottom to top progressively right */
2163          x = rcs->branches[0]->cx;          if(conf.left_right)
2164          w2 = rcs->branches[0]->tw / 2;          {
2165          for(i = rcs->branches[0]->nrevs-1; i >= 0; i--)                  x = rcs->branches[0]->y;
2166                    w2 = rcs->branches[0]->th / 2;
2167                    for(i = rcs->branches[0]->nrevs-1; i >= 0; i--)
2168                    {
2169                            initial_reposition_branch_lr(rcs->branches[0]->revs[i], &x, &w2);
2170                    }
2171            }
2172            else
2173          {          {
2174                  initial_reposition_branch(rcs->branches[0]->revs[i], &x, &w2);                  x = rcs->branches[0]->cx;
2175                    w2 = rcs->branches[0]->tw / 2;
2176                    for(i = rcs->branches[0]->nrevs-1; i >= 0; i--)
2177                    {
2178                            initial_reposition_branch(rcs->branches[0]->revs[i], &x, &w2);
2179                    }
2180          }          }
2181    
2182          /* Initially move branches left if there is room */          /* Initially move branches left if there is room */
2183          kern_tree(rcs);          kern_tree(rcs);
2184    
2185          /* Try to kern the branches more by expanding the inter-revision spacing */          /* Try to kern the branches more by expanding the inter-revision spacing */
2186          if(conf.auto_stretch)          if(conf.auto_stretch && !conf.left_right)
2187                  auto_stretch(rcs);                  auto_stretch(rcs);
2188    
2189          /* Move everything w.r.t. the top-left margin */          /* Move everything w.r.t. the top-left margin */
# Line 1961  Line 2191 
2191                  move_branch(rcs->branches[i], conf.margin_left, conf.margin_top);                  move_branch(rcs->branches[i], conf.margin_left, conf.margin_top);
2192    
2193          /* Calculate overall image size */          /* Calculate overall image size */
2194          x = rcs->branches[0]->cx - rcs->branches[0]->tw/2;          if(conf.left_right)
2195          y = rcs->branches[0]->y;          {
2196                    x = rcs->branches[0]->cx;
2197                    y = rcs->branches[0]->y - rcs->branches[0]->th/2;
2198            }
2199            else
2200            {
2201                    x = rcs->branches[0]->cx - rcs->branches[0]->tw/2;
2202                    y = rcs->branches[0]->y;
2203            }
2204          w = rcs->branches[0]->tw;          w = rcs->branches[0]->tw;
2205          h = rcs->branches[0]->th;          h = rcs->branches[0]->th;
2206          for(i = 1; i < rcs->nbranches; i++)          for(i = 1; i < rcs->nbranches; i++)
# Line 1973  Line 2211 
2211          /* Flip the entire tree */          /* Flip the entire tree */
2212          if(conf.upside_down)          if(conf.upside_down)
2213          {          {
2214                  y += rcs->th;                  if(conf.left_right)
                 for(i = 0; i < rcs->nbranches; i++)  
2215                  {                  {
2216                          branch_t *b = rcs->branches[i];                          x += rcs->tw;
2217                          for(j = 0; j < b->nrevs; j++)                          for(i = 0; i < rcs->nbranches; i++)
2218                          {                          {
2219                                  revision_t *r = b->revs[j];                                  branch_t *b = rcs->branches[i];
2220                                  r->y = y - r->y - r->h + conf.margin_top;                                  for(j = 0; j < b->nrevs; j++)
2221                                    {
2222                                            revision_t *r = b->revs[j];
2223                                            r->cx = x - r->cx - r->w + conf.margin_top;
2224                                    }
2225                                    b->cx = x - b->cx - b->w + conf.margin_top;
2226                            }
2227                    }
2228                    else
2229                    {
2230                            y += rcs->th;
2231                            for(i = 0; i < rcs->nbranches; i++)
2232                            {
2233                                    branch_t *b = rcs->branches[i];
2234                                    for(j = 0; j < b->nrevs; j++)
2235                                    {
2236                                            revision_t *r = b->revs[j];
2237                                            r->y = y - r->y - r->h + conf.margin_top;
2238                                    }
2239                                    b->y = y - b->y - b->h + conf.margin_top;
2240                          }                          }
                         b->y = y - b->y - b->h + conf.margin_top;  
2241                  }                  }
2242          }          }
2243  }  }

Legend:
Removed from v.1.24  
changed lines
  Added in v.1.25

  ViewVC Help
Powered by ViewVC 1.1.0 with CvsGraph 1.7.0