/[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.63, Sun Jul 30 21:06:02 2006 UTC revision 1.63.2.3, Wed May 21 11:51:36 2008 UTC
# Line 52  Line 52 
52  #include "readconf.h"  #include "readconf.h"
53  #include "rcs.h"  #include "rcs.h"
54    
55  #if !defined(HAVE_IMAGE_GIF) && !defined(HAVE_IMAGE_PNG) && !defined(HAVE_IMAGE_JPEG)  #if !defined(HAVE_GD_GIF) && !defined(HAVE_GD_PNG) && !defined(HAVE_GD_JPEG)
56  # error No image output format available. Check libgd  # error No image output format available. Check libgd
57  #endif  #endif
58    
# Line 272  Line 272 
272          {          {
273                  cmd = xmalloc(strlen(cvsroot) + strlen(module) + strlen(file) + 1);                  cmd = xmalloc(strlen(cvsroot) + strlen(module) + strlen(file) + 1);
274                  sprintf(cmd, "%s%s%s", cvsroot, module, file);                  sprintf(cmd, "%s%s%s", cvsroot, module, file);
275                  if(!(rcsin = fopen(cmd, "rb")))                  if(!(yyin = fopen(cmd, "rb")))
276                  {                  {
277                          perror(cmd);                          perror(cmd);
278                          return NULL;                          return NULL;
# Line 281  Line 281 
281          }          }
282          else          else
283          {          {
284                  rcsin = stdin;                  yyin = stdin;
285                  input_file = "<stdin>";                  input_file = "<stdin>";
286          }          }
287          line_number = 1;          line_number = 1;
288          rv = rcsparse();          rv = yyparse();
289          if(file)          if(file)
290          {          {
291                  fclose(rcsin);                  fclose(yyin);
292                  xfree(cmd);                  xfree(cmd);
293          }          }
294          if(rv)          if(rv)
# Line 1490  Line 1490 
1490          if(!s || !*s)          if(!s || !*s)
1491                  return 0;                  return 0;
1492    
1493  #if defined(HAVE_GDIMAGESTRINGFT) || defined(HAVE_GDIMAGESTRINGTTF)  #if defined(HAVE_GD_STRINGFT) || defined(HAVE_GD_STRINGTTF)
1494          if(conf.use_ttf && f->ttfont)          if(conf.use_ttf && f->ttfont)
1495          {          {
1496                  int bb[8];                  int bb[8];
1497                  char *e;                  char *e;
1498  #ifdef HAVE_GDIMAGESTRINGFT  #ifdef HAVE_GD_STRINGFT
1499                  e = gdImageStringFT(NULL, bb, 0, f->ttfont, f->ttsize, 0.0, 0, 0, (char *)s);                  e = gdImageStringFT(NULL, bb, 0, f->ttfont, f->ttsize, 0.0, 0, 0, (char *)s);
1500  #else  #else
1501                  e = gdImageStringTTF(NULL, bb, 0, f->ttfont, f->ttsize, 0.0, 0, 0, (char *)s);                  e = gdImageStringTTF(NULL, bb, 0, f->ttfont, f->ttsize, 0.0, 0, 0, (char *)s);
# Line 1524  Line 1524 
1524          if(!s || !*s)          if(!s || !*s)
1525                  return 0;                  return 0;
1526    
1527  #if defined(HAVE_GDIMAGESTRINGFT) || defined(HAVE_GDIMAGESTRINGTTF)  #if defined(HAVE_GD_STRINGFT) || defined(HAVE_GD_STRINGTTF)
1528          if(conf.use_ttf && f->ttfont)          if(conf.use_ttf && f->ttfont)
1529          {          {
1530                  int bb[8];                  int bb[8];
1531                  char *e;                  char *e;
1532  #ifdef HAVE_GDIMAGESTRINGFT  #ifdef HAVE_GD_STRINGFT
1533                  e = gdImageStringFT(NULL, bb, 0, f->ttfont, f->ttsize, 0.0, 0, 0, (char *)s);                  e = gdImageStringFT(NULL, bb, 0, f->ttfont, f->ttsize, 0.0, 0, 0, (char *)s);
1534  #else  #else
1535                  e = gdImageStringTTF(NULL, bb, 0, f->ttfont, f->ttsize, 0.0, 0, 0, (char *)s);                  e = gdImageStringTTF(NULL, bb, 0, f->ttfont, f->ttsize, 0.0, 0, 0, (char *)s);
# Line 1551  Line 1551 
1551          int r2 = 2*r;          int r2 = 2*r;
1552          if(!r)          if(!r)
1553                  gdImageFilledRectangle(im, x1, y1, x2, y2, bgcolor->id);                  gdImageFilledRectangle(im, x1, y1, x2, y2, bgcolor->id);
1554  #ifdef HAVE_GDIMAGEFILLEDARC  #ifdef HAVE_GD_FILLEDARC
1555          else          else
1556          {          {
1557                  gdImageFilledArc(im, x1+r, y1+r, r2, r2, 180, 270, bgcolor->id, gdArc);                  gdImageFilledArc(im, x1+r, y1+r, r2, r2, 180, 270, bgcolor->id, gdArc);
# Line 1585  Line 1585 
1585                          gdImageArc(im, x2-r, y2-r+1, r2, r2,   0,  90, clr(im, NULL, NULL, NULL, 0)->id);                          gdImageArc(im, x2-r, y2-r+1, r2, r2,   0,  90, clr(im, NULL, NULL, NULL, 0)->id);
1586                  }                  }
1587                  gdImageArc(im, x2-r, y2-r, r2, r2,   0,  90, color->id);                  gdImageArc(im, x2-r, y2-r, r2, r2,   0,  90, color->id);
1588  #if !defined(NOGDFILL) && !defined(HAVE_GDIMAGEFILLEDARC)  #if !defined(NOGDFILL) && !defined(HAVE_GD_FILLEDARC)
1589                  /* BUG: We clip manually because libgd segfaults on out of bound values */                  /* BUG: We clip manually because libgd segfaults on out of bound values */
1590                  if((x1+x2)/2 >= 0 && (x1+x2)/2 < gdImageSX(im) && (y1+y2)/2 >= 0 && (y1+y2)/2 < gdImageSY(im))                  if((x1+x2)/2 >= 0 && (x1+x2)/2 < gdImageSX(im) && (y1+y2)/2 >= 0 && (y1+y2)/2 < gdImageSY(im))
1591                          gdImageFillToBorder(im, (x1+x2)/2, (y1+y2)/2, color->id, bgcolor->id);                          gdImageFillToBorder(im, (x1+x2)/2, (y1+y2)/2, color->id, bgcolor->id);
# Line 1611  Line 1611 
1611          case ALIGN_VC: yy = h/2; break;          case ALIGN_VC: yy = h/2; break;
1612          case ALIGN_VB: yy = h; break;          case ALIGN_VB: yy = h; break;
1613          }          }
1614  #if defined(HAVE_GDIMAGESTRINGFT) || defined(HAVE_GDIMAGESTRINGTTF)  #if defined(HAVE_GD_STRINGFT) || defined(HAVE_GD_STRINGTTF)
1615          if(conf.use_ttf && f->ttfont)          if(conf.use_ttf && f->ttfont)
1616          {          {
1617                  int bb[8];                  int bb[8];
1618                  char *e;                  char *e;
1619                  int cid = conf.anti_alias ? c->id : -c->id;                  int cid = conf.anti_alias ? c->id : -c->id;
1620  #ifdef HAVE_GDIMAGESTRINGFT  #ifdef HAVE_GD_STRINGFT
1621                  e = gdImageStringFT(im, bb, cid, f->ttfont, f->ttsize, 0.0, x+xx, y+yy+h-2, (char *)s);                  e = gdImageStringFT(im, bb, cid, f->ttfont, f->ttsize, 0.0, x+xx, y+yy+h-2, (char *)s);
1622  #else  #else
1623                  e = gdImageStringTTF(im, bb, cid, f->ttfont, f->ttsize, 0.0, x+xx, y+yy+h-2, (char *)s);                  e = gdImageStringTTF(im, bb, cid, f->ttfont, f->ttsize, 0.0, x+xx, y+yy+h-2, (char *)s);
# Line 1936  Line 1936 
1936          }          }
1937  }  }
1938    
1939  static void draw_merges(gdImagePtr im, rcsfile_t *rcs, int dot)  static void calc_merge_coords(merge_t *mt, revision_t *fr, revision_t *tr, int *x1, int *x2, int *y1, int *y2, int *sx1, int *sx2, int *sy1, int *sy2)
1940  {  {
1941          int i;          int shadow = conf.box_shadow ? 1 : 0;
1942          for(i = 0; i < rcs->nmerges; i++)          assert(mt != NULL);
1943          {          assert(fr != NULL);
1944                  revision_t *fr;          assert(tr != NULL);
1945                  revision_t *tr;          assert(x1 != NULL);
1946                  int colorid;          assert(x2 != NULL);
1947                  int x1, x2, y1, y2;          assert(y1 != NULL);
1948                  switch(rcs->merges[i].type)          assert(y2 != NULL);
1949                  {          assert(sx1 != NULL);
1950                  case TR_TAG:          assert(sx2 != NULL);
1951                          fr = rcs->merges[i].from.tag->logrev;          assert(sy1 != NULL);
1952                          tr = rcs->merges[i].to.tag->logrev;          assert(sy2 != NULL);
1953                          colorid = clr(im, "merge_color", NULL, NULL, rcs->merges[i].clr)->id;          if(conf.left_right && !conf.merge_on_tag)
1954                          break;          {
1955                  case TR_REVISION:                  if(fr->branch == tr->branch)
1956                          fr = rcs->merges[i].from.rev;                  {
1957                          tr = rcs->merges[i].to.rev;                          *y1 = fr->y - (fr->h+1)/2;
1958                          colorid = clr(im, "merge_cvsnt_color", NULL, NULL, 0)->id;                          *y2 = tr->y - (tr->h+1)/2;
1959                          break;                          *sy1 = *sy2 = -1;
                 default:  
                         continue;  
1960                  }                  }
1961                  if(!fr || !tr || fr == tr)                  else
                         continue;       /* This can happen with detached tags and self-references */  
                 if(conf.left_right)  
1962                  {                  {
1963                          if(fr->branch == tr->branch)                          /* See comment below on shortest path */
1964                            int y1a = fr->y + (fr->h+1)/2 + shadow;
1965                            int y1b = fr->y - (fr->h+1)/2;
1966                            int y2a = tr->y + (tr->h+1)/2 + shadow;
1967                            int y2b = tr->y - (tr->h+1)/2;
1968                            int laa = abs(y2a - y1a);
1969                            int lba = abs(y2a - y1b);
1970                            int lab = abs(y2b - y1a);
1971                            int lbb = abs(y2b - y1b);
1972                            if(laa < lab)
1973                          {                          {
1974                                  y1 = fr->y - fr->h/2;                                  if(laa < lba)
                                 y2 = tr->y - tr->h/2;  
                         }  
                         else  
                         {  
                                 if(fr->branch && fr->branch->branchpoint &&  
                                         tr->branch && tr->branch->branchpoint &&  
                                         fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)  
1975                                  {                                  {
1976                                          y1 = fr->y + fr->h/2;                                          if(laa < lbb)
1977                                          y2 = tr->y + tr->h/2;                                          {
1978                                                    *y1 = y1a;
1979                                                    *y2 = y2a;
1980                                                    *sy1 = *sy2 = 1;
1981                                            }
1982                                            else
1983                                            {
1984    ybb:
1985                                                    *y1 = y1b;
1986                                                    *y2 = y2b;
1987                                                    *sy1 = *sy2 = -1;
1988                                            }
1989                                  }                                  }
1990                                  else if(fr->y < tr->y)                                  else
1991                                  {                                  {
1992                                          y1 = fr->y + fr->h/2;  yba:
1993                                          y2 = tr->y - tr->h/2;                                          if(lba < lbb)
1994                                            {
1995                                                    *y1 = y1b;
1996                                                    *y2 = y2a;
1997                                                    *sy1 = -1;
1998                                                    *sy2 = 1;
1999                                            }
2000                                            else
2001                                                    goto ybb;
2002                                  }                                  }
2003                                  else                          }
2004                            else
2005                            {
2006                                    if(lab < lba)
2007                                  {                                  {
2008                                          y1 = fr->y - fr->h/2;                                          if(lab < lbb)
2009                                          y2 = tr->y + tr->h/2;                                          {
2010                                                    *y1 = y1a;
2011                                                    *y2 = y2b;
2012                                                    *sy1 = 1;
2013                                                    *sy2 = -1;
2014                                            }
2015                                            else
2016                                                    goto ybb;
2017                                  }                                  }
2018                                    else
2019                                            goto yba;
2020                          }                          }
2021                          x1 = fr->cx + fr->w/2;                  }
2022                          x2 = tr->cx + tr->w/2;                  *x1 = fr->cx + fr->w/2;
2023                    *x2 = tr->cx + tr->w/2;
2024                    *sx1 = *sx2 = 1;
2025            }
2026            else
2027            {
2028                    if(fr->branch == tr->branch)
2029                    {
2030                            /* Line on same branch always on left side */
2031                            *x1 = fr->cx - fr->w/2;
2032                            *x2 = tr->cx - tr->w/2;
2033                            *sx1 = *sx2 = -1;
2034                  }                  }
2035                  else                  else
2036                  {                  {
2037                          if(fr->branch == tr->branch)                          /* Find the shortest route from the two revisions
2038                          {                           * to determine which sides of the revision box
2039                                  x1 = fr->cx - fr->w/2;                           * should be used. The basics are:
2040                                  x2 = tr->cx - tr->w/2;                           * l = (x2 -x1)^2 + (y2 - y1)^2
2041                          }                           * However, (y2 -y1) is constant and hence the
2042                          else                           * determination of the shortest path is already
2043                             * clear from |x2 -x1| for each permutation of left
2044                             * and right x.
2045                             * This strategy is still not perfect because it can
2046                             * happen that a source/destination is overlayed by
2047                             * the revision box. To prevent this, we need to do
2048                             * a very deep analysis and I'm not prepared to do
2049                             * that right now...
2050                             */
2051                            int x1a = fr->cx + (fr->w+1)/2 + shadow;
2052                            int x1b = fr->cx - (fr->w+1)/2;
2053                            int x2a = tr->cx + (tr->w+1)/2 + shadow;
2054                            int x2b = tr->cx - (tr->w+1)/2;
2055                            int laa = abs(x2a - x1a);
2056                            int lba = abs(x2a - x1b);
2057                            int lab = abs(x2b - x1a);
2058                            int lbb = abs(x2b - x1b);
2059                            if(laa < lab)
2060                          {                          {
2061                                  if(fr->branch && fr->branch->branchpoint &&                                  if(laa < lba)
                                         tr->branch && tr->branch->branchpoint &&  
                                         fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)  
                                 {  
                                         x1 = fr->cx + fr->w/2;  
                                         x2 = tr->cx + tr->w/2;  
                                 }  
                                 else if(fr->cx < tr->cx)  
2062                                  {                                  {
2063                                          x1 = fr->cx + fr->w/2;                                          if(laa < lbb)
2064                                          x2 = tr->cx - tr->w/2;                                          {
2065                                                    *x1 = x1a;
2066                                                    *x2 = x2a;
2067                                                    *sx1 = *sx2 = 1;
2068                                            }
2069                                            else
2070                                            {
2071    xbb:
2072                                                    *x1 = x1b;
2073                                                    *x2 = x2b;
2074                                                    *sx1 = *sx2 = -1;
2075                                            }
2076                                  }                                  }
2077                                  else                                  else
2078                                  {                                  {
2079                                          x1 = fr->cx - fr->w/2;  xba:
2080                                          x2 = tr->cx + tr->w/2;                                          if(lba < lbb)
2081                                            {
2082                                                    *x1 = x1b;
2083                                                    *x2 = x2a;
2084                                                    *sx1 = -1;
2085                                                    *sx2 = 1;
2086                                            }
2087                                            else
2088                                                    goto xbb;
2089                                  }                                  }
2090                          }                          }
2091                          if(rcs->merges[i].type == TR_TAG)                          else
2092                          {                          {
2093                                  y1 = fr->y + rcs->merges[i].from.tag->yofs;                                  if(lab < lba)
2094                                  y2 = tr->y + rcs->merges[i].to.tag->yofs;                                  {
2095                                            if(lab < lbb)
2096                                            {
2097                                                    *x1 = x1a;
2098                                                    *x2 = x2b;
2099                                                    *sx1 = 1;
2100                                                    *sx2 = -1;
2101                                            }
2102                                            else
2103                                                    goto xbb;
2104                                    }
2105                                    else
2106                                            goto xba;
2107                          }                          }
2108                          else                  }
2109                    if(mt->type == TR_TAG)
2110                    {
2111                            *y1 = fr->y + mt->from.tag->yofs;
2112                            *y2 = tr->y + mt->to.tag->yofs;
2113                            if(conf.left_right && conf.merge_on_tag)
2114                          {                          {
2115                                  y1 = fr->y + fr->h/2;                                  *y1 -= fr->h/2;
2116                                  y2 = tr->y + tr->h/2;                                  *y2 -= tr->h/2;
2117                          }                          }
2118                  }                  }
2119                    else
2120                    {
2121                            *y1 = fr->y + fr->h/2;
2122                            *y2 = tr->y + tr->h/2;
2123                    }
2124                    *sy1 = *sy2 = 1;
2125                    if(conf.left_right && conf.merge_on_tag)
2126                    {
2127                            *x1 += fr->w/2;
2128                            *x2 += tr->w/2;
2129                    }
2130            }
2131    }
2132    
2133    static void draw_merges(gdImagePtr im, rcsfile_t *rcs, int dot)
2134    {
2135            int i;
2136            for(i = 0; i < rcs->nmerges; i++)
2137            {
2138                    revision_t *fr;
2139                    revision_t *tr;
2140                    int colorid;
2141                    int x1, x2, y1, y2;             /* Edge position on revision box */
2142                    int sx1, sx2, sy1, sy2;         /* Direction for mergeline -1 = left/up, +1 = right/down */
2143                    switch(rcs->merges[i].type)
2144                    {
2145                    case TR_TAG:
2146                            fr = rcs->merges[i].from.tag->logrev;
2147                            tr = rcs->merges[i].to.tag->logrev;
2148                            colorid = clr(im, "merge_color", NULL, NULL, rcs->merges[i].clr)->id;
2149                            break;
2150                    case TR_REVISION:
2151                            fr = rcs->merges[i].from.rev;
2152                            tr = rcs->merges[i].to.rev;
2153                            colorid = clr(im, "merge_cvsnt_color", NULL, NULL, 0)->id;
2154                            break;
2155                    default:
2156                            continue;
2157                    }
2158                    if(!fr || !tr || fr == tr)
2159                            continue;       /* This can happen with detached tags and self-references */
2160    
2161                    calc_merge_coords(&rcs->merges[i], fr, tr, &x1, &x2, &y1, &y2, &sx1, &sx2, &sy1, &sy2);
2162    
2163                  if(dot && !conf.merge_arrows)                  if(dot && !conf.merge_arrows)
2164                  {                  {
2165                          int o = conf.left_right ? 1 : 0;                          int o = conf.left_right ? 1 : 0;
# Line 2052  Line 2182 
2182    
2183                          sx = x1; sy = y1;                          sx = x1; sy = y1;
2184                          ex = x2; ey = y2;                          ex = x2; ey = y2;
2185                          if(conf.left_right)                          if(conf.left_right && !conf.merge_on_tag)
2186                          {                          {
2187                                  if(fr->branch == tr->branch)                                  if(fr->branch == tr->branch)
2188                                  {                                  {
# Line 2062  Line 2192 
2192                                  }                                  }
2193                                  else                                  else
2194                                  {                                  {
2195                                          if(fr->branch && fr->branch->branchpoint &&                                          sy = y1 + 3 * sy1;
2196                                                  tr->branch && tr->branch->branchpoint &&                                          ey = y2 + 3 * sy2;
                                                 fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)  
                                         {  
                                                 /* line from (x1,y1+3+1) to (x2,y2+3+1) */  
                                                 sy = y1+3+1;  
                                                 ey = y2+3+1;  
                                         }  
                                         else if(y1 > y2)  
                                         {  
                                                 /* line from (x1,y1-3) to (x2,y2+3+1) */  
                                                 sy = y1-3;  
                                                 ey = y2+3+1;  
                                         }  
                                         else  
                                         {  
                                                 /* line from (x1,y1+3+1) to (x2,y2-3) */  
                                                 sy = y1+3+1;  
                                                 ey = y2-3;  
                                         }  
2197                                  }                                  }
2198                          }                          }
2199                          else                          else
# Line 2094  Line 2206 
2206                                  }                                  }
2207                                  else                                  else
2208                                  {                                  {
2209                                          if(fr->branch && fr->branch->branchpoint &&                                          sx = x1 + 3 * sx1;
2210                                                  tr->branch && tr->branch->branchpoint &&                                          ex = x2 + 3 * sx2;
                                                 fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)  
                                         {  
                                                 /* line from (x1+3,y1) to (x2+3,y2) */  
                                                 sx = x1+3;  
                                                 ex = x2+3;  
                                         }  
                                         else if(x1 > x2)  
                                         {  
                                                 /* line from (x1-3,y1) to (x2+3,y2) */  
                                                 sx = x1-3;  
                                                 ex = x2+3;  
                                         }  
                                         else  
                                         {  
                                                 /* line from (x1+3,y1) to (x2-3,y2) */  
                                                 sx = x1+3;  
                                                 ex = x2-3;  
                                         }  
2211                                  }                                  }
2212                          }                          }
2213                          /*                          /*
# Line 2138  Line 2232 
2232                  }                  }
2233                  else                  else
2234                  {                  {
2235                          if(conf.left_right)                          if(conf.left_right && !conf.merge_on_tag)
2236                          {                          {
2237                                  if(fr->branch == tr->branch)                                  if(fr->branch == tr->branch)
2238                                  {                                  {
# Line 2149  Line 2243 
2243                                  }                                  }
2244                                  else                                  else
2245                                  {                                  {
2246                                          if(fr->branch && fr->branch->branchpoint &&                                          gdImageLine(im, x1, y1, x1, y1+3*sy1, colorid);
2247                                                  tr->branch && tr->branch->branchpoint &&                                          gdImageLine(im, x2, y2, x2, y2+3*sy2, colorid);
2248                                                  fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)                                          gdImageLine(im, x1, y1+3*sy1, x2, y2+3*sy2, colorid);
                                         {  
                                                 gdImageLine(im, x1, y1, x1, y1+3+1, colorid);  
                                                 gdImageLine(im, x2, y2+1, x2, y2+3+1, colorid);  
                                                 gdImageLine(im, x1, y1+3+1, x2, y2+3+1, colorid);  
                                         }  
                                         else if(y1 > y2)  
                                         {  
                                                 gdImageLine(im, x1, y1, x1, y1-3, colorid);  
                                                 gdImageLine(im, x2, y2+1, x2, y2+3+1, colorid);  
                                                 gdImageLine(im, x1, y1-3, x2, y2+3+1, colorid);  
                                         }  
                                         else  
                                         {  
                                                 gdImageLine(im, x1, y1+1, x1, y1+3+1, colorid);  
                                                 gdImageLine(im, x2, y2, x2, y2-3, colorid);  
                                                 gdImageLine(im, x1, y1+3+1, x2, y2-3, colorid);  
                                         }  
2249                                  }                                  }
2250                          }                          }
2251                          else                          else
# Line 2182  Line 2259 
2259                                  }                                  }
2260                                  else                                  else
2261                                  {                                  {
2262                                          if(fr->branch && fr->branch->branchpoint &&                                          gdImageLine(im, x1, y1, x1+3*sx1, y1, colorid);
2263                                                  tr->branch && tr->branch->branchpoint &&                                          gdImageLine(im, x2, y2, x2+3*sx2, y2, colorid);
2264                                                  fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)                                          gdImageLine(im, x1+3*sx1, y1, x2+3*sx2, y2, colorid);
                                         {  
                                                 gdImageLine(im, x1, y1, x1+3, y1, colorid);  
                                                 gdImageLine(im, x2, y2, x2+3, y2, colorid);  
                                                 gdImageLine(im, x1+3, y1, x2+3, y2, colorid);  
                                         }  
                                         else if(x1 > x2)  
                                         {  
                                                 gdImageLine(im, x1, y1, x1-3, y1, colorid);  
                                                 gdImageLine(im, x2, y2, x2+3, y2, colorid);  
                                                 gdImageLine(im, x1-3, y1, x2+3, y2, colorid);  
                                         }  
                                         else  
                                         {  
                                                 gdImageLine(im, x1, y1, x1+3, y1, colorid);  
                                                 gdImageLine(im, x2, y2, x2-3, y2, colorid);  
                                                 gdImageLine(im, x1+3, y1, x2-3, y2, colorid);  
                                         }  
2265                                  }                                  }
2266                          }                          }
2267                  }                  }
# Line 3401  Line 3461 
3461          {          {
3462                  revision_t *fr;                  revision_t *fr;
3463                  revision_t *tr;                  revision_t *tr;
3464                  int x1, x2, y1, y2;                  int x1, x2, y1, y2;             /* Edge position on revision box */
3465                    int sx1, sx2, sy1, sy2;         /* Direction for mergeline -1 = left/up, +1 = right/down */
3466                  switch(rcs->merges[i].type)                  switch(rcs->merges[i].type)
3467                  {                  {
3468                  case TR_TAG:                  case TR_TAG:
# Line 3417  Line 3478 
3478                  }                  }
3479                  if(!fr || !tr || fr == tr)                  if(!fr || !tr || fr == tr)
3480                          continue;       /* This can happen with detached tags and self-references */                          continue;       /* This can happen with detached tags and self-references */
                 if(conf.left_right)  
                 {  
                         if(fr->branch == tr->branch)  
                         {  
                                 y1 = fr->y - fr->h/2;  
                                 y2 = tr->y - tr->h/2;  
                         }  
                         else  
                         {  
                                 if(fr->branch && fr->branch->branchpoint &&  
                                         tr->branch && tr->branch->branchpoint &&  
                                         fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)  
                                 {  
                                         y1 = fr->y + fr->h/2;  
                                         y2 = tr->y + tr->h/2;  
                                 }  
                                 else if(fr->y < tr->y)  
                                 {  
                                         y1 = fr->y + fr->h/2;  
                                         y2 = tr->y - tr->h/2;  
                                 }  
                                 else  
                                 {  
                                         y1 = fr->y - fr->h/2;  
                                         y2 = tr->y + tr->h/2;  
                                 }  
                         }  
                         x1 = fr->cx + fr->w/2;  
                         x2 = tr->cx + tr->w/2;  
                 }  
                 else  
                 {  
                         if(fr->branch == tr->branch)  
                         {  
                                 x1 = fr->cx - fr->w/2;  
                                 x2 = tr->cx - tr->w/2;  
                         }  
                         else  
                         {  
                                 if(fr->branch && fr->branch->branchpoint &&  
                                         tr->branch && tr->branch->branchpoint &&  
                                         fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)  
                                 {  
                                         x1 = fr->cx + fr->w/2;  
                                         x2 = tr->cx + tr->w/2;  
                                 }  
                                 else if(fr->cx < tr->cx)  
                                 {  
                                         x1 = fr->cx + fr->w/2;  
                                         x2 = tr->cx - tr->w/2;  
                                 }  
                                 else  
                                 {  
                                         x1 = fr->cx - fr->w/2;  
                                         x2 = tr->cx + tr->w/2;  
                                 }  
                         }  
                         if(rcs->merges[i].type == TR_TAG)  
                         {  
                                 y1 = fr->y + rcs->merges[i].from.tag->yofs;  
                                 y2 = tr->y + rcs->merges[i].to.tag->yofs;  
                         }  
                         else  
                         {  
                                 y1 = fr->y + fr->h/2;  
                                 y2 = tr->y + tr->h/2;  
                         }  
                 }  
3481    
3482                  if(conf.left_right)                  calc_merge_coords(&rcs->merges[i], fr, tr, &x1, &x2, &y1, &y2, &sx1, &sx2, &sy1, &sy2);
3483    
3484                    if(conf.left_right && !conf.merge_on_tag)
3485                  {                  {
3486                          if(fr->branch == tr->branch)                          if(fr->branch == tr->branch)
3487                          {                          {
# Line 3495  Line 3490 
3490                          }                          }
3491                          else                          else
3492                          {                          {
3493                                  if(fr->branch && fr->branch->branchpoint &&                                  if(sy1 < 0)
                                         tr->branch && tr->branch->branchpoint &&  
                                         fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)  
                                 {  
                                         map_merge_box(rcs, fp, fr, tr, im, x1-bm, y1, x1+bm, y1+bm);  
                                         map_merge_box(rcs, fp, fr, tr, im, x2-bm, y2, x2+bm, y2+bm);  
                                 }  
                                 else if(y1 > y2)  
                                 {  
3494                                          map_merge_box(rcs, fp, fr, tr, im, x1-bm, y1-bm, x1+bm, y1);                                          map_merge_box(rcs, fp, fr, tr, im, x1-bm, y1-bm, x1+bm, y1);
                                         map_merge_box(rcs, fp, fr, tr, im, x2-bm, y2, x2+bm, y2+bm);  
                                 }  
3495                                  else                                  else
                                 {  
3496                                          map_merge_box(rcs, fp, fr, tr, im, x1-bm, y1, x1+bm, y1+bm);                                          map_merge_box(rcs, fp, fr, tr, im, x1-bm, y1, x1+bm, y1+bm);
3497                                    if(sy2 < 0)
3498                                          map_merge_box(rcs, fp, fr, tr, im, x2-bm, y2-bm, x2+bm, y2);                                          map_merge_box(rcs, fp, fr, tr, im, x2-bm, y2-bm, x2+bm, y2);
3499                                  }                                  else
3500                                            map_merge_box(rcs, fp, fr, tr, im, x2-bm, y2, x2+bm, y2+bm);
3501                          }                          }
3502                  }                  }
3503                  else                  else
# Line 3523  Line 3509 
3509                          }                          }
3510                          else                          else
3511                          {                          {
3512                                  if(fr->branch && fr->branch->branchpoint &&                                  if(sx1 < 0)
                                         tr->branch && tr->branch->branchpoint &&  
                                         fr->branch->branchpoint->branch == tr->branch->branchpoint->branch)  
                                 {  
                                         map_merge_box(rcs, fp, fr, tr, im, x1, y1-tagh2, x1+bm, y1+tagh2);  
                                         map_merge_box(rcs, fp, fr, tr, im, x2, y2-tagh2, x2+bm, y2+tagh2);  
                                 }  
                                 else if(x1 > x2)  
                                 {  
3513                                          map_merge_box(rcs, fp, fr, tr, im, x1-bm, y1-tagh2, x1, y1+tagh2);                                          map_merge_box(rcs, fp, fr, tr, im, x1-bm, y1-tagh2, x1, y1+tagh2);
                                         map_merge_box(rcs, fp, fr, tr, im, x2, y2-tagh2, x2+bm, y2+tagh2);  
                                 }  
3514                                  else                                  else
                                 {  
3515                                          map_merge_box(rcs, fp, fr, tr, im, x1, y1-tagh2, x1+bm, y1+tagh2);                                          map_merge_box(rcs, fp, fr, tr, im, x1, y1-tagh2, x1+bm, y1+tagh2);
3516                                    if(sx2 < 0)
3517                                          map_merge_box(rcs, fp, fr, tr, im, x2-bm, y2-tagh2, x2, y2+tagh2);                                          map_merge_box(rcs, fp, fr, tr, im, x2-bm, y2-tagh2, x2, y2+tagh2);
3518                                  }                                  else
3519                                            map_merge_box(rcs, fp, fr, tr, im, x2, y2-tagh2, x2+bm, y2+tagh2);
3520                          }                          }
3521                  }                  }
3522          }          }
# Line 3816  Line 3793 
3793          "  -[0-9] <txt> Use <txt> for expansion\n"          "  -[0-9] <txt> Use <txt> for expansion\n"
3794          ;          ;
3795    
3796  #define VERSION_STR     "1.6.2"  #define VERSION_STR     VERSION
3797  #define NOTICE_STR      "Copyright (c) 2001-2006 B.Stultiens"  #define NOTICE_STR      "Copyright (c) 2001-2008 B.Stultiens"
3798    
3799  static void append_slash(char **path)  static void append_slash(char **path)
3800  {  {
# Line 3833  Line 3810 
3810    
3811  int main(int argc, char *argv[])  int main(int argc, char *argv[])
3812  {  {
3813          extern int rcs_flex_debug;          extern int yy_flex_debug;
3814          extern int rcsdebug;          extern int yydebug;
3815          int optc;          int optc;
3816          char *confpath = NULL;          char *confpath = NULL;
3817          char *outfile = NULL;          char *outfile = NULL;
# Line 3948  Line 3925 
3925                  setvbuf(stdout, NULL, 0, _IONBF);                  setvbuf(stdout, NULL, 0, _IONBF);
3926                  setvbuf(stderr, NULL, 0, _IONBF);                  setvbuf(stderr, NULL, 0, _IONBF);
3927          }          }
3928          rcs_flex_debug = (debuglevel & DEBUG_RCS_LEX) != 0;          yy_flex_debug = (debuglevel & DEBUG_RCS_LEX) != 0;
3929          rcsdebug = (debuglevel & DEBUG_RCS_YACC) != 0;          yydebug = (debuglevel & DEBUG_RCS_YACC) != 0;
3930    
3931          /* Set defaults */          /* Set defaults */
3932          conf.tag_font.gdfont            = gdFontTiny;          conf.tag_font.gdfont            = gdFontTiny;
# Line 4119  Line 4096 
4096  #endif  #endif
4097                  switch(conf.image_type)                  switch(conf.image_type)
4098                  {                  {
4099  #ifdef HAVE_IMAGE_GIF  #ifdef HAVE_GD_GIF
4100  # ifndef HAVE_IMAGE_PNG  # ifndef HAVE_GD_PNG
4101                  default:                  default:
4102  # endif  # endif
4103                  case IMAGE_GIF:                  case IMAGE_GIF:
4104                          gdImageGif(im, fp);                          gdImageGif(im, fp);
4105                          break;                          break;
4106  #endif  #endif
4107  #ifdef HAVE_IMAGE_PNG  #ifdef HAVE_GD_PNG
4108                  default:                  default:
4109                  case IMAGE_PNG:                  case IMAGE_PNG:
4110  #ifdef HAVE_GDIMAGEPNGEX  #ifdef HAVE_GD_PNGEX
4111                          gdImagePngEx(im, fp, conf.image_compress);                          gdImagePngEx(im, fp, conf.image_compress);
4112  #else  #else
4113                          gdImagePng(im, fp);                          gdImagePng(im, fp);
4114  #endif  #endif
4115                          break;                          break;
4116  #endif  #endif
4117  #ifdef HAVE_IMAGE_JPEG  #ifdef HAVE_GD_JPEG
4118  # if !defined(HAVE_IMAGE_GIF) && !defined(HAVE_IMAGE_PNG)  # if !defined(HAVE_GD_GIF) && !defined(HAVE_GD_PNG)
4119                  default:                  default:
4120  # endif  # endif
4121                  case IMAGE_JPEG:                  case IMAGE_JPEG:

Legend:
Removed from v.1.63  
changed lines
  Added in v.1.63.2.3

  ViewVC Help
Powered by ViewVC 1.1.0 with CvsGraph 1.7.0