home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / OWLSRC.PAK / RICHEDPR.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  9.8 KB  |  369 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1995, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.5  $
  6. //
  7. // Implementation of support classes for Print/PrintPreview of TRichEdits
  8. //----------------------------------------------------------------------------
  9. #include <owl/pch.h>
  10. #if !defined(OWL_WINDOW_H)
  11. # include <owl/window.h>
  12. #endif
  13. #if !defined(OWL_CONTROL_H)
  14. # include <owl/control.h>
  15. #endif
  16. #if !defined(OWL_EDIT_H)
  17. # include <owl/edit.h>
  18. #endif
  19. #if !defined(OWL_EDITSEAR_H)
  20. # include <owl/editsear.h>
  21. #endif
  22. #if !defined(OWL_EDITFILE_H)
  23. # include <owl/editfile.h>
  24. #endif
  25. #if !defined(OWL_RICHEDIT_H)
  26. # include <owl/richedit.h>
  27. #endif
  28. #if !defined(OWL_RICHEDPR_H)
  29. # include <owl/richedpr.h>
  30. #endif
  31.  
  32. OWL_DIAGINFO;
  33.  
  34. //
  35. //
  36. //
  37. const int PageIndexInit  = 5;
  38. const int PageIndexDelta = 5;   
  39.  
  40. //
  41. // Constructs a Printout object which represent a RICHEDIT's document
  42. //
  43. TRichEditPrintout::TRichEditPrintout(TPrinter& printer, 
  44.                                      TRichEdit& richEdit,
  45.                                      const char far *title)
  46. : 
  47.  TPrintout(title),
  48.  Printer(printer),
  49.  RichEdit(richEdit),
  50.  SizePhysPage(0),
  51.  SizePhysInch(0),
  52.  Margins(0),
  53.  FlushCache(false),
  54.  PageIndices(PageIndexInit, PageIndexDelta)
  55. { 
  56.   PRECONDITION(HWND(RichEdit));
  57.  
  58.   // Initialize data members
  59.   //
  60.   PageCount      = 0;
  61.   TextLen        = 0;
  62.   PageIndices[0] = 0;
  63. }
  64.  
  65. //
  66. // Destructor of 'RichEdit PrintOut' - Flushes any cached formatting 
  67. // information
  68. //
  69. TRichEditPrintout::~TRichEditPrintout()
  70. {
  71.   // Flush cached format information
  72.   //
  73.   if (FlushCache) {
  74.     CHECK(HWND(RichEdit));
  75.     RichEdit.FormatRange();
  76.   }
  77. }
  78.  
  79. //
  80. // This method is invoked by the printer or print-preview classes to allow
  81. // the printout to update the page range information.
  82. //
  83. void 
  84. TRichEditPrintout::GetDialogInfo(int& minPage, int& maxPage, 
  85.                                  int& selFromPage, int& selToPage)
  86. {
  87.   if (PageCount && TextLen) {
  88.     minPage = 1;
  89.     maxPage = PageCount;
  90.  
  91.     CHECK(HWND(RichEdit));
  92.     uint startSel, endSel;
  93.     RichEdit.GetSelection(startSel, endSel);
  94.  
  95.     //
  96.     selFromPage = startSel != endSel ? PageOfOffset(startSel) : 1;
  97.     selToPage = PageCount > selFromPage ? selFromPage+1 : 0;
  98.   }
  99.   else {
  100.     minPage = maxPage = 0;
  101.     selFromPage = selToPage = 0;
  102.   }
  103. }
  104.  
  105. //
  106. // This method is invoked by the printer or print-preview objects to hand
  107. // the printout object the target device context and the size of its pages.
  108. //
  109. void
  110. TRichEditPrintout::SetPrintParams(TPrintDC* dc, TSize pageSize)
  111. {
  112.   PRECONDITION(HWND(RichEdit));
  113.  
  114.   // Chain call base class' version
  115.   //
  116.   TPrintout::SetPrintParams(dc, pageSize);
  117.  
  118.   // Update size info about printer DC
  119.   //
  120.   SizePhysInch = TSize(dc->GetDeviceCaps(LOGPIXELSX),
  121.                        dc->GetDeviceCaps(LOGPIXELSY));
  122.   SizePhysPage = TSize(dc->GetDeviceCaps(PHYSICALWIDTH), 
  123.                        dc->GetDeviceCaps(PHYSICALHEIGHT));
  124.   if (!SizePhysPage.cx)
  125.     SizePhysPage.cx = dc->GetDeviceCaps(HORZRES);
  126.   if (!SizePhysPage.cy)
  127.     SizePhysPage.cy = dc->GetDeviceCaps(VERTRES);
  128.  
  129.  
  130.   // Set up the target and render DCs
  131.   // NOTE: In the case of PrintPreview, the two HDCs differ.
  132.   //       When we're really printing, the attribute DC and
  133.   //       GetHDC() return the same HDC.
  134.   //
  135.   FmtRange.SetTargetDC(dc->GetAttributeHDC()); // Format Device
  136.   FmtRange.SetRenderDC(dc->GetHDC());          // Render Device
  137.  
  138.   // Set the page and render rectangles in twips 
  139.   // Handle margins, if requested.
  140.   //
  141.   TRect rect(0, 0, MulDiv(SizePhysPage.cx, 1440, SizePhysInch.cx),
  142.                    MulDiv(SizePhysPage.cy, 1440, SizePhysInch.cy));
  143.   if (Margins.cx) {
  144.     ;
  145.   }
  146.   if (Margins.cy) {
  147.     ;
  148.   }
  149.   FmtRange.SetPageRect(rect);
  150.   FmtRange.SetRenderRect(rect);
  151.  
  152.   // Retrieve length of document and set range
  153.   //
  154.   TextLen = RichEdit.GetWindowTextLength();
  155.  
  156.   // Compute number of pages and cache their offsets
  157.   //
  158.   if (TextLen > 0) {
  159.     PageCount = 1;                  // Pages are not zero-based
  160.     FmtRange.SetRange(0, TextLen);  // Format entire range.....
  161.     int endOfRange;
  162.     do {
  163.       endOfRange = RichEdit.FormatRange(FmtRange, false);
  164.       PageIndices[PageCount++] = endOfRange;
  165.       FmtRange.chrg.cpMin = endOfRange;
  166.       FmtRange.SetRenderRect(rect); // Ctl seems to corrupt the 'rc' member!
  167.     } while (FmtRange.chrg.cpMin < TextLen);
  168.  
  169.     PageCount--;
  170.  
  171.     // Free cached formatting information
  172.     //
  173.     RichEdit.FormatRange();
  174.   } 
  175.   else {
  176.     PageCount = 0;
  177.   }
  178. }
  179.  
  180. //
  181. // This routine is invoked to inform the printout that a printing 
  182. // operation has begun. 
  183. //
  184. void 
  185. TRichEditPrintout::BeginPrinting()
  186. {
  187. }
  188.  
  189. //
  190. // This routine is invoked to inform the printout that the printing
  191. // operation has ended.
  192. //
  193. void
  194. TRichEditPrintout::EndPrinting()
  195. {
  196. }
  197.  
  198. //
  199. // This routine is invoked to request the printout object to print a page
  200. //
  201. void 
  202. TRichEditPrintout::PrintPage (int page, TRect& bandRect, unsigned)
  203. {
  204.   PRECONDITION(page > 0);
  205.   PRECONDITION(page <= PageCount);
  206.  
  207.   // Check control's handle is !0
  208.   //
  209.   PRECONDITION(HWND(RichEdit));
  210.  
  211.   // These should have been set via a prior call to 'SetPrintParams' 
  212.   //
  213.   PRECONDITION(FmtRange.hdcTarget !=0);
  214.   PRECONDITION(FmtRange.hdc != 0);
  215.  
  216.   // Check whether we're in 'real' printing mode or just print preview.
  217.   // In print preview mode the target does not match the render DC.....
  218.   //
  219.   if (FmtRange.hdc != FmtRange.hdcTarget) {
  220.  
  221.     int saveId = SaveDC(FmtRange.hdc);
  222.     if (FmtRange.hdc) {
  223.       TDC dc(FmtRange.hdc);
  224.  
  225.       // Make window DC match target's logical size
  226.       //
  227.       dc.SetMapMode(MM_ANISOTROPIC);
  228.       dc.SetWindowExt(TSize(MulDiv(SizePhysPage.cx, 
  229.                                   dc.GetDeviceCaps(LOGPIXELSX), 
  230.                                   SizePhysInch.cx),
  231.                             MulDiv(SizePhysPage.cy, 
  232.                                   dc.GetDeviceCaps(LOGPIXELSY), 
  233.                                   SizePhysInch.cy)));
  234.       dc.SetViewportExt(TSize(bandRect.Width(), bandRect.Height()));
  235.  
  236.       // Update character range for specified page
  237.       //
  238.       FmtRange.SetRange(PageIndices[page-1], PageIndices[page]);
  239.  
  240.       // Have Edit control draw into window
  241.       //
  242.       RichEdit.FormatRange(FmtRange);
  243.  
  244.       // Flag that we need to reset control
  245.       //
  246.       FlushCache = true;
  247.     }
  248.     // Restore the DC
  249.     //
  250.     RestoreDC(FmtRange.hdc, saveId);
  251.   }
  252.   else {
  253.     // We're really printing! Update character range for specified page
  254.     //
  255.     FmtRange.SetRange(PageIndices[page-1], PageIndices[page]);
  256.  
  257.     // Have Edit control format data
  258.     //
  259.     RichEdit.FormatRange(FmtRange, false);
  260.  
  261.     // Flag that we need to reset control
  262.     //
  263.     FlushCache = true;
  264.  
  265.     // Have Edit control display to render rectangle of device
  266.     //
  267.     RichEdit.DisplayBand(*((TRect*)&FmtRange.rc));
  268.   }
  269. }
  270.  
  271. //
  272. // This routine is invoked to asked the printout object whether it has
  273. // necessary information to print the specified page.
  274. //
  275. bool 
  276. TRichEditPrintout::HasPage (int pageNumber)
  277. {
  278.   return pageNumber > 0 && pageNumber <= PageCount;
  279. }
  280.  
  281. //
  282. // Return the index of the page at the particular offset within the buffer
  283. // of an edit control.
  284. //
  285. int
  286. TRichEditPrintout::PageOfOffset(int offset)
  287. {
  288.   PRECONDITION(offset <= TextLen);
  289.   
  290.   int page = 0;
  291.   if (PageCount > 0) {
  292.     for (int i=1; i<=PageCount; i++) {
  293.       if (PageIndices[i] >= offset) {
  294.         if (PageIndices[i-1] <= offset) {
  295.           page = i;
  296.           break;
  297.         }
  298.       }    
  299.     }    
  300.   }
  301.   return page;
  302. }
  303.  
  304. //
  305. // Constructor of RichEdit PagePreview object
  306. //
  307. TRichEditPagePreview::TRichEditPagePreview(TWindow* parent, 
  308.                                            TPrintout& printout,
  309.                                            TPrintDC& prndc,
  310.                                            TSize& printExtent,
  311.                                            int pagenum)
  312. :
  313.   TPreviewPage(parent, printout, prndc, printExtent, pagenum)
  314. {
  315. }
  316.  
  317. //
  318. // WM_PAINT handler of RichEdit PagePreview window. Displays a preview of the
  319. // page if the printout can handle it. Otherwise, simply fills the window
  320. // with a white background.
  321. //
  322. void
  323. TRichEditPagePreview::Paint(TDC& dc, bool, TRect& /*clip*/) 
  324. {
  325.   TRect client;
  326.   GetClientRect(client);
  327.  
  328.   TPreviewDCBase pdc(dc, PrintDC);
  329.   Printout.SetPrintParams(&pdc, PrintExtent);
  330.  
  331.   if (Printout.HasPage(PageNum)) {
  332.     Printout.BeginPrinting();
  333.     Printout.BeginDocument(PageNum, PageNum, pfBoth);
  334.     Printout.PrintPage(PageNum, client, pfBoth);
  335.     Printout.EndDocument();
  336.     Printout.EndPrinting();
  337.   }
  338.   else
  339.     dc.PatBlt(client, WHITENESS);
  340. }
  341.  
  342. //
  343. // Constructor of a RichEdit Preview Frame
  344. //
  345. TRichEditPreviewFrame::TRichEditPreviewFrame(TWindow* parentWindow, 
  346.                                              TPrinter& printer, 
  347.                                              TPrintout& printout, 
  348.                                              TRichEdit& richEdit, 
  349.                                              const char far* title, 
  350.                                              TLayoutWindow* client)
  351. :
  352.   TPreviewWin(parentWindow, printer, printout, richEdit, title, client)
  353. {
  354. }
  355.  
  356. //
  357. // Return pointer to a preview page object
  358. //
  359. TPreviewPage* 
  360. TRichEditPreviewFrame::GetNewPreviewPage(TWindow* parent, 
  361.                                          TPrintout& printout,
  362.                                          TPrintDC&  prndc,
  363.                                          TSize&     printExtent,
  364.                                          int        pagenum)
  365. {
  366.   return new TRichEditPagePreview(parent, printout, prndc, 
  367.                                   printExtent, pagenum);
  368. }
  369.