![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pastespl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui|
Return to pastespl.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*
2: * PASTESPL.C
3: *
4: * Implements the OleUIPasteSpecial function which invokes the complete
5: * Paste Special dialog.
6: *
7: * Copyright (c)1992 Microsoft Corporation, All Rights Reserved
8: */
9:
10: #define STRICT 1
11: #include "ole2ui.h"
12: #include "pastespl.h"
13: #include "common.h"
14: #include "utility.h"
15: #include "resimage.h"
16: #include "iconbox.h"
17: #include "geticon.h"
18: #include "regdb.h"
19: #include <stdlib.h>
20:
21: OLEDBGDATA
22:
23: /*
24: * OleUIPasteSpecial
25: *
26: * Purpose:
27: * Invokes the standard OLE Paste Special dialog box which allows the user
28: * to select the format of the clipboard object to be pasted or paste linked.
29: *
30: * Parameters:
31: * lpPS LPOLEUIPasteSpecial pointing to the in-out structure
32: * for this dialog.
33: *
34: * Return Value:
35: * UINT One of the following codes or one of the standard error codes (OLEUI_ERR_*)
36: * defined in OLE2UI.H, indicating success or error:
37: * OLEUI_OK User selected OK
38: * OLEUI_CANCEL User cancelled the dialog
39: * OLEUI_IOERR_SRCDATAOBJECTINVALID lpSrcDataObject field of OLEUIPASTESPECIAL invalid
40: * OLEUI_IOERR_ARRPASTEENTRIESINVALID arrPasteEntries field of OLEUIPASTESPECIAL invalid
41: * OLEUI_IOERR_ARRLINKTYPESINVALID arrLinkTypes field of OLEUIPASTESPECIAL invalid
42: * OLEUI_PSERR_CLIPBOARDCHANGED Clipboard contents changed while dialog was up
43: */
44:
45: STDAPI_(UINT) OleUIPasteSpecial(LPOLEUIPASTESPECIAL lpPS)
46: {
47: UINT uRet;
48: HGLOBAL hMemDlg=NULL;
49:
50: uRet=UStandardValidation((LPOLEUISTANDARD)lpPS, sizeof(OLEUIPASTESPECIAL)
51: , &hMemDlg);
52:
53: if (uRet != OLEUI_SUCCESS)
54: return uRet;
55:
56: //Validate PasteSpecial specific fields
57: if (NULL == lpPS->lpSrcDataObj || IsBadReadPtr(lpPS->lpSrcDataObj, sizeof(IDataObject)))
58: uRet = OLEUI_IOERR_SRCDATAOBJECTINVALID;
59: if (NULL == lpPS->arrPasteEntries || IsBadReadPtr(lpPS->arrPasteEntries, sizeof(OLEUIPASTEENTRY)))
60: uRet = OLEUI_IOERR_ARRPASTEENTRIESINVALID;
61: if (NULL != lpPS->arrLinkTypes && IsBadReadPtr(lpPS->arrLinkTypes, sizeof(UINT)))
62: uRet = OLEUI_IOERR_ARRLINKTYPESINVALID;
63: if (uRet >= OLEUI_ERR_STANDARDMIN)
64: {
65: if (NULL != hMemDlg)
66: FreeResource(hMemDlg);
67: return uRet;
68: }
69:
70: //Now that we've validated everything, we can invoke the dialog.
71: uRet = UStandardInvocation(PasteSpecialDialogProc, (LPOLEUISTANDARD)lpPS
72: , hMemDlg, MAKEINTRESOURCE(IDD_PASTESPECIAL));
73:
74: /*
75: * IF YOU ARE CREATING ANYTHING BASED ON THE RESULTS, DO IT HERE.
76: */
77:
78: return uRet;
79: }
80:
81:
82: /*
83: * PasteSpecialDialogProc
84: *
85: * Purpose:
86: * Implements the OLE Paste Special dialog as invoked through the
87: * OleUIPasteSpecial function.
88: *
89: * Parameters:
90: * Standard
91: *
92: * Return Value:
93: * Standard
94: */
95:
96: BOOL CALLBACK EXPORT PasteSpecialDialogProc(HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
97: {
98: LPOLEUIPASTESPECIAL lpOPS;
99: LPPASTESPECIAL lpPS;
100: BOOL fHook=FALSE;
101: HCURSOR hCursorOld;
102:
103: //Declare Win16/Win32 compatible WM_COMMAND parameters.
104: COMMANDPARAMS(wID, wCode, hWndMsg);
105:
106: //This will fail under WM_INITDIALOG, where we allocate it.
107: lpPS=(LPPASTESPECIAL)LpvStandardEntry(hDlg, iMsg, wParam, lParam, &fHook);
108:
109: //If the hook processed the message, we're done.
110: if (0!=fHook)
111: return fHook;
112:
113: // Process help message from Change Icon
114: if (iMsg == uMsgHelp)
115: {
116: PostMessage(lpPS->lpOPS->hWndOwner, uMsgHelp, wParam, lParam);
117: return FALSE;
118: }
119:
120: //Process the temination message
121: if (iMsg==uMsgEndDialog)
122: {
123: HWND hwndNextViewer;
124:
125: // Free the icon/icon-title metafile corresponding to Paste/PasteList option which is not selected
126: if (lpPS->fLink)
127: OleUIMetafilePictIconFree(lpPS->hMetaPictOD);
128: else OleUIMetafilePictIconFree(lpPS->hMetaPictLSD);
129:
130: // Free data associated with each list box entry
131: FreeListData(GetDlgItem(hDlg, ID_PS_PASTELIST));
132: FreeListData(GetDlgItem(hDlg, ID_PS_PASTELINKLIST));
133:
134: //Free any specific allocations before calling StandardCleanup
135: if (lpPS->hObjDesc) GlobalFree(lpPS->hObjDesc);
136: if (lpPS->hLinkSrcDesc) GlobalFree(lpPS->hLinkSrcDesc);
137: if (lpPS->hBuff) GlobalFree(lpPS->hBuff);
138:
139: // Change the clipboard notification chain
140: hwndNextViewer = GetProp(hDlg, NEXTCBVIEWER);
141: if (hwndNextViewer != HWND_BROADCAST)
142: {
143: SetProp(hDlg, NEXTCBVIEWER, HWND_BROADCAST);
144: ChangeClipboardChain(hDlg, hwndNextViewer);
145: }
146: RemoveProp(hDlg, NEXTCBVIEWER);
147:
148: StandardCleanup(lpPS, hDlg);
149: EndDialog(hDlg, wParam);
150: return TRUE;
151: }
152:
153: switch (iMsg)
154: {
155: case WM_INITDIALOG:
156: hCursorOld = HourGlassOn();
157: FPasteSpecialInit(hDlg, wParam, lParam);
158: HourGlassOff(hCursorOld);
159: return TRUE;
160:
161: case WM_DRAWCLIPBOARD:
162: {
163: HWND hwndNextViewer = GetProp(hDlg, NEXTCBVIEWER);
164:
165: if (hwndNextViewer == HWND_BROADCAST)
166: break;
167:
168: if (hwndNextViewer)
169: {
170: SendMessage(hwndNextViewer, iMsg, wParam, lParam);
171: // Refresh next viewer in case it got modified
172: // by the SendMessage() (likely if multiple
173: // PasteSpecial dialogs are up simultaneously)
174: hwndNextViewer = GetProp(hDlg, NEXTCBVIEWER);
175: }
176: SetProp(hDlg, NEXTCBVIEWER, HWND_BROADCAST);
177: ChangeClipboardChain(hDlg, hwndNextViewer);
178: wParam = OLEUI_PSERR_CLIPBOARDCHANGED;
179: goto LCancel;
180: }
181:
182: case WM_CHANGECBCHAIN:
183: {
184: HWND hwndNextViewer = GetProp(hDlg, NEXTCBVIEWER);
185:
186: if (wParam == (WORD)hwndNextViewer)
187: SetProp(hDlg, NEXTCBVIEWER, (hwndNextViewer = (HWND)LOWORD(lParam)));
188: else if (hwndNextViewer && hwndNextViewer != HWND_BROADCAST)
189: SendMessage(hwndNextViewer, iMsg, wParam, lParam);
190: break;
191: }
192:
193: case WM_COMMAND:
194: switch (wID)
195: {
196: case ID_PS_PASTE:
197: FTogglePasteType(hDlg, lpPS, PSF_SELECTPASTE);
198: break;
199:
200: case ID_PS_PASTELINK:
201: FTogglePasteType(hDlg, lpPS, PSF_SELECTPASTELINK);
202: break;
203:
204: case ID_PS_DISPLAYLIST:
205: switch (wCode)
206: {
207: case LBN_SELCHANGE:
208: ChangeListSelection(hDlg, lpPS, hWndMsg);
209: break;
210:
211: case LBN_DBLCLK:
212: // Same as pressing OK
213: SendCommand(hDlg, IDOK, BN_CLICKED, hWndMsg);
214: break;
215: }
216: break;
217:
218: case ID_PS_DISPLAYASICON:
219: ToggleDisplayAsIcon(hDlg, lpPS);
220: break;
221:
222: case ID_PS_CHANGEICON:
223: ChangeIcon(hDlg, lpPS);
224: break;
225:
226: case IDOK:
227: lpOPS = lpPS->lpOPS;
228: // Return current flags
229: lpOPS->dwFlags = lpPS->dwFlags;
230: // Return index of arrPasteEntries[] corresponding to format selected by user
231: lpOPS->nSelectedIndex = lpPS->nSelectedIndex;
232: // Return if user selected Paste or PasteLink
233: lpOPS->fLink = lpPS->fLink;
234: // Return metafile with icon and icon title that the user selected
235: lpOPS->hMetaPict=(HGLOBAL)SendDlgItemMessage(hDlg, ID_PS_ICONDISPLAY,
236: IBXM_IMAGEGET, 0, 0L);
237: SendMessage(hDlg, uMsgEndDialog, OLEUI_OK, 0L);
238: break;
239:
240: case IDCANCEL:
241: wParam = OLEUI_CANCEL;
242: LCancel:
243: // Free icon and icon title metafile
244: SendDlgItemMessage(hDlg, ID_PS_ICONDISPLAY, IBXM_IMAGEFREE, 0, 0L);
245: SendMessage(hDlg, uMsgEndDialog, wParam, 0L);
246: break;
247:
248: case ID_OLEUIHELP:
249: PostMessage(lpPS->lpOPS->hWndOwner, uMsgHelp,
250: (WPARAM)hDlg, MAKELPARAM(IDD_PASTESPECIAL, 0));
251: break;
252: }
253: break;
254: }
255: return FALSE;
256: }
257:
258:
259: /*
260: * FPasteSpecialInit
261: *
262: * Purpose:
263: * WM_INITIDIALOG handler for the Paste Special dialog box.
264: *
265: * Parameters:
266: * hDlg HWND of the dialog
267: * wParam WPARAM of the message
268: * lParam LPARAM of the message
269: *
270: * Return Value:
271: * BOOL Value to return for WM_INITDIALOG.
272: */
273:
274: BOOL FPasteSpecialInit(HWND hDlg, WPARAM wParam, LPARAM lParam)
275: {
276: LPPASTESPECIAL lpPS;
277: LPOLEUIPASTESPECIAL lpOPS;
278: HFONT hFont;
279: BOOL fPasteAvailable, fPasteLinkAvailable;
280: STGMEDIUM medium;
281: LPOBJECTDESCRIPTOR lpOD;
282: LPLINKSRCDESCRIPTOR lpLSD;
283: int n;
284: CLIPFORMAT cfFormat;
285:
286: // Copy the structure at lParam into our instance memory.
287: lpPS = (LPPASTESPECIAL)LpvStandardInit(hDlg, sizeof(PASTESPECIAL), TRUE, &hFont);
288:
289: // PvStandardInit sent a termination to us already.
290: if (NULL == lpPS)
291: return FALSE;
292:
293: lpOPS=(LPOLEUIPASTESPECIAL)lParam;
294:
295: // Copy other information from lpOPS that we might modify.
296: lpPS->lpOPS = lpOPS;
297: lpPS->dwFlags = lpOPS->dwFlags;
298:
299: // Initialize user selections in the Paste and PasteLink listboxes
300: lpPS->nPasteListCurSel = 0;
301: lpPS->nPasteLinkListCurSel = 0;
302:
303: // If we got a font, send it to the necessary controls.
304: if (NULL!=hFont)
305: {
306: SendDlgItemMessage(hDlg, ID_PS_SOURCETEXT, WM_SETFONT, (WPARAM)hFont, 0L);
307: SendDlgItemMessage(hDlg, ID_PS_RESULTTEXT, WM_SETFONT, (WPARAM)hFont, 0L);
308: }
309:
310: // Hide the help button if required
311: if (!(lpPS->lpOPS->dwFlags & PSF_SHOWHELP))
312: StandardShowDlgItem(hDlg, ID_OLEUIHELP, SW_HIDE);
313:
314: // PSF_CHECKDISPLAYASICON is an OUT flag. Clear it if has been set on the way in.
315: lpPS->dwFlags = lpPS->dwFlags & ~PSF_CHECKDISPLAYASICON;
316:
317: // Change the caption if required
318: if (NULL != lpOPS->lpszCaption)
319: SetWindowText(hDlg, lpOPS->lpszCaption);
320:
321: // Load 'Unknown Source' and 'Unknown Type' strings
322: n = LoadString(ghInst, IDS_PSUNKNOWNTYPE, lpPS->szUnknownType, PS_UNKNOWNSTRLEN);
323: if (n)
324: n = LoadString(ghInst, IDS_PSUNKNOWNSRC, lpPS->szUnknownSource, PS_UNKNOWNSTRLEN);
325: if (!n)
326: {
327: PostMessage(hDlg, uMsgEndDialog, OLEUI_ERR_LOADSTRING, 0L);
328: return FALSE;
329: }
330: lpPS->szAppName[0]='\0';
331:
332: // GetData CF_OBJECTDESCRIPTOR. If the object on the clipboard in an OLE1 object (offering CF_OWNERLINK)
333: // or has been copied to clipboard by FileMaager (offering CF_FILENAME), an OBJECTDESCRIPTOR will be
334: // created will be created from CF_OWNERLINK or CF_FILENAME. See OBJECTDESCRIPTOR for more info.
335:
336: if (lpPS->hObjDesc = OleStdFillObjectDescriptorFromData(lpOPS->lpSrcDataObj, &medium, &cfFormat))
337: {
338: lpOD = GlobalLock(lpPS->hObjDesc);
339:
340: // Get FullUserTypeName, SourceOfCopy and CLSID
341: if (lpOD->dwFullUserTypeName)
342: lpPS->szFullUserTypeNameOD = (LPSTR)lpOD+lpOD->dwFullUserTypeName;
343: else lpPS->szFullUserTypeNameOD = lpPS->szUnknownType;
344:
345: if (lpOD->dwSrcOfCopy)
346: {
347: lpPS->szSourceOfDataOD = (LPSTR)lpOD+lpOD->dwSrcOfCopy;
348: // If CF_FILENAME was offered, source of copy is a path name. Fit the path to the
349: // static control that will display it.
350: if (cfFormat == cfFileName)
351: lpPS->szSourceOfDataOD = ChopText(GetDlgItem(hDlg, ID_PS_SOURCETEXT), 0, lpPS->szSourceOfDataOD);
352: }
353: else lpPS->szSourceOfDataOD = lpPS->szUnknownSource;
354:
355: lpPS->clsidOD = lpOD->clsid;
356:
357: // Does source specify DVASPECT_ICON?
358: if (lpOD->dwDrawAspect & DVASPECT_ICON)
359: lpPS->fSrcAspectIconOD = TRUE;
360: else lpPS->fSrcAspectIconOD = FALSE;
361:
362: // Does source specify OLEMISC_ONLYICONIC?
363: if (lpOD->dwStatus & OLEMISC_ONLYICONIC)
364: lpPS->fSrcOnlyIconicOD = TRUE;
365: else lpPS->fSrcOnlyIconicOD = FALSE;
366:
367: // Get application name of source from auxusertype3 in the registration database
368: if (0==OleStdGetAuxUserType(&lpPS->clsidOD, 3, lpPS->szAppName, OLEUI_CCHKEYMAX, NULL))
369: {
370: // Use "the application which created it" as the name of the application
371: if (0==LoadString(ghInst, IDS_PSUNKNOWNAPP, lpPS->szAppName, PS_UNKNOWNSTRLEN))
372: {
373: PostMessage(hDlg, uMsgEndDialog, OLEUI_ERR_LOADSTRING, 0L);
374: return FALSE;
375: }
376: }
377:
378: // Retrieve an icon from the object
379: if (lpPS->fSrcAspectIconOD)
380: {
381: lpPS->hMetaPictOD = OleStdGetData(
382: lpOPS->lpSrcDataObj,
383: CF_METAFILEPICT,
384: NULL,
385: DVASPECT_ICON,
386: &medium
387: );
388:
389: }
390: // If object does not offer icon, obtain it from the CLSID
391: if (NULL == lpPS->hMetaPictOD)
392: {
393: lpPS->hMetaPictOD = GetIconOfClass(
394: ghInst,
395: &lpPS->clsidOD,
396: NULL,
397: TRUE // Use the short user type name (auxusertype3)
398: );
399:
400:
401: }
402: }
403:
404: // Does object offer CF_LINKSRCDESCRIPTOR?
405: if (lpPS->hLinkSrcDesc = OleStdGetData(
406: lpOPS->lpSrcDataObj,
407: cfLinkSrcDescriptor,
408: NULL,
409: DVASPECT_CONTENT,
410: &medium))
411: {
412: // Get FullUserTypeName, SourceOfCopy and CLSID
413: lpLSD = GlobalLock(lpPS->hLinkSrcDesc);
414: if (lpLSD->dwFullUserTypeName)
415: lpPS->szFullUserTypeNameLSD = (LPSTR)lpLSD+lpLSD->dwFullUserTypeName;
416: else lpPS->szFullUserTypeNameLSD = lpPS->szUnknownType;
417:
418: if (lpLSD->dwSrcOfCopy)
419: lpPS->szSourceOfDataLSD = (LPSTR)lpLSD+lpLSD->dwSrcOfCopy;
420: else lpPS->szSourceOfDataLSD = lpPS->szUnknownSource;
421:
422: lpPS->clsidLSD = lpLSD->clsid;
423:
424: // Does source specify DVASPECT_ICON?
425: if (lpOD->dwDrawAspect & DVASPECT_ICON)
426: lpPS->fSrcAspectIconLSD = TRUE;
427: else lpPS->fSrcAspectIconLSD = FALSE;
428:
429: // Does source specify OLEMISC_ONLYICONIC?
430: if (lpLSD->dwStatus & OLEMISC_ONLYICONIC)
431: lpPS->fSrcOnlyIconicLSD = TRUE;
432: else lpPS->fSrcOnlyIconicLSD = FALSE;
433:
434: // Retrieve an icon from the object
435: if (lpPS->fSrcAspectIconLSD)
436: {
437: lpPS->hMetaPictLSD = OleStdGetData(
438: lpOPS->lpSrcDataObj,
439: CF_METAFILEPICT,
440: NULL,
441: DVASPECT_ICON,
442: &medium
443: );
444:
445: }
446: // If object does not offer icon, obtain it from the CLSID
447: if (NULL == lpPS->hMetaPictLSD)
448: {
449: char szLabel[OLEUI_CCHLABELMAX];
450: HWND hIconWnd;
451: RECT IconRect;
452: int nWidth;
453: LPSTR lpszLabel;
454:
455: hIconWnd = GetDlgItem(hDlg, ID_PS_ICONDISPLAY);
456:
457: GetClientRect(hIconWnd, &IconRect);
458:
459: nWidth = (IconRect.right * 3) / 2; // width is 1.5 times width of iconbox
460:
461: lstrcpyn(szLabel, lpPS->szSourceOfDataLSD, sizeof(szLabel));
462: szLabel[sizeof(szLabel)-1] = '\0';
463:
464: lpszLabel = ChopText(hIconWnd, nWidth, (LPSTR)szLabel);
465:
466: lpPS->hMetaPictLSD = GetIconOfClass(
467: ghInst,
468: &lpPS->clsidLSD,
469: lpszLabel, // use chopped source string as label
470: FALSE // not applicable
471: );
472: }
473: }
474: else if (lpPS->hObjDesc) // Does not offer CF_LINKSRCDESCRIPTOR but offers CF_OBJECTDESCRIPTOR
475: {
476: // Copy the values of OBJECTDESCRIPTOR
477: lpPS->szFullUserTypeNameLSD = lpPS->szFullUserTypeNameOD;
478: lpPS->szSourceOfDataLSD = lpPS->szSourceOfDataOD;
479: lpPS->clsidLSD = lpPS->clsidOD;
480: lpPS->fSrcAspectIconLSD = lpPS->fSrcAspectIconOD;
481: lpPS->fSrcOnlyIconicLSD = lpPS->fSrcOnlyIconicOD;
482:
483: // Don't copy the hMetaPict; instead get a separate copy
484: if (lpPS->fSrcAspectIconLSD)
485: {
486: lpPS->hMetaPictLSD = OleStdGetData(
487: lpOPS->lpSrcDataObj,
488: CF_METAFILEPICT,
489: NULL,
490: DVASPECT_ICON,
491: &medium
492: );
493: }
494: if (NULL == lpPS->hMetaPictLSD)
495: {
496: char szLabel[OLEUI_CCHLABELMAX];
497: HWND hIconWnd;
498: RECT IconRect;
499: int nWidth;
500: LPSTR lpszLabel;
501:
502: hIconWnd = GetDlgItem(hDlg, ID_PS_ICONDISPLAY);
503:
504: GetClientRect(hIconWnd, &IconRect);
505:
506: nWidth = (IconRect.right * 3) / 2; // width is 1.5 times width of iconbox
507:
508: lstrcpyn(szLabel, lpPS->szSourceOfDataLSD, sizeof(szLabel));
509: szLabel[sizeof(szLabel)-1] = '\0';
510:
511: lpszLabel = ChopText(hIconWnd, nWidth, (LPSTR)szLabel);
512:
513: lpPS->hMetaPictLSD = GetIconOfClass(
514: ghInst,
515: &lpPS->clsidLSD,
516: lpszLabel, // Use chopped source string as label
517: FALSE // Not applicable
518: );
519: }
520: }
521:
522: // Not an OLE object
523: if (lpPS->hObjDesc == NULL && lpPS->hLinkSrcDesc == NULL)
524: {
525: lpPS->szFullUserTypeNameLSD = lpPS->szFullUserTypeNameOD = lpPS->szUnknownType;
526: lpPS->szSourceOfDataLSD = lpPS->szSourceOfDataOD = lpPS->szUnknownSource;
527: lpPS->hMetaPictLSD = lpPS->hMetaPictOD = NULL;
528: }
529:
530: // Allocate scratch memory to construct item names in the paste and pastelink listboxes
531: lpPS->hBuff = AllocateScratchMem(lpPS);
532: if (lpPS->hBuff == NULL)
533: {
534: PostMessage(hDlg, uMsgEndDialog, OLEUI_ERR_GLOBALMEMALLOC, 0L);
535: return FALSE;
536: }
537:
538: // Select the Paste Link Button if specified. Otherwise select
539: // Paste Button by default
540: if (lpPS->dwFlags & PSF_SELECTPASTELINK)
541: lpPS->dwFlags = (lpPS->dwFlags & ~PSF_SELECTPASTE) | PSF_SELECTPASTELINK;
542: else
543: lpPS->dwFlags =(lpPS->dwFlags & ~PSF_SELECTPASTELINK) | PSF_SELECTPASTE;
544:
545: // Mark which PasteEntry formats are available from source data object
546: OleStdMarkPasteEntryList(
547: lpOPS->lpSrcDataObj,lpOPS->arrPasteEntries,lpOPS->cPasteEntries);
548:
549: // Check if items are available to be pasted
550: fPasteAvailable = FFillPasteList(hDlg, lpPS);
551: if (!fPasteAvailable)
552: {
553: lpPS->dwFlags &= ~PSF_SELECTPASTE;
554: EnableWindow(GetDlgItem(hDlg, ID_PS_PASTE), FALSE);
555: }
556:
557: // Check if items are available to be paste-linked
558: fPasteLinkAvailable = FFillPasteLinkList(hDlg, lpPS);
559: if (!fPasteLinkAvailable)
560: {
561: lpPS->dwFlags &= ~PSF_SELECTPASTELINK;
562: EnableWindow(GetDlgItem(hDlg, ID_PS_PASTELINK), FALSE);
563: }
564:
565: // If one of Paste or PasteLink is disabled, select the other one regardless of what
566: // the input flags say
567: if (fPasteAvailable && !fPasteLinkAvailable)
568: lpPS->dwFlags |= PSF_SELECTPASTE;
569: if (fPasteLinkAvailable && !fPasteAvailable)
570: lpPS->dwFlags |= PSF_SELECTPASTELINK;
571:
572: if (lpPS->dwFlags & PSF_SELECTPASTE)
573: {
574: // FTogglePaste will set the PSF_SELECTPASTE flag, so clear it.
575: lpPS->dwFlags &= ~PSF_SELECTPASTE;
576: CheckRadioButton(hDlg, ID_PS_PASTE, ID_PS_PASTELINK, ID_PS_PASTE);
577: FTogglePasteType(hDlg, lpPS, PSF_SELECTPASTE);
578: }
579: else if (lpPS->dwFlags & PSF_SELECTPASTELINK)
580: {
581: // FTogglePaste will set the PSF_SELECTPASTELINK flag, so clear it.
582: lpPS->dwFlags &= ~PSF_SELECTPASTELINK;
583: CheckRadioButton(hDlg, ID_PS_PASTE, ID_PS_PASTELINK, ID_PS_PASTELINK);
584: FTogglePasteType(hDlg, lpPS, PSF_SELECTPASTELINK);
585: }
586: else // Items are not available to be be Pasted or Paste-Linked
587: {
588: // Enable or disable DisplayAsIcon and set the result text and image
589: EnableDisplayAsIcon(hDlg, lpPS);
590: SetPasteSpecialHelpResults(hDlg, lpPS);
591: }
592:
593: // Set property to handle clipboard change notifications
594: SetProp(hDlg, NEXTCBVIEWER, HWND_BROADCAST);
595: SetProp(hDlg, NEXTCBVIEWER, SetClipboardViewer(hDlg));
596:
597: /*
598: * PERFORM OTHER INITIALIZATION HERE.
599: */
600:
601: // Call the hook with lCustData in lParam
602: UStandardHook(lpPS, hDlg, WM_INITDIALOG, wParam, lpOPS->lCustData);
603: return TRUE;
604: }
605:
606: /*
607: * FTogglePasteType
608: *
609: * Purpose:
610: * Toggles between Paste and Paste Link. The Paste list and PasteLink
611: * list are always invisible. The Display List is filled from either
612: * the Paste list or the PasteLink list depending on which Paste radio
613: * button is selected.
614: *
615: * Parameters:
616: * hDlg HWND of the dialog
617: * lpPS Paste Special Dialog Structure
618: * dwOption Paste or PasteSpecial option
619: *
620: * Return Value:
621: * BOOL Returns TRUE if the option has already been selected.
622: * Otherwise the option is selected and FALSE is returned
623: */
624:
625: BOOL FTogglePasteType(HWND hDlg, LPPASTESPECIAL lpPS, DWORD dwOption)
626: {
627: DWORD dwTemp;
628: HWND hList, hListDisplay;
629: DWORD dwData;
630: int i, nItems;
631: LPSTR lpsz;
632:
633: // Skip all this if the button is already selected
634: if (lpPS->dwFlags & dwOption)
635: return TRUE;
636:
637: dwTemp = PSF_SELECTPASTE | PSF_SELECTPASTELINK;
638: lpPS->dwFlags = (lpPS->dwFlags & ~dwTemp) | dwOption;
639:
640: // Hide IconDisplay. This prevents flashing if the icon display is changed
641: StandardShowDlgItem(hDlg, ID_PS_ICONDISPLAY, SW_HIDE);
642:
643: hListDisplay = GetDlgItem(hDlg, ID_PS_DISPLAYLIST);
644:
645: // If Paste was selected
646: if (lpPS->dwFlags & PSF_SELECTPASTE)
647: {
648: // Set the Source of the object in the clipboard
649: SetDlgItemText(hDlg, ID_PS_SOURCETEXT, lpPS->szSourceOfDataOD);
650:
651: // If an icon is available
652: if (lpPS->hMetaPictOD)
653: // Set the icon display
654: SendDlgItemMessage(hDlg, ID_PS_ICONDISPLAY, IBXM_IMAGESET,
655: (WPARAM)lpPS->hMetaPictOD, 0L);
656:
657:
658: hList = GetDlgItem(hDlg, ID_PS_PASTELIST);
659: // We are switching from PasteLink to Paste. Remember current selection
660: // in PasteLink list so it can be restored.
661: lpPS->nPasteLinkListCurSel = (int)SendMessage(hListDisplay, LB_GETCURSEL, 0, 0L);
662: if (lpPS->nPasteLinkListCurSel == LB_ERR)
663: lpPS->nPasteLinkListCurSel = 0;
664: // Remember if user selected Paste or PasteLink
665: lpPS->fLink = FALSE;
666: }
667: else // If PasteLink was selected
668: {
669: // Set the Source of the object in the clipboard
670: SetDlgItemText(hDlg, ID_PS_SOURCETEXT, lpPS->szSourceOfDataLSD);
671:
672: // If an icon is available
673: if (lpPS->hMetaPictLSD)
674: // Set the icon display
675: SendDlgItemMessage(hDlg, ID_PS_ICONDISPLAY, IBXM_IMAGESET,
676: (WPARAM)lpPS->hMetaPictLSD, 0L);
677:
678:
679: hList = GetDlgItem(hDlg, ID_PS_PASTELINKLIST);
680: // We are switching from Paste to PasteLink. Remember current selection
681: // in Paste list so it can be restored.
682: lpPS->nPasteListCurSel = (int)SendMessage(hListDisplay, LB_GETCURSEL, 0, 0L);
683: if (lpPS->nPasteListCurSel == LB_ERR)
684: lpPS->nPasteListCurSel = 0;
685: // Remember if user selected Paste or PasteLink
686: lpPS->fLink = TRUE;
687: }
688:
689: // Turn drawing off while the Display List is being filled
690: SendMessage(hListDisplay, WM_SETREDRAW, (WPARAM)FALSE, 0L);
691:
692: // Move data to Display list box
693: SendMessage(hListDisplay, LB_RESETCONTENT, 0, 0L);
694: nItems = (int) SendMessage(hList, LB_GETCOUNT, 0, 0L);
695: lpsz = (LPSTR)GlobalLock(lpPS->hBuff);
696: for (i = 0; i < nItems; i++)
697: {
698: SendMessage(hList, LB_GETTEXT, (WPARAM)i, (LPARAM)lpsz);
699: dwData = SendMessage(hList, LB_GETITEMDATA, (WPARAM)i, 0L);
700: SendMessage(hListDisplay, LB_INSERTSTRING, (WPARAM)i, (LPARAM)lpsz);
701: SendMessage(hListDisplay, LB_SETITEMDATA, (WPARAM)i, dwData);
702: }
703: GlobalUnlock(lpPS->hBuff);
704:
705: // Restore the selection in the Display List from user's last selection
706: if (lpPS->dwFlags & PSF_SELECTPASTE)
707: SendMessage(hListDisplay, LB_SETCURSEL, lpPS->nPasteListCurSel, 0L);
708: else
709: SendMessage(hListDisplay, LB_SETCURSEL, lpPS->nPasteLinkListCurSel, 0L);
710:
711: // Paint Display List
712: SendMessage(hListDisplay, WM_SETREDRAW, (WPARAM)TRUE, 0L);
713: InvalidateRect(hListDisplay, NULL, TRUE);
714: UpdateWindow(hListDisplay);
715:
716: // Enable/Disable DisplayAsIcon and set the help result text and bitmap corresponding to
717: // the current selection
718: ChangeListSelection(hDlg, lpPS, hListDisplay);
719:
720: return FALSE;
721: }
722:
723:
724: /*
725: * ChangeListSelection
726: *
727: * Purpose:
728: * When the user changes the selection in the list, DisplayAsIcon is enabled or disabled,
729: * Result text and bitmap are updated and the index of the arrPasteEntries[] corresponding
730: * to the current format selection is saved.
731: *
732: * Parameters:
733: * hDlg HWND of the dialog
734: * lpPS Paste Special Dialog Structure
735: * hList HWND of the List
736: *
737: * Return Value:
738: * No return value
739: */
740:
741: void ChangeListSelection(HWND hDlg, LPPASTESPECIAL lpPS, HWND hList)
742: {
743: LPPASTELISTITEMDATA lpItemData;
744: int nCurSel;
745:
746: EnableDisplayAsIcon(hDlg, lpPS);
747: SetPasteSpecialHelpResults(hDlg, lpPS);
748:
749: // Remember index of arrPasteEntries[] corresponding to the current selection
750: nCurSel = (int)SendMessage(hList, LB_GETCURSEL, 0, 0L);
751: if (nCurSel == LB_ERR) return;
752: lpItemData = (LPPASTELISTITEMDATA) SendMessage(hList, LB_GETITEMDATA,
753: (WPARAM)nCurSel, 0L);
754: if ((LRESULT)lpItemData == LB_ERR) return;
755: lpPS->nSelectedIndex = lpItemData->nPasteEntriesIndex;
756: }
757:
758: /*
759: * EnableDisplayAsIcon
760: *
761: * Purpose:
762: * Enable or disable the DisplayAsIcon button depending on whether
763: * the current selection can be displayed as an icon or not. The following table describes
764: * the state of DisplayAsIcon. The calling application is termed CONTAINER, the source
765: * of data on the clipboard is termed SOURCE.
766: * Y = Yes; N = No; Blank = State does not matter;
767: * =====================================================================
768: * SOURCE SOURCE CONTAINER DisplayAsIcon
769: * specifies specifies specifies Initial State
770: * DVASPECT_ICON OLEMISC_ONLYICONIC OLEUIPASTE_ENABLEICON
771: *
772: * N Unchecked&Disabled
773: * Y Y Checked&Disabled
774: * Y N Y Checked&Enabled
775: * N N Y Unchecked&Enabled
776: * =====================================================================
777: *
778: * Parameters:
779: * hDlg HWND of the dialog
780: * lpPS Paste Special Dialog Structure
781: *
782: * Return Value:
783: * No return value
784: */
785:
786: void EnableDisplayAsIcon(HWND hDlg, LPPASTESPECIAL lpPS)
787: {
788: int nIndex;
789: BOOL fCntrEnableIcon;
790: BOOL fSrcOnlyIconic = (lpPS->fLink) ? lpPS->fSrcOnlyIconicLSD : lpPS->fSrcOnlyIconicOD;
791: BOOL fSrcAspectIcon = (lpPS->fLink) ? lpPS->fSrcAspectIconLSD : lpPS->fSrcAspectIconOD;
792: HWND hList;
793: LPPASTELISTITEMDATA lpItemData;
794: HGLOBAL hMetaPict = (lpPS->fLink) ? lpPS->hMetaPictLSD : lpPS->hMetaPictOD;
795:
796: hList = GetDlgItem(hDlg, ID_PS_DISPLAYLIST);
797:
798: // Get data corresponding to the current selection in the listbox
799: nIndex = (int)SendMessage(hList, LB_GETCURSEL, 0, 0);
800: if (nIndex != LB_ERR)
801: {
802: lpItemData = (LPPASTELISTITEMDATA) SendMessage(hList, LB_GETITEMDATA, (WPARAM)nIndex, 0L);
803: if ((LRESULT)lpItemData != LB_ERR)
804: fCntrEnableIcon = lpItemData->fCntrEnableIcon;
805: else fCntrEnableIcon = FALSE;
806: }
807: else fCntrEnableIcon = FALSE;
808:
809: // If there is an icon available
810: if (hMetaPict != NULL)
811: {
812: if (!fCntrEnableIcon) // Does CONTAINER specify OLEUIPASTE_ENABLEICON?
813: {
814: // Uncheck & Disable DisplayAsIcon
815: lpPS->dwFlags &= ~PSF_CHECKDISPLAYASICON;
816: CheckDlgButton(hDlg, ID_PS_DISPLAYASICON, FALSE);
817: EnableWindow(GetDlgItem(hDlg, ID_PS_DISPLAYASICON), FALSE);
818:
819: // Hide IconDisplay and ChangeIcon button
820: StandardShowDlgItem(hDlg, ID_PS_ICONDISPLAY, SW_HIDE);
821: StandardShowDlgItem(hDlg, ID_PS_CHANGEICON, SW_HIDE);
822: }
823: else if (fSrcOnlyIconic) // Does SOURCE specify OLEMISC_ONLYICONIC?
824: {
825: // Check & Disable DisplayAsIcon
826: lpPS->dwFlags |= PSF_CHECKDISPLAYASICON;
827: CheckDlgButton(hDlg, ID_PS_DISPLAYASICON, TRUE);
828: EnableWindow(GetDlgItem(hDlg, ID_PS_DISPLAYASICON), FALSE);
829:
830: // Show IconDisplay and ChangeIcon button
831: StandardShowDlgItem(hDlg, ID_PS_ICONDISPLAY, SW_SHOWNORMAL);
832: StandardShowDlgItem(hDlg, ID_PS_CHANGEICON, SW_SHOWNORMAL);
833: }
834: else if (fSrcAspectIcon) // Does SOURCE specify DVASPECT_ICON?
835: {
836: // Check & Enable DisplayAsIcon
837: lpPS->dwFlags |= PSF_CHECKDISPLAYASICON;
838: CheckDlgButton(hDlg, ID_PS_DISPLAYASICON, TRUE);
839: EnableWindow(GetDlgItem(hDlg, ID_PS_DISPLAYASICON), TRUE);
840:
841: // Show IconDisplay and ChangeIcon button
842: StandardShowDlgItem(hDlg, ID_PS_ICONDISPLAY, SW_SHOWNORMAL);
843: StandardShowDlgItem(hDlg, ID_PS_CHANGEICON, SW_SHOWNORMAL);
844: }
845: else
846: {
847: //Uncheck and Enable DisplayAsIcon
848: lpPS->dwFlags &= ~PSF_CHECKDISPLAYASICON;
849: CheckDlgButton(hDlg, ID_PS_DISPLAYASICON, FALSE);
850: EnableWindow(GetDlgItem(hDlg, ID_PS_DISPLAYASICON), TRUE);
851:
852: // Hide IconDisplay and ChangeIcon button
853: StandardShowDlgItem(hDlg, ID_PS_ICONDISPLAY, SW_HIDE);
854: StandardShowDlgItem(hDlg, ID_PS_CHANGEICON, SW_HIDE);
855:
856: }
857: }
858: else // No icon available
859: {
860: // Unchecked & Disabled
861: lpPS->dwFlags &= ~PSF_CHECKDISPLAYASICON;
862: CheckDlgButton(hDlg, ID_PS_DISPLAYASICON, FALSE);
863: EnableWindow(GetDlgItem(hDlg, ID_PS_DISPLAYASICON), FALSE);
864:
865: // Hide IconDisplay and ChangeIcon button
866: StandardShowDlgItem(hDlg, ID_PS_ICONDISPLAY, SW_HIDE);
867: StandardShowDlgItem(hDlg, ID_PS_CHANGEICON, SW_HIDE);
868: }
869: }
870:
871: /*
872: * ToggleDisplayAsIcon
873: *
874: * Purpose:
875: * Toggles the DisplayAsIcon button. Hides or shows the Icon Display and
876: * the ChangeIcon button and changes the help result text and bitmap.
877: *
878: * Parameters:
879: * hDlg HWND of the dialog
880: * lpPS Paste Special Dialog Structure
881: *
882: * Return Value:
883: * None
884: *
885: */
886:
887: void ToggleDisplayAsIcon(HWND hDlg, LPPASTESPECIAL lpPS)
888: {
889: BOOL fCheck;
890: int i;
891:
892: fCheck = IsDlgButtonChecked(hDlg, ID_PS_DISPLAYASICON);
893:
894: if (fCheck)
895: lpPS->dwFlags |= PSF_CHECKDISPLAYASICON;
896: else lpPS->dwFlags &= ~PSF_CHECKDISPLAYASICON;
897:
898: // Set the help result text and bitmap
899: SetPasteSpecialHelpResults(hDlg, lpPS);
900:
901: // Show or hide the Icon Display and ChangeIcon button depending
902: // on the check state
903: i = (fCheck) ? SW_SHOWNORMAL : SW_HIDE;
904: StandardShowDlgItem(hDlg, ID_PS_ICONDISPLAY, i);
905: StandardShowDlgItem(hDlg, ID_PS_CHANGEICON, i);
906: }
907:
908: /*
909: * ChangeIcon
910: *
911: * Purpose:
912: * Brings up the ChangeIcon dialog which allows the user to change
913: * the icon and label.
914: *
915: * Parameters:
916: * hDlg HWND of the dialog
917: * lpPS Paste Special Dialog Structure
918: *
919: * Return Value:
920: * None
921: *
922: */
923:
924: void ChangeIcon(HWND hDlg, LPPASTESPECIAL lpPS)
925: {
926: OLEUICHANGEICON ci;
927: UINT uRet;
928: CLSID clsid = (lpPS->fLink) ? lpPS->clsidLSD : lpPS->clsidOD;
929:
930: //Initialize the structure
931: _fmemset((LPOLEUICHANGEICON)&ci, 0, sizeof(ci));
932:
933: ci.hMetaPict = (HGLOBAL)SendDlgItemMessage(hDlg, ID_PS_ICONDISPLAY, IBXM_IMAGEGET, 0, 0L);
934: ci.cbStruct = sizeof(ci);
935: ci.hWndOwner = hDlg;
936: ci.clsid = clsid;
937: ci.dwFlags = CIF_SELECTCURRENT;
938:
939: // Only show help in the ChangeIcon dialog if we're showing it in this dialog.
940: if (lpPS->dwFlags & PSF_SHOWHELP)
941: ci.dwFlags = CIF_SHOWHELP;
942:
943: // Let the hook in to customize Change Icon if desired.
944: uRet = UStandardHook(lpPS, hDlg, uMsgChangeIcon, 0, (LONG)(LPSTR)&ci);
945:
946: if (0 == uRet)
947: uRet=(UINT)(OLEUI_OK==OleUIChangeIcon(&ci));
948:
949: // Update the display if necessary.
950: if (0!=uRet)
951: {
952: /*
953: * OleUIChangeIcon will have already freed our
954: * current hMetaPict that we passed in when OK is
955: * pressed in that dialog. So we use 0L as lParam
956: * here so the IconBox doesn't try to free the
957: * metafilepict again.
958: */
959: SendDlgItemMessage(hDlg, ID_PS_ICONDISPLAY, IBXM_IMAGESET, (WPARAM)ci.hMetaPict, 0L);
960: // Remember the new icon chosen by the user. Note that Paste and PasteLink have separate
961: // icons - changing one does not change the other.
962: if (lpPS->fLink)
963: lpPS->hMetaPictLSD = ci.hMetaPict;
964: else lpPS->hMetaPictOD = ci.hMetaPict;
965: }
966: }
967:
968: /*
969: *SetPasteSpecialHelpResults
970: *
971: * Purpose:
972: * Sets the help result text and bitmap according to the current
973: * list selection. The following state table indicates which ResultText
974: * and ResultImage are selected. If %s in the lpstrFormatName is present,
975: * it is assumed that an object is being pasted/paste-linked, otherwise it
976: * is assumed that data is being pasted/paste-linked.
977: * Y = Yes; N = No; Blank = State does not matter;
978: * The numbers in the the ResultText and ResultImage columns refer to the table
979: * entries that follow.
980: * =====================================================================
981: * Paste/ lpstrFormatName in DisplayAsIcon Result Result
982: * PasteLink arrPasteEntry[]contains %s checked Text Image
983: * (Is Object == Y, Is Data == N)
984: * Paste N 1 1
985: * Paste Y N 2 2
986: * Paste Y Y 3 3
987: * PasteLink N 4 4
988: * PasteLink Y N 5 4
989: * PasteLink Y Y 6 5
990: * =====================================================================
991: * Result Text:
992: *
993: * 1. "Inserts the contents of the Clipboard into your document as <native type name,
994: * and optionally an additional help sentence>"
995: * 2. "Inserts the contents of the Clipboard into your document so that you may
996: * activate it using <object app name>"
997: * 3. "Inserts the contents of the Clipboard into your document so that you may
998: * activate it using <object app name>. It will be displayed as an icon."
999: * 4. "Inserts the contents of the Clipboard into your document as <native type name>.
1000: * Paste Link creates a link to the source file so that changes to the source file
1001: * will be reflected in your document."
1002: * 5. "Inserts a picture of the Clipboard contents into your document. Paste Link
1003: * creates a link to the source file so that changes to the source file will be
1004: * reflected in your document."
1005: * 6. "Inserts an icon into your document which represents the Clipboard contents.
1006: * Paste Link creates a link to the source file so that changes to the source file
1007: * will be reflected in your document."
1008: * =====================================================================
1009: * Result Image:
1010: *
1011: * 1. Clipboard Image
1012: * 2. Paste image, non-iconic.
1013: * 3. Paste image, iconic.
1014: * 4. Paste Link image, non-iconic
1015: * 5. Paste Link image, iconic
1016: * ====================================================================
1017: *
1018: * Parameters:
1019: * hDlg HWND of the dialog
1020: * lpPS Paste Special Dialog Structure
1021: *
1022: * Return Value:
1023: * No return value
1024: */
1025: void SetPasteSpecialHelpResults(HWND hDlg, LPPASTESPECIAL lpPS)
1026: {
1027: LPSTR psz1, psz2, psz3, psz4;
1028: UINT i, iString, iImage, cch;
1029: int nPasteEntriesIndex;
1030: BOOL fDisplayAsIcon;
1031: BOOL fIsObject;
1032: HWND hList;
1033: LPPASTELISTITEMDATA lpItemData;
1034: LPOLEUIPASTESPECIAL lpOPS = lpPS->lpOPS;
1035: LPSTR szFullUserTypeName = (lpPS->fLink) ? lpPS->szFullUserTypeNameLSD : lpPS->szFullUserTypeNameOD;
1036: LPSTR szInsert;
1037:
1038: hList = GetDlgItem(hDlg, ID_PS_DISPLAYLIST);
1039:
1040: i=(UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L);
1041: if (i != LB_ERR)
1042: {
1043: lpItemData = (LPPASTELISTITEMDATA)SendMessage(hList, LB_GETITEMDATA, i, 0L);
1044: if ((LRESULT)lpItemData == LB_ERR) return;
1045: nPasteEntriesIndex = lpItemData->nPasteEntriesIndex;
1046: // Check if there is a '%s' in the lpstrFormatName, then an object is being
1047: // pasted/pastelinked. Otherwise Data is being pasted-pastelinked.
1048: fIsObject = FHasPercentS(lpOPS->arrPasteEntries[nPasteEntriesIndex].lpstrFormatName,
1049: lpPS);
1050: }
1051: else return;
1052:
1053: // Is DisplayAsIcon checked?
1054: fDisplayAsIcon=(0L!=(lpPS->dwFlags & PSF_CHECKDISPLAYASICON));
1055:
1056: szInsert = szFullUserTypeName;
1057:
1058: if (lpPS->dwFlags & PSF_SELECTPASTE) // If user selected Paste
1059: {
1060: if (fIsObject)
1061: {
1062: iString = fDisplayAsIcon ? IDS_PSPASTEOBJECTASICON : IDS_PSPASTEOBJECT;
1063: iImage = fDisplayAsIcon ? RESULTIMAGE_EMBEDICON : RESULTIMAGE_EMBED;
1064: szInsert = lpPS->szAppName;
1065: }
1066: else
1067: {
1068: iString = IDS_PSPASTEDATA;
1069: iImage = RESULTIMAGE_PASTE;
1070: }
1071: }
1072: else if (lpPS->dwFlags & PSF_SELECTPASTELINK) // User selected PasteLink
1073: {
1074: if (fIsObject)
1075: {
1076: iString = fDisplayAsIcon ? IDS_PSPASTELINKOBJECTASICON : IDS_PSPASTELINKOBJECT;
1077: iImage = fDisplayAsIcon ? RESULTIMAGE_LINKICON : RESULTIMAGE_LINK;
1078: }
1079: else
1080: {
1081: iString = IDS_PSPASTELINKDATA;
1082: iImage = RESULTIMAGE_LINK;
1083: }
1084:
1085: }
1086: else // Should never occur.
1087: {
1088: iString = IDS_PSNONOLE;
1089: iImage = RESULTIMAGE_PASTE;
1090: }
1091:
1092: // hBuff contains enough space for the 4 buffers required to build up the help
1093: // result text.
1094: cch = (UINT)GlobalSize(lpPS->hBuff)/4;
1095:
1096: psz1=(LPSTR)GlobalLock(lpPS->hBuff);
1097: psz2=psz1+cch;
1098: psz3=psz2+cch;
1099: psz4=psz3+cch;
1100:
1101: // Default is an empty string.
1102: *psz1=0;
1103:
1104: if (0!=LoadString(ghInst, iString, psz1, cch))
1105: {
1106: // Insert the FullUserTypeName of the source object into the partial result text
1107: // specified by the container.
1108: wsprintf(psz3, lpOPS->arrPasteEntries[nPasteEntriesIndex].lpstrResultText,
1109: (LPSTR)szInsert);
1110: // Insert the above partial result text into the standard result text.
1111: wsprintf(psz4, psz1, (LPSTR)psz3);
1112: psz1=psz4;
1113: }
1114:
1115: // If LoadString failed, we simply clear out the results (*psz1=0 above)
1116: SetDlgItemText(hDlg, ID_PS_RESULTTEXT, psz1);
1117:
1118: // Change the result bitmap
1119: SendDlgItemMessage(hDlg, ID_PS_RESULTIMAGE, RIM_IMAGESET, iImage, 0L);
1120:
1121: GlobalUnlock(lpPS->hBuff);
1122: }
1123:
1124: /*
1125: * FAddPasteListItem
1126: *
1127: * Purpose:
1128: * Adds an item to the list box
1129: *
1130: * Parameters:
1131: * hList HWND List into which item is to be added
1132: * fInsertFirst BOOL Insert in the beginning of the list?
1133: * nPasteEntriesIndex int Index of Paste Entry array this list item corresponsds to
1134: * lpPS Paste Special Dialog Structure
1135: * pIMalloc LPMALLOC Memory Allocator
1136: * lpszBuf LPSTR Scratch buffer to build up string for list entry
1137: *
1138: * Return Value:
1139: * BOOL TRUE if sucessful.
1140: * FALSE if unsucessful.
1141: */
1142: BOOL FAddPasteListItem(
1143: HWND hList, BOOL fInsertFirst, int nPasteEntriesIndex, LPPASTESPECIAL lpPS,
1144: LPMALLOC pIMalloc, LPSTR lpszBuf)
1145: {
1146: LPOLEUIPASTESPECIAL lpOPS = lpPS->lpOPS;
1147: LPPASTELISTITEMDATA lpItemData;
1148: int nIndex;
1149: LPSTR szFullUserTypeName = (lpPS->fLink) ?
1150: lpPS->szFullUserTypeNameLSD : lpPS->szFullUserTypeNameOD;
1151:
1152: // Allocate memory for each list box item
1153: lpItemData = (LPPASTELISTITEMDATA)pIMalloc->lpVtbl->Alloc(
1154: pIMalloc, (DWORD)sizeof(PASTELISTITEMDATA));
1155: if (NULL == lpItemData)
1156: return FALSE;
1157:
1158: // Fill data associated with each list box item
1159: lpItemData->nPasteEntriesIndex = nPasteEntriesIndex;
1160: lpItemData->fCntrEnableIcon = ((lpOPS->arrPasteEntries[nPasteEntriesIndex].dwFlags &
1161: OLEUIPASTE_ENABLEICON) ? TRUE : FALSE);
1162:
1163: // Build list box entry string, insert the string and add the data the corresponds to it
1164: wsprintf(
1165: (LPSTR)lpszBuf,
1166: lpOPS->arrPasteEntries[nPasteEntriesIndex].lpstrFormatName,
1167: (LPSTR)szFullUserTypeName
1168: );
1169: nIndex = (int)SendMessage(
1170: hList,
1171: (fInsertFirst ? LB_INSERTSTRING : LB_ADDSTRING),
1172: 0,
1173: (LPARAM)(LPSTR)lpszBuf
1174: );
1175: SendMessage(
1176: hList,
1177: LB_SETITEMDATA,
1178: nIndex,
1179: (LPARAM)(LPPASTELISTITEMDATA)lpItemData
1180: );
1181: return TRUE;
1182: }
1183:
1184:
1185: /*
1186: * FFillPasteList
1187: *
1188: * Purpose:
1189: * Fills the invisible paste list with the formats offered by the clipboard object and
1190: * asked for by the container.
1191: *
1192: * Parameters:
1193: * hDlg HWND of the dialog
1194: * lpPS Paste Special Dialog Structure
1195: *
1196: * Return Value:
1197: * BOOL TRUE if sucessful and if formats could be found.
1198: * FALSE if unsucessful or if no formats could be found.
1199: */
1200: BOOL FFillPasteList(HWND hDlg, LPPASTESPECIAL lpPS)
1201: {
1202: LPOLEUIPASTESPECIAL lpOPS = lpPS->lpOPS;
1203: LPMALLOC pIMalloc = NULL;
1204: LPSTR lpszBuf = (LPSTR)GlobalLock(lpPS->hBuff);
1205: HWND hList;
1206: int i;
1207: int nItems = 0;
1208: int nDefFormat = -1;
1209: BOOL fTryObjFmt = FALSE;
1210: BOOL fInsertFirst;
1211: HRESULT hrErr;
1212:
1213: hrErr = CoGetMalloc(MEMCTX_TASK, &pIMalloc);
1214: if (hrErr != NOERROR)
1215: goto error;
1216:
1217: hList = GetDlgItem(hDlg, ID_PS_PASTELIST);
1218:
1219: // Loop over the target's priority list of formats
1220: for (i = 0; i < lpOPS->cPasteEntries; i++)
1221: {
1222: if (lpOPS->arrPasteEntries[i].dwFlags != OLEUIPASTE_PASTEONLY &&
1223: !(lpOPS->arrPasteEntries[i].dwFlags & OLEUIPASTE_PASTE))
1224: continue;
1225:
1226: fInsertFirst = FALSE;
1227:
1228: if (lpOPS->arrPasteEntries[i].fmtetc.cfFormat==cfFileName
1229: || lpOPS->arrPasteEntries[i].fmtetc.cfFormat==cfEmbeddedObject
1230: || lpOPS->arrPasteEntries[i].fmtetc.cfFormat==cfEmbedSource) {
1231: if (! fTryObjFmt) {
1232: fTryObjFmt = TRUE; // only use 1st object format
1233: fInsertFirst = TRUE; // OLE obj format should always be 1st
1234: } else {
1235: continue; // already added an object format to list
1236: }
1237: }
1238:
1239: // add to list if entry is marked TRUE
1240: if (lpOPS->arrPasteEntries[i].dwScratchSpace) {
1241: if (nDefFormat < 0)
1242: nDefFormat = (fInsertFirst ? 0 : nItems);
1243: else if (fInsertFirst)
1244: nDefFormat++; // adjust for obj fmt inserted 1st in list
1245:
1246: if (!FAddPasteListItem(hList,fInsertFirst,i,lpPS,pIMalloc,lpszBuf))
1247: goto error;
1248: nItems++;
1249: }
1250: }
1251:
1252: // initialize selection to first format matched in list
1253: if (nDefFormat >= 0)
1254: lpPS->nPasteListCurSel = nDefFormat;
1255:
1256: // Clean up
1257: if (pIMalloc)
1258: OleStdRelease((LPUNKNOWN)pIMalloc);
1259: if (lpszBuf)
1260: GlobalUnlock(lpPS->hBuff);
1261:
1262: // If no items have been added to the list box (none of the formats
1263: // offered by the source matched those acceptable to the container),
1264: // return FALSE
1265: if (nItems > 0)
1266: return TRUE;
1267: else
1268: return FALSE;
1269:
1270: error:
1271: if (pIMalloc)
1272: OleStdRelease((LPUNKNOWN)pIMalloc);
1273: if (lpszBuf)
1274: GlobalUnlock(lpPS->hBuff);
1275: FreeListData(hList);
1276:
1277: return FALSE;
1278: }
1279:
1280:
1281: /*
1282: * FFillPasteLinkList
1283: *
1284: * Purpose:
1285: * Fills the invisible paste link list with the formats offered by the clipboard object and
1286: * asked for by the container.
1287: *
1288: * Parameters:
1289: * hDlg HWND of the dialog
1290: * lpPS Paste Special Dialog Structure
1291: *
1292: * Return Value:
1293: * BOOL TRUE if sucessful and if formats could be found.
1294: * FALSE if unsucessful or if no formats could be found.
1295: */
1296: BOOL FFillPasteLinkList(HWND hDlg, LPPASTESPECIAL lpPS)
1297: {
1298: LPOLEUIPASTESPECIAL lpOPS = lpPS->lpOPS;
1299: LPDATAOBJECT lpSrcDataObj = lpOPS->lpSrcDataObj;
1300: LPENUMFORMATETC lpEnumFmtEtc = NULL;
1301: LPMALLOC pIMalloc = NULL;
1302: LPSTR lpszBuf = (LPSTR)GlobalLock(lpPS->hBuff);
1303: OLEUIPASTEFLAG pasteFlag;
1304: UINT arrLinkTypesSupported[PS_MAXLINKTYPES]; // Array of flags that
1305: // indicate which link types
1306: // are supported by source.
1307: FORMATETC fmtetc;
1308: int i, j;
1309: int nItems = 0;
1310: BOOL fLinkTypeSupported = FALSE;
1311: HWND hList;
1312: int nDefFormat = -1;
1313: BOOL fTryObjFmt = FALSE;
1314: BOOL fInsertFirst;
1315: HRESULT hrErr;
1316:
1317: hrErr = CoGetMalloc(MEMCTX_TASK, &pIMalloc);
1318: if (hrErr != NOERROR)
1319: goto error;
1320:
1321: // Remember which link type formats are offered by lpSrcDataObj.
1322: _fmemset(&fmtetc, 0, sizeof(FORMATETC));
1323: for (i = 0; i < lpOPS->cLinkTypes; i++)
1324: {
1325: if (lpOPS->arrLinkTypes[i] = cfLinkSource) {
1326: OLEDBG_BEGIN2("OleQueryLinkFromData called\r\n")
1327: hrErr = OleQueryLinkFromData(lpSrcDataObj);
1328: OLEDBG_END2
1329: if(NOERROR == hrErr)
1330: {
1331: arrLinkTypesSupported[i] = 1;
1332: fLinkTypeSupported = TRUE;
1333: }
1334: else arrLinkTypesSupported[i] = 0;
1335: }
1336: else {
1337: fmtetc.cfFormat = lpOPS->arrLinkTypes[i];
1338: fmtetc.dwAspect = DVASPECT_CONTENT;
1339: fmtetc.tymed = 0xFFFFFFFF; // All tymed values
1340: fmtetc.lindex = -1;
1341: OLEDBG_BEGIN2("IDataObject::QueryGetData called\r\n")
1342: hrErr = lpSrcDataObj->lpVtbl->QueryGetData(lpSrcDataObj,&fmtetc);
1343: OLEDBG_END2
1344: if(NOERROR == hrErr)
1345: {
1346: arrLinkTypesSupported[i] = 1;
1347: fLinkTypeSupported = TRUE;
1348: }
1349: else arrLinkTypesSupported[i] = 0;
1350: }
1351: }
1352: // No link types are offered by lpSrcDataObj
1353: if (! fLinkTypeSupported) {
1354: nItems = 0;
1355: goto cleanup;
1356: }
1357:
1358: hList = GetDlgItem(hDlg, ID_PS_PASTELINKLIST);
1359:
1360: // Enumerate the formats acceptable to container
1361: for (i = 0; i < lpOPS->cPasteEntries; i++)
1362: {
1363: fLinkTypeSupported = FALSE;
1364:
1365: // If container will accept any link type offered by source object
1366: if (lpOPS->arrPasteEntries[i].dwFlags & OLEUIPASTE_LINKANYTYPE)
1367: fLinkTypeSupported = TRUE;
1368: else
1369: {
1370: // Check if any of the link types offered by the source
1371: // object are acceptable to the container
1372: // This code depends on the LINKTYPE enum values being powers of 2
1373: for (pasteFlag = OLEUIPASTE_LINKTYPE1, j = 0;
1374: j < lpOPS->cLinkTypes;
1375: pasteFlag*=2, j++)
1376: {
1377: if ((lpOPS->arrPasteEntries[i].dwFlags & pasteFlag) &&
1378: arrLinkTypesSupported[j])
1379: {
1380: fLinkTypeSupported = TRUE;
1381: break;
1382: }
1383: }
1384: }
1385:
1386: fInsertFirst = FALSE;
1387:
1388: if (lpOPS->arrPasteEntries[i].fmtetc.cfFormat==cfFileName
1389: || lpOPS->arrPasteEntries[i].fmtetc.cfFormat==cfLinkSource) {
1390: if (! fTryObjFmt) {
1391: fTryObjFmt = TRUE; // only use 1st object format
1392: fInsertFirst = TRUE; // OLE obj format should always be 1st
1393: } else {
1394: continue; // already added an object format to list
1395: }
1396: }
1397:
1398: // add to list if entry is marked TRUE
1399: if (fLinkTypeSupported && lpOPS->arrPasteEntries[i].dwScratchSpace) {
1400: if (nDefFormat < 0)
1401: nDefFormat = (fInsertFirst ? 0 : nItems);
1402: else if (fInsertFirst)
1403: nDefFormat++; // adjust for obj fmt inserted 1st in list
1404:
1405: if (!FAddPasteListItem(hList,fInsertFirst,i,lpPS,pIMalloc,lpszBuf))
1406: goto error;
1407: nItems++;
1408: }
1409: } // end FOR
1410:
1411: nItems = (int)SendMessage(hList, LB_GETCOUNT, 0, 0L);
1412:
1413: // initialize selection to first format matched in list
1414: if (nDefFormat >= 0)
1415: lpPS->nPasteLinkListCurSel = nDefFormat;
1416:
1417: cleanup:
1418: // Clean up
1419: if (pIMalloc)
1420: OleStdRelease((LPUNKNOWN)pIMalloc);
1421: if (lpszBuf)
1422: GlobalUnlock(lpPS->hBuff);
1423:
1424: // If no items have been added to the list box (none of the formats
1425: // offered by the source matched those acceptable to the destination),
1426: // return FALSE
1427: if (nItems > 0)
1428: return TRUE;
1429: else
1430: return FALSE;
1431:
1432: error:
1433: if (pIMalloc)
1434: OleStdRelease((LPUNKNOWN)pIMalloc);
1435: if (lpszBuf)
1436: GlobalUnlock(lpPS->hBuff);
1437: FreeListData(hList);
1438:
1439: return FALSE;
1440: }
1441:
1442:
1443: /*
1444: * FreeListData
1445: *
1446: * Purpose:
1447: * Free the local memory associated with each list box item
1448: *
1449: * Parameters:
1450: * hList HWND of the list
1451: *
1452: * Return Value:
1453: * None
1454: */
1455: void FreeListData(HWND hList)
1456: {
1457: int nItems, i;
1458: LPPASTELISTITEMDATA lpItemData;
1459: LPMALLOC pIMalloc;
1460: HRESULT hrErr;
1461:
1462: hrErr = CoGetMalloc(MEMCTX_TASK, &pIMalloc);
1463: if (hrErr != NOERROR)
1464: return;
1465:
1466: nItems = (int) SendMessage(hList, LB_GETCOUNT, 0, 0L);
1467: for (i = 0; i < nItems; i++)
1468: {
1469: lpItemData = (LPPASTELISTITEMDATA)SendMessage(hList, LB_GETITEMDATA, (WPARAM)i, 0L);
1470: if ((LRESULT)lpItemData != LB_ERR)
1471: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)lpItemData);
1472: }
1473: OleStdRelease((LPUNKNOWN)pIMalloc);
1474: }
1475:
1476: /*
1477: * FHasPercentS
1478: *
1479: * Purpose:
1480: * Determines if string contains %s.
1481: *
1482: * Parameters:
1483: * lpsz LPCSTR string in which occurence of '%s' is looked for
1484: *
1485: * Return Value:
1486: * BOOL TRUE if %s is found, else FALSE.
1487: */
1488:
1489: BOOL FHasPercentS(LPCSTR lpsz, LPPASTESPECIAL lpPS)
1490: {
1491: int n = 0;
1492: LPSTR lpszTmp;
1493:
1494: if (!lpsz) return FALSE;
1495: // Copy input string to buffer. This allows caller to pass a
1496: // code-based string. Code segments may be swapped out in low memory situations
1497: // and so code-based strings need to be copied before string elements can be accessed.
1498: lpszTmp = (LPSTR)GlobalLock(lpPS->hBuff);
1499: lstrcpy(lpszTmp, lpsz);
1500:
1501: while (*lpszTmp)
1502: {
1503: if (*lpszTmp == '%')
1504: {
1505: lpszTmp = AnsiNext(lpszTmp);
1506: if (*lpszTmp == 's') // If %s, return
1507: {
1508: GlobalUnlock(lpPS->hBuff);
1509: return TRUE;
1510: }
1511: else if (*lpszTmp == '%') // if %%, skip to next character
1512: lpszTmp = AnsiNext(lpszTmp);
1513: }
1514: else lpszTmp = AnsiNext(lpszTmp);
1515: }
1516:
1517: GlobalUnlock(lpPS->hBuff);
1518: return FALSE;
1519: }
1520:
1521: /*
1522: * AllocateScratchMem
1523: *
1524: * Purpose:
1525: * Allocates scratch memory for use by the PasteSpecial dialog. The memory is
1526: * is used as the buffer for building up strings using wsprintf. Strings are built up
1527: * using the buffer while inserting items into the Paste & PasteLink lists and while
1528: * setting the help result text. It must be big enough to handle the string that results after
1529: * replacing the %s in the lpstrFormatName and lpstrResultText in arrPasteEntries[]
1530: * by the FullUserTypeName. It must also be big enough to build the dialog's result text
1531: * after %s substitutions by the FullUserTypeName or the ApplicationName.
1532: *
1533: * Parameters:
1534: * lpPS Paste Special Dialog Structure
1535: *
1536: * Return Value:
1537: * HGLOBAL Handle to allocated global memory
1538: */
1539:
1540: HGLOBAL AllocateScratchMem(LPPASTESPECIAL lpPS)
1541: {
1542: LPOLEUIPASTESPECIAL lpOPS = lpPS->lpOPS;
1543: int nLen, i;
1544: int nSubstitutedText = 0;
1545: int nAlloc = 0;
1546:
1547: // Get the maximum length of the FullUserTypeNames specified by OBJECTDESCRIPTOR
1548: // and the LINKSRCDESCRIPTOR and the Application Name. Any of these may be substituted
1549: // for %s in the result-text/list entries.
1550: if (lpPS->szFullUserTypeNameOD)
1551: nSubstitutedText = lstrlen(lpPS->szFullUserTypeNameOD);
1552: if (lpPS->szFullUserTypeNameLSD)
1553: nSubstitutedText = __max(nSubstitutedText, lstrlen(lpPS->szFullUserTypeNameLSD));
1554: if (lpPS->szAppName)
1555: nSubstitutedText = __max(nSubstitutedText, lstrlen(lpPS->szAppName));
1556:
1557: // Get the maximum length of lpstrFormatNames & lpstrResultText in arrPasteEntries
1558: nLen = 0;
1559: for (i = 0; i < lpOPS->cPasteEntries; i++)
1560: {
1561: nLen = __max(nLen, lstrlen(lpOPS->arrPasteEntries[i].lpstrFormatName));
1562: nLen = __max(nLen, lstrlen(lpOPS->arrPasteEntries[i].lpstrResultText));
1563: }
1564:
1565: // Get the maximum length of lpstrFormatNames and lpstrResultText after %s has
1566: // been substituted (At most one %s can appear in each string).
1567: // Add 1 to hold NULL terminator.
1568: nAlloc = nLen+nSubstitutedText+1;
1569:
1570: // Allocate scratch memory to be used to build strings
1571: // nAlloc is big enough to hold any of the lpstrResultText or lpstrFormatName in arrPasteEntries[]
1572: // after %s substitution.
1573: // We also need space to build up the help result text. 512 is the maximum length of the
1574: // standard dialog help text before substitutions. 512+nAlloc is the maximum length
1575: // after %s substition.
1576: // SetPasteSpecialHelpResults() requires 4 such buffers to build up the result text
1577: return GlobalAlloc(GHND, (DWORD)4*(512+nAlloc));
1578: }
1579:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.