able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/wow16/write/clipbord.c

957 lines
26 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/
/* clipbord.c -- Cut/Paste to clipboard */
#define NOVIRTUALKEYCODES
#define NOWINSTYLES
#define NOGDICAPMASKS
#define NOSYSMETRICS
#define NOMENUS
#define NOCTLMGR
#define NOFONT
#define NOPEN
#define NOBRUSH
#define NOSCROLL
#define NOCOMM
#define NOWNDCLASS
#include <windows.h>
#include "mw.h"
#include "docdefs.h"
#include "cmddefs.h"
#include "str.h"
#include "propdefs.h"
#include "editdefs.h"
#include "winddefs.h"
#include "filedefs.h"
#include "wwdefs.h"
#include "prmdefs.h"
#if defined(OLE)
#include "obj.h"
#endif
#ifdef JAPAN //T-HIROYN Win3.1
#include "kanji.h"
#endif
#include "debug.h"
extern struct SEL selCur; /* Current selection (i.e., sel in current ww */
extern int docCur; /* Document in current ww */
extern int docUndo;
extern int docScrap;
extern int vfSeeSel;
extern struct DOD (**hpdocdod)[];
extern struct PAP vpapAbs;
extern typeCP vcpLimParaCache;
extern typeCP vcpFirstParaCache;
extern int vfPictSel;
extern HCURSOR vhcIBeam;
extern int vfScrapIsPic;
extern struct UAB vuab;
extern int ferror;
extern struct FCB (**hpfnfcb)[];
extern struct WWD rgwwd[];
/* THESE ARE LOCAL TO THIS MODULE */
#if defined(OLE)
int NEAR PASCAL CopyScrapToTmp(void);
#endif
/* fn we created during the last non-local cut of MEMO rich text */
int fnLastCut=fnNil;
/* Local communication between ChangeClipboard() and MdocDestroyClip() */
int fDontDestroyClip=FALSE;
FMdocClipboardMsg( message, wParam, lParam )
unsigned message;
WORD wParam;
LONG lParam;
{ /* Process WRITE clipboard messages sent to MdocWndproc.
return TRUE if a message was processed, FALSE otherwise */
switch (message)
{
default:
return FALSE;
/*-------DATA INTERCHANGE COMMANDS-----------*/
case WM_CUT:
fnCutEdit();
break;
case WM_COPY:
fnCopyEdit();
break;
case WM_PASTE:
#if defined(OLE)
vbObjLinkOnly = FALSE;
#endif
fnPasteEdit();
break;
case WM_CLEAR:
fnClearEdit(OBJ_DELETING);
break;
case WM_UNDO:
fnUndoEdit();
break;
/*---------------CLIPBOARD INTERACTION-------------*/
case WM_DESTROYCLIPBOARD:
/* A notification that we are about to lose the ownership
of the clipboard. We should free any resources that are
holding the contents of the clipboard */
MdocDestroyClip();
break;
case WM_RENDERFORMAT:
/* A request to render the contents of the clipboard
in the data format specified. Reception of this message
implies that the receiver is the current owner of the
clipboard. See clipbord.c */
MdocRenderFormat( wParam );
break;
/*-------CLIPBOARD DISPLAY---------------------*/
case WM_PAINTCLIPBOARD:
/* A request to paint the clipboard contents.
wParam is a handle to the clipboard window
LOWORD( lParam ) is a handle to a PAINTSTRUCT giving
a DC and RECT for the area to repaint */
MdocPaintClipboard( wParam, LOWORD(lParam) );
break;
case WM_VSCROLLCLIPBOARD:
/* A request to vertically scroll the clipboard contents.
wParam is a handle to the clipboard window
LOWORD( lParam ) is the scroll type (SB_)
HIWORD( lParam ) is the new thumb position (if needed) */
MdocVscrollClipboard( wParam, LOWORD(lParam), HIWORD(lParam) );
break;
case WM_HSCROLLCLIPBOARD:
/* A request to horizontally scroll the clipboard contents.
wParam is a handle to the clipboard window
LOWORD( lParam ) is the scroll type (SB_)
HIWORD( lParam ) is the new thumb position (if needed) */
MdocHscrollClipboard( wParam, LOWORD(lParam), HIWORD(lParam) );
break;
case WM_SIZECLIPBOARD:
/* A notification that the clipboard window is being re-sized.
wParam is a handle to the clipboard window
LOWORD(lParam) is a handle to a RECT giving the new size */
MdocSizeClipboard( wParam, LOWORD(lParam) );
break;
case WM_ASKCBFORMATNAME:
/* A request for the name of the CF_OWNERDISPLAY clip format.
wParam is the max. # of chars to store (including terminator)
lParam is a long pointer to a buffer in which to store the name */
MdocAskCBFormatName( (LPCH) lParam, wParam );
break;
}
return TRUE;
}
fnCopyEdit()
{ /* COPY command: copy selection to clipboard */
extern int vfOwnClipboard;
typeCP cpFirst;
typeCP dcp;
StartLongOp();
cpFirst = selCur.cpFirst;
SetUndo( uacReplScrap, docCur, cpFirst, dcp = selCur.cpLim - cpFirst,
docNil, cpNil, cp0, 0);
SetUndoMenuStr(IDSTRUndoEdit);
ClobberDoc(docScrap, docCur, cpFirst, dcp);
#ifdef DCLIP
{
char rgch[100];
wsprintf(rgch,"fnCopyEdit: cpFirst %lu, dcp %lu \n\r", cpFirst, dcp);
CommSz(rgch);
}
#endif
if (ferror)
NoUndo();
else
{
if (wwdCurrentDoc.fEditHeader || wwdCurrentDoc.fEditFooter)
MakeScrapUnRunning();
vfScrapIsPic = vfPictSel;
}
#ifdef STYLES
(**hpdocdod)[docScrap].docSsht = (**hpdocdod)[docCur].docSsht;
#endif
#if defined(OLE)
ObjEnumInDoc(docScrap,ObjCloneObjectInDoc);
#endif
ChangeClipboard(); /* Force repaint of clipboard display & Set ownership */
EndLongOp(vhcIBeam);
}
MakeScrapUnRunning()
{ /* If the 1st para of docScrap is a running head,
apply a sprm to the whole of docScrap that gives it an rhc code of 0.
This is to avoid pasting running head stuff into the main part of a doc */
CHAR rgb [2];
typeCP cpMacScrap = (**hpdocdod) [docScrap].cpMac;
if (cpMacScrap != cp0 )
{
CachePara( docScrap, cp0 );
if (vpapAbs.rhc != 0)
{
rgb [0] = sprmPRhc;
rgb [1] = 0;
AddSprmCps( rgb, docScrap, cp0, cpMacScrap );
}
}
}
fnCutEdit()
{ /* CUT command: copy selection to clipboard & delete it */
extern int vfOwnClipboard;
typeCP cpFirst, cpLim, dcp;
ClearInsertLine(); /* Since we will be affecting cp's */
if (!FWriteOk( fwcDelete ))
/* Not OK to write on this doc */
return;
cpFirst = selCur.cpFirst;
cpLim = selCur.cpLim;
if (!ObjDeletionOK(OBJ_CUTTING))
return;
StartLongOp();
SetUndo( uacDelScrap, docCur, cpFirst, dcp = cpLim - cpFirst, docNil,
cpNil, cp0, 0);
ClobberDoc(docScrap, docCur, cpFirst, dcp);
if (wwdCurrentDoc.fEditHeader || wwdCurrentDoc.fEditFooter)
MakeScrapUnRunning();
if (!ferror) /* Don't stomp document if Clobber Doc failed */
{
if (wwdCurrentDoc.fEditHeader || wwdCurrentDoc.fEditFooter)
MakeScrapUnRunning();
Replace(docCur, cpFirst, dcp, fnNil, fc0, fc0);
}
else
NoUndo(); /* undo would be invalid */
#ifdef STYLES
(**hpdocdod)[docScrap].docSsht = (**hpdocdod)[docCur].docSsht;
#endif
vfScrapIsPic = vfPictSel;
vfPictSel = false;
ChangeClipboard(); /* Force repaint of clipboard display, get ownership */
#if 0
#if defined(OLE)
ObjEnumInDoc(docScrap,ObjCloneObjectInDoc);
#endif
#endif
EndLongOp(vhcIBeam);
}
fnPasteEdit()
{
/* PASTE command: replace selection with clipboard contents */
extern CHAR szDocClass[];
extern int vfScrapIsPic;
extern HWND vhWnd;
HWND hWndClipOwner;
int fUnFormattedText = FALSE;
typeCP cpFirst = selCur.cpFirst;
BOOL bClearScrap=FALSE;
StartLongOp();
if ( (hWndClipOwner = GetClipboardOwner()) != vhWnd )
{ /* Clipboard owner is not this instance of memo */
if ( (hWndClipOwner == NULL) ||
!FSameClassHwndSz( hWndClipOwner, szDocClass ))
{ /* Clipboard owner is not MEMO -- process standard CF_ formats */
if ( !FReadExtScrap() )
goto PasteErr;
bClearScrap = TRUE;
fUnFormattedText = !vfScrapIsPic;
}
else
{ /* Clipboard owner is another instance of MEMO */
if (!FGrabExtMemoScrap())
goto PasteErr;
}
}
/* Replace the selection with the scrap document */
CmdInsScrap( fUnFormattedText );
if (ferror)
goto PasteErr;
#if defined(OLE)
if (!bClearScrap) // then we're keeping scrap, need to clone
{
if (ObjEnumInDoc(docScrap,ObjCloneObjectInDoc) < 0)
goto PasteErr;
}
else // then we're not keeping scrap (came from clipboard)
{
/*
We don't need contents anymore, and if it contains an object,
then its got to go because its been inserted into the doc and not cloned
and we don't want a duplicate around.
Also gotta mark the object in docCur as no longer reusable (if
it gets copied later we will need to clone it).
*/
typeCP cpLim = cpFirst+CpMacText(docScrap);
ClobberDoc(docScrap,docNil,cp0,cp0);
ObjEnumInRange(docCur,cpFirst,cpLim,ObjFromCloneInDoc);
}
#endif
EndLongOp(vhcIBeam);
return;
PasteErr:
NoUndo();
EndLongOp(vhcIBeam);
_beep();
}
MdocRenderFormat( wCf )
int wCf;
{ /* Render clipboard data in format specified by wCf */
typeCP cpMac=CpMacText( docScrap );
struct PICINFOX picInfo;
#if defined(OLE)
if (vfScrapIsPic)
{
GetPicInfo( cp0, cpMac, docScrap, &picInfo );
if ((picInfo.mfp.mm == MM_OLE) && (wCf != CF_OWNERDISPLAY))
goto Render;
}
#endif
switch (wCf) {
case CF_OWNERDISPLAY:
/* Render rich text to another MEMO instance */
FPutExtMemoScrap();
break;
case CF_TEXT:
/* Remove formatting from scrap; put bare text out to clipboard */
goto Render;
case CF_BITMAP:
if (picInfo.mfp.mm == MM_BITMAP)
{
goto Render;
}
break;
case CF_METAFILEPICT:
/* We can supply this if the scrap is a metafile picture */
if (picInfo.mfp.mm != MM_BITMAP)
{
Render:
if (!FWriteExtScrap())
Error( IDPMTClipLarge );
}
break;
}
}
MdocDestroyClip()
{ /* Handles WM_DESTROYCLIPBOARD message. We are being notified that
the clipboard is being emptied & we don't need to keep its
contents around anymore. */
extern int vfOwnClipboard;
extern HWND vhWnd;
if (fDontDestroyClip)
return;
vfOwnClipboard = FALSE;
/* Clear out the scrap document */
ClobberDoc( docScrap, docNil, cp0, cp0 );
/* Disable UNDO operations that require the clipboard */
switch (vuab.uac) {
case uacDelScrap:
case uacUDelScrap:
case uacReplScrap:
case uacUReplScrap:
NoUndo();
break;
}
/* Remove all records of the file we generated in FPutExtMemoScrap
from the hpfnfcb array. Note that we assume that no document
in this instance has pieces of fn. */
if ( fnLastCut != fnNil )
{
FreeFn( fnLastCut );
fnLastCut = fnNil;
}
/* If we made a wwd entry for the display of the clipboard,
remove it now. We test here to avoid bringing in the
CLIPDISP module if we never did any display. */
{
if (wwClipboard != wwNil)
FreeWw( wwClipboard );
}
}
int FPutExtMemoScrap()
{ /* Write docScrap to a new file; send the normalized name
of the file to the clipboard as data handle for rich text type.
Assumes clipboard is open for SetClipboardData call. On exit,
the file written has an fn, but no document (including docScrap)
has pieces that point to it. This allows us to relinquish
ownership of the fn to the pasting instance.
RETURN: TRUE == OK, FALSE == ERROR
*/
int fn;
CHAR szT[ cchMaxFile ];
HANDLE hMem;
LPCH lpch;
int cch;
#if defined(OLE)
int docTemp;
#endif
/* Create a new, formatted file with a unique name */
szT [0] = '\0'; /* Create it on a temp drive in the root */
if ((fn = FnCreateSz( szT, cp0, dtyNetwork ))== fnNil )
{
return FALSE;
}
fnLastCut = fn; /* Save in a static so we can relinquish it later */
/* Save scrap document to file. Note that FWriteFn does NOT modify
the piece table of docScrap, so no document has pieces pointing
to fn. This is important because we don't want local pastes
to generate pieces pointing to this fn; we want to be able to cleanly
transfer ownership of the fn to another instance */
#if defined(OLE)
if ((docTemp = CopyScrapToTmp()) == docNil)
{
FDeleteFn( fn ); /* This will free the fn even if deleting the file
fails */
return FALSE;
}
#endif
if (!FWriteFn( fn, docTemp, TRUE ))
{
FDeleteFn( fn ); /* This will free the fn even if deleting the file
fails */
return FALSE;
}
#if defined(OLE)
if (docTemp != docScrap)
KillDoc (docTemp);
#endif
/* Make a global handle containing the name of the file; send it to the
clipboard as the rendering of the rich text format */
if ( ((hMem = GlobalAlloc( GMEM_MOVEABLE, (LONG)(cch=CchSz( szT ))))== NULL ) ||
((lpch = GlobalLock( hMem )) == NULL) )
{
return FALSE;
}
bltbx( (LPCH)szT, lpch, cch );
GlobalUnlock( hMem );
SetClipboardData( CF_OWNERDISPLAY, hMem );
return TRUE;
}
int FGrabExtMemoScrap()
{
/* We get here on a PASTE if the clipboard contains rich text from a
MEMO instance other than this one. This routine requests the contents of
the clipboard from the other instance, and places the contents into docScrap.
The contents of the clipboard are passed in a MEMO formatted file, whose
filename is contained in the clipboard's handle. The instance that owns
the clipboard does not keep any references to the fn for the clipboard
file (once we EmptyClipboard). After pasting, this routine arrogates
the ownership of the clipboard to this instance.
returns FALSE=error, true=OK */
extern int vfOwnClipboard;
extern HWND vhWnd;
LPCH lpch;
CHAR szT [cchMaxFile];
int fn;
typeFC dfc;
HANDLE hData;
int fOK=false;
/* Open Clipboard to lock out contenders */
if ( !OpenClipboard( vhWnd ))
{
return FALSE;
}
/* Grab clipboard data handle contents: it is a normalized
filename string referring to a formatted file containing
the rich text. The GetClipboardData call actually initiates
a WM_RENDERFORMAT message to which MdocRenderFormat responds */
if ( ((hData = GetClipboardData( CF_OWNERDISPLAY )) == NULL ) ||
((lpch = GlobalLock( hData )) == NULL ) )
{
goto GrabErr;
}
bltszx( lpch, (LPCH)szT );
GlobalUnlock( hData ); /* handle will be freed in EmptyClipboard sequence */
/* Open the file; replace the contents of the scrap document
with the contents of the file */
if ((fn = FnOpenSz( szT, dtyNormal, FALSE )) == fnNil)
{ /* Unfortunately, if this fails, the file that the other
instance created will "float", with noone holding an fn
for it, and it will not get deleted at the end of the session.
On the bright side, if the reason for the failure was that
the file never got created anyway, we have done exactly right */
goto GrabErr;
}
{ /* Opened file OK */
struct FCB *pfcb = &(**hpfnfcb)[fn];
struct FFNTB **hffntb;
struct FFNTB **HffntbCreateForFn();
int wUnused;
pfcb->fDelete = TRUE;
dfc = pfcb->fFormatted ? cfcPage : fc0;
Replace( docScrap,
cp0,
(**hpdocdod)[docScrap].cpMac,
fn,
dfc,
pfcb->fcMac - dfc );
/* give the scrap the correct font table */
FreeFfntb((**hpdocdod)[docScrap].hffntb);
if (FNoHeap(hffntb = HffntbCreateForFn(fn, &wUnused)))
hffntb = 0;
(**hpdocdod)[docScrap].hffntb = hffntb;
}
#if defined(OLE)
/* if there are any objects in there, Load 'em */
if (ObjEnumInDoc(docScrap,ObjLoadObjectInDoc) < 0)
fOK = FALSE;
else
#endif
fOK = !ferror; /* All is well if we didn't run out of memory */
/* Take over ownership of the clipboard. This results in a
WM_DESTROYCLIPBOARD message being sent to the other instance,
which will delete its fn entry for the file so we are the
exclusive owners */
GrabErr:
CloseClipboard();
ChangeClipboard();
return fOK;
}
ChangeClipboard()
{ /* Mark clipboard as changed. If we are not the owner of the clipboard, */
/* make us the owner (via EmptyClipboard). The EmptyClipboard call */
/* will result in a WM_DESTROYCLIPBOARD message being sent to the */
/* owning instance. The CloseClipboard call will result in a */
/* WM_DRAWCLIPBOARD message being sent to the clipboard viewer. */
/* If the clipboard viewer is CLIP.EXE, we will get a WM_PAINTCLIPBOARD */
/* message */
/* Added 10/8/85 by BL: If docScrap is empty, relinquish ownership */
/* of the clipboard */
extern int vfOwnClipboard;
extern HWND vhWnd;
int cf;
struct PICINFOX picInfo;
typeCP cpMacScrap = (**hpdocdod) [docScrap].cpMac;
if (!OpenClipboard( vhWnd ))
{ /* Couldn't open the clipboard, wipe out contents & disable UNDO */
MdocDestroyClip();
return;
}
/* We want to clear out previous data formats in the clipboard.
Unfortunately, the only way to do this is to call EmptyClipboard(),
which has the side effect of calling us with a WM_MDOCDESTROYCLIP
message. We use this primitive global comunication to prevent
docScrap from being wiped out in MdocDestroyClip() */
fDontDestroyClip = TRUE;
EmptyClipboard();
fDontDestroyClip = FALSE;
/* Re-validate vfScrapIsPic (in case a docScrap edit changed what it should be */
CachePara( docScrap, cp0 );
vfScrapIsPic = (vpapAbs.fGraphics && vcpLimParaCache == cpMacScrap);
if (!vfScrapIsPic)
cf = CF_TEXT;
else
{
GetPicInfo( cp0, cpMacScrap, docScrap, &picInfo );
switch(picInfo.mfp.mm)
{
case MM_BITMAP:
cf = CF_BITMAP;
break;
case MM_OLE:
cf = 0;
break;
default:
cf = CF_METAFILEPICT;
break;
}
}
vfOwnClipboard = (cpMacScrap != cp0);
if (vfOwnClipboard)
{ /* only set handles if we really have something in docScrap */
SetClipboardData( CF_OWNERDISPLAY, NULL );
if ((cf != CF_TEXT) && (picInfo.mfp.mm == MM_OLE))
{
while (cf = OleEnumFormats(lpOBJ_QUERY_OBJECT(&picInfo),cf))
{
if (cf == vcfLink)
SetClipboardData( vcfOwnerLink, NULL );
else
SetClipboardData( cf, NULL );
//if (cf == vcfNative)
//SetClipboardData( vcfOwnerLink, NULL );
}
}
else
SetClipboardData( cf, NULL );
}
CloseClipboard();
}
#ifdef JAPAN //T-HIROYN Win3.1
extern typeCP vcpFetch;
extern int vcchFetch;
extern CHAR *vpchFetch;
#endif
CmdInsScrap( fUnFormattedText )
int fUnFormattedText;
{ /* Insert the scrap into the document at the current point (PASTE) */
/* If fUnFormattedText is TRUE, the scrap is treated as unformatted */
/* text; that is, the characters are put into the document with the */
/* formatting that is active at the selection */
extern struct CHP vchpSel;
typeCP cp, dcp;
int cchAddedEol=0;
struct CHP chpT;
if (!FWriteOk( fwcInsert ))
return;
if ((dcp = CpMacText(docScrap)) == cp0)
return;
ClearInsertLine();
if (fnClearEdit(OBJ_INSERTING))
return;
chpT = vchpSel;
cp = selCur.cpFirst;
CachePara( docScrap, cp0 );
if (vpapAbs.fGraphics && cp > cp0)
{ /* Special case for inserting a picture paragraph */
/* Must put an Eol in front of the picture unless we're
inserting it at the start of the document or one is there already */
Assert( !fUnFormattedText );
(**hpdocdod)[docCur].fFormatted = fTrue;
CachePara(docCur, cp - 1);
if (vcpLimParaCache != cp)
{
cchAddedEol = ccpEol;
InsertEolPap(docCur, cp, &vpapAbs);
dcp += (typeCP)ccpEol;
}
}
SetUndo( uacInsert, docCur, cp, dcp, docNil, cpNil, cp0, 0 );
SetUndoMenuStr(IDSTRUndoEdit);
ReplaceCps(docCur, cp + (typeCP)cchAddedEol, cp0, docScrap, cp0,
dcp - (typeCP)cchAddedEol);
if (ferror) /* Not enough memory to do replace operation */
NoUndo(); /* should not be able to undo what never took place */
else
{
typeCP cpSel=CpFirstSty( cp + dcp, styChar );
if (vfScrapIsPic && vuab.uac == uacReplNS)
/* Special UNDO code for picture paste */
vuab.uac = uacReplPic;
if (fUnFormattedText)
{ /* If pasting unformatted text, give it the props at the selection */
CHAR rgch[ cchCHP + 1 ];
rgch [0] = sprmCSame;
#ifdef JAPAN //T-HIROYN Win3.1
{
struct CHP savechpT;
typeCP cpF, cpFirst, cpLim, kcpF, kcpL;
int cchF;
int kanjiftc, alphaftc;
CHAR *rp;
CHAR ch;
int cch, cblen;
if(NATIVE_CHARSET != GetCharSetFromChp(&chpT)) {
kanjiftc = GetKanjiFtc(&chpT);
alphaftc = GetFtcFromPchp(&chpT);
savechpT = chpT;
cpFirst = cp;
do {
FetchCp(docCur, cpFirst, 0, fcmChars);
cpF = vcpFetch;
cchF = vcchFetch;
kcpF = cpF;
if ((cpF+cchF) < cp + dcp)
cpLim = (cpF+cchF);
else
cpLim = cp + dcp;
cch = 0;
rp = vpchFetch;
while ( kcpF < cpLim ) {
ch = *rp;
if( FKana(ch) || IsDBCSLeadByte(ch) ) {
cblen = GetKanjiStringLen(cch, cchF, rp);
chpT.ftc = kanjiftc;
} else {
cblen = GetAlphaStringLen(cch, cchF, rp);
chpT.ftc = alphaftc;
}
kcpL = kcpF + cblen;
cch += cblen;
rp += cblen;
bltbyte( &chpT, &rgch [1], cchCHP );
AddSprmCps(rgch, docCur, kcpF, kcpL);
kcpF = kcpL;
}
cpFirst = kcpF;
} while ((cpF + cchF) < cp + dcp );
chpT = savechpT;
} else {
bltbyte( &chpT, &rgch [1], cchCHP );
AddSprmCps( rgch, docCur, cp, cp + dcp );
} //END IF ELSE
} // END JAPAN
#else
bltbyte( &chpT, &rgch [1], cchCHP );
AddSprmCps( rgch, docCur, cp, cp + dcp );
#endif
}
Select( cpSel, cpSel );
vchpSel = chpT; /* Preserve insert point props across this operation */
if (wwdCurrentDoc.fEditHeader || wwdCurrentDoc.fEditFooter)
{ /* If running head/foot, remove chSects & set para props */
MakeRunningCps( docCur, cp, dcp );
}
if (ferror)
NoUndo();
}
vfSeeSel = true; /* Tell Idle() to scroll the selection into view */
}
#if defined(OLE)
int NEAR PASCAL CopyScrapToTmp(void)
/*
If scrap doesn't contain OLE objects, return docScrap. Else
create docTemp and copy docScrap into it. Make sure objects
all have their data and have their lpObjInfos NULL'd out.
*/
{
extern typeCP cpMinCur, cpMacCur, cpMinDocument;
typeCP cpMinCurT = cpMinCur,
cpMacCurT = cpMacCur,
cpMinDocumentT = cpMinDocument;
int docTemp = docNil,
docReturn = docNil;
/* are there any objects? */
switch (ObjEnumInDoc(docScrap,NULL))
{
case -1: // error
return docNil;
case 0: // no objects in scrap
return docScrap;
}
/* Create copy of document */
if ((docTemp = DocCreate(fnNil, HszCreate(""), dtyNormal)) == docNil)
return docNil;
/* copy scrap to docTemp */
ClobberDoc(docTemp, docScrap, cp0, CpMacText(docScrap));
if (ferror)
goto error;
/* now save objects to make sure their data is present */
{
OBJPICINFO picInfo;
typeCP cpPicInfo;
for (cpPicInfo = cpNil;
ObjPicEnumInRange(&picInfo,docTemp,cp0,CpMacText(docTemp),&cpPicInfo);
)
{
OBJINFO ObjInfoSave;
typeCP cpRetval;
if (picInfo.lpObjInfo == NULL)
continue;
ObjInfoSave = *picInfo.lpObjInfo;
cpRetval = ObjSaveObjectToDoc(&picInfo,docTemp,cpPicInfo);
/*
Do this just in case saving the object to docTemp changes the
object's state. We don't want the object to appear clean
or saved when in fact it isn't or hasn't been except in docTemp,
which will be deleted by the calling routine.
*/
*picInfo.lpObjInfo = ObjInfoSave;
if (cpRetval == cp0) // save failed
goto error;
/* so pasting instance will reload object */
picInfo.lpObjInfo = NULL;
ObjSetPicInfo(&picInfo,docTemp,cpPicInfo);
}
}
/* success */
docReturn = docTemp;
error:
if ((docReturn == docNil) && (docTemp != docNil))
KillDoc(docTemp);
/* Restore cpMinCur, cpMacCur */
cpMinCur = cpMinCurT;
cpMacCur = cpMacCurT;
cpMinDocument = cpMinDocumentT; /* destroyed possibly by DocCreate */
return docReturn;
}
#endif

Reference in a new issue Copy permalink