src/TortoiseProc/RevisionGraph/RevisionGraphDlgDraw.cpp

   1 // TortoiseSVN - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2011 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "stdafx.h"
  20 #include "TortoiseProc.h"
  21 #include "MyMemDC.h"
  22 #include "Revisiongraphdlg.h"
  23 #include "MessageBox.h"
  24 #include "Git.h"
  25 #include "TempFile.h"
  26 #include "UnicodeUtils.h"
  27 #include "TGitPath.h"
  28 //#include "SVNInfo.h"
  29 //#include "SVNDiff.h"
  30 #include ".\revisiongraphwnd.h"
  31 //#include "IRevisionGraphLayout.h"
  32 //#include "UpsideDownLayout.h"
  33 //#include "ShowTreeStripes.h"
  34
  35 #ifdef _DEBUG
  36 #define new DEBUG_NEW
  37 #undef THIS_FILE
  38 static char THIS_FILE[] = __FILE__;
  39 #endif
  40
  41 using namespace Gdiplus;
  42 using namespace ogdf;
  43
  44 /************************************************************************/
  45 /* Graphing functions                                                   */
  46 /************************************************************************/
  47 CFont* CRevisionGraphWnd::GetFont(BOOL bItalic /*= FALSE*/, BOOL bBold /*= FALSE*/)
  48 {
  49     int nIndex = 0;
  50     if (bBold)
  51         nIndex |= 1;
  52     if (bItalic)
  53         nIndex |= 2;
  54     if (m_apFonts[nIndex] == NULL)
  55     {
  56         m_apFonts[nIndex] = new CFont;
  57         m_lfBaseFont.lfWeight = bBold ? FW_BOLD : FW_NORMAL;
  58         m_lfBaseFont.lfItalic = (BYTE) bItalic;
  59         m_lfBaseFont.lfStrikeOut = (BYTE) FALSE;
  60         CDC * pDC = GetDC();
  61         m_lfBaseFont.lfHeight = -MulDiv(m_nFontSize, GetDeviceCaps(pDC->m_hDC, LOGPIXELSY), 72);
  62         ReleaseDC(pDC);
  63         // use the empty font name, so GDI takes the first font which matches
  64         // the specs. Maybe this will help render chinese/japanese chars correctly.
  65         _tcsncpy_s(m_lfBaseFont.lfFaceName, _T("MS Shell Dlg 2"), 32);
  66         if (!m_apFonts[nIndex]->CreateFontIndirect(&m_lfBaseFont))
  67         {
  68             delete m_apFonts[nIndex];
  69             m_apFonts[nIndex] = NULL;
  70             return CWnd::GetFont();
  71         }
  72     }
  73     return m_apFonts[nIndex];
  74 }
  75
  76 BOOL CRevisionGraphWnd::OnEraseBkgnd(CDC* /*pDC*/)
  77 {
  78     return TRUE;
  79 }
  80
  81 void CRevisionGraphWnd::OnPaint()
  82 {
  83
  84     CPaintDC dc(this); // device context for painting
  85     CRect rect = GetClientRect();
  86 /*
  87     if (IsUpdateJobRunning())
  88     {
  89         dc.FillSolidRect(rect, ::GetSysColor(COLOR_APPWORKSPACE));
  90         CWnd::OnPaint();
  91         return;
  92     }
  93
  94         else if (this->m_Graph.empty())
  95     {
  96         CString sNoGraphText;
  97         sNoGraphText.LoadString(IDS_REVGRAPH_ERR_NOGRAPH);
  98         dc.FillSolidRect(rect, RGB(255,255,255));
  99         dc.ExtTextOut(20,20,ETO_CLIPPED,NULL,sNoGraphText,NULL);
 100         return;
 101     }
 102 */
 103     GraphicsDevice dev;
 104     dev.pDC = &dc;
 105     DrawGraph(dev, rect, GetScrollPos(SB_VERT), GetScrollPos(SB_HORZ), false);
 106
 107 }
 108
 109 void CRevisionGraphWnd::ClearVisibleGlyphs (const CRect& rect)
 110 {
 111 #if 0
 112     float glyphSize = GLYPH_SIZE * m_fZoomFactor;
 113
 114     CSyncPointer<CRevisionGraphState::TVisibleGlyphs>
 115         visibleGlyphs (m_state.GetVisibleGlyphs());
 116
 117     for (size_t i = visibleGlyphs->size(), count = i; i > 0; --i)
 118     {
 119         const PointF& leftTop = (*visibleGlyphs)[i-1].leftTop;
 120         CRect glyphRect ( static_cast<int>(leftTop.X)
 121                         , static_cast<int>(leftTop.Y)
 122                         , static_cast<int>(leftTop.X + glyphSize)
 123                         , static_cast<int>(leftTop.Y + glyphSize));
 124
 125         if (CRect().IntersectRect (glyphRect, rect))
 126         {
 127             (*visibleGlyphs)[i-1] = (*visibleGlyphs)[--count];
 128             visibleGlyphs->pop_back();
 129         }
 130     }
 131 #endif
 132 }
 133
 134 void CRevisionGraphWnd::CutawayPoints (const RectF& rect, float cutLen, TCutRectangle& result)
 135 {
 136     result[0] = PointF (rect.X, rect.Y + cutLen);
 137     result[1] = PointF (rect.X + cutLen, rect.Y);
 138     result[2] = PointF (rect.GetRight() - cutLen, rect.Y);
 139     result[3] = PointF (rect.GetRight(), rect.Y + cutLen);
 140     result[4] = PointF (rect.GetRight(), rect.GetBottom() - cutLen);
 141     result[5] = PointF (rect.GetRight() - cutLen, rect.GetBottom());
 142     result[6] = PointF (rect.X + cutLen, rect.GetBottom());
 143     result[7] = PointF (rect.X, rect.GetBottom() - cutLen);
 144 }
 145
 146 void CRevisionGraphWnd::DrawRoundedRect (GraphicsDevice& graphics, const Color& penColor, int penWidth, const Pen* pen, const Color& fillColor, const Brush* brush, const RectF& rect)
 147 {
 148
 149     enum {POINT_COUNT = 8};
 150
 151     float radius = CORNER_SIZE * m_fZoomFactor;
 152     PointF points[POINT_COUNT];
 153     CutawayPoints (rect, radius, points);
 154
 155     if (graphics.graphics)
 156     {
 157         GraphicsPath path;
 158         path.AddArc (points[0].X, points[1].Y, radius, radius, 180, 90);
 159         path.AddArc (points[2].X, points[2].Y, radius, radius, 270, 90);
 160         path.AddArc (points[5].X, points[4].Y, radius, radius, 0, 90);
 161         path.AddArc (points[7].X, points[7].Y, radius, radius, 90, 90);
 162
 163         points[0].Y -= radius / 2;
 164         path.AddLine (points[7], points[0]);
 165
 166         if (brush != NULL)
 167         {
 168             graphics.graphics->FillPath (brush, &path);
 169         }
 170         if (pen != NULL)
 171             graphics.graphics->DrawPath (pen, &path);
 172     }
 173     else if (graphics.pSVG)
 174     {
 175         graphics.pSVG->RoundedRectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height, penColor, penWidth, fillColor, (int)radius);
 176     }
 177
 178 }
 179
 180
 181
 182 void CRevisionGraphWnd::DrawOctangle (GraphicsDevice& graphics, const Color& penColor, int penWidth, const Pen* pen, const Color& fillColor, const Brush* brush, const RectF& rect)
 183 {
 184     enum {POINT_COUNT = 8};
 185
 186     // show left & right edges of low boxes as "<===>"
 187
 188     float minCutAway = min (CORNER_SIZE * m_fZoomFactor, rect.Height / 2);
 189
 190     // larger boxes: remove 25% of the shorter side
 191
 192     float suggestedCutAway = min (rect.Height, rect.Width) / 4;
 193
 194     // use the more visible one of the former two
 195
 196     PointF points[POINT_COUNT];
 197     CutawayPoints (rect, max (minCutAway, suggestedCutAway), points);
 198
 199     // now, draw it
 200
 201     if (graphics.graphics)
 202     {
 203         if (brush != NULL)
 204             graphics.graphics->FillPolygon (brush, points, POINT_COUNT);
 205         if (pen != NULL)
 206             graphics.graphics->DrawPolygon (pen, points, POINT_COUNT);
 207     }
 208     else if (graphics.pSVG)
 209     {
 210         graphics.pSVG->Polygon(points, POINT_COUNT, penColor, penWidth, fillColor);
 211     }
 212 }
 213
 214
 215
 216 void CRevisionGraphWnd::DrawShape (GraphicsDevice& graphics, const Color& penColor, int penWidth, const Pen* pen, const Color& fillColor, const Brush* brush, const RectF& rect, NodeShape shape)
 217 {
 218     switch( shape )
 219     {
 220     case TSVNRectangle:
 221         if (graphics.graphics)
 222         {
 223             if (brush != NULL)
 224                 graphics.graphics->FillRectangle (brush, rect);
 225             if (pen != NULL)
 226                 graphics.graphics->DrawRectangle (pen, rect);
 227         }
 228         else if (graphics.pSVG)
 229         {
 230             graphics.pSVG->RoundedRectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height, penColor, penWidth, fillColor);
 231         }
 232         break;
 233     case TSVNRoundRect:
 234         DrawRoundedRect (graphics, penColor, penWidth, pen, fillColor, brush, rect);
 235         break;
 236     case TSVNOctangle:
 237         DrawOctangle (graphics, penColor, penWidth, pen, fillColor, brush, rect);
 238         break;
 239     case TSVNEllipse:
 240         if (graphics.graphics)
 241         {
 242             if (brush != NULL)
 243                 graphics.graphics->FillEllipse (brush, rect);
 244             if (pen != NULL)
 245                 graphics.graphics->DrawEllipse(pen, rect);
 246         }
 247         else if (graphics.pSVG)
 248             graphics.pSVG->Ellipse((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height, penColor, penWidth, fillColor);
 249         break;
 250     default:
 251         ASSERT(FALSE);  //unknown type
 252         return;
 253     }
 254 }
 255
 256
 257 inline BYTE LimitedScaleColor (BYTE c1, BYTE c2, float factor)
 258 {
 259     BYTE scaled = c2 + (BYTE)((c1-c2)*factor);
 260     return c1 < c2
 261         ? max (c1, scaled)
 262         : min (c1, scaled);
 263 }
 264
 265 Color LimitedScaleColor (const Color& c1, const Color& c2, float factor)
 266 {
 267     return Color ( LimitedScaleColor (c1.GetA(), c2.GetA(), factor)
 268                  , LimitedScaleColor (c1.GetR(), c2.GetR(), factor)
 269                  , LimitedScaleColor (c1.GetG(), c2.GetG(), factor)
 270                  , LimitedScaleColor (c1.GetB(), c2.GetB(), factor));
 271 }
 272
 273 inline BYTE Darken (BYTE c)
 274 {
 275     return c < 0xc0
 276         ? (c / 3) * 2
 277         : BYTE(int(2*c) - 0x100);
 278 }
 279
 280 Color Darken (const Color& c)
 281 {
 282     return Color ( 0xff
 283                  , Darken (c.GetR())
 284                  , Darken (c.GetG())
 285                  , Darken (c.GetB()));
 286 }
 287
 288 BYTE MaxComponentDiff (const Color& c1, const Color& c2)
 289 {
 290     int rDiff = abs ((int)c1.GetR() - (int)c2.GetR());
 291     int gDiff = abs ((int)c1.GetG() - (int)c2.GetG());
 292     int bDiff = abs ((int)c1.GetB() - (int)c2.GetB());
 293
 294     return (BYTE) max (max (rDiff, gDiff), bDiff);
 295 }
 296
 297 #if 0
 298 void CRevisionGraphWnd::DrawShadow (GraphicsDevice& graphics, const RectF& rect,
 299                                     Color shadowColor, NodeShape shape)
 300 {
 301     // draw the shadow
 302
 303     RectF shadow = rect;
 304     shadow.Offset (2, 2);
 305
 306     Pen pen (shadowColor);
 307     SolidBrush brush (shadowColor);
 308
 309     DrawShape (graphics, shadowColor, 1, &pen, shadowColor, &brush, shadow, shape);
 310 }
 311 #endif
 312
 313
 314 void CRevisionGraphWnd::DrawNode(GraphicsDevice& graphics, const RectF& rect,
 315                                  Color contour, Color overlayColor,
 316                                  const CVisibleGraphNode *node, NodeShape shape)
 317 {
 318     // special case: line deleted but deletion node removed
 319     // (don't show as "deleted" if the following node has been folded / split)
 320
 321     //enum
 322     //{
 323     //    MASK = CGraphNodeStates::COLLAPSED_BELOW | CGraphNodeStates::SPLIT_BELOW
 324     //};
 325
 326     //CNodeClassification nodeClassification = node->GetClassification();
 327     //if (   (node->GetNext() == NULL)
 328     //    && (nodeClassification.Is (CNodeClassification::PATH_ONLY_DELETED))
 329     //    && ((m_state.GetNodeStates()->GetFlags (node) & MASK) == 0))
 330    // {
 331     //    contour = m_Colors.GetColor (CColors::gdpDeletedNode);
 332    // }
 333
 334     // calculate the GDI+ color values we need to draw the node
 335
 336     Color background;
 337     background.SetFromCOLORREF (GetSysColor(COLOR_WINDOW));
 338     Color textColor;
 339    // if (nodeClassification.Is (CNodeClassification::IS_MODIFIED_WC))
 340    //     textColor = m_Colors.GetColor (CColors::gdpWCNodeBorder);
 341    // else
 342         textColor.SetFromCOLORREF (GetSysColor(COLOR_WINDOWTEXT));
 343
 344     Color brightColor = LimitedScaleColor (background, contour, 0.9f);
 345
 346     // Draw the main shape
 347
 348    bool isWorkingCopy=0;
 349    //     = nodeClassification.Is (CNodeClassification::IS_WORKINGCOPY);
 350    bool isModifiedWC=0;
 351    //     = nodeClassification.Is (CNodeClassification::IS_MODIFIED_WC);
 352    bool textAsBorderColor=0;
 353    //     = nodeClassification.IsAnyOf ( CNodeClassification::IS_LAST
 354    //                                  | CNodeClassification::IS_MODIFIED_WC)
 355    //     | nodeClassification.Matches ( CNodeClassification::IS_COPY_SOURCE
 356    //                                  , CNodeClassification::IS_OPERATION_MASK)
 357    //     | (contour.GetValue() == brightColor.GetValue());
 358
 359     Color penColor = textAsBorderColor
 360                    ? textColor
 361                    : contour;
 362
 363     Pen pen (penColor, isWorkingCopy ? 3.0f : 1.0f);
 364 #if 0
 365         if (isWorkingCopy && !isModifiedWC)
 366     {
 367         CSyncPointer<const CFullHistory> history (m_state.GetFullHistory());
 368         const CFullHistory::SWCInfo& wcInfo = history->GetWCInfo();
 369         revision_t revision = node->GetRevision();
 370
 371         bool isCommitRev =    (wcInfo.minCommit == revision)
 372                            || (wcInfo.maxCommit == revision);
 373         bool isMinAtRev =    (wcInfo.minAtRev == revision)
 374                           && (wcInfo.minAtRev != wcInfo.maxAtRev);
 375
 376         DashStyle style = wcInfo.maxAtRev == revision
 377                         ? DashStyleSolid
 378                         : isCommitRev ? isMinAtRev ? DashStyleDashDot
 379                                                    : DashStyleDot
 380                                       : DashStyleDash;
 381
 382         pen.SetDashStyle (style);
 383     }
 384 #endif
 385     SolidBrush brush (brightColor);
 386     DrawShape (graphics, penColor, isWorkingCopy ? 3 : 1, &pen, brightColor, &brush, rect, shape);
 387
 388     // overlay with some other color
 389
 390     if (overlayColor.GetValue() != 0)
 391     {
 392         SolidBrush brush2 (overlayColor);
 393         DrawShape (graphics, penColor, isWorkingCopy ? 3 : 1, &pen, overlayColor, &brush2, rect, shape);
 394     }
 395 }
 396
 397
 398 RectF CRevisionGraphWnd::TransformRectToScreen (const CRect& rect, const CSize& offset) const
 399 {
 400     PointF leftTop ( rect.left * m_fZoomFactor
 401                    , rect.top * m_fZoomFactor);
 402     return RectF ( leftTop.X - offset.cx
 403                  , leftTop.Y - offset.cy
 404                  , rect.right * m_fZoomFactor - leftTop.X - 1
 405                  , rect.bottom * m_fZoomFactor - leftTop.Y);
 406 }
 407
 408
 409 RectF CRevisionGraphWnd::GetNodeRect (const node& node, const CSize& offset) const
 410 {
 411     // get node and position
 412
 413         CRect rect;
 414         rect.left = this->m_GraphAttr.x(node) -  m_GraphAttr.width(node)/2;
 415         rect.top = this->m_GraphAttr.y(node) - m_GraphAttr.height(node)/2;
 416         rect.bottom = rect.top+ m_GraphAttr.height(node);
 417         rect.right = rect.left + m_GraphAttr.width(node);
 418
 419     RectF noderect (TransformRectToScreen (rect, offset));
 420
 421     // show two separate lines for touching nodes,
 422     // unless the scale is too small
 423
 424     if (noderect.Height > 15.0f)
 425         noderect.Height -= 1.0f;
 426
 427     // done
 428
 429     return noderect;
 430 }
 431
 432
 433 #if 0
 434 RectF CRev
 435 isionGraphWnd::GetBranchCover
 436     ( const ILayoutNodeList* nodeList
 437     , index_t nodeIndex
 438     , bool upward
 439     , const CSize& offset)
 440 {
 441     // construct a rect that covers the respective branch
 442
 443     CRect cover (0, 0, 0, 0);
 444     while (nodeIndex != NO_INDEX)
 445     {
 446         ILayoutNodeList::SNode node = nodeList->GetNode (nodeIndex);
 447         cover |= node.rect;
 448
 449         const CVisibleGraphNode* nextNode = upward
 450             ? node.node->GetPrevious()
 451             : node.node->GetNext();
 452
 453         nodeIndex = nextNode == NULL ? NO_INDEX : nextNode->GetIndex();
 454     }
 455
 456     // expand it just a little to make it look nicer
 457
 458     cover.InflateRect (10, 2, 10, 2);
 459
 460     // and now, transfrom it
 461
 462     return TransformRectToScreen (cover, offset);
 463 }
 464 #endif
 465
 466
 467 void CRevisionGraphWnd::DrawShadows (GraphicsDevice& graphics, const CRect& logRect, const CSize& offset)
 468 {
 469 #if 0  // shadow color to use
 470
 471     Color background;
 472     background.SetFromCOLORREF (GetSysColor(COLOR_WINDOW));
 473     Color textColor;
 474     textColor.SetFromCOLORREF (GetSysColor(COLOR_WINDOWTEXT));
 475
 476     Color shadowColor = LimitedScaleColor (background, ARGB (Color::Black), 0.5f);
 477
 478     // iterate over all visible nodes
 479
 480     CSyncPointer<const ILayoutNodeList> nodes (m_state.GetNodes());
 481     for ( index_t index = nodes->GetFirstVisible (logRect)
 482         ; index != NO_INDEX
 483         ; index = nodes->GetNextVisible (index, logRect))
 484     {
 485         // get node and position
 486
 487         ILayoutNodeList::SNode node = nodes->GetNode (index);
 488         RectF noderect (GetNodeRect (node, offset));
 489
 490         // actual drawing
 491
 492         switch (node.style)
 493         {
 494         case ILayoutNodeList::SNode::STYLE_DELETED:
 495         case ILayoutNodeList::SNode::STYLE_RENAMED:
 496             DrawShadow (graphics, noderect, shadowColor, TSVNOctangle);
 497             break;
 498         case ILayoutNodeList::SNode::STYLE_ADDED:
 499             DrawShadow(graphics, noderect, shadowColor, TSVNRoundRect);
 500             break;
 501         case ILayoutNodeList::SNode::STYLE_LAST:
 502             DrawShadow(graphics, noderect, shadowColor, TSVNEllipse);
 503             break;
 504         default:
 505             DrawShadow(graphics, noderect, shadowColor, TSVNRectangle);
 506             break;
 507         }
 508     }
 509 #endif
 510 }
 511
 512
 513 #if 0
 514 void CRevisionGraphWnd::DrawSquare
 515     ( GraphicsDevice& graphics
 516     , const PointF& leftTop
 517     , const Color& lightColor
 518     , const Color& darkColor
 519     , const Color& penColor)
 520 {
 521     float squareSize = MARKER_SIZE * m_fZoomFactor;
 522
 523     PointF leftBottom (leftTop.X, leftTop.Y + squareSize);
 524     RectF square (leftTop, SizeF (squareSize, squareSize));
 525
 526     if (graphics.graphics)
 527     {
 528         LinearGradientBrush lgBrush (leftTop, leftBottom, lightColor, darkColor);
 529         graphics.graphics->FillRectangle (&lgBrush, square);
 530         if (squareSize > 4.0f)
 531         {
 532             Pen pen (penColor);
 533             graphics.graphics->DrawRectangle (&pen, square);
 534         }
 535     }
 536     else if (graphics.pSVG)
 537     {
 538         graphics.pSVG->GradientRectangle((int)square.X, (int)square.Y, (int)square.Width, (int)square.Height,
 539                                         lightColor, darkColor, penColor);
 540     }
 541 }
 542
 543 void CRevisionGraphWnd::DrawGlyph
 544     ( GraphicsDevice& graphics
 545     , Image* glyphs
 546     , const PointF& leftTop
 547     , GlyphType glyph
 548     , GlyphPosition position)
 549 {
 550     // special case
 551
 552     if (glyph == NoGlyph)
 553         return;
 554
 555     // bitmap source area
 556
 557     REAL x = ((REAL)position + (REAL)glyph) * GLYPH_BITMAP_SIZE;
 558
 559     // screen target area
 560
 561     float glyphSize = GLYPH_SIZE * m_fZoomFactor;
 562     RectF target (leftTop, SizeF (glyphSize, glyphSize));
 563
 564     // scaled copy
 565
 566     if (graphics.graphics)
 567     {
 568         graphics.graphics->DrawImage ( glyphs
 569             , target
 570             , x, 0.0f, GLYPH_BITMAP_SIZE, GLYPH_BITMAP_SIZE
 571             , UnitPixel, NULL, NULL, NULL);
 572     }
 573     else if (graphics.pSVG)
 574     {
 575         // instead of inserting a bitmap, draw a
 576         // round rectangle instead.
 577         // Embedding images would blow up the resulting
 578         // svg file a lot, and the round rectangle
 579         // is enough IMHO.
 580         // Note:
 581         // images could be embedded like this:
 582         // <image y="100" x="100" id="imgId1234" xlink:href="data:image/png;base64,...base64endodeddata..." height="16" width="16" />
 583
 584         graphics.pSVG->RoundedRectangle((int)target.X, (int)target.Y, (int)target.Width, (int)target.Height,
 585                                         Color(0,0,0), 2, Color(255,255,255), (int)(target.Width/3.0));
 586     }
 587 }
 588 #endif
 589 void CRevisionGraphWnd::DrawGlyphs
 590     ( GraphicsDevice& graphics
 591     , Image* glyphs
 592     , const CVisibleGraphNode* node
 593     , const PointF& center
 594     , GlyphType glyph1
 595     , GlyphType glyph2
 596     , GlyphPosition position
 597     , DWORD state1
 598     , DWORD state2
 599     , bool showAll)
 600 {
 601     // don't show collapse and cut glyths by default
 602 #if 0
 603     if (!showAll && ((glyph1 == CollapseGlyph) || (glyph1 == SplitGlyph)))
 604         glyph1 = NoGlyph;
 605     if (!showAll && ((glyph2 == CollapseGlyph) || (glyph2 == SplitGlyph)))
 606         glyph2 = NoGlyph;
 607
 608     // glyth2 shall be set only if 2 glyphs are in use
 609
 610     if (glyph1 == NoGlyph)
 611     {
 612         std::swap (glyph1, glyph2);
 613         std::swap (state1, state2);
 614     }
 615
 616     // anything to do?
 617
 618     if (glyph1 == NoGlyph)
 619         return;
 620
 621     // 1 or 2 glyphs?
 622
 623     CSyncPointer<CRevisionGraphState::TVisibleGlyphs>
 624         visibleGlyphs (m_state.GetVisibleGlyphs());
 625
 626     float squareSize = GLYPH_SIZE * m_fZoomFactor;
 627     if (glyph2 == NoGlyph)
 628     {
 629         PointF leftTop (center.X - 0.5f * squareSize, center.Y - 0.5f * squareSize);
 630         DrawGlyph (graphics, glyphs, leftTop, glyph1, position);
 631         visibleGlyphs->push_back
 632             (CRevisionGraphState::SVisibleGlyph (state1, leftTop, node));
 633     }
 634     else
 635     {
 636         PointF leftTop1 (center.X - squareSize, center.Y - 0.5f * squareSize);
 637         DrawGlyph (graphics, glyphs, leftTop1, glyph1, position);
 638         visibleGlyphs->push_back
 639             (CRevisionGraphState::SVisibleGlyph (state1, leftTop1, node));
 640
 641         PointF leftTop2 (center.X, center.Y - 0.5f * squareSize);
 642         DrawGlyph (graphics, glyphs, leftTop2, glyph2, position);
 643         visibleGlyphs->push_back
 644             (CRevisionGraphState::SVisibleGlyph (state2, leftTop2, node));
 645     }
 646 #endif
 647 }
 648
 649 void CRevisionGraphWnd::DrawGlyphs
 650     ( GraphicsDevice& graphics
 651     , Image* glyphs
 652     , const CVisibleGraphNode* node
 653     , const RectF& nodeRect
 654     , DWORD state
 655     , DWORD allowed
 656     , bool upsideDown)
 657 {
 658     // shortcut
 659 #if 0
 660     if ((state == 0) && (allowed == 0))
 661         return;
 662
 663     // draw all glyphs
 664
 665     PointF topCenter (0.5f * nodeRect.GetLeft() + 0.5f * nodeRect.GetRight(), nodeRect.GetTop());
 666     PointF rightCenter (nodeRect.GetRight(), 0.5f * nodeRect.GetTop() + 0.5f * nodeRect.GetBottom());
 667     PointF bottomCenter (0.5f * nodeRect.GetLeft() + 0.5f * nodeRect.GetRight(), nodeRect.GetBottom());
 668
 669     DrawGlyphs ( graphics
 670                , glyphs
 671                , node
 672                , upsideDown ? bottomCenter : topCenter
 673                , (state & CGraphNodeStates::COLLAPSED_ABOVE) ? ExpandGlyph : CollapseGlyph
 674                , (state & CGraphNodeStates::SPLIT_ABOVE) ? JoinGlyph : SplitGlyph
 675                , upsideDown ? Below : Above
 676                , CGraphNodeStates::COLLAPSED_ABOVE
 677                , CGraphNodeStates::SPLIT_ABOVE
 678                , (allowed & CGraphNodeStates::COLLAPSED_ABOVE) != 0);
 679
 680     DrawGlyphs ( graphics
 681                , glyphs
 682                , node
 683                , rightCenter
 684                , (state & CGraphNodeStates::COLLAPSED_RIGHT) ? ExpandGlyph : CollapseGlyph
 685                , (state & CGraphNodeStates::SPLIT_RIGHT) ? JoinGlyph : SplitGlyph
 686                , Right
 687                , CGraphNodeStates::COLLAPSED_RIGHT
 688                , CGraphNodeStates::SPLIT_RIGHT
 689                , (allowed & CGraphNodeStates::COLLAPSED_RIGHT) != 0);
 690
 691     DrawGlyphs ( graphics
 692                , glyphs
 693                , node
 694                , upsideDown ? topCenter : bottomCenter
 695                , (state & CGraphNodeStates::COLLAPSED_BELOW) ? ExpandGlyph : CollapseGlyph
 696                , (state & CGraphNodeStates::SPLIT_BELOW) ? JoinGlyph : SplitGlyph
 697                , upsideDown ? Above : Below
 698                , CGraphNodeStates::COLLAPSED_BELOW
 699                , CGraphNodeStates::SPLIT_BELOW
 700                , (allowed & CGraphNodeStates::COLLAPSED_BELOW) != 0);
 701 #endif
 702 }
 703
 704
 705 #if 0
 706 void CRevisionGraphWnd::IndicateGlyphDirection
 707     ( GraphicsDevice& graphics
 708     , const ILayoutNodeList* nodeList
 709     , const ILayoutNodeList::SNode& node
 710     , const RectF& nodeRect
 711     , DWORD glyphs
 712     , bool upsideDown
 713     , const CSize& offset)
 714 {
 715     // shortcut
 716
 717     if (glyphs == 0)
 718         return;
 719
 720     // where to place the indication?
 721
 722     bool indicateAbove = (glyphs & CGraphNodeStates::COLLAPSED_ABOVE) != 0;
 723     bool indicateRight = (glyphs & CGraphNodeStates::COLLAPSED_RIGHT) != 0;
 724     bool indicateBelow = (glyphs & CGraphNodeStates::COLLAPSED_BELOW) != 0;
 725
 726     // fill indication area a semi-transparent blend of red
 727     // and the background color
 728
 729     Color color;
 730     color.SetFromCOLORREF (GetSysColor(COLOR_WINDOW));
 731     color.SetValue ((color.GetValue() & 0x807f7f7f) + 0x800000);
 732
 733     SolidBrush brush (color);
 734
 735     // draw the indication (only one condition should match)
 736
 737     RectF glyphCenter = indicateAbove ^ upsideDown
 738         ? RectF (nodeRect.X, nodeRect.Y - 1.0f, 0.0f, 0.0f)
 739         : RectF (nodeRect.X, nodeRect.GetBottom() - 1.0f, 0.0f, 0.0f);
 740
 741     if (indicateAbove)
 742     {
 743         const CVisibleGraphNode* firstAffected = node.node->GetSource();
 744
 745         assert (firstAffected);
 746         RectF branchCover
 747             = GetBranchCover (nodeList, firstAffected->GetIndex(), true, offset);
 748         RectF::Union (branchCover, branchCover, glyphCenter);
 749
 750         if (graphics.graphics)
 751             graphics.graphics->FillRectangle (&brush, branchCover);
 752         else if (graphics.pSVG)
 753             graphics.pSVG->RoundedRectangle((int)branchCover.X, (int)branchCover.Y, (int)branchCover.Width, (int)branchCover.Height,
 754                                             color, 1, color);
 755     }
 756
 757     if (indicateRight)
 758     {
 759         for ( const CVisibleGraphNode::CCopyTarget* branch
 760                 = node.node->GetFirstCopyTarget()
 761             ; branch != NULL
 762             ; branch = branch->next())
 763         {
 764             RectF branchCover
 765                 = GetBranchCover (nodeList, branch->value()->GetIndex(), false, offset);
 766             if (graphics.graphics)
 767                 graphics.graphics->FillRectangle (&brush, branchCover);
 768             else if (graphics.pSVG)
 769                 graphics.pSVG->RoundedRectangle((int)branchCover.X, (int)branchCover.Y, (int)branchCover.Width, (int)branchCover.Height,
 770                                                 color, 1, color);
 771         }
 772     }
 773
 774     if (indicateBelow)
 775     {
 776         const CVisibleGraphNode* firstAffected
 777             = node.node->GetNext();
 778
 779         RectF branchCover
 780             = GetBranchCover (nodeList, firstAffected->GetIndex(), false, offset);
 781         RectF::Union (branchCover, branchCover, glyphCenter);
 782
 783         if (graphics.graphics)
 784             graphics.graphics->FillRectangle (&brush, branchCover);
 785         else if (graphics.pSVG)
 786             graphics.pSVG->RoundedRectangle((int)branchCover.X, (int)branchCover.Y, (int)branchCover.Width, (int)branchCover.Height,
 787                                             color, 1, color);
 788     }
 789 }
 790
 791 void CRevisionGraphWnd::DrawMarker
 792     ( GraphicsDevice& graphics
 793     , const RectF& noderect
 794     , MarkerPosition position
 795     , int relPosition
 796     , int colorIndex )
 797 {
 798     // marker size
 799     float squareSize = MARKER_SIZE * m_fZoomFactor;
 800     float squareDist = min ( (noderect.Height - squareSize) / 2
 801                            , squareSize / 2);
 802
 803     // position
 804
 805     REAL offset = squareSize * (0.75f + relPosition);
 806     REAL left = position == mpRight
 807               ? noderect.GetRight() - offset - squareSize
 808               : noderect.GetLeft() + offset;
 809     PointF leftTop (left, noderect.Y + squareDist);
 810
 811     // color
 812
 813     Color lightColor (m_Colors.GetColor (CColors::ctMarkers, colorIndex));
 814     Color darkColor (Darken (lightColor));
 815     Color borderColor (0x80000000);
 816
 817     // draw it
 818
 819     DrawSquare (graphics, leftTop, lightColor, darkColor, borderColor);
 820 }
 821
 822 void CRevisionGraphWnd::DrawStripes (GraphicsDevice& graphics, const CSize& offset)
 823 {
 824     // we need to fill this visible area of the the screen
 825     // (even if there is graph in that part)
 826
 827     RectF clipRect;
 828     if (graphics.graphics)
 829         graphics.graphics->GetVisibleClipBounds (&clipRect);
 830
 831     // don't show stripes if we don't have multiple roots
 832
 833     CSyncPointer<const ILayoutRectList> trees (m_state.GetTrees());
 834     if (trees->GetCount() < 2)
 835         return;
 836
 837     // iterate over all trees
 838
 839     for ( index_t i = 0, count = trees->GetCount(); i < count; ++i)
 840     {
 841         // screen coordinates covered by the tree
 842
 843         CRect tree = trees->GetRect(i);
 844         REAL left = tree.left * m_fZoomFactor;
 845         REAL right = tree.right * m_fZoomFactor;
 846         RectF rect ( left - offset.cx
 847                    , clipRect.Y
 848                    , i+1 == count ? clipRect.Width : right - left
 849                    , clipRect.Height);
 850
 851         // relevant?
 852
 853         if (rect.IntersectsWith (clipRect))
 854         {
 855             // draw the background stripe
 856
 857             Color color (  (i & 1) == 0
 858                          ? m_Colors.GetColor (CColors::gdpStripeColor1)
 859                          : m_Colors.GetColor (CColors::gdpStripeColor2));
 860             if (graphics.graphics)
 861             {
 862                 SolidBrush brush (color);
 863                 graphics.graphics->FillRectangle (&brush, rect);
 864             }
 865             else if (graphics.pSVG)
 866                 graphics.pSVG->RoundedRectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height,
 867                                                 color, 1, color);
 868         }
 869     }
 870 }
 871 #endif
 872 void CRevisionGraphWnd::DrawNodes (GraphicsDevice& graphics, Image* glyphs, const CRect& logRect, const CSize& offset)
 873 {
 874
 875 //    CSyncPointer<CGraphNodeStates> nodeStates (m_state.GetNodeStates());
 876 //    CSyncPointer<const ILayoutNodeList> nodes (m_state.GetNodes());
 877
 878 //    bool upsideDown
 879 //        = m_state.GetOptions()->GetOption<CUpsideDownLayout>()->IsActive();
 880
 881     // iterate over all visible nodes
 882
 883 /*    for ( index_t index = nodes->GetFirstVisible (logRect)
 884         ; index != NO_INDEX
 885         ; index = nodes->GetNextVisible (index, logRect))
 886 */
 887         node v;
 888         forall_nodes(v,m_Graph)
 889     {
 890         // get node and position
 891
 892 //        ILayoutNodeList::SNode node = nodes->GetNode (index);
 893         RectF noderect (GetNodeRect (v, offset));
 894
 895         // actual drawing
 896
 897         Color transparent (0);
 898         Color overlayColor = transparent;
 899
 900         SVGGrouper grouper(graphics.pSVG);
 901
 902                 DrawNode(graphics, noderect, RGB(255,0,0), overlayColor, v, TSVNRoundRect);
 903 #if 0
 904         switch (node.style)
 905         {
 906         case ILayoutNodeList::SNode::STYLE_DELETED:
 907             DrawNode(graphics, noderect, m_Colors.GetColor(CColors::gdpDeletedNode), transparent, node.node, TSVNOctangle);
 908             break;
 909
 910         case ILayoutNodeList::SNode::STYLE_ADDED:
 911             if (m_bTweakTagsColors && node.node->GetClassification().Is (CNodeClassification::IS_TAG))
 912                 overlayColor = m_Colors.GetColor(CColors::gdpTagOverlay);
 913             else if (m_bTweakTrunkColors && node.node->GetClassification().Is (CNodeClassification::IS_TRUNK))
 914                 overlayColor = m_Colors.GetColor(CColors::gdpTrunkOverlay);
 915             DrawNode(graphics, noderect, m_Colors.GetColor(CColors::gdpAddedNode), overlayColor, node.node, TSVNRoundRect);
 916             break;
 917
 918         case ILayoutNodeList::SNode::STYLE_RENAMED:
 919             DrawNode(graphics, noderect, m_Colors.GetColor(CColors::gdpRenamedNode), overlayColor, node.node, TSVNOctangle);
 920             break;
 921
 922         case ILayoutNodeList::SNode::STYLE_LAST:
 923             DrawNode(graphics, noderect, m_Colors.GetColor(CColors::gdpLastCommitNode), transparent, node.node, TSVNEllipse);
 924             break;
 925
 926         case ILayoutNodeList::SNode::STYLE_MODIFIED:
 927             DrawNode(graphics, noderect, m_Colors.GetColor(CColors::gdpModifiedNode), transparent, node.node, TSVNRectangle);
 928             break;
 929
 930         case ILayoutNodeList::SNode::STYLE_MODIFIED_WC:
 931             DrawNode(graphics, noderect, m_Colors.GetColor(CColors::gdpWCNode), transparent, node.node, TSVNEllipse);
 932             break;
 933
 934         default:
 935             DrawNode(graphics, noderect, m_Colors.GetColor(CColors::gdpUnchangedNode), transparent, node.node, TSVNRectangle);
 936             break;
 937         }
 938 #endif
 939         // Draw the "tagged" icon
 940
 941         //if (node.node->GetFirstTag() != NULL)
 942         //    DrawMarker (graphics, noderect, mpRight, 0, 0);
 943
 944         //if ((m_SelectedEntry1 == node.node) || (m_SelectedEntry2 == node.node))
 945         //    DrawMarker (graphics, noderect, mpLeft, 0, 1);
 946
 947         // expansion glypths etc.
 948
 949         DrawGlyphs (graphics, glyphs, v, noderect, 0, 0, 0);
 950     }
 951
 952 }
 953
 954 PointF CRevisionGraphWnd::cutPoint(node v,double lw,PointF ps, PointF pt)
 955 {
 956         double x = m_GraphAttr.x(v);
 957         double y = m_GraphAttr.y(v);
 958         double xmin = x - this->m_GraphAttr.width(v)/2 - lw/2;
 959         double xmax = x + this->m_GraphAttr.width(v)/2 + lw/2;
 960         double ymin = y - this->m_GraphAttr.height(v)/2 - lw/2;
 961         double ymax = y + this->m_GraphAttr.height(v)/2 + lw/2;;
 962
 963         double dx = pt.X - ps.X;
 964         double dy = pt.Y - ps.Y;
 965
 966         if(dy != 0) {
 967                 // below
 968                 if(pt.Y > ymax) {
 969                         double t = (ymax-ps.Y) / dy;
 970                         double x = ps.X + t*dx;
 971
 972                         if(xmin <= x && x <= xmax)
 973                                 return PointF(x,ymax);
 974
 975                 // above
 976                 } else if(pt.Y < ymin) {
 977                         double t = (ymin-ps.Y) / dy;
 978                         double x = ps.X + t*dx;
 979
 980                         if(xmin <= x && x <= xmax)
 981                                 return PointF(x,ymin);
 982
 983                 }
 984         }
 985
 986         if(dx != 0) {
 987                 // right
 988                 if(pt.X > xmax) {
 989                         double t = (xmax-ps.X) / dx;
 990                         double y = ps.Y + t*dy;
 991
 992                         if(ymin <= y && y <= ymax)
 993                                 return PointF(xmax,y);
 994
 995                 // left
 996                 } else if(pt.X < xmin) {
 997                         double t = (xmin-ps.X) / dx;
 998                         double y = ps.Y + t*dy;
 999
1000                         if(ymin <= y && y <= ymax)
1001                                 return PointF(xmin,y);
1002
1003                 }
1004         }
1005
1006         return pt;
1007
1008 }
1009
1010 void CRevisionGraphWnd::DrawConnections (GraphicsDevice& graphics, const CRect& logRect, const CSize& offset)
1011 {
1012
1013         CArray<PointF> points;
1014         CArray<CPoint> pts;
1015
1016         if(graphics.graphics)
1017                 graphics.graphics->SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
1018
1019         Gdiplus::Pen pen(Color(0,0,0),2);
1020
1021     // iterate over all visible lines
1022         edge e;
1023         forall_edges(e, m_Graph)
1024     {
1025         // get connection and point position
1026                 const DPolyline &dpl = this->m_GraphAttr.bends(e);
1027
1028                 points.RemoveAll();
1029                 pts.RemoveAll();
1030
1031                 PointF pt;
1032                 pt.X = m_GraphAttr.x(e->source());
1033                 pt.Y = m_GraphAttr.y(e->source());
1034
1035                 points.Add(pt);
1036
1037                 ListConstIterator<DPoint> it;
1038                 for(it = dpl.begin(); it.valid(); ++it)
1039                 {
1040                         pt.X =  (*it).m_x;
1041                         pt.Y =  (*it).m_y;
1042                         points.Add(pt);
1043                 }
1044
1045                 pt.X = m_GraphAttr.x(e->target());
1046                 pt.Y = m_GraphAttr.y(e->target());
1047
1048                 points.Add(pt);
1049
1050                 points[0] = this->cutPoint(e->source(), 1, points[0], points[1]);
1051                 points[points.GetCount()-1] =  this->cutPoint(e->target(), 1, points[points.GetCount()-1], points[points.GetCount()-2]);
1052         // draw the connection
1053
1054                 for(int i=0; i < points.GetCount(); i++)
1055                 {
1056                         //CPoint pt;
1057                         points[i].X = points[i].X * this->m_fZoomFactor - offset.cx;
1058                         points[i].Y = points[i].Y * this->m_fZoomFactor - offset.cy;
1059                         //pts.Add(pt);
1060                 }
1061
1062                 if (graphics.graphics)
1063                 {
1064                         graphics.graphics->DrawLines(&pen, points.GetData(), points.GetCount());
1065
1066                 }
1067                 else if (graphics.pSVG)
1068         {
1069             Color color;
1070             color.SetFromCOLORREF(GetSysColor(COLOR_WINDOWTEXT));
1071                         graphics.pSVG->PolyBezier(pts.GetData(), pts.GetCount(), color);
1072         }
1073     }
1074 }
1075
1076
1077
1078 void CRevisionGraphWnd::DrawTexts (GraphicsDevice& graphics, const CRect& logRect, const CSize& offset)
1079 {
1080 #if  0
1081     COLORREF standardTextColor = GetSysColor(COLOR_WINDOWTEXT);
1082     if (m_nFontSize <= 0)
1083         return;
1084
1085     // iterate over all visible nodes
1086
1087     if (graphics.pDC)
1088         graphics.pDC->SetTextAlign (TA_CENTER | TA_TOP);
1089
1090
1091         node v;
1092         forall_nodes(v,m_Graph)
1093     {
1094         // get node and position
1095
1096                 String label=this->m_GraphAttr.labelNode(v);
1097                 this->m_GraphAttr.l
1098                 CRect textRect ( (int)(text.rect.left * m_fZoomFactor) - offset.cx
1099                        , (int)(text.rect.top * m_fZoomFactor) - offset.cy
1100                        , (int)(text.rect.right * m_fZoomFactor) - offset.cx
1101                        , (int)(text.rect.bottom * m_fZoomFactor) - offset.cy);
1102
1103         // draw the revision text
1104
1105         if (graphics.pDC)
1106         {
1107             graphics.pDC->SetTextColor (text.style == ILayoutTextList::SText::STYLE_WARNING
1108                 ? m_Colors.GetColor (CColors::gdpWCNodeBorder).ToCOLORREF()
1109                 : standardTextColor );
1110             graphics.pDC->SelectObject (GetFont (FALSE, text.style != ILayoutTextList::SText::STYLE_DEFAULT));
1111             graphics.pDC->ExtTextOut ((textRect.left + textRect.right)/2, textRect.top, 0, &textRect, text.text, NULL);
1112         }
1113         else if (graphics.pSVG)
1114         {
1115             graphics.pSVG->CenteredText((textRect.left + textRect.right)/2, textRect.top+m_nFontSize+3, "Arial", m_nFontSize,
1116                 false, text.style != ILayoutTextList::SText::STYLE_DEFAULT,
1117                 text.style == ILayoutTextList::SText::STYLE_WARNING
1118                 ? m_Colors.GetColor (CColors::gdpWCNodeBorder)
1119                 : standardTextColor, CUnicodeUtils::GetUTF8(text.text));
1120         }
1121     }
1122 #endif
1123 }
1124
1125
1126
1127 void CRevisionGraphWnd::DrawCurrentNodeGlyphs (GraphicsDevice& graphics, Image* glyphs, const CSize& offset)
1128 {
1129 #if 0
1130     CSyncPointer<const ILayoutNodeList> nodeList (m_state.GetNodes());
1131     bool upsideDown
1132         = m_state.GetOptions()->GetOption<CUpsideDownLayout>()->IsActive();
1133
1134     // don't draw glyphs if we are outside the client area
1135     // (e.g. within a scrollbar)
1136
1137     CPoint point;
1138     GetCursorPos (&point);
1139     ScreenToClient (&point);
1140     if (!GetClientRect().PtInRect (point))
1141         return;
1142
1143     // expansion glypths etc.
1144
1145     m_hoverIndex = GetHitNode (point);
1146     m_hoverGlyphs = GetHoverGlyphs (point);
1147
1148     if ((m_hoverIndex != NO_INDEX) || (m_hoverGlyphs != 0))
1149     {
1150         index_t nodeIndex = m_hoverIndex == NO_INDEX
1151                           ? GetHitNode (point, CSize (GLYPH_SIZE, GLYPH_SIZE / 2))
1152                           : m_hoverIndex;
1153
1154         if (nodeIndex >= nodeList->GetCount())
1155             return;
1156
1157         ILayoutNodeList::SNode node = nodeList->GetNode (nodeIndex);
1158         RectF noderect (GetNodeRect (node, offset));
1159
1160         DWORD flags = m_state.GetNodeStates()->GetFlags (node.node);
1161
1162         IndicateGlyphDirection (graphics, nodeList.get(), node, noderect, m_hoverGlyphs, upsideDown, offset);
1163         DrawGlyphs (graphics, glyphs, node.node, noderect, flags, m_hoverGlyphs, upsideDown);
1164     }
1165 #endif
1166 }
1167
1168
1169 void CRevisionGraphWnd::DrawGraph(GraphicsDevice& graphics, const CRect& rect, int nVScrollPos, int nHScrollPos, bool bDirectDraw)
1170 {
1171     CMemDC* memDC = NULL;
1172     if (graphics.pDC)
1173     {
1174         if (!bDirectDraw)
1175         {
1176             memDC = new CMemDC (*graphics.pDC, rect);
1177             graphics.pDC = &memDC->GetDC();
1178         }
1179
1180         graphics.pDC->FillSolidRect(rect, GetSysColor(COLOR_WINDOW));
1181         graphics.pDC->SetBkMode(TRANSPARENT);
1182     }
1183
1184     // preparation & sync
1185
1186     //CSyncPointer<CAllRevisionGraphOptions> options (m_state.GetOptions());
1187     ClearVisibleGlyphs (rect);
1188
1189     // transform visible
1190
1191     CSize offset (nHScrollPos, nVScrollPos);
1192     CRect logRect ( (int)(offset.cx / m_fZoomFactor)-1
1193                   , (int)(offset.cy / m_fZoomFactor)-1
1194                   , (int)((rect.Width() + offset.cx) / m_fZoomFactor) + 1
1195                   , (int)((rect.Height() + offset.cy) / m_fZoomFactor) + 1);
1196
1197     // draw the different components
1198
1199     if (graphics.pDC)
1200     {
1201         Graphics* gcs = Graphics::FromHDC(*graphics.pDC);
1202         graphics.graphics = gcs;
1203         gcs->SetPageUnit (UnitPixel);
1204         gcs->SetInterpolationMode (InterpolationModeHighQualityBicubic);
1205         gcs->SetSmoothingMode(SmoothingModeAntiAlias);
1206         gcs->SetClip(RectF(Gdiplus::REAL(rect.left), Gdiplus::REAL(rect.top), Gdiplus::REAL(rect.Width()), Gdiplus::REAL(rect.Height())));
1207     }
1208
1209 //    if (options->GetOption<CShowTreeStripes>()->IsActive())
1210 //        DrawStripes (graphics, offset);
1211
1212     if (m_fZoomFactor > SHADOW_ZOOM_THRESHOLD)
1213         DrawShadows (graphics, logRect, offset);
1214
1215     Bitmap glyphs (AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_REVGRAPHGLYPHS));
1216
1217     DrawNodes (graphics, &glyphs, logRect, offset);
1218     DrawConnections (graphics, logRect, offset);
1219     DrawTexts (graphics, logRect, offset);
1220
1221     if (m_showHoverGlyphs)
1222         DrawCurrentNodeGlyphs (graphics, &glyphs, offset);
1223
1224     // draw preview
1225
1226     if ((!bDirectDraw)&&(m_Preview.GetSafeHandle())&&(m_bShowOverview)&&(graphics.pDC))
1227     {
1228         // draw the overview image rectangle in the top right corner
1229         CMyMemDC memDC2(graphics.pDC, true);
1230         memDC2.SetWindowOrg(0, 0);
1231         HBITMAP oldhbm = (HBITMAP)memDC2.SelectObject(&m_Preview);
1232         graphics.pDC->BitBlt(rect.Width()-m_previewWidth, 0, m_previewWidth, m_previewHeight,
1233             &memDC2, 0, 0, SRCCOPY);
1234         memDC2.SelectObject(oldhbm);
1235         // draw the border for the overview rectangle
1236         m_OverviewRect.left = rect.Width()-m_previewWidth;
1237         m_OverviewRect.top = 0;
1238         m_OverviewRect.right = rect.Width();
1239         m_OverviewRect.bottom = m_previewHeight;
1240         graphics.pDC->DrawEdge(&m_OverviewRect, EDGE_BUMP, BF_RECT);
1241         // now draw a rectangle where the current view is located in the overview
1242
1243         CRect viewRect = GetViewRect();
1244         LONG width = (long)(rect.Width() * m_previewZoom / m_fZoomFactor);
1245         LONG height = (long)(rect.Height() * m_previewZoom / m_fZoomFactor);
1246         LONG xpos = (long)(nHScrollPos * m_previewZoom / m_fZoomFactor);
1247         LONG ypos = (long)(nVScrollPos * m_previewZoom / m_fZoomFactor);
1248         RECT tempRect;
1249         tempRect.left = rect.Width()-m_previewWidth+xpos;
1250         tempRect.top = ypos;
1251         tempRect.right = tempRect.left + width;
1252         tempRect.bottom = tempRect.top + height;
1253         // make sure the position rect is not bigger than the preview window itself
1254         ::IntersectRect(&m_OverviewPosRect, &m_OverviewRect, &tempRect);
1255
1256         RectF rect2 ( (float)m_OverviewPosRect.left, (float)m_OverviewPosRect.top
1257                    , (float)m_OverviewPosRect.Width(), (float)m_OverviewPosRect.Height());
1258         if (graphics.graphics)
1259         {
1260             SolidBrush brush (Color (64, 0, 0, 0));
1261             graphics.graphics->FillRectangle (&brush, rect2);
1262             graphics.pDC->DrawEdge(&m_OverviewPosRect, EDGE_BUMP, BF_RECT);
1263         }
1264     }
1265
1266     // flush changes to screen
1267
1268     delete graphics.graphics;
1269     delete memDC;
1270 }
1271
1272 #if 0
1273 void CRevisionGraphWnd::DrawRubberBand()
1274 {
1275     CDC * pDC = GetDC();
1276     pDC->SetROP2(R2_NOT);
1277     pDC->SelectObject(GetStockObject(NULL_BRUSH));
1278     pDC->Rectangle(min(m_ptRubberStart.x, m_ptRubberEnd.x), min(m_ptRubberStart.y, m_ptRubberEnd.y),
1279         max(m_ptRubberStart.x, m_ptRubberEnd.x), max(m_ptRubberStart.y, m_ptRubberEnd.y));
1280     ReleaseDC(pDC);
1281 }
1282
1283 #endif