EffectsStack Class Reference

#include <effects_stack.h>

Inheritance diagram for EffectsStack:

List of all members.

Public Member Functions
	EffectsStack ()
	Constructor.
	~EffectsStack ()
	Destructor.
BOOL	FindBestProcessor (String_256 *pstrEffectID, INT32 *piStackPos)
	Find the most appropriate effect in this effect stack mathcing the given name and stack position.
BOOL	GetLevelInfo (String_256 *pstrEffectID, INT32 *piStackPos)
	Find the most appropriate effect in this effect stack mathcing the given name and stack position.
BOOL	LockableNonEmpty ()
	Determine whether stack is empty or has destructive effects in it.
void	Clear ()
ListRange *	GetLevelRange (INT32 *piStackPos, BOOL bEscapeOldControllers=TRUE)
ListRange *	GetBaseLevelRange ()
	Get a range of nodes forming a surface above the selection and BELOW any live effects applied to the selection! (Used by legacy effects like Bevel, Contour).
PPStackLevel *	GetLevel (INT32 iStackPos)
ListRange *	FindLevelContaining (NodeEffect *pNode, INT32 *piStackPos)
	Find a given node in the post processor stack.
BOOL	NodeInTopLevel (NodeEffect *pNode)
	Find a given node in the post processor stack.
INT32	FindSelectionPos ()
	Find whether the selection has a consistent level INT32 he stack other than the usual base level, -1.
BOOL	BuildEffectMenu (ContextMenu *pMenu)
	Find whether the selection has a consistent level INT32 he stack other than the usual base level, -1.
void	AttrsHaveChanged ()
	Tell any stored ranges that any cahced attr data trhey have is now out of date.
Static Public Member Functions
static ListRange *	GetEffectsStackFromNode (Node *pNode, BOOL bNodeMaybeMidStack=FALSE, BOOL bEscapeDerived=TRUE, BOOL bIncludeLocked=FALSE)
	Get a list of LE nodes that are common to all selected nodes Only returns a list of ALL the selected nodes have identical stacks above them... Does nothing about setting current stack pos or current effect name.
static EffectsStack *	GetEffectsStackFromSelection (Range *pRange=NULL, BOOL bEscapeDerived=TRUE, BOOL bIncludeLocked=FALSE)
	Get a list of LE nodes that are common to all selected nodes Only returns a list of ALL the selected nodes have identical stacks above them...
static BOOL	NodesSharePPStack (Node *pNode, Node *pLastNode, BOOL bNodeMaybeMidStack=FALSE, BOOL bIncludeLocked=FALSE)
	Find out whether two sibling nodes in the tree share the same stack (So that we can avoid adding the same node stack to the combined stack more than once).
static Node *	FindStackBaseFrom (Node *pNode, BOOL bIncludeLocked)
	From the specified node, find the base of the local stack containing that node.
static Node *	EscapeOldControllers (Node *pUserNode)
	Find the node which PostProcessors should be wrapped around, taking old style Controller nodes into account.
static ListRange *	GetNewLevelRange (Range *pRange=NULL, BOOL bEscapeOldControllers=TRUE)
	Get a range of nodes forming a surface above the selection and above any live effects applied to the selection.
static ListRange *	GetTopClassRange (CCRuntimeClass *pClass, BOOL bClassOnly=TRUE, BOOL bIgnorePassThroughEffects=FALSE, Node **ppMasterNode=NULL, INT32 *piStackPos=NULL, Range *pRange=NULL, BOOL bEscapeOldControllers=TRUE)
	Get a range of nodes forming a surface above the selection and within any live effects applied to the selection consisting of all effect nodes of type "class" applied to the selection.
Public Attributes
BOOL	bConsistent
Protected Member Functions
BOOL	Initialise (ListRange *pRange)
BOOL	Intersect (ListRange *pRange)
	Find whether the LE nodes in the presented range match those already in this LE stack. Remove any mismatches from the PPStack, add new nodes to the stack level lists.
PPStackLevel *	FindMatch (PPStackLevel *pFirstItem, ListRange *pRange, NodeEffect *pPP)
	Find whether the LE nodes in the presented range match those already in this LE stack. Remove any mismatches from the PPStack, add new nodes to the stack level lists.
Private Attributes
ListRange *	m_pNewLevelRange

---

Detailed Description

Definition at line 167 of file effects_stack.h.

---

Constructor & Destructor Documentation

EffectsStack::EffectsStack (   )

Constructor. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/2004 Returns: Errors: See also: Definition at line 134 of file effects_stack.cpp. { bConsistent = FALSE; m_pNewLevelRange = NULL; }

EffectsStack::~EffectsStack (   )

Destructor. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/2004 Returns: Errors: See also: Definition at line 153 of file effects_stack.cpp. { // We own m_pNewLevelRange so we must delete it... if (m_pNewLevelRange) { delete m_pNewLevelRange; m_pNewLevelRange = NULL; } Clear(); }

---

Member Function Documentation

void EffectsStack::AttrsHaveChanged (   )

Tell any stored ranges that any cahced attr data trhey have is now out of date. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/10/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 893 of file effects_stack.cpp. { if (m_pNewLevelRange) { m_pNewLevelRange->AttrsHaveChanged(); } }

BOOL EffectsStack::BuildEffectMenu (  ContextMenu *  pMenu  )

Find whether the selection has a consistent level INT32 he stack other than the usual base level, -1. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/06/2005 Parameters: pMenu  - Pointer to ContextMenu we should add items to [INPUTS] -  [OUTPUTS] Returns: TRUE if everything is OK FALSE if something went wrong enough to require caller to stop building menus Errors: See also: Definition at line 1330 of file effects_stack.cpp. { PORTNOTE("menu", "BuildEffectMenu can't do anything until we have XPEHost::GetEffectDetails or equivalent"); #ifndef EXCLUDE_FROM_XARALX PPStackLevel* pItem = (PPStackLevel*)GetHead(); // PPStackLevel* pNextItem = NULL; INT32 pos = 0; pMenu->BuildCommand(OPTOKEN_EDITEFFECTS); MenuItem* pRootItem = pMenu->GetLastItem(); while (pItem!=NULL) { // pNextItem = (PPStackLevel*)GetNext(pItem); String_64 strDisplayName; BOOL bDestructive = FALSE; XPEHost::GetEffectDetails(pItem->strPostProID, &strDisplayName, &bDestructive); OpLiveEffectParam* pParam = new OpLiveEffectParam(); if (pParam==NULL) return FALSE; pParam->strOpUnique = pItem->strPostProID; pParam->bIsDestructive = bDestructive; pParam->StackPosition = pos; pParam->pPPStack = this; if (pItem->strPostProID==String_256(POSTPRO_ID_SHADOW)) pMenu->BuildCommand(OPTOKEN_EDIT_LEGACYEFFECT, FALSE, pRootItem, strDisplayName, pParam); else if (pItem->strPostProID==String_256(POSTPRO_ID_FEATHER)) pMenu->BuildCommand(OPTOKEN_EDIT_LEGACYEFFECT, FALSE, pRootItem, strDisplayName, pParam); else pMenu->BuildCommand(OPTOKEN_EDIT_LIVEEFFECT, FALSE, pRootItem, strDisplayName, pParam); pItem = (PPStackLevel*)GetNext(pItem); pos++; } #endif return TRUE; }

void EffectsStack::Clear (   )

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 515 of file effects_stack.cpp. { // No match so clear out the Stack and return while (GetCount()!=0) { PPStackLevel* pItem = (PPStackLevel*)RemoveTail(); delete pItem; } }

Node * EffectsStack::EscapeOldControllers (  Node *  pUserNode  )  [static]

Find the node which PostProcessors should be wrapped around, taking old style Controller nodes into account. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 29/11/2004 Parameters: pNode  - pointer to node in tree which may have a LiveEffect stack above it [INPUTS] -  [OUTPUTS] Returns: Node* - pointer to node above presented node which is an old style non-postprocessor controller node Definition at line 762 of file effects_stack.cpp. { Node* pTestNode = pUserNode->FindParent(); while (pTestNode && pTestNode->IsController() && !pTestNode->IsEffect()) { pUserNode = pTestNode; pTestNode = pTestNode->FindParent(); } return pUserNode; }

BOOL EffectsStack::FindBestProcessor (  String_256 *  pstrEffectID, INT32 *  piStackPos )

Find the most appropriate effect in this effect stack mathcing the given name and stack position. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if an effect was found FALSE otherwise Errors: See also: Definition at line 421 of file effects_stack.cpp. { INT32 pos = *piStackPos; PPStackLevel* pLevel = NULL; // Search up from the last known stack position for an effect of the same name do { pLevel = (PPStackLevel*)FindItem(pos); if (pLevel && pLevel->strPostProID==*pstrEffectID) { *piStackPos = pos; return TRUE; } pos++; } while (pLevel); // Search down from the last known stack position for an effect of the same name pos = *piStackPos-1; do { pLevel = (PPStackLevel*)FindItem(pos); if (pLevel && pLevel->strPostProID==*pstrEffectID) { *piStackPos = pos; return TRUE; } pos--; } while (pLevel); return FALSE; }

ListRange * EffectsStack::FindLevelContaining (  NodeEffect *  pNode, INT32 *  piStackPos )

Find a given node in the post processor stack. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/11/2004 Parameters: pNode  - Pointer to node to search for [INPUTS] -  [OUTPUTS] Returns: A pointer to a list range owned by the PostProcessor stack describing the layer of consistent nodes in the stack of which Node was a member NULL if couldn't find node in stack Errors: See also: Definition at line 1168 of file effects_stack.cpp. { *piStackPos = STACKPOS_TOP; if (IsEmpty()) return NULL; PPStackLevel* pItem = (PPStackLevel*)GetHead(); *piStackPos = 0; while (pItem!=NULL) { Node* pTestNode = pItem->listSelNodes.FindFirst(); while (pTestNode) { if (pNode==pTestNode) return &pItem->listSelNodes; pTestNode = pItem->listSelNodes.FindNext(pTestNode); } (*piStackPos)++; pItem = (PPStackLevel*)GetNext(pItem); } *piStackPos = STACKPOS_TOP; return NULL; }

PPStackLevel * EffectsStack::FindMatch (  PPStackLevel *  pFirstItem, ListRange *  pRange, NodeEffect *  pPP )  [protected]

Find whether the LE nodes in the presented range match those already in this LE stack. Remove any mismatches from the PPStack, add new nodes to the stack level lists. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/2004 Parameters: pRange  - A stack of LiveEffects above a node in the selection [INPUTS] [OUTPUTS]  Returns: Errors: See also: Definition at line 544 of file effects_stack.cpp. { PPStackLevel* pItem = pFirstItem; PPStackLevel* pLastMatchItem = NULL; BOOL bMatch = TRUE; // HRESULT hr; do { bMatch = pPP->CompareState(pItem->pPPNode); // Polymorphic compare for PostProcessors if (bMatch) pLastMatchItem = pItem; // Possible future change to detect inconsistent levels. But this would require changes elsewhere // bMatch = (pPP->GetRuntimeClass() == pItem->pPPNode->GetRuntimeClass()); // if (pItem->bConsistent) // { // pItem->bConsistent = pPP->CompareState(pItem->pPPNode); // } pPP = (NodeEffect*)pRange->FindNext(pPP); pItem = (PPStackLevel*)GetNext(pItem); } while (bMatch && pItem!=NULL && pPP); return pLastMatchItem; }

INT32 EffectsStack::FindSelectionPos (   )

Find whether the selection has a consistent level INT32 he stack other than the usual base level, -1. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The stack position of the selection or -1 Errors: See also: Definition at line 1249 of file effects_stack.cpp. { INT32 Pos = -1; Range* pRange = GetApplication()->FindSelection(); ENSURE(pRange, "!"); ENSURE(pRange->GetRangeControlFlags().PromoteToParent==FALSE, "GetEffectsStackFromSel given a bad range"); PPStackLevel* pFoundLevel = NULL; Node* pNode = pRange->FindFirst(); while (pNode) { Node* pStackNode = pNode->GetParentController(); if (pStackNode==NULL) return -1; if (pFoundLevel==NULL) { PPStackLevel* pItem = (PPStackLevel*)GetHead(); Pos = 0; while (pItem!=NULL && pFoundLevel==NULL) { Node* pTestNode = pItem->listSelNodes.FindFirst(); while (pTestNode && pTestNode!=pStackNode) { pTestNode = pItem->listSelNodes.FindNext(pTestNode); } if (pTestNode==pStackNode) { pFoundLevel = pItem; break; } Pos++; pItem = (PPStackLevel*)GetNext(pItem); } if (pFoundLevel==NULL) return -1; } else { // Just look in the level we have already identified... Node* pTestNode = pFoundLevel->listSelNodes.FindFirst(); while (pTestNode && pTestNode!=pStackNode) { pTestNode = pFoundLevel->listSelNodes.FindNext(pTestNode); } if (pTestNode!=pStackNode) { return -1; } } pNode = pRange->FindNext(pNode); } return Pos; }

Node * EffectsStack::FindStackBaseFrom (  Node *  pNode, BOOL  bIncludeLocked )  [static]

From the specified node, find the base of the local stack containing that node. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/2004 Parameters: pNode  - pointer to node in tree which may have a LiveEffect stack above it [INPUTS] and below it! -  [OUTPUTS] Returns: Pointer to node at the base of the stack containing the input node Definition at line 719 of file effects_stack.cpp. { Node* pStackNode = pNode; if (!pStackNode->IsEffect()) { if (pStackNode->GetParentController()) pStackNode = pStackNode->GetParentController(); } while (pStackNode && pStackNode->IsEffect()) { // Stop immediately if we find a destructive post pro - the user cannot be // allowed to see or manipulate anything underneath one of those... if (!bIncludeLocked && ((NodeEffect*)pStackNode)->IsLockedEffect()) break; if (!((NodeEffect*)pStackNode)->CanBeUnlocked()) break; pStackNode = ((NodeEffect*)pStackNode)->GetInkNodeFromController(); } return pStackNode; }

ListRange * EffectsStack::GetBaseLevelRange (   )

Get a range of nodes forming a surface above the selection and BELOW any live effects applied to the selection! (Used by legacy effects like Bevel, Contour). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 03/12/2004 Parameters: -  [INPUTS] [OUTPUTS]  Returns: A pointer to a list range owned by you! Errors: See also: Definition at line 1119 of file effects_stack.cpp. { // Loop through selection ensuring that all nodes are LiveEffects // and that they all share the same edit list Range* pRange = GetApplication()->FindSelection(); ENSURE(pRange, "No selection in GetNewLevelRange!"); // We want to apply the LiveEffect to the entire selection, underneath any PostProcessors // // Loop through the current selection and search the parents of each selected node ListRange* pLERange = new ListRange(); Node* pNode = pRange->FindFirst(); // INT32 pos = 0; while (pNode!=NULL) { Node* pEscNode = pNode; // Only traverse the effect stack if the selected node is 'in' the effect stack // (it could be offset, e.g. NodeShadow) if (!pNode->NeedsParent(pNode->FindParent())) pEscNode = EscapeOldControllers(pNode); pLERange->AddNode(pEscNode); pNode = pRange->FindNext(pNode); } return pLERange; }

ListRange * EffectsStack::GetEffectsStackFromNode (  Node *  pNode, BOOL  bNodeMaybeMidStack = FALSE, BOOL  bEscapeDerived = TRUE, BOOL  bIncludeLocked = FALSE )  [static]

Get a list of LE nodes that are common to all selected nodes Only returns a list of ALL the selected nodes have identical stacks above them... Does nothing about setting current stack pos or current effect name. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/2004 Parameters: pNode  - pointer to node in tree which may have a LiveEffect stack above it [INPUTS] -  [OUTPUTS] Returns: pPPStack - NULL if <None> Empty if <Many> Populated if consistent stack (caller becomes owner of this list!) See also: LiveEffectsTool::GetLEListFromSelAndStack Definition at line 593 of file effects_stack.cpp. { // First, test whether node CAN be in a PPStack or stands aside from it // (E.g. shadows) // if (!bEscapeDerived && pNode->NeedsParent(pNode->FindParent())) return NULL; ListRange* pStack = new ListRange(); Node* pUpNode = pNode; // If the node could be in the middle of a stack then we need to find the base // of the stack before we start our scan // (E.g. the node could be a selected Shadow node somewhere high above the // object it applies to) if (bNodeMaybeMidStack) { pUpNode = FindStackBaseFrom(pUpNode, bIncludeLocked); } // Special case handling for old legacy effects until they become true // PostProcessors... // Search for Contour, Bevel, ClipView controllers above selected node // and if found, make them the base for PostProcessor scanning pUpNode = EscapeOldControllers(pUpNode); // Now go up the post processor stack, adding every one we find to the list do { if (pUpNode->IsEffect()) pStack->AddNode(pUpNode); pUpNode = pUpNode->FindParent(); } while (pUpNode && pUpNode->IsEffect()); // Best to get rid of the list here if it's empty (don't trust caller) if (pStack->IsEmpty()) { delete pStack; pStack = NULL; } return pStack; }

EffectsStack * EffectsStack::GetEffectsStackFromSelection (  Range *  pRange = NULL, BOOL  bEscapeDerived = TRUE, BOOL  bIncludeLocked = FALSE )  [static]

Get a list of LE nodes that are common to all selected nodes Only returns a list of ALL the selected nodes have identical stacks above them... Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/10/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: pStack - pointer to ListRange representing stack applied consistently to selection Definition at line 182 of file effects_stack.cpp. { // Loop through selection ensuring that all nodes are LiveEffects // and that they all share the same edit list if (pRange==NULL) pRange = GetApplication()->FindSelection(); ENSURE(pRange, "!"); ENSURE(pRange->GetRangeControlFlags().PromoteToParent==FALSE, "GetEffectsStackFromSel given a bad range"); EffectsStack* pPPStack = new EffectsStack(); // New stack is marked as being "inconsistent" BOOL bStartNewStack = TRUE; ListRange* pLocalStack = NULL; BOOL bLiveEffectsAreApplied = FALSE; // Ensure that pEditedLE has a useful value... // Loop through the current selection and search the parents of each selected node for LiveEffects... Node* pNode = pRange->FindFirst(); Node* pLastNode = NULL; while (pNode!=NULL) { if (pNode->IsAnObject()) { // Don't try to add the same stack to the system more than once // (For instance NodeShadows and their originals are siblings and can both be selected // below a NodeShadowController) if (!NodesSharePPStack(pNode, pLastNode, TRUE, bIncludeLocked)) { // Get the local stack pLocalStack = GetEffectsStackFromNode(pNode, TRUE, bEscapeDerived, bIncludeLocked); // If this node is in the middle of a stack, find the whole stack if (pLocalStack) { bLiveEffectsAreApplied = TRUE; if (bStartNewStack) { if (pPPStack->IsEmpty()) { pPPStack->Initialise(pLocalStack); } else { BOOL bOK = pPPStack->Intersect(pLocalStack); if (!bOK) { delete pLocalStack; pPPStack->Clear(); // Just to make sure! return pPPStack; } } } delete pLocalStack; } else { // A node in the selection doesn't have any LiveEffects applied but we can't stop // because we have to keep scanning to see whether ANY nodes have LiveEffects // Clear the effect stack out because this node has none. pPPStack->Clear(); bStartNewStack = FALSE; // Could test for lengthy scanning here and if it takes too long return <UNKNOWN> // if (taking too long) code = SELTYPE_UNKNOWN; } } pLastNode = pNode; } pNode = pRange->FindNext(pNode); } if (pPPStack->IsEmpty() && bLiveEffectsAreApplied) pPPStack->bConsistent = FALSE; else pPPStack->bConsistent = TRUE; return pPPStack; }

PPStackLevel* EffectsStack::GetLevel (  INT32  iStackPos  )  [inline]

Definition at line 196 of file effects_stack.h. {return (PPStackLevel*)FindItem(iStackPos);}

BOOL EffectsStack::GetLevelInfo (  String_256 *  pstrEffectID, INT32 *  piStackPos )

Find the most appropriate effect in this effect stack mathcing the given name and stack position. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/11/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if an effect was found FALSE otherwise Errors: See also: Definition at line 479 of file effects_stack.cpp. { PPStackLevel* pLevel = NULL; if (*piStackPos>=STACKPOS_TOP) pLevel = (PPStackLevel*)GetTail(); else pLevel = (PPStackLevel*)FindItem(*piStackPos); if (pLevel) { *piStackPos = (INT32) this->FindPosition(pLevel); *pstrEffectID = pLevel->strPostProID; return TRUE; } return FALSE; }

ListRange * EffectsStack::GetLevelRange (  INT32 *  piStackPos, BOOL  bEscapeOldControllers = TRUE )

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 29/09/2004 Parameters: iStackPos  - position in LiveEffect stack to find nodes [INPUTS] 0 means first stack pos above selection [OUTPUTS]  Returns: A pointer to a list range owned by the EffectsStack - i.e. you don't have to delete it when you're finished. Errors: See also: Definition at line 832 of file effects_stack.cpp. { ENSURE(*piStackPos>=0, "Invalid stack pos in GetLevelRange!"); // If the stack is inconsistent then we need to make a range of nodes that arch // over the selection and any stacked PostProcessors that might be on them // In this case we expect our caller to not have specified a valid stack position if (!bConsistent || IsEmpty() || *piStackPos>=STACKPOS_TOP) { ENSURE(*piStackPos>=STACKPOS_TOP, "Incorrect attempt to insert into an inconsistent PostPro stack"); // By definition, if someone had previously requested a new level range // during the lifetime of this effects stack then the same range must // still apply (otherwise the EffectsStack would have been destroyed). // So just return the range we already found... if (m_pNewLevelRange) { return m_pNewLevelRange; // delete m_pNewLevelRange; // m_pNewLevelRange = NULL; } m_pNewLevelRange = GetNewLevelRange(NULL, bEscapeOldControllers); // We own this listrange, so we can delete it later // Return new stack pos; correct number for consistent stack, INVALID for inconsistent stack if (bConsistent) *piStackPos = ((INT32)GetCount())-1; else *piStackPos = STACKPOS_INVALID; return m_pNewLevelRange; } // This is the typical case: Adding/Inserting to a consistent stack if (*piStackPos>=(INT32)GetCount()) *piStackPos = ((INT32)GetCount())-1; PPStackLevel* pLevel = (PPStackLevel*)FindItem(*piStackPos); ENSURE(pLevel, "Argh something's got out of line!"); ListRange* pLERange = &pLevel->listSelNodes; return pLERange; // The EffectsStack owns this listrange }

ListRange * EffectsStack::GetNewLevelRange (  Range *  pRange = NULL, BOOL  bEscapeOldControllers = TRUE )  [static]

Get a range of nodes forming a surface above the selection and above any live effects applied to the selection. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 26/10/2004 Parameters: -  [INPUTS] [OUTPUTS]  Returns: A pointer to a list range owned by you! Errors: See also: Definition at line 919 of file effects_stack.cpp. { // Loop through selection ensuring that all nodes are LiveEffects // and that they all share the same edit list if (pRange==NULL) pRange = GetApplication()->FindSelection(); ENSURE(pRange, "No selection in GetNewLevelRange!"); // We want to apply the LiveEffect to the entire selection, however inconsistent it is // // Loop through the current selection and search the parents of each selected node for LiveEffects... ListRange* pLERange = new ListRange(); Node* pNode = pRange->FindFirst(); INT32 pos = 0; while (pNode!=NULL) { NodeEffect* pFirstEditedLE = NULL; Node* pBaseNode = pNode; // Only traverse the effect stack if the selected node is 'in' the effect stack // (it could be offset, e.g. NodeShadow) if (!pNode->NeedsParent(pNode->FindParent())) { if (bEscapeOldControllers) pBaseNode = EscapeOldControllers(pNode); Node* pUpNode = pBaseNode; pos = 0; do { pUpNode = pUpNode->FindParent(); if (pUpNode && pUpNode->IsEffect()) pFirstEditedLE = (NodeEffect*)pUpNode; pos++; } while (pUpNode && pUpNode->IsEffect()); } if (pFirstEditedLE) { pLERange->AddNode(pFirstEditedLE); } else { pLERange->AddNode(pBaseNode); } pNode = pRange->FindNext(pNode); } return pLERange; }

ListRange * EffectsStack::GetTopClassRange (  CCRuntimeClass *  pClass, BOOL  bClassOnly = TRUE, BOOL  bIgnorePassThroughEffects = FALSE, Node **  ppMasterNode = NULL, INT32 *  piStackPos = NULL, Range *  pRange = NULL, BOOL  bEscapeOldControllers = TRUE )  [static]

Get a range of nodes forming a surface above the selection and within any live effects applied to the selection consisting of all effect nodes of type "class" applied to the selection. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 11/05/2005 Parameters: pClass  - pointer to class of node to find in effects stack [INPUTS] bClassOnly - Only allow nodes of the specified class to be added to the list pRange - pointer to range of nodes to scan bEscapeConts- TRUE if old controller nodes should be escaped pMasterNode  - pointer to one example of this class of node in the returned range [OUTPUTS] piStackPos - pointer to stack pos INT32 Returns: A pointer to a list range owned by you! Errors: Definition at line 1004 of file effects_stack.cpp. { // Loop through selection ensuring that all nodes are LiveEffects // and that they all share the same edit list if (pRange==NULL) pRange = GetApplication()->FindSelection(); ENSURE(pRange, "No selection in GetClassRange!"); if (ppMasterNode) *ppMasterNode = NULL; // We want to apply the LiveEffect to the entire selection, however inconsistent it is // // Loop through the current selection and search the parents of each selected node for LiveEffects... ListRange* pLERange = new ListRange(); Node* pNode = pRange->FindFirst(); INT32 pos = 0; while (pNode!=NULL) { NodeEffect* pFirstEditedLE = NULL; NodeEffect* pFirstEditedEffectClass = NULL; Node* pBaseNode = pNode; // Only traverse the effect stack if the selected node is 'in' the effect stack // (it could be offset/derived, e.g. NodeShadow) // In this context we know that we always want to go up effects stacks whether the selected node // is mainstream or derived... // if (!pNode->NeedsParent(pNode->FindParent())) // { if (bEscapeOldControllers) pBaseNode = EscapeOldControllers(pNode); Node* pUpNode = pBaseNode; pos = 0; do { pUpNode = pUpNode->FindParent(); if (pUpNode && pUpNode->IsEffect()) // if (!(bIgnorePassThroughEffects && ((NodeEffect*)pUpNode)->IsPassThroughEffect())) // The meaning of the bIgnorePassThroughEffects has changed to mean "ignore all effects" if (!bIgnorePassThroughEffects) pFirstEditedLE = (NodeEffect*)pUpNode; if (pUpNode && pUpNode->IsEffect() && pUpNode->GetRuntimeClass() == pClass) { pFirstEditedEffectClass = (NodeEffect*)pUpNode; // iClassPos = pos; } pos++; } while (pUpNode && pUpNode->IsEffect()); // } // Decide what effect node should be added to the listrange for this node in the input range // Add a node of the specified class if we found one if (pFirstEditedEffectClass) { pLERange->AddNode(pFirstEditedEffectClass); if (ppMasterNode && *ppMasterNode==NULL) *ppMasterNode = pFirstEditedEffectClass; } // Add the last effect if effects were found else if (!bClassOnly) { if (pFirstEditedLE) { pLERange->AddNode(pFirstEditedLE); } // Add the input node itself if no effects were found else { pLERange->AddNode(pBaseNode); } } pNode = pRange->FindNext(pNode); } // Temp hack if (piStackPos) *piStackPos = STACKPOS_INVALID; return pLERange; }

BOOL EffectsStack::Initialise (  ListRange *  pRange  )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 279 of file effects_stack.cpp. { ENSURE(pRange, "EffectsStack::Initialise must be given a range"); Node* pNode = pRange->FindFirst(); while (pNode) { ENSURE(pNode->IsEffect(), "PostProcessor list contains non-PostProcessor in EffectsStack::Initialise"); NodeEffect* pLE = (NodeEffect*)pNode; PPStackLevel* pNewItem = new PPStackLevel(); pNewItem->pPPNode = pLE; pNewItem->listSelNodes.AddNode(pLE); pNewItem->strPostProID = pLE->GetPostProcessorID(); AddTail(pNewItem); pNode = pRange->FindNext(pNode); } return TRUE; }

BOOL EffectsStack::Intersect (  ListRange *  pRange  )  [protected]

Find whether the LE nodes in the presented range match those already in this LE stack. Remove any mismatches from the PPStack, add new nodes to the stack level lists. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/2004 Parameters: pRange  - A stack of LiveEffects above a node in the selection [INPUTS] [OUTPUTS]  Returns: Errors: See also: Definition at line 323 of file effects_stack.cpp. { ENSURE(pRange, "EffectsStack::Intersect must be given a range"); Node* pNode = pRange->FindFirst(); while (pNode) { ENSURE(pNode->IsEffect(), "PostProcessor list contains non-PostProcessor in EffectsStack::Intersect"); NodeEffect* pLE = (NodeEffect*)pNode; PPStackLevel* pLastMatchItem = NULL; PPStackLevel* pFirstMatchItem = (PPStackLevel*)GetHead(); NodeEffect* pStackSample; while (pFirstMatchItem!=NULL && pLastMatchItem==NULL) { pStackSample = pFirstMatchItem->pPPNode; pLastMatchItem = FindMatch(pFirstMatchItem, pRange, pLE); if (pLastMatchItem) break; // Stop as soon as we find a match! pFirstMatchItem = (PPStackLevel*)GetNext(pFirstMatchItem); } if (pLastMatchItem) { // ------------------------------------------------------------ // We have a match so remove the stack levels that didn't match PPStackLevel* pItem = (PPStackLevel*)GetHead(); while (pItem != pFirstMatchItem) { PPStackLevel* pNextItem = (PPStackLevel*)GetNext(pItem); RemoveItem(pItem); pItem = pNextItem; } // ------------------------------------------------------------ // Add the nodes that do match to the ListRanges in the levels do { pItem->listSelNodes.AddNode(pLE); pLE = (NodeEffect*)pRange->FindNext(pLE); pItem = (PPStackLevel*)GetNext(pItem); } while (pItem!=NULL && pItem!=pLastMatchItem && pLE!=NULL); if (pItem!=NULL && pItem==pLastMatchItem && pLE!=NULL) { pItem->listSelNodes.AddNode(pLE); } // ------------------------------------------------------------ // Remove further levels that didn't match if (pItem) { pItem = (PPStackLevel*)GetNext(pItem); while (pItem != NULL) { PPStackLevel* pNextItem = (PPStackLevel*)GetNext(pItem); RemoveItem(pItem); pItem = pNextItem; } } return TRUE; } pNode = pRange->FindNext(pNode); } Clear(); return FALSE; }

BOOL EffectsStack::LockableNonEmpty (   )

Determine whether stack is empty or has destructive effects in it. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/2004 Parameters: pNode  - pointer to node in tree which may have a LiveEffect stack above it [INPUTS] -  [OUTPUTS] Returns: TRUE if stack has some lockable effects layers FALSE if no levels or any level contains an unlockable effect See also: LiveEffectsTool::GetLEListFromSelAndStack Definition at line 792 of file effects_stack.cpp. { if (IsEmpty()) return FALSE; PPStackLevel* pItem = (PPStackLevel*)GetHead(); NodeEffect* pLENode; while (pItem!=NULL) { pLENode = pItem->pPPNode; ENSURE(pLENode, "PPStackLevel node pointer is NULL in LockableNonEmpty"); if (!pLENode->CanBeUnlocked()) return FALSE; pItem = (PPStackLevel*)GetNext(pItem); } return TRUE; }

BOOL EffectsStack::NodeInTopLevel (  NodeEffect *  pNode  )

Find a given node in the post processor stack. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/2004 Parameters: pNode  - Pointer to node to search for [INPUTS] -  [OUTPUTS] Returns: TRUE if the node is in the top level of the stack FALSE otherwise Errors: See also: Definition at line 1213 of file effects_stack.cpp. { if (IsEmpty()) return TRUE; PPStackLevel* pItem = (PPStackLevel*)GetTail(); Node* pTestNode = pItem->listSelNodes.FindFirst(); while (pTestNode) { if (pNode==pTestNode) return TRUE; pTestNode = pItem->listSelNodes.FindNext(pTestNode); } return FALSE; }

BOOL EffectsStack::NodesSharePPStack (  Node *  pNode, Node *  pLastNode, BOOL  bNodeMaybeMidStack = FALSE, BOOL  bIncludeLocked = FALSE )  [static]

Find out whether two sibling nodes in the tree share the same stack (So that we can avoid adding the same node stack to the combined stack more than once). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 16/11/2004 Parameters: pNode  - pointer to node in tree which may have a LiveEffect stack above it [INPUTS] pLastNode - pointer to another node whicyh may have a LiveEffect stack -  [OUTPUTS] Returns: TRUE if both nodes have the same stack above them FALSE if the nodes have different stacks See also: LiveEffectsTool::GetLEListFromSelAndStack Definition at line 660 of file effects_stack.cpp. { if (pNode==NULL || pLastNode==NULL) return FALSE; if (bNodeMaybeMidStack) { // Find the true stack base for both these pNode = FindStackBaseFrom(pNode, bIncludeLocked); pLastNode = FindStackBaseFrom(pLastNode, bIncludeLocked); } // Special case handling for old legacy effects until they become true // PostProcessors... // Search for Contour, Bevel, ClipView controllers above selected node // and if found, make them the base for PostProcessor scanning pNode = EscapeOldControllers(pNode); pLastNode = EscapeOldControllers(pLastNode); if (!bIncludeLocked) { if (pNode->IsEffect() && ((NodeEffect*)pNode)->IsLockedEffect()) return FALSE; if (pLastNode->IsEffect() && ((NodeEffect*)pLastNode)->IsLockedEffect()) return FALSE; } if (pNode->IsEffect() && !((NodeEffect*)pNode)->CanBeUnlocked()) return FALSE; if (pLastNode->IsEffect() && !((NodeEffect*)pLastNode)->CanBeUnlocked()) return FALSE; Node* pParent = pNode->FindParent(); if (pParent==NULL) return FALSE; return (pParent == pLastNode->FindParent() && pParent->IsEffect()); }

---

Member Data Documentation

BOOL EffectsStack::bConsistent

Definition at line 210 of file effects_stack.h.

ListRange* EffectsStack::m_pNewLevelRange [private]

Definition at line 213 of file effects_stack.h.

---

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

• Kernel/effects_stack.h (r1785/r751)
• Kernel/effects_stack.cpp (r1785/r859)

---