![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sty_prnt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / style|
Return to sty_prnt.c CVS log | Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / style |
1.1 ! root 1: /*==============================================================*\ ! 2: * Prnt.c - routines for printing of a document ! 3: * Created 1990, Microsoft, IBM Corp. ! 4: *-------------------------------------------------------------- ! 5: * ! 6: * This module contains the routines for the printing of a ! 7: * a document. Included are the routines for calling the ! 8: * standard dialogs for obtaining the user's printer and ! 9: * page setup preferences. Also included is the routine to ! 10: * determine the number of pages in a document as well as the ! 11: * routine to obtain the printer DC and print the document. ! 12: * ! 13: *-------------------------------------------------------------- ! 14: * ! 15: * This source file contains the following functions: ! 16: * ! 17: * InitPrinting(); ! 18: * PageSetup(hwndOwner); ! 19: * PrintSetup(hwndOwner); ! 20: * Print(); ! 21: * CalcPrintArea(hpsPrinter, ! 22: * hdcPrinter, ! 23: * prclPrintArea, ! 24: * pfm); ! 25: * PrintDoc(hdc); ! 26: * QueryMaxPages(); ! 27: * ! 28: * ! 29: \*==============================================================*/ ! 30: ! 31: /*--------------------------------------------------------------*\ ! 32: * Include files, macros, defined constants, and externs ! 33: \*--------------------------------------------------------------*/ ! 34: ! 35: #define INCL_WINMLE ! 36: #define INCL_GPICONTROL ! 37: #define INCL_GPITRANSFORMS ! 38: #define INCL_GPIPRIMITIVES ! 39: #define INCL_GPILCIDS ! 40: #define INCL_DEV ! 41: ! 42: #include <os2.h> ! 43: #include "sty_main.h" ! 44: #include "sty_xtrn.h" ! 45: ! 46: #if 0 ! 47: #include "pmkitp.h" ! 48: #define PRINT_DLGS_ENABLED ! 49: #endif ! 50: ! 51: #define MAXHEADERLEN 100 /* maximum length of header */ ! 52: #define MAXFOOTERLEN 100 /* maximum length of footer */ ! 53: #define DLGTITLELEN 30 /* length of dialog title string */ ! 54: ! 55: #define DEVDATACOUNT 7L /* # fields of DEVOPENSTRUCT used */ ! 56: ! 57: #define FONTLCID 1L /* LCID for printer font */ ! 58: ! 59: #define QMP_ERROR -1 /* error return from QueryMaxPages() */ ! 60: ! 61: /* constants used in InitPrintingDlgs() for initial and maximum margins */ ! 62: #define ONEINCH (MAKEFIXED(1, 0)) ! 63: #define EIGHTINCHES (MAKEFIXED(8, 0)) ! 64: #define ELEVENINCHES (MAKEFIXED(11, 0)) ! 65: ! 66: /* Macro for converting a FIXED integer value into LO_ENGLISH ! 67: world coordinates */ ! 68: #define FIXEDTOWORLD(x) ((FIXEDINT(x) * 100L) + \ ! 69: ((FIXEDFRAC(x) * 100L) / 65536L)) ! 70: ! 71: ! 72: /*--------------------------------------------------------------*\ ! 73: * Global variables ! 74: \*--------------------------------------------------------------*/ ! 75: #ifdef PRINT_DLGS_ENABLED ! 76: ! 77: static PAGESETUPDLG pgsd; ! 78: static PRINTSETUPDLG psd; ! 79: static PRINTDLG prtd; ! 80: static CHAR szHeader[MAXHEADERLEN], szFooter[MAXFOOTERLEN]; ! 81: static CHAR szPgsdTitle[DLGTITLELEN]; ! 82: static CHAR szPsdtitle[DLGTITLELEN]; ! 83: static CHAR szPrtdTitle[DLGTITLELEN]; ! 84: ! 85: #endif ! 86: ! 87: /*--------------------------------------------------------------*\ ! 88: * Entry point declarations ! 89: \*--------------------------------------------------------------*/ ! 90: SHORT QueryMaxPages(VOID); ! 91: BOOL PrintDoc(HDC hdc); ! 92: BOOL CalcPrintArea(HPS hpsPrinter, ! 93: PRECTL prclPrintArea, ! 94: PFONTMETRICS pfm); ! 95: ! 96: ! 97: /****************************************************************\ ! 98: * Initalizes the print dialog structures ! 99: *-------------------------------------------------------------- ! 100: * ! 101: * Name: InitPrintDialogs() ! 102: * ! 103: * Purpose: Places defaults in the global info structures ! 104: * used by the standard print dialogs ! 105: * ! 106: * Usage: called once from the initialization routine ! 107: * ! 108: * Method: places standard defaults into each of the fields ! 109: * of the Page Setup, Print Setup, and Print Dialog ! 110: * structures. The values used are standard defaults, ! 111: * such as inches for the page units, which can be ! 112: * easily changed by changing the default values in ! 113: * the routine. The application developer should ! 114: * modify these values if he wishes to have the ! 115: * default printer and page setup use different values. ! 116: * ! 117: * Returns: ! 118: * ! 119: \****************************************************************/ ! 120: VOID InitPrintingDialogs(VOID) ! 121: { ! 122: ! 123: #ifdef PRINT_DLGS_ENABLED ! 124: ! 125: fPrintEnabled = TRUE; ! 126: ! 127: /*--------------------------------------------------------------*\ ! 128: * Initialize the Page Setup structure ! 129: \*--------------------------------------------------------------*/ ! 130: pgsd.kgd.cbSize = sizeof(PAGESETUPDLG); ! 131: pgsd.kgd.flStyle = PGSS_CENTER; ! 132: ! 133: if(!WinLoadString(hab, ! 134: NULL, ! 135: IDS_PAGESETUPTITLE, ! 136: DLGTITLELEN, ! 137: (PSZ)szPgsdTitle)) { ! 138: ! 139: MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, FALSE); ! 140: fPrintEnabled = FALSE; ! 141: return; ! 142: } ! 143: ! 144: pgsd.kgd.pszDlgTitle = szPgsdTitle; ! 145: pgsd.kgd.pfnDlgProc = NULL; ! 146: pgsd.kgd.hmod = NULL; ! 147: pgsd.kgd.idDlg = 0; ! 148: pgsd.kgd.lReturn = 0L; ! 149: pgsd.kgd.x = 0; ! 150: pgsd.kgd.y = 0; ! 151: ! 152: pgsd.flFlags = PGSF_INCHES; ! 153: ! 154: /* Setup the header and footer fields. */ ! 155: pgsd.cchHeader = MAXFOOTERLEN; ! 156: pgsd.cchFooter = MAXHEADERLEN; ! 157: pgsd.pszHeader = szHeader; ! 158: pgsd.pszFooter = szFooter; ! 159: ! 160: /* Setup the margin fields to one inch top and side margins */ ! 161: pgsd.fxLeftMargin = ONEINCH; ! 162: pgsd.fxRightMargin = ONEINCH; ! 163: pgsd.fxTopMargin = ONEINCH; ! 164: pgsd.fxBottomMargin = ONEINCH; ! 165: ! 166: /* maximum margins are 8 inch left and right, 11 inch bottom. We ! 167: are assuming the default page size is 8 1/2" x 11 " */ ! 168: pgsd.fxLeftMarginMax = EIGHTINCHES; ! 169: pgsd.fxRightMarginMax = EIGHTINCHES; ! 170: pgsd.fxTopMarginMax = ELEVENINCHES; ! 171: pgsd.fxBottomMarginMax = ELEVENINCHES; ! 172: ! 173: pgsd.lUser = 0L; ! 174: ! 175: ! 176: /*--------------------------------------------------------------*\ ! 177: * Initialize the Print Setup structure ! 178: \*--------------------------------------------------------------*/ ! 179: psd.kgd.cbSize = sizeof(PRINTSETUPDLG); ! 180: psd.kgd.flStyle = PGSS_CENTER; ! 181: ! 182: if(!WinLoadString(hab, ! 183: NULL, ! 184: IDS_PRINTSETUPTITLE, ! 185: DLGTITLELEN, ! 186: (PSZ)szPsdTitle)) { ! 187: ! 188: MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, FALSE); ! 189: fPrintEnabled = FALSE; ! 190: return; ! 191: } ! 192: ! 193: psd.kgd.pszDlgTitle = szPsdTitle; ! 194: psd.kgd.pfnDlgProc = NULL; ! 195: psd.kgd.hmod = NULL; ! 196: psd.kgd.idDlg = 0; ! 197: psd.kgd.lReturn = 0L; ! 198: psd.kgd.x = 0; ! 199: psd.kgd.y = 0; ! 200: ! 201: psd.pszAppName = szAppName; ! 202: psd.lUser = 0L; ! 203: ! 204: /*--------------------------------------------------------------*\ ! 205: * Initialize the Print Dialog structure ! 206: \*--------------------------------------------------------------*/ ! 207: prtd.kgd.cbSize = sizeof(PRINTDLG); ! 208: prtd.kgd.flStyle = PGSS_CENTER; ! 209: ! 210: if(!WinLoadString(hab, ! 211: NULL, ! 212: IDS_PRINTTITLE, ! 213: DLGTITLELEN, ! 214: (PSZ)szPrtdTitle)) { ! 215: ! 216: MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, FALSE); ! 217: fPrintEnabled = FALSE; ! 218: return; ! 219: } ! 220: ! 221: ! 222: prtd.kgd.pszDlgTitle = szPrtdTitle; ! 223: prtd.kgd.pfnDlgProc = NULL; ! 224: prtd.kgd.hmod = NULL; ! 225: prtd.kgd.idDlg = 0; ! 226: prtd.kgd.lReturn = 0L; ! 227: prtd.kgd.x = 0; ! 228: prtd.kgd.y = 0; ! 229: ! 230: prtd.flFlags = PRTF_ALLPAGES; ! 231: prtd.cPages = 0; ! 232: prtd.cCopies = 1; ! 233: ! 234: prtd.iFrom = 0; ! 235: prtd.iTo = 0; ! 236: ! 237: prtd.cchFileName = 0; ! 238: prtd.pszFileName = NULL; ! 239: ! 240: prtd.lUser = 0L; ! 241: ! 242: ! 243: /*--------------------------------------------------------------*\ ! 244: * Associate all of the dialog structures with each other so ! 245: * that the dialogs can be called from one another ! 246: \*--------------------------------------------------------------*/ ! 247: pgsd.ppsd = &psd; ! 248: pgsd.pprtd = &prtd; ! 249: psd.ppgsd = &pgsd; ! 250: psd.pprtd = &prtd; ! 251: prtd.ppsd = &psd; ! 252: prtd.ppgsd = &pgsd; ! 253: ! 254: ! 255: /*--------------------------------------------------------------*\ ! 256: * Initialize the DEVOPENSTRUC in psd and prtd with the data ! 257: * from the default printer in os2.ini ! 258: \*--------------------------------------------------------------*/ ! 259: psd.kgd.flStyle |= PSS_INITDEVOPENSTRUC; ! 260: if(!KitPrintSetupDlg(NULL, &psd)) ! 261: fPrintEnabled = FALSE; ! 262: ! 263: prtd.kgd.flStyle |= PSS_INITDEVOPENSTRUC; ! 264: if(!KitPrintDlg(NULL, &prtd)) ! 265: fPrintEnabled = FALSE; ! 266: ! 267: if(!fPrintEnabled) ! 268: MessageBox(HWND_DESKTOP, ! 269: IDMSG_PRINTINITFAILED, ! 270: MB_OK | MB_ERROR, ! 271: FALSE); ! 272: ! 273: #else ! 274: fPrintEnabled = FALSE; ! 275: #endif ! 276: ! 277: } /* InitPrintDialogs() */ ! 278: ! 279: #ifdef PRINT_DLGS_ENABLED ! 280: ! 281: ! 282: /****************************************************************\ ! 283: * Calls the page setup dialog ! 284: *-------------------------------------------------------------- ! 285: * ! 286: * Name: PageSetup(hwndOwner) ! 287: * ! 288: * Purpose: Changes the page setup options by calling the ! 289: * standard page setup dialog ! 290: * ! 291: * Usage: called whenever the user wants to update his ! 292: * page setup. ! 293: * ! 294: * Method: Calls the standard Page Setup dialog with the ! 295: * global PAGESETUPDLG structure which currently ! 296: * holds the user's choices. ! 297: * ! 298: * Returns: ! 299: * ! 300: \****************************************************************/ ! 301: VOID PageSetup(hwndOwner) ! 302: HWND hwndOwner; /* Owner of the dialog */ ! 303: { ! 304: if(!KitPageSetupDlg(hwndOwner, &pgsd)) ! 305: MessageBox(hwndOwner, ! 306: IDMSG_CANNOTRUNPAGESETUP, ! 307: MB_OK | MB_ERROR, ! 308: TRUE); ! 309: ! 310: } /* PageSetup() */ ! 311: ! 312: ! 313: /****************************************************************\ ! 314: * Calls the print setup dialog ! 315: *-------------------------------------------------------------- ! 316: * ! 317: * Name: PrintSetup(hwndOwner) ! 318: * ! 319: * Purpose: Changes the printer setup by calling the standard ! 320: * print setup dialog ! 321: * ! 322: * Usage: called whenever the user wants to update his ! 323: * printer set up. ! 324: * ! 325: * Method: Calls the standard Print Setup dialog with the ! 326: * global PRINTSETUPDLG structure which currently ! 327: * holds the user's choices. ! 328: * ! 329: * Returns: ! 330: * ! 331: \****************************************************************/ ! 332: VOID PrintSetup(hwndOwner) ! 333: HWND hwndOwner; /* Owner of the dialog */ ! 334: { ! 335: ! 336: if(!KitPrintSetupDlg(hwndOwner, &psd)) ! 337: MessageBox(hwndOwner, ! 338: IDMSG_CANNOTRUNPRINTSETUP, ! 339: MB_OK | MB_ERROR, ! 340: TRUE); ! 341: ! 342: } /* PrintSetup() */ ! 343: ! 344: ! 345: /****************************************************************\ ! 346: * Begins the printing of a document ! 347: *-------------------------------------------------------------- ! 348: * ! 349: * Name: Print() ! 350: * ! 351: * Purpose: Does the groundwork necessary when printing a file ! 352: * ! 353: * Usage: called whenever the user wants to print his file ! 354: * ! 355: * Method: - determines the number of pages in the document ! 356: * - calls the standard print dialog to get the user's ! 357: * printing options ! 358: * - opens the DC for the selected printer ! 359: * - calls the application's printing routine, passing ! 360: * it the handle to the DC of the printer ! 361: * ! 362: * Returns: ! 363: * ! 364: \****************************************************************/ ! 365: VOID Print(hwndOwner) ! 366: HWND hwndOwner; /* Owner of the dialog */ ! 367: { ! 368: HDC hdcPrinter; ! 369: ! 370: /* Determine number of pages available to print */ ! 371: prtd.cPages = QueryMaxPages(); ! 372: if(prtd.cPages == QMP_ERROR) { ! 373: MessageBox(hwndOwner, IDMSG_CANNOTGETPAGEINFO, MB_OK | MB_ERROR, FALSE); ! 374: return; ! 375: } ! 376: ! 377: prtd.cCopies = 1; /* initialize the number of copies to one */ ! 378: ! 379: /* Bring up the Print Dialog */ ! 380: if(!KitPrintDlg(hwndOwner, &prtd)) { ! 381: MessageBox(hwndOwner, IDMSG_CANNOTRUNPRINT, MB_OK | MB_ERROR, TRUE); ! 382: return; ! 383: } ! 384: ! 385: /* if user cancelled the dialog, cancel the printing */ ! 386: if(prtd.kgd.lReturn == ID_CANCEL) ! 387: return; ! 388: ! 389: ! 390: /*--------------------------------------------------------------*\ ! 391: * Open the DC for the default printer. The default printer ! 392: * DEVOPENDATA is stored in the prtd structure ! 393: \*--------------------------------------------------------------*/ ! 394: hdcPrinter = DevOpenDC(hab, ! 395: OD_QUEUED, ! 396: "*", ! 397: DEVDATACOUNT, ! 398: (PDEVOPENDATA)&prtd.ppsd->dop, ! 399: (HDC)NULL); ! 400: ! 401: if(!hdcPrinter) { ! 402: MessageBox(hwndMain, IDMSG_CANNOTOPENPRINTER, MB_OK | MB_ERROR, FALSE); ! 403: return; ! 404: } ! 405: ! 406: /*--------------------------------------------------------------*\ ! 407: * Call the application's printing function ! 408: \*--------------------------------------------------------------*/ ! 409: ! 410: if(!PrintDoc(hdcPrinter)) ! 411: MessageBox(hwndOwner, IDMSG_PRINTERROR, MB_OK | MB_ERROR, FALSE); ! 412: ! 413: DevCloseDC(hdcPrinter); ! 414: ! 415: } /* Print() */ ! 416: ! 417: ! 418: /****************************************************************\ ! 419: * Calculates the print area of the printer page ! 420: *-------------------------------------------------------------- ! 421: * ! 422: * Name: CalcPrintArea(hpsPrinter, prclPrintArea, pfm) ! 423: * ! 424: * Purpose: Sets up the print HPS by installing the font, ! 425: * calculating the print rectangle, and returning ! 426: * the metrics of the chosen font ! 427: * ! 428: * Usage: called by PrintDoc() and QueryMaxPages() to set ! 429: * up the printer HPS for printing. ! 430: * ! 431: * Note: HPS must be associated with the printer HDC ! 432: * ! 433: * Method: Routine creates an HPS for the printer DC that ! 434: * uses LOENGLISH for page units. A similar HPS is ! 435: * created for the MLE through which the current MLE ! 436: * font is translated from device metrics to LOENGLISH ! 437: * metrics. The print rectangle is determined by ! 438: * finding the printer page size and then subtracting ! 439: * the margins and the headers and footers, if any. ! 440: * The new font is selected into the printer PS and ! 441: * the metrics are returned for the font. The HPS ! 442: * is returned with the printer font selected. ! 443: * ! 444: * Returns: TRUE if successfull, FALSE if not ! 445: * ! 446: \****************************************************************/ ! 447: BOOL CalcPrintArea(hpsPrinter, prclPrintArea, pfm) ! 448: HPS hpsPrinter; /* INPUT: HPS associated with the printer DC */ ! 449: PRECTL prclPrintArea; /* OUTPUT: buffer for the print rectangle */ ! 450: PFONTMETRICS pfm; /* OUTPUT: pointer to buffer for fontmetrics of ! 451: printer font */ ! 452: { ! 453: HPS hpsMLE; ! 454: SIZEL szl; ! 455: FATTRS fattr; ! 456: FONTMETRICS fm; ! 457: HDC hdcPrinter; ! 458: ! 459: szl.cx = szl.cy = 0L; ! 460: ! 461: /* get the handle to the HDC of the printer */ ! 462: hdcPrinter = GpiQueryDevice(hpsPrinter); ! 463: if(!hdcPrinter) ! 464: return FALSE; ! 465: ! 466: /* get width and height of paper and convert those points to page units */ ! 467: if(!DevQueryCaps(hdcPrinter, CAPS_WIDTH, 2L, (PLONG)&szl)) ! 468: return FALSE; ! 469: ! 470: if(GpiConvert(hpsPrinter, CVTC_DEVICE, CVTC_WORLD, 2L, (PPOINTL)&szl) == ! 471: GPI_ERROR) ! 472: return FALSE; ! 473: ! 474: ! 475: ! 476: /*--------------------------------------------------------------*\ ! 477: * prclPrintArea will be set to the rectangle that encompasses ! 478: * the area of the page where the text will be printed. The ! 479: * rectangle is defined to be the rectangle of the page minus ! 480: * the margins on each side. For example, the print area ! 481: * on a page using the default margins will be the rectangle ! 482: * that is one inch from the left, bottom, right, and top ! 483: * edges of the papaer. ! 484: * ! 485: * This routine creates the print area rectangle in world ! 486: * coordinates. Since the printer HPS was created in LOENGLISH ! 487: * page units, each point of world coordinate space equals ! 488: * .01 inch, or 100 points equals one inch. The left and ! 489: * bottom sides of the print area rectangle are equal to the ! 490: * the number of inches of the left and bottom margins times ! 491: * 100. The top and right margins can also be calculated by ! 492: * multiplying the margin size * 100, but then that distance ! 493: * must be subtracted from the width and height of the paper. ! 494: * ! 495: * The FIXEDTOWORLD() macro, as defined above, converts a ! 496: * FIXED integer value into LOENGLISH world coordinates. If ! 497: * you change either the page units of the printer HPS or the ! 498: * scale of the margins, you must changed FIXEDTOWORLD() to ! 499: * translate the margin dimensions to fit the new parameters. ! 500: * ! 501: \*--------------------------------------------------------------*/ ! 502: prclPrintArea->xLeft = FIXEDTOWORLD(pgsd.fxLeftMargin); ! 503: ! 504: prclPrintArea->yBottom = FIXEDTOWORLD(pgsd.fxBottomMargin); ! 505: ! 506: prclPrintArea->xRight = szl.cx - FIXEDTOWORLD(pgsd.fxRightMargin); ! 507: ! 508: prclPrintArea->yTop = szl.cy - FIXEDTOWORLD(pgsd.fxTopMargin); ! 509: ! 510: ! 511: ! 512: /* get a PS for the MLE and set it to be LOENGLISH also. ! 513: * ! 514: * Note: only GpiSetPS is checked for an error return. That is ! 515: * because if the WinGetPS() function returns an error, hpsMLE ! 516: * will be NULL. If hpsMLE is NULL, then GpiSetPS() will fail. ! 517: * So, GpiSetPS() will fail if WinGetPS() fails, so we only need ! 518: * to check the return code from GpiSetPS() ! 519: */ ! 520: ! 521: hpsMLE = WinGetPS(hwndMLE); ! 522: if(GpiSetPS(hpsMLE, &szl, PU_LOENGLISH) == GPI_ERROR) ! 523: return FALSE; ! 524: ! 525: /* get font information from MLE and create similar font on printer */ ! 526: WinSendMsg(hwndMLE, MLM_QUERYFONT, MPFROMP(&fattr), NULL); ! 527: ! 528: /* convert font information to LOENGLISH by setting the font into ! 529: * the LOENGLISH PS we created for the MLE, getting the ! 530: * fontmetrics, and then updating the fattr structure. ! 531: * ! 532: * Note: only GpiSetCharSet's return value is checked, because if ! 533: * the GpiCreateLogFont call fails, the LCID passed to GpiSetCharSet ! 534: * will be invalid and GpiSetCharSet will fail as well. ! 535: */ ! 536: ! 537: GpiCreateLogFont(hpsMLE, (PSTR8)fattr.szFacename, FONTLCID, &fattr); ! 538: if(GpiSetCharSet(hpsMLE, FONTLCID) == GPI_ERROR) ! 539: return FALSE; ! 540: ! 541: if(GpiQueryFontMetrics(hpsMLE, ! 542: (ULONG)sizeof(FONTMETRICS), ! 543: (PFONTMETRICS)&fm) == GPI_ERROR) ! 544: return FALSE; ! 545: ! 546: /* delete font and release MLE HPS. Return values are not checked for ! 547: * error because a failure in the clean up of the HPS will not ! 548: * adversely affect this routine ! 549: */ ! 550: GpiSetCharSet(hpsMLE, 0); ! 551: GpiDeleteSetId(hpsMLE, FONTLCID); ! 552: WinReleasePS(hpsMLE); ! 553: ! 554: /* The FATTRS structure was filled with the information for the font ! 555: * of the MLE. The height and width of the font is in device ! 556: * coordinates, however. Since we created the same font on a ! 557: * PU_LOENGLISH HPS, we now can get the height and width in ! 558: * PU_LOENGLISH page units. These values are contained in the ! 559: * fm structure. We replace the height and width of the font with ! 560: * the PU_LOENGLISH equavalents and set the lMatch to 0, so that ! 561: * GPI will look through all printer fonts for the font that most ! 562: * closely matches the size of the font used on the screen. ! 563: */ ! 564: ! 565: fattr.lMaxBaselineExt = fm.lMaxBaselineExt; ! 566: fattr.lAveCharWidth = fm.lAveCharWidth; ! 567: fattr.lMatch = 0L; ! 568: ! 569: /* Create the font on the printer HPS. ! 570: * ! 571: * Note: if GpiCreateLogFont() returns 1, then an exact match for ! 572: * the font desired was not found. This application does not care ! 573: * if the font matches exactly or not, but your application might. ! 574: * If GpiCreateLogFont() returns 0, and error occurred, which will ! 575: * be caught when we attempt GpiSetCharSet() with this font's LCID ! 576: */ ! 577: GpiCreateLogFont(hpsPrinter, (PSTR8)fattr.szFacename, FONTLCID, &fattr); ! 578: ! 579: if(GpiSetCharSet(hpsPrinter, FONTLCID) == GPI_ERROR) ! 580: return FALSE; ! 581: ! 582: /* get printer font information for return in pfm */ ! 583: if(GpiQueryFontMetrics(hpsPrinter, ! 584: (LONG)sizeof(FONTMETRICS), ! 585: pfm) == GPI_ERROR) ! 586: return FALSE; ! 587: ! 588: ! 589: /*--------------------------------------------------------------*\ ! 590: * If a header or footer is present, it will take two lines - ! 591: * one for the text and one blank line. Since rclPrintArea ! 592: * is the rectangle where the document text is to be printed, ! 593: * the two lines of the header or footer are removed from ! 594: * the current print area. The top and bottom side are ! 595: * adjusted accordingly. ! 596: * ! 597: * When the header and footer are printed, they are printed ! 598: * two lines above and below the print area. ! 599: * ! 600: \*--------------------------------------------------------------*/ ! 601: ! 602: /* if header is present, adjust top for it */ ! 603: if(pgsd.pszHeader[0]) ! 604: prclPrintArea->yTop -= (pfm->lMaxBaselineExt + ! 605: pfm->lExternalLeading) * 2L; ! 606: ! 607: /* if footer is present, adjust bottom for it */ ! 608: if(pgsd.pszFooter[0]) ! 609: /*--------------------------------------------------------------*\ ! 610: * A line of text has a height equal to the MaxBaselineExt ! 611: * followed by the ExternalLeading. Since the footer is ! 612: * printed on the bottom of the page, the ExternalLeading ! 613: * following the footer is not necessary. The height of the ! 614: * footer, then, is calculated as the sum of the heights ! 615: * of the text line, the blank line, and the External Leading * ! 616: * between them. ! 617: * ! 618: \*--------------------------------------------------------------*/ ! 619: prclPrintArea->yBottom += (pfm->lMaxBaselineExt * 2L) + ! 620: pfm->lExternalLeading; ! 621: ! 622: return TRUE; ! 623: ! 624: } /* CalcPrintArea() */ ! 625: ! 626: ! 627: /****************************************************************\ ! 628: * Determines the maximum number of pages in the document ! 629: *-------------------------------------------------------------- ! 630: * ! 631: * Name: QueryMaxPages() ! 632: * ! 633: * Purpose: returns the maximum number of pages in a file ! 634: * ! 635: * Usage: called by Print() to initialize the prtd.cPages ! 636: * field ! 637: * ! 638: * Method: ! 639: * ! 640: * Returns: Number of pages in the document or QMP_ERROR if an error ! 641: * ! 642: \****************************************************************/ ! 643: SHORT QueryMaxPages(VOID) ! 644: { ! 645: HDC hdcPrinter; ! 646: FONTMETRICS fm; ! 647: RECTL rclPrintArea; ! 648: HPS hpsPrinter; ! 649: SIZEL szl; ! 650: LONG lLines, lLinesPerPage; ! 651: ! 652: /*--------------------------------------------------------------*\ ! 653: * Code to determine the number of pages in the document ! 654: * to be printed ! 655: \*--------------------------------------------------------------*/ ! 656: ! 657: /* create an info dc for the printer */ ! 658: hdcPrinter = DevOpenDC(hab, ! 659: OD_INFO, ! 660: "*", ! 661: DEVDATACOUNT, ! 662: (PDEVOPENDATA)&prtd.ppsd->dop, ! 663: (HDC)NULL); ! 664: if(!hdcPrinter) ! 665: return QMP_ERROR; ! 666: ! 667: /* create a ps for the DC. Use english page units so we can ! 668: measure the margins easily */ ! 669: szl.cx = szl.cy = 0L; ! 670: hpsPrinter = GpiCreatePS(hab, ! 671: hdcPrinter, ! 672: &szl, ! 673: PU_LOENGLISH | GPIT_NORMAL | GPIF_DEFAULT | GPIA_ASSOC); ! 674: if(!hpsPrinter) ! 675: return QMP_ERROR; ! 676: ! 677: if(!CalcPrintArea(hpsPrinter, &rclPrintArea, &fm)) ! 678: return QMP_ERROR; ! 679: ! 680: /* get number of lines in the document */ ! 681: lLines = (LONG)WinSendMsg(hwndMLE, MLM_QUERYLINECOUNT, NULL, NULL); ! 682: ! 683: /* calculate the number of lines per page */ ! 684: lLinesPerPage = (rclPrintArea.yTop - rclPrintArea.yBottom) / ! 685: (fm.lMaxBaselineExt + fm.lExternalLeading); ! 686: ! 687: GpiAssociate(hpsPrinter, NULL); ! 688: GpiDestroyPS(hpsPrinter); ! 689: DevCloseDC(hdcPrinter); ! 690: ! 691: return(SHORT)(lLines / lLinesPerPage) + 1; ! 692: ! 693: } /* QueryMaxPages() */ ! 694: ! 695: ! 696: /****************************************************************\ ! 697: * Performs the actual printing of a document ! 698: *-------------------------------------------------------------- ! 699: * ! 700: * Name: PrintDoc(hdc) ! 701: * ! 702: * Purpose: Performs the printing of a file ! 703: * ! 704: * Usage: called by Print() to actually print the file ! 705: * ! 706: * Method: This routine prints each line of the MLE. If a ! 707: * line is longer than the page width, then the line ! 708: * is clipped to the margin; it is not wrapped to ! 709: * the next line. ! 710: * ! 711: * Note: this routine should NOT close the printer DC ! 712: * ! 713: * Returns: TRUE if successfull, FALSE if not ! 714: * ! 715: \****************************************************************/ ! 716: BOOL PrintDoc(hdc) ! 717: HDC hdc; /* hdc of the printer */ ! 718: { ! 719: USHORT usSpoolId, usNumCopies; ! 720: LONG lOutData, lOffset = 0L, lFileEnd, lLine, lT, lPageLines; ! 721: LONG lLinesPerPage, lLineHeight, lStartOffset, lTotalLines; ! 722: RECTL rclPrintArea, rclText; ! 723: HPS hpsPrinter; ! 724: SIZEL szl; ! 725: PVOID pvBuf; ! 726: FONTMETRICS fm; ! 727: POINTL ptl; ! 728: BOOL fRet = TRUE; ! 729: ! 730: /*--------------------------------------------------------------*\ ! 731: * Creates a PS for the DC. Note that you can associate an ! 732: * existing HPS to the DC here instead if you are using ! 733: * retained graphics in the HPS. The PS must use PU_LOENGLISH ! 734: * page units since the CalcPrintArea() routine expects the ! 735: * the PS to use them. ! 736: \*--------------------------------------------------------------*/ ! 737: szl.cx = szl.cy = 0L; ! 738: hpsPrinter = GpiCreatePS(hab, ! 739: hdc, ! 740: &szl, ! 741: PU_LOENGLISH | GPIT_NORMAL | GPIF_DEFAULT | GPIA_ASSOC); ! 742: if(!hpsPrinter) ! 743: return FALSE; ! 744: ! 745: if(!CalcPrintArea(hpsPrinter, &rclPrintArea, &fm)) { ! 746: fRet = FALSE; ! 747: goto PrintDocExit; ! 748: } ! 749: ! 750: /*--------------------------------------------------------------*\ ! 751: * Note: CalcPrintArea() has created the printer font on ! 752: * hpsPrinter and selected the font. It has also returned ! 753: * the metrics for the font in fm. rclPrintArea is the ! 754: * rectangle bounding the print area of the page, excluding ! 755: * the header and footer. ! 756: \*--------------------------------------------------------------*/ ! 757: ! 758: /*--------------------------------------------------------------*\ ! 759: * rclText is set to the rectangle that will encompass one ! 760: * line of output. Its left and right sides are set to the ! 761: * margins of the paper, namely the left and right sides of ! 762: * the print area as represented by rclPrintArea. Its top ! 763: * will be repositioned for each line of output and its ! 764: * bottom will always be set to one line's height below the ! 765: * top. All text output will be clipped to this rectangle. ! 766: \*--------------------------------------------------------------*/ ! 767: ! 768: /* set rectangle for each text line to have its left and right sides ! 769: equal to the left and right margin of the print area */ ! 770: rclText.xLeft = rclPrintArea.xLeft; ! 771: rclText.xRight = rclPrintArea.xRight; ! 772: ! 773: /* calculate the height of each printed line, including any space ! 774: (leading) between the lines */ ! 775: lLineHeight = fm.lMaxBaselineExt + fm.lExternalLeading; ! 776: ! 777: /* calculate the number of lines that fit on a page */ ! 778: lLinesPerPage = (rclPrintArea.yTop - rclPrintArea.yBottom) / ! 779: lLineHeight; ! 780: ! 781: /* If our page size is too small to print even one line, then ! 782: abort the print job */ ! 783: if(lLinesPerPage < 0L) { ! 784: MessageBox(hwndMLE, IDMSG_PRINTAREATOOSMALL, MB_OK | MB_ERROR, FALSE); ! 785: goto PrintDocExit; ! 786: } ! 787: ! 788: ! 789: /* get the length of the output file */ ! 790: lFileEnd = (LONG)WinSendMsg(hwndMLE, MLM_QUERYTEXTLENGTH, NULL, NULL); ! 791: ! 792: /* create a buffer to hold the file */ ! 793: DosAllocMem((PPVOID) &pvBuf, lFileEnd, fALLOC); ! 794: ! 795: /* set up the buffer for the MLE text */ ! 796: WinSendMsg(hwndMLE, ! 797: MLM_SETIMPORTEXPORT, ! 798: MPFROMP(pvBuf), ! 799: MPFROMLONG(lFileEnd)); ! 800: ! 801: ! 802: /* if printing all pages, set file offset to beginning of file *\ ! 803: * and set the last line to the end of the file. If printing ! 804: * only certain pages, calculate the beginning and ending line ! 805: \* based on the pages */ ! 806: ! 807: if(prtd.flFlags & PRTF_ALLPAGES) { ! 808: lStartOffset = 0L; ! 809: lTotalLines = (LONG)WinSendMsg(hwndMLE, ! 810: MLM_QUERYLINECOUNT, ! 811: NULL, ! 812: NULL); ! 813: } else { ! 814: /* set lStartOffset to the beginning of the first line of the ! 815: first page set to print */ ! 816: lT = (LONG)(prtd.iFrom - 1L) * lLinesPerPage; ! 817: ! 818: if(lT < 0L); /* lT should never be less than 0, so this is */ ! 819: lT = 0L; /* purely defensive programming */ ! 820: ! 821: /* lT is the number of lines in all pages from the beginning ! 822: of the document to the first page printed */ ! 823: ! 824: lStartOffset = (LONG)WinSendMsg(hwndMLE, ! 825: MLM_CHARFROMLINE, ! 826: MPFROMLONG(lT), ! 827: NULL); ! 828: ! 829: /* set lTotalLines to the number of lines in the pages between the ! 830: starting and ending */ ! 831: lTotalLines = (LONG)(prtd.iTo - prtd.iFrom + 1) * lLinesPerPage; ! 832: lFileEnd = (LONG)WinSendMsg(hwndMLE, ! 833: MLM_QUERYLINECOUNT, ! 834: NULL, ! 835: NULL); ! 836: ! 837: /* if last line is beyond end of file, set the last line to ! 838: be the end of file */ ! 839: if(lTotalLines + lT > lFileEnd) ! 840: lTotalLines = lFileEnd - lT; ! 841: } ! 842: ! 843: ! 844: ! 845: /* print one document for each number of copies */ ! 846: usNumCopies = (USHORT)prtd.cCopies; ! 847: while(usNumCopies--) { ! 848: ! 849: /* set file offset variable to the beginning of the lines ! 850: being printed; set line variable to the number of lines ! 851: to be printed */ ! 852: lLine = lTotalLines; ! 853: lOffset = lStartOffset; ! 854: ! 855: /* send a DEVESC_STARTDOC to start the printing */ ! 856: if(DevEscape(hdc, ! 857: DEVESC_STARTDOC, ! 858: (LONG)MAXNAMEL, ! 859: (PBYTE)szAppName, ! 860: (PLONG)NULL, ! 861: (PBYTE)NULL) != DEV_OK) { ! 862: ! 863: MessageBox(hwndMain, ! 864: IDMSG_CANNOTOPENPRINTER, ! 865: MB_OK | MB_ERROR, ! 866: FALSE); ! 867: ! 868: fRet = FALSE; ! 869: goto PrintDocExit; ! 870: } ! 871: ! 872: while(lLine) { ! 873: ! 874: /* if we have header text, print the header at the top of the page */ ! 875: if(pgsd.pszHeader[0]) { ! 876: ! 877: /* set text rectangle to two lines above print area since ! 878: we reserved two lines for it in CalcPrintArea() */ ! 879: ! 880: rclText.yTop = rclPrintArea.yTop + (lLineHeight * 2L); ! 881: rclText.yBottom = rclText.yTop - fm.lMaxBaselineExt; ! 882: ! 883: ptl.x = rclText.xLeft; ! 884: ptl.y = rclText.yTop - fm.lMaxAscender; ! 885: ! 886: GpiMove(hpsPrinter, &ptl); ! 887: ! 888: GpiCharStringPos(hpsPrinter, ! 889: &rclText, ! 890: CHS_CLIP, ! 891: pgsd.cchHeader, ! 892: pgsd.pszHeader, ! 893: NULL); ! 894: ! 895: } ! 896: ! 897: /*==============================================================*\ ! 898: * Now print each line of text in the print area ! 899: \*==============================================================*/ ! 900: ! 901: /*--------------------------------------------------------------*\ ! 902: * The top of rclText is set here to the top of the print ! 903: * area while the bottom is set to the height of one line ! 904: * below the top. The measurement used to position the ! 905: * bottom is not the lLineHeight variable, but rather the ! 906: * actual height of the characters in the font as given by ! 907: * the lMaxBaselineExt field of the fontmetrics structure. ! 908: * Thus, rclText will be the height of the characters in the ! 909: * line and will not include any external leading. ! 910: \*--------------------------------------------------------------*/ ! 911: rclText.yTop = rclPrintArea.yTop; ! 912: rclText.yBottom = rclText.yTop - fm.lMaxBaselineExt; ! 913: ! 914: /*--------------------------------------------------------------*\ ! 915: * ptl will be the beginning point of the text string. The ! 916: * x coordinate of the point will always be on the left side ! 917: * of the print line, as given the rclText.xLeft. The y ! 918: * coordinate is set to the baseline of the font. The ! 919: * baseline is the line at the bottom of all characters, ! 920: * excluding any descenders. The baseline is determined by ! 921: * taking the top of the text line and subtracting the height ! 922: * of the ascender of the font. Thus: ! 923: * ! 924: * **** === === ! 925: * * * | | ! 926: * * * | ascender | ! 927: * * * | | MaxBaselineExt ! 928: * baseline --- *****------=== | ! 929: * * | | ! 930: * * * | descender | ! 931: * **** === === ! 932: * ! 933: * ptl.y is set to the baseline coordinate by subracting the ! 934: * Ascender of the font (fm.lMaxAscender) from the top of ! 935: * the text rectangle (rclText.yTop). ! 936: * ! 937: \*--------------------------------------------------------------*/ ! 938: ! 939: ptl.x = rclText.xLeft; ! 940: ptl.y = rclText.yTop - fm.lMaxAscender; ! 941: ! 942: /* set lPageLines to the number of lines on the page. If ! 943: there are fewer lines left in the document, then set ! 944: it to the number of lines left */ ! 945: lPageLines = min(lLinesPerPage, lLine); ! 946: ! 947: while(lPageLines--) { ! 948: ptl.y = rclText.yTop - fm.lMaxAscender; /* re-set baseline */ ! 949: ! 950: /* get current line from MLE */ ! 951: lT = WinSendMsg(hwndMLE, ! 952: MLM_QUERYFORMATLINELENGTH, ! 953: MPFROMLONG(lOffset), ! 954: NULL); ! 955: /* lT is the length of the current line, including the ! 956: CR/LF pair at the end */ ! 957: ! 958: lOutData = lT - 2L; /* length of line minus CR/LF pair */ ! 959: ! 960: /* get the text from the MLE */ ! 961: WinSendMsg(hwndMLE, ! 962: MLM_EXPORT, ! 963: MPFROMP(&lOffset), ! 964: MPFROMP(&lT)); ! 965: ! 966: /* print the string */ ! 967: if(GpiMove(hpsPrinter, &ptl) == GPI_ERROR) { ! 968: fRet = FALSE; ! 969: goto PrintDocExit; ! 970: } ! 971: ! 972: ! 973: if(GpiCharStringPos(hpsPrinter, ! 974: &rclText, ! 975: CHS_CLIP, ! 976: lOutData, ! 977: pvBuf, ! 978: NULL) == GPI_ERROR) { ! 979: fRet = FALSE; ! 980: goto PrintDocExit; ! 981: } ! 982: ! 983: /* subtract one from the lines remaining */ ! 984: lLine--; ! 985: ! 986: /* move offset pointer to the beginning of next line */ ! 987: lOffset += lT; ! 988: ! 989: /* set the top of the text rectangle to the top of the ! 990: next line. Set the bottom to a character's height ! 991: below the top */ ! 992: rclText.yTop = rclText.yBottom - fm.lExternalLeading; ! 993: rclText.yBottom = rclText.yTop - fm.lMaxBaselineExt; ! 994: ! 995: } /* while(lPageLines) */ ! 996: ! 997: ! 998: /* add footer if necessary */ ! 999: if(pgsd.pszFooter[0]) { ! 1000: ! 1001: /* set text rectangle to two lines below print area since ! 1002: we reserved two lines for it in CalcPrintArea(). Refer ! 1003: to the CalcPrintArea() function for an explanation of ! 1004: the height of the footer */ ! 1005: ! 1006: rclText.yBottom = rclPrintArea.yBottom - ! 1007: ((fm.lMaxBaselineExt * 2L) + ! 1008: fm.lExternalLeading); ! 1009: ! 1010: rclText.yTop = rclText.yBottom + fm.lMaxBaselineExt; ! 1011: ! 1012: /* set ptl to baseline */ ! 1013: ptl.y = rclText.yTop - fm.lMaxAscender; ! 1014: ! 1015: /* print the footer text */ ! 1016: if(GpiMove(hpsPrinter, &ptl) == GPI_ERROR) { ! 1017: fRet = FALSE; ! 1018: goto PrintDocExit; ! 1019: } ! 1020: ! 1021: if(GpiCharStringPos(hpsPrinter, ! 1022: &rclText, ! 1023: CHS_CLIP, ! 1024: pgsd.cchFooter, ! 1025: pgsd.pszFooter, ! 1026: NULL) == GPI_ERROR) { ! 1027: fRet = FALSE; ! 1028: goto PrintDocExit; ! 1029: } ! 1030: ! 1031: } ! 1032: ! 1033: /* send a DEVESC_NEWFRAME to end this page */ ! 1034: if(DevEscape(hdc, ! 1035: DEVESC_NEWFRAME, ! 1036: 0L, ! 1037: (PBYTE)NULL, ! 1038: (PLONG)NULL, ! 1039: (PBYTE)NULL) != DEV_OK) { ! 1040: ! 1041: fRet = FALSE; ! 1042: goto PrintDocExit; ! 1043: } ! 1044: ! 1045: } /* while(lLine) */ ! 1046: ! 1047: ! 1048: ! 1049: /* send a DEVESC_ENDDOC to end the printing */ ! 1050: if(DevEscape(hdc, ! 1051: DEVESC_ENDDOC, ! 1052: 0L, ! 1053: (PBYTE)NULL, ! 1054: (PLONG)&lOutData, ! 1055: (PBYTE)&usSpoolId) != DEV_OK) { ! 1056: ! 1057: fRet = FALSE; ! 1058: goto PrintDocExit; ! 1059: } ! 1060: ! 1061: } /* while(usNumCopies) */ ! 1062: ! 1063: PrintDocExit: ! 1064: ! 1065: /* free the text buffer and destroy the PS */ ! 1066: GpiFreeMem((PVOID)pvBuf); ! 1067: ! 1068: GpiAssociate(hpsPrinter, NULL); ! 1069: GpiDestroyPS(hpsPrinter); ! 1070: ! 1071: return fRet; ! 1072: ! 1073: } /* PrintDoc() */ ! 1074: ! 1075: ! 1076: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.