![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / showdib|
Return to dib.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / showdib |
1.1 root 1: /*******************************************************************************
2: * *
3: * MODULE : DIB.C *
4: * *
5: * DESCRIPTION : Routines for dealing with Device Independent Bitmaps. *
6: * *
7: * FUNCTIONS : OpenDIB() - Opens DIB file and creates a memory DIB*
8: * *
9: * WriteDIB() - Writes a global handle in CF_DIB format*
10: * to a file. *
11: * *
12: * DibInfo() - Retrieves the info. block associated *
13: * with a CF_DIB format memory block. *
14: * *
15: * CreateBIPalette() - Creates a GDI palette given a pointer *
16: * to a BITMAPINFO structure. *
17: * *
18: * CreateDibPalette() - Creates a GDI palette given a HANDLE *
19: * to a BITMAPINFO structure. *
20: * *
21: * ReadDibBitmapInfo() - Reads a file in DIB format and returns *
22: * a global handle to it's BITMAPINFO *
23: * *
24: * PaletteSize() - Calculates the palette size in bytes *
25: * of given DIB *
26: * *
27: * DibNumColors() - Determines the number of colors in DIB *
28: * *
29: * BitmapFromDib() - Creates a DDB given a global handle to *
30: * a block in CF_DIB format. *
31: * *
32: * DibFromBitmap() - Creates a DIB repr. the DDB passed in. *
33: * *
34: * DrawBitmap() - Draws a bitmap at specified position *
35: * in the DC. *
36: * *
37: * DibBlt() - Draws a bitmap in CIF_DIB format using *
38: * SetDIBitsToDevice() *
39: * *
40: * StretchDibBlt() - Draws a bitmap in CIF_DIB format using *
41: * StretchDIBits() *
42: * *
43: * lread() - Private routine to read more than 64k *
44: * *
45: * lwrite() - Private routine to write more than 64k *
46: * *
47: *******************************************************************************/
48:
49: #include <windows.h>
50: #include "showdib.h"
51: static HCURSOR hcurSave;
52:
53: /****************************************************************************
54: * *
55: * FUNCTION :OpenDIB(LPSTR szFile) *
56: * *
57: * PURPOSE :Open a DIB file and create a MEMORY DIB, a memory handle *
58: * containing BITMAPINFO, palette data and the bits. *
59: * *
60: * RETURNS :A handle to the DIB. *
61: * *
62: ****************************************************************************/
63: HANDLE OpenDIB (LPSTR szFile)
64: {
65: HFILE fh;
66: BITMAPINFOHEADER bi;
67: LPBITMAPINFOHEADER lpbi;
68: DWORD dwLen = 0;
69: DWORD dwBits;
70: HANDLE hdib;
71: HANDLE h;
72: OFSTRUCT of;
73:
74: /* Open the file and read the DIB information */
75: fh = OpenFile(szFile, &of, (UINT)OF_READ);
76: if (fh == -1)
77: return NULL;
78:
79: hdib = ReadDibBitmapInfo(fh);
80: if (!hdib)
81: return NULL;
82: DibInfo(hdib,&bi);
83:
84: /* Calculate the memory needed to hold the DIB */
85: dwBits = bi.biSizeImage;
86: dwLen = bi.biSize + (DWORD)PaletteSize (&bi) + dwBits;
87:
88: /* Try to increase the size of the bitmap info. buffer to hold the DIB */
89: h = GlobalReAlloc(hdib, dwLen, GHND);
90: if (!h){
91: GlobalFree(hdib);
92: hdib = NULL;
93: }
94: else
95: hdib = h;
96:
97: /* Read in the bits */
98: if (hdib){
99:
100: lpbi = (VOID FAR *)GlobalLock(hdib);
101: lread(fh, (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize(lpbi), dwBits);
102: GlobalUnlock(hdib);
103: }
104: _lclose(fh);
105:
106: return hdib;
107: }
108:
109: /****************************************************************************
110: * *
111: * FUNCTION : WriteDIB(LPSTR szFile,HANDLE hdib) *
112: * *
113: * PURPOSE : Write a global handle in CF_DIB format to a file. *
114: * *
115: * RETURNS : TRUE - if successful. *
116: * FALSE - otherwise *
117: * *
118: ****************************************************************************/
119: BOOL WriteDIB (
120: LPSTR szFile,
121: HANDLE hdib)
122: {
123: BITMAPFILEHEADER hdr;
124: LPBITMAPINFOHEADER lpbi;
125: HFILE fh;
126: OFSTRUCT of;
127:
128: if (!hdib)
129: return FALSE;
130:
131: fh = OpenFile(szFile, &of, (UINT)OF_CREATE|OF_READWRITE);
132: if (fh == -1)
133: return FALSE;
134:
135: lpbi = (VOID FAR *)GlobalLock (hdib);
136:
137: /* Fill in the fields of the file header */
138: hdr.bfType = BFT_BITMAP;
139: hdr.bfSize = GlobalSize (hdib) + SIZEOF_BITMAPFILEHEADER_PACKED;
140: hdr.bfReserved1 = 0;
141: hdr.bfReserved2 = 0;
142: hdr.bfOffBits = (DWORD) (SIZEOF_BITMAPFILEHEADER_PACKED + lpbi->biSize +
143: PaletteSize(lpbi));
144:
145: /* Write the file header */
146: #ifdef FIXDWORDALIGNMENT
147: _lwrite(fh, (LPSTR)&hdr, (UINT)(SIZEOF_BITMAPFILEHEADER_PACKED));
148: #else
149: WriteMapFileHeaderandConvertFromDwordAlignToPacked(fh, &hdr);
150: #endif
151:
152: /* this struct already DWORD aligned!*/
153: /* Write the DIB header and the bits */
154: lwrite (fh, (LPSTR)lpbi, GlobalSize (hdib));
155:
156: GlobalUnlock (hdib);
157: _lclose(fh);
158: return TRUE;
159: }
160:
161: /****************************************************************************
162: * *
163: * FUNCTION : DibInfo(HANDLE hbi,LPBITMAPINFOHEADER lpbi) *
164: * *
165: * PURPOSE : Retrieves the DIB info associated with a CF_DIB *
166: * format memory block. *
167: * *
168: * RETURNS : TRUE - if successful. *
169: * FALSE - otherwise *
170: * *
171: ****************************************************************************/
172: BOOL DibInfo (
173: HANDLE hbi,
174: LPBITMAPINFOHEADER lpbi)
175: {
176: if (hbi){
177: *lpbi = *(LPBITMAPINFOHEADER)GlobalLock (hbi);
178:
179: /* fill in the default fields */
180: if (lpbi->biSize != sizeof (BITMAPCOREHEADER)){
181: if (lpbi->biSizeImage == 0L)
182: lpbi->biSizeImage = WIDTHBYTES(lpbi->biWidth*lpbi->biBitCount) * lpbi->biHeight;
183:
184: if (lpbi->biClrUsed == 0L)
185: lpbi->biClrUsed = DibNumColors (lpbi);
186: }
187: GlobalUnlock (hbi);
188: return TRUE;
189: }
190: return FALSE;
191: }
192:
193: /****************************************************************************
194: * *
195: * FUNCTION : CreateBIPalette(LPBITMAPINFOHEADER lpbi) *
196: * *
197: * PURPOSE : Given a Pointer to a BITMAPINFO struct will create a *
198: * a GDI palette object from the color table. *
199: * *
200: * RETURNS : A handle to the palette. *
201: * *
202: ****************************************************************************/
203: HPALETTE CreateBIPalette (LPBITMAPINFOHEADER lpbi)
204: {
205: LOGPALETTE *pPal;
206: HPALETTE hpal = NULL;
207: WORD nNumColors;
208: BYTE red;
209: BYTE green;
210: BYTE blue;
211: WORD i;
212: RGBQUAD FAR *pRgb;
213:
214: if (!lpbi)
215: return NULL;
216:
217: if (lpbi->biSize != sizeof(BITMAPINFOHEADER))
218: return NULL;
219:
220: /* Get a pointer to the color table and the number of colors in it */
221: pRgb = (RGBQUAD FAR *)((LPSTR)lpbi + (WORD)lpbi->biSize);
222: nNumColors = DibNumColors(lpbi);
223:
224: if (nNumColors){
225: /* Allocate for the logical palette structure */
226: pPal = (LOGPALETTE*)LocalAlloc(LPTR,sizeof(LOGPALETTE) + nNumColors * sizeof(PALETTEENTRY));
227: if (!pPal)
228: return NULL;
229:
230: pPal->palNumEntries = nNumColors;
231: pPal->palVersion = PALVERSION;
232:
233: /* Fill in the palette entries from the DIB color table and
234: * create a logical color palette.
235: */
236: for (i = 0; i < nNumColors; i++){
237: pPal->palPalEntry[i].peRed = pRgb[i].rgbRed;
238: pPal->palPalEntry[i].peGreen = pRgb[i].rgbGreen;
239: pPal->palPalEntry[i].peBlue = pRgb[i].rgbBlue;
240: pPal->palPalEntry[i].peFlags = (BYTE)0;
241: }
242: hpal = CreatePalette(pPal);
243: LocalFree((HANDLE)pPal);
244: }
245: else if (lpbi->biBitCount == 24){
246: /* A 24 bitcount DIB has no color table entries so, set the number of
247: * to the maximum value (256).
248: */
249: nNumColors = MAXPALETTE;
250: pPal = (LOGPALETTE*)LocalAlloc(LPTR,sizeof(LOGPALETTE) + nNumColors * sizeof(PALETTEENTRY));
251: if (!pPal)
252: return NULL;
253:
254: pPal->palNumEntries = nNumColors;
255: pPal->palVersion = PALVERSION;
256:
257: red = green = blue = 0;
258:
259: /* Generate 256 (= 8*8*4) RGB combinations to fill the palette
260: * entries.
261: */
262: for (i = 0; i < pPal->palNumEntries; i++){
263: pPal->palPalEntry[i].peRed = red;
264: pPal->palPalEntry[i].peGreen = green;
265: pPal->palPalEntry[i].peBlue = blue;
266: pPal->palPalEntry[i].peFlags = (BYTE)0;
267:
268: if (!(red += 32))
269: if (!(green += 32))
270: blue += 64;
271: }
272: hpal = CreatePalette(pPal);
273: LocalFree((HANDLE)pPal);
274: }
275: return hpal;
276: }
277:
278: /****************************************************************************
279: * *
280: * FUNCTION : CreateDibPalette(HANDLE hbi) *
281: * *
282: * PURPOSE : Given a Global HANDLE to a BITMAPINFO Struct *
283: * will create a GDI palette object from the color table. *
284: * (BITMAPINFOHEADER format DIBs only) *
285: * *
286: * RETURNS : A handle to the palette. *
287: * *
288: ****************************************************************************/
289: HPALETTE CreateDibPalette (HANDLE hbi)
290: {
291: HPALETTE hpal;
292:
293: if (!hbi)
294: return NULL;
295: hpal = CreateBIPalette((LPBITMAPINFOHEADER)GlobalLock(hbi));
296: GlobalUnlock(hbi);
297: return hpal;
298: }
299:
300: /****************************************************************************
301: * *
302: * FUNCTION : ReadDibBitmapInfo(int fh) *
303: * *
304: * PURPOSE : Will read a file in DIB format and return a global HANDLE *
305: * to it's BITMAPINFO. This function will work with both *
306: * "old" (BITMAPCOREHEADER) and "new" (BITMAPINFOHEADER) *
307: * bitmap formats, but will always return a "new" BITMAPINFO *
308: * *
309: * RETURNS : A handle to the BITMAPINFO of the DIB in the file. *
310: * *
311: ****************************************************************************/
312: HANDLE ReadDibBitmapInfo (INT fh)
313: {
314: DWORD off;
315: HANDLE hbi = NULL;
316: INT size;
317: INT i;
318: WORD nNumColors;
319:
320: RGBQUAD FAR *pRgb;
321: BITMAPINFOHEADER bi;
322: BITMAPCOREHEADER bc;
323: LPBITMAPINFOHEADER lpbi;
324: BITMAPFILEHEADER bf;
325: DWORD dwWidth = 0;
326: DWORD dwHeight = 0;
327: WORD wPlanes, wBitCount;
328:
329: if (fh == -1)
330: return NULL;
331: #ifdef FIXDWORDALIGNMENT
332: /* Reset file pointer and read file header */
333: off = _llseek(fh, 0L, (UINT)SEEK_CUR);
334: if ((SIZEOF_BITMAPFILEHEADER_PACKED) != _lread(fh, (LPSTR)&bf, (UINT)sizeof (SIZEOF_BITMAPFILEHEADER_PACKED)))
335: return FALSE;
336: #else
337: ReadBitMapFileHeaderandConvertToDwordAlign(fh, &bf, &off);
338: /* at this point we have read the file into bf*/
339: #endif
340:
341: /* Do we have a RC HEADER? */
342: if (!ISDIB (bf.bfType)) {
343: bf.bfOffBits = 0L;
344: _llseek(fh, off, (UINT)SEEK_SET); /*seek back to beginning of file*/
345: }
346: if (sizeof (bi) != _lread(fh, (LPSTR)&bi, (UINT)sizeof(bi)))
347: return FALSE;
348:
349: nNumColors = DibNumColors (&bi);
350:
351: /* Check the nature (BITMAPINFO or BITMAPCORE) of the info. block
352: * and extract the field information accordingly. If a BITMAPCOREHEADER,
353: * transfer it's field information to a BITMAPINFOHEADER-style block
354: */
355: switch (size = (INT)bi.biSize){
356: case sizeof (BITMAPINFOHEADER):
357: break;
358:
359: case sizeof (BITMAPCOREHEADER):
360:
361: bc = *(BITMAPCOREHEADER*)&bi;
362:
363: dwWidth = (DWORD)bc.bcWidth;
364: dwHeight = (DWORD)bc.bcHeight;
365: wPlanes = bc.bcPlanes;
366: wBitCount = bc.bcBitCount;
367:
368: bi.biSize = sizeof(BITMAPINFOHEADER);
369: bi.biWidth = dwWidth;
370: bi.biHeight = dwHeight;
371: bi.biPlanes = wPlanes;
372: bi.biBitCount = wBitCount;
373:
374: bi.biCompression = BI_RGB;
375: bi.biSizeImage = 0;
376: bi.biXPelsPerMeter = 0;
377: bi.biYPelsPerMeter = 0;
378: bi.biClrUsed = nNumColors;
379: bi.biClrImportant = nNumColors;
380:
381: _llseek(fh, (LONG)sizeof (BITMAPCOREHEADER) - sizeof (BITMAPINFOHEADER), (UINT)SEEK_CUR);
382: break;
383:
384: default:
385: /* Not a DIB! */
386: return NULL;
387: }
388:
389: /* Fill in some default values if they are zero */
390: if (bi.biSizeImage == 0){
391: bi.biSizeImage = WIDTHBYTES ((DWORD)bi.biWidth * bi.biBitCount)
392: * bi.biHeight;
393: }
394: if (bi.biClrUsed == 0)
395: bi.biClrUsed = DibNumColors(&bi);
396:
397: /* Allocate for the BITMAPINFO structure and the color table. */
398: hbi = GlobalAlloc (GHND, (LONG)bi.biSize + nNumColors * sizeof(RGBQUAD));
399: if (!hbi)
400: return NULL;
401: lpbi = (VOID FAR *)GlobalLock (hbi);
402: *lpbi = bi;
403:
404: /* Get a pointer to the color table */
405: pRgb = (RGBQUAD FAR *)((LPSTR)lpbi + bi.biSize);
406: if (nNumColors){
407: if (size == sizeof(BITMAPCOREHEADER)){
408: /* Convert a old color table (3 byte RGBTRIPLEs) to a new
409: * color table (4 byte RGBQUADs)
410: */
411: _lread(fh, (LPSTR)pRgb, (UINT)nNumColors * sizeof(RGBTRIPLE));
412:
413: for (i = nNumColors - 1; i >= 0; i--){
414: RGBQUAD rgb;
415:
416: rgb.rgbRed = ((RGBTRIPLE FAR *)pRgb)[i].rgbtRed;
417: rgb.rgbBlue = ((RGBTRIPLE FAR *)pRgb)[i].rgbtBlue;
418: rgb.rgbGreen = ((RGBTRIPLE FAR *)pRgb)[i].rgbtGreen;
419: rgb.rgbReserved = (BYTE)0;
420:
421: pRgb[i] = rgb;
422: }
423: }
424: else
425: _lread(fh, (LPSTR)pRgb, (UINT)nNumColors * sizeof(RGBQUAD));
426: }
427:
428: if (bf.bfOffBits != 0L){
429: _llseek(fh, off + bf.bfOffBits, (UINT)SEEK_SET);
430: }
431: GlobalUnlock(hbi);
432: return hbi;
433: }
434:
435: /****************************************************************************
436: * *
437: * FUNCTION : PaletteSize(VOID FAR * pv) *
438: * *
439: * PURPOSE : Calculates the palette size in bytes. If the info. block *
440: * is of the BITMAPCOREHEADER type, the number of colors is *
441: * multiplied by 3 to give the palette size, otherwise the *
442: * number of colors is multiplied by 4. *
443: * *
444: * RETURNS : Palette size in number of bytes. *
445: * *
446: ****************************************************************************/
447: WORD PaletteSize (VOID FAR * pv)
448: {
449: LPBITMAPINFOHEADER lpbi;
450: WORD NumColors;
451:
452: lpbi = (LPBITMAPINFOHEADER)pv;
453: NumColors = DibNumColors(lpbi);
454:
455: if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
456: return (WORD)(NumColors * sizeof(RGBTRIPLE));
457: else
458: return (WORD)(NumColors * sizeof(RGBQUAD));
459: }
460:
461: /****************************************************************************
462: * *
463: * FUNCTION : DibNumColors(VOID FAR * pv) *
464: * *
465: * PURPOSE : Determines the number of colors in the DIB by looking at *
466: * the BitCount filed in the info block. *
467: * *
468: * RETURNS : The number of colors in the DIB. *
469: * *
470: ****************************************************************************/
471: WORD DibNumColors (VOID FAR * pv)
472: {
473: INT bits;
474: LPBITMAPINFOHEADER lpbi;
475: LPBITMAPCOREHEADER lpbc;
476:
477: lpbi = ((LPBITMAPINFOHEADER)pv);
478: lpbc = ((LPBITMAPCOREHEADER)pv);
479:
480: /* With the BITMAPINFO format headers, the size of the palette
481: * is in biClrUsed, whereas in the BITMAPCORE - style headers, it
482: * is dependent on the bits per pixel ( = 2 raised to the power of
483: * bits/pixel).
484: */
485: if (lpbi->biSize != sizeof(BITMAPCOREHEADER)){
486: if (lpbi->biClrUsed != 0)
487: return (WORD)lpbi->biClrUsed;
488: bits = lpbi->biBitCount;
489: }
490: else
491: bits = lpbc->bcBitCount;
492:
493: switch (bits){
494: case 1:
495: return 2;
496: case 4:
497: return 16;
498: case 8:
499: return 256;
500: default:
501: /* A 24 bitcount DIB has no color table */
502: return 0;
503: }
504: }
505: /****************************************************************************
506: * *
507: * FUNCTION : DibFromBitmap() *
508: * *
509: * PURPOSE : Will create a global memory block in DIB format that *
510: * represents the Device-dependent bitmap (DDB) passed in. *
511: * *
512: * RETURNS : A handle to the DIB *
513: * *
514: ****************************************************************************/
515: HANDLE DibFromBitmap (
516: HBITMAP hbm,
517: DWORD biStyle,
518: WORD biBits,
519: HPALETTE hpal)
520: {
521: BITMAP bm;
522: BITMAPINFOHEADER bi;
523: BITMAPINFOHEADER FAR *lpbi;
524: DWORD dwLen;
525: HANDLE hdib;
526: HANDLE h;
527: HDC hdc;
528:
529: if (!hbm)
530: return NULL;
531:
532: if (hpal == NULL)
533: hpal = GetStockObject(DEFAULT_PALETTE);
534:
535: GetObject(hbm,sizeof(bm),(LPSTR)&bm);
536:
537: if (biBits == 0)
538: biBits = bm.bmPlanes * bm.bmBitsPixel;
539:
540: bi.biSize = sizeof(BITMAPINFOHEADER);
541: bi.biWidth = bm.bmWidth;
542: bi.biHeight = bm.bmHeight;
543: bi.biPlanes = 1;
544: bi.biBitCount = biBits;
545: bi.biCompression = biStyle;
546: bi.biSizeImage = 0;
547: bi.biXPelsPerMeter = 0;
548: bi.biYPelsPerMeter = 0;
549: bi.biClrUsed = 0;
550: bi.biClrImportant = 0;
551:
552: dwLen = bi.biSize + PaletteSize(&bi);
553:
554: hdc = GetDC(NULL);
555: hpal = SelectPalette(hdc,hpal,FALSE);
556: RealizePalette(hdc);
557:
558: hdib = GlobalAlloc(GHND,dwLen);
559:
560: if (!hdib){
561: SelectPalette(hdc,hpal,FALSE);
562: ReleaseDC(NULL,hdc);
563: return NULL;
564: }
565:
566: lpbi = (VOID FAR *)GlobalLock(hdib);
567:
568: *lpbi = bi;
569:
570: /* call GetDIBits with a NULL lpBits param, so it will calculate the
571: * biSizeImage field for us
572: */
573: GetDIBits(hdc, hbm, 0L, (DWORD)bi.biHeight,
574: (LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);
575:
576: bi = *lpbi;
577: GlobalUnlock(hdib);
578:
579: /* If the driver did not fill in the biSizeImage field, make one up */
580: if (bi.biSizeImage == 0){
581: bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
582:
583: if (biStyle != BI_RGB)
584: bi.biSizeImage = (bi.biSizeImage * 3) / 2;
585: }
586:
587: /* realloc the buffer big enough to hold all the bits */
588: dwLen = bi.biSize + PaletteSize(&bi) + bi.biSizeImage;
589: if (h = GlobalReAlloc(hdib,dwLen,0))
590: hdib = h;
591: else{
592: GlobalFree(hdib);
593: hdib = NULL;
594:
595: SelectPalette(hdc,hpal,FALSE);
596: ReleaseDC(NULL,hdc);
597: return hdib;
598: }
599:
600: /* call GetDIBits with a NON-NULL lpBits param, and actualy get the
601: * bits this time
602: */
603: lpbi = (VOID FAR *)GlobalLock(hdib);
604:
605: if (GetDIBits( hdc,
606: hbm,
607: 0L,
608: (DWORD)bi.biHeight,
609: (LPBYTE)lpbi + (WORD)lpbi->biSize + PaletteSize(lpbi),
610: (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS) == 0){
611: GlobalUnlock(hdib);
612: hdib = NULL;
613: SelectPalette(hdc,hpal,FALSE);
614: ReleaseDC(NULL,hdc);
615: return NULL;
616: }
617:
618: bi = *lpbi;
619: GlobalUnlock(hdib);
620:
621: SelectPalette(hdc,hpal,FALSE);
622: ReleaseDC(NULL,hdc);
623: return hdib;
624: }
625:
626: /****************************************************************************
627: * *
628: * FUNCTION : BitmapFromDib(HANDLE hdib, HPALETTE hpal) *
629: * *
630: * PURPOSE : Will create a DDB (Device Dependent Bitmap) given a global *
631: * handle to a memory block in CF_DIB format *
632: * *
633: * RETURNS : A handle to the DDB. *
634: * *
635: ****************************************************************************/
636: HBITMAP BitmapFromDib (
637: HANDLE hdib,
638: HPALETTE hpal)
639: {
640: LPBITMAPINFOHEADER lpbi;
641: HPALETTE hpalT;
642: HDC hdc;
643: HBITMAP hbm;
644:
645: StartWait();
646:
647: if (!hdib)
648: return NULL;
649:
650: lpbi = (VOID FAR *)GlobalLock(hdib);
651:
652: if (!lpbi)
653: return NULL;
654:
655: hdc = GetDC(NULL);
656:
657: if (hpal){
658: hpalT = SelectPalette(hdc,hpal,FALSE);
659: RealizePalette(hdc); // GDI Bug...????
660: }
661:
662: hbm = CreateDIBitmap(hdc,
663: (LPBITMAPINFOHEADER)lpbi,
664: (LONG)CBM_INIT,
665: (LPSTR)lpbi + lpbi->biSize + PaletteSize(lpbi),
666: (LPBITMAPINFO)lpbi,
667: DIB_RGB_COLORS );
668:
669: if (hpal)
670: SelectPalette(hdc,hpalT,FALSE);
671:
672: ReleaseDC(NULL,hdc);
673: GlobalUnlock(hdib);
674:
675: EndWait();
676:
677: return hbm;
678: }
679: /****************************************************************************
680: * *
681: * FUNCTION : DrawBitmap(HDC hdc, int x, int y, HBITMAP hbm, DWORD rop) *
682: * *
683: * PURPOSE : Draws bitmap <hbm> at the specifed position in DC <hdc> *
684: * *
685: * RETURNS : Return value of BitBlt() *
686: * *
687: ****************************************************************************/
688: BOOL DrawBitmap (
689: HDC hdc,
690: INT x,
691: INT y,
692: HBITMAP hbm,
693: DWORD rop)
694: {
695: HDC hdcBits;
696: BITMAP bm;
697: // HPALETTE hpalT;
698: BOOL f;
699:
700: if (!hdc || !hbm)
701: return FALSE;
702:
703: hdcBits = CreateCompatibleDC(hdc);
704: GetObject(hbm,sizeof(BITMAP),(LPSTR)&bm);
705: SelectObject(hdcBits,hbm);
706: f = BitBlt(hdc,0,0,bm.bmWidth,bm.bmHeight,hdcBits,0,0,rop);
707: DeleteDC(hdcBits);
708:
709: return f;
710: UNREFERENCED_PARAMETER(y);
711: UNREFERENCED_PARAMETER(x);
712: }
713: /****************************************************************************
714: * *
715: * FUNCTION : DibBlt( HDC hdc, *
716: * int x0, int y0, *
717: * int dx, int dy, *
718: * HANDLE hdib, *
719: * int x1, int y1, *
720: * LONG rop) *
721: * *
722: * PURPOSE : Draws a bitmap in CF_DIB format, using SetDIBits to device.*
723: * taking the same parameters as BitBlt(). *
724: * *
725: * RETURNS : TRUE - if function succeeds. *
726: * FALSE - otherwise. *
727: * *
728: ****************************************************************************/
729: BOOL DibBlt (
730: HDC hdc,
731: INT x0,
732: INT y0,
733: INT dx,
734: INT dy,
735: HANDLE hdib,
736: INT x1,
737: INT y1,
738: LONG rop)
739: {
740: LPBITMAPINFOHEADER lpbi;
741: // HPALETTE hpal,hpalT;
742: LPSTR pBuf;
743: // HDC hdcMem;
744: // HBITMAP hbm,hbmT;
745:
746: if (!hdib)
747: return PatBlt(hdc,x0,y0,dx,dy,rop);
748:
749: lpbi = (VOID FAR *)GlobalLock(hdib);
750:
751: if (!lpbi)
752: return FALSE;
753:
754: pBuf = (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize(lpbi);
755: SetDIBitsToDevice (hdc, x0, y0, dx, dy,
756: x1,y1,
757: x1,
758: dy,
759: pBuf, (LPBITMAPINFO)lpbi,
760: DIB_RGB_COLORS );
761:
762: GlobalUnlock(hdib);
763: return TRUE;
764: }
765: /****************************************************************************
766: * *
767: * FUNCTION : StretchDibBlt( HDC hdc, *
768: * int x, int y, *
769: * int dx, int dy, *
770: * HANDLE hdib, *
771: * int x0, int y0, *
772: * int dx0, int dy0, *
773: * LONG rop) *
774: * *
775: * PURPOSE : Draws a bitmap in CF_DIB format, using StretchDIBits() *
776: * taking the same parameters as StretchBlt(). *
777: * *
778: * RETURNS : TRUE - if function succeeds. *
779: * FALSE - otherwise. *
780: * *
781: ****************************************************************************/
782: BOOL StretchDibBlt (
783: HDC hdc,
784: INT x,
785: INT y,
786: INT dx,
787: INT dy,
788: HANDLE hdib,
789: INT x0,
790: INT y0,
791: INT dx0,
792: INT dy0,
793: LONG rop)
794:
795: {
796: LPBITMAPINFOHEADER lpbi;
797: LPSTR pBuf;
798: BOOL f;
799:
800: if (!hdib)
801: return PatBlt(hdc,x,y,dx,dy,rop);
802:
803: lpbi = (VOID FAR *)GlobalLock(hdib);
804:
805: if (!lpbi)
806: return FALSE;
807:
808: pBuf = (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize(lpbi);
809:
810: f = StretchDIBits ( hdc,
811: x, y,
812: dx, dy,
813: x0, y0,
814: dx0, dy0,
815: pBuf, (LPBITMAPINFO)lpbi,
816: DIB_RGB_COLORS,
817: rop);
818:
819: GlobalUnlock(hdib);
820: return f;
821: }
822:
823: /************* PRIVATE ROUTINES TO READ/WRITE MORE THAN 64K ***************/
824: /****************************************************************************
825: * *
826: * FUNCTION : lread(int fh, VOID FAR *pv, DWORD ul) *
827: * *
828: * PURPOSE : Reads data in steps of 32k till all the data has been read.*
829: * *
830: * RETURNS : 0 - If read did not proceed correctly. *
831: * number of bytes read otherwise. *
832: * *
833: ****************************************************************************/
834: DWORD PASCAL lread (
835: INT fh,
836: VOID FAR *pv,
837: DWORD ul)
838: {
839: DWORD ulT = ul;
840: BYTE HUGE_T *hp = pv;
841:
842: while (ul > (DWORD)MAXREAD) {
843: if (_lread(fh, (LPSTR)hp, (UINT)MAXREAD) != MAXREAD)
844: return 0;
845: ul -= MAXREAD;
846: hp += MAXREAD;
847: }
848: if (_lread(fh, (LPSTR)hp, (UINT)ul) != (UINT)ul)
849: return 0;
850: return ulT;
851: }
852:
853: /****************************************************************************
854: * *
855: * FUNCTION : lwrite(int fh, VOID FAR *pv, DWORD ul) *
856: * *
857: * PURPOSE : Writes data in steps of 32k till all the data is written. *
858: * *
859: * RETURNS : 0 - If write did not proceed correctly. *
860: * number of bytes written otherwise. *
861: * *
862: ****************************************************************************/
863: DWORD PASCAL lwrite (
864: INT fh,
865: VOID FAR *pv,
866: DWORD ul)
867: {
868: DWORD ulT = ul;
869: BYTE HUGE_T *hp = pv;
870:
871: while (ul > MAXREAD) {
872: if (_lwrite(fh, (LPSTR)hp, (UINT)MAXREAD) != MAXREAD)
873: return 0;
874: ul -= MAXREAD;
875: hp += MAXREAD;
876: }
877: if (_lwrite(fh, (LPSTR)hp, (UINT)ul) != (UINT)ul)
878: return 0;
879:
880: return ulT;
881: }
882:
883: /****************************************************************************
884: * *
885: * FUNCTION : ReadBitMapFileHeaderandConvertToDwordAlign(HFILE fh, LPBITMAPFILEHEADER pbf)
886: * *
887: * PURPOSE : read file header (which is packed) and convert into unpacked BITMAPFILEHEADER strucutre
888: * *
889: * RETURNS : VOID
890: * *
891: ****************************************************************************/
892:
893: VOID ReadBitMapFileHeaderandConvertToDwordAlign(HFILE fh, LPBITMAPFILEHEADER pbf, LPDWORD lpdwoff)
894: {
895: DWORD off;
896:
897: off = _llseek(fh, 0L, (UINT) SEEK_CUR);
898: *lpdwoff = off;
899:
900: /* BITMAPFILEHEADER STRUCUTURE is as follows
901: * BITMAPFILEHEADER
902: * WORD bfType
903: > .... < add WORD if packed here!
904: * DWORD bfSize
905: * WORD bfReserved1
906: * WORD bfReserved2
907: * DWORD bfOffBits
908: * This is the packed format, unpacked adds a WORD after bfType
909: */
910:
911: /* read in bfType*/
912: _lread(fh, (LPSTR) &pbf->bfType, sizeof(WORD));
913: /* read in last 3 dwords*/
914: _lread(fh, (LPSTR) &pbf->bfSize, sizeof(DWORD) * 3);
915:
916: }
917:
918:
919:
920: /****************************************************************************
921: * *
922: * FUNCTION : WriteMapFileHeaderandConvertFromDwordAlignToPacked(HFILE fh, LPBITMAPFILEHEADER pbf)
923: * *
924: * PURPOSE : write header structure (which NOT packed) and write it PACKED
925: * *
926: * RETURNS : VOID
927: * *
928: ****************************************************************************/
929:
930: VOID WriteMapFileHeaderandConvertFromDwordAlignToPacked(HFILE fh, LPBITMAPFILEHEADER pbf)
931: {
932:
933: /* write bfType*/
934: _lwrite(fh, (LPSTR)&pbf->bfType, (UINT)sizeof (WORD));
935: /* now pass over extra word, and only write next 3 DWORDS!*/
936: _lwrite(fh, (LPSTR)&pbf->bfSize, sizeof(DWORD) * 3);
937: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.