With The Case Of  Release The Power OF  Visual C++ !   Home Products | Purchase Support | Downloads  
View in English
View in Japanese
View in
View in Français
View in Italiano
View in 中文(繁體)
Download Evaluation
Pricing & Purchase?
E-XD++Visual C++/ MFC Products
Features Tour 
Electronic Form Solution
Visualization & HMI Solution
Power system HMI Solution
CAD Drawing and Printing Solution

Bar code labeling Solution
Workflow Solution

Coal industry HMI Solution
Instrumentation Gauge Solution

Report Printing Solution
Graphical modeling Solution
GIS mapping solution

Visio graphics solution
Industrial control SCADA &HMI Solution
BPM business process Solution

Industrial monitoring Solution
Flowchart and diagramming Solution
Organization Diagram Solution

Graphic editor Source Code
UML drawing editor Source Code
Map Diagramming Solution

Architectural Graphic Drawing Solution
Request Evaluation
ActiveX COM Products
Technical Support
  General Q & A
Discussion Board
Contact Us


Get Ready to Unleash the Power of UCanCode .NET

Visual C++ Print /VC++ Printing Class Library

Tables Printing, and Report Printing, it also with Form printing

Free download source codes Links

"Diagramming business logic when developing a custom application is a time-consuming, tedious—and necessary—process. With E-XD++ Diagramming Source Code Kit, you can spend more time focusing on the finer points of your customer's business and less time worrying about making the business process diagram look good. "

Tooltips CToolBar EnableToolTips and CBRS_ALIGN_ANY | CBRS_TOOLTIPS | CBRS_FLYBY with_countof

SCADA Automation Programming Tool And visualization component Control VC++ Source Code Solution

RichEdit Control in MFC CRichEditView and MSFTEDIT

Create COM Object, Build COM Component, ATL Component with Visual C++

Free VC++ Port / IO Serial Communication Source Code

Visual C++ Express Download

HMI-SCADA Software from UCanCode Software

HMI-SCADA Visualization Solutions for C/C++, Java, C# and VB

Hosting WPF Content in an VC++ MFC Application


C# Article: Graph Draw and Layout Control Source Code

Screen Capture , to Clipboard, C++ Source Code, Get bitmap of Window

Visual Studio 2013

SVG Vector Graphics Editor With Source Code

Read DXF File, Write DXF File, Draw DXF File and autocad with source codes

Direct2D Vector Graphics Rendering with Visual C++, MFC

Free Graphics and Free Meter, Free Dials with C/C++ Source Code, ActiveX Control, .NET

Visual C++ Article: free image library with image viewer with CxImage and CListCtrl thumbnail images

OPC Client, OPC Server and OPC Component in C++ Source Code

UML Case Diagram, UML Sequence Diagram, VC + +/.NET visualization component library source code

VC++ Example and Article: Drawing Double Buffering With GDI+

VC++ Converting ANSI to Unicode with _MSC_VER, MBCS, Multiple Byte

Download Visual Assist

AutoCAD File Format, Read and Write drawing with Visual C++ Source Code

Printing ActiveX Controls, C++ Source Code

Call Lua Script in Visual C++ / MFC Sample

DXF File, Read and Draw, Import and View .NET and C++ Source Code

Factory Pattern in C++

Play GIF, Load GIF, GIF Animate, with GDI+ Example

Serial Port Communication, Read data from port Visual C++ Samples

Graphics Drawing Tool by with C# Source Code

PID process control, Process Simulation, PLC Real Time, VC++ Source Code

High-speed Charting Control, Real Time Chart, Data Visualization, C# Source Code

Visual C++ MFC Class Wizard

CXImage Library, PNG, Show, Pocket PC with VC++ Sample

Graphics Library for WinCE, Draw Bitmap, Draw Gif, Draw Jpg with Win CE, Visual C++ Codes

First time here?

Product Tour
E-XD++ product walkthrough

Applications built on E-XD++

Product feature comparison

Powerful, flexible, and easy to use Diagram Components.
Powerful and flexible enough to create diagrams exactly the way you want them to appear. So easy to use that you will be able to prototype your application in just a few minutes.

Feature rich.
With features such as automatic layout, multiple layers, collapsible sub-graphs, snap-to connection points, XML, SVG, and more, E-XD++ Have the power and flexibility you need to create sophisticated diagrams, quickly and easily. Events such as click, double-click, hover, select, rubber-band select, copy, delete, resize and move are supported. Operations such as drag-and-drop, unlimited undo/redo, and clipboard operations are common and complex, and are expected by today's sophisticated users. it full supports importing ArcGis, SVG and DXF File format.

Performance and Scalability.
UCanCode E-XD++ Capable of handling many thousands of nodes and edges, up to hundreds of thousands depending upon the complexity of the nodes you wish to draw and the operations you wish to allow. Our graphical classes are extremely lightweight objects enabling outstanding performance.

Save Time and Money and gain Reliability.
A diagram is worth 1,000 words, and E-XD++ is shipped with more than 500,000 lines of well designed and well tested code! It is used by hundreds of the world's most quality conscious companies. It will saves you thousands of hours of complex coding and years of maintenance.


  • Download demo project - 104 Kb
  • Download source files - 49 Kb

    Full class documentation available here.

    This class library is designed to provide printing and print preview capabilities to applications developed using the Microsoftİ Foundation Class Library. In our business we have need to emulate many pre-printed business and insurance forms. In some cases the client wishes us to print the entire document and in others just fill in the fields with information gathered or generated by the application. This class eliminates the need to use and ship report generators with your application.

    Below is some output from the library functions. These images were taken directly from the print preview window running the demo program. Much more detailed printing is possible with the functions as written. They are also easily modified for special needs.

There was no commercial solution that we could find to do this so we started from scratch. It was an interesting journey.

There is probably no portion of MFC programming that is as mis-understood and poorly documented as printing. Most books and training films give it very short thrift and then it's on to the flashy GUI stuff we all love.
Lot of programs resort to using a commercial report writing tool to handle simple printing chores and others simply direct screen drawing to the printer DC in a crude kind of screen print. We found this unacceptable.

The classes are divided into two logical sections. The file Cprinter.cpp holds the low-level printer primitives. Suprisingly there are only three of them:

virtual int PrintText(PRTTYPE *ps,double LineSpacing);
virtual void DrawLine(PRTTYPE *ps,int LineSize);
virtual void DrawRect(PRTTYPE *ps,int LineSize);

These are all that we needed to provide a large amount of printing options. If you wish to add more low-level capabilities this is the place to put them.

The higher level constructs are in the file Cpage.cpp. The classes here are:

  • CPage represents a page of printed output. MFC printing architecture provides for printing on a page by page method. CPage holds and manipulates data concerning that page. There are member functions to output text, draw boxes and lines, create and use moveable print regions, and create and use tables of data. Fonts and text attributes can be changed freely and newspaper type columns are supported. Much of this functionality is provided by helper classes that are created by CPage as needed and used. These classes are:

  • CTable represents a table of data. A table is much like a grid. It has rows and columns. It can have vertical and/or horizontal separations, a border, and a title. Each column in the table is composed of a class that holds a description of the column. This is the header for that column and the width of the column. Please see the documentation and the sample code for the use of tables. In essence the use is really simple. You create a variable of type CTABLEHEADER either on the stack or the heap and set its member variables to describe the table you wish to use. You the pass a pointer to the filled in structure to CPage via the CPage::Table(CTABLEHEADER*) function. The table is constructed and displayed at this time. Data may be added to the table using overloaded functions in CPage that are the same as used to print to the page. Look at the documentation and the sample source code for details

  • CPrintRegion represents a sub region of the printed page that is to be treated as a single object. This region may contain textual data, columnar output, check boxes, and graphics but is to be treated as a single unit. The region can have a border and a title id desired. Move the region and all its contents move with it. This allows story boarding of the page. Since most forms have areas that are logical units these can be considered as a print region. Then when the client ucancode.nets if you can move this here and that there it is a simple of placing the new co-ordinates in and recompiling. Everything moves with the region. CPage::CreateRegion() will return a pointer to a newly created CPrintRegion class. Since CPage actually creates this pointer it keeps an internal list of pointers and deletes the when the CPage:~CPage() destructor runs. DO NOT DELETE A CPrintRegion * passed to you from CPage as a page fault may occur when the destructor runs.
All of these classes (CPage CTable CPrintRegion ) are defined in CPage.h and implemented in CPage.cpp.The bit map printing is in dib.cpp and dib.h. In order to implement the class functionality in your application include these files in your project and include the line #include "cpage.h" in any file using the classes.

There is a RTF file titled REFERENCE.rtf included in the source code that contains more detailed information on the class members and their use.There is also a html file by the same name. I suggest that you download the demo project as it shows how to use the more esoteric features of the classes. It contains sample code exercising most of the class members.

One thing that we learned from this project is that it is possible to be to object oriented.
At one time we had a CParagraph and a CSentence and a CTitle etc. It really just got to be more trouble than it was worth. We think we have hit a happy medium here. This code is being used as the basis for ad hoc report writers, data base output, forms generation, and several other tucancode.nets and has proven to be pretty stable. It has not been tested on Win3.1 but the original code was and was developed there so barring any MFC 32 bit stuff it should compile and run fine in 3.1.

I have added the ability to print disk based bit maps to the library. The function is PrintBitMap() and is documented in REFERENCE.rtf. Most of the code was taken from a sample program included with the compiler and modified to fit into this library. The print functions have the ability to print over the bitmap(s). This allows one to scan a form and later print it and place data on it or to place boilerplate printing in a bit map and print only those portions of the form you wish. It is also handy for printing company logos, letter head, etc.

This code snippet shows how the classes are used in the view class:

void CMainView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
        CPage* ps = new CPage(pInfo-m_rectDraw,pDC,MM_TEXT);
        if(PRINTWHAT==0) PrintForm1(ps);
        if(PRINTWHAT==1) PrintForm2(ps); // subform demo
        if(PRINTWHAT==2) PrintForm3(ps); // table demo
        if(PRINTWHAT==3) PrintForm3(ps); // bitmap demo
        delete ps;

Below are some small examples of how the classes are used.

void PrintForm1(CPage* pPage)
    double Row; 
    //Print a bitmap
    //Print a title
    Row = pPage-Print(0.0,0.0,TEXT_NORMAL|TEXT_CENTER,24,"Form Title"); 
    //create and use a print region
    CPrintRegion *Region1=pPage->CreateRegion(.5,0.0,1.5,3.9);
    Region1->DrawTitle("Customer Information",8,TEXT_BOLD|TEXT_CENTER|TEXT_RECT,FILL_NONE);
    Row = pPage->Print(Region2,0.0,0.01,TEXT_NORMAL|TEXT_SINGLELINE,9,"Name");
    Row = pPage->Print(Region2,Row,0.01,TEXT_NORMAL|TEXT_SINGLELINE,9,"Location"); 

//create and use a table
pTable->PointSize = 10;
pTable->LineSize = 1;

//default shown only for demo purposes
pTable->UseInches  = TRUE;
pTable->AutoSize   = FALSE;
pTable->Border     = TRUE;
pTable->FillFlag   = FILL_NONE;
pTable->NumColumns = 5;
pTable->NumRows    = 12;
pTable->StartRow   = 0.0;
pTable->StartCol   = 0.0;
pTable->EndCol     = 8.0;

pTable->ColDesc[0].Init(1.0,"Item #",FILL_NONE);
pTable->ColDesc[4].Init(1.0,"Ext Cost"); 


//place information in a table 
pPage->Print(pTable,0,1,12,TEXT_CENTER|TEXT_BOLD,"SmallCray Computer");

CPage Class Reference
In order to use the printing functions in your project you need to include the files:


In any file where reference to the printing functions is needed include the header file:

That’s all that is needed to incorporate the printing functions. If you find this library useful let me know. (

Table of Contents

  • CPrinter Class
  • Prttype Structure Definition
  • CPage Class Definition
  • Functions

    Not all functions are located here. Consult the demo program or CPage.h for a complete list

    CPage Constructor
    Rotated Text

    Print(TABLEHEADER* )


    Printer Class Documentation

    Class definitions located in CPrinter.h

    Functions in CPrinter.cpp: This is a low-level printer function class. All calls from the higher-level functions will eventually get here to one of the printer primitives. To add functionality to the high level class(s) it is best to let the high level classes handle all formatting etc and call simple primitive output functions. This will make porting to a different output device or operating system a little easier. Below is the class definition of the low-level class CPrinter.

    class CPrinter{
        virtual ~CPrinter();
        virtual int GetPrintInfo(PRTTYPE *ps,double LineSpacing);
        virtual int PrintText(PRTTYPE *ps,double LineSpacing);
        virtual void DrawLine(PRTTYPE *ps,int LineSize);
        virtual void DrawRect(PRTTYPE *ps,int LineSize);

    int GetPrintInfo: This function will set internal variables without actually printing the output string. It is mainly used internally.

    int PrintText: The workhorse. Just about every call gets routed here eventually. This function creates a font each time it is called and calculates print parameters and changes internal variables. If the class is to slow this is where it can be sped up considerably. The return value is the next logical print line. It is calculated using the current map mode, font size, and spacing factor.

    void DrawLine: Line drawing primitive. Very basic.

    void DrawRect: Rectangle drawing function. Very basic.

    The class user should call none of these functions. Use the higher level calls. However, if minimal print functionality is all that is needed this can be a standalone library and does have quite a bit of functionality



    PRTTYPE structure definition

    The PRTTYPE structure is used to hold information about the current print page and the current output string. It also retains information across printer calls that can be used in determining future output selections. It is defined below:

    typedef struct tagPrinter{
        CDC *pDC;
        RECT rc;
        int PointSize;
        CString Text;
        UINT uTextFlags;
        UINT uFillFlags;
        UINT uPenFlags;
        CString FontName;
        UINT n_maxWidth; // max width of formatting rect
        UINT n_maxLength; // ditto len
        UINT n_minNextLine; // next posiible legible line
        int m_NextCharPos; // pos in line of next char
        int m_MinDisplacement;
        RECT LastPrintArea; // printing rect last used
        TEXTMETRIC* tm;

    This structure is a member of the Cpage class and is maintained internally. It is initialized in the Cpage constructor using information passed. The TEXTMETRIC field ,LastPrintArea, and m_NextCharPos are calculated and changed by each call to PrintText(). The print behavior is modified by changing the uTextFlags and uPenFlags variable ( see definitions in CPrinter.h ) .The current output string is contained in the variable Text ( isn’t that remarkable ). The parameters are set using information passed to the various output routines.



    CPage Class Definitions

    CPage contains most of the class functionality. CPage.H and CPage.Cpp contain the class headers and class definition.

    All of the print routines have a new override added that takes a user supplied integer indentifier and passes it to a user suppled function that will return the text to be printed. This function must be in the form of: LPCSTR (*PF_REMOTE)(int) which is defined in CPage.h. This function is set by a call to CPage::SetUserFunction(UserFunctionAddress). If this function is not called all the output routines called form the functions calling the user defined function will do no output and those that return a value will return 0. All of the Print and PrintColumn functions, including those that print to regions, have this over ride. The demo program has been updated to show these functions in a working example. These functions are included to make it easier to design a data independant form and to facilitate using the library as a portion of a report generator, form generator, etc. See PrintForm5(CPage* ps) located in PrintForm1.cpp. A sample user defined function is shown below:

    LPCSTR MyFunction(int ID)
        static CString S;
            case ID_1:          
                return "Called From User Function ID 1";
            case ID_2:
                return "Called From User Function ID 2";
            case ID_3:
               return "Called From User Function ID 3";
            case ID_4:
               return "Called From User Function ID 4";
            case ID_5:
               return "Called From User Function ID 5";
            case ID_6:
               return S;
        return "*****unknown ID Passed*****";

    This is a very simple version of a user function but demonstrates how it is used. In real life it would be more complex and probably call other functions, do calculations, and other data manipulation tucancode.nets. Just as long as it returns a pointer to a output string all is well. The string is used immediatly and need not be persistant. Static buffers can be re-used between calls. However if CStrings or other variables are used as buffers be certain that they are either static or created on the heap and not destroyed until after use. Variables set on the stack frame will not be accessable to the output routines because they will go out of scope on he user function return. In order to set the call up you will call:



    This can be called more than once thereby replacing the active function making it possible to have several output functions for the same page. The effect of this technique is a lot like subclassing the CPage object but without the overhead. The user defined function should be prototyped as typedef LPCSTR (*PF_REMOTE)(int). An example is :

    LPCSTR MyFunction(int ID)
             case ID_1:
                 S="Called From User Function ID 1";
                 return S;
             case ID_2:
                 return "Called From User Function ID 2";
        return "";

    There is a special over ride of the Print function:

    virtual double Print(double row,double col,UINT TextFlags,int PointSize,int ID);

    This function works in conjunction with the SeUserFunction in that the user defined function is called to supply the prit text. See the demo program for details.


    void PrintStuff(CPage* ps)
         double row = ps->Print(0.0,0.0,TEXT_NORMAL|TEXT_CENTER,24,"User Demo");
         row = ps->Print(row,0.0,TEXT_BOLD|TEXT_ITALIC|TEXT_CENTER,24,ID_1);

    static void SetPrinterMode(CDC* pDC,int Mode=DMORIENT_PORTRAIT);

    This function will change the printer orientation of the printer. IT CANNOT BE CALLED AFTER THE CONSTRUCTOR for Cpage is called and as such is a static member function. It must be called by a function in the function chain somewhere before the OnPrint() or OnDraw() function is called and after access to the CDC for the print job is available. The recommended place to call the static member function is your CView::OnPrepareDC() override. The CDC passed to this function will be changed by this function call. The mode parameter must be either DMORIENT_PORTRAIT ( default ) or DMORIENT_LANDSCAPE.


    void CMainView::OnPrepareDC(CDC* pDC, CPrintInfo* pInfo)
        CView::OnPrepareDC(pDC, pInfo); // always call base class first
        switch(pInfo->m_nCurPage) // switch modes based on page number
            case 1:CPage::SetPrinterMode(pDC);break;
            case 2:CPage::SetPrinterMode(pDC,DMORIENT_LANDSCAPE);break;

    For users not familiar with static member functions. The above code creates a CPage object on the stack and executes the member function. The function does not depend on or alter any data in the class so it needs no virtual table entry or a this pointer. ( as a matter of fact in CANNOT read or write and class data at all) There will be one and only one copy of the function created no matter how many CPage objects that there are. This is a poor explanation of static member functions; please consult the MS documentation for details. HA!



    static LPCSTR GetPrinterName(CDC* pDC);

    This function will return the name of the selected printer driver in use for this CDC. The driver cannot be changed but can be used to switch between options. This function and the above function also demonstrates the method of get data from and changing data in a DEVMODE structure. This method can be used to change paper size DPI etc for all supported printers,


    CPage(RECT rectDraw, CDC* p_Dc, int MapMode=MM_ANISOTROPIC)

    This is the class constructor. There is no private constructor override. This class is designed to be used in conjunction with MFC and makes use of the Cview class printing architecture. The parameters are:

    RECT rectDraw The drawing rectangle to be used by this output device. ( see example )

    CDC* The display context object passed by MFC to the print function
    Int mapMode The supported mapping modes are MM_TEXT and MM_ANISOTROPIC

    Example of use:

    void CMainView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
        double Row,Col;
        CPage* ps = new CPage(pInfo->m_rectDraw, pDC,MM_TEXT);
        Row=ps->Print(6.5,4.0,TEXT_NORMAL,10,"This is a test");
        delete ps;

    int Print(int row,int col,char* fmt,...); // use cpage default parameteres for flags pt size etc...
    int Print(int row,int col,UINT TextFlags,int PointSize,char* fmt,...);

    The workhorse. This function has many different overloads*. All class functions are designed to use several different units of measurement. In MM_TEXT map mode the native unit is pixels, which can vary from output device to output device. In MM_ANISOTROPIC the units are user defined in both axis. The default for this class is 1000 by 1000. The library can also function in terms of inches. The passed parameters are converted to native units before being passed to lower level functions. Inches present the problem of being fractional in value and not integral. To facilitate the ease of use the library makes the following assumptions to all calls to the Print functions (With one exception noted below). If the value is a double it is treated as a inch measurement. If one of the location variables (Row and Col) is a double the other must be a double also. The parameters are:

    Int row the vertical displacement for the print line. Displacement is relative to the top of the page.
    Int col the horizontal displacement for the print line. Displacement is relative to the left side
    ( both of these parameters can be doubles and if so are treated as inches )
    UINT Textflags Modify the appearance of the output string. See CPrinter.h
    Int PointSize The number of points to use for the font.
    Char* fmt a printf type format string.
    Example of use:

     Void PrintStuff (CPage* ps)
        Row = ps->Print(6.5,4.0,TEXT_NORMAL,10,"This is a test");
        Row = ps->Print(Row,4.0,TEXT_NORMAL,10,"This is a test Also");
        Row = ps->Print(Row,4.0,TEXT_NORMAL,10,"This is a test Also as is this");
        Col = 1.0; 
        ps->Print(Row,&Col,TEXT_NORMAL,10,"This is a test Also as is this");
        ps->Print(Row,&Col,TEXT_BOLD,10,"is Italic");

    Consult CPage.h for details on all the various overloads. There are many.

    int Print(int row,int *col,UINT TextFlags,int PointSize,char* fmt,...) is a special override that takes a pointer to the column variable. (See example above). On execution the column variable is updated to the next column position. Subsequent calls to Print using the variable will result in the output being a continuos line allowing different attributes to be assigned within a line of text. It is useful when printing a series of question/answer type forms also as the variable will point to the next logical horizontal print area at all times. There are also two overrides of this function that take only Row,Column, Text parameters and get the rest of the information from the defaults set into the CPage object.


    void PrintColumn(int Top,int Left,int Bottom,int Right,UINT flags,int PointSize,LPCSTR Text);

    Print function to allow for newspaper style print columns. The location variables function in the same manner as in Print() above but have two extra dimensions to describe a bounding rectangle. All text will be printed in the rectangle. If the flags variable includes TEXT_RECT the bounding rectangle will be drawn on the output device. See Print() for variable usage.


    Example of use:

    Void PrintStuff (CPage* ps)
                 "This is a test of the column wrap feature");
                 "This is a test of the column wrap feature ");

    double SetLineSpacing(double Spacing);

    Set the constant used in calculating the next logical print line.. The amount needed to get the affect you want will vary so experiment. Should be no smaller than 1.0


    LPCSTR SetFont(LPCSTR FontName);

    Set the default font name. The constructor sets it to "Times New Roman". Spelling does count. The old font name is returned from this function. If all you want is the font name use SetFont(NULL) to return the current font name.


    int SetFontSize(int sz);
    Set default font pointsize.

    COLORREF SetColor(COLORREF Color);
    If the output device supports color set the current color here. Returns the old color.

    virtual int SetRightMargin(int width)
    Change the size of the default printing rectangle right margin. A value of -1 will reset it to MaxWidth. A value of 0 will just return the current value.Returns the previous width.

    int SetBottomMargin(int length);
    Same as above except the margin affected is the bottom

    double SetRightMargin(double width);
    See above

    double SetBottomMargin(double length);
    See Above

    CDC* GetDisplayContext();
    Return the display context used for this page. Can be used for direct manipulation of the context

    Example of use:

    void PrintStuff (CPage* ps)
       CDC*  pDcpDc=ps->GetDisplayContext();

    void PrintBitMap(int top,int left,int bottom,int right,LPCSTR name);
    void PrintBitMap(double top,double left,double bottom,double right,LPCSTR name);

    Prints a bitmap from a disk file into a region of the page. The numeric parameteres are location vectors for the bounding rectangle and the LPCSTR param is the name of the file to print. Disk based bitmaps are directly supported as there are many ways to print a resource bitmap.

    Example of use:

     Void PrintStuff (CPage* ps)

    double GetNextLogicalColumn(BOOL Convert=TRUE,BOOL AddOffset=FALSE);

    Returns the next logical print column based on the last call to Print(). This must not be used prior to a call to Print() as garbage will be returned. Parameters are:

    BOOL Convert if true will return result in inches
    BOOL AddOffset if true will add extra space to column to give separation.
    Example of use:

    Void PrintStuff (CPage* ps)
        double Col; 
        ps->Print(6.5,4.0,TEXT_NORMAL,10,"This is a test");
        Col = ps->GetNextLogicalColumn(TRUE);
        ps->Print(6.5,Col,TEXT_NORMAL|TEXT_ITALIC,10,"This is a test Also");
    Output will be "This is a test.This is a test also" starting 4 inches over and 6.5 inches down. The common usage is to apply special formatting to indivivual words in a sentence.

    void Line(int top,int left,int bottom,int right,int LineSize=1,UINT flag=PEN_SOLID);
    void Box(int top,int left,int bottom,int right,int LineSize=1,UINT Fillflags=FILL_NONE,UINT PenFlags=PEN_SOLID);

    Drawing primitives exposed to user. Parameters can also be doubles. If so they represent inches.Parameters are:
    Int top,left,bottom,right: top/left define the position of the left starting point
    Bottom/right the right.

    In the case of a rectangle the points describe the bounding area to draw the rectangle around
    Int Linesize Determines thickness of the line used to draw the shape 1 is smallest
    Int Fillflags determines if area is filled with color see CPrinter.h for definitions
    Int Penflags Pen type used to draw See CPrinter.h for definitions

    Example of use:

    Void PrintStuff(CPage*ps)

    void CheckBox(LPSTR Caption,BOOL Data,int top,int left,int FontSize,int Direction=LABEL_RIGHT,int LineSize=2,UINT Fillflags=FILL_NONE,UINT TextFlags=TEXT_NORMAL|TEXT_NOCLIP|TEXT_SINGLELINE);

    Draws a Checkbox on the output device. Parameters are :
    LPSTR Caption The text accompanying the checkbox
    BOOL Data The true/false expression to be shown
    Int top,left The starting position to print the Checkbox. Can be doubles.If so units are inches.
    Int Direction either LABLE_RIGHT or LABEL_LEFT
    Int Linesize Thickness of pen used to draw the boxUINT Fillflags If set to any value other than FILL_NONE the checkbox will use the fill color to fill the box rather than Xing the box
    UINT TextFlags Define text attributes (See CPrinter.h)

    Example of use:

    void PrintStuff (CPage* ps)
        ps->CheckBox("A Test",TRUE,1000,1000,12,LABEL_LEFT,2,FILL_BLACK,TEXT_BOLD);
        ps->CheckBox("A Test again",TRUE,1100,1000,6,LABEL_RIGHT,2,FILL_NONE,TEXT_BOLD);
        ps->CheckBox("A Test",TRUE,8.0,1.0,12,LABEL_LEFT,2,FILL_BLACK,TEXT_BOLD);
        ps->CheckBox("A Test again",TRUE,9.0,1.0,6,LABEL_RIGHT,2,FILL_NONE,TEXT_BOLD);


    Tables are a method of showing tabular data. They are similar to a grid control, only printed. Many business forms are simply a series of tables. The table metaphor has been implemented by use of three helper classes:

    class CPrintTable;
    class COLUMNDATA;
    class TABLEHEADER;
    TABLEHEADER is a very simple class that describes a table of data. It is described below.

    class TABLEHEADER {
        BOOL UseInches;     // if set to true all points passed are considered to be in inches
        BOOL AutoSize;      // if set true will make all columns the same size
        UINT FillFlag;      // see fillflags in CPrinter.h default FILL_NONE
        int PointSize;      // Pointsize for header
        int LineSize;       // line size
        int NumColumns;     // number of columns in the table
        int NumRows;        // number of rows in the table
        BOOL Border;        // if true draw aborder around table default TRUE
        BOOL Vlines;        // if true separate items with vertical lines default TRUE
        BOOL HLines;        // if true separate items with horizontal lines default 
        BOOL HeaderOnly;    // if true display header only (virtual table)
        BOOL NoHeader;      // if true only draw the boxes no headers
        int HeaderLines;    // number of lines in header default 1
        int NumPrintLines;  // logical number of visable print lines per cell default 1
        double StartRow;    // starting row position ( seeUseInches above )
        double StartCol;    // stating column position ( see UseInches above)
        Double EndCol;      // ending column position ( see UseInches)
        Double EndRow;      // This is determined by the class and is available to the end user
        COLUMNDATA ColDesc[20]; // see COLUMNDATA class description
        CprintTable* pClsTable; // ptr to object ownibg this header

    Example of use:

    pTable->EndCol=  8.0;
    pTable->ColDesc[1].Init(3.0,"Limits ofLiability");
    ps->Print(pTable,0,0,8,TEXT_LEFT,"Section I - Coverage A: Dwelling");
    ps->Print(pTable,1,0,8,TEXT_LEFT,"Section I - Coverage A: Other Structures");
    delete pTable;

    Class COLUMNDATA is also a very simple class. Its total functionality is demonstrated above. It is a member of class TABLEHEADER and is created when it is and destroyed with it. Just use it to describe the columns width and caption. The width unit of measurement is determined by the TABLEHEADER UseInches variable.

    class COLUMNDATA
          double Width;
          CString Text;
          COLUMNDATA() { Width = 0; Text.Empty(); };
          Void Init(double nWidth,LPCSTR lpzText) { Width = nWidth; Text = lpzText; };

    Class CPrintTable is used internally and should not be exposed. It actually draws and fills the table with data. It is called and used by CPage . See the source code for details.

    Tables are attached to the page by using the function CPage::Table(pValidTableHeader). Once the TABLEHEADER has been created and filled in pass it to the CPage class using this function. The Table is drawn on the output device at this point. The variable LastRow is filled in at this time and is available for use.If you are stacking tables this variable will tell you where to start the next table. See example below.

    There is an overloaded Print() function in CPage that allows data to be inserted into the table:


    virtual void Print(TABLEHEADER* TheTable,int row,int col,int PointSize,UINT TextFlags,char* fmt,...);

    In creating a table if the data element NumPrintLines is greater than 1 each cell will be made large enough to contain multiple print lines. The size will be determined from the font size used to create the table. If you use a smaller font in printing there may be more visible print lines than you specified. The standard Print(TABLEHEADER,...) overide of the Print function will operate in a different manner if the value is set to more than 1. See CTable::InsertItem for details. Word wrap and text clipping is in affect unless overridden.

    The Row and Col parameters that usually show position indicate the table row and column in this overload. Other than that it operates just like the CPage::Print() statement

    Example of use:

        double lastRow=pTable->EndRow;
        ps->Print(pTable,0,0,8,TEXT_LEFT,"Section I - Coverage A: Dwelling");
        ps->Print(pTable,1,0,8,TEXT_LEFT,"Section I - Coverage A: Other Structures");

    That’s all there is to using tables. They are used a lot in business forms and insurance applications.




    Regions are a lot harder to describe than to use. A Region is a area of the page that you wish to treat as a single item. It may contain Text or checkboxes or columns. It may have a title and a border. If the location of the region moves then all of the data contained in the region moves with it. Many forms have areas that contain data on specific topics. Many times you’ll get everything finished and someone will say "Boy it would be neat if that section was here and that one here". Regions are the cure for that. The class CPrintRegion implements regions. It is really a very simple class. Data is put into Regions using, of course, overloaded versions of the CPage::Print() CPage::PrintColumn() and CPage::CheckBox() functions already described. The functions all take one extra parameter. A pointer to a CPrintRegion. You obtain a pointer to a CPrintRegion by calling one of these two functions defines in CPage:


    virtual CPrintRegion* CPage::CreateRegion(double ptop,double pleft,double pbottom, double pright);
    virtual CPrintRegion* CPage::CreateRegion(int ptop,int pleft,int pbottom, int pright);
    CPrintRegion* CreateSubRegion(CPrintRegion* pParent,int ptop,int pleft,int pbottom, int pright);
    CPrintRegion* CreateSubRegion(CPrintRegion* pParent,double ptop,double pleft,double pbottom, double pright);

    As usual if the position is passed as a double we assume that all measurements are in inches.
    The only callable functions from CPrintRegion are DrawBorder() and DrawTitle(). See the header file in CPage.H for details. Subregions are simply regions that are referenced to another region. A Subregion is completly contained in the parent region and all offsets are based on the parent region at creation. If the parent region is moved the subregion moves with it.Usage of these functions are shown below.

    Example of use: 

    Void PrintStuff (CPage* ps)
        double Row;
        PrintRegion *Region1=ps->CreateRegion(1.0,1.0,2.0,4.0);
        CPrintRegion *SubRegion1=ps->CreateSubRegion(Region1,0.0,1.0,2.0,2.0);
        Region1->DrawTitle("The Title",8,TEXT_BOLD|TEXT_CENTER|TEXT_RECT,FILL_NONE); 
        ps->CheckBox(Region1,"A Test",TRUE,.2,0.0,12,LABEL_LEFT,1,FILL_NONE,TEXT_BOLD);
        Row=ps->Print(Region1,1.0,0.0,TEXT_NORMAL,14,"This is a test");
        ps->Print(SubRegion1,0.0,0.0,TEXT_BOLD,"In subregion");


    There are overrides for all the line and box drawing routines. They work just like CPage::Line() and CPage::Box() with he exception of the first parameter which is a pointer to a CPrintRegion. They are not documented here but see the source code for details. They do provide some checking for parameter validity and assure that drawing only takes place within the region passed.. As usual all offsets are relative to the region not the page. A offset of 0,0 refers to the first printable spot in the region, whereever it is located. If offsets are outside the region they are adjusted back to fit within the region.


    void PrintRotatedText(double Top,double Left,double Bottom,double Right,UINT flags,int PointSize,LPCSTR Text,int angle);

    This function allows one to print text rotated thru 360 degrees. The angle of orientation is expressed in 1/10 of a degree and represented as an integer for 0 to 3600. Parameters are
    double Top,Left,Bottom,Right. Boundries of text clipping area. TEXT_NOCLIP should be used to rotate text thru non region areas.
    UINT Flags are the standard text flags
    int Point size is the font size
    LPCSTR Text is , of course, the text
    int angle is the rotation angle expressed in 1/10 of a degree. Valid range is 0-3600.
    Example of use:

    Get Business Card / Label Print Component C++ Source Codes

    Draw transparency  image file, Alpha Blending using GDI+ Sample

    VC++ MFC Project Setting, Unicode, MBCS,_MBCS or _UNICODE, wWinMainCRTStartup

    For more about printing component, click here. 

    Contact UCanCode Software

    To buy the source code or learn more about with:

    Ask any questions by MSN: Yahoo:


    Copyright ?1998-2011 UCanCode.Net Software , all rights reserved.
    Other product and company names herein may be the trademarks of their respective owners.

    Please direct your questions or comments to