Layer Class Reference

Layers optionally exist on a page, they group together objects which are drawn at a particular level in a document. More...

#include <layer.h>

Inheritance diagram for Layer:

List of all members.

Public Member Functions
	Layer ()
	This constructor creates a Layer linked to no other nodes, with all status flags false, and NULL bounding and pasteboard rectangles.
	~Layer ()
	Default destructor.
	Layer (Node *ContextNode, AttachNodeDirection Direction, const String_256 &LayerID, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This method initialises the node and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated.
String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method.
virtual SubtreeRenderState	RenderSubtree (RenderRegion *pRender, Node **ppNextNode=NULL, BOOL bClip=TRUE)
	Virtual function - this version decides whether or not a layer should be rendered according to the ExcludeLockedLayers flags and the state of the layer itself.
virtual void	RenderAfterSubtree (RenderRegion *pRender)
	Capture the group as a cached bitmap.
virtual BOOL	NeedsToExport (RenderRegion *pRender, BOOL VisibleLayersOnly=FALSE, BOOL CheckSelected=FALSE)
	Indicate that we want to export layers. Now takes a parameter to say whether we want to take notice of the layers visible status when deciding about exporting it or not.
void	PreExportRender (RenderRegion *pRegion)
	Outputs data to mark the beginning of a layer.
BOOL	ExportRender (RenderRegion *pRegion)
	Called after all child nodes are asked to export.
BOOL	IsLayer () const
	Indicate that we are a layer (overrides function in Node).
DocRect	GetPasteboardRect (BOOL Pixelise=TRUE, View *pView=NULL) const
	For obtaining the layer's pasteboard rectangle which is actually the pasteboard rectangle of its parent spread node.
Layer *	FindNextLayer (BOOL ExcludeInvisible=FALSE, BOOL ExcludeLocked=FALSE)
	To find the next sibling layer.
Layer *	FindPrevLayer (BOOL ExcludeInvisible=FALSE, BOOL ExcludeLocked=FALSE)
	To find the prev sibling layer.
Layer *	FindNextFrameLayer ()
	To find the next sibling frame layer.
Layer *	FindPrevFrameLayer ()
	To find the prev sibling frame layer.
virtual BOOL	HidingNode ()
	This virtual function is called whenever the node is hidden. It allows the node do things like 'optimise' itself to use less memory or send a message to let others know it is being hidden etc.
BOOL	IsVisible (DocView *pDocView=NULL)
	For finding the layers visible status.
BOOL	IsLocked ()
	For finding the layers locked status A layer is locked if the following is true - The layer's locked flag is TRUE AND The layer is NOT active (clause not used in Alpha release 15/8/94) AND The Multilayer flag in the parent document is FALSE.
BOOL	IsActive ()
	For finding the layers active status.
BOOL	IsPrintable ()
	For finding the layers printable status.
BOOL	IsBackground ()
	For finding the layers background status.
BOOL	IsOutline ()
	For finding the layers outline status.
BOOL	IsGuide ()
	For finding the layers guide status.
BOOL	IsPageBackground ()
	For finding the layer's page background status.
String_256 &	GetLayerID ()
	For finding the layers identifier.
BOOL	IsOverlay ()
	For finding the frame's/layer's Overlay status.
BOOL	IsSolid ()
	For finding the frame's/layer's Solid status.
BOOL	IsEdited ()
	For finding the frame's/layer's Edited status.
BOOL	IsFrame ()
	For finding the frame's/layer's Frame status.
BOOL	IsHiddenFrame ()
	For finding the frame's/layer's Hidden status This marks this frame as a hidden frame layer which will not be saved into the GIF animation but may take part in the rendering process of other frames.
BOOL	IsPseudoFrame ()
	For finding out whether this might be regarded as a frame layer without especially having its frame flag set.
BOOL	GetVisibleFlagState ()
	Returns the raw state of the layer's visible flag (specialist use only).
BOOL	GetLockedFlagState ()
	Returns the raw state of the layer's Locked flag (specialist use only).
BOOL	HasLayerGotRenderableChildren ()
	Scans the layer for children that render something on the screen. It ignores attributes, hidden nodes, etc - nodes that don't render anything themselves.
BOOL	IncludeLayerInBoundingCalcs ()
	For finding out whether to include the layer in bounding box calcalutions. This may not be a simple IsVisible test as usually you want to exclude the two special layers:- guides and page background. This function should be used when:- Calculating drawing sizes for zooming Calculating drawing sizes for export.
LayerStatus &	GetLayerStatus ()
	Returns the layers status.
void	SetVisible (BOOL Status)
	To set the Layer's visible flag status (TRUE/FALSE).
void	SetLocked (BOOL Status)
	To set the Layer's locked flag status (TRUE/FALSE).
void	SetActive (BOOL Status)
	To set the Layer's active flag status (TRUE/FALSE).
void	SetPrintable (BOOL Status)
	To set the Layer's printable flag status (TRUE/FALSE).
void	SetBackground (BOOL Status)
	To set the Layer's background flag status (TRUE/FALSE).
void	SetOutline (BOOL Status)
	To set the Layer's outline flag status (TRUE/FALSE).
void	SetGuide (BOOL Status)
	To set the Layer's Guide flag status (TRUE/FALSE).
void	SetPageBackground (BOOL Status)
	To set the Layer's PageBackground flag status (TRUE/FALSE).
void	SetLayerID (String_256 &LayerID)
	For setting the layer's identifier.
void	SetLayerStatus (LayerStatus &Status)
	To set the layers status.
void	SetSolid (BOOL Status)
	To set the Frame/Layer's Solid flag status (TRUE/FALSE).
void	SetOverlay (BOOL Status)
	To set the Frame/Layer's Overlay flag status (TRUE/FALSE).
void	SetEdited (BOOL Status)
	To set the Frame/Layer's Edited flag status (TRUE/FALSE).
void	SetFrame (BOOL Status)
	To set the Frame/Layer's Frame flag status (TRUE/FALSE).
void	SetHiddenFrame (BOOL Status)
	To set the Frame/Layer's Hidden flag status (TRUE/FALSE).
void	EnsureUniqueLayerID (void)
	Ensures that the layers ID is unique amoung it's siblings. Call after the node is linked into the document tree.
void	GetDebugDetails (StringBase *Str)
	For obtaining debug information about the Node.
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual DocRect	GetBlobBoundingRect ()
	Returns the layer's bounding rect inflated by the size of a blob.
BOOL	BelongsToDocument (Document *pDoc)
	Checks to see if this layer belongs to the document, i.e. the node is part of the tree that is attached to the given document.
Document *	FindDocument ()
	This should be able to return the document associated with this layer. If not, then this program is a worthless piece of junk and way beyond repair.
virtual BOOL	AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE)
	Layers will allow any op to happen to them, or to their children.
virtual void	SetOpPermission (OpPermissionState NewState, BOOL AndParents=FALSE)
	Calls Node::SetOpPermission(NewState,FALSE), i.e. you can set the layer's op permission state, but the 'AndParent' param is ignored.
DocColour *	GetGuideColour ()
	Returns the DocColour that specifies the colour to render the guide objects in this layer with.
void	SetGuideColour (IndexedColour *pIndexedColour)
	Assigns the given indexed colour as the colour to render guide objects in this layer in.
void	MakeGuideColourDefault ()
	Makes the current colour the default for all guide layers.
DocColour	GetDefaultGuideColour ()
	Makes the current colour the default for all guide layers.
void	ColourChanged (IndexedColour *pChangedColour)
	Called when a colour has changed.
void	ColourDeleted ()
	Called when a colour may have been deleted.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes out the layer data suitable for the web format.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
	Writes out the layer data suitable for the native format.
virtual BOOL	WritePostChildrenWeb (BaseCamelotFilter *pFilter)
	Gives the node a change to write data to the filter after its children have been automatically written out.
virtual BOOL	WritePostChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	CanWriteChildrenWeb (BaseCamelotFilter *pFilter)
	Determines if the layer should write out its contents in the web format.
virtual BOOL	CanWriteChildrenNative (BaseCamelotFilter *pFilter)
	Determines if the layer should write out its contents in the native format.
virtual BOOL	WriteBeginChildRecordsWeb (BaseCamelotFilter *pFilter)
virtual BOOL	WriteBeginChildRecordsNative (BaseCamelotFilter *pFilter)
	Begins the child record sequence for layers in the native format.
virtual BOOL	WriteEndChildRecordsWeb (BaseCamelotFilter *pFilter)
virtual BOOL	WriteEndChildRecordsNative (BaseCamelotFilter *pFilter)
	Ends the child record sequence for layers in the native format.
virtual BOOL	ReadPostChildrenWeb (BaseCamelotFilter *pFilter)
	This function is called during the importing of the file.
virtual BOOL	ReadPostChildrenNative (BaseCamelotFilter *pFilter)
virtual UINT32	CountNumWritableWebLayers (BaseCamelotFilter *pFilter)
	Counts how many layers are writable, as determined by Layer::CanWriteChildrenWeb().
virtual BOOL	WriteAtomicNodesColourRefs (Node *pLayer, BaseCamelotFilter *pFilter)
	All compound nodes (e.g. bevels, contours, shadows, clipview) are now defined as being atomic. This is so that they can be backwards compatible with CX2. This means that colour definitions that occur within these nodes are omitted when CX2 reads the files. The cause access violations when another colour definition references the omitted. Thus, compund atomic nodes MUST write colour definitions BEFORE the node is written. The function scans the document for relevent nodes, and cause them to write out their colour definitions immediately after the layer node. This is only done of compound atomic nodes, since doing it for all would slow down other peoples distributed stuff.
virtual PathName	MakeExportLayerName (const PathName &path)
	Make a pathname that's specific to this layer.
virtual BOOL	WriteFrameLayerProperties (BaseCamelotFilter *pFilter)
	Exports the delay details for this frame layer to the filter.
DWORD	GetFrameDelay ()
void	SetFrameDelay (const DWORD &Delay)
Quality	GetCaptureQuality ()
void	SetCaptureQuality (const Quality &NewQuality)
KernelBitmap *	GetGeneratedBitmap ()
	To recover the bitmap that has been generated to represent this layer, if any.
BOOL	SetGeneratedBitmap (KernelBitmap *pBitmap)
	To set the bitmap that has been generated to represent this layer.
virtual KernelBitmap *	EnumerateBitmaps (UINT32 Count)
	Find out what bitmaps, if any, are used by this node.
KernelBitmap *	GetReferencedBitmap ()
	To recover the bitmap that is present on the layer and is of the correct sort so that it can be used to represent this layer.
BOOL	SetReferencedBitmap (KernelBitmap *pBitmap)
	To set the bitmap that has been found which is a single bitmap on this layer which is of the correct colour depth and scaling which can be used to directly represent this layer. Usually, the bitmap will be part of an animation that has been loaded in.
virtual ChangeCode	OnChildChange (ObjChangeParam *pParam)
	We override the function to mark layers as edited. This should do the same as the baseclass i.e. return ok but should else set the edited flag to true. Composite objects can use this function to respond to one of their children undergoing a change. They should return CC_FAIL whenever they are unable to cope with the change.
Static Public Member Functions
static BOOL	Init ()
	Does any layer initialisation necessary. Declares some layer INI settings Creates a layer message handler.
static void	Deinit ()
	Deinits the layer system. This deletes the layer message handler.
static Layer *	CreateGuideLayer ()
	This does everything required in creating a layer fit to be called the guide layer.
Static Public Attributes
static BOOL	ActiveLayerVisibleAndEditable = FALSE
	Dictates whether the active layer is automatically made visible and editable or whether it is left in its last state which might include it being invisible. Defaults to the old system (FALSE).
static INT32	EnableLayerCacheing = 1
	Control whether layers are cached or not.
Protected Member Functions
virtual Node *	SimpleCopy ()
	This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes.
void	CopyNodeContents (Layer *NodeCopy)
	This method copies the node's contents to the node pointed to by NodeCopy.
Private Attributes
LayerStatus	LayerSt
BOOL	Active
BOOL	Visible
BOOL	Locked
BOOL	Printable
BOOL	Background
BOOL	Outline
BOOL	Guide
BOOL	m_PageBackground
BOOL	m_Overlay
BOOL	m_Solid
BOOL	m_Edited
BOOL	m_Frame
BOOL	m_HiddenFrame
DWORD	m_FrameDelay
Quality	m_CaptureQuality
KernelBitmapRef	m_GeneratedBitmap
KernelBitmap *	m_pReferencedBitmap
DocColour *	pGuideColour
IndexedColour *	pIndexedGuideColour
Static Private Attributes
static INT32	GuideLayerRed = 255
static INT32	GuideLayerGreen = 0
static INT32	GuideLayerBlue = 0
static LayerMsgHandler *	pLayerMsgHandler = NULL

---

Detailed Description

Layers optionally exist on a page, they group together objects which are drawn at a particular level in a document.

Author:

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

Date:

25/4/93

See also:

NodeRenderablePaper

Chapter

Spread

Page

Definition at line 158 of file layer.h.

---

Constructor & Destructor Documentation

Layer::Layer (   )

This constructor creates a Layer linked to no other nodes, with all status flags false, and NULL bounding and pasteboard rectangles. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: Definition at line 275 of file layer.cpp. : NodeRenderablePaper() { // Set all layer flags to their defaults Visible = TRUE; Locked = FALSE; Printable = TRUE; Background = FALSE; Outline = FALSE; Guide = FALSE; Active = FALSE; pGuideColour= NULL; pIndexedGuideColour = NULL; m_PageBackground = FALSE; // Frame related items m_Solid = FALSE; m_Overlay = FALSE; m_Edited = FALSE; m_Frame = FALSE; m_HiddenFrame = FALSE; m_FrameDelay = 10; m_pReferencedBitmap = NULL; // DO NOT DELETE as it is a reference }

Layer::~Layer (   )

Default destructor. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Returns: Errors: Definition at line 313 of file layer.cpp. { if (pGuideColour != NULL) delete pGuideColour; if (pIndexedGuideColour != NULL) delete pIndexedGuideColour; m_pReferencedBitmap = NULL; // DO NOT DELETE as it is a reference }

Layer::Layer (  Node *  ContextNode, AttachNodeDirection  Direction, const String_256 &  LayerID, BOOL  NodeLocked = FALSE, BOOL  Mangled = FALSE, BOOL  Marked = FALSE, BOOL  Selected = FALSE )

This method initialises the node and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] Direction: Specifies the direction in which this node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node LayerID: String which uniquely identifies layer within the spread The remaining inputs specify the status of the node: Locked: Is node locked ? Mangled: Is node mangled ? Marked: Is node marked ? Selected: Is node selected ? Parameters: -  [OUTPUTS] Returns: - Errors: An assertion error will occur if ContextNode is NULL Definition at line 373 of file layer.cpp. : NodeRenderablePaper(ContextNode, Direction, NodeLocked, Mangled, Marked, Selected) { // Set all layer flags to their defaults Visible = TRUE; Locked = FALSE; Printable = TRUE; Background = FALSE; Outline = FALSE; Guide = FALSE; Active = FALSE; m_PageBackground = FALSE; // Frame related flags m_Overlay = FALSE; m_Solid = FALSE; m_Edited = FALSE; m_Frame = FALSE; m_HiddenFrame = FALSE; m_FrameDelay = 10; m_pReferencedBitmap = NULL; // DO NOT DELETE as it is a reference pGuideColour = NULL; pIndexedGuideColour = NULL; LayerSt.StringLayerID = LayerID; }

---

Member Function Documentation

BOOL Layer::AllowOp (  ObjChangeParam *  pParam, BOOL  SetOpPermissionState = TRUE, BOOL  DoPreTriggerEdit = TRUE )  [virtual]

Layers will allow any op to happen to them, or to their children. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> 20/01/2000 Date: 6/02/95 Parameters: pParam  = describes the way an op wants to change the node [INPUTS] SetOpPermissionState = if TRUE the Op permission state of this node will be set according to the outcome of the call DoPreTriggerEdit = layers and the nodes above them are not part of the stretching mechanism, and hence do not use this flag at all. -  [OUTPUTS] Returns: TRUE always!! The main purpose for layers overriding this func is to ensure that layers become the top level node in the tree for the op permission mechanism, i.e. parents of layers (spreads, etc) shouldn't play a part. This func will always return TRUE, and if 'SetOpPermissionState' is TRUE, the layer's op permission state will be set to PERMISSION_ALLOWED. See also: Node::AllowOp(),Node::GetOpPermission(),Node::SetOpPermission(),Layer::SetOpPermission() Reimplemented from Node. Definition at line 2554 of file layer.cpp. { if (SetOpPermissionState) SetOpPermission(PERMISSION_ALLOWED); return TRUE; }

BOOL Layer::BelongsToDocument (  Document *  pDoc  )

Checks to see if this layer belongs to the document, i.e. the node is part of the tree that is attached to the given document. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/94 Parameters: pDoc  = ptr to the document [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer belongs to the current document Errors: - See also: - Definition at line 1198 of file layer.cpp. { ENSURE(pDoc != NULL,"Get a NULL pDoc"); if (pDoc == NULL) return FALSE; Node* pTreeStart = pDoc->GetFirstNode(); ENSURE(pTreeStart != NULL,"This doc doesn't have a tree start node"); Node* pNodeDoc = pTreeStart->FindNext(CC_RUNTIME_CLASS(NodeDocument)); Node* pThisNodeDoc = FindParent(CC_RUNTIME_CLASS(NodeDocument)); ENSURE(pNodeDoc != NULL,"This doc has no NodeDocument node"); ENSURE(pThisNodeDoc != NULL,"This layer has no NodeDocument parent node"); BOOL ok = ((pNodeDoc != NULL) && (pThisNodeDoc != NULL) && (pNodeDoc == pThisNodeDoc)); if( !ok ) { TRACEUSER( "MarkN", _T("-------\n")); TRACEUSER( "MarkN", _T("pDoc = %ld 0x%p\n"),pDoc,pDoc); TRACEUSER( "MarkN", _T("pLayer = %ld 0x%p\n"),this,this); TRACEUSER( "MarkN", _T("Layer's NodeDoc = %ld 0x%p\n"),pThisNodeDoc,pThisNodeDoc); TRACEUSER( "MarkN", _T("pDoc's NodeDoc = %ld 0x%p\n"),pNodeDoc,pNodeDoc); } return (ok); }

BOOL Layer::CanWriteChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Determines if the layer should write out its contents in the native format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 31/7/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE if it's ok to write out the layer's children FALSE otherwise Native files will not write out layers when: It's actually the cack compact format AND The user has selected "Remove invisible layers" AND The layer is invisible The layer is NOT a frame layer See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 2884 of file layer.cpp. { #ifdef DO_EXPORT // if we are saving in the compact format, and // the user has selected to remove invisible layers & the layer is invisible, // then don't let the children go out if (pFilter->IsCompactNativeFilter()) { // If user doesn't want visible layers, and it's not visible and it's not a animated GIF frame layer, don't bother if (pFilter->GetRemoveInvisibleLayers() && !IsVisible() && !IsFrame()) return FALSE; } return Node::CanWriteChildrenNative(pFilter); #else return FALSE; #endif }

BOOL Layer::CanWriteChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Determines if the layer should write out its contents in the web format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 31/7/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE if it's ok to write out the layer's children FALSE otherwise Web files will not write out the following types of layer: Invisible layers Layers than contain no renderable objects Guide layers See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 2837 of file layer.cpp. { #ifdef DO_EXPORT // If not visible and not a animated GIF frame layer, don't bother if (!IsVisible() && !IsFrame()) return FALSE; // If a guide layer, don't bother if (IsGuide()) return FALSE; // If no renderable objects on the layer and not a animated GIF frame layer, don't bother if (!IsFrame()) { DocRect Rect = GetBoundingRect(); if (Rect.IsEmpty()) return FALSE; } return TRUE; #else return FALSE; #endif }

void Layer::ColourChanged (  IndexedColour *  pChangedColour  )

Called when a colour has changed. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: pChangedColour  = ptr to the colour that's just changed [INPUTS] -  [OUTPUTS] Returns: - See also: ColourDeleted() Definition at line 3218 of file layer.cpp. { // WEBSTER - markn 15/1/97 // Don't need this in Webster #ifndef WEBSTER #if !defined(EXCLUDE_FROM_RALPH) if (pChangedColour == NULL || pGuideColour == NULL) return; IndexedColour* pColour = pGuideColour->FindParentIndexedColour(); if (pChangedColour == pColour) { Document* pDoc = Document::GetCurrent(); if (pDoc != NULL) LayerSGallery::ForceRedrawLayer(pDoc,this); } #endif #endif // WEBSTER }

void Layer::ColourDeleted (   )

Called when a colour may have been deleted. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: ColourChanged() Definition at line 3253 of file layer.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (pGuideColour != NULL) { IndexedColour* pIndexedColour = pGuideColour->FindParentIndexedColour(); if (pIndexedColour != NULL && pIndexedColour->IsDeleted()) { ColourGeneric ColGen; pIndexedColour->GetSourceColour(&ColGen); ColourModel Model = pIndexedColour->GetColourModel(); IndexedColour* pNewColour = new IndexedColour(Model,&ColGen); SetGuideColour(pNewColour); // Document* pDoc = Document::GetCurrent(); // if (pDoc != NULL) // LayerSGallery::ForceRedrawLayer(pDoc,this); } } #endif }

void Layer::CopyNodeContents (  Layer *  NodeCopy  )  [protected]

This method copies the node's contents to the node pointed to by NodeCopy. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/8/94 Parameters: NodeCopy  = ptr to the layer node that needs to become a copy of this layer [INPUTS] The  layer at *NodeCopy is a identical copy of this layer [OUTPUTS] Returns: - Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Definition at line 737 of file layer.cpp. { // Ensure the pointer's not null ENSURE(NodeCopy != NULL,"Trying to copy a node's contents into a NULL node"); // Get immediate base class to copy its bits NodeRenderablePaper::CopyNodeContents(NodeCopy); // Copy layer-specific stuff now. NodeCopy->LayerSt = LayerSt; NodeCopy->Active = Active; NodeCopy->Visible = Visible; NodeCopy->Locked = Locked; NodeCopy->Printable = Printable; NodeCopy->Background = Background; NodeCopy->Outline = Outline; NodeCopy->Guide = Guide; NodeCopy->Active = Active; NodeCopy->Visible = Visible; NodeCopy->Locked = Locked; NodeCopy->Printable = Printable; NodeCopy->Background = Background; NodeCopy->Outline = Outline; NodeCopy->Guide = Guide; // Copy across the useful frame related information NodeCopy->m_FrameDelay = m_FrameDelay; NodeCopy->m_Overlay = m_Overlay; NodeCopy->m_Solid = m_Solid; NodeCopy->m_Frame = m_Frame; NodeCopy->m_HiddenFrame = m_HiddenFrame; NodeCopy->m_Edited = m_Edited; NodeCopy->m_PageBackground = m_PageBackground; }

UINT32 Layer::CountNumWritableWebLayers (  BaseCamelotFilter *  pFilter  )  [virtual]

Counts how many layers are writable, as determined by Layer::CanWriteChildrenWeb(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 2/8/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: The number of layers that will be written in the web file The count looks at all layers, including this one, in the spread to which this layer belongs See also: CanWriteChildrenWeb() Definition at line 2696 of file layer.cpp. { #ifdef DO_EXPORT /***************************************************** See note in BOOL Layer::WritePreChildrenWeb(BaseCamelotFilter* pFilter) for a reason why this code is commented out (markn 12/8/96) UINT32 WritableLayerCount = 0; Spread* pSpread = (Spread*)FindParent(CC_RUNTIME_CLASS(Spread)); if (pSpread != NULL) { Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL) { if (pLayer->CanWriteChildrenWeb(pFilter)) WritableLayerCount++; pLayer = pLayer->FindNextLayer(); } } return WritableLayerCount; ******************************************************/ return 0; #else return 0; #endif }

Layer * Layer::CreateGuideLayer (   )  [static]

This does everything required in creating a layer fit to be called the guide layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Ptr to a guide layer that's ready to be inserted into the tree WEBSTER - markn - 15/1/97 Moved from OpGuideLine for WEBSTER purposes, but it should be in this class anyway See also: - Definition at line 3294 of file layer.cpp. { Layer* pNewLayer = new Layer; if (pNewLayer != NULL) { String_256 LayerName(_R(IDS_GUIDESLAYERNAME)); pNewLayer->SetVisible(TRUE); pNewLayer->SetLocked(FALSE); pNewLayer->SetPrintable(FALSE); // pNewLayer->SetBackground(TRUE); pNewLayer->SetBackground(FALSE); // make sure Guides are in the "normal" foreground section pNewLayer->SetOutline(FALSE); pNewLayer->SetGuide(TRUE); pNewLayer->SetLayerID(LayerName); Quality Qual; Qual.SetQuality(-1); QualityAttribute QualAttr(Qual); NodeAttribute* pNodeAttr = QualAttr.MakeNode(); pNodeAttr->AttachNode(pNewLayer,FIRSTCHILD); } return pNewLayer; }

void Layer::Deinit (  void   )  [static]

Deinits the layer system. This deletes the layer message handler. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: Definition at line 248 of file layer.cpp. { if (pLayerMsgHandler != NULL) { delete pLayerMsgHandler; pLayerMsgHandler = NULL; } }

String Layer::Describe (  BOOL  Plural, BOOL  Verbose )  [virtual]

To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Parameters: Plural,:  Flag indicating if the string description should be plural or [INPUTS] singular. -  [OUTPUTS] Retuns: Description of the object The description will always begin with a lower case letter. Returns: Errors: A resource exception will be thrown if a problem occurs when loading the string resource. See also: - Reimplemented from Node. Definition at line 644 of file layer.cpp. { if (Plural) return(String(_R(IDS_LAYER_DESCRP))); else return(String(_R(IDS_LAYER_DESCRS))); };

void Layer::EnsureUniqueLayerID (  void   )

Ensures that the layers ID is unique amoung it's siblings. Call after the node is linked into the document tree. Author: Ben_Summers (Xara Group Ltd) <camelotdev@xara.com> Date: 18/04/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: Layer::SetLayerID Definition at line 2603 of file layer.cpp. { // first, find the first sibling of this node Layer *pFirstSibling = this; Layer *pPrevious = NULL; while ((pPrevious = pFirstSibling->FindPrevLayer()) != NULL) pFirstSibling = pPrevious; // then run though checking to see if the name is unqiue. String_256 ID = GetLayerID(); INT32 Count = 1; // the count of the extra number to give the layer Layer *pExamine = NULL; BOOL Unique = FALSE; BOOL Changed = FALSE; // whether the ID got changed do { // run through the siblings to find out if their ID match this one pExamine = pFirstSibling; Unique = TRUE; while (pExamine != NULL) { // don't fiddle with this layer if (pExamine != this) { // OK, does it match? Layer *pLayer = pExamine; if (pLayer->GetLayerID() == ID) { // nope Unique = FALSE; break; } } // next thing to look at... pExamine = pExamine->FindNextLayer(); } // right then, is it unique? if (Unique == FALSE) { // munge up a new layer name Count++; // there is a problem here.. // a) ralph has no string resources // b) MakeMsg has been bodged so that it never fails // the result is that ralph sits in this loop forever // ralph doesn't give a fig about layer names so just get out of here #ifdef RALPH return; #endif UINT32 format_id = _R(IDT_LAYERNAMEUNIQUEFORM); // "#1%s (#2%d)" // If its a frame then use a different form of unique formatter without the brackets if (IsFrame()) format_id = _R(IDS_FRAMENAMEUNIQUEFORM); // "#1%s #2%d" if (ID.MakeMsg(format_id, (TCHAR *)GetLayerID(), Count) == 0) return; // error getting a string -- give up! (doesn't really matter as the only problem will be the user seeing two layers with the same name) Changed = TRUE; // and then try again... } } while (Unique == FALSE); // and if it needs to be changed, change it if (Changed) SetLayerID(ID); }

KernelBitmap * Layer::EnumerateBitmaps (  UINT32  Count  )  [virtual]

Find out what bitmaps, if any, are used by this node. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> based on Will code Date: 7/5/97 Parameters: Count  - the bitmap to get (see Purpose). [INPUTS] Returns: The KernelBitmap in use by the node, or NULL if no more are used. The base class returns NULL always, so you over-ride this in any node classes that use bitmaps. This function supports nodes that use more than one bitmap - you call this function repeatedly and keep incrementing the Count parameter that you pass in each time by 1. You should stop calling it when it returns NULL, as this indicates that no more bitmaps are used by this node. Count should start off as 0 for the first call. Note that this function can (and often will) return NULL for the first call, as many nodes don't use bitmaps, obviously. See also: KernelBitmap Reimplemented from Node. Definition at line 2133 of file layer.cpp. { if (Count == 0) return GetGeneratedBitmap(); return NULL; }

BOOL Layer::ExportRender (  RenderRegion *  pRegion  )  [virtual]

Called after all child nodes are asked to export. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/95 Parameters: pRegion  = the render region to export to [INPUTS] -  [OUTPUTS] Returns: - Reimplemented from Node. Definition at line 2487 of file layer.cpp. { #ifdef DO_EXPORT // Can only export guide layers in Native format if (Guide && pRegion->IS_KIND_OF(NativeRenderRegion)) { EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); pDC->OutputToken(_T("ceo")); pDC->OutputNewLine(); } PORTNOTE("cmx", "Disabled CMXRenderRegion") #ifndef EXCLUDE_FROM_XARALX else if(pRegion->IsKindOf(CC_RUNTIME_CLASS(CMXRenderRegion))) { // mark start of a group... CMXExportDC *pDC = (CMXExportDC *) pRegion->GetRenderDC(); pDC->EndLayer(); return TRUE; } #endif // Graeme (11-4-00) - Added call to AIEPSRenderRegion to export layers in that format. else if ( pRegion->IsKindOf ( CC_RUNTIME_CLASS ( AIEPSRenderRegion ) ) ) { // Cast the render region to get a reference to an AIEPSRenderRegion. AIEPSRenderRegion *pAIEPS = static_cast<AIEPSRenderRegion*> ( pRegion ); // Call the export method. pAIEPS->ExportLayer ( this ); // Return TRUE to avoid calling the standard exporter code. return TRUE; } #endif return FALSE; }