ExternalClipboard Class Reference

Handlers for external (Windows) clipboard functions. Interacts with the internal clipboard document. More...

#include <clipext.h>

List of all members.

Public Member Functions
BOOL	IsOurs () const
	ExternalClipboard ()
	constructor
virtual	~ExternalClipboard ()
	Destructor. Cleans up our lists and wotnot.
void	CheckKeepClipboardOnExit (void)
	Called once on exit to check if the user wants the contents of the clipboard to be available after camelot is gone. This is supposed to be done when RenderAllFormats is called, but this happens after the main frame window has departed, so we want someone to call this method sometime between the last document being closed and the main frame being removed.
void	DestroyClipboard (void)
	Destroys the external and internal clipboards.
void	RenderFormat (UINT32 ClipboardFormat)
	"Renders" the given format to the clipboard (i.e. exports the internal clipboard to the windows clipboard using the specified mapping)
void	RenderFormat (ClipboardMapping *Info)
	"Renders" the given format to the clipboard (i.e. exports the internal clipboard to the windows clipboard using the specified mapping)
void	RenderAllFormats (void)
	Renders all available formats onto the windows clipboard Called when WM_RENDER_ALL_FORMATS is received (if the application quits when it owns the clipboard).
void	WindowsClipboardHasChanged (void)
	Destroys the internal clipboard.
BOOL	UnlinkTempClipboard ()
	Delete the temporary clipboard and return any static pointers to normal.
Static Public Member Functions
static BOOL	Init (void)
	Initialises the ExternalClipboard ready for operation.
static void	Deinit (void)
	De-Initialises the ExternalClipboard when you're shutting down.
static void	RegisterDataType (ClipboardMapping *TypeInfo)
	Called by filters to add import/export mappings to the external clipboard. Each mapping indicates which filter to call in order to convert data between a particular internal and external clipboard format.
static void	PrepareForShutdown (void)
static BOOL	CanImport (UINT32 WindowsFormat)
	Determines if there is an import mapping that can cope with the given format.
static void	GetExternalFormatName (UINT32 ExternalFormat, String_64 *Result)
	To get the textual description of a clipboard format.
static ExternalClipboard *	GetExternalClipboard (void)
	Finds the external clipboard. Only really of any use to the InternalClipboard and the main window which has to pass events to the ExternalClipboard.
static ExternalClipboard *	LinkTempClipboard ()
	Create a new temporary clipboard document and point the statics at it.
static void	UpdateSystemClipboard (BOOL fState)
Protected Member Functions
BOOL	PrepareForCopy (void)
	To ready the clipboard for a cut/copy operation (copy data TO the clipboard). This will interact with the external clipboard in order to claim the global clipboard, and readies the clipboard for use.
BOOL	CopyCompleted (void)
	Tells the ExternalClipboard that you have finished copying data to it. This interacts with the external clipboard in order to make the new data available to the outside world.
BOOL	PrepareForPaste (void)
	To ready the clipboard for a paste operation (copy data FROM the clipboard). This may interact with the external clipboard in order to provide the necessary data.
BOOL	PasteCompleted (void)
	Tells the ExternalClipboard that you have finished copying data from it. This provides interaction with the external clipboard.
Static Protected Member Functions
static BOOL	IsEmpty (void)
	To ready the clipboard for a cut/copy operation (copy data TO the clipboard). This will interact with the external clipboard in order to claim the global clipboard, and readies the clipboard for use.
static void	DescribeContents (String_64 *Result)
	To get the textual description of the clipboard format which will be pasted if a paste operation is to be applied now.
static CWnd *	GetOwnerWindow (void)
	Finds the main window of camelot, which is used to handle all communications between us and Windows regardingthe clipboard.
Protected Attributes
List	Mappings
BOOL	KeepFormatsOnExit
Static Protected Attributes
static ExternalClipboard *	pInstance = NULL
Static Private Attributes
static BOOL	m_fUpdateSystemClipboard = TRUE
Friends
class	InternalClipboard
class	CMainFrame
class	OpClipboardImport
class	PasteSpecialDlg
class	ScreenCamView

---

Detailed Description

Handlers for external (Windows) clipboard functions. Interacts with the internal clipboard document.

Author:

Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>

Date:

16/4/95

See also:

class InternalClipboard

Definition at line 138 of file clipext.h.

---

Constructor & Destructor Documentation

ExternalClipboard::ExternalClipboard (   )

constructor Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Definition at line 215 of file clipext.cpp. { if (pInstance == NULL) pInstance = this; else { ERROR3("Oy! You can't have more than one instance of the ExternalClipboard!"); } KeepFormatsOnExit = TRUE; #if (_OLE_VER >= 0x200) m_fIgnoreChange = FALSE; #endif }

ExternalClipboard::~ExternalClipboard (   )  [virtual]

Destructor. Cleans up our lists and wotnot. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Definition at line 244 of file clipext.cpp. { Mappings.DeleteAll(); if (pInstance == this) pInstance = NULL; else { ERROR3("Oy! You can't have more than one instance of the ExternalClipboard!"); } }

---

Member Function Documentation

BOOL ExternalClipboard::CanImport (  UINT32  WindowsFormat  )  [static]

Determines if there is an import mapping that can cope with the given format. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 2/5/95 Parameters: WindowsFormat  - the windows format (e.g. CF_ constant) which you wish to check [INPUTS] Returns: TRUE if it can import that data type Definition at line 642 of file clipext.cpp. { if (pInstance == NULL) return(FALSE); ClipboardMapping *Mapping = (ClipboardMapping *) pInstance->Mappings.GetHead(); while (Mapping != NULL) { if (Mapping->Type != CLIPMAP_EXPORTONLY && Mapping->ExternalDataType == WindowsFormat) return(TRUE); Mapping = (ClipboardMapping *) pInstance->Mappings.GetNext(Mapping); } return(FALSE); }

void ExternalClipboard::CheckKeepClipboardOnExit (  void   )

Called once on exit to check if the user wants the contents of the clipboard to be available after camelot is gone. This is supposed to be done when RenderAllFormats is called, but this happens after the main frame window has departed, so we want someone to call this method sometime between the last document being closed and the main frame being removed. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/4/95 It flags the user's choice, and this result will be used if/when we get a render-all-formats request. The user may not be asked at all (e.g. if we don't own the clipboard) See also: ExternalClipboard::RenderAllFormats Definition at line 542 of file clipext.cpp. { if (InternalClipboard::IsEmpty(FALSE)) // No clipboard! return; // Do we own the clipboard? if (!IsOurs()) return; // OK, Now let's determine just how complicated the data is. If it looks like it // will take an INT32 time or a lot of memory to leave it on the CB, then we'll // ask the user - if not, we'll just stay quiet about it and lump it all onto // the CB without asking permission. // This is done with a very rough guide: A node count of the clipboard content, // modified slightly to take account of the fact that blends and grad fills usually // cause a lot more output (in WMF format etc). Node *pRoot = InternalClipboard::GetInsertionLayer(); if (pRoot == NULL) { KeepFormatsOnExit = TRUE; return; } Node *pNode = pRoot->FindFirstDepthFirst(); INT32 RoughNodeCount = 0; while (pNode != NULL && RoughNodeCount < KeepClipboardThreshold) { if (pNode->IsAVisibleTextNode()) { RoughNodeCount += 1; // Text chars export small, so count as 1 } else if (IS_A(pNode, NodeBlend)) { // Each blend step counts as another 8 RoughNodeCount += 128 * (((NodeBlend *)pNode)->GetNumBlendSteps()); } else if (pNode->IsAnAttribute()) { // Each fill counts as 64 (in case it's a grad fill) if (pNode->IsKindOf(CC_RUNTIME_CLASS(AttrFillGeometry))) RoughNodeCount += 64; } else if (IS_A(pNode, NodeBitmap)) { // Add Bitmap memory size to the count // This will hit the threshold at about 128kB KernelBitmapRef *BmpRef = ((NodeBitmap*)pNode)->GetBitmapRef(); if (BmpRef != NULL) { KernelBitmap *KernelBmp = BmpRef->GetBitmap(); if (KernelBmp != NULL) { OILBitmap *OilBmp = KernelBmp->ActualBitmap; if (OilBmp != NULL) { BitmapInfo BmpInfo; OilBmp->GetInfo(&BmpInfo); RoughNodeCount += BmpInfo.MemoryUsed / 32; } } } } else RoughNodeCount += 10; // All other nodes count as 10 pNode = pNode->FindNextDepthFirst(pRoot); } // Default to saving the clipboard content on exit... KeepFormatsOnExit = TRUE; if (RoughNodeCount >= KeepClipboardThreshold) { // It looks a bit complicated, so maybe we'd better ask the user if they want the // clipboard contents to stick around once Camelot has quit. INT32 ButtonPressed = AskQuestion(_R(IDS_CLIPBOARD_KEEPONQUIT), _R(IDS_CLIPBOARD_KEEP), _R(IDS_CLIPBOARD_DISCARD)); // Then remember whether we should render all available formats to the clipboard KeepFormatsOnExit = (ButtonPressed == 1); } }

BOOL ExternalClipboard::CopyCompleted (  void   )  [protected]

Tells the ExternalClipboard that you have finished copying data to it. This interacts with the external clipboard in order to make the new data available to the outside world. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/95 Returns: TRUE if all went well FALSE if the copy failed in some way Notes: Before starting to copy data to the clipboard you MUST call PrepareForCopy This is called AFTER have updated the internal clipboard. However, if we already own the Windows clipboard, Windows very kindly asks us to destroy our clipboard when we call EmptyClipboard. To avoid disembowling ourselves we thus have to check if we are the owner of the clipboard so that we only wipe the internal clipboard if someone else takes control of the external clipboard - see DestroyClipboard Scope: protected (for friend class InternalClipboard only) See also: ExternalClipboard::PrepareForCopy Definition at line 1056 of file clipext.cpp. { // TRACEUSER( "JustinF", _T("In ExternalClipboard::CopyCompleted\n")); InternalClipboardFormat VectorFormat(CLIPTYPE_VECTOR); ClipboardMapping *Mapping = (ClipboardMapping *) Mappings.GetHead(); while (Mapping != NULL) { // Mark all "vector" mappings available for export Mapping->Available = Mapping->GetInternalDataType()->IsSameFormat(VectorFormat); Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping); } // Scan the InternalClipboard document tree to determine which internal formats are available Node *pRoot = InternalClipboard::GetInsertionLayer(); Node *pNode = pRoot->FindFirstDepthFirst(); BOOL AllDone = FALSE; // Becomes TRUE when there is no need to continue the scan while (pNode != NULL && !AllDone) { AllDone = TRUE; Mapping = (ClipboardMapping *) Mappings.GetHead(); while (Mapping != NULL) { if (!Mapping->Available && Mapping->Type != CLIPMAP_IMPORTONLY) { // Check if this mapping can be used on this node to provide another // output data format that was previously unavailable Mapping->Available = pNode->SupportsClipboardFormat(Mapping->GetInternalDataType()); if (!Mapping->Available) AllDone = FALSE; } Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping); } pNode = pNode->FindNextDepthFirst(pRoot); } #if (_OLE_VER >= 0x200) // Put the contents of the internal clipboard on the OLE clipboard, using the // associated CCamSrvrItem to do the hard stuff. m_fIgnoreChange = TRUE; // Only put stuff on the external clipboard if we are allowed to ... if (m_fUpdateSystemClipboard) { // If you have been using something like GIF construction set then this may // lock the clipboard. At this point, an exception will be thrown. This is an unknown // exception as far a Camelot is concerned and so is very bad. We should really stop // the main expection handler getting its claws on it and not knowing what to do with it. // Our exception handler can just pretend that nothing really happened. // Just mention to the user about the problem. TRY { // Get the oil form of the document and the associated server item CCamDoc * pCamDoc = InternalClipboard::Instance()->GetOilDoc(); CCamSrvrItem* pServer = NULL; if (pCamDoc != NULL) pServer = pCamDoc->GetEmbeddedItem(); // If that went well then ask it to copy the data to the clipboard if (pServer != NULL) pServer->CopyToClipboard(); } CATCH(COleException, e) // Handle all ole exceptions { // "e" contains information about the exception. TRACEUSER( "Neville", _T("ExternalClipboard::CopyCompleted exception handler\n")); // Do nothing special, as all this means is that the external clipboard // has had a problem. Just report a generic error to the user so that they // know that something is not working correctly. InformError(_R(IDE_CLIPBOARDCOPYPROBLEM)); // There was a problem copying to the Windows clipboard } END_CATCH } m_fIgnoreChange = FALSE; return TRUE; #else CWnd *Parent = GetOwnerWindow(); if (Parent->OpenClipboard() != NULL) { ::EmptyClipboard(); // Clear the windows clipboard // Add all available export formats onto the clipboard Mapping = (ClipboardMapping *) Mappings.GetHead(); while (Mapping != NULL) { #if FALSE #if _DEBUG TRACEUSER( "Jason", _T("Mapping %s available (for ICF %ld)\n"), Mapping->Available?"is":"NOT", (INT32)(Mapping->GetInternalDataType()->GetFormatID())); #endif #endif if (Mapping->Available && Mapping->Type != CLIPMAP_IMPORTONLY) ::SetClipboardData(Mapping->ExternalDataType, NULL); Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping); } ::CloseClipboard(); } // else another application/window has the clipboard open! return(TRUE); #endif }

void ExternalClipboard::Deinit (  void   )  [static]

De-Initialises the ExternalClipboard when you're shutting down. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 See also: ExternalClipboard::Init Definition at line 360 of file clipext.cpp. { if (pInstance != NULL) delete pInstance; pInstance = NULL; }

void ExternalClipboard::DescribeContents (  String_64 *  Result  )  [static, protected]

To get the textual description of the clipboard format which will be pasted if a paste operation is to be applied now. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/95 Parameters: Result  will be returned with a string describing the current clipboard [OUTPUTS] format. This may be the format of the internal clipboard (quickshape, line, etc) or could be from the external clipboard (metafile, text, bitmap) If no special information can be given, or if the clipboard is empty, Result will contain an empty string Definition at line 728 of file clipext.cpp. { ERROR3IF(Result == NULL, "Illegal null param"); // Ensure a safe return value *Result = TEXT(""); if (pInstance == NULL) // There ain't no clipboard hereabouts, mac! return; if (pInstance->IsOurs() || !InternalClipboard::IsEmpty(FALSE)) { // We own the clipboard, or have a cached result - Use the internal one ERROR3IF(InternalClipboard::IsEmpty(FALSE), "We own the clipboard but the internal clipboard is empty!!"); InternalClipboard::DescribeContentsInternal(Result); return; } if (GetOwnerWindow()->OpenClipboard() == NULL) return; // Can't open the clipboard UINT32 ThisFormat = 0; UINT32 DefaultImportFormat = 0; INT32 NumExternalFormats = 0; BOOL IncludesTextFormat = FALSE; do { ThisFormat = EnumClipboardFormats(ThisFormat); if (ThisFormat != 0 && ExternalClipboard::CanImport(ThisFormat)) { // Bodge - text can be on the clipboard in 3 forms, but we only want to treat // it as a single format for the 'paste special' count if (ThisFormat == CF_TEXT || ThisFormat == CF_UNICODETEXT || ThisFormat == CF_OEMTEXT) { if (!IncludesTextFormat) NumExternalFormats++; IncludesTextFormat = TRUE; } else NumExternalFormats++; // Remember which format we will import by default if (DefaultImportFormat == 0) DefaultImportFormat = ThisFormat; } } while (ThisFormat != 0); ::CloseClipboard(); if (NumExternalFormats > 1) { // if there are 2 or more external formats, then we'll paste special ("Paste...") *Result = _R(IDS_CLIPFORMAT_ELIPSES); // TEXT("..."); } else { // There is no data, or only one format that we recognise. If there is something we // can paste, then lob its name on the end ("Paste blobby"), else leave result blank ("Paste") if (DefaultImportFormat != 0) GetExternalFormatName(DefaultImportFormat, Result); } }

void ExternalClipboard::DestroyClipboard (  void   )

Destroys the external and internal clipboards. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Called in response to Windows WM_DestroyClipboard message, when another application takes ownership of the clipboard away from us. Notes: Now scans all registered mappings, and calls their RemoveTempFile methods in order to remove any tempfiles left lying about "on" the clipboard. Definition at line 1590 of file clipext.cpp. { // Whenever this method is called, we only wipe the clipboard if someone else owns it // (we're guaranteed to be called with us as the owner in all the situations where // we don't want to wipe the internal clipboard! Excellent!) if (!IsOurs()) { // And try to remove any temporary files that were hanging around "on" the clipboard InternalClipboard::Clear(); ClipboardMapping* Mapping = (ClipboardMapping*) Mappings.GetHead(); while (Mapping != NULL) { Mapping->RemoveTempFile(); Mapping = (ClipboardMapping*) Mappings.GetNext(Mapping); } } }

ExternalClipboard * ExternalClipboard::GetExternalClipboard (  void   )  [static]

Finds the external clipboard. Only really of any use to the InternalClipboard and the main window which has to pass events to the ExternalClipboard. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Returns: A pointer to the application-wide instance of the ExternalClipboard Definition at line 1842 of file clipext.cpp. { return(pInstance); }

void ExternalClipboard::GetExternalFormatName (  UINT32  ExternalFormat, String_64 *  Result )  [static]

To get the textual description of a clipboard format. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 22/4/95 Parameters: ExternalFormat  - A windows clipboard format ID (e.g. a CF_ constant) [INPUTS] Result  will be returned with a string describing this format [OUTPUTS] Notes: Microsoft, being in a particularly helpful frame of mind, have given us a function that does not provide the names of the default (CF_ constant) clipboard formats. We must therefore recognise all the likely formats and provide our own names. Thanks, guys. Definition at line 816 of file clipext.cpp. { ERROR3IF(Result == NULL, "Illegal NULL param"); if (ExternalFormat >= 0xC000 && ExternalFormat <= 0xFFFF) { GetClipboardFormatName(ExternalFormat, (LPTSTR)((TCHAR *)*Result), 63); if (*Result==String_64(_T("CorelXARA Document"))) *Result = String(_R(IDS_CLIPFORMAT_NATIVE)); } else { switch(ExternalFormat) { case CF_TEXT: *Result = String(_R(IDS_CLIPFORMAT_ATEXT)); break; case CF_BITMAP: *Result = String(_R(IDS_CLIPFORMAT_BMP)); break; case CF_METAFILEPICT: *Result = String(_R(IDS_CLIPFORMAT_WMF)); break; // case CF_SYLK: // *Result = TEXT("Symbolic Link"); // break; // case CF_DIF: // *Result = TEXT("Data Interchange Format"); // break; case CF_TIFF: *Result = String(_R(IDS_CLIPFORMAT_TIFF)); break; case CF_OEMTEXT: *Result = String(_R(IDS_CLIPFORMAT_ATEXT)); // Shares 'unformatted text' with CF_TEXT break; case CF_DIB: *Result = String(_R(IDS_CLIPFORMAT_DIB)); break; // case CF_PALETTE: // *Result = TEXT("Palette"); // break; // case CF_PENDATA: // *Result = TEXT("Pen data"); // break; // case CF_RIFF: // *Result = TEXT("RIFF data"); // break; // case CF_WAVE: // *Result = TEXT("WAVE sound"); // break; case CF_UNICODETEXT: *Result = String(_R(IDS_CLIPFORMAT_UTEXT)); break; case CF_ENHMETAFILE: *Result = String(_R(IDS_CLIPFORMAT_EMF)); break; default: *Result = String(_R(IDS_CLIPFORMAT_UNRECOGNISED_FORMAT)); // "Unrecognised format" TRACE( _T("WARNING: Unrecognised 'standard' windows clipboard format (%ld), %s,%ld\n"), (INT32)ExternalFormat, __FILE__, __LINE__); break; } } // If you want to hack a clipboard format, this little baby knows // how to dump it into the file c:\jason.tmp #if FALSE #if _DEBUG /* if (!camStrncmp((TCHAR *)(*Result), "QuarkXPress", 10)) // A Quack XPress clipboard format? { HANDLE Bob = GetClipboardData(ExternalFormat); char *buff = (char *) GlobalLock(Bob); FILE *fp = _tfopen("c:\\jason.tmp", "wb"); size_t Size = (size_t)GlobalSize(Bob); fwrite(buff, 1, Size, fp); fclose(fp); GlobalUnlock(Bob); ERROR3("Quack XPress data detected and saved!"); } */ #endif #endif }

CWnd * ExternalClipboard::GetOwnerWindow (  void   )  [static, protected]

Finds the main window of camelot, which is used to handle all communications between us and Windows regardingthe clipboard. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Returns: A pointer to the CWnd Window which "owns" the clipboard for Camelot. Scope: protected Definition at line 1865 of file clipext.cpp. { return GetMainFrame(); }

BOOL ExternalClipboard::Init (  void   )  [static]

Initialises the ExternalClipboard ready for operation. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 See also: ExternalClipboard::Deinit Definition at line 271 of file clipext.cpp. { if (!OpClipboardExport::Init()) return(FALSE); if (!OpClipboardImport::Init()) return(FALSE); if (!PasteSpecialDlg::Init()) return(FALSE); ExternalClipboard *TheClipboard = new ExternalClipboard(); if (TheClipboard == NULL) return(FALSE); // **** !!!! DEBUG BODGE - add export mapping for text characters - ideally this // clipboard mapping should be provided by a proper text import/export filter, // but one does not exist yet. // Add a UNICODE filter - this only works under NT, as nobody else supports unicode BodgeUnicodeClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT, CF_UNICODETEXT); // 8-bit text (windows implicitly converts between these for us) // The first one is the filter, while the second one is an 'alias' for import // which will make windows convert the OEMTEXT into TEXT and then we put this through // our normal TEXT mapping... BodgeTextClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT, CF_TEXT); BodgeTextClipMap::CreateAndRegister(CLIPMAP_IMPORTONLY, CF_OEMTEXT); // Add bitmap/DIB import/export mappings // Note that if we export WMF and DIB, there is no need to bother with Bitmap // (Corel don't, probably because there is no way of getting a quality image via Bitmaps, // and also because some programs are stupid and corrupt the DIB by using the palette // which we supply for the Bitmap! Arrgh!) // BitmapClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT); BitmapClipMap::CreateAndRegister(CLIPMAP_IMPORTONLY); DIBClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT); // CMX import and export stuff to make commicating with Corel happier CMX16ClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT, ::RegisterClipboardFormat("Corel Presentation Exchange Data")); CMX32ClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT, ::RegisterClipboardFormat("Corel 32-bit Presentation Exchange Data")); // native clipboard thing -- for OLE stuff // // this is export only (although functional code does exist for import) // as there are several technical problems with getting the native filter // to import into the clipboard document. See the comment near the // NativeClipMap::HandleImport() function for more details. NativeClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT /*CLIPMAP_EXPORTONLY*/, ::RegisterClipboardFormat("CorelXARA Document")); // NativeClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT /*CLIPMAP_EXPORTONLY*/, ::RegisterClipboardFormat("XaraX Document")); // Add a palette export mapping - used in conjunction with Bitmap exporter, it provides // the palette for the given bitmap. (not needed now we don't export BMPs) // PaletteClipMap::CreateAndRegister(); #if FALSE // And add our Quark EPS import filter QuarkPictureClipMap::CreateAndRegister(); #endif // Read the bug-fix preference for CMX. if (!GetApplication()->DeclareSection(TEXT("OLE Local Server"), 5) || !GetApplication()->DeclarePref(TEXT("OLE Local Server"), TEXT("DontExportCMXInIDataObject"), &fNoCMXDataExport, FALSE, TRUE)) { TRACEUSER( "JustinF", _T("Couldn't read CMX pref in ExternalClipboard::Init\n")); return FALSE; } return(TRUE); }

BOOL ExternalClipboard::IsEmpty (  void   )  [static, protected]

To ready the clipboard for a cut/copy operation (copy data TO the clipboard). This will interact with the external clipboard in order to claim the global clipboard, and readies the clipboard for use. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/95 Returns: TRUE if the clipboard is ready to accept new data FALSE if the copy must be aborted Notes: After you have copied data to the clipboard, you MUST call CopyCompleted Scope: protected (for friend class InternalClipboard only) See also: ExternalClipboard::CopyCompleted; ExternalClipboard::PrepareForPaste Definition at line 943 of file clipext.cpp. { BOOL IsEmpty = TRUE; if (pInstance == NULL) return(TRUE); CWnd *Parent = GetOwnerWindow(); if (Parent == NULL) return TRUE; if (pInstance->IsOurs()) // We own the clipboard! Use the internal one { if (InternalClipboard::IsEmpty(FALSE)) { ERROR3("We own the clipboard but the internal clipboard is empty!!"); } else { ERROR3("Why are you asking the External clipboard if it's empty when the internal one isn't?"); } return(FALSE); } if (Parent->OpenClipboard() == NULL) return(TRUE); // Can't open the clipboard, so we're empty ClipboardMapping *Mapping; UINT32 ThisFormat = 0; // 0 makes EnumClipboardFormats start from the beginning do { ThisFormat = EnumClipboardFormats(ThisFormat); if (ThisFormat != 0) { Mapping = (ClipboardMapping *) pInstance->Mappings.GetHead(); while (Mapping != NULL && IsEmpty) { // If this mapping is an import mapping and can handle this external format, // then we need look no further - there is importable data on the clipboard if (Mapping->Type != CLIPMAP_EXPORTONLY && Mapping->ExternalDataType == ThisFormat) IsEmpty = FALSE; Mapping = (ClipboardMapping *) pInstance->Mappings.GetNext(Mapping); } } } while (ThisFormat != 0 && IsEmpty); ::CloseClipboard(); return(IsEmpty); }

BOOL ExternalClipboard::IsOurs (   )  const

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/96 Returns: TRUE if Camelot currently owns the clipboard, FALSE if it doesn't or the clipboard is empty. See also: COleDataSource::GetClipboardOwner; CWnd::GetClipboardOwner Definition at line 427 of file clipext.cpp. { #if (_OLE_VER >= 0x200) // OLE does it with data sources (but paste still does it with window handles). return CCamDataSource::GetClipboardOwner() != 0 || CWnd::GetClipboardOwner() == GetOwnerWindow(); #else // Windows does it with window handles. return CWnd::GetClipboardOwner() == GetOwnerWindow(); #endif }

ExternalClipboard * ExternalClipboard::LinkTempClipboard (   )  [static]

Create a new temporary clipboard document and point the statics at it. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 27/9/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Definition at line 2717 of file clipext.cpp. { // TODO: Make new internal and external clipboard objects // BODGE: Just use the existing clipboards return(ExternalClipboard::pInstance); }

BOOL ExternalClipboard::PasteCompleted (  void   )  [protected]

Tells the ExternalClipboard that you have finished copying data from it. This provides interaction with the external clipboard. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/95 Returns: TRUE if all went well FALSE if the paste failed in some way Notes: Before starting to copy data to the clipboard you MUST call PrepareForPaste Scope: protected (for friend class InternalClipboard only) See also: ExternalClipboard::PrepareForPaste Definition at line 1564 of file clipext.cpp. { // Do nothing return(TRUE); }

BOOL ExternalClipboard::PrepareForCopy (  void   )  [protected]

To ready the clipboard for a cut/copy operation (copy data TO the clipboard). This will interact with the external clipboard in order to claim the global clipboard, and readies the clipboard for use. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/95 Returns: TRUE if the clipboard is ready to accept new data FALSE if the copy must be aborted Notes: After you have copied data to the clipboard, you MUST call CopyCompleted Scope: protected (for friend class InternalClipboard only) See also: ExternalClipboard::CopyCompleted; ExternalClipboard::PrepareForPaste Definition at line 1018 of file clipext.cpp. { // Do nothing return(TRUE); }

BOOL ExternalClipboard::PrepareForPaste (  void   )  [protected]

To ready the clipboard for a paste operation (copy data FROM the clipboard). This may interact with the external clipboard in order to provide the necessary data. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/95 Returns: TRUE if the clipboard is ready to provide data for pasting FALSE if the paste must be aborted (nothing to paste) Notes: After copying data from the clipboard you MUST call PasteCompleted Scope: protected (for friend class InternalClipboard only) See also: ExternalClipboard::PasteCompleted Definition at line 1386 of file clipext.cpp. { // Open the clipboard - if this fails, return immediately CWnd *Parent = GetOwnerWindow(); if (Parent->OpenClipboard() == NULL) return(FALSE); ClipboardMapping *Mapping; UINT32 ForceFormat = 0; UINT32 ThisFormat = 0; #if DO_PASTE_SPECIAL // First, count how many external formats are available - if there are less than 2 formats // which we can import, then there is no point in showing the paste-special dialogue. INT32 NumExternalFormats = 0; BOOL IncludesTextFormat = FALSE; do { ThisFormat = EnumClipboardFormats(ThisFormat); if (ThisFormat != 0 && ExternalClipboard::CanImport(ThisFormat)) { // Bodge - text can be on the clipboard in 3 forms, but we only want to treat // it as a single format for the 'paste special' count if (ThisFormat == CF_TEXT || ThisFormat == CF_UNICODETEXT || ThisFormat == CF_OEMTEXT) { if (!IncludesTextFormat) NumExternalFormats++; IncludesTextFormat = TRUE; } else NumExternalFormats++; } } while (ThisFormat != 0); // if there are 2 or more external fornmats, then pop up the paste special dialogue automatically if (NumExternalFormats > 1) { ForceFormat = PasteSpecialDlg::InvokeDialog(); if (ForceFormat == 0) { // User pressed "cancel" ::CloseClipboard(); return(FALSE); } } #if _DEBUG { TRACEUSER( "Jason", _T("\nClipboard formats available:\n")); UINT32 ThisFormat = 0; do { ThisFormat = EnumClipboardFormats(ThisFormat); if (ThisFormat != 0) { String_64 name; GetExternalFormatName(ThisFormat, &name); TRACEUSER( "Jason", _T(" %ld %s %s\n", (INT32)ThisFormat, (TCHAR *)name, CanImport(ThisFormat)?" (supported)":"")); } } while (ThisFormat != 0); } #endif #endif BOOL IKnowWhatType = FALSE; ThisFormat = 0; // If we know we`ve only one format type and it`s a text object, find out if the clipboard // is holding it as a UNICODE format if(IncludesTextFormat && NumExternalFormats == 1) { // To find out if it`s unicode, we need to search the clipboard enumerations to // see if it contains the unicode type. IKnowWhatType = TRUE; UINT32 Type = EnumClipboardFormats(0); while(Type > 0) { if(Type == 13) { ThisFormat = 13; break; } Type = EnumClipboardFormats(Type); } // If we didn`t find the unicode type set it to the normal type! if(ThisFormat == 0) ThisFormat = 1; } do { if(!IKnowWhatType) ThisFormat = EnumClipboardFormats(ThisFormat); if (ThisFormat != 0) { if (ForceFormat == 0 || ForceFormat == ThisFormat) Mapping = (ClipboardMapping *) Mappings.GetHead(); else Mapping = NULL; while (Mapping != NULL) { // Is this mapping an import mapping for the given format? if (Mapping->Type != CLIPMAP_EXPORTONLY && Mapping->ExternalDataType == ThisFormat) { // Little check here - if this is a simple mapping, then we can go ahead. however, // if it says 'unformatted text' but will actually try to use windows' implicit conversion // to unicode text, we really need to check if the 'real' data type (unicode) is also // available on the clipboard. if (Mapping->ExternalDataType == Mapping->RealExternalType || ::IsClipboardFormatAvailable(Mapping->RealExternalType)) { #if _DEBUG { String_64 name; GetExternalFormatName(ThisFormat, &name); TRACEUSER( "Jason", _T("I choose to import: %s\n"), (TCHAR *)name); if (Mapping->ExternalDataType != Mapping->RealExternalType) { GetExternalFormatName(Mapping->RealExternalType, &name); TRACEUSER( "Jason", _T(" (Which actually imports via implicit conversion to %s)\n"), (TCHAR *)name); } } #endif OpDescriptor *ImportOp = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpClipboardImport)); ERROR3IF(ImportOp == NULL, "Clipboard Import OpDesc not found!"); if (ImportOp != NULL) { OpParam Bob((INT32)Mapping, 0); ImportOp->Invoke(&Bob); } ::CloseClipboard(); return(!InternalClipboard::IsEmpty(FALSE)); } ERROR3("Windows implicit clipboard conversion unavailable! Trying other formats"); } Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping); } } } while (ThisFormat != 0); ::CloseClipboard(); return(FALSE); }

void ExternalClipboard::PrepareForShutdown (  void   )  [static]

Definition at line 465 of file clipext.cpp. { // Is there a clipboard? if (InternalClipboard::IsEmpty(FALSE)) return; ExternalClipboard* pClipboard = GetExternalClipboard(); if (pClipboard == NULL) return; pClipboard->CheckKeepClipboardOnExit(); #if (_OLE_VER >= 0x200) if (pClipboard->KeepFormatsOnExit) { // Render all the clipboard formats now (except CMX cos it may crash if there's a // bitmap or a fractal about - doh-doh-double-doh?!?!?) // TRACEUSER( "JustinF", _T("Rendering clipboard formats now ...\n")); fBodgeNoCMX = TRUE; CCamDataSource::FlushClipboard(); fBodgeNoCMX = FALSE; } else { // Discard the clipboard contents now. // TRACEUSER( "JustinF", _T("Discarding clipboard formats ...\n")); COleDataSource* pSource = CCamDataSource::GetClipboardOwner(); if (pSource) pSource->Empty(); } #else // This member var. will have been set by someone calling CheckKeepClipboardOnExit() if (!pClipboard->KeepFormatsOnExit) { // They don't want to keep the clipboard formats, so wipe the clipboard. CWnd* pParent = GetOwnerWindow(); if (pParent->OpenClipboard() != NULL) { ::EmptyClipboard(); ::CloseClipboard(); } return; } // They do want to keep the clipboard contents, so render all formats to it now pClipboard->RenderAllFormats(); #endif // And make sure that we ignore any further attempt to make us render formats pClipboard->KeepFormatsOnExit = FALSE; }

void ExternalClipboard::RegisterDataType (  ClipboardMapping *  Mapping  )  [static]

Called by filters to add import/export mappings to the external clipboard. Each mapping indicates which filter to call in order to convert data between a particular internal and external clipboard format. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Parameters: TypeInfo  - info describing the import/export mapping to add [INPUTS] Notes: The Mapping is NOW OWNED by the ExternalClipboard. DO NOT DELETE IT. Definition at line 678 of file clipext.cpp. { ERROR3IF(Mapping == NULL, "Illegal NULL param"); if (pInstance == NULL) { ERROR3("Attempt to register a clipboard mapping when there is no ExternalClipboard"); delete Mapping; return; } List *TheList = &pInstance->Mappings; ClipboardMapping *Ptr = (ClipboardMapping *) TheList->GetHead(); while (Ptr != NULL) { if (Ptr->Priority < Mapping->Priority) { TheList->InsertBefore(Ptr, Mapping); return; } Ptr = (ClipboardMapping *) TheList->GetNext(Ptr); } // Haven't found a lower-priority entry, so this one belongs at the tail TheList->AddTail(Mapping); }

void ExternalClipboard::RenderAllFormats (  void   )

Renders all available formats onto the windows clipboard Called when WM_RENDER_ALL_FORMATS is received (if the application quits when it owns the clipboard). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Notes: Simply calls RenderFormat for all available formats Despite what some help entries in books online may say, this method should NOT OpenClipboard() before doing SetClipboardData() See also: ExternalClipboard::RenderFormat Definition at line 1795 of file clipext.cpp. { if (InternalClipboard::IsEmpty(FALSE)) // No clipboard! Eek! return; // **** !!!! Check if the user wants us to keep the clipboard contents // This should be called from elsewhere so the question box appears before the main frame // window has been closed... // CheckKeepClipboardOnExit(); // **** // This member var. will have been set by someone calling CheckKeepClipboardOnExit() if (!KeepFormatsOnExit) return; CWnd *Parent = GetOwnerWindow(); if (Parent->OpenClipboard() != NULL) { ClipboardMapping *Mapping = (ClipboardMapping *) Mappings.GetHead(); while (Mapping != NULL) { if (Mapping->Type != CLIPMAP_IMPORTONLY && Mapping->Available) RenderFormat(Mapping); // Only render the available formats Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping); } ::CloseClipboard(); } }

void ExternalClipboard::RenderFormat (  ClipboardMapping *  pMapping  )

"Renders" the given format to the clipboard (i.e. exports the internal clipboard to the windows clipboard using the specified mapping) Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Parameters: Info  - points to the information on the available format [INPUTS] Called in response to WM_RENDER_FORMAT message Notes: This is the internal form of this method; It is called by the other form once the mapping has been determined. Despite what some help entries in books online may say, this method should NOT OpenClipboard() before doing SetClipboardData() Definition at line 1722 of file clipext.cpp. { ERROR3IF(pMapping == NULL, "Illegal NULL param"); ERROR3IF(!pMapping->Available, "Requested clipboard format is not available!"); ERROR3IF(pMapping->Type == CLIPMAP_IMPORTONLY, "Attempt to use import-only mapping for export"); if (pMapping == NULL || !pMapping->Available || pMapping->Type == CLIPMAP_IMPORTONLY) return; // JustinF says: bodge alert! We mustn't render CMX formats on shut-down because they // crash if the clipboard doc contains bitmaps or fractals. if (pMapping->IS_KIND_OF(CMXClipMap) && (fBodgeNoCMX || fNoCMXDataExport)) { TRACEUSER( "JustinF", _T("Skipping CMX mapping at 0x%p\n"), (LPVOID) pMapping); return; } // The "export to clipboard" must be done inside an Op so it can call filters, so find the // OpDescriptor, and call our Export Op. OpDescriptor* pExportOp = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpClipboardExport)); ERROR3IF(pExportOp == NULL, "Clipboard Export OpDesc not found!"); // The OLE clipboard can pass you an already allocated memory block of a given size. if (pExportOp) { #if (_OLE_VER >= 0x200) // Pass on the mapping and the parameters from SetRenderMemory. OpClipboardExportParams prm; prm.pMapping = pMapping; prm.hMem = m_hMem; prm.cbMemSize = m_cbMemSize; prm.pDoc = m_pDoc; // Invoke the export op for the given format on the given memory. OpParam opp((INT32) &prm, 0); pExportOp->Invoke(&opp); // Maybe the operation allocated the memory, so update these just in case. m_hMem = prm.hMem; m_cbMemSize = prm.cbMemSize; #else OpParam opp((INT32) pMapping, 0); pExportOp->Invoke(&opp); #endif } }

void ExternalClipboard::RenderFormat (  UINT32  nFmt  )

"Renders" the given format to the clipboard (i.e. exports the internal clipboard to the windows clipboard using the specified mapping) Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Parameters: ClipboardFormat  - A CF_ descriptor for a Windows clipboard format [INPUTS] Called in response to WM_RENDER_FORMAT message Notes: This is the external interface. This then calls the other override of RenderFormat to actually do the rendering. Despite what some help entries in books online may say, this method should NOT OpenClipboard() before doing SetClipboardData() Definition at line 1669 of file clipext.cpp. { if (InternalClipboard::IsEmpty(FALSE)) // No clipboard! Eek! return; // Check for all the boring old static formats. ClipboardMapping *Mapping = (ClipboardMapping *) Mappings.GetHead(); while (Mapping != NULL) { // If this mapping is for export, and matches the desired output format if (Mapping->Type != CLIPMAP_IMPORTONLY && Mapping->ExternalDataType == nFmt) { if (Mapping->Available) RenderFormat(Mapping); else { ERROR2RAW("Requested clipboard format is unavailable!"); InformError(); } return; } Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping); } ERROR2RAW("Requested clipboard format is illegal (unknown)!"); InformError(); }

BOOL ExternalClipboard::UnlinkTempClipboard (   )

Delete the temporary clipboard and return any static pointers to normal. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 27/9/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Definition at line 2740 of file clipext.cpp. { return TRUE; }

static void ExternalClipboard::UpdateSystemClipboard (  BOOL  fState  )  [inline, static]

Definition at line 302 of file clipext.h. { m_fUpdateSystemClipboard = fState; }

void ExternalClipboard::WindowsClipboardHasChanged (  void   )

Destroys the internal clipboard. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/95 Called whenever the contents of the Windows clipboard are changed. We use this to destroy the contents of our internal clipboard (cache). Definition at line 1624 of file clipext.cpp. { #if (_OLE_VER >= 0x200) // The comment below is no longer true, as now OLE takes possession of the clipboard // for us, which the old code thinks is someone else taking possession, and hence it // clears out the clipboard. This bodgy flag stops that happening when we ask OLE // to set the clipboard for us. // TRACEUSER( "JustinF", _T("In ExternalClipboard::WindowsClipboardHasChanged\n")); if (m_fIgnoreChange) { // TRACEUSER( "JustinF", _T("\t- ignoring this change to the clipboard ...\n")); return; } #endif // Whenever this method is called, we only wipe the clipboard if someone else owns it // (we're guaranteed to be called with us as the owner in all the situations where // we don't want to wipe the internal clipboard! Excellent!) if (!IsOurs() && m_fUpdateSystemClipboard) InternalClipboard::Clear(); }

---

Friends And Related Function Documentation

friend class CMainFrame [friend]

Definition at line 141 of file clipext.h.

friend class InternalClipboard [friend]

Definition at line 140 of file clipext.h.

friend class OpClipboardImport [friend]

Definition at line 142 of file clipext.h.

friend class PasteSpecialDlg [friend]

Definition at line 143 of file clipext.h.

friend class ScreenCamView [friend]

Definition at line 144 of file clipext.h.

---

Member Data Documentation

BOOL ExternalClipboard::KeepFormatsOnExit [protected]

Definition at line 289 of file clipext.h.

BOOL ExternalClipboard::m_fUpdateSystemClipboard = TRUE [static, private]

Definition at line 296 of file clipext.h.

List ExternalClipboard::Mappings [protected]

Definition at line 287 of file clipext.h.

ExternalClipboard * ExternalClipboard::pInstance = NULL [static, protected]

Definition at line 286 of file clipext.h.

---

The documentation for this class was generated from the following files:

• wxOil/clipext.h (r1785/r1282)
• wxOil/clipext.cpp (r1785/r1282)

---