![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to imagedc.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 imagedc.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 manipulating images.
13: *
14: * History:
15: *
16: ****************************************************************************/
17:
18: #include "imagedit.h"
19:
20:
21:
22: /************************************************************************
23: * ImageDCCreate
24: *
25: * Allocates the image DC's and bitmaps used to hold the current image
26: * being edited. This includes ghdcImage and ghbmImage. For icons and
27: * cursors, also allocates the DC and bitmap that holds the AND mask
28: * that contains information about whether any given pixel is screen
29: * color, inverted screen color or a true color. These globals are
30: * ghdcANDMask and ghbmANDMask.
31: *
32: * The image DC will contain the image as it will appear when displayed.
33: * For icons and cursors, this means that it is the combined XOR and AND
34: * portions of the image. When the icon/cursor file is saved, the bits
35: * will be separated back out, but having them combined in the image
36: * makes it fast to display the image while editing. Because of this,
37: * however, care must be taken when changing the screen color because
38: * it is not possible to determine from the image DC alone whether a
39: * pixel is screen color or simply a true color that happens to be the
40: * same as the current screen color. The AND mask is very important for
41: * keeping this straight and must be properly updated when drawing on
42: * the image DC with any of the drawing tools!
43: *
44: * Arguments:
45: * INT iType - Type of image.
46: * INT cx - Width of the image.
47: * INT cy - Height of the image.
48: * INT nColors - Number of colors.
49: *
50: * Returns TRUE if successful, or FALSE if an error occurs.
51: *
52: * History:
53: *
54: ************************************************************************/
55:
56: BOOL ImageDCCreate(
57: INT iType,
58: INT cx,
59: INT cy,
60: INT nColors)
61: {
62: HDC hdcParent;
63:
64: /*
65: * Delete the old image DC's.
66: */
67: ImageDCDelete();
68:
69: hdcParent = GetDC(ghwndMain);
70:
71: if (!(ghdcImage = CreateCompatibleDC(hdcParent)))
72: goto Error1;
73:
74: if (!(ghbmImage = MyCreateBitmap(hdcParent, cx, cy, 16)))
75: goto Error2;
76:
77: SelectObject(ghdcImage, ghbmImage);
78:
79: /*
80: * If image is an icon or cursor, also allocate the AND mask
81: * DC and bitmap. Note that this cannot be a DIB (must use
82: * CreateBitmap) or the ImageDCSeparate() code will fail.
83: */
84: if (iType == FT_ICON || iType == FT_CURSOR) {
85: if (!(ghdcANDMask = CreateCompatibleDC(hdcParent)))
86: goto Error2;
87:
88: if (!(ghbmANDMask = CreateBitmap(cx, cy, (BYTE)1, (BYTE)1, NULL)))
89: goto Error3;
90:
91: SelectObject(ghdcANDMask, ghbmANDMask);
92: }
93:
94: ReleaseDC(ghwndMain, hdcParent);
95:
96: /*
97: * Set some globals.
98: */
99: gcxImage = cx;
100: gcyImage = cy;
101: gnColors = nColors;
102:
103: /*
104: * Initialize the bits.
105: */
106: ImageDCClear();
107:
108: return TRUE;
109:
110: Error3:
111: DeleteDC(ghdcANDMask);
112: ghdcANDMask = NULL;
113:
114: Error2:
115: DeleteDC(ghdcImage);
116: ghdcImage = NULL;
117:
118: Error1:
119: ReleaseDC(ghwndMain, hdcParent);
120:
121: return FALSE;
122: }
123:
124:
125:
126: /************************************************************************
127: * ImageDCDelete
128: *
129: * Deletes the current image DC. For icons and cursors, also deletes the
130: * mask DC. Finally, it destroys the undo buffers.
131: *
132: * History:
133: *
134: ************************************************************************/
135:
136: VOID ImageDCDelete(VOID)
137: {
138: if (ghdcImage) {
139: DeleteDC(ghdcImage);
140: ghdcImage = NULL;
141: DeleteObject(ghbmImage);
142: ghbmImage = NULL;
143: }
144:
145: if (ghdcANDMask) {
146: DeleteDC(ghdcANDMask);
147: ghdcANDMask = NULL;
148: DeleteObject(ghbmANDMask);
149: ghbmANDMask = NULL;
150: }
151:
152: /*
153: * Destroy the undo buffer.
154: */
155: ImageFreeUndo();
156: }
157:
158:
159:
160: /************************************************************************
161: * ImageDCClear
162: *
163: * Clears the image DC. Sets it to completely white. For icons and
164: * cursors, sets the image mask to be fully opaque also.
165: *
166: * History:
167: *
168: ************************************************************************/
169:
170: VOID ImageDCClear(VOID)
171: {
172: PatBlt(ghdcImage, 0, 0, gcxImage, gcyImage, WHITENESS);
173:
174: /*
175: * For icons and cursors, set all the mask bits to zero.
176: */
177: if (ghdcANDMask)
178: PatBlt(ghdcANDMask, 0, 0, gcxImage, gcyImage, BLACKNESS);
179: }
180:
181:
182:
183: /************************************************************************
184: * ImageDCSeparate
185: *
186: * This function separates out the XOR mask in hdcImage so that it does
187: * not have any pixels that are screen/inverse color. This must be done
188: * prior to saving the image (or changing the screen color) because
189: * normally the hdcImage contains the image as it will be displayed,
190: * which is really a combined view of the XOR and AND masks. The function
191: * ImageDCCombine can be used after this function to combine the masks
192: * back together.
193: *
194: * History:
195: *
196: ************************************************************************/
197:
198: VOID ImageDCSeparate(
199: HDC hdcImage,
200: INT cx,
201: INT cy,
202: HDC hdcANDMask,
203: DWORD rgbScreen)
204: {
205: HBITMAP hbmTemp;
206: HDC hdcTemp;
207: HBITMAP hbmOld;
208:
209: /*
210: * Create a temporary bitmap and DC for the mask bits and
211: * select bitmap into the DC.
212: */
213: hdcTemp = CreateCompatibleDC(hdcImage);
214: hbmTemp = CreateCompatibleBitmap(hdcImage, cx, cy);
215: hbmOld = SelectObject(hdcTemp, hbmTemp);
216:
217: /*
218: * Background color of temporary DC is set to the specified
219: * screen (transparent) color. The bits from mask DC (mono) are
220: * transferred to temp. DC (color). Thus the 1s in the mask (corresp.
221: * to "screen" and "inverse" portions) become "screen" colored pixels
222: * in temporary DC.
223: */
224: SetBkColor(hdcTemp, rgbScreen);
225: BitBlt(hdcTemp, 0, 0, cx, cy, hdcANDMask, 0, 0, SRCCOPY);
226:
227: /*
228: * The bits in the temporary DC are XORed against the bits in the image
229: * DC to recover the true XOR mask in hdcImage. The AND mask is already
230: * in hdcANDMask.
231: */
232: BitBlt(hdcImage, 0, 0, cx, cy, hdcTemp, 0, 0, SRCINVERT);
233:
234: SelectObject(hdcTemp, hbmOld);
235: DeleteDC(hdcTemp);
236: DeleteObject(hbmTemp);
237: }
238:
239:
240:
241: /************************************************************************
242: * ImageDCCombine
243: *
244: * This function takes the raw XOR mask in hdcImage and combines
245: * it with the AND mask in hdcANDMask to put into hdcImage the
246: * current image as it will be displayed. This needs to be done after
247: * it is separated (just prior to saving the file and also when changing
248: * the screen color) and when the image is first opened.
249: *
250: * The current screen color in ghbrScreen is used when combining the
251: * image in this routine.
252: *
253: * History:
254: *
255: ************************************************************************/
256:
257: VOID ImageDCCombine(
258: HDC hdcImage,
259: INT cx,
260: INT cy,
261: HDC hdcANDMask)
262: {
263: HBITMAP hbmTemp;
264: HDC hdcTemp;
265: HBITMAP hbmOld;
266: HBRUSH hbrOld;
267:
268: /*
269: * Make a copy of the image DC with the XOR mask in it.
270: */
271: hdcTemp = CreateCompatibleDC(hdcImage);
272: hbmTemp = CreateCompatibleBitmap(hdcImage, cx, cy);
273: hbmOld = SelectObject(hdcTemp, hbmTemp);
274: BitBlt(hdcTemp, 0, 0, cx, cy, hdcImage, 0, 0, SRCCOPY);
275:
276: /*
277: * Clear the image DC to the current screen color.
278: */
279: hbrOld = SelectObject(hdcImage, ghbrScreen);
280: PatBlt(hdcImage, 0, 0, cx, cy , PATCOPY);
281: SelectObject(hdcImage, hbrOld);
282:
283: /*
284: * Reconstruct the image by superimposing the XOR and AND masks.
285: */
286: BitBlt(hdcImage, 0, 0, cx, cy, hdcANDMask, 0, 0, SRCAND);
287: BitBlt(hdcImage, 0, 0, cx, cy, hdcTemp, 0, 0, SRCINVERT);
288:
289: SelectObject(hdcTemp, hbmOld);
290: DeleteDC(hdcTemp);
291: DeleteObject(hbmTemp);
292: }
293:
294:
295:
296: /************************************************************************
297: * ImageDCMonoBlt
298: *
299: * This function blts an image onto a monochrome bitmap, then back
300: * again. This converts it to a monochrome image.
301: *
302: * History:
303: *
304: ************************************************************************/
305:
306: VOID ImageDCMonoBlt(
307: HDC hdcImage,
308: INT cx,
309: INT cy)
310: {
311: HBITMAP hbmTemp;
312: HDC hdcTemp;
313: HBITMAP hbmOld;
314:
315: /*
316: * Create a temporary monochrome bitmap and dc.
317: */
318: hdcTemp = CreateCompatibleDC(hdcImage);
319: hbmTemp = MyCreateBitmap(hdcImage, cx, cy, 2);
320: hbmOld = SelectObject(hdcTemp, hbmTemp);
321:
322: /*
323: * Blt the image to the mono bitmap, then back again.
324: */
325: BitBlt(hdcTemp, 0, 0, cx, cy, hdcImage, 0, 0, SRCCOPY);
326: BitBlt(hdcImage, 0, 0, cx, cy, hdcTemp, 0, 0, SRCCOPY);
327:
328: /*
329: * Cleanup.
330: */
331: SelectObject(hdcTemp, hbmOld);
332: DeleteObject(hbmTemp);
333: DeleteDC(hdcTemp);
334: }
335:
336:
337:
338:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.