SelOperation Class Reference

A SelOperation. More...

#include <selop.h>

Inheritance diagram for SelOperation:

List of all members.

Public Member Functions
	SelOperation ()
	SelOperation constructor, calls the constructor of the base class.
virtual	~SelOperation ()
	SelOperation destructor.
BOOL	DoStartSelOp (BOOL RenderEndSelStateBlobs, BOOL RenderStartSelStateBlobs=TRUE, BOOL UndoRenderEndSelStateBlobs=FALSE, BOOL UndoRenderStartSelStateBlobs=FALSE)
	This function must be called by all SelOperations. It does the following:.
virtual void	End ()
	Calls DoEndSelOp(), then Operation::End().
virtual BOOL	MayChangeNodeBounds () const
virtual BOOL	GetStarted () const
virtual BOOL	DoAttributesSelected (List &AttribsToApply, UINT32 OpName, BOOL bPasteAttrs)
	This high level function should be called whenever we need to apply multiple attributes to the selection (eg. PasteAttributes).
virtual BOOL	DoApplyAttribsToSelection (OpParam *pOpParam, BOOL bClearIfNoneApplied=FALSE)
	Performs the OpApplyAttribsToSelected operation. This tries to apply the list of attributes in the OpParam->AttribsToApplyList to the selection. If no attribute can be applied then the operation does not generate any actions, and so will be a NOP and be destroyed during End().
virtual BOOL	DoApplyToSelection (List *Attribs, List *AttrGroupList, BOOL *pAttribWasRequired)
virtual BOOL	DoApply (Node *CurrentNode, NodeAttribute *Attrib, BOOL Mutate, BOOL InvalidateRegion=TRUE, BOOL KeepExistingCharacteristics=TRUE, BOOL *AttribWasRequired=NULL, BOOL *pbCanDiscardUndo=NULL)
	Will not apply the attribute to CurrentNode if it does not require it.
Static Public Member Functions
static BOOL	DoApply (SelOperation *pOp, Node *CurrentNode, NodeAttribute *Attrib, BOOL Mutate, BOOL InvalidateRegion=TRUE, BOOL KeepExistingCharacteristics=TRUE, BOOL bOptimise=TRUE, BOOL *AttribWasRequired=NULL, BOOL *pbCanDiscardUndo=NULL)
static BOOL	InvalidateNodeRegion (SelOperation *pOp, NodeRenderableBounded *CurrentNode, NodeAttribute *Attrib, BOOL Mutate)
static BOOL	ReleaseCachedForAttrApply (NodeRenderableBounded *pNode, BOOL bEffectRootOnly)
	If we have just set an effect attribute then we can avoid releasing cached info of the specified node and all its children... We RELY on invalidations associated with this function not calling ReleaseCached themselves!
Protected Member Functions
virtual BOOL	ApplyAttributeToBrush (Node *pCurrentNode, NodeAttribute *pAttr)
	Works out if pCurrentNode has an applied brush attribute, and if so then sets up an action to tell the brush to use the attribute being applied.
virtual BOOL	ApplyLineWidthToBrush (AttrBrushType *pAttrBrush, NodeRenderableInk *pBrushedNode, NodeAttribute *pAttr)
	If we are applying a line width to a brushed node we need to tell the brush that it must scale to line width. We must also do an additional invalidate region so that if we are increasing in size then the brush will be rerendered properly.
virtual BOOL	ApplyStrokeColourToBrush (AttrBrushType *pAttrBrush, NodeRenderableInk *pBrushedNode)
	When a new stroke colour is applied to a brushed object we wish to set the flag that tells the brush to override the named colours in the brush with the colour applied.
virtual BOOL	ApplyTransparencyToBrush (AttrBrushType *pAttrBrush, NodeRenderableInk *pBrushedNode)
	When a transparency is applied to a brushed object we need to set a flag in the brush to tell it to use this new transparency.
virtual BOOL	ApplyBrushAttr (Node *pCurrentNode, AttrBrushType *pAttrBrush)
	When we apply a brush attribute to an object we want to check to see if the current line width attribute is the same as the default attribute. If it is then we will apply the default line width suggested by the brush itself. This is because people keep on applying brush attributes to 500MP lines and ending up with thousands of brush objects, which makes everything really slow.
Private Member Functions
BOOL	DoEndSelOp ()
	This function gets called automatically by End().
Private Attributes
SelectionState *	SelState
BOOL	m_bStartCalled
Static Private Attributes
static BOOL	RenderEndSelStateBlobs
static BOOL	RenderStartSelStateBlobs
static BOOL	UndoRenderEndSelStateBlobs
static BOOL	UndoRenderStartSelStateBlobs

---

Detailed Description

A SelOperation.

Author:

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

Date:

15/2/94

See also:

TransOperation

Definition at line 121 of file selop.h.

---

Constructor & Destructor Documentation

SelOperation::SelOperation (   )

SelOperation constructor, calls the constructor of the base class. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 138 of file selop.cpp. : UndoableOperation() { m_bStartCalled = FALSE; }

SelOperation::~SelOperation (   )  [virtual]

SelOperation destructor. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 158 of file selop.cpp. { }

---

Member Function Documentation

BOOL SelOperation::ApplyAttributeToBrush (  Node *  pCurrentNode, NodeAttribute *  pAttr )  [protected, virtual]

Works out if pCurrentNode has an applied brush attribute, and if so then sets up an action to tell the brush to use the attribute being applied. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/2000 Parameters: pCurrentNode  - the node that the attribute is being applied to [INPUTS] pAttr - the attribute to apply Returns: TRUE if all ok. Errors: - See also: - Notes: This is only currently operational for fill attributes, others may be added in future. 18/4/2000 - Line widths added Definition at line 770 of file attrappl.cpp. { ERROR2IF(pCurrentNode == NULL, FALSE, "Current node is NULL"); ERROR2IF(pAttr == NULL, FALSE, "Attribute is NULL"); // currently this only works for colour changes and transparent fills if (!pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrStrokeColourChange)) && !pAttr->IsATranspFill() && !pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrLineWidth)) && !pAttr->IsABrush()) return TRUE; // first get the existing brush attribute AttrBrushType* pAttrBrush = NULL; // for some reason we don't check the return value here?? /*BOOL ok =*/ ((NodeRenderableInk*)pCurrentNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), (NodeAttribute**)&pAttrBrush); // if we're applying a brush attribute then do something else if (pAttr->IsABrush()) { AttrBrushType* pNewAttrBrush = (AttrBrushType*)pAttr; return ApplyBrushAttr(pCurrentNode, pNewAttrBrush); } // there isn't one - thats ok if (pAttrBrush == NULL || pAttrBrush->GetBrushHandle() == BrushHandle_NoBrush) return TRUE; // so now we have a brush attribute, so lets determine what to do: if (pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrStrokeColourChange))) { // only do this is the new colour is not transparent AttrStrokeColourChange* pStrokeCol = static_cast<AttrStrokeColourChange*>(pAttr); DocColour* pCol = pStrokeCol->GetStartColour(); //PORTNOTE("other","Removed DocColour usage") - AMB Unremoved if (pCol->IsTransparent()) return TRUE; return ApplyStrokeColourToBrush(pAttrBrush, (NodeRenderableInk*)pCurrentNode); } // Is this a porting comment-out? AMB // if (pAttr->IsATranspFill()) // return ApplyTransparencyToBrush(pAttrBrush, (NodeRenderableInk*)pCurrentNode); if (pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrLineWidth))) return ApplyLineWidthToBrush(pAttrBrush, (NodeRenderableInk*)pCurrentNode, pAttr); // trash the cached bounding rect pAttrBrush->ClearCachedRect(); // if it isn't one of the above then we dont have to do anything return TRUE; }

BOOL SelOperation::ApplyBrushAttr (  Node *  pCurrentNode, AttrBrushType *  pAttrBrush )  [protected, virtual]

When we apply a brush attribute to an object we want to check to see if the current line width attribute is the same as the default attribute. If it is then we will apply the default line width suggested by the brush itself. This is because people keep on applying brush attributes to 500MP lines and ending up with thousands of brush objects, which makes everything really slow. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/2000 Parameters: pCurrentNode  - the node we are applying the brush to [INPUTS] pAttrBrush - the brush attribute we are applying Returns: TRUE if all ok. Definition at line 961 of file attrappl.cpp. { ERROR2IF(pCurrentNode == NULL || pAttrBrush == NULL, FALSE, "Null input pointers to OpApplyAttrib::ApplyBrushAttr"); ERROR2IF(!pCurrentNode->IsAnObject(), FALSE, "Input node is not an ink node in OpApplyAttrib::ApplyBrushAttr"); // its too complicated when you have compound nodes if (pCurrentNode->IsCompound()) return TRUE; AttrLineWidth* pCurrentLineWidth = NULL; ((NodeRenderableInk*)pCurrentNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth), (NodeAttribute**)&pCurrentLineWidth); if (pCurrentLineWidth != NULL) { // Get the default line width AttrLineWidth* pDefault = (AttrLineWidth*)(AttributeManager::GetDefaultAttribute(ATTR_LINEWIDTH)); if (pDefault == NULL) { ERROR3("Unable to get default line width, theres no way this can happen Jim!"); // continue anyway } else { // check to see if default is the same as current, if not then just leave if (pCurrentLineWidth->Value.LineWidth != pDefault->Value.LineWidth-1) { delete pDefault; PathProcessorBrush* pPPB = pAttrBrush->GetPathProcessor(); if (pPPB) { BOOL UsesPressure = pAttrBrush->GetPressureCache() != NULL; pPPB->ScaleToValue(pCurrentLineWidth->Value.LineWidth, !UsesPressure); pPPB->AdjustSpacingForClosedPath((NodeRenderableInk*)pCurrentNode); } return TRUE; } delete pDefault; } } // otherwise we want a new line width attribute MILLIPOINT LineWidth = pAttrBrush->GetDefaultLineWidth(TRUE); //DoApply makes a copy so we only need to make this local AttrLineWidth NewLineWidth; NewLineWidth.Value.LineWidth = LineWidth; // now apply it return DoApply(pCurrentNode, &NewLineWidth, FALSE, FALSE); }

BOOL SelOperation::ApplyLineWidthToBrush (  AttrBrushType *  pAttrBrush, NodeRenderableInk *  pBrushedNode, NodeAttribute *  pAttr )  [protected, virtual]

If we are applying a line width to a brushed node we need to tell the brush that it must scale to line width. We must also do an additional invalidate region so that if we are increasing in size then the brush will be rerendered properly. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/2000 Parameters: pAttrBrush  - the brush attribute that we wish to update [INPUTS] pBrushedNode -the node that the brush applies to pAttr - the line width that we are applying Returns: TRUE if all ok. Definition at line 921 of file attrappl.cpp. { ERROR2IF(pAttrBrush == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyLineWidthToBrush"); ERROR2IF(pBrushedNode == NULL, FALSE, "Node pointer is NULL in OnApplyAttrib::ApplyLineWidthToBrush"); ERROR2IF(pAttr == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyLineWidthToBrush"); // if we are on a closed path then ask the PPB to even out the spacing PathProcessorBrush* pPPB = pAttrBrush->GetPathProcessor(); if (pPPB != NULL) { // scale to the new line width AttrLineWidth* pLineWidth = (AttrLineWidth*)pAttr; BOOL UsesPressure = pAttrBrush->GetPressureCache() != NULL; pPPB->ScaleToValue(pLineWidth->Value.LineWidth, !UsesPressure); pPPB->AdjustSpacingForClosedPath(pBrushedNode); } return TRUE; }

BOOL SelOperation::ApplyStrokeColourToBrush (  AttrBrushType *  pAttrBrush, NodeRenderableInk *  pBrushedNode )  [protected, virtual]

When a new stroke colour is applied to a brushed object we wish to set the flag that tells the brush to override the named colours in the brush with the colour applied. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/2000 Parameters: pAttrBrush  - the brush attribute that we wish to update [INPUTS] pbrushed node - the node that the brush applies to Returns: TRUE if all ok. Definition at line 871 of file attrappl.cpp. { ERROR2IF(pAttrBrush == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyStrokeColourToBrush"); ERROR2IF(pBrushedNode == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyStrokeColourToBrush"); // if the brush already uses local colours then don't bother doing anything PathProcessorBrush *pPPB = pAttrBrush->GetPathProcessor(); if (pPPB == NULL) return TRUE; if (pPPB->GetUseLocalFillColour() || !pPPB->GetUseNamedColours()) return TRUE; // make the OpParam ChangeBrushOpParam Param; Param.ChangeType = CHANGEBRUSH_USENAMEDCOL; Param.m_bNewUseNamed = FALSE; ChangeBrushAction* pAction = NULL; // initialise the action if (ChangeBrushAction::Init(this, &UndoActions, pBrushedNode, &Param, &pAction) == AC_FAIL) return FALSE; return TRUE; }

BOOL SelOperation::ApplyTransparencyToBrush (  AttrBrushType *  pAttrBrush, NodeRenderableInk *  pBrushedNode )  [protected, virtual]

When a transparency is applied to a brushed object we need to set a flag in the brush to tell it to use this new transparency. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 24/2/2000 Parameters: pAttrBrush  - the brush attribute that we wish to update [INPUTS] pAttr - the attribute to apply Returns: TRUE if all ok. Definition at line 838 of file attrappl.cpp. { ERROR2IF(pAttrBrush == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyTransparencyToBrush"); ERROR2IF(pBrushedNode == NULL, FALSE, "Attribute pointer is NULL in OnApplyAttrib::ApplyTransparencyToBrush"); // make the OpParam ChangeBrushOpParam Param; Param.ChangeType = CHANGEBRUSH_USELOCALTRANSP; Param.m_bNewUseLocalTransp = TRUE; ChangeBrushAction* pAction = NULL; // initialise the action if (ChangeBrushAction::Init(this, &UndoActions, pBrushedNode, &Param, &pAction) == AC_FAIL) return FALSE; return TRUE; }

BOOL SelOperation::DoApply (  Node *  CurrentNode, NodeAttribute *  Attrib, BOOL  Mutate, BOOL  InvalidateRegion = TRUE, BOOL  KeepExistingCols = TRUE, BOOL *  pbAttribWasRequired = NULL, BOOL *  pbCanDiscardUndo = NULL )  [virtual]

Will not apply the attribute to CurrentNode if it does not require it. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: InvalidateRegion,:  When TRUE DoInvalidateNodeRegion is called before and [INPUTS] after the attribute has been applied. If the attribute is being applied to a range of objects then it is inefficient to do this. KeepExistingCols: When TRUE the new attribute takes on the colour characteristics of the attribute it is replacing. AttribWasRequired:This  output is optional. It indicates if the [OUTPUTS] Attrib was required by the object. Returns: TRUE if successful FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) Errors: - See also: NodeRenderableInk::GetObjectToApplyTo Definition at line 229 of file attrappl.cpp. { return SelOperation::DoApply(this, CurrentNode, Attrib, Mutate, InvalidateRegion, KeepExistingCols, TRUE, pbAttribWasRequired, pbCanDiscardUndo); }

BOOL SelOperation::DoApply (  SelOperation *  pOp, Node *  CurrentNode, NodeAttribute *  Attrib, BOOL  Mutate, BOOL  InvalidateRegion = TRUE, BOOL  KeepExistingCharacteristics = TRUE, BOOL  bOptimise = TRUE, BOOL *  AttribWasRequired = NULL, BOOL *  pbCanDiscardUndo = NULL )  [static]

Definition at line 241 of file attrappl.cpp. { BOOL AttributeExists = FALSE; // Until we find that the attribute does exist CCRuntimeClass* AttrType = Attrib->GetAttributeType(); ERROR3IF(!CurrentNode->IsAnObject(), "Trying to apply an attribute to a non-NodeRenderableInk"); // We don't allow attributes like 'Quality' to be applied to objects directly. ERROR3IF(!(Attrib->CanBeAppliedToObject()), "Trying to apply an illegal attribute to the object"); if (!(Attrib->CanBeAppliedToObject())) return TRUE; // Just pretend they ever tried. Node* OriginalCurrentNode = CurrentNode; if (CurrentNode->IsAnObject()) { // Obtain the real object to apply the attribute to CurrentNode = ((NodeRenderableInk*)CurrentNode)->GetObjectToApplyTo(Attrib->GetAttributeType()); if (!CurrentNode) { ERROR3("OpApplyAttrib::DoApply, Unable to find object to apply to"); return TRUE; } } // NOTE! Better to get the value of this flag here, now that GetObjectToApplyTo has been called BOOL bEffectRootOnly = (CurrentNode->IsAnObject() && ((NodeRenderableInk*)CurrentNode)->IsValidEffectAttr(Attrib)); // If we are applying attributes to the Caret alone then the caller should not retain an undo record // for this operation... if (pbCanDiscardUndo) *pbCanDiscardUndo = *pbCanDiscardUndo && CurrentNode->DiscardsAttributeChildren(); // BODGE! ------------------------------------------------------------ // Don't apply stroke transparency as an effect attribute - nothing // needs it. Test has to be done here because other objects in the // selection might need it... if (bEffectRootOnly && AttrType == CC_RUNTIME_CLASS(AttrStrokeTransp)) return TRUE; // END-BODGE! -------------------------------------------------------- // Needed to support adding triggers, who can be multiply applied BOOL AddEvenIfMultiple = FALSE; // Do not apply the attribute if CurrentNode does not require it if ((((NodeRenderableInk*)CurrentNode)->RequiresAttrib(Attrib))) { if (pbAttribWasRequired) *pbAttribWasRequired = TRUE; if (CurrentNode != OriginalCurrentNode) { // BODGE TEXT // We need to call AllowOp, for the TextStories benefit, // so that lines know they have been affected ObjChangeFlags cFlags; cFlags.Attribute = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING, cFlags, NULL, pOp); if (!CurrentNode->AllowOp(&ObjChange)) { // It's already passed the test once. ERROR3("Doing op when no nodes will allow it"); } } // ----------------------------------------------------------------------------- // Determine if the current node already has an attribute which is the same // runtime class as Attrib. Node* n = CurrentNode->FindFirstChild(); Node* pLastBoundedNode = NULL; if (bEffectRootOnly) { pLastBoundedNode = CurrentNode->FindLastChild(CC_RUNTIME_CLASS(NodeRenderableBounded)); ERROR3IF(pLastBoundedNode==NULL, "Attempt to apply effect attr to node with no children"); if (pLastBoundedNode) n = pLastBoundedNode->FindNext(); } while (n && (n->IsOrHidesAnAttribute())) { // Now lets see if we can find an attribute of the same type // as the one we are interested in. if (n->IsAnAttribute()) { NodeAttribute* pNdAttr = (NodeAttribute*)n; if( pNdAttr->GetAttributeType() == AttrType) { // Attributes are of the same type (whatever that might mean) // Look for another attribute of the same Type if we're allowed more than // one per object BOOL LookForMultiple = FALSE; if (Attrib->CanBeMultiplyApplied()) { // If the classID's are the same then we want to replace the old one // (unless they're identical) if (Attrib->GetAttributeClassID() == pNdAttr->GetAttributeClassID()) { LookForMultiple = FALSE; // stop looking now AddEvenIfMultiple = FALSE; // replace the old one } else { // they're not the same classID's then we'll add a new one // but keep looking for a duplicate LookForMultiple = TRUE; AddEvenIfMultiple = TRUE; } } // Do the attributes have the same value ?. If they do then there is no point in // applying it a second time // to have the same value they must share the same runtime class if (IS_SAME_CLASS(pNdAttr, Attrib)) { // Found an identical attribute, so ignore this apply if ((*pNdAttr)==(*Attrib)) return TRUE; // We are not failing, just doing nothing. if (Attrib->IsABrush()) ((AttrBrushType*)Attrib)->OnReplaceAttribute((AttrBrushType*)pNdAttr); } // if applying a brush attribute we must copy some data over if (!LookForMultiple) { AttributeExists = TRUE; break; } } } n = n->FindNext(); // Find next child of CurrentNode } // >>>> Temporary BODGE to aid select-inside... // >>>> ALWAYS clear any attributes of the same type from the subtree (even if the // >>>> attribute just applied replaced an existing one) so that dubious // >>>> attribute states (due to this routine not dealing with Select-inside // >>>> properly yet) can be cleared. // >>>> NOTE! the current att (n) is passed in to DoRemoveAttTypeFromSubtree so // >>>> that it won't be deleted along with atts of the same type - that would be // >>>> (has been) disastrous! // Triggers can be multiply applied to groups, so we need to check CanBeMultiplyApplied if (CurrentNode->IsCompound() && !Attrib->CanBeMultiplyApplied() && !bEffectRootOnly) { // Remove all instances of attributes of the same type from the subtree. // This is not neccessary if the AttributeExists flag is TRUE because // we know in this situation that the subtree cannot contain any other // instances of the attribute !. if (pOp && !pOp->DoRemoveAttrTypeFromSubtree(CurrentNode, Attrib->GetAttributeType(), n)) { pOp->FailAndExecute(); // Just to make sure return FALSE; } } // At this point we have Either ..... // 1. Found an attribute of the same type as the new one, and we will // now replace it. // 2. Found the specific attribute we were looking for and will replace // that. // 3. Found an attribute to mutate. // 4. Found no attribute of the correct type, indicating that it has // been factored out, and we need to put a new one in here. // 5. The attribute had CanBeMultiplyApplied() set, and no exact same // Attribute was found. // // Have we have got an Attribute to do something with ? NodeAttribute* AttribClone = NULL; if ( !AddEvenIfMultiple && n && n->IsAnAttribute()) { // Yes ! NodeAttribute* pAttr = (NodeAttribute*)n; if (Mutate) { // Mutate it into the new type. AttribClone = ((AttrFillGeometry*)n)->Mutate((AttrFillGeometry*)Attrib, bOptimise); } else { // We're gunna just replace the attribute with the new one. // First make a copy of the new attribute. if (pOp) ALLOC_WITH_FAIL(AttribClone ,((NodeAttribute*)Attrib->SimpleCopy()), pOp) else AttribClone = (NodeAttribute*)Attrib->SimpleCopy(); if (AttribClone == NULL) return FALSE; // Complication !! // If we are replacing a Fill Attribute and the attribute we are replacing // is already filled, then we need to extract the colour of the existing // fill and use them for the new fill. if ( KeepExistingCols && ((NodeAttribute*)n)->IsAFillAttr() ) { AttrFillGeometry* NodeReplaced = (AttrFillGeometry*)n; // Copy the old fill characteristics into the new Fill if (!OpApplyAttrib::KeepExistingCharacteristics(NodeReplaced, (AttrFillGeometry*)AttribClone)) return FALSE; } if ( Attrib->IsATranspFill() && Attrib->IsAFlatFill()) { ((AttrFillGeometry*)n)->RenderFillBlobs(); } } // If Mutate returned NULL, which means the Mutate // did nothing, we should return TRUE, which will move // onto the next object. if (AttribClone == NULL) return TRUE; // ---------------------------------------------------------- // If we have just set an effect attribute then we can avoid releasing // cached info of the specified node and all its children... // // We RELY on invalidations associated with this function not // calling ReleaseCached themselves! // ReleaseCachedForAttrApply((NodeRenderableBounded*)CurrentNode, bEffectRootOnly); // ---------------------------------------------------------- if (InvalidateRegion) { // Invalidate the Object before the attribute is applied if (!InvalidateNodeRegion(pOp, (NodeRenderableBounded*)CurrentNode, Attrib, Mutate)) // Doesn't invalidate cached info! return FALSE; } // Now we have done with the old attribute, so lets hide it, so // the changes can be undone // // Don't write any undo info if we don't have an op or the node // discards attributes by itself if (pOp && !CurrentNode->DiscardsAttributeChildren()) { // Note that we wouldn't need this test and we wouldn't need // to use the HideNode/ShowNode actions here if solid fill // dragging used OpApplyAttrInteractive. Instead it uses an // older system which relies on the HideNodeAction recording // a pointer to an attribute at the start of the drag which // is subsequently updated during the drag. if (pOp->IsKindOf(CC_RUNTIME_CLASS(OpApplyAttrInteractive))) { ApplyAction* pUndoApply; // Create an action to re-apply the attribute when we undo if ( ApplyAction::Init(pOp, pOp->GetUndoActionList(), CurrentNode, pAttr, TRUE, // When the attribute gets hidden we // must include its size (Action**)(&pUndoApply)) == AC_FAIL) { return FALSE; } pAttr->CascadeDelete(); delete pAttr; pAttr = NULL; } else { if (!pOp->DoHideNode(n, TRUE)) // Include the subtree size return FALSE; } } else { pAttr->CascadeDelete(); delete pAttr; pAttr = NULL; } } else // if (n != NULL) { // We've not found an attribute to replace, so we'll have to put // a new one in NodeAttribute* TempAttr = NULL; BOOL FoundAttr = ((NodeRenderableInk*)CurrentNode)-> FindAppliedAttribute(Attrib->GetAttributeType(), &TempAttr); if (!FoundAttr || TempAttr == NULL) return FALSE; if (Mutate) { AttribClone = ((AttrFillGeometry*)TempAttr)->Mutate((AttrFillGeometry*)Attrib, bOptimise); } else { // We'll just put a copy of our attribute in the tree. if (pOp) ALLOC_WITH_FAIL(AttribClone ,((NodeAttribute*)Attrib->SimpleCopy()), pOp) else AttribClone = (NodeAttribute*)Attrib->SimpleCopy(); if ( KeepExistingCols && (TempAttr->IsAFillAttr()) ) { AttrFillGeometry* NodeReplaced = (AttrFillGeometry*)TempAttr; // Copy the old fill characteristics into the new Fill if (!OpApplyAttrib::KeepExistingCharacteristics(NodeReplaced, (AttrFillGeometry*)AttribClone)) return FALSE; } if (Attrib->IsATranspFill() && Attrib->IsAFlatFill()) { // If we are mutating into a flat fill, then we need // to make sure we remove any existing fill blobs. ((AttrFillGeometry*)TempAttr)->RenderFillBlobs(); } } if (AttribClone) { ReleaseCachedForAttrApply((NodeRenderableBounded*)CurrentNode, bEffectRootOnly); if (InvalidateRegion) { // Make sure the node is redrawn if (!InvalidateNodeRegion(pOp, (NodeRenderableBounded*)CurrentNode, Attrib, Mutate)) // Doesn't invalidate cached info! return FALSE; } } } // If the AttribClone has the same value as an applied attribute // (A default attr if the attribs have been localised). Then we don't want to apply it ! if (AttribClone && AttribClone->ShouldBeOptimized() && !bEffectRootOnly && bOptimise) { NodeAttribute* pAppliedAttr; if (((NodeRenderableInk*)CurrentNode)->FindAppliedAttribute(AttribClone->GetAttributeType(), &pAppliedAttr)) { // Do the attributes have the same value ? if ((IS_SAME_CLASS(AttribClone, pAppliedAttr))) { if ((*AttribClone)==(*pAppliedAttr)) { AttribClone->CascadeDelete(); // Delete the attribute // If attribute affect's the bounds of the object (eg. a LineWidth) then invalidate the // bounds of the object if (pAppliedAttr->EffectsParentBounds()) { ((NodeRenderableBounded*)CurrentNode)->InvalidateBoundingRect(TRUE); } delete AttribClone; AttribClone = NULL; } } } } // Effect attributes don't optimise so if the value of this is the // same as the default value we should not add it here // if (AttribClone && bEffectRootOnly && AttribClone->HasEquivalentDefaultValue() && bOptimise) { // Just allow the attribute to be hidden AttribClone->CascadeDelete(); // Delete the attribute delete AttribClone; AttribClone = NULL; } if (AttribClone) { // Finally !! We can add the new attribute node into the tree. if (bEffectRootOnly) AttribClone->AttachNode(pLastBoundedNode, NEXT); else AttribClone->AttachNode(CurrentNode, FIRSTCHILD); AttributeManager::pLastNodeAppliedTo = (NodeRenderableInk*)CurrentNode; // And now it's in the tree, we need to make sure that any fill control // points are valid. if (AttribClone->IsAFillAttr()) { ((AttrFillGeometry*)AttribClone)->AttributeChanged(); } if (pOp && !CurrentNode->DiscardsAttributeChildren()) { // Note that we wouldn't need this test and we wouldn't need // to use the HideNode/ShowNode actions here if solid fill // dragging used OpApplyAttrInteractive. Instead it uses an // older system which relies on the HideNodeAction recording // a pointer to an attribute at the start of the drag and the // contents of the attribute being updated during the drag. if (pOp->IsKindOf(CC_RUNTIME_CLASS(OpApplyAttrInteractive))) { UnApplyAction* pUndoApply; // Create an action to hide the attribute when we undo if ( UnApplyAction::Init(pOp, pOp->GetUndoActionList(), CurrentNode, AttribClone, TRUE, // When the attribute gets hidden we // must include its size (Action**)(&pUndoApply)) == AC_FAIL) { AttribClone->CascadeDelete(); delete (AttribClone); return FALSE; } } else { HideNodeAction* UndoHideNodeAction; // Create an action to hide the attribute when we undo if ( HideNodeAction::Init(pOp, pOp->GetUndoActionList(), AttribClone, TRUE, // When the attribute gets hidden we // must include its size (Action**)(&UndoHideNodeAction)) == AC_FAIL) { AttribClone->CascadeDelete(); delete (AttribClone); return FALSE; } } } } ReleaseCachedForAttrApply((NodeRenderableBounded*)CurrentNode, bEffectRootOnly); if (InvalidateRegion) { // Invalidate the node rectangle, now the new attr has been applied if (!InvalidateNodeRegion(pOp, (NodeRenderableBounded*)CurrentNode, Attrib, Mutate)) // Doesn't invalidate cached info! return FALSE; } } // we may have to apply this to a brushed node if (pOp) // TODO: Make this work when no undo op specified? { if (!pOp->ApplyAttributeToBrush(CurrentNode, Attrib)) return FALSE; } return TRUE; // success }

BOOL SelOperation::DoApplyAttribsToSelection (  OpParam *  pOpParam, BOOL  bClearIfNoneApplied = FALSE )  [virtual]

Performs the OpApplyAttribsToSelected operation. This tries to apply the list of attributes in the OpParam->AttribsToApplyList to the selection. If no attribute can be applied then the operation does not generate any actions, and so will be a NOP and be destroyed during End(). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> (from Simon) Date: 16/02/2005 (from 16/8/93) Parameters: OpParam,:  This must be a ApplyAttribsToSelectedParam type [INPUTS] OpParam->AttribsToApply: This is the list of attributes that is to be applied to the selection. Each item on this list must be a NodeAttributePtrItem. OpParam->undoAttribStrID: Specifies the undo string to display (eg. Paste Atrributes) Parameters: OpParam->AttrGroupList,:  This list must be empty on entry to this function [OUTPUTS] If (Success) then this list will contain one ListListItem per attribute on the AttribsToApplyList. Each of these items will point to a Set of AttributeGroupItems. Attribute -> { Set of current attribute groups } Whenever an attribute is applied to an object, the Current AttributeGroup associated with the object is added to the attributes set of current attribute groups. Therefore if an attribute's set is empty then we know that the attribute has not been applied. OpParam->Success: FALSE if the operation failed. i.e. FailAndExecute() was called. anyAttrsApplied: FALSE if the operation has not applied any attributes This Operation currently does not support mutation Definition at line 2388 of file attrappl.cpp. { // Ensure that the OpParam is valid ERROR3IF(!pOpParam, "No parameters passed to OpApplyAttribsToSelected"); ApplyAttribsToSelectedParam* pParam = (ApplyAttribsToSelectedParam*)pOpParam; // get inputs List* pAttrsToApply = pParam->AttribsToApply; // m_pAttribList = pAttrsToApply; // UndoAttribStrID = pParam->UndoAttribStrID; // TODO: Fix this? // and outputs List* AttrGroupList = pParam->AttrGroupList; ERROR3IF(!(AttrGroupList->IsEmpty()), "AttributeGroupList not empty on entry to OpApplyAttribsToSelected"); BOOL* Success = pParam->Success; *Success = FALSE; // Let's be pessimistic BOOL* AppliedAttrs = pParam->AnyAttrsApplied; *AppliedAttrs = FALSE; BOOL bAnyApplied = FALSE; BOOL bWeStartedThisOp = FALSE; // Create a stable range of objects to apply to Range SelRng(*(GetApplication()->FindSelection())); // We need two sets of attribute types // one for Line level attributes, and one for non Line level attributes. This is because the localise // and factor out routines require each attribute in the set to be all applicable to the same // object. This would not be true if our set contained a BOLD, and a LINE_SPACING attribute for example. // Make our attribute type sets AttrTypeSet LineLevelAttrTypes; AttrTypeSet OtherAttrTypes; NodeAttributePtrItem* pAttrItem = (NodeAttributePtrItem*)(pAttrsToApply->GetHead()); NodeAttribute* pAttr; AttrTypeSet* SetToAddTo; while (pAttrItem) { pAttr = pAttrItem->NodeAttribPtr; ERROR3IF(!pAttr, "Should be an attribute"); if (pAttr->IsALineLevelAttrib()) SetToAddTo = &LineLevelAttrTypes; else SetToAddTo = &OtherAttrTypes; if (!SetToAddTo->AddToSet(pAttr->GetAttributeType())) { FailAndExecute(); goto EndOperation; } pAttrItem = (NodeAttributePtrItem*)(pAttrsToApply->GetNext(pAttrItem)); } // ----------------------------------------------------------- if (SelRng.FindFirst()!=NULL) { SelRange* Sel; ObjChangeFlags cFlags; cFlags.Attribute = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); Sel = GetApplication()->FindSelection(); if (!Sel->AllowOp(&ObjChange)) { FailAndExecute(); goto