apc.htm

有关Visual C++ 6.0 编程实例与技巧方面的相关资料

</PRE>
<P>The first thing you'll notice that's different from OnDraw() is the second parameter,
the pointer to a CPrintInfo object pInfo. This is where you'll find the details about
the current print, specifically the rectangle coordinates for the printer device
context you require. There are lots of useful CPrintInfo member variables. Some of
these are shown in Table C.1.</P>
<P>
<H4>TABLE C.1.&nbsp;&nbsp;CPrintInfo MEMBER VARIABLES SPECIFIC TO PRINT INFORMATION.</H4>
<P>
<TABLE BORDER="1">
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT"><I>Variable Name</I></TD>
		<TD ALIGN="LEFT"><I>Description of Contents</I></TD>
	</TR>
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT">m_nCurPage		</TD>
		<TD ALIGN="LEFT">The current page number for multipage prints		</TD>
	</TR>
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT">m_nNumPreviewPages		</TD>
		<TD ALIGN="LEFT">Either 1 or 2, depending on the preview pages shown		</TD>
	</TR>
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT">m_rectDraw		</TD>
		<TD ALIGN="LEFT">The coordinates of the print page rectangle		</TD>
	</TR>
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT">m_pPD		</TD>
		<TD ALIGN="LEFT">Pointer to a CPrintDialog class if the Print dialog box is used		</TD>
	</TR>
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT">m_bDirect		</TD>
		<TD ALIGN="LEFT">TRUE if the Print dialog box has been bypassed		</TD>
	</TR>
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT">m_bPreview		</TD>
		<TD ALIGN="LEFT">TRUE if currently in print preview		</TD>
	</TR>
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT">m_strPageDesc		</TD>
		<TD ALIGN="LEFT">A format string to help generate the page number		</TD>
	</TR>
	<TR ALIGN="LEFT" VALIGN="TOP">
		<TD ALIGN="LEFT">m_lpUserData		</TD>
		<TD ALIGN="LEFT">A pointer that can be used to hold user data		</TD>
	</TR>
</TABLE>
</P>
<P>Some other member variables in CPrintInfo are covered later in this chapter, but
first you'll need to find the printing rectangle coordinates rather than the window's
rectangle. The m_rectDraw member holds the coordinate rectangle of the current print
page. You can use these coordinates with the printer device context in the OnDraw()
function. There is a problem though, in that this structure isn't passed to the OnDraw(),
but you can copy the coordinates into a member variable held in your CPrintItView
class.</P>
<P>Add the following lines to store the rectangle after the // TODO comment, but
before the CView::OnPrint() call:</P>
<P>
<PRE>// ** copy the print rectangle from the pInfo
    if (pInfo) m_rcPrintRect = pInfo-&gt;m_rectDraw;
</PRE>
<P>This will store the printing rectangle in the m_rcPrintRect member of the CPrintItView
class. You must therefore declare this member variable, which is easily done by right-clicking
the CPrintItView class in the ClassView pane of the Project Workspace view and choosing
the Add Member Variable<B> </B>option. The Variable Type<B> </B>is a CRect, and the
declaration is obviously m_rcPrintRect. Access should be private because you don't
need or want any other classes to know about this internal rectangle.</P>
<P>
<H3><A NAME="Heading5"></A>Using the Printer Device Context</H3>
<P>The device context passed to OnPrint() differs slightly from the display context
in that it may have fewer colors and is probably larger that your display. Other
than these attributes, you can use it to draw in exactly the same way as the screen
device context. This is how you can use the same OnDraw() to print as well as view
in a window. The base class call CView::OnPrint() implements code that does exactly
this.</P>
<P>The device context holds a flag that you can interrogate via the IsPrinting()
function to determine whether you are drawing to a screen-based device context or
a printer-based device context. You might use this difference to change the printed
output from the screen output, or more subtly to adjust the coordinates used to produce
the printed output.</P>
<P>For the sample program it only remains to use the m_rcPrintRect coordinates when
printing in the OnDraw() function. The code necessary to use the IsPrinting() function
to determine whether the window's client rectangle or the printer's rectangle should
be used is shown in Listing C.2. The output produced is shown by the print preview
in Figure C.2.</P>
<P>
<H4>LISTING C.2.&nbsp;LST23_2.CPP--ADDING PRINTING RECTANGLE SUPPORT TO THE STANDARD
OnDraw() IMPLEMENTATION.</H4>
<PRE>1:  // Declare a client rectangle
2:  CRect rcClient;
3:
4:  // ** Check the device context for printing mode
5:  if (pDC-&gt;IsPrinting())
6:  {
7:      // ** Printing, so use the print rectangle
8:      rcClient = m_rcPrintRect;
9:  }
10:  else
11:  {
12:      // ** Not printing, so client rect will do
13:      GetClientRect(&amp;rcClient);
14:  }
15:
16:  // Convert to logical units
17:  pDC-&gt;DPtoLP(&amp;rcClient);
</PRE>
<P>Notice in Listing C.2 that an if statement is used in line 5 to call the device
context's IsPrinting() function. This function returns TRUE if this is a printer
device context (or preview) and FALSE for any other device contexts. In the printing
case, you can assign the stored print page rectangle to rcClient, as shown in line
8. In the normal screen window case you can just use the standard GetClientRect()
to find the window's rectangle, as shown in line 13.</P>
<P>Because you've used a mapping mode, you must convert both printing and display
rectangle coordinates from device units to logical units. This is done by the DPtoLP()
function in line 17. If you change and add lines 4-14 to your existing OnDraw() function
and then build and run the application, you should be able to run the print preview
as before, with better results (see Figure C.2).</P>
<P><A HREF="javascript:popUp('23fig02.gif')"><B>FIGURE C.2.</B></A><B> </B><I>Print
preview using the full print page rectangle coordinates.</I></P>

<P><I></I>
<H3><A NAME="Heading6"></A>Maintaining the Aspect Ratio</H3>
<P>As you can see from Figure C.2, because the paper is much longer and thinner than
the window, the printed output becomes stretched. The relationship between the width
and the height is the aspect ratio<I>.</I> To stop the image from stretching one
way or another, you must keep the same aspect ratio as the image in the window. The
code in Listing C.2 doesn't try to maintain aspect ratios, which isn't very satisfactory
in most cases, so you would need to add some code to maintain the aspect ratio of
the printed output.</P>
<P>The best tactic to use in this case is to find out whether setting either the
width or the height to the full width or height of the paper will give maximum coverage
and then shorten the other dimension to maintain the aspect ratio.</P>
<P>To do this, you need some information about the paper dimensions and its own aspect
ratio. There is a device context function that retrieves these details (and many
more) named GetDeviceCaps(). By passing the ASPECTX or ASPECTY flags to GetDeviceCaps(),
you can find the relationship between the width of a pixel and its height. If the
relationship is 1:1 the pixel is square; otherwise, it is oblong and might differ
from the screen's own aspect ratio. If it differs, you can decide which axis will
give you the largest image, while maintaining the same aspect ratio as the screen.
That way you can avoid a stretched looking image.</P>
<P>Code that does just that in the OnDraw() function is demonstrated in Listing C.3.</P>


<BLOCKQUOTE>
	<P>
<HR>
<B>DEVICE ASPECT RATIOS</B><BR>
	</P>

	<P>For most printers, you'll probably find that the aspect ratio is 1:1. But if you
	look closely at thermal printer output like those in fax machines, you can see a
	very distinctive aspect ratio difference in their pixels.
<HR>


</BLOCKQUOTE>

<H4>LISTING C.3.&nbsp;&nbsp;LST23_3.CPP--MAINTAINING THE ASPECT RATIO WHILE PRODUCING
THE LARGEST PRINTED REPRESENTATION.</H4>
<PRE>1:  //** Declare a client rectangle and get the client rect
2:  CRect rcClient;
3:  GetClientRect(&amp;rcClient);
4:
5:  // ** Check the device context for printing mode
6:  if (pDC-&gt;IsPrinting())
7:  {
8:    // ** Find the Print width : Window width ratio
9:    double dWidthRatio=(double)m_rcPrintRect.Width()/
10:                            (double)rcClient.Width();
11:
12:    // ** Find the Print height : Window height ratio
13:    double dHeightRatio=(double)m_rcPrintRect.Height()/
14:                            (double)rcClient.Height();
15:
16:    // ** Calculate the device's aspect ratio
17:    double dAspect=(double)pDC-&gt;GetDeviceCaps(ASPECTX)/
18:                   (double)pDC-&gt;GetDeviceCaps(ASPECTY);
19:
20:    // ** Find the new relative height
21:    int nHeight=(int)(rcClient.Height() *
22:                     dWidthRatio * dAspect );
23:
24:    // ** Find the new relative width
25:    int nWidth=(int)(rcClient.Width() *
26:                     dHeightRatio * (1.0 / dAspect) );
27:
28:    // ** Set the whole rectangle
29:    rcClient=m_rcPrintRect;
30:
31:    // ** Determine the best fit across or down the page
32:    if (nHeight &gt; nWidth)
33:    {
34:        // ** Down is best, so adjust the width
35:        rcClient.BottomRight().x=
36:            m_rcPrintRect.TopLeft().x + nWidth;
37:    }
38:    else
39:    {
40:        // ** Across is best, so adjust the height
41:        rcClient.BottomRight().y=
42:            m_rcPrintRect.TopLeft().y + nHeight;
43:    }
44:  }
45:
46:  // Convert to logical units
47:  pDC-&gt;DPtoLP(&amp;rcClient);
</PRE>
<P>Notice that both the screen window and printed case use the window coordinates
that are found from the GetClientRect() in line 3. In the onscreen window case, nothing
else is done and the code continues as normal.</P>
<P>However, a lot now happens when printing, if the IsPrinting() test in line 6 returns
TRUE. First, you must find the ratios of the window width to the paper width and
the window height to the paper height. You can find these ratios as shown in lines
9 and 13 by dividing the paper dimensions by the window dimensions.</P>
<P>The next thing you must calculate is the device's own aspect ratio peculiarities.
You can use the GetDeviceCaps() function in line 17 to find the ratio of width to
height in the device itself and store the result in dAspect.</P>
<P>Using these values, you can now calculate the device's comparative width and height
coordinates in terms of the opposing window dimension, as shown in lines 21 and 25.
This calculation, which includes the device aspect ratio for each dimension, will
yield the adjusted height for the full page width or vice versa. Now you must decide
whether you can best fit the full width or height of a page and adjust the other
dimension. The condition on line 32 makes this decision based on the bigger width
or height. This means that if you have a tall, thin window, it is better to use the
full height of the paper and adjust the width; conversely, if you have a short, wide
window, it is better to use the full width and adjust the height. Depending on what
is better, the adjustment is made on line 35 or 42 by setting the bottom-right point's
x- or y-coordinate to the adjusted width or height.</P>
<P>Notice that all the other dimensions are set to rcClient from the paper in the
assignment on line 29, so the adjustment is the only change required. After this
section, the program continues and will use the adjusted rectangle to do its drawing.</P>
<P>If you build and run the application after adding the lines in Listing C.3 to
the OnDraw() function, you should see that printing or previewing the window will
now maintain the same aspect ratio as the onscreen window. If you stretch the window
to make it higher than it is wide, the printed output will use the full height of
the page rather than the full width, but still maintain the correct aspect ratios.</P>
<P>
<H2><A NAME="Heading7"></A>Pagination and Orientation</H2>
<P>Printing a single page to represent the view in a window is a common requirement,
but largely the printing process is concerned with printing large and complex multipage
documents from the user's sophisticated data. The framework comes to the rescue again
and simplifies this process by providing a common Print Setup dialog box and a page
enumeration system to print and preview the specified range of pages.</P>
<P>
<H3><A NAME="Heading8"></A>Setting the Start and End Pages</H3>
<P>The first considerations for a multipage document are the start and end pages,
which also indicate how many pages you are going to print. A framework virtual function
in the view class is called first when printing begins. This function is OnPreparePrinting()
and it supplies one parameter, the CPrintInfo object pInfo. This is the first time
you'll see the CPrintInfo, and this is where you can first change it to customize
the print to your requirements. The OnPreparePrinting() function is supplied automatically
from the AppWizard when you create the SDI, so you don't have to add it yourself.
You can see the default implementation by double-clicking the OnPreparePrinting()
member of the CPrintItView class in the ClassView pane.</P>
<P>It should look like this:</P>
<P>
<PRE>BOOL CPrintItView::OnPreparePrinting(CPrintInfo* pInfo)
{
    // default preparation
    return DoPreparePrinting(pInfo);
}
</PRE>
<P>By default, the DoPreparePrinting() function is called and passed the pInfo pointer
to the CPrintInfo object for the print. DoPreparePrinting() sets up the required
device context and calls the standard Print dialog box if you are printing (not previewing).
This dialog box is covered in more detail in the next section, but first you can
set up a range of pages to print by modifying the CPrintInfo object before the DoPreparePrinting().</P>
<P>To do this, add the following lines before the // default preparation comment:</P>
<P>
<PRE>pInfo-&gt;SetMinPage(2);
    pInfo-&gt;SetMaxPage(8);
</PRE>
<P>These two member functions of the CPrintInfo class will modify the CPrintInfo
object pointed at by pInfo to set the starting page at page 2 via SetMinPage() and
the ending page at page 8 via SetMaxPage().</P>
<P>Now when the document is printed, the OnPrint() function will be called six times.
The only difference between each of these calls will be the pInfo-&gt;m_nCurPage
member variable that will hold the current page as it iterates between 2 and 8.</P>
<P>Depending on the kind of application you write, the technique you'll use to determine
the number of pages will vary. If you are selling music compact discs and want to
print a brochure of your product range, you would probably fit the cover picture
and review of each CD on one printed page, so if you sell 120 different CDs, you