![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to image.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / imagedit|
Return to image.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / imagedit |
1.1 root 1: /****************************************************************************/
2: /* */
3: /* Microsoft Confidential */
4: /* */
5: /* Copyright (c) Microsoft Corp. 1987, 1991 */
6: /* All Rights Reserved */
7: /* */
8: /****************************************************************************/
9: /****************************** Module Header *******************************
10: * Module Name: image.c
11: *
12: * Routines for opening and saving images.
13: *
14: * History:
15: *
16: ****************************************************************************/
17:
18: #include "imagedit.h"
19:
20: #include <stdio.h>
21: #include <string.h>
22:
23:
24:
25: /************************************************************************
26: * ImageNew
27: *
28: * Creates a new image for the specified device.
29: *
30: * Arguments:
31: *
32: * History:
33: *
34: ************************************************************************/
35:
36: BOOL ImageNew(
37: PDEVICE pDevice)
38: {
39: PIMAGEINFO pImage;
40:
41: if (!(pImage = ImageLinkAlloc(pDevice, pDevice->cx, pDevice->cy,
42: 0, 0, pDevice->nColors)))
43: return FALSE;
44:
45: /*
46: * Allocate work space for the new image.
47: */
48: if (!ImageDCCreate(pDevice->iType, pImage->cx, pImage->cy,
49: pImage->nColors)) {
50: ImageLinkFree(pImage);
51: return FALSE;
52: }
53:
54: gpImageCur = pImage;
55: gnImages++;
56: giType = pDevice->iType;
57:
58: /*
59: * Initialize the pick rectangle to encompass the entire image.
60: */
61: PickSetRect(0, 0, gcxImage - 1, gcyImage - 1);
62:
63: /*
64: * Mark the newly created image as dirty to be sure it gets saved.
65: */
66: fImageDirty = TRUE;
67:
68: /*
69: * Update the palettes.
70: */
71: SetColorPalette(gnColors, giType, FALSE);
72: PropBarUpdate();
73: ToolboxUpdate();
74: ViewReset();
75:
76: /*
77: * Reset the workspace window and then show it.
78: */
79: WorkReset();
80: ShowWindow(ghwndWork, SW_SHOWNORMAL);
81:
82: return TRUE;
83: }
84:
85:
86:
87: /************************************************************************
88: * ImageNewBitmap
89: *
90: * Creates a new bitmap image given a set of characteristics. After
91: * device link is created for those characteristics, ImageNew() is
92: * called to do the actual work.
93: *
94: * Arguments:
95: *
96: * History:
97: *
98: ************************************************************************/
99:
100: BOOL ImageNewBitmap(
101: INT cx,
102: INT cy,
103: INT nColors)
104: {
105: PDEVICE pDevice;
106:
107: if (!(pDevice = DeviceLinkAlloc(FT_BITMAP, NULL, nColors, cx, cy)))
108: return FALSE;
109:
110: return ImageNew(pDevice);
111: }
112:
113:
114:
115: /************************************************************************
116: * ImageOpen
117: *
118: * Determines what has to be done to open the specified image. If it
119: * is not already the current image, it will save the current image
120: * then will call ImageOpen2() to open the new one.
121: *
122: * Arguments:
123: *
124: * History:
125: *
126: ************************************************************************/
127:
128: BOOL ImageOpen(
129: PIMAGEINFO pImage)
130: {
131: /*
132: * New image is already current. Return success.
133: */
134: if (pImage == gpImageCur)
135: return TRUE;
136:
137: /*
138: * Is this an image for a known device?
139: */
140: if (pImage->pDevice) {
141: /*
142: * Save away the current image.
143: */
144: ImageSave();
145:
146: /*
147: * Do the real open of the new image.
148: */
149: return ImageOpen2(pImage);
150: }
151: else {
152: Message(MSG_CANTEDITIMAGE);
153: return FALSE;
154: }
155: }
156:
157:
158:
159: /************************************************************************
160: * ImageOpen2
161: *
162: * Unconditionally opens up the specified image for editing. This involves
163: * parsing the DIB into various globals, putting the bits onto the screen
164: * and updating the different palettes appropriately.
165: *
166: * Arguments:
167: *
168: * History:
169: *
170: ************************************************************************/
171:
172: BOOL ImageOpen2(
173: PIMAGEINFO pImage)
174: {
175: HCURSOR hcurOld;
176: LPBITMAPINFO lpbi;
177: INT iBitCount;
178: INT cx;
179: INT cy;
180: INT nColors;
181: DWORD cbColorTable;
182: DWORD cbBits;
183: LPBYTE lpDIBBits;
184: HBITMAP hbmMono;
185: HBITMAP hbmImage;
186: PBITMAPINFO pbi;
187:
188: hcurOld = SetCursor(hcurWait);
189:
190: lpbi = (LPBITMAPINFO)pImage->DIBPtr;
191: iBitCount = lpbi->bmiHeader.biBitCount;
192:
193: cx = (INT)lpbi->bmiHeader.biWidth;
194: cy = (INT)lpbi->bmiHeader.biHeight;
195: if (giType != FT_BITMAP)
196: cy /= 2;
197:
198: nColors = pImage->nColors;
199:
200: /*
201: * Allocate work space for the image.
202: */
203: if (!ImageDCCreate(giType, cx, cy, nColors))
204: goto Error1;
205:
206: /*
207: * Create a temporary bitmap.
208: */
209: if (!(hbmMono = CreateBitmap(1, 1, 1, 1, NULL))) {
210: Message(MSG_OUTOFMEMORY);
211: goto Error2;
212: }
213:
214: cbColorTable = (1 << iBitCount) * sizeof(RGBQUAD);
215: lpDIBBits = (LPSTR)lpbi + sizeof(BITMAPINFOHEADER) + cbColorTable;
216: cbBits = (((((DWORD)cx * iBitCount) + 31) & 0xffffffe0) >> 3) * cy;
217:
218: /*
219: * Make a copy of the info header and color table.
220: */
221: if (!(pbi = (PBITMAPINFO)MyAlloc(
222: sizeof(BITMAPINFOHEADER) + (INT)cbColorTable)))
223: goto Error3;
224:
225: memcpy((LPBYTE)pbi, lpbi, sizeof(BITMAPINFOHEADER) + (INT)cbColorTable);
226:
227: /* * Adjust some fields. The size field in an icon/cursor dib
228: * includes the AND mask bits, which we don't want to include
229: * right now.
230: */
231: pbi->bmiHeader.biHeight = cy;
232: pbi->bmiHeader.biSizeImage = cbBits;
233:
234: /*
235: * Set the bits into the XOR mask.
236: */
237: hbmImage = SelectObject(ghdcImage, hbmMono);
238: SetDIBits(ghdcImage, hbmImage, 0, cy, lpDIBBits, pbi, DIB_RGB_COLORS);
239: SelectObject(ghdcImage, hbmImage);
240:
241: /*
242: * If we are editing an icon or cursor, we need to set the bits
243: * for the AND mask also now.
244: */
245: if (giType != FT_BITMAP) {
246: /*
247: * Skip past the XOR mask bits to the AND bits that follow.
248: */
249: lpDIBBits += cbBits;
250:
251: cbColorTable = 2 * sizeof(RGBQUAD);
252:
253: /*
254: * Adjust some fields in the copy of the bitmap info structure,
255: * then copy a monochrome color table into it. Note that we
256: * are using the same allocated copy, which is ok because there
257: * will always be enough room allocated for the monochrome
258: * color table.
259: */
260: pbi->bmiHeader.biBitCount = 1;
261: pbi->bmiHeader.biSizeImage =
262: cy * ((((DWORD)cx + 31) & 0xffffffe0) >> 3);
263: pbi->bmiHeader.biClrImportant = 0;
264: pbi->bmiHeader.biClrUsed = 0;
265: memcpy((PBYTE)pbi->bmiColors, (PBYTE)gargbColorTable2,
266: (INT)cbColorTable);
267:
268: /*
269: * Set the bits into the AND mask.
270: */
271: hbmImage = SelectObject(ghdcANDMask, hbmMono);
272: SetDIBits(ghdcANDMask, hbmImage, 0, cy, lpDIBBits, pbi,
273: DIB_RGB_COLORS);
274: SelectObject(ghdcANDMask, hbmImage);
275:
276: /*
277: * Combine the XOR and AND masks into a viewable image.
278: */
279: ImageDCCombine(ghdcImage, gcxImage, gcyImage, ghdcANDMask);
280: }
281:
282: MyFree(pbi);
283: DeleteObject(hbmMono);
284:
285: /*
286: * Set the current image pointer.
287: */
288: gpImageCur = pImage;
289: fImageDirty = FALSE;
290: /*
291: * Initialize the pick rectangle to encompass the entire image.
292: */
293: PickSetRect(0, 0, gcxImage - 1, gcyImage - 1);
294:
295: SetColorPalette(gnColors, giType, FALSE);
296:
297: /*
298: * Update the properties bar info and toolbox.
299: */
300: PropBarUpdate();
301: ToolboxUpdate();
302:
303: ViewReset();
304:
305: /*
306: * Reset the workspace window and then show it.
307: */
308: WorkReset();
309: ShowWindow(ghwndWork, SW_SHOWNORMAL);
310:
311: SetCursor(hcurOld);
312:
313: return TRUE;
314:
315: Error3:
316: DeleteObject(hbmMono);
317:
318: Error2:
319: ImageDCDelete();
320:
321: Error1:
322: SetCursor(hcurOld);
323:
324: return FALSE;
325: }
326:
327:
328:
329: /************************************************************************
330: * ImageSave
331: *
332: * Saves the state of the current image into the image list (if it
333: * is dirty).
334: *
335: * History:
336: *
337: ************************************************************************/
338:
339: VOID ImageSave(VOID)
340: {
341: HCURSOR hcurOld;
342: INT iBitCount;
343: DWORD cbColorTable;
344: DWORD cbXORBits;
345: DWORD cbANDBits;
346: HANDLE hDIB;
347: DWORD dwDIBSize;
348: LPBITMAPINFOHEADER lpbih;
349: LPBYTE lpBits;
350: HBITMAP hbmMono;
351: HBITMAP hbmImage;
352:
353: if (!fImageDirty)
354: return;
355:
356: hcurOld = SetCursor(hcurWait);
357:
358: /*
359: * Separate out the XOR and AND masks for ico/cur images.
360: */
361: if (giType != FT_BITMAP)
362: ImageDCSeparate(ghdcImage, gcxImage, gcyImage, ghdcANDMask, grgbScreen);
363:
364: /*
365: * Create a temporary bitmap.
366: */
367: if (!(hbmMono = CreateBitmap(1, 1, 1, 1, NULL))) {
368: Message(MSG_OUTOFMEMORY);
369: goto Error1;
370: }
371:
372: switch (gpImageCur->nColors) {
373: case 2:
374: iBitCount = 1;
375: break;
376:
377: case 16:
378: iBitCount = 4;
379: break;
380: }
381:
382: cbColorTable = (DWORD)gpImageCur->nColors * sizeof(RGBQUAD);
383: cbXORBits = (((((DWORD)gpImageCur->cx * iBitCount) + 31)
384: & 0xffffffe0) >> 3) * gpImageCur->cy;
385:
386: switch (giType) {
387: case FT_BITMAP:
388: cbANDBits = 0;
389: break;
390:
391: case FT_ICON:
392: case FT_CURSOR:
393: cbANDBits = (DWORD)gpImageCur->cy *
394: ((((DWORD)gpImageCur->cx + 31) & 0xffffffe0) >> 3);
395: break;
396: }
397:
398: dwDIBSize = sizeof(BITMAPINFOHEADER) + cbColorTable + cbXORBits +
399: cbANDBits;
400:
401: /*
402: * Allocate space for the DIB for this image.
403: */
404: if (!(hDIB = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwDIBSize))) {
405: Message(MSG_OUTOFMEMORY);
406: goto Error2;
407: }
408:
409: lpbih = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
410:
411: /*
412: * For icons and cursors, we need to get the AND mask bits first.
413: */
414: if (giType != FT_BITMAP) {
415: /*
416: * Point to where the AND bits should go.
417: */
418: lpBits = (LPBYTE)lpbih + sizeof(BITMAPINFOHEADER) +
419: cbColorTable + cbXORBits;
420:
421: /*
422: * Fill in the bitmap info header for getting the AND bits.
423: */
424: lpbih->biSize = sizeof(BITMAPINFOHEADER);
425: lpbih->biWidth = gpImageCur->cx;
426: lpbih->biHeight = gpImageCur->cy;
427: lpbih->biPlanes = 1;
428: lpbih->biBitCount = 1;
429: lpbih->biCompression = BI_RGB;
430: lpbih->biSizeImage = cbANDBits;
431: lpbih->biXPelsPerMeter = 0;
432: lpbih->biYPelsPerMeter = 0;
433: lpbih->biClrImportant = 0;
434: lpbih->biClrUsed = 0;
435:
436: /*
437: * Get the bits from the AND mask.
438: */
439: hbmImage = SelectObject(ghdcANDMask, hbmMono);
440: GetDIBits(ghdcANDMask, hbmImage, 0, gpImageCur->cy, lpBits,
441: (LPBITMAPINFO)lpbih, DIB_RGB_COLORS);
442: SelectObject(ghdcANDMask, hbmImage);
443: }
444:
445: /*
446: * Fill in the bitmap info header for getting the XOR bits.
447: */
448: lpbih->biSize = sizeof(BITMAPINFOHEADER);
449: lpbih->biWidth = gpImageCur->cx;
450: lpbih->biHeight = gpImageCur->cy;
451: lpbih->biPlanes = 1;
452: lpbih->biBitCount = iBitCount;
453: lpbih->biCompression = BI_RGB;
454: lpbih->biSizeImage = cbXORBits;
455: lpbih->biXPelsPerMeter = 0;
456: lpbih->biYPelsPerMeter = 0;
457: lpbih->biClrImportant = 0;
458: lpbih->biClrUsed = 0;
459:
460: /*
461: * Point to where the XOR bits should go.
462: */
463: lpBits = (LPBYTE)lpbih + sizeof(BITMAPINFOHEADER) + cbColorTable;
464:
465: /*
466: * Get the bits from the XOR mask.
467: */
468: hbmImage = SelectObject(ghdcImage, hbmMono);
469: GetDIBits(ghdcImage, hbmImage, 0, gpImageCur->cy, lpBits,
470: (LPBITMAPINFO)lpbih, DIB_RGB_COLORS);
471: SelectObject(ghdcImage, hbmImage);
472:
473: /*
474: * For icons and cursors, we have a few extra steps.
475: */
476: if (giType != FT_BITMAP) {
477: /*
478: * Set the fields in the info structure to their final
479: * values. The saved value in the bitmap info header for the
480: * height in an icon/cursor DIB is really twice the height of
481: * the image, and the size of the image is the size of both
482: * the XOR and the AND mask bits.
483: */
484: lpbih->biHeight *= 2;
485: lpbih->biSizeImage = cbXORBits + cbANDBits;
486:
487: /*
488: * Recombine the XOR and AND masks now that we have their bits.
489: */
490: ImageDCCombine(ghdcImage, gcxImage, gcyImage, ghdcANDMask);
491: }
492:
493: /*
494: * Free any old DIB.
495: */
496: if (gpImageCur->DIBhandle) {
497: GlobalUnlock(gpImageCur->DIBhandle);
498: GlobalFree(gpImageCur->DIBhandle);
499: }
500:
501: /*
502: * Set the image structure to point to the newly created DIB.
503: */
504: gpImageCur->DIBSize = dwDIBSize;
505: gpImageCur->DIBhandle = hDIB;
506: gpImageCur->DIBPtr = (LPBYTE)lpbih;
507:
508: fFileDirty = TRUE;
509: fImageDirty = FALSE;
510:
511: Error2:
512: DeleteObject(hbmMono);
513:
514: Error1:
515: SetCursor (hcurOld);
516: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.