Get Ready to Unleash the Power of UCanCode .NET

    CDC dc;
    Graphics graphics;

    dc.SetMapMode(MM_TEXT);
    graphics.SetPageUnit(UnitDocument); 

int CreateFontSize(HDC hDC, int points, double dpiRatio)
{
	// This will calculate the font size for the printer that is specified
	// by a point size.
	//
	// if points is:
	//  (-) negative uses height as value for Net Font Height (ie. point size)
	//	(+) positive height is Total Height plus Leading Height!
	ASSERT(hDC);
	
	POINT size;
	int logPixelsY=::GetDeviceCaps(hDC, LOGPIXELSY);
	size.x = size.y = MulDiv(points, logPixelsY, 72);

	// here we scale the font...
	return (float)floor(size.y*dpiRatio);
}

Unit fontUnit = m_pGraphics->GetPageUnit();
// if fontUnit is UnitDisplay, then specify UnitPixel, 
// otherwise you'll get a "InvalidParameter" from GDI+
if (fontUnit == UnitDisplay)
fontUnit = UnitPixel;
// classical constructor use, lfHeight is the font height
Font font(&fontFamily, CreateFontSize(hDC, 
          lfHeight, dpiRatio), FontStyleRegular, fontUnit);

Included functions are:

1. UserPage which returns a CRect which defines a consistent printable area for each printer (Your margins must be within the printable region of all printers of course!)
2. CreateFontSize which returns a CSize which defines the font attribute with respect to the desired point size and printer characteristics.

The remaining code shows sample usage of these functions.

//Input: desired margin
//Output: CRect to use for printing area
CRect CChildView::UserPage(CDC * pDC, float margin)
{
    // This function returns the area in device units to be used to
    // prints a page with a true boarder of "margin".
    //
    // You could use individual margins for each edge
    // and apply below as needed.
    //
    // Set Map Mode - We do not want device units
    // due to lack of consistency.
    // If you do not use TWIPS you will have to change
    // the scaling factor below.
    int OriginalMapMode = pDC->SetMapMode(MM_TWIPS);

    // Variable needed to store printer info.
    CSize PrintOffset,Physical,Printable;

    // This gets the Physical size of the page in Device Units
    Physical.cx = pDC->GetDeviceCaps(PHYSICALWIDTH);
    Physical.cy = pDC->GetDeviceCaps(PHYSICALHEIGHT);
    // convert to logical
    pDC->DPtoLP(&Physical);

    // This gets the offset of the printable area from the
    // top corner of the page in Device Units
    PrintOffset.cx = pDC->GetDeviceCaps(PHYSICALOFFSETX);
    PrintOffset.cy = pDC->GetDeviceCaps(PHYSICALOFFSETY);
    // convert to logical
    pDC->DPtoLP(&PrintOffset);

    // Set Page scale to TWIPS, Which is 1440 per inch,
    // Zero/Zero is the upper left corner
    // Get Printable Page Size (This is in MM!) so convert to twips.
    Printable.cx =  (int)((float)pDC->GetDeviceCaps(HORZSIZE)*56.69);
    Printable.cy = (int)((float)pDC->GetDeviceCaps(VERTSIZE)*56.69);

    // Positive X -> RIGHT
    // Positive Y -> UP
    // Ref Zero is upper left corner
    int inch = 1440; // Scaling Factor Inches to TWIPS
    int Dx1, Dx2, Dy1, Dy2; // Distance printable area is from edge of paper
    Dx1 = PrintOffset.cx;
    Dy1 = PrintOffset.cy;
    // calculate remaining borders
    Dy2 = Physical.cy-Printable.cy-Dy1;
    Dx2 = Physical.cx-Printable.cx-Dx1;
    //
    // Define the User Area's location
    CRect PageArea;
    PageArea.left = (long)(margin*inch-Dx1);
    PageArea.right = (long)(Printable.cx-margin*inch+Dx2);
    PageArea.top = (int)-(margin*inch-Dy1); // My scale is inverted for y
    PageArea.bottom = (int)-(Printable.cy-margin*inch+Dy2);
    // now put back to device units to return to the program.
    pDC->LPtoDP(&PageArea);
    //
    // return
    return PageArea;
}

 Input: pointer to device context for printer
// Input: desired point size of font (in points).
// Output: integer height to send to CreateFont function.
int CChildView::CreateFontSize(CDC *pdc, int points)
{
// This will calculate the font size for the printer that is specified
// by a point size.
//
// if points is:
// (-) negative uses height as value for Net Font Height
// (ie. point size)
// (+) positive height is Total Height plus Leading Height!
CSize size;
int perinch = pdc->GetDeviceCaps(LOGPIXELSY);
size.cx = size.cy = (perinch*points)/72;
pdc->DPtoLP(&size);
return size.cy;
}

To use CreateFontSize, just insert the function call into the CreateFont function:

    BaseFont.CreateFont( -CreateFontSize(pdc,11), 0, 0, 0, FW_MEDIUM,
        FALSE, FALSE, 0, ANSI_CHARSET, 
        OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, 
        DEFAULT_QUALITY, DEFAULT_PITCH , "Courier New" );

The UserPage function can be used internal to your OnPrint function. Where you call it, use the returned area rather than the region found from the pDC's GetDeviceCaps function. (Usually sent in the PrintInfo data.) Or you can call it to set the region in to be passed.

void CChildView::PrintSetup(int item)
{
// Create Standard windows dialog.
BOOL bStdSetUpDlg = TRUE;
// See PRINTDLG for flags to set defaults in dialog.
// DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | 
PD_NOPAGENUMS | PD_HIDEPRINTTOFILE | PD_NOSELECTION;
DWORD dwFlags = PD_ALLPAGES;
// Parent (may be NULL)
CWnd *pParent = this;
CPrintDialog MyPrintDlg(bStdSetUpDlg,dwFlags,pParent);
// Print Info
CPrintInfo MyPrintInfo;
// first link with dialog so data is shared
// Your input into min and max pages is now shared.
MyPrintInfo.m_pPD = &MyPrintDlg;
//
// Get Users Answer;
int MyAnswer;
MyAnswer = MyPrintDlg.DoModal();
// Allow the user to cancel
if(MyAnswer==IDCANCEL) return;
//
// Get the mode the printer is in from the Print Dialog.
// This memory block must be unlocked later.
DEVMODE *MyPrintMode;
MyPrintMode = MyPrintDlg.GetDevMode();
// 
// Create our Printer Context
CDC MyPrintDC;
MyPrintDC.CreateDC(MyPrintDlg.GetDriverName(), // Ignored for Printer DC's
MyPrintDlg.GetDeviceName(), // The only required item for Printer DC's
MyPrintDlg.GetPortName(), // Ignored for Printer DC's
MyPrintMode); // Optional Item for Printer DC's
//
// Start the Document for our document
DOCINFO MyDocInfo;
MyDocInfo.cbSize=sizeof(DOCINFO);
CString DocName;
DocName.LoadString(AFX_IDS_APP_TITLE);
MyDocInfo.lpszDocName="DocName";
MyDocInfo.lpszOutput="";
//
// Start the document
int iErr = MyPrintDC.StartDoc(&MyDocInfo);
if(iErr < 0)
{
//success returns positive value
MyPrintDC.AbortDoc();
GlobalUnlock(MyPrintMode); // Release the print mode.
return;
}
// success so set flag to printing
MyPrintDC.m_bPrinting=TRUE;
// Most programs us the device's printable region found with
// MyPrintDC.GetDevicecaps(****) functions.
// However this is not consistent between printers so -->
// The UserPage functions calculates what margins
// to specify so we have the
// actual distance from the edge of the page
// to be consistent between printers.
CRect MyArea;
// fixed margin in inches (you can change this)
MyArea = UserPage(&MyPrintDC, 0.9f);
MyPrintInfo.m_rectDraw.SetRect(MyArea.left, 
MyArea.top,MyArea.right,MyArea.bottom);
//
// We are now into personal preferences based on your program needs.
//
// We can call OnBeginPrinting and OnEndPrinting functions
// to initialize and clean up
// and loop through calls to OnPrint
// (calling Startpage and EndPage functions)
//
// or as I have done here->
// Call the StartPage the first time EndPage at the end
// with the print fnuction handling the begin
// and end when needed internally.
//
// Start the page. (This allways sets the DC to device units!) 
MyPrintDC.StartPage();
// Set mode.
MyPrintDC.SetMapMode(MM_TEXT);
//
// We are now ready to print our data. Switch to the options allowed.
// For our usage we will end and restart
// each page in the functions called
// based on the location of the current print location on the page.
//
// Internal to the fucntions we need to call:
// pdc->EndPage();
// pdc->StartPage(); // Returns in Device units
// pdc->SetMapMode(MM_LOENGLISH); // Reset to our desired mode
// Reset position to draw, etc....
// as needed.
//
switch(item)
{
case(1):
PrintLoose(&MyPrintDC,MyArea);
break;
case(2):
PrintRecord(&MyPrintDC,MyArea);
break;
}
// We are all done. Clean up
MyPrintDC.m_bPrinting=FALSE;
// end last page
MyPrintDC.EndPage();
// end the document
MyPrintDC.EndDoc();
// Release the device context
GlobalUnlock(MyPrintMode); // Release the print mode.
return;
}

// this procedure extracts a single image from an image list into a DIB
HANDLE ImageToDIB( CImageList* pImageList, int iImageNumber, CWnd* pWnd)
{
    // Local Variables
    CBitmap     bitmap;
    CWindowDC    dc( pWnd );

    CDC         memDC;
    CRect        rect;
    CPalette    pal;
    IMAGEINFO   imageInfo;

    if (!pImageList->GetImageInfo( iImageNumber, &imageInfo ))
        {
        // Getting of the Imageinfos failed
        return NULL;
        }

    // Create compatible stuff and select Bitmap
    if (!memDC.CreateCompatibleDC(&dc ))
        {
        // Create failed
        return NULL;
        }

    if (!bitmap.CreateCompatibleBitmap(&dc, 
                                        imageInfo.rcImage.bottom-imageInfo.rcImage.top, 
                                        imageInfo.rcImage.right-imageInfo.rcImage.left))
        {
        // Create failed
        memDC.DeleteDC() ;
        return NULL;
        }

    CBitmap* pOldBitmap = memDC.SelectObject( &bitmap );
    if( NULL == pOldBitmap )
        {
        // Select failed
        memDC.DeleteDC() ;
        return NULL;
        }

    // Local Variables for Draw
    CPoint point( 0, 0);
    UINT nStyle = ILD_NORMAL;

    // Draw Image to the compatible DC
    if(!pImageList->Draw( &memDC, iImageNumber, point, nStyle ))
        {
        // Drawing of the Image failed
        memDC.SelectObject(pOldBitmap) ;
        VERIFY(bitmap.DeleteObject()) ;
        memDC.DeleteDC() ;
        return NULL;
        }

    // Create logical palette if device support a palette
    if( dc.GetDeviceCaps( RASTERCAPS ) & RC_PALETTE )
        {
        UINT        nSize   = sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 );
        LOGPALETTE* pLP     = (LOGPALETTE*)new BYTE[nSize];
        pLP->palVersion     = 0x300;
        pLP->palNumEntries = (unsigned short)GetSystemPaletteEntries( dc, 0, 255, 
        pLP->palPalEntry );

        // Create the palette
        pal.CreatePalette( pLP );

        // Free memory
        delete[] pLP;
        }

    memDC.SelectObject( pOldBitmap );
    memDC.DeleteDC() ;

    // Convert the bitmap to a DIB
    HANDLE h = DDBToDIB(bitmap, BI_RGB, &pal );
    VERIFY(bitmap.DeleteObject()) ;
    return h ;
}


// DDBToDIB        - Creates a DIB from a DDB
// bitmap        - Device dependent bitmap
// dwCompression    - Type of compression - see BITMAPINFOHEADER
// pPal            - Logical palette
HANDLE DDBToDIB( CBitmap& bitmap, DWORD dwCompression, CPalette* pPal ) 
{
    BITMAP            bm;
    BITMAPINFOHEADER    bi;
    LPBITMAPINFOHEADER     lpbi;
    DWORD            dwLen;
    HANDLE            hDIB;
    HANDLE            handle;
    HDC             hDC;
    HPALETTE        hPal;


    ASSERT( bitmap.GetSafeHandle() );

    // The function has no arg for bitfields
    if( dwCompression == BI_BITFIELDS )
        return NULL;

    // If a palette has not been supplied use defaul palette
    hPal = (HPALETTE) pPal->GetSafeHandle();
    if (hPal==NULL)
        hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);

    // Get bitmap information
    bitmap.GetObject(sizeof(bm),(LPSTR)&bm);

    // Initialize the bitmapinfoheader
    bi.biSize        = sizeof(BITMAPINFOHEADER);
    bi.biWidth        = bm.bmWidth;
    bi.biHeight         = bm.bmHeight;
    bi.biPlanes         = 1;
    bi.biBitCount        = (unsigned short)(bm.bmPlanes * bm.bmBitsPixel) ;
    bi.biCompression    = dwCompression;
    bi.biSizeImage        = 0;
    bi.biXPelsPerMeter    = 0;
    bi.biYPelsPerMeter    = 0;
    bi.biClrUsed        = 0;
    bi.biClrImportant    = 0;

    // Compute the size of the  infoheader and the color table
    int nColors = 0;
    if(bi.biBitCount <= 8)
        {
        nColors = (1 << bi.biBitCount);
        }
    dwLen  = bi.biSize + nColors * sizeof(RGBQUAD);

    // We need a device context to get the DIB from
    hDC = ::GetDC(NULL);
    hPal = SelectPalette(hDC,hPal,FALSE);
    RealizePalette(hDC);

    // Allocate enough memory to hold bitmapinfoheader and color table
    hDIB = GlobalAlloc(GMEM_FIXED,dwLen);

    if (!hDIB){
        SelectPalette(hDC,hPal,FALSE);
        ::ReleaseDC(NULL,hDC);
        return NULL;
    }

    lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);

    *lpbi = bi;

    // Call GetDIBits with a NULL lpBits param, so the device driver 
    // will calculate the biSizeImage field 
    GetDIBits(hDC, (HBITMAP)bitmap.GetSafeHandle(), 0L, (DWORD)bi.biHeight,
            (LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);

    bi = *lpbi;

    // If the driver did not fill in the biSizeImage field, then compute it
    // Each scan line of the image is aligned on a DWORD (32bit) boundary
    if (bi.biSizeImage == 0){
        bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8) 
                        * bi.biHeight;

        // If a compression scheme is used the result may infact be larger
        // Increase the size to account for this.
        if (dwCompression != BI_RGB)
            bi.biSizeImage = (bi.biSizeImage * 3) / 2;
    }

    // Realloc the buffer so that it can hold all the bits
    dwLen += bi.biSizeImage;
    handle = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE) ;
    if (handle != NULL)
        hDIB = handle;
    else
        {
        GlobalFree(hDIB);

        // Reselect the original palette
        SelectPalette(hDC,hPal,FALSE);
        ::ReleaseDC(NULL,hDC);
        return NULL;
        }

    // Get the bitmap bits
    lpbi = (LPBITMAPINFOHEADER)hDIB;

    // FINALLY get the DIB
    BOOL bGotBits = GetDIBits( hDC, (HBITMAP)bitmap.GetSafeHandle(),
                0L,                      // Start scan line
                (DWORD)bi.biHeight,      // # of scan lines
                (LPBYTE)lpbi             // address for bitmap bits
                + (bi.biSize + nColors * sizeof(RGBQUAD)),
                (LPBITMAPINFO)lpbi,      // address of bitmapinfo
                (DWORD)DIB_RGB_COLORS);  // Use RGB for color table

    if( !bGotBits )
    {
        GlobalFree(hDIB);
        
        SelectPalette(hDC,hPal,FALSE);
        ::ReleaseDC(NULL,hDC);
        return NULL;
    }

    SelectPalette(hDC,hPal,FALSE);
    ::ReleaseDC(NULL,hDC);
    return hDIB;
}