![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to icclip.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 icclip.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / imagedit |
1.1 root 1: /***************************************************************************
2: * *
3: * MODULE : ICClip.C *
4: * *
5: * DESCRIPTION : Clipboard functions for ImagEdit *
6: * *
7: * FUNCTIONS : CopyImageClip () - Copies selected portion of image to *
8: * the clipboard. *
9: * *
10: * PasteImageClip () - Pastes the clipboard image to *
11: * selected portion of edit image. *
12: * *
13: * *
14: * HISTORY : 6/21/89 - created by LR *
15: * *
16: ***************************************************************************/
17:
18: #include "imagedit.h"
19: #include "dialogs.h"
20: #include "iehelp.h"
21:
22:
23:
24: /*==========================================================================
25: |ImagEdit's clipboard data is in two formats: |
26: | a) a standard CF_BITMAP format and |
27: | b) a private ImagEdit format described below. |
28: | |
29: |The private ImagEdit format data consists of: |
30: | 1. a DWORD describing screen color when image was sent to clipboard |
31: | followed by... |
32: | 2. the DIB bits of the monochrome AND image (in ghdcANDMask). |
33: | |
34: |The CF_BITMAP format consists of the image bitmap (the combined XOR and |
35: |AND images in ghdcImage for icons and cursors). |
36: | |
37: |This information is sufficient to re-create the image correctly during |
38: |paste even if the screen viewing color is subsequently changed. |
39: | |
40: |Both formats are created if the image being edited is an icon or a cursor.|
41: |Only the CF_BITMAP format is created if a bitmap is being edited. |
42: ==========================================================================*/
43:
44: /****************************************************************************
45: * *
46: * FUNCTION : BOOL PASCAL CopyImageClip(fBitmap) *
47: * *
48: * PURPOSE : Copies the information from the selected area of image to *
49: * the clipboard. *
50: * *
51: * SIDE EFFECTS: may change contents of the clipboard. The "pick" or clip *
52: * rectangle is reset to cover the entire image. *
53: * *
54: ****************************************************************************/
55:
56: BOOL CopyImageClip(VOID)
57: {
58: HCURSOR hcurOld;
59: HBITMAP hStdBitmap;
60: HBITMAP hPrivBitmap;
61: HDC hStdDC;
62: HDC hPrivDC;
63: HANDLE hOldSObj;
64: HANDLE hOldPObj;
65: HANDLE hPriv;
66: LPSTR lpPriv;
67:
68: hcurOld = SetCursor(hcurWait);
69:
70: /* create a temp. bitmap and DC for the standard clipboard format
71: * along the same lines as the image bitmap
72: */
73: hStdDC = CreateCompatibleDC(ghdcImage);
74: hStdBitmap = MyCreateBitmap(ghdcImage, gcxPick, gcyPick, 16);
75: hOldSObj = SelectObject(hStdDC, hStdBitmap);
76:
77: /* blt the image bits into standard format DC */
78: BitBlt(hStdDC, 0, 0, gcxPick, gcyPick, ghdcImage,
79: grcPick.left, grcPick.top, SRCCOPY);
80: SelectObject(hStdDC, hOldSObj);
81:
82: if (giType != FT_BITMAP) {
83: /* for icons and cursors, create a temp. DC and bitmap for the AND
84: * mask and blt the mask bits into it.
85: */
86: hPrivDC = CreateCompatibleDC(ghdcANDMask);
87: hPrivBitmap = CreateCompatibleBitmap(ghdcANDMask, gcxPick, gcyPick);
88: hOldPObj = SelectObject(hPrivDC, hPrivBitmap);
89: BitBlt(hPrivDC, 0, 0, gcxPick, gcyPick, ghdcANDMask,
90: grcPick.left, grcPick.top, SRCCOPY);
91:
92: /* Allocate a buffer for the private ImagEdit format */
93: hPriv = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
94: (DWORD)((gcxPick + 31) >> 3) * gcyPick + sizeof(DWORD));
95: if (!hPriv) {
96: DeleteDC(hStdDC);
97: DeleteObject(hStdBitmap);
98: DeleteDC(hPrivDC);
99: DeleteObject(hPrivBitmap);
100: return FALSE;
101: }
102:
103: lpPriv = (LPSTR)GlobalLock(hPriv);
104:
105: /* Fill in the first DWORD with the screen color information */
106: *((DWORD FAR *)lpPriv) = grgbScreen;
107:
108: /* Get the mask bits into the buffer */
109: GetBitmapBits(hPrivBitmap, (DWORD)((gcxPick + 31) >> 3) * gcyPick,
110: (LPSTR)lpPriv + sizeof(DWORD));
111:
112: SelectObject(hPrivDC, hOldPObj);
113: DeleteObject(hPrivBitmap);
114: DeleteDC(hPrivDC);
115: }
116:
117: /* Open clipboard and clear it of it's contents */
118: if (!OpenClipboard(ghwndMain)) {
119: DeleteDC(hStdDC);
120: return(FALSE);
121: }
122: EmptyClipboard();
123:
124: if (giType != FT_BITMAP) {
125: /* set the private ImagEdit format data into the clipboard */
126: if (!SetClipboardData(ClipboardFormat, hPriv)) {
127: DeleteDC(hStdDC);
128: GlobalUnlock(hPriv);
129: GlobalFree(hPriv);
130: CloseClipboard();
131: return(FALSE);
132: }
133: GlobalUnlock(hPriv);
134: }
135: /* set the standard CF_BITMAP format data in the clipboard */
136: if (!SetClipboardData(CF_BITMAP, hStdBitmap)) {
137: DeleteDC(hStdDC);
138: GlobalFree(hPriv); // hPriv may not have been initialized (if giType == BITMAP).
139: CloseClipboard();
140: return(FALSE);
141: }
142:
143: CloseClipboard();
144: DeleteDC(hStdDC);
145:
146: /*
147: * Reset pick rectangle to cover entire image.
148: */
149: PickSetRect(0, 0, gcxImage - 1, gcyImage - 1);
150:
151: /*
152: * Erase the drag rectangle.
153: */
154: WorkUpdate();
155:
156: SetCursor(hcurOld);
157:
158: return TRUE;
159: }
160:
161:
162:
163: /************************************************************************
164: * PasteImageClip
165: *
166: * Pastes an image from the clipboard to the current image.
167: *
168: * It is assumed that this routine will not be called unless an
169: * image is currently being edited.
170: *
171: * The pick rectangle is reset to cover the entire image if the
172: * paste is successful.
173: *
174: * Basic outline of how Paste is done in ImagEdit.
175: *
176: * Find out what format is available in the clipboard:
177: * a. CF_BITMAP only
178: * --------------
179: * case 1: Pasting to an icon or cursor
180: * * We don't have any screen color information.
181: * Make the mask bits opaque and blt. the bitmap to
182: * ghdcImage.
183: *
184: * case 2: Pasting to a bitmap
185: * * Blt the bitmap to the image DC.
186: *
187: * b. both ImagEdit and CF_BITMAP
188: * ---------------------------
189: * case 1: Pasting to an icon or cursor
190: * * Recover the image from the AND and screen color
191: * data (in ImagEdit) and the combined image bitmap
192: * (in CF_BITMAP). Use the information to make the
193: * neccessary changes if the screen viewing color was
194: * changed between Copy and Paste.
195: *
196: * case 2: Pasting to a bitmap
197: * * Blt the CF_BITMAP data to the image DC.
198: *
199: * If the destination image differs in dimensions from
200: * source image, the source image is stretched or clipped to that of
201: * destination, depending on preference
202: *
203: * History:
204: *
205: ************************************************************************/
206:
207: BOOL PasteImageClip(VOID)
208: {
209: HCURSOR hcurOld;
210: INT cxClip;
211: INT cyClip;
212: INT cxTarget;
213: INT cyTarget;
214: INT cxSource;
215: INT cySource;
216: DWORD rgbClipScreen;
217: BOOL fIEFormatFound;
218: HANDLE hClipData;
219: LPSTR lpClipData;
220: BITMAP bmClip;
221: HDC hdcClip;
222: HBITMAP hbmClip;
223: HBITMAP hbmClipOld;
224: HDC hdcClipAND;
225: HBITMAP hbmClipAND;
226: HBITMAP hbmClipANDOld;
227: HDC hdcClipAND16;
228: HBITMAP hbmClipAND16;
229: HBITMAP hbmClipAND16Old;
230: HDC hdcTarget;
231: HBITMAP hbmTarget;
232: HBITMAP hbmTargetOld;
233: HDC hdcTargetAND16;
234: HBITMAP hbmTargetAND16;
235: HBITMAP hbmTargetAND16Old;
236: HDC hdcTargetAND;
237: HBITMAP hbmTargetAND;
238: HBITMAP hbmTargetANDOld;
239:
240: hcurOld = SetCursor(hcurWait);
241:
242: if (!OpenClipboard(ghwndMain)) {
243: Message(MSG_NOCLIPBOARD);
244: goto Error1;
245: }
246:
247: if (!(hbmClip = GetClipboardData(CF_BITMAP))) {
248: Message(MSG_NOCLIPBOARDFORMAT);
249: goto Error2;
250: }
251:
252: GetObject(hbmClip, sizeof(BITMAP), (LPSTR)&bmClip);
253: cxClip = (INT)bmClip.bmWidth;
254: cyClip = (INT)bmClip.bmHeight;
255:
256: /*
257: * If the dimensions of the current pick rectangle don't match
258: * the bitmap being pasted, ask the user if they want to stretch
259: * or clip the pasted image.
260: */
261: cxTarget = gcxPick;
262: cyTarget = gcyPick;
263: cxSource = cxClip;
264: cySource = cyClip;
265: if (gcxPick != cxClip || gcyPick != cyClip) {
266: if (DlgBox(DID_PASTEOPTIONS, (WNDPROC)PasteOptionsDlgProc) == IDCANCEL) {
267: goto Error2;
268: }
269:
270: /*
271: * If clipping and the clipboard dimensions differ from the
272: * selected pick rectangle, then either the target dimensions
273: * or the source dimensions need to be sized down.
274: */
275: if (!fStretchClipboardData) {
276: if (cxClip < gcxPick)
277: cxTarget = cxClip;
278: else
279: cxSource = gcxPick;
280:
281: if (cyClip < gcyPick)
282: cyTarget = cyClip;
283: else
284: cySource = gcyPick;
285: }
286: }
287:
288: /*
289: * Update the undo buffer now that we are committed to the paste.
290: */
291: ImageUpdateUndo();
292:
293: /*
294: * Determine if the private ImagEdit clipboard format is available.
295: */
296: fIEFormatFound = IsClipboardFormatAvailable(ClipboardFormat);
297:
298: if (giType != FT_BITMAP && fIEFormatFound) {
299: /*
300: * Get the AND mask bitmap and the old screen color out of
301: * the private format.
302: */
303: hClipData = GetClipboardData(ClipboardFormat);
304: lpClipData = (LPSTR)GlobalLock(hClipData);
305: rgbClipScreen = *((DWORD FAR *)lpClipData);
306: hdcClipAND = CreateCompatibleDC(ghdcImage);
307: hbmClipAND = CreateBitmap(cxClip, cyClip, (BYTE)1, (BYTE)1,
308: (LPSTR)lpClipData + sizeof(DWORD));
309: hbmClipANDOld = SelectObject(hdcClipAND, hbmClipAND);
310:
311: /*
312: * Create a color bitmap for temporary use.
313: */
314: hdcClipAND16 = CreateCompatibleDC(ghdcImage);
315: hbmClipAND16 = MyCreateBitmap(ghdcImage, cxSource, cySource, 16);
316: hbmClipAND16Old = SelectObject(hdcClipAND16, hbmClipAND16);
317:
318: /*
319: * Blt the AND mask onto the color bitmap.
320: */
321: BitBlt(hdcClipAND16, 0, 0, cxSource, cySource, hdcClipAND,
322: 0, 0, SRCCOPY);
323:
324: /*
325: * Create the color target AND mask bitmap.
326: */
327: hdcTargetAND16 = CreateCompatibleDC(ghdcImage);
328: hbmTargetAND16 = MyCreateBitmap(ghdcImage, cxTarget, cyTarget, 16);
329: hbmTargetAND16Old = SelectObject(hdcTargetAND16, hbmTargetAND16);
330:
331: /*
332: * StretchBlt from the color AND mask bitmap to the color target
333: * AND mask bitmap. The blt must be done from a color bitmap to
334: * a color bitmap, and the stretch blt mode must be set to
335: * COLORONCOLOR. All this is necessary so that the AND mask
336: * stays exactly in sync with the stretch blt of the color
337: * (XOR) mask. If these steps are not done correctly, shrinking
338: * an image with screen colored pixels in it can cause problems,
339: * because the stretch blt will use a slightly different
340: * algorithm to compress the monochrome AND mask and the color
341: * XOR mask.
342: */
343: SetStretchBltMode(hdcTargetAND16, COLORONCOLOR);
344: SetStretchBltMode(hdcClipAND16, COLORONCOLOR); //
345: StretchBlt(hdcTargetAND16, 0, 0, cxTarget, cyTarget, hdcClipAND16,
346: 0, 0, cxSource, cySource, SRCCOPY);
347:
348: /*
349: * Create the monochrome target AND mask bitmap.
350: */
351: hdcTargetAND = CreateCompatibleDC(ghdcImage);
352: hbmTargetAND = MyCreateBitmap(ghdcImage, cxTarget, cyTarget, 2);
353: hbmTargetANDOld = SelectObject(hdcTargetAND, hbmTargetAND);
354:
355: /*
356: * Blt the color AND mask onto the monochrome AND mask.
357: * The monochrome AND mask is the one that we will use
358: * later. It must be monochrome or the ImageDCSeparate
359: * and ImageDCCombine functions will not work properly.
360: */
361: BitBlt(hdcTargetAND, 0, 0, cxTarget, cyTarget, hdcTargetAND16,
362: 0, 0, SRCCOPY);
363:
364: /*
365: * Cleanup.
366: */
367: SelectObject(hdcTargetAND16, hbmTargetAND16Old);
368: DeleteObject(hbmTargetAND16);
369: DeleteDC(hdcTargetAND16);
370: SelectObject(hdcClipAND16, hbmClipAND16Old);
371: DeleteObject(hbmClipAND16);
372: DeleteDC(hdcClipAND16);
373: SelectObject(hdcClipAND, hbmClipANDOld);
374: DeleteObject(hbmClipAND);
375: DeleteDC(hdcClipAND);
376: GlobalUnlock(hClipData);
377: }
378:
379: /*
380: * Get the clipboard bitmap into a DC.
381: */
382: hdcClip = CreateCompatibleDC(ghdcImage);
383: hbmClipOld = SelectObject(hdcClip, hbmClip);
384:
385: /*
386: * Create the target bitmap.
387: */
388: hdcTarget = CreateCompatibleDC(ghdcImage);
389: hbmTarget = MyCreateBitmap(ghdcImage, cxTarget, cyTarget, 16);
390: hbmTargetOld = SelectObject(hdcTarget, hbmTarget);
391:
392: /*
393: * StretchBlt the bitmap onto the target.
394: */
395: SetStretchBltMode(hdcTarget, COLORONCOLOR);
396: SetStretchBltMode(hdcClip, COLORONCOLOR); //
397: StretchBlt(hdcTarget, 0, 0, cxTarget, cyTarget, hdcClip, 0, 0,
398: cxSource, cySource, SRCCOPY);
399:
400: /*
401: * Handle some special cases.
402: */
403: if (giType == FT_BITMAP || !fIEFormatFound) {
404: /*
405: * The image we are pasting into is either a bitmap, or
406: * there does not exist an AND mask in the clipboard.
407: */
408: if (gnColors == 2) {
409: /*
410: * We are pasting to a mono image. We must convert the
411: * colors in the clipboard bitmap into monochrome.
412: */
413: ImageDCMonoBlt(hdcTarget, cxTarget, cyTarget);
414: }
415: }
416: else {
417: /*
418: * We are pasting into an icon or cursor image and we have
419: * available an AND mask. Is the current image monochrome?
420: */
421: if (gnColors == 2) {
422: /*
423: * Remove the old screen/inverse colors from the image,
424: * convert it to monochrome, then put back in the
425: * current screen/inverse colors.
426: */
427: ImageDCSeparate(hdcTarget, cxTarget, cyTarget, hdcTargetAND,
428: rgbClipScreen);
429: ImageDCMonoBlt(hdcTarget, cxTarget, cyTarget);
430: ImageDCCombine(hdcTarget, cxTarget, cyTarget, hdcTargetAND);
431: }
432: /*
433: * Does the screen color specified in the clipboard
434: * differ from the current screen color?
435: */
436: else if (rgbClipScreen != grgbScreen) {
437: /*
438: * Remove the old screen/inverse colors, then put back
439: * in the current ones.
440: */
441: ImageDCSeparate(hdcTarget, cxTarget, cyTarget, hdcTargetAND,
442: rgbClipScreen);
443: ImageDCCombine(hdcTarget, cxTarget, cyTarget, hdcTargetAND);
444: }
445: }
446:
447: /*
448: * Blt the clipboard image to the proper rectangle in the current image.
449: */
450: BitBlt(ghdcImage, grcPick.left, grcPick.top,
451: cxTarget, cyTarget, hdcTarget, 0, 0, SRCCOPY);
452:
453: /*
454: * If the current image is an icon or cursor, we must take care
455: * of the AND mask also.
456: */
457: if (giType != FT_BITMAP) {
458: /*
459: * Is there an AND mask in the clipboard to use?
460: */
461: if (fIEFormatFound) {
462: /*
463: * Blt it into the current image's AND mask.
464: */
465: BitBlt(ghdcANDMask, grcPick.left, grcPick.top,
466: cxTarget, cyTarget, hdcTargetAND, 0, 0, SRCCOPY);
467: }
468: else {
469: /*
470: * Make the AND mask opaque, because there is no
471: * screen color information.
472: */
473: PatBlt(ghdcANDMask, grcPick.left, grcPick.top,
474: cxTarget, cyTarget, BLACKNESS);
475: }
476: }
477:
478: /*
479: * Cleanup.
480: */
481: SelectObject(hdcTarget, hbmTargetOld);
482: DeleteObject(hbmTarget);
483: DeleteDC(hdcTarget);
484:
485: if (giType != FT_BITMAP && fIEFormatFound) {
486: SelectObject(hdcTargetAND, hbmTargetANDOld);
487: DeleteObject(hbmTargetAND);
488: DeleteDC(hdcTargetAND);
489: }
490:
491: SelectObject(hdcClip, hbmClipOld);
492: DeleteDC(hdcClip);
493:
494: CloseClipboard();
495:
496: /*
497: * Update the View and workspace windows.
498: */
499: ViewUpdate();
500:
501: /*
502: * Reset pick rectangle to cover entire image.
503: */
504: PickSetRect(0, 0, gcxImage - 1, gcyImage - 1);
505:
506: fImageDirty = TRUE;
507:
508: SetCursor(hcurOld);
509:
510: return TRUE;
511:
512: Error2:
513: CloseClipboard();
514:
515: Error1:
516: SetCursor(hcurOld);
517:
518: return FALSE;
519: }
520:
521:
522:
523: /************************************************************************
524: * PasteOptionsDlgProc
525: *
526: * Proc for the dialog that asks the user whether they want to clip
527: * or stretch the bitmap being pasted in.
528: *
529: * Upon return with an IDOK value, the fStretchClipboardData global
530: * will be TRUE if they want to stretch, or FALSE if they want to clip.
531: *
532: * History:
533: *
534: ************************************************************************/
535:
536: DIALOGPROC PasteOptionsDlgProc(
537: HWND hwnd,
538: UINT msg,
539: WPARAM wParam,
540: LPARAM lParam)
541: {
542: switch (msg) {
543: case WM_INITDIALOG:
544: CheckRadioButton(hwnd, DID_PASTEOPTIONSSTRETCH,
545: DID_PASTEOPTIONSCLIP,
546: fStretchClipboardData ?
547: DID_PASTEOPTIONSSTRETCH : DID_PASTEOPTIONSCLIP);
548:
549: CenterWindow(hwnd);
550:
551: break;
552:
553: case WM_COMMAND:
554: switch (LOWORD(wParam)) {
555: case IDOK :
556: if (IsDlgButtonChecked(hwnd, DID_PASTEOPTIONSSTRETCH))
557: fStretchClipboardData = TRUE;
558: else
559: fStretchClipboardData = FALSE;
560:
561: EndDialog(hwnd, IDOK);
562: break;
563:
564: case IDCANCEL:
565: EndDialog(hwnd, IDCANCEL);
566: break;
567:
568: case IDHELP:
569: WinHelp(ghwndMain, gszHelpFile, HELP_CONTEXT,
570: HELPID_PASTEOPTIONS);
571: break;
572: }
573:
574: break;
575:
576: default:
577: return FALSE;
578: }
579:
580: return TRUE;
581: }
582:
583:
584:
585: /************************************************************************
586: * PickSetRect
587: *
588: * Sets the globals for the picking rectangle size. This affects
589: * what is copied into the clipboard.
590: *
591: * Arguments:
592: *
593: * History:
594: *
595: ************************************************************************/
596:
597: VOID PickSetRect(
598: INT xLeft,
599: INT yTop,
600: INT xRight,
601: INT yBottom)
602: {
603: SetRect(&grcPick, xLeft, yTop, xRight, yBottom);
604: gcxPick = (grcPick.right - grcPick.left) + 1;
605: gcyPick = (grcPick.bottom - grcPick.top) + 1;
606: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.