Using LineDDA to produce complex line styles

Environment: Windows NT 3.1-4.0, Windows 95/98 (not supported on CE)


A Very old method for generating complex line styles is the use of the Win32
API call “LineDDA”. LineDDA can be used to create dashed or dotted lines, as
well as more complex graphics such as wavy lines or “Railroad Tracks”.

This method was first made available with Windows NT 3.1 and is currently
supported by Windows 95/98. (Not Supported by Windows CE)

LineDDA is a GDI32 library call that takes a set of line coordinates, an
address to a callback function and a pointer to some user data with the
following signature: (Taken from the GDI: Platform SDK)

             int nXStart,             // x-coordinate of line's starting point
             int nYStart,             // y-coordinate of line's starting point
             int nXEnd,               // x-coordinate of line's ending point
             int nYEnd,               // y-coordinate of line's ending point
             LINEDDAPROC lpLineFunc,  // pointer to callback function
             LPARAM lpData            // pointer to application-defined data

The callback function has the signature: (Taken from the GDI: Platform SDK)

                          int X,          // x-coordinate of point being evaluated
                          int Y,          // y-coordinate of point being evaluated
                          LPARAM lpData   // pointer to application-defined data


Basic use requires that LineDDA be called with the coordinates of the line
segment, the address of the LineDDAProc and some User defined data and GDI
will call the LineDDAProc for every calculated point on the line. (Excluding
the Endpoint)

LineDDA is not a Graphics routine in that it does not draw anything, but
rather is a support routine used to set up the callback stream. (DDA stands
for Digital Differential Analyzer) Because of this, the line will always be
calculated using default transformations and mapping modes applied to the
current display resolution. Manual Transformation of the X and Y values
passed to the LineDDAProc if other than the defaults are used.


A basic implementation would have a call to LinDDA in the “OnDraw” method
passing in a static or global pointer to a function that would draw whatever
interesting lines styles that the solution required:

void CSimpleView::OnDraw(CDC* pDC)
    //Implementation Note: it is safe to pass our local reference
    //of the pDC object because all of the callbacks will complete
    //before the pDC goes out of scope.

    CSimpleDoc* pDoc = GetDocument();

    //Draw a Line

    //Use LineDDA to Draw 0's at intervals along the line.


VOID CALLBACK DrawZero(int X,int Y,LPARAM lpData)
    //This Callback routine will be called for every calculated
    //point in the line.

    //Implementation Note: Use lpData to pass a reference to a
    //CDC object for drawing.

    CDC* pDC;
    pDC = (CDC*)lpData;

    if( X % 20 ==0)


This treatment would have acceptable performance in very simple situations
but under more rigorous application, would not be sufficient.

A better approach would be to use this method to precalculate points for
later use in the OnDraw method. If the points are static, this would only be
performed once.


LineDDA can provide a solution to problems requiring more complex line
styles. This is a Win32 solution and is currently not supported directly by
MFC. (Probably because it is not used very much) As a general solution it
may not prove to be very useful but it will solve some very unique problems
for which no other direct solution exists.

Further Reading:

The Win32 SDK contains an average amount of documentation on this method.
MSDN Knowledge Base contains several examples of how to use LineDDA to
create some interesting affects. One sample actually used LineDDA to draw
the cell lines for a simple spreadsheet program. (Article ID: Q68301)

More by Author

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Must Read