![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lffile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / linefrac|
Return to lffile.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / linefrac |
1.1 root 1: /************************************************************************
2: *
3: * lffile.c -- File handling subroutines for LineFrac.
4: *
5: * Created by Microsoft Corporation, 1989
6: *
7: ************************************************************************/
8:
9: #define INCL_WIN
10: #define INCL_GPI
11: #define INCL_DOSMEMMGR
12: #define INCL_DOSFILEMGR
13: #define INCL_BITMAPFILEFORMAT
14: #include <os2.h>
15:
16: #include <stdio.h>
17:
18: #include "opendlg.h"
19:
20: #define INCL_GLOBALS
21: #define INCL_THREADS
22: #include "linefrac.h"
23:
24: #define INCL_LFFILE
25: #define INCL_LFPS
26: #define INCL_LFUTIL
27: #include "lffuncs.h"
28:
29:
30:
31:
32: /*
33: * this is the bitmap resource file format structure
34: */
35: typedef struct {
36: USHORT wType;
37: ULONG dwSize;
38: int xHotspot;
39: int yHotspot;
40: ULONG dwBitsOffset;
41: USHORT bmWidth; /* from here this is a BitmapInfo table */
42: USHORT bmHeight;
43: USHORT bmPlanes;
44: USHORT bmBitcount;
45: } RCBITMAP;
46: typedef RCBITMAP FAR *PRCBITMAP;
47:
48:
49:
50:
51: /************************************************************************
52: *
53: * Global Variables
54: *
55: ************************************************************************/
56:
57: extern GLOBALDATA global;
58:
59:
60:
61:
62: /************************************************************************
63: *
64: * LfReadFile
65: *
66: * Calls the OpenDlg function to ask the user what file name to
67: * read from.
68: *
69: ************************************************************************/
70:
71: VOID
72: LfReadFile(hwnd, pthr)
73: HWND hwnd;
74: PTHR pthr;
75: {
76: HFILE hFile;
77: DLF dlf;
78:
79: dlf.rgbAction = DLG_OPENDLG;
80: dlf.rgbFlags = ATTRDIRLIST;
81: dlf.phFile = &hFile;
82: dlf.pszExt = (PSZ)"\\*.bmp";
83: dlf.pszAppName = "LineFrac";
84: dlf.pszTitle = "Load Bitmap";
85: dlf.pszInstructions = NULL;
86: dlf.szFileName[0] = '\0';
87: dlf.szOpenFile[0] = '\0';
88:
89: switch (DlgFile(hwnd,&dlf))
90: {
91: case TDF_ERRMEM:
92: case TDF_INVALID:
93: MyMessageBox(hwnd, "Error reading file.");
94: break;
95:
96: case TDF_NOOPEN:
97: break;
98:
99: default:
100: if (!LfReadBMP(pthr, &dlf))
101: MyMessageBox(hwnd, "Error reading file.\nIs AutoResize enabled?");
102: }
103: }
104:
105:
106:
107:
108: /************************************************************************
109: *
110: * LfReadBMP
111: *
112: * Read a bitmap in from a BMP format file. Prepare the DC for the
113: * given thread to accept it. The user can have the DC resized to
114: * fit exactly the bitmap, or fit the bits in as best as we can.
115: * If we're not resizing and the bitmap is larger than the thread's
116: * DC, then load the bits flush with the lower left.
117: *
118: * Both old-style (PRCBITMAP) and new-style (PBITMAPFILEHEADER)
119: * bitmaps can be read.
120: *
121: * Free up memory and close the file before leaving. The file
122: * will have been opened by the time this function is called,
123: * and the file handle will be in the *pdlf structure.
124: *
125: ************************************************************************/
126:
127: BOOL
128: LfReadBMP(pthr, pdlf)
129: PTHR pthr;
130: PDLF pdlf; /* File information filled by DlgFile. */
131: {
132: HFILE hfile;
133: ULONG cScans;
134: ULONG ulSize; /* Number of bytes occupied by bitmap bits. */
135: USHORT cSegs; /* Number of 64K segments in ulSize. */
136: USHORT cbExtra; /* Bytes in last segment of ulSize. */
137: SEL sel; /* Base selector to file data. */
138: USHORT hugeshift; /* Segment index shift value. */
139: USHORT cbRead1; /* Number of bytes to read first call to DosRead */
140: USHORT cbRead2; /* Number of bytes to read second call to DosRead */
141: USHORT cbRead; /* Number of bytes read by DosRead. */
142: BOOL fRet = FALSE; /* Function return code. */
143: int i; /* Generic loop index. */
144: FILESTATUS fsts;
145: PBITMAPFILEHEADER pbfh;
146: PRCBITMAP rb;
147: PBYTE pImage;
148:
149:
150: /*******************************************************************
151: * Find out how big the file is so we can read the whole thing in.
152: *******************************************************************/
153:
154: hfile = *(pdlf->phFile);
155: if( DosQFileInfo( hfile, 1, &fsts, sizeof(FILESTATUS)) != 0)
156: goto lfread_error_close_file;
157:
158: ulSize = fsts.cbFile;
159: cSegs = (USHORT)(ulSize/0x10000L);
160: cbExtra = (USHORT)(ulSize%0x10000L);
161: if (DosAllocHuge(cSegs, cbExtra, (PSEL)&sel, 0, 0))
162: goto lfread_error_close_file;
163: if (DosGetHugeShift(&hugeshift))
164: goto lfread_error_free_bits;
165:
166: pImage = (PBYTE)MAKEP(sel, 0);
167: rb = (PRCBITMAP)pImage;
168: pbfh = (PBITMAPFILEHEADER)pImage;
169:
170:
171: /*******************************************************************
172: * Read the bits in from the file. The DosRead function allows a
173: * maximum of 64K-1 bytes read at a time. We get around this
174: * by reading two 32K chunks for each 64K segment, and reading the
175: * last segment in one piece.
176: *******************************************************************/
177:
178: for (i = 0; i <= cSegs; ++i)
179: {
180: if (i < cSegs)
181: {
182: /* This segment is 64K bytes long, so split it up. */
183: cbRead1 = 0x8000;
184: cbRead2 = 0x8000;
185: }
186: else
187: {
188: /* This segment is less than 64K bytes long, so read it all. */
189: cbRead1 = cbExtra;
190: cbRead2 = 0;
191: }
192:
193: /* There's a possibility that cbExtra will be 0, so check
194: * to avoid an unnecessary system call.
195: */
196: if (cbRead1 > 0)
197: {
198: if (DosRead( hfile
199: , (PVOID)MAKEP(sel+(i<<hugeshift), 0)
200: , cbRead1
201: , &cbRead))
202: goto lfread_error_free_bits;
203: if (cbRead1 != cbRead)
204: goto lfread_error_free_bits;
205: }
206:
207: /* This will always be skipped on the last partial segment. */
208: if (cbRead2 > 0)
209: {
210: if (DosRead( hfile
211: , (PVOID)MAKEP(sel+(i<<hugeshift), cbRead1)
212: , cbRead2
213: , &cbRead))
214: goto lfread_error_free_bits;
215: if (cbRead2 != cbRead)
216: goto lfread_error_free_bits;
217: }
218: }
219:
220:
221: /*******************************************************************
222: * At this point we have the bitmap completely in memory. Now we
223: * look at how the user wants them set into the thread's PS. If
224: * the thread has fAutoResizePS set, then make the PS fit the size
225: * of the bitmap (the easy case). If the flag is not set, then
226: * figure out how to place it.
227: *******************************************************************/
228:
229: if (pthr->fAutoSizePS)
230: {
231: if (pbfh->bmp.cbFix != sizeof(BITMAPINFOHEADER))
232: {
233: global.bm.cx = rb->bmWidth;
234: global.bm.cy = rb->bmHeight;
235: global.bm.cPlanes = rb->bmPlanes;
236: global.bm.cBitCount = rb->bmBitcount;
237: }
238: else
239: {
240: global.bm.cx = pbfh->bmp.cx;
241: global.bm.cy = pbfh->bmp.cy;
242: global.bm.cPlanes = pbfh->bmp.cPlanes;
243: global.bm.cBitCount = pbfh->bmp.cBitCount;
244: }
245:
246: LfResizePS(pthr);
247: }
248: else
249: goto lfread_error_free_bits;
250:
251:
252: /*******************************************************************
253: * Tell GPI to put the bits into the thread's PS. The function returns
254: * the number of scan lines of the bitmap that were copied. We want
255: * all of them at once.
256: *******************************************************************/
257:
258: if (pbfh->bmp.cbFix != sizeof(BITMAPINFOHEADER))
259: {
260: pImage += rb->dwBitsOffset;
261: rb->dwBitsOffset = sizeof(BITMAPINFOHEADER);
262: cScans = GpiSetBitmapBits( pthr->hps
263: , 0L
264: , (LONG)rb->bmHeight
265: , pImage
266: , (PBITMAPINFO)&(rb->dwBitsOffset));
267: if (cScans != (LONG)rb->bmHeight) /* compare with original number of scans */
268: goto lfread_error_free_bits;
269: }
270: else
271: {
272: cScans = GpiSetBitmapBits( pthr->hps
273: , 0L
274: , (LONG)pbfh->bmp.cy
275: , pImage + pbfh->offBits
276: , (PBITMAPINFO)&(pbfh->bmp));
277: if (cScans != (LONG)pbfh->bmp.cy) /* compare with original number of scans */
278: goto lfread_error_free_bits;
279: }
280: fRet = TRUE; /* We made it! The bits are in the thread's PS. */
281:
282:
283: /*******************************************************************
284: * Close the file, free the buffer space and leave. This is a
285: * common exit point from the function. Since the same cleanup
286: * operations need to be performed for such a large number of
287: * possible error conditions, this is a concise way to do the right
288: * thing.
289: *******************************************************************/
290:
291: lfread_error_free_bits:
292: DosFreeSeg(sel);
293: lfread_error_close_file:
294: DosClose(hfile);
295: return fRet;
296: }
297:
298:
299:
300:
301: /************************************************************************
302: *
303: * LfWriteFile
304: *
305: * Calls the OpenDlg function to ask the user what file name to
306: * save under.
307: *
308: ************************************************************************/
309:
310: VOID
311: LfWriteFile(hwnd, pthr)
312: HWND hwnd;
313: PTHR pthr;
314: {
315: HFILE hFile;
316: DLF dlf;
317: BITMAPINFOHEADER bmih;
318:
319:
320: SetUpDLF( &dlf
321: , DLG_SAVEDLG
322: , &hFile
323: , (PSZ)"\\*.BMP"
324: , (PSZ)"LineFrac"
325: , (PSZ)"Save Bitmap"
326: , NULL );
327: dlf.szFileName[0] = '\0';
328: dlf.szOpenFile[0] = '\0';
329:
330: switch (DlgFile(hwnd,&dlf))
331: {
332: case TDF_ERRMEM:
333: case TDF_INVALID:
334: MyMessageBox(hwnd, "Error opening file.");
335: break;
336:
337: case TDF_NOSAVE:
338: break;
339:
340: default:
341: bmih.cbFix = sizeof(BITMAPINFOHEADER);
342: bmih.cx = (USHORT) pthr->rcl.xRight;
343: bmih.cy = (USHORT) pthr->rcl.yTop;
344: bmih.cPlanes = pthr->cPlanes;
345: bmih.cBitCount = pthr->cBitCount;
346:
347: if (!LfWriteBMP(pthr->hps, &bmih, &dlf))
348: MyMessageBox(hwnd, "Error writing file.");
349: }
350: }
351:
352:
353:
354:
355: /************************************************************************
356: *
357: * LfWriteBMP
358: *
359: * Write the bitmap out to a BMP format file. Write the file
360: * header first, then the bitmap bits. Space for the header
361: * and the bits is allocated. Huge bitmaps are supported.
362: * Free up memory and close the file before leaving. The file
363: * will have been opened by the time this function is called,
364: * and the file handle will be in the *pdlf structure.
365: *
366: ************************************************************************/
367:
368: BOOL
369: LfWriteBMP(hPS, pbmih, pdlf)
370: HPS hPS; /* hPS from which to get bitmap bits. */
371: PBITMAPINFOHEADER pbmih;/* Bitmap information. */
372: PDLF pdlf; /* File information filled by DlgFile. */
373: {
374: HFILE hfile;
375: ULONG cScans;
376: ULONG ulSize; /* Number of bytes occupied by bitmap bits. */
377: USHORT cSegs; /* Number of 64K segments in ulSize. */
378: USHORT cbExtra; /* Bytes in last segment of ulSize. */
379: SEL selBits; /* Base selector to bitmap bits. */
380: USHORT hugeshift; /* Segment index shift value. */
381: USHORT cbBMHdr; /* Size of bitmap header. */
382: PBITMAPFILEHEADER pbfh; /* Pointer to private copy of bitmap info data. */
383: USHORT cbWrite1; /* Number of bytes to write first call to DosWrite */
384: USHORT cbWrite2; /* Number of bytes to write second call to DosWrite */
385: USHORT cbWritten; /* Number of bytes written by DosWrite. */
386: BOOL fRet = FALSE; /* Function return code. */
387: int i; /* Generic loop index. */
388: struct
389: {
390: LONG cPlanes;
391: LONG cBitCount;
392: } bmFmt;
393:
394:
395: hfile = *(pdlf->phFile);
396:
397: /*******************************************************************
398: * If the bitmap was created with either 0 planes or 0 bits per
399: * pixel, then query the format to write with. By asking for just
400: * one format (two LONGs, or one instance of structure of bmFmt),
401: * we'll get the device's favored format.
402: *******************************************************************/
403:
404: if ((pbmih->cPlanes == 0) || (pbmih->cBitCount))
405: {
406: if (!GpiQueryDeviceBitmapFormats(hPS, 2L, (PLONG)&bmFmt))
407: goto lfwrite_error_close_file;
408: }
409: else
410: {
411: bmFmt.cPlanes = pbmih->cPlanes;
412: bmFmt.cBitCount = pbmih->cBitCount;
413: }
414:
415:
416: /*******************************************************************
417: * Determine size of bitmap header. The header consists of a
418: * a fixed-size part and a variable-length color table. The
419: * latter has 2^cBitCount entries, each of which is sizeof(RGB)
420: * bytes long. The exception is when cBitCount is 24, in which
421: * case the color table is omitted because the pixels are direct
422: * rgb values.
423: *******************************************************************/
424:
425: i = (int) bmFmt.cBitCount;
426: if (i == 24)
427: cbBMHdr = 0;
428: else
429: for (cbBMHdr = sizeof(RGB); i > 0; --i)
430: cbBMHdr *= 2;
431: cbBMHdr += sizeof(BITMAPFILEHEADER);
432:
433:
434: /*******************************************************************
435: * Copy structure from input to work buffer. The call to
436: * GpiQueryBitmapBits will have write-access to this, so we won't
437: * let it have the user's data.
438: *******************************************************************/
439:
440: pbfh = 0;
441: if (DosAllocSeg(cbBMHdr, ((PUSHORT)&pbfh)+1, 0))
442: goto lfwrite_error_close_file;
443: pbfh->bmp = *pbmih;
444: if ((pbmih->cPlanes == 0) || (pbmih->cBitCount))
445: {
446: pbfh->bmp.cPlanes = (USHORT) bmFmt.cPlanes;
447: pbfh->bmp.cBitCount = (USHORT) bmFmt.cBitCount;
448: }
449:
450:
451: /*******************************************************************
452: * Allocate space for the bitmap bits -- all of them at once.
453: * The extra ULONG casts are there to force all the arithmetic
454: * to be done in 32 bits.
455: *******************************************************************/
456:
457: ulSize = (
458: (
459: (
460: (ULONG)pbfh->bmp.cBitCount
461: * (ULONG)pbfh->bmp.cx
462: + 31L
463: ) / 32L
464: ) * (ULONG)pbfh->bmp.cPlanes * 4L
465: ) * (ULONG)pbfh->bmp.cy;
466:
467: cSegs = (USHORT)(ulSize/0x10000L);
468: cbExtra = (USHORT)(ulSize%0x10000L);
469: if (DosAllocHuge(cSegs, cbExtra, (PSEL)&selBits, 0, 0))
470: goto lfwrite_error_free_header;
471: if (DosGetHugeShift(&hugeshift))
472: goto lfwrite_error_free_bits;
473:
474:
475: /*******************************************************************
476: * Tell GPI to give us the bits. The function returns the number
477: * of scan lines of the bitmap that were copied. We want all of
478: * them at once.
479: *******************************************************************/
480:
481: cScans = GpiQueryBitmapBits( hPS
482: , 0L
483: , (ULONG)pbfh->bmp.cy
484: , (PBYTE)MAKEP(selBits, 0)
485: , (PBITMAPINFO)&pbfh->bmp);
486: if (cScans != pbfh->bmp.cy) /* compare with original number of scans */
487: goto lfwrite_error_free_bits;
488:
489:
490: /*******************************************************************
491: * Fill in the extra header fields and write the header out to
492: * the file.
493: *******************************************************************/
494:
495: pbfh->usType = 0x4D42; /* 'MB' */
496: pbfh->cbSize = ulSize + cbBMHdr;
497: pbfh->xHotspot = pbfh->bmp.cx / 2; /* why bother ? */
498: pbfh->yHotspot = pbfh->bmp.cy / 2;
499: pbfh->offBits = cbBMHdr;
500:
501: if (DosWrite( hfile
502: , (PVOID)pbfh
503: , cbBMHdr
504: , &cbWritten))
505: goto lfwrite_error_free_bits;
506: if (cbWritten != cbBMHdr)
507: goto lfwrite_error_free_bits;
508:
509:
510: /*******************************************************************
511: * Write the bits out to the file. The DosWrite function allows a
512: * maximum of 64K-1 bytes written at a time. We get around this
513: * by writing two 32K chunks for each 64K segment, and writing the
514: * last segment in one piece.
515: *******************************************************************/
516:
517: for (i = 0; i <= cSegs; ++i)
518: {
519: if (i < cSegs)
520: {
521: /* This segment is 64K bytes long, so split it up. */
522: cbWrite1 = 0x8000;
523: cbWrite2 = 0x8000;
524: }
525: else
526: {
527: /* This segment is less than 64K bytes long, so write it all. */
528: cbWrite1 = cbExtra;
529: cbWrite2 = 0;
530: }
531:
532: /* There's a possibility that cbExtra will be 0, so check
533: * to avoid an unnecessary system call.
534: */
535: if (cbWrite1 > 0)
536: {
537: if (DosWrite( hfile
538: , (PVOID)MAKEP(selBits+(i<<hugeshift), 0)
539: , cbWrite1
540: , &cbWritten))
541: goto lfwrite_error_free_bits;
542: if (cbWrite1 != cbWritten)
543: goto lfwrite_error_free_bits;
544: }
545:
546: /* This will always be skipped on the last partial segment. */
547: if (cbWrite2 > 0)
548: {
549: if (DosWrite( hfile
550: , (PVOID)MAKEP(selBits+(i<<hugeshift), cbWrite1)
551: , cbWrite2
552: , &cbWritten))
553: goto lfwrite_error_free_bits;
554: if (cbWrite2 != cbWritten)
555: goto lfwrite_error_free_bits;
556: }
557: }
558:
559: fRet = TRUE; /* We made it! The bits are on the disk. */
560:
561:
562: /*******************************************************************
563: * Close the file, free the buffer space and leave. This is a
564: * common exit point from the function. Since the same cleanup
565: * operations need to be performed for such a large number of
566: * possible error conditions, this is concise way to do the right
567: * thing.
568: *******************************************************************/
569:
570: lfwrite_error_free_bits:
571: DosFreeSeg(selBits);
572: lfwrite_error_free_header:
573: DosFreeSeg(*((PUSHORT)&pbfh+1));
574: lfwrite_error_close_file:
575: DosClose(hfile);
576: return fRet;
577: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.