InternalClipboard Class Reference

Camelot's internal clipboard document. More...

#include <clipint.h>

Inheritance diagram for InternalClipboard:

List of all members.

Public Types
enum	ID { CLIPBOARD, DRAGDROP }
Static Public Member Functions
static InternalClipboard *	Instance ()
static InternalClipboard *	Other ()
static void	Swap ()
	Swaps the two internal clipboards, pInstance and pOther. Used to allow drag'n'drop operations to happen without disturbing the internal clipboard.
static ID	GetCurrentID ()
static BOOL	IsEmpty (BOOL AskExternalClipboard=TRUE)
	To determine if there is anything currently stored on the internal clipboard.
static void	DescribeContents (String_64 *Result)
	To determine the description of the clipboard contents.
static DocRect	GetObjectsBounds ()
	For finding the bounds of all objects in the clipboard.
static Layer *	GetInsertionLayer ()
	Returns a pointer to the clipboard's layer node which is the parent of all nodes which get added to the clipboard.
static Range *	GetClipboardRange ()
static BOOL	PrepareForCopy ()
	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 BOOL	CopyInProgress ()
	Allows external entities to determine if they were called during a clipboard copy operation.
static BOOL	CopyObjects (Range &RangeToCopy, Operation *pOp=NULL)
	Copies a range of objects to the clipboard, all previous clipboard contents are deleted. If the copy fails the clipboard is emptied and FALSE returned. It can be called via CALL_WITH_FAIL.
static BOOL	CopyComponentData (BaseDocument *pSrcDoc)
	This function should get called after CopyObjects has been called. It asks all objects to copy accross their component data to the clipboard. It can be called via CALL_WITH_FAIL.
static BOOL	CopyCompleted ()
	Tells the InternalClipboard 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.
static BOOL	CopyText (TCHAR *pBuffer)
	Copies the text on to the clipboard (by converting it to a text object).
static BOOL	PrepareForPaste (BOOL *pExternalSource=0)
	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.
static BOOL	PasteCompleted ()
	Tells the InternalClipboard that you have finished copying data from it. This provides interaction with the external clipboard.
static DocCoord	GetOriginalCentrePoint ()
	Paste-in-place centres the objects when they are pasted at this point.
static void	SetOriginalCentrePoint (DocCoord NewCentre)
	Paste-in-place centres the objects when they are pasted at this point. Reset the centre point but only do so when the centre point is unlocked.
static void	Clear ()
	Deletes the contents of the internal clipboard.
static void	AttrsHaveChanged ()
	This function should be called if the attributes of the Internal clipboard have changed in some way. eg. if a bitmap has been deleted. It destroys the cache of common attributes.
static BOOL	Initialise ()
	This method creates the one and only instance of the InternalClipboard and then initialises it. Called by main3.cpp.
static void	Deinit ()
	This method destroys the InternalClipboard It is called by main.cpp on shutdown (and now by CCamDocTemplate::CloseAllDocuments immediately prior to shutdown).
Protected Member Functions
	InternalClipboard (ID id, BOOL fHide=TRUE)
virtual	~InternalClipboard ()
	InternalClipboard destructor.
virtual BOOL	Init (CCamDoc *pOilDoc)
	This method initialises the Internal clipboard. It is an internal method, called by Initialise() It calls down to Document::Init, then adds an insertion Layer node to the bottom of the basic doc tree.
virtual BOOL	IsNotAClipboard () const
virtual BOOL	IsAClipboard () const
Private Member Functions
BOOL	OnNewClipboardObjects ()
	This fn will be called whenever data has successfuly been transfered to the InternalClipboard. i.e. After a Cut, Copy, or (paste from External Clipboard).
	CC_DECLARE_DYNAMIC (InternalClipboard)
Static Private Member Functions
static void	DescribeContentsInternal (String_64 *Result)
	To determine the description of the clipboard contents.
Private Attributes
Range *	pClipboardRange
BOOL	ClipOp
DocCoord	dcCentre
ID	m_id
BOOL	OriginalCentreLock
Static Private Attributes
static InternalClipboard *	pInstance = 0
static InternalClipboard *	pOther = 0
Friends
class	ExternalClipboard
class	OpDeleteBitmap

---

Detailed Description

Camelot's internal clipboard document.

Author:

Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> (Connection to ExternalClipboard by Jason, OLE stuff by JustinF)

Date:

05/07/94 (19/4/95)

This is a cache, if you like, of the contents of the ExternalClipboard

When Camelot "owns" the external clipboard, the InternalClipboard contains the objects which will be pasted into other applications. (When external apps paste, they will request that Camelot exports the InternalClipboard in some external exchange format)

When Camelot doesn't own the external clipboard, the InternalClipboard will either be empty, or will be a cached copy of the external clipboard (if the user has pasted once into Camelot, while the clipboard remains unchanged, the internal clipboard will have the internal camelot tree representation of the clipboard cached - thus, pasting a .cdr file into camelot will only do the slow conversion once, and subsequent pastes will be 'native')

See also:

ExternalClipboard; Document

Definition at line 139 of file clipint.h.

---

Member Enumeration Documentation

enum InternalClipboard::ID

Enumerator: CLIPBOARD  DRAGDROP  Definition at line 148 of file clipint.h. { CLIPBOARD, DRAGDROP };

---

Constructor & Destructor Documentation

InternalClipboard::InternalClipboard (  ID  id, BOOL  fHide = TRUE )  [protected]

InternalClipboard::~InternalClipboard (   )  [protected, virtual]

InternalClipboard destructor. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Definition at line 178 of file clipint.cpp. { delete pClipboardRange; pClipboardRange = 0; }

---

Member Function Documentation

void InternalClipboard::AttrsHaveChanged (   )  [static]

This function should be called if the attributes of the Internal clipboard have changed in some way. eg. if a bitmap has been deleted. It destroys the cache of common attributes. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Definition at line 530 of file clipint.cpp. { if (pInstance && pInstance->pClipboardRange) { pInstance->pClipboardRange->AttrsHaveChanged(); } }

InternalClipboard::CC_DECLARE_DYNAMIC (  InternalClipboard   )  [private]

void InternalClipboard::Clear (   )  [static]

Deletes the contents of the internal clipboard. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/94 Definition at line 419 of file clipint.cpp. { Layer* Root = GetInsertionLayer(); if (Root == NULL || Root->FindFirstChild() == NULL) return; // The clipboard is empty already // The clipboard range is no longer valid if (pInstance->pClipboardRange) delete pInstance->pClipboardRange; // An empty range. We need to create this cos the operation could fail pInstance->pClipboardRange = new Range; // Delete all objects in clipboard Root->DeleteChildren(Root->FindFirstChild()); // Ensure that the top level of the tree has bounding rect caches invalidated, // as we' ve just vaped the entire subtree below it Root->InvalidateBoundingRect(); // We can't do this at the moment because by the time we're called it seems the component // copy is already under way, and so we're well screwed // Destroy and re-initialise the doc-components (to chuck away unneeded stuff) // DestroyDocComponents(); // if (!InitDocComponents()) // { // ERROR3("DocComponent initialisation failed in InternalClipboard::ClearClipboard"); // } // Instead, we are really only concerned about stacks of colours building up, so // we'll just delete any *unused* IndexedColours from the document's list. (Some colours // are kept in-use by the attribute manager and stuff...) // First, all named colours (styles) ColourList *ColList = pInstance->GetIndexedColours(); IndexedColour *Ptr = (IndexedColour *) ColList->GetHead(); IndexedColour *Next; while (Ptr != NULL) { Next = (IndexedColour *) ColList->GetNext((ListItem*)Ptr); if (!Ptr->IsInUse()) { // Remove this colour from the list ColList->RemoveItem(Ptr); // Ensure this is not in use as a parent of other colours ColList->RemoveLinksToColour(Ptr); // And vape it delete Ptr; } Ptr = Next; } // Now all unnamed colours (locals) List *Locals = ColList->GetUnnamedColours(); Ptr = (IndexedColour *) Locals->GetHead(); while (Ptr != NULL) { Next = (IndexedColour *) Locals->GetNext(Ptr); if (!Ptr->IsInUse()) { // Remove this colour from the list Locals->RemoveItem(Ptr); // And vape it (locals can't be parent colours, so no need to // RemoveLinksToColour() for them) delete Ptr; } Ptr = Next; } // Now do the same for this document's bitmap list BitmapList *pBmpList = pInstance->GetBitmapList(); if (pBmpList) { ListItem* pItem = pBmpList->GetHead(); ListItem* pNextItem; while (pItem) { pNextItem = pBmpList->GetNext(pItem); KernelBitmap* pBmpItem = (KernelBitmap*)pItem; // check if it is the default bitmap, if so then leave in the list if (!pBmpItem->IsDefaultBitmap()) { pBmpList->RemoveItem(pBmpItem); delete pBmpItem; } pItem = pNextItem; } } }

BOOL InternalClipboard::CopyCompleted (  void   )  [static]

Tells the InternalClipboard 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 See also: InternalClipboard::PrepareForCopy; ExternalClipboard::CopyCompleted Definition at line 864 of file clipint.cpp. { if (IsEmpty(FALSE)) { ERROR3("That copy wasn't much fun - the clipboard's still empty!"); return(FALSE); } PORTNOTE("extclipboard", "Removed use of External Clipboard") #ifndef EXCLUDE_FROM_XARALX ExternalClipboard *Clipboard = ExternalClipboard::GetExternalClipboard(); if (Clipboard == NULL) return(FALSE); if (Clipboard->CopyCompleted()) { #endif // Objects have successfully been moved to clipboard. Perform neccessary processing if (!pInstance->OnNewClipboardObjects()) InformError(); return TRUE; #ifndef EXCLUDE_FROM_XARALX } else { return FALSE; } #endif }

BOOL InternalClipboard::CopyComponentData (  BaseDocument *  pSrcDoc  )  [static]

This function should get called after CopyObjects has been called. It asks all objects to copy accross their component data to the clipboard. It can be called via CALL_WITH_FAIL. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/94 Parameters: pSrcDoc,:  The source document [INPUTS] Returns: FALSE if the component data has not successfuly been copied accross. In this situation AbortComponentCopy gets called. Definition at line 667 of file clipint.cpp. { if (IsEmpty(FALSE)) { // The CopyObjects either was not called, or failed ERROR3("InternalClipboard::CopyComponentData called when clipboard is empty!"); return(FALSE); } // Scan all clipboard nodes Node* Root = GetInsertionLayer(); Node* Current = Root->FindFirstDepthFirst(); while (Current != NULL) { // Ask the current node if it would copy it's data to the relevant DocComponents if (Current->IsKindOf(CC_RUNTIME_CLASS(NodeRenderable))) { if (!((NodeRenderable*) Current)->CopyComponentData(pSrcDoc, pInstance)) { // No luck pInstance->AbortComponentCopy(); // Cancel all data which has been copied Clear(); // Tidy up return FALSE; } } Current = Current->FindNextDepthFirst(Root); } return TRUE; // Success }

BOOL InternalClipboard::CopyInProgress (   )  [static]

Allows external entities to determine if they were called during a clipboard copy operation. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/95 Returns: TRUE if we are currently busy copying Definition at line 750 of file clipint.cpp. { return pInstance->ClipOp; }

BOOL InternalClipboard::CopyObjects (  Range &  RangeToCopy, Operation *  pOp = NULL )  [static]

Copies a range of objects to the clipboard, all previous clipboard contents are deleted. If the copy fails the clipboard is emptied and FALSE returned. It can be called via CALL_WITH_FAIL. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/94 Parameters: RangeToCopy,:  The objects to copy to the clipboard [INPUTS] Returns: FALSE if we could not copy See also: InternalClipboard::CopyComponentData() Definition at line 560 of file clipint.cpp. { // Delete the current contents of the clipboard pInstance->ClipOp = TRUE; Clear(); // All objects to be copied to the clipboard need to be made attribute complete or else // they may loose important attributes. This is especially true of objects within groups. if (!(RangeToCopy.MakeAttributeComplete(TRUE,FALSE,TRUE))) return(FALSE); // Failed BOOL Failed = FALSE; // until we know better Node* Root = GetInsertionLayer(); ENSURE(Root != NULL, "Root of clipboard is NULL"); if (!Root->CopyComplexRange(RangeToCopy)) { Failed = TRUE; Clear(); // Tidy up ERROR3("Failed to copy objects"); } // Matt (+Karim, + MarkH + loads of other people I whined to) - 02/02/2001 // Removed David McClarnon's fix for 'copy-inside on bevelled blends' as it causes the operation history to // reference the object in the clipboard - which is deleted when the clipboard is changed !!! -> AccessViolation-ahoy! /* // call post duplicate on all nodes Node * pChildNode = Root->FindFirstDepthFirst(); while (pChildNode && pChildNode != Root) { if (pChildNode->IsAnObject()) { if (pOp != NULL) { if (pOp->IS_KIND_OF(UndoableOperation)) { ((NodeRenderableInk *)pChildNode)->PostDuplicate((UndoableOperation *)pOp); } else { if (!pChildNode->IsABaseTextClass()) ((NodeRenderableInk *)pChildNode)->PostDuplicate(NULL); } } } pChildNode = pChildNode->FindNextDepthFirst(Root); } */ // We now need to optimise the attributes on all objects copied to the clipboard if (!Failed) { Node* FirstNode = pInstance->GetFirstNode(); ERROR3IF(!FirstNode, "Cannot find first clipboard node"); if (FirstNode) { Node* Root = FirstNode->FindNext(); ERROR3IF(!Root, "Clipboard has no root"); ERROR3IF(!(IS_A(Root, NodeDocument)), "This should be the root of the clipboard"); if (Root) { if (!Root->OptimiseAttributes()) { Failed = TRUE; Clear(); } } } } // Ensure that the top level of the tree has bounding rect caches invalidated, // as we've just plugged an entire new subtree in! ((Layer *)Root)->InvalidateBoundingRect(); // We now need to Normalise the attributes of all objects copied RangeToCopy.NormaliseAttributes(FALSE,TRUE); pInstance->ClipOp = FALSE; return (!Failed); }

BOOL InternalClipboard::CopyText (  TCHAR *  pcBuffer  )  [static]

Copies the text on to the clipboard (by converting it to a text object). Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com>, liberally copied from BodgeTextMap::HandleImport Date: 24/4/97 Input: pcBuffer The text to copy on to the clipboard Returns: - See also: TextStory::CreateFromChars, BodgeTextMap::HandleImport Definition at line 1347 of file clipint.cpp. { PORTNOTE("other", "InternalClipboard::CopyText disabled due to use of CCamSrvrItem") #ifndef EXCLUDE_FROM_XARALX //We need to tell CCamSrvrItem that what we are about to put on the clipboard //should be treated as text //To do this, we call RenderProprietary Formats, which sets a flag. The //returned value will be the old state of this flag, which we must remember //cos otherwise Justin will beat me up BOOL fOldState = CCamSrvrItem::RenderProprietaryFormats(FALSE); //If we have some text if (pcBuffer != NULL && pcBuffer[0] != '\0') { //Create a text story, which we position arbitarily on the clipboard TextStory* pTextStory=TextStory::CreateFromChars(DocCoord(100,100), pcBuffer, NULL, InternalClipboard::Instance(), NULL, TRUE); if (pTextStory!=NULL) { //Prepare to copy...this will clear the clipboard PrepareForCopy(); // Attach the text story to the clipboard pTextStory->AttachNode(InternalClipboard::GetInsertionLayer(), LASTCHILD); pTextStory->NormaliseAttributes(); // And format the text story properly pTextStory->FormatAndChildren(NULL,FALSE,FALSE); CopyCompleted(); //And reset the old state of the flag CCamSrvrItem::RenderProprietaryFormats(fOldState); return(TRUE); } // We failed, so clear the clipboard InternalClipboard::Clear(); //And reset the old state of the flag CCamSrvrItem::RenderProprietaryFormats(fOldState); return FALSE; } #endif return FALSE; }

void InternalClipboard::Deinit (   )  [static]

This method destroys the InternalClipboard It is called by main.cpp on shutdown (and now by CCamDocTemplate::CloseAllDocuments immediately prior to shutdown). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Notes: This code may be called multiple times without problems. Please keep it that way. Definition at line 315 of file clipint.cpp. { // Make sure the clipboards are empty. // Sort out the main clipboard first Clear(); // Now sort out the alternate clipborad Swap(); Clear(); Swap(); if (pInstance) { delete pInstance->GetOilDoc(); pInstance = 0; } if (pOther) { delete pOther->GetOilDoc(); pOther = 0; } }

void InternalClipboard::DescribeContents (  String_64 *  Result  )  [static]

To determine the description of the clipboard contents. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/95 Parameters: Result  will be filled in with either a blank string, or a description of the [OUTPUTS] current internal clipboard contents. Notes: Redirects the call to the external clipboard, as it has a better idea of the overall picture. See also: ExternalClipboard::DescribeContents Definition at line 1022 of file clipint.cpp. { ERROR3IF(Result == NULL, "Illegal NULL param"); PORTNOTE("extclipboard", "Removed use of External Clipboard") #ifndef EXCLUDE_FROM_XARALX ExternalClipboard::DescribeContents(Result); #else static String_64 strDesc = String_64(_T("No description (see InternalClipboard::DescribeContents)")); Result = &strDesc; #endif }

void InternalClipboard::DescribeContentsInternal (  String_64 *  Result  )  [static, private]

To determine the description of the clipboard contents. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/95 Parameters: Result  will be filled in with either a blank string, or a description of the [OUTPUTS] current internal clipboard contents. Notes: Internal version of this call, for the external clipboard only. See also: InternalClipboard::DescribeContents Definition at line 1054 of file clipint.cpp. { ERROR3IF(Result == NULL, "Illegal NULL param"); *Result = TEXT(""); if (IsEmpty(FALSE)) return; // --- Scan the document tree to determine the description. Note that this should be // done by calling a range, except that the code is in SelRange, so I've rewritten it here // to save myself half a day's delay waiting for a range.h rebuild when I can't afford it... Node* Subtree = GetInsertionLayer(); if (Subtree == NULL) return; Range ClipRange(Subtree->FindFirstChild(), Subtree->FindLastChild(), RangeControl(TRUE,TRUE,TRUE,TRUE)); String_256 Description; Node* Current = ClipRange.FindFirst(); if (Current == NULL) return; // Implementation Node* FirstInRange = Current; CCRuntimeClass* NodeType = Current->GetRuntimeClass(); // -------------------------------------------------------------------------------- // Determine if there is more than one type of object selected BOOL OneTypeOfObject = TRUE; // TRUE if range contains only // one type of object. do { if (Current->GetRuntimeClass() != NodeType) // Range contains more than one // type of object { // Current object is not the same type as the first so we know there is more // than one type of object. OneTypeOfObject = FALSE; break; } Current = ClipRange.FindNext(Current); } while (Current); UINT32 NumObjectsInRange = ClipRange.Count(); // Count is cached ERROR3IF(NumObjectsInRange <= 0, "No objects selected"); if (OneTypeOfObject) { // All objects in the selection are of the same type String_32 Name; BOOL UseClassToDescribe = TRUE; NodeGroup* FirstGroup = NULL; if (FirstInRange->GetRuntimeClass() == CC_RUNTIME_CLASS(NodeGroup)) { UseClassToDescribe = FALSE; // If all selected groups have the same name then the name is used in the // description FirstGroup = (NodeGroup*)FirstInRange; NodeGroup* CurrentGroup = FirstGroup; Name = CurrentGroup->GetName(); if (!(Name.IsEmpty())) { do { CurrentGroup=(NodeGroup*)ClipRange.FindNext(CurrentGroup); if (CurrentGroup != NULL) { if (CurrentGroup->GetName() != Name) { // A group has been found with a different name. Stop the search and // use the class to describe the selection. UseClassToDescribe = TRUE; break; } } } while (CurrentGroup != NULL); } else { UseClassToDescribe = TRUE; } } if (UseClassToDescribe) { Description = (FirstInRange->Describe(NumObjectsInRange>1)); } else { // Use the group name to describe the selection ERROR3IF(FirstGroup == NULL, "FirstGroup should be the first selected group"); if (NumObjectsInRange > 1) { Description = SelRange::Pluralise(FirstGroup->GetName()); } else { Description = FirstGroup->GetName(); } } } else { // There must be more than one type of selected objects ERROR3IF(NumObjectsInRange <= 1, "Only a single object is in range"); // Cos there are multiple objects of different types we describe them as 'objects' Description = String(_R(IDS_OBJECTS)); } Description.Left(Result, 63); }

static Range* InternalClipboard::GetClipboardRange (   )  [inline, static]

Definition at line 161 of file clipint.h. { return pInstance->pClipboardRange; }

InternalClipboard::ID InternalClipboard::GetCurrentID (   )  [static]

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/96 Returns: The ID of the 'current' clipboard, the one return by Instance(). Definition at line 194 of file clipint.cpp. { return pInstance->m_id; }

Layer * InternalClipboard::GetInsertionLayer (   )  [static]

Returns a pointer to the clipboard's layer node which is the parent of all nodes which get added to the clipboard. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (recoded from Simon's for new clipboard document layout) Date: 23/4/95 (21/7/94) Returns: A pointer to the layer which is the parent of all objects placed on the clipboard Errors: ERROR3 and returns NULL if an internal consistency check fails Definition at line 381 of file clipint.cpp. { // Is there a tree (this gets called during destruction, which is a real pain). if (!pInstance || !pInstance->GetFirstNode()) { TRACEUSER( "JustinF", _T("No first node in InternalClipboard::GetInsertionLayer\n")); return 0; } // Get the first spread Node* pSpread = pInstance->FindFirstSpread(); ERROR3IF(pSpread == NULL, "No spread found in clipboard doc"); // Get the spread's first child... Node *InsPos = pSpread->FindFirstChild(); ERROR3IF(InsPos == NULL, "No spread-child found in clipboard doc"); // And now search across until we find the first layer while (InsPos != NULL && !InsPos->IsLayer()) InsPos = InsPos->FindNext(); ERROR3IF(InsPos == NULL, "No insertion layer found in clipboard doc"); return (Layer*) InsPos; }

DocRect InternalClipboard::GetObjectsBounds (   )  [static]

For finding the bounds of all objects in the clipboard. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/7/94 Returns: The bounds of all objects in the clipboard Definition at line 714 of file clipint.cpp. { DocRect Bounds; ERROR3IF(IsEmpty(FALSE), "InternalClipboard::GetObjectsBounds called when CB is empty"); Node* CurrentNode = GetInsertionLayer()->FindFirstChild(); while (CurrentNode != NULL) { if (CurrentNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded))) { Bounds = Bounds.Union( ( ((NodeRenderableBounded*)CurrentNode)->GetBoundingRect(TRUE, FALSE)) ); } CurrentNode = CurrentNode->FindNext(); } return Bounds; }

DocCoord InternalClipboard::GetOriginalCentrePoint (   )  [static]

Paste-in-place centres the objects when they are pasted at this point. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/96 Returns: The original centre point of the objects on the clipboard before they were copied. See also: InternalClipboard::OnNewClipboardObjects; Definition at line 1305 of file clipint.cpp. { return pInstance->dcCentre; }

BOOL InternalClipboard::Init (  CCamDoc *  pOilDoc  )  [protected, virtual]

This method initialises the Internal clipboard. It is an internal method, called by Initialise() It calls down to Document::Init, then adds an insertion Layer node to the bottom of the basic doc tree. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Parameters: pOilDoc  - the CCamDoc to attach the cliboard to, if any. [INPUTS] Returns: FALSE if it failed See also: InternalClipboard::Initialise(); Document::Init; Document::InitTree Reimplemented from Document. Definition at line 271 of file clipint.cpp. { if (!Document::Init(pOilDoc)) return FALSE; Node *pSpread = FindFirstSpread(); ERROR3IF(pSpread == NULL, "No Spread in document!"); Node *InsPos = pSpread->FindFirstChild(); ERROR3IF(InsPos == NULL, "No Spread-child in document!"); // Now scan the children of the first spread until we find a layer, or run out of nodes while (InsPos != NULL && !InsPos->IsLayer()) InsPos = InsPos->FindNext(); if (InsPos == NULL) // No Layer, so we'd better add one for ourselves { String_256 LayerID = String_256(_R(IDS_K_CLIPINT_LAYERNAME)); Layer *pLayer = new Layer(pSpread, LASTCHILD, LayerID); ERRORIF(!pLayer, _R(IDE_NOMORE_MEMORY), InitFailed()) } OriginalCentreLock = TRUE; // Sucess. return(TRUE);; }

BOOL InternalClipboard::Initialise (   )  [static]

This method creates the one and only instance of the InternalClipboard and then initialises it. Called by main3.cpp. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Definition at line 213 of file clipint.cpp. { // Create the clipboards. if (!(pInstance = new InternalClipboard(InternalClipboard::CLIPBOARD))) return FALSE; if (!(pOther = new InternalClipboard(InternalClipboard::DRAGDROP))) { delete pInstance; return FALSE; } // if (!CCamDoc::Create(pInstance)) PORTNOTE("other", "Clipboard doc should be hidden") CCamDoc* pOilDoc1 = new CCamDoc(pInstance); if (pOilDoc1 == NULL) { delete pInstance; delete pOther; return FALSE; } // if (!CCamDoc::Create(pOther)) PORTNOTE("other", "Clipboard doc should be hidden") CCamDoc* pOilDoc2 = new CCamDoc(pOther); if (pOilDoc2 == NULL) { delete pInstance->GetOilDoc(); delete pOther; return FALSE; } pInstance->OriginalCentreLock = TRUE; return TRUE; }

static InternalClipboard* InternalClipboard::Instance (   )  [inline, static]

Definition at line 151 of file clipint.h. { return pInstance; }

virtual BOOL InternalClipboard::IsAClipboard (   )  const [inline, protected, virtual]

Reimplemented from Document. Definition at line 203 of file clipint.h. { return TRUE; };

BOOL InternalClipboard::IsEmpty (  BOOL  AskExternalClipboard = TRUE  )  [static]

To determine if there is anything currently stored on the internal clipboard. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/95 Parameters: AskExternalClipboard  - if TRUE, this method will tell you if there is ANY [INPUTS] data available for pasting. If FALSE, it simply checks if the internal clipboard (esentially an internal cache) is empty. ONLY the external clipboard (or internal calls in this class) should ever pass in FALSE for this parameter! Returns: TRUE if the clipboard is empty (no data to paste) FALSE if the clipboard is non-empty (there is data available to paste) Notes: If there is no internal clipboard, it will return TRUE Definition at line 777 of file clipint.cpp. { if (pInstance == NULL) return(TRUE); Layer *templayer = pInstance->GetInsertionLayer(); if (!templayer) { ERROR3("Can't get clipboard insertion layer!"); return TRUE; } Node* n = templayer->FindFirstChild(); BOOL Empty = (n == NULL); if (Empty && AskExternalClipboard) { PORTNOTE("extclipboard", "Removed use of External Clipboard") #ifndef EXCLUDE_FROM_XARALX // We're empty, so ask the External clipboard if it can supply us with data ExternalClipboard *Clipboard = ExternalClipboard::GetExternalClipboard(); if (Clipboard == NULL) return(TRUE); return(Clipboard->IsEmpty()); #else return TRUE; #endif } return(Empty); }

virtual BOOL InternalClipboard::IsNotAClipboard (   )  const [inline, protected, virtual]

Reimplemented from Document. Definition at line 202 of file clipint.h. { return FALSE; };

BOOL InternalClipboard::OnNewClipboardObjects (   )  [private]

This fn will be called whenever data has successfuly been transfered to the InternalClipboard. i.e. After a Cut, Copy, or (paste from External Clipboard). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/95 Returns: FALSE if something has gone wrong. An InformError should be called if this occurs. The Cut/Copy/Paste Operation being performed should not be aborted though. Scope: private Definition at line 1192 of file clipint.cpp. { // Set the bounds of the spread containing the objects to the bounds of the objects. Spread* pSpread = FindFirstSpread(); ERROR2IF(!pSpread, FALSE, "No first Spread in InternalClipboard::OnNewClipboardObjects"); // Calculate the bounds of all the objects on the spread (this code is based on // Spread::GetPageVisibleBounds, ie. the function that Zoom to Drawing uses). DocRect drBounds; drBounds.MakeEmpty(); // Search through all the children of the spread, looking for layers. Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer) { // We ignore the guide layers, which always have an empty bounding box // (according to Mark Neves!) if (!pLayer->IsGuide()) { // Include the bounds of the objects on this layer. drBounds = drBounds.Union(pLayer->GetBoundingRect()); } // And onto the next layer ... pLayer = pLayer->FindNextLayer(); } // If the bounds aren't empty then set the page size to be those bounds, so the // page is the smallest size that encloses the objects it contains. if (!drBounds.IsEmpty()) { // Remember the centre of the bounds of the objects, so Paste-In-Place will // still work. dcCentre.x = drBounds.lo.x + drBounds.Width() / 2; dcCentre.y = drBounds.lo.y + drBounds.Height() / 2; // Now convert to document coordinates. pSpread->SpreadCoordToDocCoord(&drBounds); // Work out the new dimensions of the page. /* MILLIPOINT mpWidth = drBounds.Width(); MILLIPOINT mpHeight = drBounds.Height(); // Inflate the size of the page by 5% to give a pleasing border around the objects. const double fpInflate = 1.024695076596; mpWidth = (MILLIPOINT) floor(mpWidth * fpInflate + 0.5); mpHeight = (MILLIPOINT) floor(mpHeight * fpInflate + 0.5); */ PORTNOTE("other", "Removed use of CCamDoc::SetPageSize") #ifndef EXCLUDE_FROM_XARALX //#if (_OLE_VER >= 0x200) // Resize the page to just surround the objects, but don't scale the objects // by the same amount. ERROR2IF(!GetOilDoc()->SetPageSize(mpWidth, mpHeight, FALSE), FALSE, "SetPageSize failed in InternalClipboard::OnNewClipboardObjects"); //#endif #endif // Discard any undo information in this clipboard document. EmptyOperationHistory(); } #ifdef _DEBUG else { // This should be investigated if you see this TRACE. Perhaps because the selection // consisted of invisible layers? TRACE( _T("Warning: no bounds for SetPageSize in InternalClipboard::OnNewClipboardObjects (?)\n")); } #endif // Currently this routine creates a new Range of objects on the clipboard delete pClipboardRange; pClipboardRange = NULL; // Find the first child of the clipboard's layer Node* pNode = Node::FindFirstChapter(this); NodeRenderableInk* pInkNode = NULL; if (pNode) pNode = ((Chapter*) pNode)->FindFirstSpread(); if (pNode) pNode = ((Spread*) pNode)->FindFirstLayer(); if (pNode) { pInkNode = (NodeRenderableInk*)pNode->FindFirstChild(CC_RUNTIME_CLASS(NodeRenderableInk)); while (pInkNode!=NULL && !pInkNode->CanSelectAsCompoundParent()) { if (pInkNode->IsCompoundClass() && ((NodeCompound*)pInkNode)->GetInkNodeFromController()) pInkNode = ((NodeCompound*)pInkNode)->GetInkNodeFromController(); else pInkNode = (NodeRenderableInk*)pInkNode->FindFirstChild(CC_RUNTIME_CLASS(NodeRenderableInk)); } } ERROR3IF(!pInkNode, "InternalClipboard::OnNewClipboardObjects, Where has the clipboard gone ??"); if (!pInkNode) return FALSE; // What else can we do ? // Try to create a range of all objects. pClipboardRange = new Range(pInkNode, NULL, RangeControl(TRUE, TRUE)); return pClipboardRange != 0; }

static InternalClipboard* InternalClipboard::Other (   )  [inline, static]

Definition at line 152 of file clipint.h. { return pOther; }

BOOL InternalClipboard::PasteCompleted (  void   )  [static]

Tells the InternalClipboard 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 PrepareForCopy See also: InternalClipboard::PrepareForPaste; ExternalClipboard::PasteCompleted Definition at line 981 of file clipint.cpp. { if (IsEmpty(FALSE)) { ERROR3("That paste wasn't much fun - the clipboard's empty now!"); } PORTNOTE("extclipboard", "Removed use of External Clipboard") #ifndef EXCLUDE_FROM_XARALX ExternalClipboard *Clipboard = ExternalClipboard::GetExternalClipboard(); if (Clipboard == NULL) return(FALSE); return(Clipboard->PasteCompleted()); #else return TRUE; #endif }

BOOL InternalClipboard::PrepareForCopy (  void   )  [static]

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 See also: InternalClipboard::CopyCompleted; InternalClipboard::PrepareForPaste; ExternalClipboard::PrepareForCopy Definition at line 830 of file clipint.cpp. { Clear(); PORTNOTE("extclipboard", "Removed use of External Clipboard") #ifndef EXCLUDE_FROM_XARALX ExternalClipboard* pcb = ExternalClipboard::GetExternalClipboard(); return pcb ? pcb->PrepareForCopy() : FALSE; #else return TRUE; #endif }

BOOL InternalClipboard::PrepareForPaste (  BOOL *  ExternalSource = 0  )  [static]

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 Parameters: ExternalSource,:  When the function returns TRUE, ExternalSource will be TRUE [OUTPUTS] if the data has come from the external clipboard, and FALSE if not. 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 See also: InternalClipboard::PasteCompleted; InternalClipboard::PrepareForCopy; ExternalClipboard::PrepareForPaste Definition at line 919 of file clipint.cpp. { if (ExternalSource) *ExternalSource = FALSE; // Until we know better pInstance->OriginalCentreLock = TRUE; // Don't allow centre to be reset // If we are empty, then we'll have to go and look outside for something to put onto // the internal clipboard. if (IsEmpty(FALSE)) { PORTNOTE("extclipboard", "Removed use of External Clipboard") #ifndef EXCLUDE_FROM_XARALX ExternalClipboard *Clipboard = ExternalClipboard::GetExternalClipboard(); if (Clipboard == NULL || !Clipboard->PrepareForPaste()) return(FALSE); // Optimise attributes on the clipboard Node* FirstNode = pInstance->GetFirstNode(); ERROR3IF(!FirstNode, "Cannot find first clipboard node"); if (FirstNode) { Node* Root = FirstNode->FindNext(); ERROR3IF(!Root, "Clipboard has no root"); ERROR3IF(!(IS_A(Root, NodeDocument)), "This should be the root of the clipboard"); if (Root && !Root->OptimiseAttributes()) return FALSE; } // Objects successfully transferred to clipboard. Perform neccessary processing if (!pInstance->OnNewClipboardObjects()) InformError(); pInstance->OriginalCentreLock = FALSE; // Allow centre to be reset on first Paste // Data has come from external clipboard if (ExternalSource) *ExternalSource = TRUE; #endif } return(TRUE); }

void InternalClipboard::SetOriginalCentrePoint (  DocCoord  NewCentre  )  [static]

Paste-in-place centres the objects when they are pasted at this point. Reset the centre point but only do so when the centre point is unlocked. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/96 Input: NewCentre A position that the caller would like to record as being the "original centre" of the objects on the clipboard. Returns: - See also: InternalClipboard::OnNewClipboardObjects, OpPaste::DoPasteStandard; Definition at line 1326 of file clipint.cpp. { if (!pInstance->OriginalCentreLock) { pInstance->dcCentre = NewCentre; pInstance->OriginalCentreLock = TRUE; } }

void InternalClipboard::Swap (   )  [static]

Swaps the two internal clipboards, pInstance and pOther. Used to allow drag'n'drop operations to happen without disturbing the internal clipboard. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 29/9/96 Returns: Errors: - See also: - Definition at line 355 of file clipint.cpp. { InternalClipboard* pcb = pInstance; pInstance = pOther; pOther = pcb; }

---

Friends And Related Function Documentation

friend class ExternalClipboard [friend]

Definition at line 223 of file clipint.h.

friend class OpDeleteBitmap [friend]

Definition at line 224 of file clipint.h.

---

Member Data Documentation

BOOL InternalClipboard::ClipOp [private]

Definition at line 215 of file clipint.h.

DocCoord InternalClipboard::dcCentre [private]

Definition at line 216 of file clipint.h.

ID InternalClipboard::m_id [private]

Definition at line 217 of file clipint.h.

BOOL InternalClipboard::OriginalCentreLock [private]

Definition at line 218 of file clipint.h.

Range* InternalClipboard::pClipboardRange [private]

Definition at line 214 of file clipint.h.

InternalClipboard * InternalClipboard::pInstance = 0 [static, private]

Definition at line 212 of file clipint.h.

InternalClipboard * InternalClipboard::pOther = 0 [static, private]

Definition at line 213 of file clipint.h.

---

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

• Kernel/clipint.h (r1785/r1282)
• Kernel/clipint.cpp (r1785/r1282)

---