OpLiveEffect Class Reference

Base class for all LiveEffect ops See also:. More...

#include <opliveeffects.h>

Inheritance diagram for OpLiveEffect:

List of all members.

Public Member Functions
	OpLiveEffect ()
	Constructor.
	~OpLiveEffect ()
	Destructor.
virtual void	Do (OpDescriptor *pOpDesc)
virtual void	DoWithParam (OpDescriptor *pOpDesc, OpParam *pOpParam)
ListRange *	GetLiveEffectList ()
virtual void	DoEndEdit (BOOL bChangingSelection=FALSE, BOOL bBroadcast=TRUE, BOOL bCancelled=FALSE, BOOL bEmpty=FALSE)
BOOL	GetPreviewQuality () const
void	SetPreviewQuality (BOOL bNew)
Protected Member Functions
ListRange *	DoApplyLiveEffect (Range *pSel, String_256 strEffectID, String_64 strDisplayName, double dResolution, IXMLDOMDocumentPtr pEditsList=NULL, BOOL bMakeLocked=FALSE, BOOL bDetectDirectBitmaps=FALSE)
virtual ListRange *	DoApplyLockedEffect (Range *pSel, String_256 strEffectID, String_64 strDisplayName, double dResolution, IXMLDOMDocumentPtr pEditsList=NULL, BOOL bDetectDirectBitmaps=FALSE)
BOOL	EnsureLiveEffectOriginalBitmaps ()
	Ensure that all NodeBitmapEffects in the current selection have original bitmaps ready and wait for us to pick up.
BOOL	GenerateBitmap (NodeBitmapEffect *pBitmapEffect, double dResolution, LPBITMAPINFO *ppInfo, LPBYTE *ppBits, DocRect *prectBounds)
BOOL	SetChanged (BOOL bNewState)
BOOL	HasChanged ()
	Detect whether any of the LiveEffect nodes created/edited by this operation have actually been changed/do anything useful...
BOOL	IsTopOfStack (EffectsStack *pPPStack, INT32 iStackPos)
virtual BOOL	DoEffectOp (ListRange *pLevelRange, OpLiveEffectParam *pLEOpParam)
virtual BOOL	AllowEmptySelection () const
virtual BOOL	CheckEffectOpParam (OpLiveEffectParam *pLEOpParam)
virtual BOOL	DoEffectRangeOp (UINT32 idsProgress, Range *pLevel, OpLiveEffectParam *pParam)
virtual BOOL	DoEffectNodeOp (NodeEffect *pEffect, OpLiveEffectParam *pParam, NodeBitmapEffect **ppNewEffect)
Protected Attributes
ListRange *	m_pLERange
BOOL	m_bAppliedNewEffects
String_256	m_strEffectID
INT32	m_iStackPos
BOOL	m_bPreviewQuality
Private Member Functions
	CC_DECLARE_DYNCREATE (OpLiveEffect)
Static Private Member Functions
static BOOL	Init ()
static BOOL	UpdateCurrentEditor ()
	Reset the current Op to refer to the new PPStack and tell the running XPE edit that things are changing.
static BOOL	DoCopyPPStackToSelection (UndoableOperation *pOp, EffectsStack *pPPStack, Document *pSrcDoc, Document *pDestDoc)
	Copy the specified LiveEffect stack onto the selection Used by Paste Attributes.
static BOOL	DoLocaliseLiveEffects (UndoableOperation *pOp, Node *pNode)
	Copy the specified LiveEffect stack onto the selection Used by Paste Attributes.
static BOOL	DoLocaliseEffectAttrs (UndoableOperation *pOp, Node *pNode)
	Copy the Effect attributes from the specified node down to lower nodes, remaining effect attrs where possible but becoming normal attrs if that's not possible Used by ungroup.
static BOOL	DoCopyEffectAttr (UndoableOperation *pOp, NodeAttribute *pAttr, Node *pNode)
	Copy the Effect attributes from the specified node down to lower nodes, remaining effect attrs where possible but becoming normal attrs if that's not possible Used by ungroup.
static Node *	DoDeleteAllPostProcessors (UndoableOperation *pOp, NodeRenderableInk *pNode, BOOL bDeleteOldControllers=FALSE, BOOL bDeleteBelowLocked=FALSE)
static BOOL	DoDeletePostProcessor (UndoableOperation *pOp, Range *pRange)
static BOOL	DoDeletePostProcessor (UndoableOperation *pOp, NodeEffect *pLE, BOOL bMoveEffectAttrs=FALSE)
static ListRange *	DoApplyFeatherEffect (UndoableOperation *pOp, Range *pSel, String_256 strEffectID, String_64 strDisplayName, MILLIPOINT FeatherSize, CProfileBiasGain Profile)
static NodeFeatherEffect *	DoApplyFeatherEffectNode (UndoableOperation *pOp, Node *pSel, String_256 strEffectID, String_64 strDisplayName, MILLIPOINT FeatherSize, CProfileBiasGain Profile)
static BOOL	DoCopyEffectsStack (UndoableOperation *pOp, Node *pDestNode, ListRange *pEffectsStack, Document *pSrcDoc, Document *pDestDoc)
	Copy the specified LiveEffect stack onto the selection Used by Paste Attributes and OpCombineShapes.
static NodeBitmapEffect *	DoApplyLiveEffect (UndoableOperation *pOp, Node *pNode, String_256 strEffectID, String_64 strDisplayName, double dResolution, IXMLDOMDocumentPtr pEditsList=NULL, BOOL bMakeLocked=FALSE)
static BOOL	DoCopyAttributes (UndoableOperation *pOp, Node *pSrcNode, Node *pDestNode, BOOL bEffectsOnly, Document *pSrcDoc, Document *pDestDoc)
	Copy the specified LiveEffect stack onto the selection Used by Paste Attributes Assumes that only simple attributes will be copied in simple situations I.e. attrs that aren't optimsed so much.

---

Detailed Description

Base class for all LiveEffect ops See also:.

Author:

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

Date:

13/09/2004

Definition at line 229 of file opliveeffects.h.

---

Constructor & Destructor Documentation

OpLiveEffect::OpLiveEffect (   )

Constructor. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/09/2004 Returns: Errors: See also: Definition at line 168 of file opliveeffects.cpp. { m_pLERange=NULL; m_bAppliedNewEffects = FALSE; m_iStackPos = 0; m_bPreviewQuality = FALSE; }

OpLiveEffect::~OpLiveEffect (   )

Destructor. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/09/2004 Returns: Errors: See also: Definition at line 189 of file opliveeffects.cpp. { if (m_pLERange) { delete m_pLERange; m_pLERange = NULL; } }

---

Member Function Documentation

virtual BOOL OpLiveEffect::AllowEmptySelection (   )  const [inline, protected, virtual]

Reimplemented in OpEditLiveEffect. Definition at line 307 of file opliveeffects.h. { return FALSE; }

OpLiveEffect::CC_DECLARE_DYNCREATE (  OpLiveEffect   )  [private]

BOOL OpLiveEffect::CheckEffectOpParam (  OpLiveEffectParam *  pLEOpParam  )  [protected, virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/06/2005 Parameters: pLEopParam  - pointer to parameter object to check [INPUTS] -  [OUTPUTS] Returns: TRUE if Op can continue FALSE otherwise Reimplemented in OpDeleteAllLiveEffect, and OpEffectLockAll. Definition at line 2615 of file opliveeffects.cpp. { if (pLEOpParam->StackPosition==-1) { ERROR3("OpLiveEffect must be given a valid position in the LiveEffects Stack"); return FALSE; } // ERROR3IF(pLEOpParam->pPPStack==NULL, "Can't find EffectsStack"); if (pLEOpParam->pPPStack==NULL) return FALSE; return TRUE; }

void OpLiveEffect::Do (  OpDescriptor *  pOpDesc  )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/06/2005 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Reimplemented from Operation. Definition at line 2464 of file opliveeffects.cpp. { // ERROR3("Why are you doing this? You need params, boy, params!"); DoWithParam(pOpDesc, NULL); }

ListRange * OpLiveEffect::DoApplyFeatherEffect (  UndoableOperation *  pOp, Range *  pSel, String_256  strEffectID, String_64  strDisplayName, MILLIPOINT  FeatherSize, CProfileBiasGain  Profile )  [static, private]

Definition at line 585 of file opliveeffects.cpp. { ENSURE(pSel, "DoApplyFeatherEffect not given a useful range"); ENSURE(strEffectID!=String(""), "DoApplyFeatherEffect given blank effect name string"); ListRange* pLERange = new ListRange(); ENSURE(pLERange, "DoApplyEffect can't create a ListRange"); if (pLERange==NULL) return NULL; Node* pNode = pSel->FindFirst(); BOOL bOK = TRUE; while (pNode && bOK) { NodeFeatherEffect* pEffect = DoApplyFeatherEffectNode(pOp, pNode, strEffectID, strDisplayName, FeatherSize, Profile); if (pEffect) { pLERange->AddNode(pEffect); // Make sure the attributes are optimised correctly bOK = pOp->DoFactorOutCommonChildAttributes(pEffect); } else bOK = FALSE; pNode = pSel->FindNext(pNode); } if (pLERange->FindFirst()==NULL || bOK==FALSE) { // Don't let an empty list of LiveEffect nodes hang around delete pLERange; pLERange = NULL; } return pLERange; }

NodeFeatherEffect * OpLiveEffect::DoApplyFeatherEffectNode (  UndoableOperation *  pOp, Node *  pSel, String_256  strEffectID, String_64  strDisplayName, MILLIPOINT  FeatherSize, CProfileBiasGain  Profile )  [static, private]

Definition at line 650 of file opliveeffects.cpp. { ENSURE(pNode, "DoApplyFeatherEffectNode not given a useful node"); ENSURE(strEffectID!=String(""), "DoApplyFeatherEffectNode given blank effect name string"); BOOL bSelectInside = pNode->IsSelected() || pNode->IsParentOfSelected(); // create a new NodeLiveEffect, which we will shortly insert into the tree; // note that ALLOC_WITH_FAIL automatically calls FailAndExecute() if things go wrong. NodeFeatherEffect* pBmpFXNode = NULL; ALLOC_WITH_FAIL(pBmpFXNode, new NodeFeatherEffect, pOp); if (pBmpFXNode == NULL) return NULL; // put an action to hide the NodeClipViewController onto the undo action-list, // so that if the user presses undo then it will be hidden. pBmpFXNode->SetPostProcessorID(strEffectID); pBmpFXNode->SetDisplayName(strDisplayName); pBmpFXNode->m_FeatherSize = FeatherSize; pBmpFXNode->m_Profile = Profile; HideNodeAction* pUndoHideNodeAction = NULL; ActionCode ac = HideNodeAction::Init(pOp, pOp->GetUndoActions(), pBmpFXNode, FALSE, // don't include subtree size (Action**)&pUndoHideNodeAction, FALSE); // don't tell subtree when undone if (ac == AC_FAIL) { delete pBmpFXNode; return NULL; } // right! we've got our node, we've got our action - lets stick it in the tree // (at a position just next to the last node which will go in the group). pBmpFXNode->AttachNode(pNode, NEXT); // Move the node below the newly inserted LiveEffect BOOL bOK = pOp->DoMoveNode(pNode, pBmpFXNode, FIRSTCHILD); if (!bOK) return NULL; // Deselect the node and select the live effect instead ((NodeRenderable*)pNode)->DeSelect(FALSE); pBmpFXNode->Select(FALSE); // Set the OpPersmission flags in the newly inserted node // Otherwise the tree scanner in UpdateChangedNodes won't go below this node ObjChangeFlags cFlags(NULL, TRUE, NULL, NULL, NULL, NULL, NULL, TRUE); // ReplaceNode & RegenerateNode ObjChangeParam ObjChange(OBJCHANGE_STARTING, cFlags, NULL, pOp); pBmpFXNode->AllowOp(&ObjChange); return pBmpFXNode; }

ListRange * OpLiveEffect::DoApplyLiveEffect (  Range *  pSel, String_256  strEffectID, String_64  strDisplayName, double  dResolution, IXMLDOMDocumentPtr  pEditsList = NULL, BOOL  bMakeLocked = FALSE, BOOL  bDetectDirectBitmaps = FALSE )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 29/09/2004 Parameters: pSel  - pointer to range of nodes to insert LiveEffects above [INPUTS] strDispayName - The display name of the effect we're going to apply pNewSel  - pointer to new range of LiveEffect nodes [OUTPUTS] NULL if no new live effects added Returns: Errors: See also: Definition at line 365 of file opliveeffects.cpp. { ENSURE(pSel, "DoApplyLiveEffect not given a useful range"); ENSURE(strEffectID!=String(""), "DoApplyLiveEffect given blank effect name string"); ListRange* pLERange = new ListRange(); ENSURE(pLERange, "DoApplyEffect can't create a ListRange"); if (pLERange==NULL) return NULL; Node* pNode = pSel->FindFirst(); while (pNode) { // create a new NodeLiveEffect, which we will shortly insert into the tree; // note that ALLOC_WITH_FAIL automatically calls FailAndExecute() if things go wrong. NodeBitmapEffect* pBmpFXNode = NULL; pBmpFXNode = DoApplyLiveEffect(this, pNode, strEffectID, strDisplayName, dResolution, pEditsList, bMakeLocked); if (pBmpFXNode) { // If the node we're applying to can supply DirectBitmaps and we can accept them // Then change res to be "automatic" if (bDetectDirectBitmaps && pNode->IsAnObject() && ((NodeRenderableInk*)pNode)->CanSupplyDirectBitmap() && dResolution != 0 ) { // Child node can supply a DirectBitmap so it would be better if we were in // "Automatic" mode. pBmpFXNode->SetPixelsPerInch(0); // Set "Automatic" // We can only test EnableDirectCapture after we have set the res to automatic // Otherwise it may return FALSE because the stored res (dResolution) may not match that // of the DirectBitmap child. // If it fails, then reset resolution back to what was specified. if (!pBmpFXNode->EnableDirectCapture()) pBmpFXNode->SetPixelsPerInch(dResolution); } // Deselect the node and select the live effect instead // TODO: Really? ((NodeRenderable*)pNode)->DeSelect(FALSE); pBmpFXNode->Select(FALSE); pLERange->AddNode(pBmpFXNode); // Make sure the attributes are optimised correctly BOOL ok = DoFactorOutCommonChildAttributes(pBmpFXNode); if (!ok) pBmpFXNode = NULL; } if (!pBmpFXNode) { if (pLERange->FindFirst()==NULL) { // Don't let an empty list of LiveEffect nodes hang around delete pLERange; pLERange = NULL; } return pLERange; } pNode = pSel->FindNext(pNode); } if (pLERange->FindFirst()==NULL) { // Don't let an empty list of LiveEffect nodes hang around delete pLERange; pLERange = NULL; } return pLERange; }

NodeBitmapEffect * OpLiveEffect::DoApplyLiveEffect (  UndoableOperation *  pOp, Node *  pNode, String_256  strEffectID, String_64  strDisplayName, double  dResolution, IXMLDOMDocumentPtr  pEditsList = NULL, BOOL  bMakeLocked = FALSE )  [static, private]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/02/2005 Parameters: pOp  - Op to add undo info to [INPUTS] pNode - pointer to node to insert LiveEffects above strEffectID - Unique identifier for Op strDispayName - The display name of the effect we're going to apply pEditsList - pointer to optional list of edit params for this effect -  [OUTPUTS] Returns: TRUE if worked OK Errors: See also: Definition at line 469 of file opliveeffects.cpp. { ERROR2IF(pOp==NULL, NULL, "Missing Op pointer"); ERROR2IF(pNode==NULL, NULL, "Missing Node pointer"); ERROR2IF(strEffectID==String(""), NULL, "DoApplyLiveEffect given blank effect name string"); ERROR2IF(strDisplayName==String(""), NULL, "DoApplyLiveEffect given blank display name string"); BOOL bSelectInside = pNode->IsSelected() || pNode->IsParentOfSelected(); // Possible solution to issue of Bitmap with Feather attr under DirectBitmap effects // Detect that state, delete the feather attr, apply a feather effect with the same values //pNode = ApplyDirectFeatherBodge(pNode); // create a new NodeLiveEffect, which we will shortly insert into the tree; // note that ALLOC_WITH_FAIL automatically calls FailAndExecute() if things go wrong. NodeBitmapEffect* pBmpFXNode = NULL; if (bMakeLocked) { ALLOC_WITH_FAIL(pBmpFXNode, new NodeLockedEffect, pOp); } else { ALLOC_WITH_FAIL(pBmpFXNode, new NodeLiveEffect, pOp); } if (pBmpFXNode==NULL) return NULL; // Get details from XPE so that displayname gets translated into // locale language if not already BOOL bDestructive = FALSE; XPEHost::GetEffectDetails(strEffectID, &strDisplayName, &bDestructive); ERROR3IF(bDestructive, "DoApplyLiveEffect asked to apply destructive effect!!!"); if (bDestructive) return NULL; // Set effect params pBmpFXNode->SetPostProcessorID(strEffectID); pBmpFXNode->SetDisplayName(strDisplayName); pBmpFXNode->SetPixelsPerInch(dResolution); if (pEditsList) { pBmpFXNode->SetEditList(pEditsList); } else if (!pBmpFXNode->SetDefaultEditList()) { return NULL; } if (pBmpFXNode->IsLockedEffect()) ((NodeLockedEffect*)pBmpFXNode)->SetLockPermanence(bDestructive); // put an action to hide the NodeLiveEffect onto the undo action-list, // so that if the user presses undo then it will be hidden. HideNodeAction* pUndoHideNodeAction = NULL; ActionCode ac = HideNodeAction::Init(pOp, pOp->GetUndoActionList(), pBmpFXNode, FALSE, // don't include subtree size (Action**)&pUndoHideNodeAction, FALSE); // don't tell subtree when undone if (ac == AC_FAIL) return NULL; // right! we've got our node, we've got our action - lets stick it in the tree // (at a position just next to the last node which will go in the group). pBmpFXNode->AttachNode(pNode, NEXT); // Move the node below the newly inserted LiveEffect BOOL ok = pOp->DoMoveNode(pNode, pBmpFXNode, FIRSTCHILD); if (!ok) return NULL; // Set the OpPersmission flags in the newly inserted node // Otherwise the tree scanner in UpdateChangedNodes won't go below this node ObjChangeFlags cFlags(NULL, TRUE, NULL, NULL, NULL, NULL, NULL, TRUE); // ReplaceNode & RegenerateNode ObjChangeParam ObjChange(OBJCHANGE_STARTING, cFlags, NULL, pOp); pBmpFXNode->AllowOp(&ObjChange); // Deselect the node and select the live effect instead // TODO: Really? // ((NodeRenderable*)pNode)->DeSelect(FALSE); // pBmpFXNode->Select(FALSE); return pBmpFXNode; }

ListRange * OpLiveEffect::DoApplyLockedEffect (  Range *  pSel, String_256  strEffectID, String_64  strDisplayName, double  dResolution, IXMLDOMDocumentPtr  pEditsList = NULL, BOOL  bDetectDirectBitmaps = FALSE )  [protected, virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 29/09/2004 Parameters: pSel  - pointer to range of nodes to insert LiveEffects above [INPUTS] strDispayName - The display name of the effect we're going to apply pNewSel  - pointer to new range of LiveEffect nodes [OUTPUTS] NULL if no new live effects added Returns: Errors: See also: Definition at line 737 of file opliveeffects.cpp. { ENSURE(pSel, "DoApplyLockedEffect not given a useful range"); ENSURE(strEffectID!=String(""), "DoApplyLockedEffect given blank effect name string"); ListRange* pLERange = new ListRange(); ENSURE(pLERange, "DoApplyEffect can't create a ListRange"); if (pLERange==NULL) return NULL; // we need to insert the controller node at the position of the highest // selected node in the z-order, ie last in the selection, so find it. Node* pFirstNode = pSel->FindFirst(); Node* pNode = pFirstNode; Node* pLastNode = NULL; while (pNode != NULL) { pLastNode = pNode; pNode = pSel->FindNext(pLastNode); } // loop terminates with pNode == NULL, pLastNode == last-node-in-sel. // create a new NodeClipViewController, which we will shortly insert into the tree; // note that ALLOC_WITH_FAIL automatically calls FailAndExecute() if things go wrong. NodeLockedEffect* pBmpFXNode = NULL; ALLOC_WITH_FAIL(pBmpFXNode, new NodeLockedEffect, this); BOOL ok = (pBmpFXNode != NULL); if (ok) { // Get details from XPE so that displayname gets translated into // locale language if not already and destructive state is updated // for the current machine (shouldn't really change, though) BOOL bDestructive = TRUE; XPEHost::GetEffectDetails(strEffectID, &strDisplayName, &bDestructive); pBmpFXNode->SetPostProcessorID(strEffectID); pBmpFXNode->SetDisplayName(strDisplayName); pBmpFXNode->SetPixelsPerInch(dResolution); if (pEditsList) { pBmpFXNode->SetEditList(pEditsList); } else if (!pBmpFXNode->SetDefaultEditList()) { delete pBmpFXNode; // Don't let an empty list of LiveEffect nodes hang around delete pLERange; pLERange = NULL; return pLERange; } pBmpFXNode->SetLockPermanence(bDestructive); // put an action to hide the NodeClipViewController onto the undo action-list, // so that if the user presses undo then it will be hidden. HideNodeAction* pUndoHideNodeAction = NULL; ActionCode ac = HideNodeAction::Init(this, &UndoActions, pBmpFXNode, FALSE, // don't include subtree size (Action**)&pUndoHideNodeAction, FALSE); // don't tell subtree when undone if (ac == AC_FAIL) { delete pBmpFXNode; // Don't let an empty list of LiveEffect nodes hang around delete pLERange; pLERange = NULL; return pLERange; } else { // right! we've got our node, we've got our action - lets stick it in the tree // (at a position just next to the last node which will go in the group). pBmpFXNode->AttachNode(pLastNode, NEXT); pLERange->AddNode(pBmpFXNode); } } // move each item from the selection into our ClipView group, // remembering to deselect them as we go. // TODO: // sneaky suspicion I should be putting this in a Do fn in UndoableOperation... if (ok) { pNode = pSel->FindNext(pFirstNode); // the node we're moving now. // if (pFirstNode->IsAnObject()) // ok = DoLocaliseCommonAttributes((NodeRenderableInk*)pFirstNode); ok = DoMoveNode(pFirstNode, pBmpFXNode, FIRSTCHILD); if (ok) ((NodeRenderable*)pFirstNode)->DeSelect(FALSE, TRUE); } Node* pNextNode = NULL; // the next node to move. Node* pAnchorNode = pFirstNode; // the node we've just moved. while (ok && pNode != NULL) { // get the next node to move. pNextNode = pSel->FindNext(pNode); // now move the current node next to the anchor and deselect it. // if (pNode->IsAnObject()) // ok = DoLocaliseCommonAttributes((NodeRenderableInk*)pNode); ok = DoMoveNode(pNode, pAnchorNode, NEXT); if (ok) ((NodeRenderable*)pNode)->DeSelect(FALSE, TRUE); // get the new anchor node and the next node to move. pAnchorNode = pNode; pNode = pNextNode; } // If we're applied to a single node and that node can supply DirectBitmaps and we can accept them // Then change res to be same as child node NodeRenderableInk* pInkNode = pBmpFXNode->GetInkNodeFromController(); if (bDetectDirectBitmaps && pInkNode && pInkNode->CanSupplyDirectBitmap() ) { // Child node can supply a DirectBitmap so it would be better if we had same resolution // as the child node... double dDirectRes = 0; pInkNode->GetDirectBitmap(NULL, NULL, NULL, NULL, NULL, &dDirectRes); if (dDirectRes!=0) { pBmpFXNode->SetPixelsPerInch(dDirectRes); // Set res // We can only test EnableDirectCapture after we have set the res correctly // Otherwise it may return FALSE because the stored res (dResolution) may not match that // of the DirectBitmap child. // If it fails, then reset resolution back to what was specified. if (!pBmpFXNode->EnableDirectCapture()) pBmpFXNode->SetPixelsPerInch(dResolution); } } if (ok) { // select the new destructive effect, but don't draw any blobs yet. pBmpFXNode->Select(FALSE); // factor out any common attributes. DoFactorOutCommonChildAttributes(pBmpFXNode); // Set the OpPersmission flags in the newly inserted node // Otherwise the tree scanner in UpdateChangedNodes won't go below this node ObjChangeFlags cFlags(NULL, TRUE, NULL, NULL, NULL, NULL, NULL, TRUE); // ReplaceNode & RegenerateNode ObjChangeParam ObjChange(OBJCHANGE_STARTING, cFlags, NULL, this); pBmpFXNode->AllowOp(&ObjChange); } if (pLERange->FindFirst()==NULL) { // Don't let an empty list of LiveEffect nodes hang around delete pLERange; pLERange = NULL; } return pLERange; }

BOOL OpLiveEffect::DoCopyAttributes (  UndoableOperation *  pOp, Node *  pSrcNode, Node *  pDestNode, BOOL  bEffectsOnly, Document *  pSrcDoc, Document *  pDestDoc )  [static, private]

Copy the specified LiveEffect stack onto the selection Used by Paste Attributes Assumes that only simple attributes will be copied in simple situations I.e. attrs that aren't optimsed so much. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 21/03/2005 Parameters: pOp  - POinter to Op to add undo records to [INPUTS] pSrcNode - Node containing attrs to copy pDestNode - Node to copy attrs into bEffectsOnly - TRUE if should only copy Effect Attrs Doc ptrs to allow component data to be copied [OUTPUTS]  Returns: Errors: See also: Definition at line 1692 of file opliveeffects.cpp. { if (!pDestNode->IsBounded() || !pSrcNode->IsBounded()) return TRUE; ((NodeRenderableBounded*)pDestNode)->InvalidateBoundingRect(); DocRect NodeBounds = ((NodeRenderableBounded*)pDestNode)->GetBoundingRect(TRUE); Node* pNode = pSrcNode->FindFirstChild(); while (pNode) { if (pNode->IsAnAttribute()) { NodeAttribute* pAttr = (NodeAttribute*)pNode; if (!bEffectsOnly || pAttr->IsEffectAttribute()) { if (pAttr->CanBeAppliedToObject()) { NodeAttribute* pAttrCopy = NULL; pAttr->NodeCopy((Node **)(&pAttrCopy)); if (pAttrCopy->IsAFillAttr()) { // Set the bounds of the attribute. (Why is this wrong here?) ((AttrFillGeometry*)pAttrCopy)->SetBoundingRect(((NodeRenderableBounded*)pSrcNode)->GetBoundingRect()); // I'm not sure if this is neccessary but Will does it when making an attribute // current. if (pAttrCopy->IsAFractalFill()) { // The attr, should always use the default DPI for fractals. ((AttrFillGeometry*)pAttrCopy)->SetFractalDPI(AttrFillGeometry::FractalDPI); } } pAttrCopy->TransformToNewBounds(NodeBounds); pAttrCopy->AttachNode(pDestNode, LASTCHILD); pAttrCopy->LinkToGeometry(pDestNode); if (pAttrCopy->IsAFillAttr()) { // Now the Attribute is in the tree, we need to tell the fill // attribute to check that it's control points are valid. // Unless the fill we transformed above, this will usually // involve the fill 'centring' itself within the bounds of its // parent. ((AttrFillGeometry*)pAttrCopy)->AttributeChanged(); } // Inform all DocComponents in the destination doc that a copy is about to take place BOOL ok; CALL_WITH_FAIL((pDestDoc->StartComponentCopy()), pOp, ok) if (ok) { if (!pAttrCopy->CopyComponentData(pSrcDoc, pDestDoc)) { pDestDoc->AbortComponentCopy(); // Cancel all data which has been copied ok = FALSE; // stop what were doing } if (ok) ok = pDestDoc->EndComponentCopy(); } // Remove similar nodes in this level Node* pCurrent = pDestNode->FindFirstChild(); Node* pNext; CCRuntimeClass* pAttrType = pAttrCopy->GetAttributeType(); while (pCurrent) { pNext = pCurrent->FindNext(); // Determine if the Current node is to be hidden if (pCurrent!=pAttrCopy && pCurrent->IsKindOf(CC_RUNTIME_CLASS(NodeAttribute))) { { if (((NodeAttribute*)pCurrent)->GetAttributeType() == pAttrType) { pCurrent->CascadeDelete(); delete pCurrent; } } } pCurrent = pNext; } } } } pNode = pNode->FindNext(); } return TRUE; }

BOOL OpLiveEffect::DoCopyEffectAttr (  UndoableOperation *  pOp, NodeAttribute *  pAttr, Node *  pNode )  [static, private]

Copy the Effect attributes from the specified node down to lower nodes, remaining effect attrs where possible but becoming normal attrs if that's not possible Used by ungroup. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/03/2005 Parameters: pOp  - pointer to op [INPUTS] pAttr - pointer to effect attribute to copy pNode - pointer to node whose children should get copies of the attribute [OUTPUTS]  Returns: TRUE if it worked Errors: See also: Definition at line 1969 of file opliveeffects.cpp. { Node* pChildNode = pNode->FindFirstChild(); while (pChildNode) { if (pChildNode->IsAnObject()) { NodeRenderableInk* pInkNode = (NodeRenderableInk*)pChildNode; if (pInkNode->IsValidEffectAttr(pAttr)) { NodeAttribute* pExistingAttr = pInkNode->FindAppliedAttribute(pAttr->GetRuntimeClass()); if (pExistingAttr==NULL || pExistingAttr->FindParent()!=pInkNode) { // We can copy our effect attr to pInkNode as an effect attr // Make a copy of this LiveEffect NodeAttribute* pCopyAttr = NULL; BOOL bOK = FALSE; CALL_WITH_FAIL(pCopyAttr = (NodeAttribute*)pAttr->SimpleCopy(), pOp, bOK); if (!bOK) return FALSE; // No room to take a copy of the node // pOp->DoInsertNewNode(pCopyAttr, pInkNode, LASTCHILD, FALSE, FALSE, FALSE, FALSE); // Create a hide node action to hide the node when we undo pCopyAttr->AttachNode(pInkNode, LASTCHILD); HideNodeAction* UndoHideNodeAction; if (HideNodeAction::Init(pOp, pOp->GetUndoActions(), pCopyAttr, TRUE, (Action**)(&UndoHideNodeAction)) == AC_FAIL) { pCopyAttr->CascadeDelete(); delete pCopyAttr; return FALSE; } } } else { NodeAttribute* pExistingAttr = pInkNode->FindAppliedAttribute(pAttr->GetRuntimeClass()); if (pExistingAttr==NULL || pExistingAttr->FindParent()!=pInkNode) { // We can copy our effect attrs to pInkNode as a normal attr NodeAttribute* pCopyAttr = NULL; BOOL bOK = FALSE; CALL_WITH_FAIL(pCopyAttr = (NodeAttribute*)pAttr->SimpleCopy(), pOp, bOK); if (!bOK) return FALSE; // No room to take a copy of the node // pOp->DoInsertNewNode(pCopyAttr, pInkNode, FIRSTCHILD, FALSE, FALSE, FALSE, FALSE); // Create a hide node action to hide the node when we undo pCopyAttr->AttachNode(pInkNode, FIRSTCHILD); HideNodeAction* UndoHideNodeAction; if (HideNodeAction::Init(pOp, pOp->GetUndoActions(), pCopyAttr, TRUE, (Action**)(&UndoHideNodeAction)) == AC_FAIL) { pCopyAttr->CascadeDelete(); delete pCopyAttr; return FALSE; } // if (UndoHideNodeAction) // UndoHideNodeAction->DontPanic(); // Remove any deeper attributes of the same type to make a consistent structure pOp->DoRemoveAttrTypeFromSubtree(pInkNode, pAttr->GetRuntimeClass(), pCopyAttr); } } } pChildNode = pChildNode->FindNext(); } return TRUE; }

BOOL OpLiveEffect::DoCopyEffectsStack (  UndoableOperation *  pOp, Node *  pDestNode, ListRange *  pEffectsStack, Document *  pSrcDoc, Document *  pDestDoc )  [static, private]

Copy the specified LiveEffect stack onto the selection Used by Paste Attributes and OpCombineShapes. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/02/2005 Parameters: pOp  - pointer to Op [INPUTS] pPPStack - pointer to EffectsStack to copy [OUTPUTS]  Returns: Errors: See also: Definition at line 1530 of file opliveeffects.cpp. { ERROR2IF(pOp==NULL, FALSE, "No Op given to DoCopyEffectsStack\n"); ERROR2IF(pEffectsStack==NULL || pEffectsStack->IsEmpty(), FALSE, "No stack/empty stack given to DoCopyEffectsStack\n"); ERROR2IF(pDestNode==NULL, FALSE, "No destination node given to DoCopyEffectsStack\n"); //----------------------------------------------------------------------------- // Remove all current LiveEffects on the selection // if (pDestNode->IsAnObject() && !pDestNode->NeedsParent(pDestNode->FindParent())) pDestNode = DoDeleteAllPostProcessors(pOp, (NodeRenderableInk*)pDestNode, FALSE, TRUE); // TRUE means delete all effects in stack, even those below pDestNode //----------------------------------------------------------------------------- // Apply new LiveEffects from the specified stack // BOOL bWasSelected = pDestNode->IsSelected() || pDestNode->IsParentOfSelected(); Node* pSelectNode = pDestNode; if (pDestNode->IsNodeRenderableClass()) ((NodeRenderable*)pDestNode)->DeSelect(FALSE, TRUE); Node* pTopNode = pDestNode; NodeEffect* pEffect = (NodeEffect*)pEffectsStack->FindFirst(); while (pEffect) { // Test for legacy effect special cases first // Shadow ------------------------------------------------------------- if (pEffect->IsAShadowController()) { if (pTopNode->NeedsParent(pTopNode->FindParent())) { if (pTopNode->IsAShadow()) { // TODO: Copy shadow properties here? } } else { NodeShadowController* pController = (NodeShadowController*)pEffect; NodeShadowParam param(pController->GetShadowType(), pController->GetFloorShadowAngle(), pController->GetFloorShadowHeight(), pController->GetOffsetX(), pController->GetOffsetY(), pController->GetPenumbraWidth(), pController->GetShadow()->GetDarkness(), pController->GetWallShadowScale(), pController->GetGlowWidth(), pController->GetShadow()->GetBiasGain(), TRUE); param.strOpUnique = pEffect->GetPostProcessorID(); param.StackPosition = STACKPOS_INSERT_TOP; pTopNode = OpApplyShadow::DoApplyShadow(pOp, pTopNode, &param, FALSE); // BOOL ok = pOp->DoFactorOutCommonChildAttributes(pShadControl); if (pTopNode == NULL) { pOp->FailAndExecute(); return FALSE; } // Copy attributes applied to Shadow node NodeShadow* pShadow = pController->GetShadow(); NodeShadow* pNewShadow = NULL; if (pTopNode->IsAShadowController()) pNewShadow = ((NodeShadowController*)pTopNode)->GetShadow(); ERROR3IF(pShadow==NULL || pNewShadow==NULL, "ShadowController doesn't seem to have a shadow"); if (pShadow && pNewShadow) { DoCopyAttributes(pOp, pShadow, pNewShadow, FALSE, pSrcDoc, pDestDoc); } delete param.pPPStack; } } // Feather ----------------------------------------------------------------- else if (pEffect->IsFeatherEffect()) { NodeFeatherEffect* pFeather = (NodeFeatherEffect*)pEffect; String_64 strDisplayName; XPEHost::GetEffectDetails(pEffect->GetPostProcessorID(), &strDisplayName); pTopNode = DoApplyFeatherEffectNode(pOp, pTopNode, pEffect->GetPostProcessorID(), strDisplayName, pFeather->GetFeatherSize(), pFeather->GetProfile()); if (pTopNode == NULL) { pOp->FailAndExecute(); return FALSE; } } // LiveEffects ------------------------------------------------------------- else if (pEffect->IsBitmapEffect()) { if (pEffect->IsLockedEffect() && ((NodeLockedEffect*)pEffect)->CanBeUnlocked()) { String_64 strDisplayName; XPEHost::GetEffectDetails(pEffect->GetPostProcessorID(), &strDisplayName); pTopNode = DoApplyLiveEffect(pOp, pTopNode, pEffect->GetPostProcessorID(), strDisplayName, ((NodeBitmapEffect*)pEffect)->GetPixelsPerInchValue(), ((NodeBitmapEffect*)pEffect)->GetEditList(), TRUE); // MakeLocked if (pTopNode == NULL) { pOp->FailAndExecute(); return FALSE; } } else if (!pEffect->IsLockedEffect()) { String_64 strDisplayName; XPEHost::GetEffectDetails(pEffect->GetPostProcessorID(), &strDisplayName); pTopNode = DoApplyLiveEffect(pOp, pTopNode, pEffect->GetPostProcessorID(), strDisplayName, ((NodeBitmapEffect*)pEffect)->GetPixelsPerInchValue(), ((NodeBitmapEffect*)pEffect)->GetEditList(), FALSE); if (pTopNode == NULL) { pOp->FailAndExecute(); return FALSE; } } if (pTopNode->IsEffect() && ((NodeEffect*)pTopNode)->IsLockedEffect()) { // Don't allow anything to be selected inside a Locked effect! pSelectNode = pTopNode; } } // Copy effect attributes that might be applied to this level if (pTopNode) { DoCopyAttributes(pOp, pEffect, pTopNode, TRUE, pSrcDoc, pDestDoc); } // ---------------------------------------------------------------------- pEffect = (NodeEffect*)pEffectsStack->FindNext(pEffect); } if (pSelectNode && bWasSelected && pSelectNode->IsNodeRenderableClass()) { ((NodeRenderable*)pSelectNode)->Select(FALSE); } return TRUE; }

BOOL OpLiveEffect::DoCopyPPStackToSelection (  UndoableOperation *  pOp, EffectsStack *  pPPStack, Document *  pSrcDoc, Document *  pDestDoc )  [static, private]

Copy the specified LiveEffect stack onto the selection Used by Paste Attributes. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/2004 Parameters: pPPStack  - pointer to EffectsStack to copy [INPUTS] [OUTPUTS]  Returns: Errors: See also: Definition at line 1464 of file opliveeffects.cpp. { ERROR2IF(pPPStack==NULL || pPPStack->IsEmpty(), FALSE, "No stack/empty stack given to DoCopyPPStackToSelection\n"); SelRange* pRange = GetApplication()->FindSelection(); ERROR2IF(pRange==NULL, FALSE, "Can't find SelRange\n"); if (pPPStack==NULL) return TRUE; // That was easy! // Convert the pPPStack into a simple ListRange for DoCopyEffectsStack ListRange EffectsStack; INT32 l = 0; PPStackLevel* pLevel = pPPStack->GetLevel(l); while (pLevel) { ERROR3IF(pLevel->pPPNode==NULL, "PPStack has a badly formed level in it"); if (pLevel->pPPNode->CanBeUnlocked()) EffectsStack.AddNode(pLevel->pPPNode); pLevel = pPPStack->GetLevel(++l); } pOp->DoInvalidateNodesRegions(*pRange, TRUE, FALSE); // Now loop through the selection if (!EffectsStack.IsEmpty()) { Node* pNode = pRange->FindFirst(); Node* pNextNode = NULL; while (pNode) { pNextNode = pRange->FindNext(pNode); DoCopyEffectsStack(pOp, pNode, &EffectsStack, pSrcDoc, pDestDoc); pNode = pNextNode; } } pOp->DoInvalidateNodesRegions(*pRange, TRUE, FALSE); return TRUE; }

Node * OpLiveEffect::DoDeleteAllPostProcessors (  UndoableOperation *  pOp, NodeRenderableInk *  pNode, BOOL  bDeleteOldControllers = FALSE, BOOL  bDeleteBelowLocked = FALSE )  [static, private]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/11/2004 Parameters: pOp  - Operation to add undo actions to [INPUTS] pNode - Selected node (note, not parent of selected) [OUTPUTS]  Returns: Errors: See also: Definition at line 2060 of file opliveeffects.cpp. { BOOL bOK = TRUE; // First, find pointer to child node to be moved into place as the LiveEffects stack is deleted Node* pNewBaseNode = pNode; if (pNode->IsEffect()) { ENSURE(((NodeEffect*)pNode)->IsLockedEffect(), "Only destructive LiveEffects should be selectable"); // Find the first ink node that's a child of this LiveEffect if (bDeleteBelowLocked) { // Locked effects can have several children - GetInkNodeFC only returns non-NULL // when there is a single node below the locked effect if (((NodeEffect*)pNewBaseNode)->GetInkNodeFromController()==NULL) pNewBaseNode = pNewBaseNode->FindFirstChild(); else { Node* pChild = pNewBaseNode; while (pChild && pChild->IsEffect()) { pChild = ((NodeEffect*)pChild)->GetInkNodeFromController(); if (pChild) pNewBaseNode = pChild; } } } } Node* pHighestLE = NULL; Node* pEffectScanBase = NULL; /* // [Phil, 22/08/2005] There must be a better way to arrange the following logic! // // Push common attributes down into the nodes we're going to retain Node* pAncestor = pChild->FindParent(); if (pAncestor && !pAncestor->IsAnObject()) pAncestor = NULL; if (pAncestor) { bOK = pOp->DoLocaliseCommonAttributes((NodeRenderableInk*)pAncestor, FALSE, TRUE); if (!bOK) return FALSE; } // If there are old style controller nodes applied to the object before any effects // Then get rid of them... if (bDeleteOldControllers) { while (pAncestor && pAncestor->IsController() && !pAncestor->IsEffect()) { pHighestLE = pAncestor; pAncestor = pAncestor->FindParent(); } } else { // Move the BaseNode pointer above the old controllers that we are not deleting while (pAncestor && pAncestor->IsController() && !pAncestor->IsEffect()) { pNewBaseNode = pAncestor; pAncestor = pAncestor->FindParent(); } } // Delete all LiveEffects from pChild upwards while (pAncestor && pAncestor->IsEffect()) { pHighestLE = pAncestor; pAncestor = pAncestor->FindParent(); } */ // ------------------------------------------------------------------ // Deal with old style controllers { Node* pAncestor = pNewBaseNode->FindParent(); Node* pHighestOldController = NULL; pEffectScanBase = pNewBaseNode; while (pAncestor && pAncestor->IsController() && !pAncestor->IsEffect()) { pHighestOldController = pAncestor; pAncestor = pAncestor->FindParent(); } if (pHighestOldController) { if (bDeleteOldControllers) pEffectScanBase = pHighestOldController; // Leave base node pointer alone and tell scanner to start above the old controllers else { pEffectScanBase = pHighestOldController; // Tell scanner to start above the old controllers pNewBaseNode = pHighestOldController; // but Reset base node pointer to refer to it so we leave it in the tree } } } // ------------------------------------------------------------------ // Find highest Effect above the base node { Node* pAncestor = pEffectScanBase->FindParent(); while (pAncestor && pAncestor->IsEffect()) { pHighestLE = pAncestor; pAncestor = pAncestor->FindParent(); } } // ------------------------------------------------------------------ // Push common attributes down into the nodes we're going to retain (the base node) { Node* pAncestor = pNewBaseNode->FindParent(); if (pAncestor && pAncestor->IsAnObject()) { bOK = pOp->DoLocaliseCommonAttributes((NodeRenderableInk*)pAncestor, FALSE, TRUE); if (!bOK) return NULL; } } // ------------------------------------------------------------------ // If we have found Effects above the selected node (then we can // get rid of them) if (pHighestLE) { // Loop around all the children of the LiveEffect moving them up // (but note that only Destructive effects can have multiple children...) // (Er, but note again that effect attributes can be left in the tree...) Node* pInsertNode = pHighestLE; Node* pNextChild = NULL; Node* pChild = pNewBaseNode; while (pChild) { pNextChild = pChild->FindNext(); // Find next child before we move it! if (pChild->IsAnObject()) { // Only move pChild if it's not linked to the PostProcessor above it! // (Otherwise leave it in place so it gets hidden along with the PostPros) if (!((NodeRenderableInk*)pChild)->NeedsParent(pChild->FindParent())) // Controlled? { bOK = pOp->DoMoveNode(pChild, pInsertNode, NEXT); if (!bOK) return NULL; ((NodeRenderableInk*)pChild)->Select(FALSE); if (pChild->IsAnObject()) pOp->DoFactorOutCommonAttributes((NodeRenderableInk*)pChild); pInsertNode = pChild; } } pChild = (NodeRenderableInk*)pNextChild; } // Now that all the children are moved outside all the LE nodes // we can delete all the LE nodes (by hiding the root node and thus // hiding the entire stack at one go!) if (pHighestLE->IsRenderable()) ((NodeRenderable*)pHighestLE)->DeSelect(FALSE); bOK = pOp->DoHideNode(pHighestLE, FALSE, NULL, FALSE); } return pNewBaseNode; }

BOOL OpLiveEffect::DoDeletePostProcessor (  UndoableOperation *  pOp, NodeEffect *  pLE, BOOL  bMoveEffectAttrs = FALSE )  [static, private]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 26/04/2005 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 2284 of file opliveeffects.cpp. { BOOL ok = FALSE; // We should have a decent list of LiveEffect nodes... ERROR2IF(pLE==NULL, FALSE, "DoDeletePostProcessor given NULL node"); // Go through all the LiveEffects, move their children up to be siblings and then // "delete" the LiveEffect nodes by hiding them. // BOOL bSelected = pLE->IsSelected(); pOp->DoLocaliseCommonAttributes(pLE); // Loop around all the children of the LiveEffect moving them up // (but note that only Destructive effects can have multiple children...) // (Er, but note again that effect attributes can be left in the tree...) Node* pInsertNode = pLE; Node* pNextChild = NULL; Node* pParent = pLE->FindParent(); NodeEffect* pParentEffect = NULL; if (pParent && pParent->IsEffect()) pParentEffect = (NodeEffect*)pLE->FindParent(); NodeRenderableInk* pChild = (NodeRenderableInk*)pLE->FindFirstChild(CC_RUNTIME_CLASS(NodeRenderableInk)); while (pChild) { pNextChild = pChild->FindNext(); // Find next child before we move it! if (pChild->IsAnObject()) { // Only move pChild if it's not linked to the PostProcessor above it! // (Otherwise leave it in place so it gets hidden along with the PostPros) if (!((NodeRenderableInk*)pChild)->NeedsParent(pChild->FindParent())) // Controlled? { pOp->DoMoveNode(pChild, pInsertNode, NEXT); if (bSelected) pChild->Select(FALSE); if (pChild->IsAnObject()) pOp->DoFactorOutCommonAttributes((NodeRenderableInk*)pChild); pInsertNode = pChild; } } if (bMoveEffectAttrs && pParentEffect && pChild->IsAnAttribute() && ((NodeAttribute*)pChild)->IsEffectAttribute()) { if (pParentEffect->IsValidEffectAttr((NodeAttribute*)pChild)) { pOp->DoMoveNode(pChild, pInsertNode, NEXT); pInsertNode = pChild; } } pChild = (NodeRenderableInk*)pNextChild; } pLE->ReleaseCached(TRUE, FALSE, FALSE, FALSE); if (bSelected) pLE->DeSelect(FALSE); pOp->DoHideNode(pLE, FALSE, NULL, FALSE); return TRUE; }

BOOL OpLiveEffect::DoDeletePostProcessor (  UndoableOperation *  pOp, Range *  pRange )  [static, private]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/11/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 2242 of file opliveeffects.cpp. { BOOL ok = FALSE; // We should have a decent list of LiveEffect nodes... ERROR2IF(pRange==NULL, FALSE, "DoDeletePostProcessor given an empty range"); // Go through all the LiveEffects, move their children up to be siblings and then // "delete" the LiveEffect nodes by hiding them. // Node* pNode = pRange->FindFirst(); while (pNode) { if (pNode->IsEffect()) { NodeEffect* pLE = (NodeEffect*)pNode; DoDeletePostProcessor(pOp, pLE); } pNode = pRange->FindNext(pNode); } return TRUE; }

virtual BOOL OpLiveEffect::DoEffectNodeOp (  NodeEffect *  pEffect, OpLiveEffectParam *  pParam, NodeBitmapEffect **  ppNewEffect )  [inline, protected, virtual]

Reimplemented in OpEffectRes, and OpEffectLock. Definition at line 310 of file opliveeffects.h. {*ppNewEffect = NULL; return FALSE;}

virtual BOOL OpLiveEffect::DoEffectOp (  ListRange *  pLevelRange, OpLiveEffectParam *  pLEOpParam )  [inline, protected, virtual]

Reimplemented in OpEditLiveEffect, OpDeleteLiveEffect, OpDeleteAllLiveEffect, OpEffectRes, OpEffectLock, and OpEffectLockAll. Definition at line 306 of file opliveeffects.h. { return TRUE; }

BOOL OpLiveEffect::DoEffectRangeOp (  UINT32  idsProgress, Range *  pRange, OpLiveEffectParam *  pParam )  [protected, virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/06/2005 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 2366 of file opliveeffects.cpp. { BOOL ok = FALSE; Progress progress(idsProgress, pRange->Count(), FALSE); // We should have a decent list of LiveEffect nodes... ERROR2IF(pRange==NULL, FALSE, "DoEffectRangeOp given an empty range"); // Go through all the LiveEffects, move their children up to be siblings and then // "delete" the LiveEffect nodes by hiding them. // INT32 iCount = 0; INT32 iChanges = 0; Node* pNode = pRange->FindFirst(); while (pNode && progress.Update(iCount, TRUE) && !OpHasFailed()) { if (pNode->IsEffect()) { // -------------------------------------------- // This is the core of this function, // Call overridden specialist function to perform // the Op on this node alone NodeEffect* pLE = (NodeEffect*)pNode; NodeBitmapEffect* pNewEffect = NULL; BOOL bChanged = DoEffectNodeOp(pLE, pParam, &pNewEffect); // -------------------------------------------- if (bChanged) { iChanges++; // Invalidate the region we just changed // (Rely on DoEffectNodeop to have released the cache if it thinks it needs to if (!DoInvalidateNodeRegion(pNewEffect, TRUE, FALSE, FALSE, FALSE)) { FailAndExecute(); End(); return FALSE; } // Update the view inside our progress indication so the user gets // better idea of where we are... DocView* pDocView = GetWorkingDocView(); if (pDocView) { // Update just the working view immediately pDocView->FlushRedraw(); GetApplication()->ServiceRendering(); } } } iCount++; pNode = pRange->FindNext(pNode); } // If we aborted with nodes remaining to be done // Then abort the whole Operation! if (pNode) { FailAndExecute(); End(); return FALSE; } ObjChangeFlags cFlags(NULL, TRUE, NULL, NULL, NULL, NULL, NULL, TRUE); ObjChangeParam ObjChange(OBJCHANGE_FINISHED, cFlags, NULL, this); ok = UpdateChangedNodes(&ObjChange); // If we didn't change anything then don't add this op to the undo history if (iChanges==0) { SucceedAndDiscard(); End(); return FALSE; } End(); return FALSE; // We don't need any of the normal tidy up to occur }

void OpLiveEffect::DoEndEdit (  BOOL  bChangingSelection = FALSE, BOOL  bBroadcast = TRUE, BOOL  bCancelled = FALSE, BOOL  bEmpty = FALSE )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 16/09/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 1356 of file opliveeffects.cpp. { BOOL ok = FALSE; BOOL bRecache = FALSE; // If the are no changes in any of the LiveEffect nodes as a result of this edit // And we only just created new LiveEffects in this Op // Then remove them from the tree because they are redundant if (bCancelled || (m_bAppliedNewEffects && (!HasChanged() || bEmpty))) { if (bChangingSelection) FailAndExecuteIgnoreSelActions(); else FailAndExecute(); // Tell the selrange that things have changed! GetApplication()->FindSelection()->Update(); End(); return; } // If we were editing but we are told that the edit has resulted in a NULL effect // Then we can remove the effect to keep things neat and tidy if (bEmpty && !m_bAppliedNewEffects && m_pLERange!=NULL) { BOOL bOK = DoDeletePostProcessor(this, m_pLERange); if (!bOK) { FailAndExecute(); // Tell the selrange that things have changed! GetApplication()->FindSelection()->Update(); End(); return; } } // We have finished with the range of edited nodes now so we should delete it // to reduce memory usage while this object sits on the undo/redo lists if (m_pLERange) { delete m_pLERange; m_pLERange = NULL; } // Check whether XPE's state machine ended up in the correct state if (GetPreviewQuality()) { ERROR3("We would expect XPE to have ended with at least one non-preview bitmap!"); SetPreviewQuality(FALSE); bRecache = TRUE; } Tool* pTool = Tool::GetCurrent(); // Update the LiveEffect Tool's permanent status if (pTool->GetID()==TOOLID_LIVEEFFECT) { ((LiveEffectsTool*)pTool)->SetCurrentEffectID(m_strEffectID); ((LiveEffectsTool*)pTool)->SetCurrentStackPos(m_iStackPos); } // render blobs off for tools which don't automatically redraw their blobs. Spread* pSpread = Document::GetSelectedSpread(); // invalidate the (new) region bounding the selection. if (!DoInvalidateNodesRegions(*(GetApplication()->FindSelection()), TRUE, FALSE, FALSE, bRecache)) { End(); return; } // render blobs back on if the current tool doesn't automatically redraw its blobs. if (pSpread != NULL && pTool != NULL && !pTool->AreToolBlobsRenderedOnSelection()) pTool->RenderToolBlobs(pSpread, NULL); ObjChangeFlags cFlags(NULL, TRUE, NULL, NULL, NULL, NULL, NULL, TRUE); ObjChangeParam ObjChange(OBJCHANGE_FINISHED, cFlags, NULL, this); ok = UpdateChangedNodes(&ObjChange); if (bBroadcast) { BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::EFFECTSTACKCHANGED)); } // Tell the selrange that things have changed! GetApplication()->FindSelection()->Update(); End(); }

BOOL OpLiveEffect::DoLocaliseEffectAttrs (  UndoableOperation *  pOp, Node *  pNode )  [static, private]

Copy the Effect attributes from the specified node down to lower nodes, remaining effect attrs where possible but becoming normal attrs if that's not possible Used by ungroup. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/03/2005 Parameters: pOp  - pointer to op [INPUTS] pNode - [OUTPUTS]  Returns: TRUE if it worked Errors: See also: Definition at line 1901 of file opliveeffects.cpp. { // From top of stack // find effect attr // Copy it down to children of specified node // If node can cope with effect attr // Then copy as effect attr // Else // If object already has that type of attr // Then do nothing // Else copy attribute into place and delete attrs in subtree ListRange* pPPStack = EffectsStack::GetEffectsStackFromNode(pNode, FALSE, TRUE, TRUE); if (pPPStack) { Node* pEffectNode = pPPStack->FindLast(); while (pEffectNode) { NodeAttribute* pAttr = NodeAttribute::FindFirstAppliedAttr(pEffectNode); while (pAttr && pAttr->IsEffectAttribute() && pAttr->FindParent()==pEffectNode) { if (!pAttr->HasEquivalentDefaultValue(TRUE)) // Only copy attr if it doesn't look like the default DoCopyEffectAttr(pOp, pAttr, pNode); pAttr = NodeAttribute::FindPrevAppliedAttr(pAttr); } pEffectNode = pPPStack->FindPrev(pEffectNode); } } // Finally, do the same thing for the node itself... NodeAttribute* pAttr = NodeAttribute::FindFirstAppliedAttr(pNode); while (pAttr && pAttr->IsEffectAttribute() && pAttr->FindParent()==pNode) { if (!pAttr->HasEquivalentDefaultValue(TRUE)) // Only copy attr if it doesn't look like the default DoCopyEffectAttr(pOp, pAttr, pNode); pAttr = NodeAttribute::FindPrevAppliedAttr(pAttr); } delete pPPStack; return TRUE; }

BOOL OpLiveEffect::DoLocaliseLiveEffects (  UndoableOperation *  pOp, Node *  pNode )  [static, private]

Copy the specified LiveEffect stack onto the selection Used by Paste Attributes. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 25/10/2004 Parameters: pPPStack  - pointer to EffectsStack to copy [INPUTS] [OUTPUTS]  Returns: Errors: See also: Definition at line 1803 of file opliveeffects.cpp. { ListRange* pPPStack = EffectsStack::GetEffectsStackFromNode(pNode, FALSE, TRUE, TRUE); if (pPPStack==NULL) return TRUE; NodeRenderableInk* pChild = pNode->FindFirstChildInk(); while (pChild) { NodeRenderableInk* pNextChild = pChild->FindNextInk(); // Don't localise into "controlled" nodes if (pChild->GetParentController()==NULL) { NodeRenderableInk* pInsertContext = pChild; NodeBitmapEffect* pLENode = (NodeBitmapEffect*)pPPStack->FindFirst(); ERROR2IF(!pLENode->CanBeUnlocked(), FALSE, "Can't localise Destructive effects"); while (pLENode) { // Make a copy of this LiveEffect NodeBitmapEffect* pCopy = NULL; BOOL bOK = FALSE; CALL_WITH_FAIL(pCopy = (NodeBitmapEffect*)pLENode->SimpleCopy(), pOp, bOK); if (!bOK) return FALSE; // No room to take a copy of the node // Can't insert directly as parent because of restrictions with HiddenNode // So insert as sibling and then move context node into sibling bOK = pOp->DoInsertNewNode(pCopy, pInsertContext, NEXT, TRUE, FALSE, FALSE, FALSE); if (!bOK) return FALSE; bOK = pOp->DoMoveNode(pInsertContext, pCopy, FIRSTCHILD); if (!bOK) return FALSE; pInsertContext = pCopy; // Copy any necessary children of the LiveEffect // This could be much more developed, possibly using a virtual function // on the node that's just been copied to copy it's necessary parts // or ComplexCopy // But this works well enough for now (NodeShadowControllers and NodeShadows) Node* pNode = pLENode->FindFirstChild(); AttachNodeDirection dir = FIRSTCHILD; while (pNode) { if (pNode->NeedsParent(pNode->FindParent()) && pNode->IsBounded()) { // Make a copy of this "Needed" node NodeRenderableBounded* pCopy = NULL; BOOL bOK = FALSE; CALL_WITH_FAIL(pNode->NodeCopy((Node**)&pCopy), pOp, bOK); // Copy node and subtree if (!bOK) return FALSE; // No room to take a copy of the node bOK = pOp->DoInsertNewNode(pCopy, pInsertContext, dir, TRUE, FALSE, FALSE, FALSE); if (!bOK) return FALSE; } pNode = pNode->FindNext(); } pLENode = (NodeBitmapEffect*)pPPStack->FindNext(pLENode); } } pChild = pNextChild; } delete pPPStack; //----------------------------------------------------------------------------- // Remove all current LiveEffects on the selection // if (pNode->IsAnObject()) return (OpLiveEffect::DoDeleteAllPostProcessors(pOp, (NodeRenderableInk*)pNode)!=NULL); else return TRUE; }

void OpLiveEffect::DoWithParam (  OpDescriptor *  pOpDesc, OpParam *  pOpParam )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/06/2005 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Reimplemented from Operation. Reimplemented in OpApplyLiveEffect, and OpApplyFeatherEffect. Definition at line 2487 of file opliveeffects.cpp. { BOOL ok = FALSE; OpLiveEffectParam* pLEOpParam = NULL; if (pOpParam && pOpParam->IsKindOf(CC_RUNTIME_CLASS(OpLiveEffectParam))) pLEOpParam = (OpLiveEffectParam*) pOpParam; if (!CheckEffectOpParam(pLEOpParam)) { End(); return; } // Remember some details for later on when the Op ends successfully (?) if (pLEOpParam) { m_strEffectID = pLEOpParam->strOpUnique; m_iStackPos = pLEOpParam->StackPosition; } // obtain the current selection. Range Sel(*(GetApplication()->FindSelection())); RangeControl rc = Sel.GetRangeControlFlags(); rc.PromoteToParent = TRUE; Sel.Range::SetRangeControl(rc); if (!AllowEmptySelection() && Sel.FindFirst()==NULL) { End(); return; } // render blobs off for tools which don't automatically redraw their blobs. Tool* pTool = Tool::GetCurrent(); Spread* pSpread = Document::GetSelectedSpread(); if (pSpread != NULL && pTool != NULL && !pTool->AreToolBlobsRenderedOnSelection()) pTool->RenderToolBlobs(pSpread, NULL); // record the current selection state and if required, render off any selection blobs. if (!DoStartSelOp(FALSE, FALSE)) { End(); return; } // Ask the range whether it's OK to do the transform... // Get an ObjChangeParam ready, so we can ask op permission from nodes. ObjChangeFlags cFlags(NULL, TRUE, NULL, NULL, NULL, NULL, NULL, TRUE); // ReplaceNode & RegenerateNode ObjChangeParam ObjChange(OBJCHANGE_STARTING, cFlags, NULL, this); BOOL bOK = Sel.AllowOp(&ObjChange); if (!bOK) { End(); return; } // invalidate the region bounding the selection. if (!DoInvalidateNodesRegions(Sel, TRUE, FALSE, FALSE, FALSE)) { End(); return; } // Get a list of the LiveEffects we will be working on ListRange* pLERange = NULL; if (pLEOpParam && pLEOpParam->pPPStack) { pLERange = pLEOpParam->pPPStack->GetLevelRange(&pLEOpParam->StackPosition); // We don't own the returned range // Make a local copy in case the original dies during selection processing if (pLERange) pLERange = new ListRange(pLERange); } m_bAppliedNewEffects = FALSE; // ------------------------------------------------------------------- // Call virtual function of derived Ops to do the specialised function BOOL bEndNormally = DoEffectOp(pLERange, pLEOpParam); // ------------------------------------------------------------------- if (pLERange) { delete pLERange; pLERange = NULL; } if (bEndNormally) { // invalidate the (new) region bounding the selection. if (!DoInvalidateNodesRegions(*(GetApplication()->FindSelection()), TRUE, FALSE, FALSE, FALSE)) { End(); return; } // render blobs back on if the current tool doesn't automatically redraw its blobs. if (pSpread != NULL && pTool != NULL && !pTool->AreToolBlobsRenderedOnSelection()) pTool->RenderToolBlobs(pSpread, NULL); ObjChangeFlags cFlags(NULL, TRUE, NULL, NULL, NULL, NULL, NULL, TRUE); ObjChangeParam ObjChange(OBJCHANGE_FINISHED, cFlags, NULL, this); BOOL ok = UpdateChangedNodes(&ObjChange); BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::EFFECTSTACKCHANGED)); // Tell the selrange that things have changed! GetApplication()->FindSelection()->Update(); End(); } }

BOOL OpLiveEffect::EnsureLiveEffectOriginalBitmaps (   )  [protected]

Ensure that all NodeBitmapEffects in the current selection have original bitmaps ready and wait for us to pick up. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 10/09/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 949 of file opliveeffects.cpp. { if (m_pLERange==NULL) return TRUE; BOOL bRenderingNeeded = FALSE; DocView* pDocView = DocView::GetSelected(); bRenderingNeeded = FALSE; Node* pNode = m_pLERange->FindFirst(); while (pNode) { ENSURE(pNode->IsBitmapEffect(), "LiveEffects list contains non-LiveEffect in EnsureLiveEffectOriginalBitmaps"); NodeBitmapEffect* pLE = (NodeBitmapEffect*)pNode; if (!pLE->GetOriginalBitmap(NULL, NULL, NULL) && pLE->CanGenerateBitmap()) { // We need to forcibly render this node to get its original // bitmap set up // // Version2 Bitmap Generation // // Grab bitmap without using on screen rendering // This is more efficient than rendering the whole tree and // allows parameters to be controlled independently from screen view // // Ideally: // Start a render into a RenderRegion // Don't allow the RenderRegion to grab bitmap of its own - NOT DONE // Don't allow the RenderRegion to blit captures into it's own bitmap - NOT DONE // Ensure only the effect and it's children are rendered - DONE! // Just let the effect rendering functions create their capture bitmap - DONE! // Create a new GRenderDIB region // Most of the parameters here are immaterial because we are not really // interested in the results of the rendered region - just the capture pLE->ReleaseCached(TRUE, FALSE); // We will change so tell parents to uncache // Bodge? Ensure that locked effects will render their children // because they don't respond to ReleaseCached... if (pLE->IsLockedEffect()) pLE->SetProcessedBitmap(NULL, NULL, DocRect(), 0, 0, 0, 0); View* pView = View::GetCurrent(); Spread* pSpread = Document::GetSelectedSpread(); Matrix Mat = pView->ConstructScaledRenderingMatrix(pSpread, 1.0); FIXED16 Scale; Mat.Decompose(&Scale); double dpi = 0.0; // use screen dpi (ie PIXELS_PER_INCH) GRenderDIB* pNewGRR = new GRenderDIB(pLE->GetBoundingRect(), Mat, Scale, 32, dpi); ERROR2IF(pNewGRR == NULL, FALSE, "Failed to create a GRenderDIB!"); // State flags + pixel width calculations if (!pNewGRR->AttachDevice(pView, NULL, pSpread)) // view and spread from previous RR rather than Current - nb in create bitmap copy case { ERROR3("Cannot attach devices"); delete pNewGRR; pNewGRR = NULL; return FALSE; } pNewGRR->m_DoCompression = FALSE; pNewGRR->InitDevice(); pNewGRR->InitAttributes(); pNewGRR->SetLineAttributes(); pNewGRR->SetFillAttributes(); pNewGRR->SetBackmostChangedNode(pSpread); // Don't allow any cached 24BPP bitmaps to be used! // NB following call gets GRendRegion to create the bitmap into which GDraw will render BOOL Started = pNewGRR->StartRender(); if (Started) { // Setup attribute state outside this subtree CCAttrMap* pAttrMap = new CCAttrMap; if (pAttrMap!=NULL) { pLE->FindAppliedAttributes(pAttrMap, 5000, NULL, FALSE, FALSE); pAttrMap->Render(pNewGRR); delete pAttrMap; } // This is the important bit - force top quality rendering // so that effects capture is done properly regardless of // the current document/view quality pNewGRR->RRQuality.SetQuality(QUALITY_MAX); pNewGRR->SetQualityLevel(); pNewGRR->SetImmediateRender(TRUE); pNewGRR->RenderTree(pLE, FALSE, FALSE); pNewGRR->StopRender(); } // Sanity check // We really should have generated an original bitmap by now! ERROR2IF(!pLE->GetOriginalBitmap(NULL, NULL, NULL), FALSE, "EnsureLiveEffectOriginalBitmaps failed to generate an original bitmap"); delete pNewGRR; pNewGRR = NULL; } pNode = m_pLERange->FindNext(pNode); } return TRUE; }

BOOL OpLiveEffect::GenerateBitmap (  NodeBitmapEffect *  pBitmapEffect, double  dResolution, LPBITMAPINFO *  ppInfo, LPBYTE *  ppBits, DocRect *  prectBounds )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 13/06/2005 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 1080 of file opliveeffects.cpp. { // We need to forcibly render this node to get its original // bitmap set up // // Version2 Bitmap Generation // // Grab bitmap without using on screen rendering // This is more efficient than rendering the whole tree and // allows parameters to be controlled independently from screen view // // Ideally: // Start a render into a RenderRegion // Don't allow the RenderRegion to grab bitmap of its own - NOT DONE // Don't allow the RenderRegion to blit captures into it's own bitmap - NOT DONE // Ensure only the effect and it's children are rendered - DONE! // Just let the effect rendering functions create their capture bitmap - DONE! // Create a new GRenderDIB region // Most of the parameters here are immaterial because we are not really // interested in the results of the rendered region - just the capture View* pView = View::GetCurrent(); Spread* pSpread = Document::GetSelectedSpread(); Matrix Mat = pView->ConstructScaledRenderingMatrix(pSpread, 1.0); FIXED16 Scale; Mat.Decompose(&Scale); GRenderDIB* pNewGRR = new GRenderDIB(pBitmapEffect->GetBoundingRect(), Mat, Scale, 32, dResolution); ERROR2IF(pNewGRR == NULL, FALSE, "Failed to create a GRenderDIB!"); // State flags + pixel width calculations if (!pNewGRR->AttachDevice(pView, NULL, pSpread)) // view and spread from previous RR rather than Current - nb in create bitmap copy case { ERROR3("Cannot attach devices"); delete pNewGRR; pNewGRR = NULL; *ppInfo = NULL; *ppBits = NULL; *prectBounds = DocRect(); return FALSE; } pNewGRR->m_DoCompression = TRUE; // We do want transparency pNewGRR->InitDevice(); pNewGRR->InitAttributes(); pNewGRR->SetLineAttributes(); pNewGRR->SetFillAttributes(); // NB following call gets GRendRegion to create the bitmap into which GDraw will render BOOL Started = pNewGRR->StartRender(); if (Started) { // Setup attribute state outside this subtree CCAttrMap* pAttrMap = new CCAttrMap; if (pAttrMap!=NULL) { pBitmapEffect->FindAppliedAttributes(pAttrMap, 5000, NULL, FALSE, FALSE); pAttrMap->Render(pNewGRR); delete pAttrMap; } // This is the important bit - force top quality rendering // so that effects capture is done properly regardless of // the current document/view quality pNewGRR->RRQuality.SetQuality(QUALITY_MAX); pNewGRR->SetQualityLevel(); pNewGRR->RenderTree(pBitmapEffect, FALSE, FALSE); pNewGRR->StopRender(); } *prectBounds = pNewGRR->GetClipRect(); // Get pixel-aligned rect pNewGRR->GetBitmapPointers(ppInfo, ppBits); // Get the bitmap data out of the region, converting T channel pNewGRR->SetBitmapPointers(NULL, NULL); // We own the bitmap now, it will not be deallocated by // the following renderegion deleteion delete pNewGRR; pNewGRR = NULL; return TRUE; }

ListRange* OpLiveEffect::GetLiveEffectList (   )  [inline]

Definition at line 275 of file opliveeffects.h. {return m_pLERange;}

BOOL OpLiveEffect::GetPreviewQuality (   )  const [inline]

Definition at line 280 of file opliveeffects.h. {return m_bPreviewQuality;}

BOOL OpLiveEffect::HasChanged (   )  [protected]

Detect whether any of the LiveEffect nodes created/edited by this operation have actually been changed/do anything useful... Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/09/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if any of the nodes in the liveeffects list have changed since this operation started FALSE otherwise Errors: See also: Definition at line 1225 of file opliveeffects.cpp. { if (m_pLERange==NULL) return FALSE; Node* pNode = m_pLERange->FindFirst(); while (pNode) { ENSURE(pNode->IsBitmapEffect(), "LiveEffects list contains non-LiveEffect in EnsureLiveEffectOriginalBitmaps"); NodeBitmapEffect* pLE = (NodeBitmapEffect*)pNode; if (pLE->HasChanged()) return TRUE; pNode = m_pLERange->FindNext(pNode); } return FALSE; }

BOOL OpLiveEffect::Init (  void   )  [static, private]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/09/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Reimplemented from SimpleCCObject. Definition at line 214 of file opliveeffects.cpp. { BOOL bOK = TRUE; // Use an ParamOpDescriptor to allow OpApplyLiveEffect to receive extra information // about the menu item that invoked it... ParamOpDescriptor* pOD = NULL; pOD = new ParamOpDescriptor(OPTOKEN_APPLY_LIVEEFFECT, CC_RUNTIME_CLASS(OpApplyLiveEffect), OpApplyLiveEffect::GetParamState); bOK = bOK && (pOD!=NULL); pOD = new ParamOpDescriptor(OPTOKEN_EDIT_LIVEEFFECT, CC_RUNTIME_CLASS(OpEditLiveEffect), OpEditLiveEffect::GetParamState); bOK = bOK && (pOD!=NULL); pOD = new ParamOpDescriptor(OPTOKEN_EDIT_LEGACYEFFECT, CC_RUNTIME_CLASS(OpEditLegacyEffect), OpEditLegacyEffect::GetParamState); bOK = bOK && (pOD!=NULL); #ifdef FEATHER_EFFECT pOD = new ParamOpDescriptor(OPTOKEN_APPLY_FEATHEREFFECT, CC_RUNTIME_CLASS(OpApplyFeatherEffect), OpApplyFeatherEffect::GetParamState); bOK = bOK && (pOD!=NULL); #endif /* bOK = bOK && RegisterOpDescriptor(0, // Tool ID _R(IDS_EDIT_LIVEEFFECT), // String resource ID CC_RUNTIME_CLASS(OpEditLiveEffect), // Runtime class OPTOKEN_EDIT_LIVEEFFECT, // Token string OpEditLiveEffect::GetState, // GetState function 0, // Help ID _R(IDBBL_EDIT_LIVEEFFECT), // Bubble ID 0, // Resource ID 0, // Control ID SYSTEMBAR_ILLEGAL, // Bar ID TRUE, // Receive system messages FALSE, // Smart duplicate operation FALSE, // Clean operation 0, // No vertical counterpart GREY_WHEN_NO_CURRENT_DOC | DONT_GREY_WHEN_SELECT_INSIDE); // automatic state checking. */ bOK = bOK && RegisterOpDescriptor(0, // Tool ID _R(IDS_DELETE_LIVEEFFECT), // String resource ID CC_RUNTIME_CLASS(OpDeleteLiveEffect), // Runtime class OPTOKEN_DELETE_LIVEEFFECT, // Token string OpDeleteLiveEffect::GetState, // GetState function 0, // Help ID _R(IDBBL_DELETE_LIVEEFFECT), // Bubble ID 0, // Resource ID 0, // Control ID SYSTEMBAR_ILLEGAL, // Bar ID TRUE, // Receive system messages FALSE, // Smart duplicate operation FALSE, // Clean operation 0, // No vertical counterpart GREY_WHEN_NO_CURRENT_DOC | DONT_GREY_WHEN_SELECT_INSIDE); // automatic state checking. bOK = bOK && RegisterOpDescriptor(0, // Tool ID _R(IDS_DELETEALL_LIVEEFFECT), // String resource ID CC_RUNTIME_CLASS(OpDeleteAllLiveEffect), // Runtime class OPTOKEN_DELETEALL_LIVEEFFECT, // Token string OpDeleteAllLiveEffect::GetState, // GetState function 0, // Help ID _R(IDBBL_DELETEALL_LIVEEFFECT), // Bubble ID 0, // Resource ID 0, // Control ID SYSTEMBAR_ILLEGAL, // Bar ID TRUE, // Receive system messages FALSE, // Smart duplicate operation FALSE, // Clean operation 0, // No vertical counterpart GREY_WHEN_NO_CURRENT_DOC | DONT_GREY_WHEN_SELECT_INSIDE); // automatic state checking. bOK = bOK && RegisterOpDescriptor(0, // Tool ID _R(IDS_CHANGE_EFFECT_RES), // String resource ID CC_RUNTIME_CLASS(OpEffectRes), // Runtime class OPTOKEN_CHANGE_EFFECT_RES, // Token string OpEffectRes::GetState, // GetState function 0, // Help ID _R(IDBBL_CHANGE_EFFECT_RES), // Bubble ID 0, // Resource ID 0, // Control ID SYSTEMBAR_ILLEGAL, // Bar ID TRUE, // Receive system messages FALSE, // Smart duplicate operation FALSE, // Clean operation 0, // No vertical counterpart GREY_WHEN_NO_CURRENT_DOC | DONT_GREY_WHEN_SELECT_INSIDE); // automatic state checking. bOK = bOK && RegisterOpDescriptor(0, // Tool ID _R(IDS_CHANGE_EFFECT_LOCK), // String resource ID CC_RUNTIME_CLASS(OpEffectLock), // Runtime class OPTOKEN_CHANGE_EFFECT_LOCK, // Token string OpEffectLock::GetState, // GetState function 0, // Help ID _R(IDBBL_CHANGE_EFFECT_LOCK), // Bubble ID 0, // Resource ID 0, // Control ID SYSTEMBAR_ILLEGAL, // Bar ID TRUE, // Receive system messages FALSE, // Smart duplicate operation FALSE, // Clean operation 0, // No vertical counterpart GREY_WHEN_NO_CURRENT_DOC | DONT_GREY_WHEN_SELECT_INSIDE); // automatic state checking. bOK = bOK && RegisterOpDescriptor(0, // Tool ID _R(IDS_CHANGE_EFFECT_LOCKALL), // String resource ID CC_RUNTIME_CLASS(OpEffectLockAll), // Runtime class OPTOKEN_CHANGE_EFFECT_LOCKALL, // Token string OpEffectLockAll::GetState, // GetState function 0, // Help ID _R(IDBBL_CHANGE_EFFECT_LOCKALL), // Bubble ID 0, // Resource ID 0, // Control ID SYSTEMBAR_ILLEGAL, // Bar ID TRUE, // Receive system messages FALSE, // Smart duplicate operation FALSE, // Clean operation 0, // No vertical counterpart GREY_WHEN_NO_CURRENT_DOC | DONT_GREY_WHEN_SELECT_INSIDE); // automatic state checking. return bOK; }

BOOL OpLiveEffect::IsTopOfStack (  EffectsStack *  pPPStack, INT32  iStackPos )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/10/2004 Parameters: iStackPos  - position in LiveEffect stack to find nodes [INPUTS] 0 means first stack pos above selection [OUTPUTS]  Returns: Errors: See also: Definition at line 926 of file opliveeffects.cpp. { return (iStackPos>=(INT32)pPPStack->GetCount()); }

BOOL OpLiveEffect::SetChanged (  BOOL  bNewState  )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/09/2004 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 1186 of file opliveeffects.cpp. { if (m_pLERange==NULL) return TRUE; Node* pNode = m_pLERange->FindFirst(); while (pNode) { ENSURE(pNode->IsBitmapEffect(), "LiveEffects list contains non-LiveEffect in EnsureLiveEffectOriginalBitmaps"); NodeBitmapEffect* pLE = (NodeBitmapEffect*)pNode; pLE->SetChanged(bNewState); pNode = m_pLERange->FindNext(pNode); } return TRUE; }

void OpLiveEffect::SetPreviewQuality (  BOOL  bNew  )  [inline]

Definition at line 281 of file opliveeffects.h. {m_bPreviewQuality = bNew;}

BOOL OpLiveEffect::UpdateCurrentEditor (   )  [static, private]

Reset the current Op to refer to the new PPStack and tell the running XPE edit that things are changing. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/2004 Definition at line 1258 of file opliveeffects.cpp. { OpLiveEffect* pCurrentOp = XPEHost::GetCurrentLEOp(); // If we haven't got a list of editors yet then get one if (pCurrentOp==NULL) return FALSE; // TODO: May need to force a redraw if the current op is in preview mode at the moment ENSURE(pCurrentOp->GetPreviewQuality()==FALSE, "We can't leave the bitmaps in the tree in preview mode!"); // Read the current op's details... String_256 strEffectID = pCurrentOp->m_strEffectID; INT32 iStackPos = pCurrentOp->m_iStackPos; // Stop the current Op and commit all of its changes // Disconnect it from the XPE system so that, just for the moment at least, other routines // think that there's no running edit session pCurrentOp->DoEndEdit(TRUE, TRUE); // Sends ScreenChangeMsg - and thus releases pPPStack XPEHost::SetCurrentLEOp(NULL); // Tells UpdateCurrentEditor not to try to update dying editor // Reset pPPStack in LiveEffectTool to reset the Tool after the ScreenChangeMsg sent above // (prevent idle handler looping forever calling this function) EffectsStack* pPPStack = EffectsStack::GetEffectsStackFromSelection(); // Try to find the same effect in the new stack // If found then invoke a new Op to use the running editor on that effect BOOL bOK = pPPStack->FindBestProcessor(&strEffectID, &iStackPos); // Decide which sort of Operation we need to use instead... OpDescriptor* pOp = NULL; if (bOK) { // We found the right sort of Effect in the stack so we'll just edit that pOp = OpDescriptor::FindOpDescriptor(OPTOKEN_EDIT_LIVEEFFECT); } else { // We didn't find the right sort of effect so we'll apply a brand new one! // At the top of the stack pOp = OpDescriptor::FindOpDescriptor(OPTOKEN_APPLY_LIVEEFFECT); iStackPos = STACKPOS_INSERT_TOP; } // Start a new Op but tell it to use the existing edit session instead of making a new one if (pOp) { OpLiveEffectParam Param; Param.strOpUnique = strEffectID; Param.StackPosition = iStackPos; Param.pPPStack = pPPStack; Param.bReUseEditor = TRUE; // This is the important param! BOOL bValid = XPEHost::GetEffectDetails(strEffectID, &Param.strMenuText, &Param.bIsDestructive); String_256 strDummy; if (bValid && pOp->GetOpsState(&strDummy).Greyed==FALSE) { pOp->Invoke(&Param); // Reset the Tool's current stack pointer now so that it doesn't need // to be updated under idle events with the consequent call to this function // and infinite loop... Tool* pTool = Tool::GetCurrent(); if (pTool->GetID()==TOOLID_LIVEEFFECT) ((LiveEffectsTool*)pTool)->UpdatePPStack(FALSE); // If that successfully set up a new editor op then we're fine to carry on if (XPEHost::GetCurrentLEOp()!=NULL) { delete pPPStack; return TRUE; } } } // If we get here then we must have failed in some way so close down the running editor XPEHost::EndEditLiveEffect(); delete pPPStack; return FALSE; }

---

Member Data Documentation

BOOL OpLiveEffect::m_bAppliedNewEffects [protected]

Definition at line 314 of file opliveeffects.h.

BOOL OpLiveEffect::m_bPreviewQuality [protected]

Definition at line 317 of file opliveeffects.h.

INT32 OpLiveEffect::m_iStackPos [protected]

Definition at line 316 of file opliveeffects.h.

ListRange* OpLiveEffect::m_pLERange [protected]

Definition at line 313 of file opliveeffects.h.

String_256 OpLiveEffect::m_strEffectID [protected]

Definition at line 315 of file opliveeffects.h.

---

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

• tools/opliveeffects.h (r1785/r1361)
• tools/opliveeffects.cpp (r1785/r1282)

---