Drawing Barcodes in Windows Part 4 - Code 93

• Download source - 40 Kb

Introduction

A recent project at work required that I write out barcode characters into a font file for an old photo-typesetter. This experience inspired me to start a side project writing some code that renders a barcode on the Windows screen, given the proper input. This series of articles is the result of that project.

Code 93 basics

This fourth article is about drawing Code 93 barcodes on the Windows screen. Before I start discussing the code, we'll need to know some basic facts about the Code 93 barcode symbology. Code 93 is an alpha-numeric code that can encode all ASCII characters through the use of four "shift" characters. Code 93 characters consist of 3 bars and 3 spaces, which are built by using 9 modules each of which can be black or white. Because all of the characters are built from the same 9 modules, there really is only one element width that needs to be defined, the module width. The bar/space patterns for the 47 data characters and the start/stop codes are listed below. Each pattern is 9 characters (modules) long, and is either 'b' (that module is a bar) or 's' (that module is a space). Note that the start and stop characters are the same except that the stop character adds a "termination bar".

Each Code 93 barcode has two check characters (referred to as "C" and "K") that immediately precede the stop character. Check character "C" is a modulo 47 sum of the weighted message characters, weighted by the repeating sequence {1,2,3....19,20} weighted from right to left. Check character "K" is a modulo 47 sum of the weighted message characters , weighted by the repeating sequence {1,2,...14,15} weighted from right to left beginning with the previously calculated check character "C". An example of the check digit calculations is shown below, using the message "DATA".

To calculate "C" first find the sum of products: (13*4)+(10*3)+(29*2)+(10*1) = 150. Divide 150 by 47 to get 3 with a remainder of 9. The value of "C" is 9 which corresponds to the digit 9.

To calculate "K" first find the sum of products: (13*5)+(10*4)+(29*3)+(10*2)+(9*1) = 221. Divide 221 by 47 to get 4 with a remainder of 33. The value of "K" is 33 which corresponds to the character 'X'.

A picture of the complete Code 93 barcode is show below.

Note that the barcode reader uses the "C" and "K" check digits to decode the barcode, but does not transmit them.

Full ASCII Code 93

This library implements full ASCII Code 93. The table below shows how produce all ASCII characters using the 47 character Code 93 character set.

The Barcode Bitmap Workspace

There are three different projects in the Barcode Bitmap workspace. The first and most important project is the bblib project. This project is a static library where code to draw all of the different types of barcodes exists. This also is the main piece of code discussed in this series of articles. Another project Barcode Bitmap workspace is the bbdll project. This project is simply a regular DLL wrapper around the bblib static library. The final project in the Barcode Bitmap workspace is the DLL client project. This project is a simple dialog-based application that calls the bbdll DLL to draw barcodes in the dialog, or put barcodes on the clipboard as Windows bitmaps.

The base class CBarcode

The base class for all the barcode types discussed in this series of articles is the CBarcode class. The class declaration is listed below.

class CBarcode
{
    public:
        CBarcode();
        void LoadData(CString csMessage, double dNarrowBar, double dFinalHeight, 
                      HDC pDC, int nStartingXPixel, int nStartingYPixel, 
                      double dRatio = 1.0);
        virtual void DrawBitmap() = 0;
        virtual void BitmapToClipboard() = 0;
        virtual ~CBarcode();
        long GetBarcodePixelWidth();
        long GetBarcodePixelHeight();
    protected:
        CString m_csMessage;
        HDC m_hDC;
        long m_nFinalBarcodePixelWidth;
        long m_nNarrowBarPixelWidth;
        long m_nPixelHeight;
        long m_nStartingXPixel;
        long m_nStartingYPixel;
        long m_nSymbology;
        long m_nWideBarPixelWidth;
        virtual void DrawPattern(CString csPattern) = 0;
};

There are a few things to note about the CBarcode class. First note that it has data members that contain all of the useful data needed to draw a barcode message. This data includes the narrow element pixel width, the wide element pixel width, the message, and the symbology. Second the class has data members that contain information about how to output the barcode message. This data includes a device context handle, and a starting X and Y pixel. Third the class has some public member functions to intialize the class by loading data, and obtain information about the barcode message, namely its pixel height and width. Fourth the class has several abstract member functions that make this class an abstract base class. Any classes derived from CBarcode will be expected to implement these functions.

The CCode93 class

The CCode93 class is the class to implement to draw a Code93 barcode. The class declaration is listed below.

class CCode93 : public CBarcode  
{
public:
    CCode93();
    virtual ~CCode93();
    void BitmapToClipboard();
    void DrawBitmap();
private:
    void    ASCIItoCode93Sequence( long nASCIINumber,
                                    long *nFirstNumber, 
                                    long *nSecondNumber);
    void    DrawCheckDigits();
    void    DrawPattern(CString csPattern);
    CString    RetrievePattern( long c );
}

The class has two public functions BitmapToClipboard() and DrawBitmap(), plus it inherits the LoadData() function from the CBarcode class. The steps to use the class are simple, declare an instance of the class, call LoadData() to intialize class data, and then call either BitmapToClipboard() if you want to put a bitmap of the barcode on the clipboard, or call DrawBitmap() to draw the barcode message.

Drawing a Barcode to a Device Context

The following code snipet is an example using DrawBitmap().

CString            csMessage;
double            dNarrowBar,dHeight;
HDC            pDC;
long            nStartingXPixel, nStartingYPixel;
CCode93            oBarcode;

// assign variable values here


// call LoadData and draw the barcode

oBarcode.LoadData(csMessage,dNarrowBar,dHeight,pDC,
                  nStartingXPixel,nStartingYPixel);
oBarcode.DrawBitmap();

Drawing a Barcode to the Clipboard

The following code snipet is an example using BitmapToClipboard().

HDC            hDC = NULL;
double            dNarrowbar,dHeight;
CCode93            oBarcode;

// assign variable values here


// call LoadData and BitmapToClipboard()

oBarcode.LoadData(csMessage,dNarrowBar,dHeight,hDC,0,0);
oBarcode.BitmapToClipboard();

Note that when using the BitmapToClipboard() function, you can pass a null device context handle and zeroes for the starting X and Y pixel in the LoadData() call. Obviously the starting X and Y pixels are meaningless on the clipboard, but what about the null device context handle? The answer to that question can be found by looking at this code snipet from the BitmapToClipboard() function.

CDC    memDC;
memDC.CreateCompatibleDC(NULL);

So the BitmapToClipboard() function creates its own memory device context by using the memDC.CreateCompatibleDC(NULL) function call. A quick look at the MSDN documentation shows that if you pass a NULL value to CreateCompatibleDC, the device context created is compatible with the screen.

CBarcode::LoadData() details

The parameters for CBarcode::LoadData() deserve some further explanation and this seems like the place to do it. The first parameter, csMessage is simply the message you wish to be drawn as a Code 93 barcode. The next parameter dNarrowBar is the width of each module in inches. The parameter dHeight is the height of the barcode in inches. The parameter pDC is a handle to the device context that the barcode will be drawn in. The next two parameters, nStartingXPixel and nStartingYPixel define the coordinates to start drawing the barcode. The final parameter, dRatio is the ratio of wide/narrow element widths, and has no use in a Code 93 barcode. If you look at the declaration of CBarcode::LoadData(), you'll see the parameter dRatio has a default value of 1.0. So when using LoadData() for a Code 93 barcode, you can just leave out the dRatio parameter. If you remember the declaration of the CBarcode class above, you'll remember that it stores all width and height information in pixels, and that it stores the narrow element width and the wide element width instead of the narrow element width and the wide/narrow element width ratio. Clearly CBarcode::LoadData() is doing some behind the scenes conversion work.

The first step to that conversion work is to get the X axis and Y axis dpi, which is done by the following code, taken from CBarcode::LoadData().

CDC    tempDC;
tempDC.Attach(m_hDC);
nXAxisDpi = tempDC.GetDeviceCaps(LOGPIXELSX);
nYAxisDpi = tempDC.GetDeviceCaps(LOGPIXELSY);
tempDC.Detach();

Once you have the X and Y axis dpi, you can calculate the pixel height, narrow element pixel width, and wide element pixel width as shown in the following code snipet.

// load the final attributes that depend on the device context

m_nPixelHeight = (int)((nYAxisDpi*dFinalHeight)+0.5);
m_nNarrowBarPixelWidth = (int)((nXAxisDpi*dNarrowBar)+0.5);
m_nWideBarPixelWidth = (int)(dRatio*m_nNarrowBarPixelWidth);

Note the rounding effect when calculating the narrow element pixel width and the wide element pixel width. The narrow element width has a lower limit of one pixel, so the barcode you can produce is limited by the physical limitations of the output device. Also note that for Code 93, the ratio will always be 1.0 and the member variable m_nWideBarPixelWidth will always equal m_nNarrowBarPixelWidth and will not be used.

Next you can calculate the final barcode pixel width, this operation is symbology specific and the Code 39 code excerpt is listed below.

nTemp = m_csMessage.GetLength();

m_nFinalBarcodePixelWidth = (((nTemp+4)*9)+1)*m_nNarrowBarPixelWidth;

This code computes the width of a Code 93 barcode by taking the message length, adding 4 to it (the start code, the "C" check digit, the "K" check digit, and the stop code), multiplying the sum by 9 (for the 9 modules), adding 1 to that product (for the stop code termination bar), and multiplying that final sum by the module width in pixels.

CCode93::DrawBitmap() details

The DrawBitmap() function is where each message character is drawn.. A listing of the CCode93::DrawBitmap() function is listed below.

void CCode93::DrawBitmap()
{
    long        i,nFirstNumber,nSecondNumber;
    CString        csCurrentPattern;

    // draw start character

    DrawPattern(RetrievePattern(47));
    
    // draw each character in the message

    for (i=0;i<m_csMessage.GetLength();i++)
    {
        // get current ASCII character

        ASCIItoCode93Sequence((long)m_csMessage.GetAt(i),
                               &nFirstNumber,&nSecondNumber);

        DrawPattern(RetrievePattern(nFirstNumber));
        if (nSecondNumber!=-1)
            DrawPattern(RetrievePattern(nSecondNumber));
    }

    // add the check digit characters

    DrawCheckDigits();

    // draw stop character

    DrawPattern(RetrievePattern(48));

    return;
}

The CCode93::DrawBitmap() function starts out by drawing the start code. Then the code steps through every character in the message and draws the characters by retrieving the Code 93 characters necessary to draw that message character (remember this could be one or two Code 93 characters). Then the two check digits are drawn, followed finally by the stop character. There are 4 private member functions used in DrawBitmap(). The function ASCIItoCode93Sequence() returns the two numbers necessary to draw the passed ASCII character in the two variables nFirstNumber and nSecondNumber. If the current message character can be drawn using one Code 93 character the nSecondNumber variable is set to -1, and the if statement skips drawing the second Code 93 character. CCode93::RetrievePattern() is basically a giant switch statement, retrieving the pattern for any Code 93 character passed to it. CCode93::DrawPattern() draws the pattern passed to it, the pattern is a CString in the form of “bsssbsbss” (the character '0') like the Code 93 character data mentioned above.

CCode93::DrawPattern() details

The CCode93::DrawPattern() function draws a single Code 93 barcode character in the passed device context. The CCode93::DrawPattern() function is listed below.

void CCode93::DrawPattern( CString csPattern )
{
    int            i,nXPixel,nYPixel;
    CDC            oDC;

    // attach to the device context

    oDC.Attach(m_hDC);

    // initialize X pixel value

    nXPixel = m_nStartingXPixel;
    
    for (i=0;i<csPattern.GetLength();i++)
    {
        // X value for loop

        for (nXPixel=m_nStartingXPixel;
             nXPixel<m_nStartingXPixel+m_nNarrowBarPixelWidth;
             nXPixel++)
        {
            // Y value for loop

            for (nYPixel=m_nStartingYPixel;
                 nYPixel<m_nStartingYPixel+m_nPixelHeight;
                 nYPixel++)
            {
                // if this is a bar

                if (csPattern.GetAt(i)=='b')
                    oDC.SetPixelV(nXPixel,nYPixel,COLORBLACK);
                else
                    oDC.SetPixelV(nXPixel,nYPixel,COLORWHITE);
            }
        }

        // advance the starting position

        m_nStartingXPixel+= m_nNarrowBarPixelWidth;
    }

    // detach from the device context

    oDC.Detach();
    
    return;
}

The CCode93::DrawPattern() function is basically three loops. The outermost loop loops thru every module in the passed pattern (bsssbsbss). The middle loop loops through every X pixel in the current module width. The innermost loop loops through every Y pixel in the current X pixel. In the center of the three loops is a simple if statement that determines if this module is a bar or a space, and sets the current pixel to black or white for a bar or space. This function is repeated for the start character, all the message characters, the two check digits, and the stop character to draw the complete Code 93 barcode.

Summary

Thats it for drawing Code93 barcodes. Part V of the series deals with drawing Code 128 barcodes. I hope you find this class library useful.

Reference

The Bar Code Book - A Comprehensive Guide To Reading, Printing, Specifying, and Applying Bar Code and Other Machine-Readable Symbols 4th Edition