![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tprint.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff|
Return to tprint.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /****************************** Module Header *******************************
13: * Module Name: TPRINT.C
14: *
15: * Print functions.
16: *
17: * Functions:
18: *
19: * gtab_print()
20: * gtab_printsetup()
21: * gtab_prtwidths()
22: * gtab_printjob()
23: * AbortProc()
24: * AbortDlg()
25: * gtab_printpage()
26: * gtab_setrects()
27: * gtab_printhead()
28: *
29: * Comments:
30: *
31: * See table.h for interface description.
32: *
33: ****************************************************************************/
34:
35: #include <string.h>
36: #include <windows.h>
37: #include <commdlg.h>
38:
39: #include "gutils.h"
40: #include "gutilsrc.h"
41: #include "table.h"
42: #include "tpriv.h"
43:
44: /* in tpaint.c, calls GetTextExtentPoint */
45: extern int GetTextExtent(HDC, LPSTR, int);
46:
47: extern HANDLE hLibInst;
48:
49: /* function prototypes */
50: lpTable gtab_printsetup(HWND hwnd, lpTable ptab, HANDLE heap,
51: lpPrintContext pcontext);
52: BOOL gtab_prtwidths(HWND hwnd, lpTable ptab, HANDLE heap, lpPrintContext
53: pcontext);
54: void gtab_printjob(HWND hwnd, lpTable ptab, lpPrintContext pcontext);
55: int APIENTRY AbortProc(HDC hpr, int code);
56: int APIENTRY AbortDlg(HWND hdlg, UINT msg, UINT wParam, LONG lParam);
57: BOOL gtab_printpage(HWND hwnd, lpTable ptab, lpPrintContext pcontext, int page);
58: void gtab_setrects(lpPrintContext pcontext, LPRECT rcinner, LPRECT rcouter);
59: void gtab_printhead(HWND hwnd, HDC hdc, lpTable ptab, lpTitle head, int page);
60:
61:
62: /***************************************************************************
63: * Function: gtab_print
64: *
65: * Purpose:
66: *
67: * Prints a table.
68: */
69: void
70: gtab_print(HWND hwnd, lpTable ptab, HANDLE heap, lpPrintContext pcontext)
71: {
72: BOOL fNoContext, fNoMargin, fNoPD;
73: lpTable ptab_prt;
74:
75: fNoContext = FALSE;
76: fNoPD = FALSE;
77: fNoMargin = FALSE;
78:
79: if (pcontext == NULL) {
80: fNoContext = TRUE;
81: pcontext = (lpPrintContext) gmem_get(heap,
82: sizeof(PrintContext));
83: pcontext->head = pcontext->foot = NULL;
84: pcontext->margin = NULL;
85: pcontext->pd = NULL;
86: pcontext->id = 0;
87: }
88: if (pcontext->pd == NULL) {
89: fNoPD = TRUE;
90: }
91: if (pcontext->margin == NULL) {
92: fNoMargin = TRUE;
93: }
94: ptab_prt = gtab_printsetup(hwnd, ptab, heap, pcontext);
95:
96: if (ptab_prt != NULL) {
97: gtab_printjob(hwnd, ptab_prt, pcontext);
98:
99: gtab_deltable(hwnd, ptab_prt);
100: }
101: if (fNoMargin) {
102: gmem_free(heap, (LPSTR)pcontext->margin,
103: sizeof(Margin));
104: pcontext->margin = NULL;
105: }
106: if (fNoPD) {
107: if (pcontext->pd->hDevMode != NULL) {
108: GlobalFree(pcontext->pd->hDevMode);
109: }
110: if (pcontext->pd->hDevNames != NULL) {
111: GlobalFree(pcontext->pd->hDevNames);
112: }
113: gmem_free(heap, (LPSTR) pcontext->pd, sizeof(PRINTDLG));
114: pcontext->pd = NULL;
115: }
116: if (fNoContext) {
117: gmem_free(heap, (LPSTR) pcontext, sizeof(PrintContext));
118: }
119: }
120:
121:
122:
123: /***************************************************************************
124: * Function: gtab_printsetup
125: *
126: * Purpose:
127: *
128: * Sets up printercontext - builds lpTable for printer, incl. sizing
129: * and initialises pcontext fields that may be null.
130: */
131: lpTable
132: gtab_printsetup(HWND hwnd, lpTable ptab, HANDLE heap, lpPrintContext pcontext)
133: {
134: lpTable pprttab;
135: PRINTDLG FAR * pd;
136: int ncols, i;
137: ColPropsList cplist;
138:
139: /* set fields for context that user left null */
140: if (pcontext->margin == NULL) {
141: pcontext->margin = (lpMargin) gmem_get(heap, sizeof(Margin));
142: if (pcontext->margin == NULL) {
143: return(NULL);
144: }
145: pcontext->margin->left = 10;
146: pcontext->margin->right = 10;
147: pcontext->margin->top = 15;
148: pcontext->margin->bottom = 15;
149: pcontext->margin->topinner = 15;
150: pcontext->margin->bottominner = 15;
151: }
152:
153: if (pcontext->pd == NULL) {
154: pd = (PRINTDLG FAR *) gmem_get(heap, sizeof(PRINTDLG));
155: if (pd == NULL) {
156: return(NULL);
157: }
158: pcontext->pd = pd;
159:
160: pd->lStructSize = sizeof(PRINTDLG);
161: pd->hwndOwner = hwnd;
162: pd->hDevMode = (HANDLE) NULL;
163: pd->hDevNames = (HANDLE) NULL;
164: pd->Flags = PD_RETURNDC|PD_RETURNDEFAULT;
165:
166: if (PrintDlg(pd) == FALSE) {
167: return(NULL);
168: }
169: }
170:
171: /* now create a Table struct by querying the owner */
172: pprttab = (lpTable) gmem_get(heap, sizeof(Table));
173:
174: if (pprttab == NULL) {
175: return(NULL);
176: }
177: pprttab->hdr = ptab->hdr;
178:
179: /* get the row/column count from owner window */
180: if (pcontext->id == 0) {
181: pprttab->hdr.id = ptab->hdr.id;
182: } else {
183: pprttab->hdr.id = pcontext->id;
184: }
185: pprttab->hdr.props.valid = 0;
186: pprttab->hdr.sendscroll = FALSE;
187: if (gtab_sendtq(hwnd, TQ_GETSIZE, (long) (LPSTR)&pprttab->hdr) == FALSE) {
188: return(NULL);
189: }
190:
191: /* alloc and init the col data structs */
192: ncols = pprttab->hdr.ncols;
193: pprttab->pcolhdr = (lpColProps) gmem_get(heap, sizeof(ColProps) * ncols);
194: if (pprttab->pcolhdr == NULL) {
195: gmem_free(heap, (LPSTR)pprttab, sizeof(Table));
196: return(NULL);
197: }
198:
199: /* init col properties to default */
200: for (i=0; i < ncols; i++) {
201: pprttab->pcolhdr[i].props.valid = 0;
202: pprttab->pcolhdr[i].nchars = 0;
203: }
204: /* get the column props from owner */
205: cplist.plist = pprttab->pcolhdr;
206: cplist.id = pprttab->hdr.id;
207: cplist.startcol = 0;
208: cplist.ncols = ncols;
209: gtab_sendtq(hwnd, TQ_GETCOLPROPS, (long) (LPSTR)&cplist);
210:
211:
212: pprttab->scrollscale = 1;
213: pprttab->pcellpos = (lpCellPos) gmem_get(heap,
214: sizeof(CellPos) * ptab->hdr.ncols);
215: if (pprttab->pcellpos == NULL) {
216: gmem_free(heap, (LPSTR) pprttab->pcolhdr, sizeof(ColProps) * ncols);
217: gmem_free(heap, (LPSTR)pprttab, sizeof(Table));
218: return(NULL);
219: }
220:
221:
222: pprttab->pdata = NULL;
223: pprttab->nlines = 0;
224:
225: if (!gtab_prtwidths(hwnd, pprttab, heap, pcontext)) {
226: gmem_free(heap, (LPSTR)pprttab->pcellpos,
227: sizeof(CellPos) * ptab->hdr.ncols);
228: gmem_free(heap, (LPSTR)pprttab, sizeof(Table));
229: return(NULL);
230: }
231: return(pprttab);
232: }
233:
234:
235: /***************************************************************************
236: * Function: gtab_prtwidths
237: *
238: * Purpose:
239: *
240: * Calc the height/width settings and alloc line data
241: */
242: BOOL
243: gtab_prtwidths(HWND hwnd, lpTable ptab, HANDLE heap, lpPrintContext pcontext)
244: {
245: TEXTMETRIC tm;
246: int cx, cxtotal, i, curx, cury;
247: lpProps hdrprops, cellprops;
248: lpCellPos xpos, ypos;
249: RECT rcinner, rcouter;
250:
251: hdrprops = &ptab->hdr.props;
252: GetTextMetrics(pcontext->pd->hDC, &tm);
253: ptab->avewidth = tm.tmAveCharWidth;
254: ptab->rowheight = tm.tmHeight + tm.tmExternalLeading;
255: if (hdrprops->valid & P_HEIGHT) {
256: ptab->rowheight = hdrprops->height;
257: }
258:
259: /* set sizes for headers */
260: gtab_setrects(pcontext, &rcinner, &rcouter);
261:
262: /* set width/pos for each col. */
263: cxtotal = 0;
264: curx = rcinner.left;
265: for (i = 0; i < ptab->hdr.ncols; i++) {
266: cellprops = &ptab->pcolhdr[i].props;
267: xpos = &ptab->pcellpos[i];
268:
269: if (cellprops->valid & P_WIDTH) {
270: cx = cellprops->width;
271: } else if (hdrprops->valid & P_WIDTH) {
272: cx = hdrprops->width;
273: } else {
274: cx = ptab->pcolhdr[i].nchars + 1;
275: cx *= ptab->avewidth;
276: }
277: /* add 2 for intercol spacing */
278: cx += 2;
279:
280: xpos->size = cx;
281: xpos->start = curx + 1;
282: xpos->clipstart = xpos->start;
283: xpos->clipend = xpos->start + xpos->size - 2;
284: xpos->clipend = min(xpos->clipend, rcinner.right);
285:
286: cxtotal += xpos->size;
287: curx += xpos->size;
288: }
289: ptab->rowwidth = cxtotal;
290:
291: if(pcontext->head != NULL) {
292: xpos = &pcontext->head->xpos;
293: ypos = &pcontext->head->ypos;
294:
295: xpos->start = rcouter.left + 1;
296: xpos->clipstart = rcouter.left + 1;
297: xpos->clipend = rcouter.right - 1;
298: xpos->size = rcouter.right - rcouter.left;
299:
300: ypos->start = rcouter.top;
301: ypos->clipstart = rcouter.top;
302: ypos->clipend = rcinner.top;
303: ypos->size = ptab->rowheight;
304: }
305:
306: if (pcontext->foot != NULL) {
307: xpos = &pcontext->foot->xpos;
308: ypos = &pcontext->foot->ypos;
309:
310: xpos->start = rcouter.left + 1;
311: xpos->clipstart = rcouter.left + 1;
312: xpos->clipend = rcouter.right - 1;
313: xpos->size = rcouter.right - rcouter.left;
314:
315: ypos->start = rcouter.bottom - ptab->rowheight;
316: ypos->clipstart = rcinner.bottom;
317: ypos->clipend = rcouter.bottom;
318: ypos->size = ptab->rowheight;
319: }
320:
321: /* set nr of lines per page */
322: ptab->nlines = (rcinner.bottom - rcinner.top) / ptab->rowheight;
323: if (!gtab_alloclinedata(hwnd, heap, ptab)) {
324: return(FALSE);
325: }
326: /* set line positions */
327: cury = rcinner.top;
328: for (i = 0; i < ptab->nlines; i++) {
329: ypos = &ptab->pdata[i].linepos;
330: ypos->start = cury;
331: ypos->clipstart = ypos->start;
332: ypos->clipend = ypos->start + ypos->size;
333: ypos->clipend = min(ypos->clipend, rcinner.bottom);
334: cury += ypos->size;
335: }
336: return(TRUE);
337: }
338:
339:
340: /* static information for this module */
341: BOOL bAbort;
342: FARPROC lpAbortProc;
343: DLGPROC lpAbortDlg;
344: HWND hAbortWnd;
345: int npage;
346: int pages;
347:
348: /***************************************************************************
349: * Function: gtab_printjob
350: *
351: * Purpose:
352: *
353: * Sets up print job and dialogs
354: */
355: void
356: gtab_printjob(HWND hwnd, lpTable ptab, lpPrintContext pcontext)
357: {
358: int moveables;
359: int endpage;
360: int startpage = 1;
361: HDC hpr;
362: int status;
363: HANDLE hcurs;
364: static char str[256];
365: DOCINFO di;
366:
367: hcurs = SetCursor(LoadCursor(NULL, IDC_WAIT));
368:
369: moveables = ptab->nlines - ptab->hdr.fixedrows;
370: pages = (int) (ptab->hdr.nrows - ptab->hdr.fixedrows + moveables - 1)
371: / moveables;
372: endpage = pages;
373:
374: if (pcontext->pd->Flags & PD_PAGENUMS) {
375: startpage = pcontext->pd->nFromPage;
376: endpage = pcontext->pd->nToPage;
377: }
378: hpr = pcontext->pd->hDC;
379:
380: lpAbortDlg = (DLGPROC) MakeProcInstance((WNDPROC) AbortDlg, hLibInst);
381: lpAbortProc = (FARPROC) MakeProcInstance((WNDPROC)AbortProc, hLibInst);
382:
383: SetAbortProc(hpr, (ABORTPROC) lpAbortProc);
384:
385: di.lpszDocName = "Table";
386: di.cbSize = lstrlen(di.lpszDocName);
387: di.lpszOutput = NULL;
388:
389: StartDoc(hpr, &di);
390:
391: bAbort = FALSE;
392:
393: /* add abort modeless dialog later!! */
394: hAbortWnd = CreateDialog(hLibInst, "GABRTDLG", hwnd, lpAbortDlg);
395: if (hAbortWnd != NULL) {
396: ShowWindow(hAbortWnd, SW_NORMAL);
397: EnableWindow(hwnd, FALSE);
398: }
399: SetCursor(hcurs);
400:
401:
402: for (npage = startpage; npage<=endpage; npage++) {
403: wsprintf(str, "Page %d of %d pages", npage, pages);
404: SetDlgItemText(hAbortWnd, IDC_LPAGENR, str);
405: status = gtab_printpage(hwnd, ptab, pcontext, npage);
406: if (status < 0) {
407: AbortDoc(hpr);
408: break;
409: }
410: }
411: if (status >= 0) {
412: EndDoc(hpr);
413: }
414:
415: if (hAbortWnd != NULL) {
416: EnableWindow(hwnd, TRUE);
417: DestroyWindow(hAbortWnd);
418: }
419: FreeProcInstance((WNDPROC) lpAbortDlg);
420: FreeProcInstance(lpAbortProc);
421:
422: DeleteDC(hpr);
423: }
424:
425: /***************************************************************************
426: * Function: AbortProc
427: *
428: * Purpose:
429: *
430: * Abort procedure for print job
431: */
432: int APIENTRY
433: AbortProc(HDC hpr, int code)
434: {
435:
436: MSG msg;
437:
438: if (!hAbortWnd) {
439: return(TRUE);
440: }
441: while (!bAbort && PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
442: if (!IsDialogMessage(hAbortWnd, &msg)) {
443: TranslateMessage(&msg);
444: DispatchMessage(&msg);
445: }
446: }
447: return(!bAbort);
448: }
449:
450: /***************************************************************************
451: * Function: AbortDlg
452: *
453: * Purpose:
454: *
455: * Dialog for abort procedure
456: */
457: int APIENTRY
458: AbortDlg(HWND hdlg, UINT msg, UINT wParam, LONG lParam)
459: {
460: switch(msg) {
461:
462: case WM_COMMAND:
463: bAbort = TRUE;
464: EndDialog(hdlg, TRUE);
465: return TRUE;
466:
467: case WM_INITDIALOG:
468: return TRUE;
469: }
470: return(FALSE);
471: }
472:
473: /***************************************************************************
474: * Function: gtab_printpage
475: *
476: * Purpose:
477: *
478: * Print a single page. page number is 1-based
479: */
480: BOOL
481: gtab_printpage(HWND hwnd, lpTable ptab, lpPrintContext pcontext, int page)
482: {
483: HDC hpr;
484: int moveables, i;
485: int x1, y1, x2, y2;
486:
487: hpr = pcontext->pd->hDC;
488: StartPage(hpr);
489:
490: moveables = ptab->nlines - ptab->hdr.fixedrows;
491: ptab->toprow = moveables * (page-1);
492: gtab_invallines(hwnd, ptab, ptab->hdr.fixedrows, moveables);
493:
494: for (i =0; i < ptab->nlines; i++) {
495: gtab_paint(hwnd, hpr, ptab, i);
496: }
497: if ((ptab->hdr.vseparator) && (ptab->hdr.fixedcols > 0)) {
498: x1 = ptab->pcellpos[ptab->hdr.fixedcols -1].clipend+1;
499: y1 = ptab->pdata[0].linepos.clipstart;
500: y2 = ptab->pdata[ptab->nlines-1].linepos.clipend;
501: MoveToEx(hpr, x1, y1, NULL);
502: LineTo(hpr, x1, y2);
503: }
504: if ((ptab->hdr.hseparator) && (ptab->hdr.fixedrows > 0)) {
505: y1 = ptab->pdata[ptab->hdr.fixedrows-1].linepos.clipend;
506: x1 = ptab->pcellpos[0].clipstart;
507: x2 = ptab->pcellpos[ptab->hdr.ncols-1].clipend;
508: MoveToEx(hpr, x1, y1, NULL);
509: LineTo(hpr, x2, y1);
510: }
511:
512: if (pcontext->head != NULL) {
513: gtab_printhead(hwnd, hpr, ptab, pcontext->head, page);
514: }
515: if (pcontext->foot != NULL) {
516: gtab_printhead(hwnd, hpr, ptab, pcontext->foot, page);
517: }
518:
519: return(EndPage(hpr));
520: }
521:
522:
523: /***************************************************************************
524: * Function: gtab_setrects
525: *
526: * Purpose:
527: *
528: * Calculate the outline positions in pixels for the headers
529: * (outer rect) and for the page itself (inner rect). Based on
530: * page size and PrintContext margin info (which is in millimetres).
531: */
532: void
533: gtab_setrects(lpPrintContext pcontext, LPRECT rcinner, LPRECT rcouter)
534: {
535: HDC hpr;
536: int hpixels, hmms;
537: int vpixels, vmms;
538: int h_pixpermm, v_pixpermm;
539:
540: hpr = pcontext->pd->hDC;
541: hpixels = GetDeviceCaps(hpr, HORZRES);
542: vpixels = GetDeviceCaps(hpr, VERTRES);
543: vmms = GetDeviceCaps(hpr, VERTSIZE);
544: hmms = GetDeviceCaps(hpr, HORZSIZE);
545:
546: h_pixpermm = hpixels / hmms;
547: v_pixpermm = vpixels / vmms;
548:
549: rcouter->top = (pcontext->margin->top * v_pixpermm);
550: rcouter->bottom = vpixels - (pcontext->margin->bottom * v_pixpermm);
551: rcouter->left = (pcontext->margin->left * h_pixpermm);
552: rcouter->right = hpixels - (pcontext->margin->right * h_pixpermm);
553:
554: rcinner->left = rcouter->left;
555: rcinner->right = rcouter->right;
556: rcinner->top = rcouter->top +
557: (pcontext->margin->topinner * v_pixpermm);
558: rcinner->bottom = rcouter->bottom -
559: (pcontext->margin->bottominner * v_pixpermm);
560: }
561:
562:
563: /***************************************************************************
564: * Function: gtab_printhead
565: *
566: * Purpose:
567: *
568: * Print header information
569: */
570: void
571: gtab_printhead(HWND hwnd, HDC hdc, lpTable ptab, lpTitle head, int page)
572: {
573: RECT rc, rcbox;
574: int i, cx, x, y, tab;
575: UINT align;
576: LPSTR chp, tabp;
577: DWORD fcol, bkcol;
578: char str[256];
579:
580: rc.top = head->ypos.clipstart;
581: rc.bottom = head->ypos.clipend;
582: rc.left = head->xpos.clipstart;
583: rc.right = head->xpos.clipend;
584:
585: /* update page number */
586: chp = str;
587: for (i = 0; i < lstrlen(head->ptext); i++) {
588: switch(head->ptext[i]) {
589:
590: case '#':
591: chp += wsprintf(chp, "%d", page);
592: break;
593:
594: case '$':
595: chp += wsprintf(chp, "%d", pages);
596: break;
597:
598: default:
599: *chp++ = head->ptext[i];
600: break;
601: }
602: }
603: *chp = '\0';
604: chp = str;
605:
606: if (head->props.valid & P_ALIGN) {
607: align = head->props.alignment;
608: } else {
609: align = P_LEFT;
610: }
611:
612: /* set colours if not default */
613: if (head->props.valid & P_FCOLOUR) {
614: fcol = SetTextColor(hdc, head->props.forecolour);
615: }
616: if (head->props.valid & P_BCOLOUR) {
617: bkcol = SetBkColor(hdc, head->props.backcolour);
618: }
619:
620: /* calc offset of text within cell for right-align or centering */
621: if (align == P_LEFT) {
622: cx = ptab->avewidth/2;
623: } else {
624: cx = LOWORD(GetTextExtent(hdc, chp, lstrlen(chp)));
625: if (align == P_CENTRE) {
626: cx = (head->xpos.size - cx) / 2;
627: } else {
628: cx = head->xpos.size - cx - (ptab->avewidth/2);
629: }
630: }
631: cx += head->xpos.start;
632:
633: /* expand tabs on output */
634: tab = ptab->avewidth * 8;
635: x = 0;
636: y = head->ypos.start;
637:
638: for ( ; (tabp = strchr(chp, '\t')) != NULL; ) {
639: /* perform output upto tab char */
640: ExtTextOut(hdc, x+cx, y, ETO_CLIPPED, &rc, chp, tabp-chp, NULL);
641:
642: /* advance past the tab */
643: x += LOWORD(GetTextExtent(hdc, chp, tabp - chp));
644: x = ( (x + tab) / tab) * tab;
645: chp = ++tabp;
646: }
647:
648: /*no more tabs - output rest of string */
649: ExtTextOut(hdc, x+cx, y, ETO_CLIPPED, &rc, chp, lstrlen(chp), NULL);
650:
651: /* reset colours to original if not default */
652: if (head->props.valid & P_FCOLOUR) {
653: SetTextColor(hdc, fcol);
654: }
655: if (head->props.valid & P_BCOLOUR) {
656: SetBkColor(hdc, bkcol);
657: }
658:
659: /* now box cell if marked */
660: if (head->props.valid & P_BOX) {
661: if (head->props.box != 0) {
662: rcbox.top = head->ypos.start;
663: rcbox.bottom = rcbox.top + head->ypos.size;
664: rcbox.left = head->xpos.start;
665: rcbox.right = rcbox.left + head->xpos.size;
666: gtab_boxcell(hwnd, hdc, &rcbox, &rc, head->props.box);
667: }
668: }
669: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.