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; }

Document * Layer::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. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Finds the Document object that contains the tree that contains this layer, or NULL (God forbit) Errors: - See also: - Definition at line 1146 of file layer.cpp. { Node* pThisNodeDoc = FindParent(CC_RUNTIME_CLASS(NodeDocument)); if (pThisNodeDoc != NULL) { List* pList = &GetApplication()->Documents; if (pList != NULL) { Document* pDoc = (Document*) pList->GetHead(); while (pDoc != NULL) { Node* pNodeDoc = pDoc->GetFirstNode(); if (pNodeDoc != NULL) pNodeDoc = pNodeDoc->FindNext(CC_RUNTIME_CLASS(NodeDocument)); if (pNodeDoc == pThisNodeDoc) return (pDoc); pDoc = (Document*) pList->GetNext(pDoc); } } } return NULL; }

Layer * Layer::FindNextFrameLayer (   )

To find the next sibling frame layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 23/04/97 Returns: The next sibling frame layer of this node, or NULL if there are no more layers Errors: - See also: FindPrevFrameLayer; FindPrevLayer; Definition at line 914 of file layer.cpp. { Layer* pCurrentLayer = FindNextLayer(); while (pCurrentLayer != NULL) { // Frame layers cannot be guide layers or background layers if (pCurrentLayer->IsFrame() && !pCurrentLayer->IsPageBackground() && !pCurrentLayer->IsGuide()) { return pCurrentLayer; } pCurrentLayer = pCurrentLayer->FindNextLayer(); } // No next frame layer found return NULL; }

Layer * Layer::FindNextLayer (  BOOL  ExcludeInvisible = FALSE, BOOL  ExcludeLocked = FALSE )

To find the next sibling layer. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/01/94 Parameters: ExcludeInvisible  Do not consider any invisible layer. [INPUTS] ExcludeLocked Do not consider any locked layer. -  [OUTPUTS] Returns: The next sibling layer of this node, or NULL if there are no more layers Notes: Karim 08/08/2000 Extended this method so we can also exclude locked layers from the search. Returns: Errors: - See also: - Definition at line 819 of file layer.cpp. { Node* CurrentNode = FindNext(); while (CurrentNode != NULL) { if (CurrentNode->IsLayer()) { Layer* l = (Layer*) CurrentNode; if (ExcludeInvisible && !l->IsVisible()) { // we're ignoring invisible layers and this layer is invisible. } else if (ExcludeLocked && l->IsLocked()) { // we're ignoring locked layers and this layer is locked. } else { // this one's ok - return it. return l; } } CurrentNode = CurrentNode->FindNext(); } // no layer found. return NULL; }

Layer * Layer::FindPrevFrameLayer (   )

To find the prev sibling frame layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 23/04/97 Returns: The previous sibling frame layer of this node, or NULL if there are no more layers Errors: - See also: FindNextFrameLayer; FindNextLayer; Definition at line 946 of file layer.cpp. { Layer* pCurrentLayer = FindPrevLayer(); while (pCurrentLayer != NULL) { // Frame layers cannot be guide layers or background layers if (pCurrentLayer->IsFrame() && !pCurrentLayer->IsPageBackground() && !pCurrentLayer->IsGuide()) { return pCurrentLayer; } pCurrentLayer = pCurrentLayer->FindPrevLayer(); } // No next frame layer found return NULL; }

Layer * Layer::FindPrevLayer (  BOOL  ExcludeInvisible = FALSE, BOOL  ExcludeLocked = FALSE )

To find the prev sibling layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/8/94 Parameters: ExcludeInvisible  Do not consider any invisible layer. [INPUTS] ExcludeLocked Do not consider any locked layer. -  [OUTPUTS] Returns: The prev sibling layer of this node, or NULL if there are no more layers Notes: Karim 08/08/2000 Extended this method so we can also exclude locked layers from the search. Returns: Errors: - See also: - Definition at line 871 of file layer.cpp. { Node* CurrentNode = FindPrevious(); while (CurrentNode != NULL) { if (CurrentNode->IsLayer()) { Layer* l = (Layer*) CurrentNode; if (ExcludeInvisible && !l->IsVisible()) { // we're ignoring invisible layers and this layer is invisible. } else if (ExcludeLocked && l->IsLocked()) { // we're ignoring locked layers and this layer is locked. } else { // this one's ok - return it. return l; } } CurrentNode = CurrentNode->FindPrevious(); } // no layer found. return (NULL); }

DocRect Layer::GetBlobBoundingRect (   )  [virtual]

Returns the layer's bounding rect inflated by the size of a blob. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The layer's blob bounds See also: NodeRenderable::GetBlobBoundingRect() Reimplemented from NodeRenderable. Definition at line 2361 of file layer.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ENSURE(BlobMgr != NULL,"No blob manager - HELP!"); DocRect rect = GetBoundingRect(); INT32 BlobSize = BlobMgr->GetBlobSize(); rect.Inflate(BlobSize); return (rect); #else return DocRect(0,0,0,0); #endif }

Quality Layer::GetCaptureQuality (   )  [inline]

Definition at line 325 of file layer.h. { return m_CaptureQuality; }

void Layer::GetDebugDetails (  StringBase *  Str  )  [virtual]

For obtaining debug information about the Node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/93 Parameters: -  [INPUTS] Str,:  String giving debug info about the node [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from NodeRenderablePaper. Definition at line 2269 of file layer.cpp. { #ifdef _DEBUG NodeRenderablePaper::GetDebugDetails(Str); (*Str)+= TEXT("\r\nLayer Status("); (*Str)+=TEXT("\r\n VISIBLE = "); if (Visible) (*Str)+=TEXT("TRUE"); else (*Str)+=TEXT("FALSE"); (*Str)+=TEXT("\r\n LOCKED = "); if (Locked) (*Str)+=TEXT("TRUE"); else (*Str)+=TEXT("FALSE"); (*Str)+=TEXT("\r\n ACTIVE = "); if (Active) (*Str)+=TEXT("TRUE"); else (*Str)+=TEXT("FALSE"); (*Str)+=TEXT("\r\n PRINTABLE = "); if (Printable) (*Str)+=TEXT("TRUE"); else (*Str)+=TEXT("FALSE"); (*Str)+=TEXT("\r\n BACKGROUND = "); if (Background) (*Str)+=TEXT("TRUE"); else (*Str)+=TEXT("FALSE"); (*Str)+=TEXT("\r\n"); String_256 Temp; Temp._MakeMsg(TEXT("Outline = #1%ld\r\n"),Outline); (*Str)+=Temp; Temp._MakeMsg(TEXT("Guide = #1%ld\r\n"),Guide); (*Str)+=Temp; Temp._MakeMsg(TEXT("PageBackground = #1%ld\r\n"),m_PageBackground); (*Str)+=Temp; Temp._MakeMsg(TEXT("Frame = #1%ld\r\n"),m_Frame); (*Str)+=Temp; Temp._MakeMsg(TEXT("Edited = #1%ld\r\n"),m_Edited); (*Str)+=Temp; Temp._MakeMsg(TEXT("Hidden frame = #1%ld\r\n"),m_HiddenFrame); (*Str)+=Temp; (*Str)+=TEXT("Layer ID = "); (*Str)+=LayerSt.StringLayerID; (*Str)+=TEXT("\r\n"); #endif }

DocColour Layer::GetDefaultGuideColour (   )

Makes the current colour the default for all guide layers. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The DocColour that represents the default colour settings See also: GetGuideColour(),SetGuideColour() Definition at line 3189 of file layer.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ColourValue r = ColourValue(double(GuideLayerRed) / double(COL_MAX)); ColourValue g = ColourValue(double(GuideLayerGreen) / double(COL_MAX)); ColourValue b = ColourValue(double(GuideLayerBlue) / double(COL_MAX)); DocColour Col(r,g,b); return Col; #else return DocColour(0,0,0); #endif }

DWORD Layer::GetFrameDelay (   )

Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 01/05/97 Returns: The delay value for each animation frame layer. Definition at line 1641 of file layer.cpp. { return m_FrameDelay; }

KernelBitmap * Layer::GetGeneratedBitmap (   )

To recover the bitmap that has been generated to represent this layer, if any. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 7/5/97 Returns: NULL or the kernel bitmap that we generated to represent this layer Definition at line 2038 of file layer.cpp. { // Just ask the embedded bitmap ref to return its current status return m_GeneratedBitmap.GetBitmap(); }

DocColour * Layer::GetGuideColour (   )

Returns the DocColour that specifies the colour to render the guide objects in this layer with. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: ptr to the DocColour attached to this layer See also: SetGuideColour() Definition at line 3104 of file layer.cpp. { if (pGuideColour == NULL) SetGuideColour(NULL); return (pGuideColour); }

String_256 & Layer::GetLayerID (   )

For finding the layers identifier. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The layers ID Errors: - See also: - Definition at line 1704 of file layer.cpp. { return (LayerSt.StringLayerID); }

LayerStatus & Layer::GetLayerStatus (   )

Returns the layers status. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 10/1/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1724 of file layer.cpp. { return (LayerSt); }

BOOL Layer::GetLockedFlagState (   )

Returns the raw state of the layer's Locked flag (specialist use only). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer's Locked is TRUE, FALSE otherwise Errors: - See also: Layer::IsLocked() Definition at line 1400 of file layer.cpp. { return (Locked); }

UINT32 Layer::GetNodeSize (   )  const [virtual]

For finding the size of the node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The size of the node in bytes See also: Node::GetSubtreeSize Reimplemented from Node. Definition at line 2342 of file layer.cpp. { return (sizeof(Layer)); }

DocRect Layer::GetPasteboardRect (  BOOL  Pixelise = TRUE, View *  pView = NULL )  const [virtual]

For obtaining the layer's pasteboard rectangle which is actually the pasteboard rectangle of its parent spread node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: Pixelise  - whether or not to pixelise the pasteboard rectangle before [INPUTS] returning it. pView - the view to pixelise to (not used if Pixelise is FALSE). The  objects pasteboard rectangle [OUTPUTS] Returns: - Errors: Reimplemented from NodeRenderablePaper. Definition at line 672 of file layer.cpp. { // Ensure that the parent of the Layer object is a spread ERROR2IF(!Parent->IsKindOf(CC_RUNTIME_CLASS(Spread)), DocRect(0,0,0,0), "The parent of a layer node was not a spread node"); return ( ((Spread*)Parent)->GetPasteboardRect(Pixelise, pView) ); }

KernelBitmap * Layer::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 7/5/97 Returns: NULL or the kernel bitmap that we reference to represent this layer Definition at line 2161 of file layer.cpp. { // We have a direct pointer rather than a ref as otherwise we will see the bitmap twice // in the bitmap gallery for this document. return m_pReferencedBitmap; }

BOOL Layer::GetVisibleFlagState (   )

Returns the raw state of the layer's visible flag (specialist use only). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer's Visible is TRUE, FALSE otherwise Errors: - See also: Layer::IsVisible() Definition at line 1307 of file layer.cpp. { if (Guide) { DocView* pDocView = DocView::GetCurrent(); if (pDocView != NULL) return (pDocView->GetShowGuidesState()); } return (Visible); }

BOOL Layer::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> from MarkN version in LayerSGallery::HasLayerGotChildren() Date: 21/7/97 Returns: TRUE - The layer has children the user may be interested in - i.e. children that actually render something. FALSE - The layer has no rendering children Definition at line 2209 of file layer.cpp. { Node* pNode = FindFirstChild(); BOOL ChildFound = FALSE; while (pNode != NULL && !ChildFound) { ChildFound = pNode->IsBounded(); pNode = pNode->FindNext(); } return (ChildFound); }

BOOL Layer::HidingNode (   )  [virtual]

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/97 Returns: TRUE if all was ok. FALSE if an error occured. ALWAYS CALL THE BASE CLASS' FUNCTION FROM YOUR OVERRIDDEN FUNCTION. Reimplemented from Node. Definition at line 979 of file layer.cpp. { // Call the base class first if (!Node::HidingNode()) return FALSE; // Check if we are the active layer, if we are then try and make // another layer active if (IsActive()) { // Hiding an active layer TRACEUSER( "Neville", _T("++++++ Hiding the active layer\n")); // Included in Camelot2 for frame/layer integration - RanbirR - 06/11/97 //#ifdef WEBSTER if (!IsFrame()) { // Choose the next/prev layer to be the new active one Layer* pNewActiveLayer = FindPrevLayer(); if (pNewActiveLayer == NULL) pNewActiveLayer = FindNextLayer(); if (pNewActiveLayer != NULL) LayerSGallery::MakeActiveLayer(pNewActiveLayer); } else { PORTNOTE("other", "Disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX // Choose the next/prev frame layer to be the new active one Layer* pNewActiveLayer = FindPrevFrameLayer(); if (pNewActiveLayer == NULL) pNewActiveLayer = FindNextFrameLayer(); if (pNewActiveLayer != NULL) FrameSGallery::MakeActiveLayer(pNewActiveLayer); #endif } } // If we are hiding the page background layer then we must mark all frame layers // as edited as they must be regenerated. // Use frame layers as only these will have been captured if (IsPageBackground()) { Node * pParentNode = FindParent(); Spread * pSpread = NULL; if (pParentNode->IsKindOf(CC_RUNTIME_CLASS(Spread))) pSpread = (Spread*)pParentNode; if (pSpread) { Layer* pLayer = pSpread->FindFirstFrameLayer(); while (pLayer != NULL) { // This is just as a double check if (pLayer->IsPseudoFrame()) { // Set the edited flag on the layer pLayer->SetEdited(TRUE); #ifdef _DEBUG // Tell the frame gallery to update its display of the frame BROADCAST_TO_ALL(LayerMsg(pLayer, LayerMsg::REDRAW_LAYER)); #endif } // Move to the next frame layer in the animation pLayer = pLayer->FindNextFrameLayer(); } } } return TRUE; }

BOOL Layer::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 8/4/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is one that can contains the page background Errors: - See also: Spread::GetPageVisibleBounds(); BaseBitmapFilter::GetSizeOfDrawing(); Definition at line 1680 of file layer.cpp. { // Only add the bounding box of the layer in if it is visible and if it is not // either a guide layer or the page background layer. return (!IsPageBackground() && !IsGuide() && IsVisible()); }

BOOL Layer::Init (  void   )  [static]

Does any layer initialisation necessary. Declares some layer INI settings Creates a layer message handler. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: Reimplemented from NodeRenderableBounded. Definition at line 210 of file layer.cpp. { BOOL ok = TRUE; #if !defined(EXCLUDE_FROM_RALPH) // Declare the section that the preferences for layers will live in if (ok) ok= Camelot.DeclareSection(TEXT("Layers"), 3); // declare the guideline colour vars if (ok) ok= Camelot.DeclarePref(TEXT("Layers"), TEXT("GuideLayerRed"), &Layer::GuideLayerRed, 0, COL_MAX); if (ok) ok= Camelot.DeclarePref(TEXT("Layers"), TEXT("GuideLayerGreen"),&Layer::GuideLayerGreen, 0, COL_MAX); if (ok) ok= Camelot.DeclarePref(TEXT("Layers"), TEXT("GuideLayerBlue"), &Layer::GuideLayerBlue, 0, COL_MAX); #endif if (ok) { pLayerMsgHandler = new LayerMsgHandler; ok = (pLayerMsgHandler != NULL); } return ok; }

BOOL Layer::IsActive (   )

For finding the layers active status. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is active, otherwise FALSE. Errors: - See also: - Definition at line 1421 of file layer.cpp. { return (Active); }

BOOL Layer::IsBackground (   )

For finding the layers background status. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is a background layer, otherwise FALSE. Errors: - See also: - Definition at line 1463 of file layer.cpp. { return (Background); }

BOOL Layer::IsEdited (   )

For finding the frame's/layer's Edited status. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Returns: TRUE if the frame/layer is one that has its Edited flag set Definition at line 1574 of file layer.cpp. { return m_Edited; }

BOOL Layer::IsFrame (   )

For finding the frame's/layer's Frame status. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/97 Returns: TRUE if the frame/layer is one that has its Frame flag set Definition at line 1590 of file layer.cpp. { return m_Frame; }

BOOL Layer::IsGuide (   )

For finding the layers guide status. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is one that can contain guidelines Errors: - See also: - Definition at line 1505 of file layer.cpp. { return (Guide); }

BOOL Layer::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/97 Returns: TRUE if the frame/layer is one that has its Hidden flag set Definition at line 1608 of file layer.cpp. { return m_HiddenFrame; }

BOOL Layer::IsLayer (   )  const [virtual]

Indicate that we are a layer (overrides function in Node). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/94 Returns: TRUE => This node is a layer See also: Node::IsLayer Reimplemented from Node. Definition at line 609 of file layer.cpp. { return TRUE; }

BOOL Layer::IsLocked (  void   )

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. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> (modified by Markn) (modified to not use CurrentDoc by Jason) Date: 6/1/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is locked, otherwise FALSE. Errors: - See also: - Reimplemented from Node. Definition at line 1338 of file layer.cpp. { /* // WEBSTER - markn 29/1/97 // All layers are editable in Webster #ifndef WEBSTER */ // Disabled as we now have frame layers and some layers MUST be locked // Fast track it if the layer is not locked (the majority of cases) if (!Locked) return (FALSE); // If we are the page background layer then ALWAYS return locked if (IsPageBackground()) return TRUE; // If the "Active layer is editable and visible" flag is TRUE, // then return FALSE (layer is editable) if this layer is Active if (Active && ActiveLayerVisibleAndEditable) return (FALSE); // This layer is locked. However, if the document to which this layer belongs // has the Multilayer flag set (i.e. all layers editable), the return FALSE // I.e. return the inverse of the doc's Multilayer state Document *pDoc = FindDocument(); if (pDoc == NULL) return (FALSE); return (!pDoc->IsMultilayer()); /* #else // Fast track it if the layer is not locked (the majority of cases) // Required in Webster so that when the BackgroundOp is inserting objects and // it has turned the locked status off, then we do not get the warning. In other // cases where the user is trying to change the background layer and the locked // flag is set to its default true state, we should fall through to the PageBackground // test and fail. if (!Locked) return (FALSE); // If we are the page background layer then ALWAYS return locked if (IsPageBackground()) return TRUE; // always return FALSE i.e. editable return FALSE; #endif // WEBSTER */ }

BOOL Layer::IsOutline (   )

For finding the layers outline status. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is to render its objects in outline mode Errors: - See also: - Definition at line 1484 of file layer.cpp. { return (Outline); }

BOOL Layer::IsOverlay (   )

For finding the frame's/layer's Overlay status. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Returns: TRUE if the frame/layer is one that has its Overlay flag set Definition at line 1542 of file layer.cpp. { return m_Overlay; }

BOOL Layer::IsPageBackground (   )

For finding the layer's page background status. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is one that can contains the page background Errors: - See also: - Definition at line 1525 of file layer.cpp. { return (m_PageBackground); }

BOOL Layer::IsPrintable (   )

For finding the layers printable status. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is printable, otherwise FALSE. Errors: - See also: - Definition at line 1442 of file layer.cpp. { return (Printable && !IsGuide()); }

BOOL Layer::IsPseudoFrame (   )

For finding out whether this might be regarded as a frame layer without especially having its frame flag set. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/97 Returns: TRUE if the frame/layer is one that might be a frame layer Definition at line 1625 of file layer.cpp. { // Only true if the layer is not a background layer or a guide layer or a page background // layer return (!IsBackground() && !IsGuide() && !IsPageBackground()); }

BOOL Layer::IsSolid (   )

For finding the frame's/layer's Solid status. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Returns: TRUE if the frame/layer is one that has its Solid flag set Definition at line 1558 of file layer.cpp. { return m_Solid; }

BOOL Layer::IsVisible (  DocView *  pDocView = NULL  )

For finding the layers visible status. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> (modified by Markn) Date: 6/1/94 Parameters: pDocView  = ptr to a docview (only used if the layer is a guide layer) [INPUTS] -  [OUTPUTS] Returns: TRUE if the layer is visible, otherwise FALSE. Errors: - See also: - Definition at line 1255 of file layer.cpp. { if (Guide) { // WEBSTER - markn 29/1/97 // Guide layers are always invisible #ifndef WEBSTER if (pDocView == NULL) pDocView = DocView::GetCurrent(); if (pDocView != NULL) return (pDocView->GetShowGuidesState()); else return FALSE; #else return FALSE; #endif // WEBSTER } // If it is visible, fast track the return if (Visible) return (TRUE); // If the "Active layer is editable and visible" flag is TRUE, // then return TRUE (layer is visible) if this layer is Active if (Active && ActiveLayerVisibleAndEditable) return (TRUE); // This layer is NOT visible. However, if the document to which this layer belongs // has the AllVisible flag set, then return TRUE // I.e. return the doc's AllVisible state Document *pDoc = FindDocument(); if (pDoc == NULL) return(TRUE); return(pDoc->IsAllVisible()); }

PathName Layer::MakeExportLayerName (  const PathName &  path  )  [virtual]

Make a pathname that's specific to this layer. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/03/2004 Input: PathName - original pathname Parameters: -  [OUTPUTS] Returns: PathName - modified pathname Definition at line 3389 of file layer.cpp. { PathName pathLayer = path; String_256 filename = path.GetFileName(FALSE); filename += String( _T(" ") ); // if (LayerSt.StringLayerID.SubWithoutCase("Layer")==-1) // filename += String("Layer "); filename += LayerSt.StringLayerID; pathLayer.SetFileName(filename); return pathLayer; };

void Layer::MakeGuideColourDefault (   )

Makes the current colour the default for all guide layers. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: GetGuideColour(),SetGuideColour() Definition at line 3161 of file layer.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (pGuideColour != NULL) { INT32 Red,Green,Blue; pGuideColour->GetRGBValue(&Red,&Green,&Blue); GuideLayerRed = INT32(Red); GuideLayerGreen = INT32(Green); GuideLayerBlue = INT32(Blue); } #endif }

BOOL Layer::NeedsToExport (  RenderRegion *  pRender, BOOL  VisibleLayersOnly = FALSE, BOOL  CheckSelected = FALSE )  [virtual]

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. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 24/03/94 Parameters: pRender  - A pointer to the current export region (NULL if none) [INPUTS] VisibleLayersOnly - TRUE => remove nodes which are on invisible layers FALSE => export everything CheckSelected - TRUE => we check if object selected and only export selected bjects FALSE => we don't bother checking for selection or not Returns: TRUE => export this node. See also: Layer::NeedsToRender Reimplemented from NodeRenderablePaper. Definition at line 549 of file layer.cpp. { #ifdef DO_EXPORT // If this is export as a ART file, we want to save all the layers if (pRender->IS_KIND_OF(NativeRenderRegion)) return TRUE; // If there's a filter running // and it's trying to export just one layer // then return FALSE if this layer is NOT the layer in question // else fall through to the normal logic... Filter* pFilter = pRender->GetFilter(); if (pFilter) { Layer* pFilterLayer = pFilter->GetSoleLayer(); if (pFilterLayer!=NULL && pFilterLayer!=this) return FALSE; } // if this is an export as a CMX file, we don't want invisible layers // as CMX doesn't support non-visible stuff so we can't save it and // get the file looking the same PORTNOTE("cmx", "Removed use of CMXRenderRegion") #ifndef EXCLUDE_FROM_XARALX if(!IsVisible() && pRender->IS_KIND_OF(CMXRenderRegion)) return FALSE; #endif // Guide layers only export to Native render regions if (Guide) return FALSE; // Changed so that instead of always returning True there is a parameter which // defaults to the old state whereby it always returns True but can be set so // that we return the visible state of the layer and hence this dictates whether // only visible layers will be exported. if (VisibleLayersOnly) return (IsVisible()); else return(TRUE); #else return FALSE; #endif }

ChangeCode Layer::OnChildChange (  ObjChangeParam *  pParam  )  [virtual]

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 08/05/97 Parameters: pParam  = pointer to a object change parameter class [INPUTS] Returns: CC_OK if we have successfully processed the change. CC_FAIL if we cannot handle this particular change and must prevent the child from continuing See also: WarnParentOfChange(); Reimplemented from Node. Definition at line 2010 of file layer.cpp. { // Note that this layer has been edited SetEdited(TRUE); #ifdef _DEBUG // Tell the frame gallery to update its display of the frame BROADCAST_TO_ALL(LayerMsg(this, LayerMsg::REDRAW_LAYER)); #endif return CC_OK; }

void Layer::PolyCopyNodeContents (  NodeRenderable *  pNodeCopy  )  [virtual]

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/12/2003 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeRenderablePaper. Definition at line 787 of file layer.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, Layer), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, Layer)) CopyNodeContents((Layer*)pNodeCopy); }

void Layer::PreExportRender (  RenderRegion *  pRegion  )  [virtual]

Outputs data to mark the beginning of a layer. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 17/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Reimplemented from Node. Definition at line 2392 of file layer.cpp. { #ifdef DO_EXPORT if(pRegion->IsKindOf(CC_RUNTIME_CLASS(ArtWorksEPSRenderRegion))) { // export layers in ArtWorks-type EPS render regions // Can only export guide layers in Native format if (Guide && !pRegion->IS_KIND_OF(NativeRenderRegion)) return; // Get ptr to the export DC EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); // Guide layers are extended objects so mark them as such if (Guide) { pDC->OutputValue(INT32(EOTAG_GUIDELAYER)); // Output start extended object tag and token pDC->OutputToken(_T("cso")); pDC->OutputNewLine(); } // Output the layer name pDC->OutputString(LayerSt.StringLayerID); // Layer type - foreground or background if (IsBackground()) pDC->OutputToken(_T("0")); else pDC->OutputToken(_T("1")); // Visible flag if (Visible) pDC->OutputToken(_T("1")); else pDC->OutputToken(_T("0")); // Printable flag if (IsPrintable()) pDC->OutputToken(_T("1")); else pDC->OutputToken(_T("0")); // Locked flag if (Locked) pDC->OutputToken(_T("1")); else pDC->OutputToken(_T("0")); // Layer token itself if (!Guide) pDC->OutputToken(_T("alyr")); else { // Output guide layer stuff if (pGuideColour == NULL) SetGuideColour(NULL); ERROR3IF(pGuideColour == NULL,"Can't export guide layer without a colour"); if (pGuideColour != NULL) pDC->OutputNamedColour(pGuideColour); pDC->OutputToken(_T("glyr")); } 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->StartLayer(GetLayerID()); } #endif #endif }

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

Reimplemented from Node. Definition at line 3080 of file layer.cpp. { if (pFilter != NULL) pFilter->InvalidateRegion(this); return Node::ReadPostChildrenNative(pFilter); }

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

This function is called during the importing of the file. > virtual BOOL Node::ReadPostChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/96 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise A node gets called via this function after all its children have been imported. This allows complex nodes (such as moulds) to do some post-import work, which can only be done after all its children have been read in and created. See also: CanWriteChildrenWeb(), WritePreChildrenWeb() Reimplemented from Node. Definition at line 3072 of file layer.cpp. { if (pFilter != NULL) pFilter->InvalidateRegion(this); return Node::ReadPostChildrenWeb(pFilter); }

void Layer::RenderAfterSubtree (  RenderRegion *  pRegion  )  [virtual]

Capture the group as a cached bitmap. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/2004 Parameters: pRender  - The region to render into [INPUTS] Reimplemented from Node. Definition at line 520 of file layer.cpp. { // Call Helper function to run all my cacheing functionality for me... if (IsVisible()) CaptureCached(pRegion); }

SubtreeRenderState Layer::RenderSubtree (  RenderRegion *  pRender, Node **  ppNextNode = NULL, BOOL  bClip = TRUE )  [virtual]

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. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 07/02/94 Parameters: pRender  - A pointer to the current render region (NULL if none) [INPUTS] Returns: TRUE => This node should be rendered, FALSE => This node does not need to be rendered. See also: Node::NeedsToRender Reimplemented from NodeRenderablePaper. Definition at line 426 of file layer.cpp. { if (pRender==NULL) return SUBTREE_ROOTANDCHILDREN; // ignore hit detection render regions when the layer is locked. if (pRender->IsHitDetect() && IsLocked()) return SUBTREE_NORENDER; // If we are printing then we do special things else if (pRender->IsPrinting()) { // Ignore non-printable layers (i.e. don't ever print background layers) if (!IsPrintable()) return SUBTREE_NORENDER; // Added this since we want to print what we see - might need looking at ? return IsVisible() ? SUBTREE_ROOTANDCHILDREN : SUBTREE_NORENDER; // Otherwise, get the print control CCPrintInfo *pInfo = CCPrintInfo::GetCurrent(); // ERROR2IF(pInfo == NULL, FALSE, "No print info for printing render region!"); PrintControl *pPrCtrl = NULL; if (pInfo != NULL) pPrCtrl = pInfo->GetPrintControl(); // ERROR2IF(pPrCtrl == NULL, FALSE, "No print control for printing render region!"); // Ok, work out what whether we should print this layer... if (pPrCtrl == NULL || pPrCtrl->GetPrintLayers() == PRINTLAYERS_VISIBLEFOREGROUND) { // Print only visible foreground layers. return IsVisible() ? SUBTREE_ROOTANDCHILDREN : SUBTREE_NORENDER; } else { // Print all foreground layers, regardless of visibility. return SUBTREE_ROOTANDCHILDREN; } } else if (IS_A(pRender,CamelotEPSRenderRegion)) return (IsVisible() && IsPrintable()) ? SUBTREE_ROOTANDCHILDREN : SUBTREE_NORENDER; else { // Normal rendering // // Ask Helper function to set up cacheing for me... // // If we can find a cached bitmap for this node and render it // Then tell the renderer to move on without doing any more... // Else we might have set up a capture, in which case render as normal // and let RenderAfterSubtree catch the capture at the other end switch (Layer::EnableLayerCacheing) { // Value 1 means enable all layer cacheing case 1: if (IsVisible() && !IsGuide() && RenderCached(pRender)) { return SUBTREE_NORENDER; } break; // Value 2 means enable layer cacheing for all but the active layer case 2: if (IsVisible() && !IsGuide() && !IsActive() && RenderCached(pRender)) { return SUBTREE_NORENDER; } break; } // Simple visibility check... return IsVisible() ? SUBTREE_ROOTANDCHILDREN : SUBTREE_NORENDER; } return SUBTREE_NORENDER; }

void Layer::SetActive (  BOOL  Status  )

To set the Layer's active flag status (TRUE/FALSE). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: Status,:  Status of the Layer's active flag [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1796 of file layer.cpp. { Active = Status; }

void Layer::SetBackground (  BOOL  Status  )

To set the Layer's background flag status (TRUE/FALSE). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: Status,:  Status of the Layer's background flag [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1838 of file layer.cpp. { Background = Status; }

void Layer::SetCaptureQuality (  const Quality &  NewQuality  )  [inline]

Definition at line 326 of file layer.h. { m_CaptureQuality = NewQuality; }

void Layer::SetEdited (  BOOL  Status  )

To set the Frame/Layer's Edited flag status (TRUE/FALSE). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: Status,:  Status of the Frame/Layer's Edited flag [INPUTS] Definition at line 1949 of file layer.cpp. { m_Edited = Status; }

void Layer::SetFrame (  BOOL  Status  )

To set the Frame/Layer's Frame flag status (TRUE/FALSE). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: Status,:  Status of the Frame/Layer's Frame flag [INPUTS] Definition at line 1965 of file layer.cpp. { m_Frame = Status; }

void Layer::SetFrameDelay (  const DWORD &  Delay  )

Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 01/05/97 Returns: - purpose: To set the delay value for each animation frame layer. Definition at line 1655 of file layer.cpp. { m_FrameDelay = Delay; }

BOOL Layer::SetGeneratedBitmap (  KernelBitmap *  pBitmap  )

To set the bitmap that has been generated to represent this layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 7/5/97 Parameters: The  kernel bitmap that we wish to represent this layer [INPUTS] Definition at line 2055 of file layer.cpp. { //ERROR2IF(pBitmap == NULL,FALSE,"SetGeneratedBitmap Bad params"); Document *pParentDoc = (Document *) FindOwnerDoc(); ERROR2IF(pParentDoc == NULL,FALSE,"SetGeneratedBitmap bad parent doc!"); // delete the old one from the system, if it is there and it is not used // elsewhere in the document KernelBitmap * pOldBitmap = m_GeneratedBitmap.GetBitmap(); if (pOldBitmap) { // Disclude ourselves from the count m_GeneratedBitmap.Detach(); // Should we use HasBeenDeleted??? // If the bitmap is not used in this document then delete it if (!pOldBitmap->IsUsedInDocument(pParentDoc)) delete pOldBitmap; //m_GeneratedBitmap.DeleteBmp(); } // Only do this if we are passed in a non-null bitmap if (pBitmap != NULL) { // Make our bitmap ref use the new specified one // We could use the nice and simple:- //m_GeneratedBitmap.Attach(pBitmap, pParentDoc); // but this makes a new kernel bitmap, which is bad! // So do this instead:- // Try and add it to the list of bitmaps already present in this document BitmapList * pBmpList = pParentDoc->GetBitmapList(); if (pBmpList == NULL) { ERROR3("SetGeneratedBitmap No document bitmap ref found!"); return FALSE; } // and then attach the bitmap pBitmap->Attach(pBmpList); // and tell everybody about the change BROADCAST_TO_ALL(BitmapListChangedMsg(pBmpList, pBitmap)); m_GeneratedBitmap.SetBitmap(pBitmap); // If we have a generated bitmap then we cannot have a referenced bitmap // so reset the referenced bitmap SetReferencedBitmap(NULL); } return TRUE; }

void Layer::SetGuide (  BOOL  Status  )

To set the Layer's Guide flag status (TRUE/FALSE). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/95 Parameters: Status,:  Status of the Layer's Guide flag [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1881 of file layer.cpp. { Guide = Status; }

void Layer::SetGuideColour (  IndexedColour *  pIndexedColour  )

Assigns the given indexed colour as the colour to render guide objects in this layer in. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/95 Parameters: pIndexedColour  = ptr to IndexedColour (NULL means set to default) [INPUTS] -  [OUTPUTS] Returns: - See also: GetGuideColour() Definition at line 3126 of file layer.cpp. { if (pGuideColour == NULL) pGuideColour = new DocColour(); if (pGuideColour != NULL) { if (pIndexedColour == NULL) { ColourValue r = ColourValue(double(GuideLayerRed) / double(COL_MAX)); ColourValue g = ColourValue(double(GuideLayerGreen) / double(COL_MAX)); ColourValue b = ColourValue(double(GuideLayerBlue) / double(COL_MAX)); pIndexedColour = new IndexedColour(r,g,b); pIndexedGuideColour = pIndexedColour; } if (pIndexedColour != NULL) pGuideColour->MakeRefToIndexedColour(pIndexedColour); } }

void Layer::SetHiddenFrame (  BOOL  Status  )

To set the Frame/Layer's Hidden flag status (TRUE/FALSE). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/97 Parameters: Status,:  Status of the Frame/Layer's Hidden flag [INPUTS] Definition at line 1981 of file layer.cpp. { m_HiddenFrame = Status; }

void Layer::SetLayerID (  String_256 &  LayerID  )

For setting the layer's identifier. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: LayerID,:  The new layer identifier [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 2238 of file layer.cpp. { LayerSt.StringLayerID = LayerID; }

void Layer::SetLayerStatus (  LayerStatus &  Status  )

To set the layers status. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 14/1/94 Parameters: Status,:  The new status for the layer [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: Layer::SetVisible Layer::SetLocked Layer::SetActive Layer::SetPrintable Layer::SetBackground LAyer::SetGlobalQualityFlg Definition at line 2264 of file layer.cpp. { LayerSt = Status; }

void Layer::SetLocked (  BOOL  Status  )

To set the Layer's locked flag status (TRUE/FALSE). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: Status,:  Status of the Layer's locked flag [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Node. Definition at line 1775 of file layer.cpp. { Locked = Status; }

void Layer::SetOpPermission (  OpPermissionState  NewState, BOOL  AndParents = FALSE )  [virtual]

Calls Node::SetOpPermission(NewState,FALSE), i.e. you can set the layer's op permission state, but the 'AndParent' param is ignored. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/02/95 Parameters: NewState  = the state to set the permission to [INPUTS] AndParents = Ignored (see later) -  [OUTPUTS] Returns: - The purpose of this func is to make layers the top level node that has it's op permission state changed. See also: Node::SetOpPermission(); Reimplemented from Node. Definition at line 2582 of file layer.cpp. { Node::SetOpPermission(NewState,FALSE); }

void Layer::SetOutline (  BOOL  Status  )

To set the Layer's outline flag status (TRUE/FALSE). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/94 Parameters: Status,:  Status of the Layer's outline flag [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1860 of file layer.cpp. { Outline = Status; }

void Layer::SetOverlay (  BOOL  Status  )

To set the Frame/Layer's Overlay flag status (TRUE/FALSE). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: Status,:  Status of the Frame/Layer's Overlay flag [INPUTS] Definition at line 1933 of file layer.cpp. { m_Overlay = Status; }

void Layer::SetPageBackground (  BOOL  Status  )

To set the Layer's PageBackground flag status (TRUE/FALSE). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/97 Parameters: Status,:  Status of the Layer's PageBackground flag [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1901 of file layer.cpp. { m_PageBackground = Status; }

void Layer::SetPrintable (  BOOL  Status  )

To set the Layer's printable flag status (TRUE/FALSE). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: Status,:  Status of the Layer's printable flag [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1817 of file layer.cpp. { Printable = Status; }

BOOL Layer::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/97 Parameters: The  kernel bitmap that we wish to represent this layer [INPUTS] Definition at line 2182 of file layer.cpp. { // We have a direct pointer rather than a ref as otherwise we will see the bitmap twice // in the bitmap gallery for this document. m_pReferencedBitmap = pBitmap; return TRUE; }

void Layer::SetSolid (  BOOL  Status  )

To set the Frame/Layer's Solid flag status (TRUE/FALSE). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/4/97 Parameters: Status,:  Status of the Frame/Layer's Solid flag [INPUTS] Definition at line 1917 of file layer.cpp. { m_Solid = Status; }

void Layer::SetVisible (  BOOL  Status  )

To set the Layer's visible flag status (TRUE/FALSE). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: Status,:  Status of the Layer's visible flag [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1747 of file layer.cpp. { if (Guide) { DocView* pDocView = DocView::GetCurrent(); if (pDocView != NULL) pDocView->SetShowGuidesState(Status); } else Visible = Status; }

Node * Layer::SimpleCopy (  void   )  [protected, virtual]

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. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/93 Parameters: -  [INPUTS] [OUTPUTS]  Returns: A copy of the node, or NULL if memory runs out Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Scope: protected Reimplemented from NodeRenderablePaper. Definition at line 702 of file layer.cpp. { Layer* NodeCopy; NodeCopy = new Layer(); //ERRORIF(NodeCopy == NULL, _R(IDE_NOMORE_MEMORY), NULL); if (NodeCopy != NULL) CopyNodeContents(NodeCopy); return (NodeCopy); }

BOOL Layer::WriteAtomicNodesColourRefs (  Node *  pLayer, BaseCamelotFilter *  pFilter )  [virtual]

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. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 14/9/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if written, FALSE otherwise Errors: - See also: BaseCamelotFilter::WriteRemainingAtomicTagDefinitions () Layer::WriteAtomicNodesColourRefs () AttrFillGeometry::WriteColourDefinitions () Definition at line 3560 of file layer.cpp. { BOOL ok = TRUE; CCRuntimeClass * pClass = CC_RUNTIME_CLASS(AttrFlatColourFill); BOOL done = FALSE; INT32 i = 0; while (!done) { AttrFillGeometry* pNode = (AttrFillGeometry*) SliceHelper::FindNextOfClass(pLayer, pLayer, pClass); while (pNode) { if (ShouldWriteColourDefinitions (pNode)) { ok = pNode->WriteColourDefinitions (pFilter); } pNode = (AttrFillGeometry*) SliceHelper::FindNextOfClass(pNode, pLayer, pClass); } if (!ok) done = TRUE; switch (i) { case 0: pClass = CC_RUNTIME_CLASS(AttrLinearColourFill); break; case 1: pClass = CC_RUNTIME_CLASS(AttrRadialColourFill); break; case 2: pClass = CC_RUNTIME_CLASS(AttrConicalColourFill); break; case 3: pClass = CC_RUNTIME_CLASS(AttrSquareColourFill); break; case 4: pClass = CC_RUNTIME_CLASS(AttrThreeColColourFill); break; case 5: pClass = CC_RUNTIME_CLASS(AttrFourColColourFill); break; case 6: pClass = CC_RUNTIME_CLASS(AttrBitmapColourFill); break; case 7: pClass = CC_RUNTIME_CLASS(AttrFractalColourFill); break; case 8: pClass = CC_RUNTIME_CLASS(AttrNoiseColourFill); break; case 9: pClass = CC_RUNTIME_CLASS(AttrStrokeColour); break; default: done = TRUE; } i++; } return (ok); }

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

Begins the child record sequence for layers in the native format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/8/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE if the node has written out a record to the filter FALSE otherwise The native format writes out all layers and includes the layer details record as the layer's first child record See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 2923 of file layer.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); // First thing to do is write out the Down record BOOL ok = (pFilter->WriteZeroSizedRecord(TAG_DOWN)); // The colour ref used in the guide layer info record INT32 ColRef = 0; // Firstly, if it's a guide layer write out the colour definition if (ok && IsGuide()) { DocColour* pColour = GetGuideColour(); if (pColour != NULL) ColRef = pFilter->WriteRecord(pColour); if (ColRef == 0) { pFilter->GotError(_R(IDE_FILE_WRITE_ERROR)); ok = FALSE; } } if (ok) { // Assume it's a normal layer (i.e. not a guide layer) UINT32 Tag = TAG_LAYERDETAILS; INT32 Size = TAG_LAYERDETAILS_SIZE; // If it's a guide layer, change the tag & size values if (IsGuide()) { Tag = TAG_GUIDELAYERDETAILS; Size = TAG_GUIDELAYERDETAILS_SIZE; } // Build the flags byte BYTE Flags = 0; if (GetVisibleFlagState()) Flags |= TAG_LAYER_FLAG_VISIBLE; if (GetLockedFlagState()) Flags |= TAG_LAYER_FLAG_LOCKED; if (IsPrintable()) Flags |= TAG_LAYER_FLAG_PRINTABLE; if (IsActive()) Flags |= TAG_LAYER_FLAG_ACTIVE; // new 4/4/97 if (IsPageBackground()) Flags |= TAG_LAYER_FLAG_PAGEBACKGROUND; if (IsBackground()) Flags |= TAG_LAYER_FLAG_BACKGROUND; // Create a record and write to it CamelotFileRecord Rec(pFilter,Tag,Size); if (ok) ok = Rec.Init(); if (ok) ok = Rec.WriteBYTE(Flags); if (ok) ok = Rec.WriteUnicode(GetLayerID()); // Make sure the guide layer details include the colour ref if (ok && Tag == TAG_GUIDELAYERDETAILS) ok = Rec.WriteReference(ColRef); // Write the details record to the file. ok = (pFilter->Write(&Rec) != 0); // Only write out the frame properties if it is a frame layer if (ok && IsFrame()) ok = WriteFrameLayerProperties(pFilter); ok = WriteAtomicNodesColourRefs (this, pFilter); } return ok; #else return FALSE; #endif }

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

See note in BOOL Layer::WritePreChildrenWeb(BaseCamelotFilter* pFilter) for a reason why this code is commented out (markn 12/8/96) UINT32 WritableLayerCount = CountNumWritableWebLayers(pFilter); if (WritableLayerCount < 2) return TRUE; Reimplemented from Node. Definition at line 3040 of file layer.cpp. { /***************************************************** See note in BOOL Layer::WritePreChildrenWeb(BaseCamelotFilter* pFilter) for a reason why this code is commented out (markn 12/8/96) - UINT32 WritableLayerCount = CountNumWritableWebLayers(pFilter); - - if (WritableLayerCount < 2) - return TRUE; ******************************************************/ return Node::WriteBeginChildRecordsWeb(pFilter); }

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

Ends the child record sequence for layers in the native format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/8/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE if the node has written out a record to the filter FALSE otherwise The native format writes out all layers. This func just writes out the Up record See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 3015 of file layer.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); return pFilter->WriteZeroSizedRecord(TAG_UP); #else return FALSE; #endif }

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

See note in BOOL Layer::WritePreChildrenWeb(BaseCamelotFilter* pFilter) for a reason why this code is commented out (markn 12/8/96) UINT32 WritableLayerCount = CountNumWritableWebLayers(pFilter); if (WritableLayerCount < 2) return TRUE; Reimplemented from Node. Definition at line 3056 of file layer.cpp. { /***************************************************** See note in BOOL Layer::WritePreChildrenWeb(BaseCamelotFilter* pFilter) for a reason why this code is commented out (markn 12/8/96) - UINT32 WritableLayerCount = CountNumWritableWebLayers(pFilter); - - if (WritableLayerCount < 2) - return TRUE; ******************************************************/ return Node::WriteEndChildRecordsWeb(pFilter); }

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

Exports the delay details for this frame layer to the filter. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 8/5/97 Input: pFilter = ptr to the filter to export to. Parameters: -  [OUTPUTS] Returns: TRUE if ok, FALSE otherwise. Definition at line 3333 of file layer.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); BOOL RecordWritten = FALSE; BOOL ok = TRUE; // Add a description of the TAG_LAYER_FRAMEPROPS record, for older importers that don't understand this record pFilter->AddTagDescription(TAG_LAYER_FRAMEPROPS, _R(IDS_TAG_LAYER_FRAMEPROPS)); // Start a record to save our data in CXaraFileRecord Rec(TAG_LAYER_FRAMEPROPS, TAG_LAYER_FRAMEPROPS_SIZE); // Get the Frame delay inforamtion. DWORD Delay = GetFrameDelay(); BYTE Flags = 0; if (IsSolid()) Flags |= TAG_LAYER_FLAG_SOLID; if (IsOverlay()) Flags |= TAG_LAYER_FLAG_OVERLAY; if (IsHiddenFrame()) Flags |= TAG_LAYER_FLAG_HIDDEN; ok = Rec.Init(); if (ok) ok = Rec.WriteUINT32(Delay); if (ok) ok = Rec.WriteBYTE(Flags); // Write out the record. if (ok) ok = (pFilter->Write(&Rec) != 0); if (ok) RecordWritten = TRUE; else pFilter->GotError(_R(IDE_FILE_WRITE_ERROR)); return RecordWritten; #else return FALSE; #endif };

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

Reimplemented from Node. Definition at line 3035 of file layer.cpp. { return Node::WritePostChildrenNative(pFilter); }

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

Gives the node a change to write data to the filter after its children have been automatically written out. > virtual BOOL Node::WritePostChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/96 Parameters: pFilter  = ptr to filter to write to [INPUTS] Returns: TRUE if ok, FALSE otherwise This function will get called even if CanWriteChildrenWeb() has returned FALSE See also: CanWriteChildrenWeb(), WritePreChildrenWeb() Reimplemented from Node. Definition at line 3030 of file layer.cpp. { return Node::WritePostChildrenWeb(pFilter); }

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

Writes out the layer data suitable for 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 the node has written out a record to the filter FALSE otherwise See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 2798 of file layer.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); // If the layer doesn't want the children to be written out, then don't write out the layer record if (!CanWriteChildrenNative(pFilter)) return FALSE; // Always write out the layer record in the native format CamelotFileRecord Rec(pFilter,TAG_LAYER,TAG_LAYER_SIZE); return (pFilter->Write(&Rec) != 0); #else return FALSE; #endif }

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

Writes out the layer data suitable for 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 the node has written out a record to the filter FALSE otherwise Web files only need to write out the basic layer record - no other info is needed. NOTE: See Layer::CanWriteChildrenWeb() header for the rules that determine whether a layer is actually written or not See also: CanWriteChildrenWeb() Reimplemented from Node. Definition at line 2747 of file layer.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); // If the layer doesn't want the children to be written out, then don't write out the layer record if (!CanWriteChildrenWeb(pFilter)) return FALSE; /*************************************** Originally, .web files would not write out a layer node if there was only one layer i.e. the layer could be implied, hence saving space. However, writing the layer node out has benefits when importing .web files. It means we can easily make sure undo import works, plus we can cope with redraw problems easier. So single-layer docs saved out in the new format will contain a layer node. (markn 12/8/96) - UINT32 WritableLayerCount = CountNumWritableWebLayers(pFilter); - ERROR3IF(WritableLayerCount == 0,"WritableLayerCount should be at least 1"); - - // If there aren't 2 or more writable layers, then don't bother - if (WritableLayerCount < 2) - return FALSE; *****************************************/ CamelotFileRecord Rec(pFilter,TAG_LAYER,TAG_LAYER_SIZE); return (pFilter->Write(&Rec) != 0); #else return FALSE; #endif }

---

Member Data Documentation

BOOL Layer::Active [private]

Definition at line 344 of file layer.h.

BOOL Layer::ActiveLayerVisibleAndEditable = FALSE [static]

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). Preference: ActiveLayerVisibleAndEditable Section: Layers Range: 0 - 1 It is controlled by the "Current layer always visible & editable" switch in the General options tab. See also: NodeRenderableBounded::Init(); Definition at line 278 of file layer.h.

BOOL Layer::Background [private]

Definition at line 350 of file layer.h.

INT32 Layer::EnableLayerCacheing = 1 [static]

Control whether layers are cached or not. Preference: EnableLayerCacheing Section: Layers Range: 0 - 2 See also: NodeRenderableBounded::Init(); Definition at line 279 of file layer.h.

BOOL Layer::Guide [private]

Definition at line 352 of file layer.h.

INT32 Layer::GuideLayerBlue = 0 [static, private]

Definition at line 383 of file layer.h.

INT32 Layer::GuideLayerGreen = 0 [static, private]

Definition at line 382 of file layer.h.

INT32 Layer::GuideLayerRed = 255 [static, private]

Definition at line 381 of file layer.h.

LayerStatus Layer::LayerSt [private]

Definition at line 342 of file layer.h.

BOOL Layer::Locked [private]

Definition at line 347 of file layer.h.

Quality Layer::m_CaptureQuality [private]

Definition at line 370 of file layer.h.

BOOL Layer::m_Edited [private]

Definition at line 362 of file layer.h.

BOOL Layer::m_Frame [private]

Definition at line 364 of file layer.h.

DWORD Layer::m_FrameDelay [private]

Definition at line 368 of file layer.h.

KernelBitmapRef Layer::m_GeneratedBitmap [private]

Definition at line 372 of file layer.h.

BOOL Layer::m_HiddenFrame [private]

Definition at line 365 of file layer.h.

BOOL Layer::m_Overlay [private]

Definition at line 358 of file layer.h.

BOOL Layer::m_PageBackground [private]

Definition at line 354 of file layer.h.

KernelBitmap* Layer::m_pReferencedBitmap [private]

Definition at line 374 of file layer.h.

BOOL Layer::m_Solid [private]

Definition at line 360 of file layer.h.

BOOL Layer::Outline [private]

Definition at line 351 of file layer.h.

DocColour* Layer::pGuideColour [private]

Definition at line 377 of file layer.h.

IndexedColour* Layer::pIndexedGuideColour [private]

Definition at line 378 of file layer.h.

LayerMsgHandler * Layer::pLayerMsgHandler = NULL [static, private]

Definition at line 386 of file layer.h.

BOOL Layer::Printable [private]

Definition at line 349 of file layer.h.

BOOL Layer::Visible [private]

Definition at line 346 of file layer.h.

---

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

• Kernel/layer.h (r1785/r1282)
• Kernel/layer.cpp (r1785/r1361)

---