/* * CiderPress * Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved. * See the file LICENSE for distribution terms. */ /* * Support for printing. */ #include "stdafx.h" #include "Print.h" #include "Main.h" #include "Preferences.h" /* * ========================================================================== * PrintStuff * ========================================================================== */ /*static*/ const char* PrintStuff::kCourierNew = _T("Courier New"); /*static*/ const char* PrintStuff::kTimesNewRoman = _T("Times New Roman"); /* * Set up various values. */ void PrintStuff::InitBasics(CDC* pDC) { ASSERT(pDC != nil); ASSERT(fpDC == nil); fpDC = pDC; /* make sure we're in MM_TEXT mode */ pDC->SetMapMode(MM_TEXT); /* get device capabilities; logPixels is e.g. 300 */ fVertRes = pDC->GetDeviceCaps(VERTRES); fHorzRes = pDC->GetDeviceCaps(HORZRES); fLogPixelsX = pDC->GetDeviceCaps(LOGPIXELSX); fLogPixelsY = pDC->GetDeviceCaps(LOGPIXELSY); WMSG4("+++ logPixelsX=%d logPixelsY=%d fHorzRes=%d fVertRes=%d\n", fLogPixelsX, fLogPixelsY, fHorzRes, fVertRes); } /* * Create a new font, based on the number of lines per page we need. */ void PrintStuff::CreateFontByNumLines(CFont* pFont, int numLines) { ASSERT(pFont != nil); ASSERT(numLines > 0); ASSERT(fpDC != nil); /* required height */ int reqCharHeight; reqCharHeight = (fVertRes + numLines/2) / numLines; /* magic fudge factor */ int fudge = reqCharHeight / 24; WMSG2(" Reducing reqCharHeight from %d to %d\n", reqCharHeight, reqCharHeight - fudge); reqCharHeight -= fudge; pFont->CreateFont(reqCharHeight, 0, 0, 0, FW_NORMAL, 0, 0, 0, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, kTimesNewRoman); /*fpOldFont =*/ fpDC->SelectObject(pFont); } /* * Returns the width of the string. */ int PrintStuff::StringWidth(const CString& str) { CSize size; size = fpDC->GetTextExtent(str); return size.cx; } /* * Trim a string to the specified number of pixels. If it's too large, * ellipsis will be added on the left or right. */ int PrintStuff::TrimString(CString* pStr, int width, bool addOnLeft) { static const char* kEllipsis = "..."; CString newStr; int strWidth; CSize size; size = fpDC->GetTextExtent(kEllipsis); if (width < size.cx) { ASSERT(false); return width; } newStr = *pStr; /* * Do a linear search. This would probably be better served with a * binary search or at least a good textmetric-based guess. */ strWidth = StringWidth(newStr); while (strWidth > width) { if (pStr->IsEmpty()) { ASSERT(false); return width; } if (addOnLeft) { *pStr = pStr->Right(pStr->GetLength() -1); newStr = kEllipsis + *pStr; } else { *pStr = pStr->Left(pStr->GetLength() -1); newStr = *pStr + kEllipsis; } if (!addOnLeft) { WMSG1("Now trying '%s'\n", (LPCTSTR) newStr); } strWidth = StringWidth(newStr); } *pStr = newStr; return strWidth; } /* * ========================================================================== * PrintContentList * ========================================================================== */ /* * Calculate some constant values. */ void PrintContentList::Setup(CDC* pDC, CWnd* pParent) { /* init base class */ InitBasics(pDC); /* init our stuff */ CreateFontByNumLines(&fPrintFont, kTargetLinesPerPage); fpParentWnd = pParent; /* compute text metrics */ TEXTMETRIC metrics; pDC->GetTextMetrics(&metrics); fCharHeight = metrics.tmHeight + metrics.tmExternalLeading; fLinesPerPage = fVertRes / fCharHeight; WMSG2("fVertRes=%d, fCharHeight=%d\n", fVertRes, fCharHeight); /* set up our slightly reduced lines per page */ ASSERT(fLinesPerPage > kHeaderLines+1); fCLLinesPerPage = fLinesPerPage - kHeaderLines; } /* * Compute the number of pages in fpContentList. */ void PrintContentList::CalcNumPages(void) { /* set up our local goodies */ ASSERT(fpContentList != nil); int numLines = fpContentList->GetItemCount(); ASSERT(numLines > 0); fNumPages = (numLines + fCLLinesPerPage -1) / fCLLinesPerPage; ASSERT(fNumPages > 0); WMSG3("Using numLines=%d, fNumPages=%d, fCLLinesPerPage=%d\n", numLines, fNumPages, fCLLinesPerPage); } /* * Initiate printing of the specified list to the specified DC. * * Returns 0 if all went well, nonzero on cancellation or failure. */ int PrintContentList::Print(const ContentList* pContentList) { fpContentList = pContentList; CalcNumPages(); fFromPage = 1; fToPage = fNumPages; return StartPrint(); } int PrintContentList::Print(const ContentList* pContentList, int fromPage, int toPage) { fpContentList = pContentList; CalcNumPages(); fFromPage = fromPage; fToPage = toPage; return StartPrint(); } /* * Kick off the print job. */ int PrintContentList::StartPrint(void) { MainWindow* pMain = (MainWindow*)::AfxGetMainWnd(); BOOL bres; int jobID; int result = -1; ASSERT(fFromPage >= 1); ASSERT(fToPage <= fNumPages); // clear the abort flag pMain->SetAbortPrinting(false); // obstruct input to the main window fpParentWnd->EnableWindow(FALSE); // create a print-cancel dialog // PrintCancelDialog* pPCD = new PrintCancelDialog; CancelDialog* pPCD = new CancelDialog; bres = pPCD->Create(&pMain->fAbortPrinting, IDD_PRINT_CANCEL, fpParentWnd); if (bres == FALSE) { WMSG0("WARNING: PrintCancelDialog init failed\n"); } else { fpDC->SetAbortProc(pMain->PrintAbortProc); } fDocTitle = pMain->GetPrintTitle(); // set up the print job CString printTitle; printTitle.LoadString(IDS_PRINT_CL_JOB_TITLE); DOCINFO di; ::ZeroMemory(&di, sizeof(DOCINFO)); di.cbSize = sizeof(DOCINFO); di.lpszDocName = printTitle; jobID = fpDC->StartDoc(&di); if (jobID <= 0) { WMSG0("Got invalid jobID from StartDoc\n"); goto bail; } WMSG1("Got jobID=%d\n", jobID); // do the printing if (DoPrint() != 0) { WMSG0("Printing was aborted\n"); fpDC->AbortDoc(); } else { WMSG0("Printing was successful\n"); fpDC->EndDoc(); result = 0; } bail: // destroy print-cancel dialog and restore main window fpParentWnd->EnableWindow(TRUE); //fpParentWnd->SetActiveWindow(); if (pPCD != nil) pPCD->DestroyWindow(); return result; } /* * Print all pages. * * Returns 0 on success, nonzero on failure. */ int PrintContentList::DoPrint(void) { WMSG2("Printing from page=%d to page=%d\n", fFromPage, fToPage); for (int page = fFromPage; page <= fToPage; page++) { if (fpDC->StartPage() <= 0) { WMSG0("StartPage returned <= 0, returning -1\n"); return -1; } DoPrintPage(page); // delay so we can test "cancel" button // { // MainWindow* pMain = (MainWindow*)::AfxGetMainWnd(); // pMain->EventPause(1000); // } if (fpDC->EndPage() <= 0) { WMSG0("EndPage returned <= 0, returning -1\n"); return -1; } } return 0; } /* * Print page N of the content list, where N is a 1-based count. */ void PrintContentList::DoPrintPage(int page) { /* * Column widths, on an arbitrary scale. These will be * scaled appropriately for the page resolution. */ static const struct { const char* name; int width; bool rightJust; } kColumnWidths[kNumVisibleColumns] = { { "Pathname", 250, false }, // 200 { "Type", 40, false }, // 44 { "Auxtype", 47, false }, // 42 { "Mod Date", 96, false }, // 99 { "Format", 52, false }, // 54 { "Size", 55, true }, // 60 { "Ratio", 40, true }, // 41 { "Packed", 55, true }, // 60 { "Access", 39, false }, // 53 upper, 45 lower }; const int kBorderWidth = 3; /* normalize */ float widthMult; int totalWidth; totalWidth = 0; for (int i = 0; i < NELEM(kColumnWidths); i++) totalWidth += kColumnWidths[i].width; widthMult = (float) fHorzRes / totalWidth; WMSG3("totalWidth=%d, fHorzRes=%d, mult=%.3f\n", totalWidth, fHorzRes, widthMult); /* * Calculate some goodies. */ int start, end; start = (page-1) * fCLLinesPerPage; end = start + fCLLinesPerPage; if (end >= fpContentList->GetItemCount()) end = fpContentList->GetItemCount()-1; int offset, nextOffset, cellWidth, border; border = (int) (kBorderWidth * widthMult); /* * Print page header. */ fpDC->TextOut(0, 1 * fCharHeight, fDocTitle); CString pageNum; pageNum.Format("Page %d/%d", page, fNumPages); int pageNumWidth = StringWidth(pageNum); fpDC->TextOut(fHorzRes - pageNumWidth, 1 * fCharHeight, pageNum); /* * Print data. */ for (int row = -1; row < fCLLinesPerPage && start + row <= end; row++) { CString text; offset = 0; for (int col = 0; col < kNumVisibleColumns; col++) { cellWidth = (int) ((float)kColumnWidths[col].width * widthMult); nextOffset = offset + cellWidth; if (col != kNumVisibleColumns-1) cellWidth -= border; if (col == 0) cellWidth -= (border*2); // extra border on pathname int yOffset; if (row == -1) { text = kColumnWidths[col].name; yOffset = (row+kHeaderLines-1) * fCharHeight; } else { text = fpContentList->GetItemText(start + row, col); yOffset = (row+kHeaderLines) * fCharHeight; } int strWidth; strWidth = TrimString(&text, cellWidth, col == 0); if (kColumnWidths[col].rightJust) fpDC->TextOut((offset + cellWidth) - strWidth, yOffset, text); else fpDC->TextOut(offset, yOffset, text); offset = nextOffset; } } /* * Add some fancy lines. */ CPen penBlack(PS_SOLID, 1, RGB(0, 0, 0)); CPen* pOldPen = fpDC->SelectObject(&penBlack); fpDC->MoveTo(0, (int) (fCharHeight * (kHeaderLines - 0.5))); fpDC->LineTo(fHorzRes, (int) (fCharHeight * (kHeaderLines - 0.5))); //fpDC->MoveTo(0, 0); //fpDC->LineTo(fHorzRes, fVertRes); //fpDC->MoveTo(fHorzRes-1, 0); //fpDC->LineTo(0, fVertRes); fpDC->SelectObject(pOldPen); } /* * ========================================================================== * PrintRichEdit * ========================================================================== */ /* * Calculate some constant values. */ void PrintRichEdit::Setup(CDC* pDC, CWnd* pParent) { /* preflighting can cause this to be initialized twice */ fpDC = nil; /* init base class */ InitBasics(pDC); if (!fInitialized) { /* * Find a nice font for the title area. */ const int kPointSize = 10; int fontHeight; BOOL result; fontHeight = -MulDiv(kPointSize, fLogPixelsY, 72); result = fTitleFont.CreateFont(fontHeight, 0, 0, 0, FW_NORMAL, 0, 0, 0, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, kTimesNewRoman); ASSERT(result); // everybody has Times New Roman } fpParentWnd = pParent; fInitialized = true; } /* * Pre-flight the print process to get the number of pages. */ int PrintRichEdit::PrintPreflight(CRichEditCtrl* pREC, int* pNumPages) { fStartChar = 0; fEndChar = -1; fStartPage = 0; fEndPage = -1; return StartPrint(pREC, "(test)", pNumPages, false); } /* * Print all pages. */ int PrintRichEdit::PrintAll(CRichEditCtrl* pREC, const char* title) { fStartChar = 0; fEndChar = -1; fStartPage = 0; fEndPage = -1; return StartPrint(pREC, title, nil, true); } /* * Print a range of pages. */ int PrintRichEdit::PrintPages(CRichEditCtrl* pREC, const char* title, int startPage, int endPage) { fStartChar = 0; fEndChar = -1; fStartPage = startPage; fEndPage = endPage; return StartPrint(pREC, title, nil, true); } /* * Print the selected area. */ int PrintRichEdit::PrintSelection(CRichEditCtrl* pREC, const char* title, long startChar, long endChar) { fStartChar = startChar; fEndChar = endChar; fStartPage = 0; fEndPage = -1; return StartPrint(pREC, title, nil, true); } /* * Start the printing process by posting a print-cancel dialog. */ int PrintRichEdit::StartPrint(CRichEditCtrl* pREC, const char* title, int* pNumPages, bool doPrint) { CancelDialog* pPCD = nil; MainWindow* pMain = (MainWindow*)::AfxGetMainWnd(); int result; /* set up the print cancel dialog */ if (doPrint) { BOOL bres; /* disable main UI */ fpParentWnd->EnableWindow(FALSE); pPCD = new CancelDialog; bres = pPCD->Create(&pMain->fAbortPrinting, IDD_PRINT_CANCEL, fpParentWnd); /* set up the DC's print abort callback */ if (bres != FALSE) fpDC->SetAbortProc(pMain->PrintAbortProc); } result = DoPrint(pREC, title, pNumPages, doPrint); if (doPrint) { fpParentWnd->EnableWindow(TRUE); if (pPCD != nil) pPCD->DestroyWindow(); } return result; } /* * Do some prep work before printing. */ void PrintRichEdit::PrintPrep(FORMATRANGE* pFR) { CFont* pOldFont; /* make sure we're in MM_TEXT mode */ fpDC->SetMapMode(MM_TEXT); TEXTMETRIC metrics; pOldFont = fpDC->SelectObject(&fTitleFont); fpDC->GetTextMetrics(&metrics); fCharHeight = metrics.tmHeight + metrics.tmExternalLeading; fpDC->SelectObject(pOldFont); //WMSG1("CHAR HEIGHT is %d\n", fCharHeight); /* compute fLeftMargin and fRightMargin */ ComputeMargins(); /* * Set up the FORMATRANGE values. The Rich Edit stuff likes to have * measurements in TWIPS, whereas the printer is using DC pixel * values. fLogPixels_ tells us how many pixels per inch. */ memset(pFR, 0, sizeof(FORMATRANGE)); pFR->hdc = pFR->hdcTarget = fpDC->m_hDC; /* * Set frame for printable area, in TWIPS. The printer DC will set * its own "reasonable" margins, so the area here is not the entire * sheet of paper. */ pFR->rcPage.left = pFR->rcPage.top = 0; pFR->rcPage.right = (fHorzRes * kTwipsPerInch) / fLogPixelsX; pFR->rcPage.bottom = (fVertRes * kTwipsPerInch) / fLogPixelsY; long topOffset = (long) ((fCharHeight * 1.5 * kTwipsPerInch) / fLogPixelsY); pFR->rc.top = pFR->rcPage.top + topOffset; pFR->rc.bottom = pFR->rcPage.bottom; pFR->rc.left = pFR->rcPage.left + (fLeftMargin * kTwipsPerInch) / fLogPixelsX; pFR->rc.right = pFR->rcPage.right - (fRightMargin * kTwipsPerInch) / fLogPixelsX; WMSG2("PRINTABLE AREA is %d wide x %d high (twips)\n", pFR->rc.right - pFR->rc.left, pFR->rc.bottom - pFR->rc.top); WMSG2("FRAME is %d wide x %d high (twips)\n", pFR->rcPage.right - pFR->rcPage.left, pFR->rcPage.bottom - pFR->rcPage.top); pFR->chrg.cpMin = fStartChar; pFR->chrg.cpMax = fEndChar; } /* * Compute the size of the left and right margins, based on the width of 80 * characters of 10-point Courier New on the current printer. * * Sets fLeftMargin and fRightMargin, in printer DC pixels. */ void PrintRichEdit::ComputeMargins(void) { CFont tmpFont; CFont* pOldFont; int char80width, fontHeight, totalMargin; BOOL result; fontHeight = -MulDiv(10, fLogPixelsY, 72); result = tmpFont.CreateFont(fontHeight, 0, 0, 0, FW_NORMAL, 0, 0, 0, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, kCourierNew); ASSERT(result); pOldFont = fpDC->SelectObject(&tmpFont); // in theory we could compute one 'X' * 80; this seems more reliable char str[81]; for (int i = 0; i < 80; i++) str[i] = 'X'; str[i] = '\0'; char80width = StringWidth(str); fpDC->SelectObject(pOldFont); //WMSG1("char80 string width=%d\n", char80width); /* * If there's not enough room on the page, set the margins to zero. * If the margins required exceed two inches, just set the margin * to one inch on either side. */ totalMargin = fHorzRes - char80width; if (totalMargin < 0) { WMSG0(" Page not wide enough, setting margins to zero\n"); fLeftMargin = fRightMargin = 0; } else if (totalMargin > fLogPixelsX * 2) { WMSG0(" Page too wide, setting margins to 1 inch\n"); fLeftMargin = fRightMargin = fLogPixelsX; } else { // try to get leftMargin equal to 1/2" fLeftMargin = totalMargin / 2; if (fLeftMargin > fLogPixelsX / 2) fLeftMargin = fLogPixelsX / 2; fRightMargin = totalMargin - fLeftMargin -1; WMSG3(" +++ Margins (in %d pixels/inch) are left=%ld right=%ld\n", fLogPixelsX, fLeftMargin, fRightMargin); } } /* * Send the contents of the rich edit control to the printer DC. * * This was derived from Microsft KB article 129860. */ int PrintRichEdit::DoPrint(CRichEditCtrl* pREC, const char* title, int* pNumPages, bool doPrint) { FORMATRANGE fr; DOCINFO di; long textLength, textPrinted, lastTextPrinted; int pageNum; WMSG2("DoPrint: title='%s' doPrint=%d\n", title, doPrint); WMSG4(" startChar=%d endChar=%d startPage=%d endPage=%d\n", fStartChar, fEndChar, fStartPage, fEndPage); /* * Get the title font and fill out the FORMATRANGE structure. */ PrintPrep(&fr); /* fill out a DOCINFO */ memset(&di, 0, sizeof(di)); di.cbSize = sizeof(DOCINFO); di.lpszDocName = title; if (doPrint) fpDC->StartDoc(&di); /* * Here's the really strange part of the affair. The GetTextLength call * shown in the MSFT KB article doesn't return the correct number of * characters. The CRichEditView code in MFC uses a GetTextLengthEx * call, which is documented as being part of the CRichEditCtrl but * doesn't appear in the header files. Call it the hard way. * * If you print a "raw" file with carriage returns, and you use version * 5.30.23.1200 of "riched20.dll", you get "9609" from GetTextLength and * "9528" from GetTextLengthEx when the document's length is 9528 and * there are 81 carriage returns. The value you want to use is 9528, * because the print code doesn't double-up the count on CRs. * * If instead you use version 5.30.23.1215, you get the same answer * from both calls, and printing works fine. * * GetTextLengthEx is part of "riched20.dll". Win9x uses "riched32.dll", * which doesn't support the call. */ #ifdef _UNICODE # error "should be code page 1200, not CP_ACP" #endif GETTEXTLENGTHEX exLenReq; long basicTextLength, extdTextLength; basicTextLength = pREC->GetTextLength(); exLenReq.flags = GTL_PRECISE | GTL_NUMCHARS; exLenReq.codepage = CP_ACP; extdTextLength = (long)::SendMessage(pREC->m_hWnd, EM_GETTEXTLENGTHEX, (WPARAM) &exLenReq, (LPARAM) NULL); WMSG2("RichEdit text length: std=%ld extd=%ld\n", basicTextLength, extdTextLength); if (fEndChar == -1) { if (extdTextLength > 0) textLength = extdTextLength; else textLength = basicTextLength; } else textLength = fEndChar - fStartChar; WMSG1(" +++ starting while loop, textLength=%ld\n", textLength); pageNum = 0; lastTextPrinted = -1; do { bool skipPage = false; pageNum++; WMSG1(" +++ while loop: pageNum is %d\n", pageNum); if (fEndPage > 0) { if (pageNum < fStartPage) skipPage = true; if (pageNum > fEndPage) break; // out of while, ending print } if (doPrint && !skipPage) { fpDC->StartPage(); CFont* pOldFont = fpDC->SelectObject(&fTitleFont); fpDC->TextOut(0, 0 * fCharHeight, title); CString pageNumStr; pageNumStr.Format("Page %d", pageNum); int pageNumWidth = StringWidth(pageNumStr); fpDC->TextOut(fHorzRes - pageNumWidth, 0 * fCharHeight, pageNumStr); fpDC->SelectObject(pOldFont); CPen penBlack(PS_SOLID, 1, RGB(0, 0, 0)); CPen* pOldPen = fpDC->SelectObject(&penBlack); int ycoord = (int) (fCharHeight * 1.25); fpDC->MoveTo(0, ycoord-1); fpDC->LineTo(fHorzRes, ycoord-1); fpDC->MoveTo(0, ycoord); fpDC->LineTo(fHorzRes, ycoord); fpDC->SelectObject(pOldPen); } //WMSG1(" +++ calling FormatRange(%d)\n", doPrint && !skipPage); //LogHexDump(&fr, sizeof(fr)); /* print a page full of RichEdit stuff */ textPrinted = pREC->FormatRange(&fr, doPrint && !skipPage); WMSG1(" +++ returned from FormatRange (textPrinted=%d)\n", textPrinted); if (textPrinted <= lastTextPrinted) { /* the earlier StartPage can't be undone, so we'll get an extra blank page at the very end */ WMSG3("GLITCH: no new text printed (printed=%ld, last=%ld, len=%ld)\n", textPrinted, lastTextPrinted, textLength); pageNum--; // fix page count estimator break; } lastTextPrinted = textPrinted; // delay so we can test "cancel" button //((MainWindow*)::AfxGetMainWnd())->EventPause(1000); if (doPrint && !skipPage) { if (fpDC->EndPage() <= 0) { /* the "cancel" button was hit */ WMSG0("EndPage returned <= 0 (cancelled)\n"); fpDC->AbortDoc(); return -1; } } if (textPrinted < textLength) { fr.chrg.cpMin = textPrinted; fr.chrg.cpMax = fEndChar; // -1 if nothing selected } } while (textPrinted < textLength); //WMSG0(" +++ calling FormatRange(nil, FALSE)\n"); pREC->FormatRange(nil, FALSE); //WMSG0(" +++ returned from final FormatRange\n"); if (doPrint) fpDC->EndDoc(); if (pNumPages != nil) *pNumPages = pageNum; WMSG1("Printing completed (textPrinted=%ld)\n", textPrinted); return 0; }