path: root/private/mvdm/wow16/write/clipbord.c

/************************************************************/
/* 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

#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();
}



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;
		bltbyte( &chpT,	&rgch [1], cchCHP );
		AddSprmCps(	rgch, docCur, cp, cp + dcp );
		}
	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