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 EndOperation; } } if (!GetStarted()) { if (!DoStartSelOp(FALSE,FALSE, TRUE,TRUE)) // Try to record the selection state , don't // render the blobs though goto EndOperation; bWeStartedThisOp = TRUE; } // Make a stable range // Range SelRng(*(GetApplication()->FindSelection())); // Invalidate objects regions (include blobs because this may be neccessary, // there is little overhead anyway). if (!DoInvalidateNodesRegions(SelRng, TRUE, FALSE)) goto EndOperation; // Before we apply the attribute to the selection we must localise all attributes // with the same type that we are going to apply. If we don't do this then the // tree will be left in an invalid state. if (!LineLevelAttrTypes.IsEmpty() && SelRng.FindFirst()!=NULL) { if (!DoLocaliseForAttrChange(&SelRng, &LineLevelAttrTypes)) goto EndOperation; } if (!OtherAttrTypes.IsEmpty() && SelRng.FindFirst()!=NULL) { if (!DoLocaliseForAttrChange(&SelRng, &OtherAttrTypes)) goto EndOperation; } // ----------------------------------------------------------- if (!DoApplyToSelection(pAttrsToApply, AttrGroupList, &bAnyApplied)) { goto EndOperation; } // ----------------------------------------------------------- // If attributes were applied we must factor them out if (bAnyApplied) { // Having applied the attributes, we must now try and factor out the newly // applied attributes if (!LineLevelAttrTypes.IsEmpty()) { if (!DoFactorOutAfterAttrChange(&SelRng, &LineLevelAttrTypes)) { goto EndOperation; } } if (!OtherAttrTypes.IsEmpty()) { if (!DoFactorOutAfterAttrChange(&SelRng, &OtherAttrTypes)) { goto EndOperation; } } { ObjChangeFlags cFlags; cFlags.Attribute = TRUE; ObjChangeParam ObjChange(OBJCHANGE_FINISHED,cFlags,NULL,this); if (!UpdateChangedNodes(&ObjChange)) { FailAndExecute(); goto EndOperation; } } // Invalidate after if (!DoInvalidateNodesRegions(SelRng, TRUE, FALSE)) { goto EndOperation; } } else if (bClearIfNoneApplied) { // We applied no attributes so we can just chuck this undo record // and all its actions away SucceedAndDiscard(); } // Output values *Success = TRUE; // If we got here we must have succeeded *AppliedAttrs = bAnyApplied; // Tell caller if any attributes were applied EndOperation: // Delete our lists of attribute types LineLevelAttrTypes.DeleteAll(); OtherAttrTypes.DeleteAll(); if (bWeStartedThisOp) End(); return *Success; }

BOOL SelOperation::DoApplyToSelection (  List *  Attribs, List *  AttrGroupList, BOOL *  pAttribWasRequired )  [virtual]

Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: A  list of attributes to apply to the selection. Each item in the list is [INPUTS] a NodeAttributePtrItem. 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 Attribs List. 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. Returns: TRUE if successful FALSE if the operation should be aborted (TIDYUP THEN CALL End()!) See also: OpApplyAttribsToSelected::DoWithParam Definition at line 2594 of file attrappl.cpp. { ERROR3IF(!(AttrGroupList->IsEmpty()), "Invalid output param"); // Set up a range of all selected nodes SelRange* pSel = GetApplication()->FindSelection(); EffectsStack* pStack = pSel->GetEffectsStack(FALSE, FALSE); // Get cached stack, don't escape derived objects (allow attrs to be applie to derived objects) ERROR3IF(pStack==NULL, "Failed to get PPStack in ApplyToSelection"); INT32 stackpos = STACKPOS_TOP; Range* pLevel = pStack->GetLevelRange(&stackpos, FALSE); // Don't escape old controllers, apply attr to base nodes BOOL bCanDiscardUndo = TRUE; NodeAttributePtrItem* pAttrItem = (NodeAttributePtrItem*)(Attribs->GetHead()); while (pAttrItem) { NodeAttribute* pAttr = pAttrItem->NodeAttribPtr; // Create the pAttr's set of current attribute groups { currently empty } ListListItem* pAttrsSetItem = new ListListItem; if (!pAttrsSetItem) goto Failed; List* pAttrsSet = &(pAttrsSetItem->list); AttrGroupList->AddTail(pAttrsSetItem); // While there are still nodes to apply the attribute to Node* CurrentNode = pLevel->FindFirst(); // Node* FirstNode = CurrentNode; while (CurrentNode) { NodeAttribute* AttrToApply = pAttr; BOOL AppliedAttribIsCopy = FALSE; BOOL ThisAttrWasRequired = FALSE; if (pAttr->IsAFillAttr()) { // Transform the attribute to fit the node's bounds DocRect NodeBounds = ((NodeRenderableInk*)CurrentNode)->GetBoundingRect(TRUE); // We will transform a copy of the attribute. AttrToApply = (NodeAttribute*)(pAttr->SimpleCopy()); AppliedAttribIsCopy = TRUE; // cos it is if (!AttrToApply) goto Failed; AttrToApply->TransformToNewBounds(NodeBounds); } if (!DoApply(CurrentNode, AttrToApply, FALSE, // Don't mutate FALSE, // Don't invalidate region FALSE, // Don't keep existing characteristics &ThisAttrWasRequired, &bCanDiscardUndo)) { goto Failed; } if (ThisAttrWasRequired) { *pAttribWasRequired = TRUE; // This next bit is a bit yucky, we are in desperate need of templates to implement // proper sets. // The attribute was required by the object // Add the current attribute group associated with the object to the attributes set // Search the pAttrsSet set to see if it's already there CCRuntimeClass* NewAttrGroup = ((NodeRenderableInk*)CurrentNode)->GetCurrentAttribGroup(); ERROR3IF(NewAttrGroup == NULL, "Object has a NULL attribute group"); BOOL InSet = FALSE; AttributeGroupItem* pAttrGrpItem = (AttributeGroupItem*)pAttrsSet->GetHead(); while(pAttrGrpItem != NULL) { CCRuntimeClass* InSetAttrGroup = pAttrGrpItem->AttrGroup; ERROR3IF(InSetAttrGroup == NULL, "NULL attribute group found"); if (NewAttrGroup == InSetAttrGroup) { InSet = TRUE; break; // It's already in the set don't add it } pAttrGrpItem = (AttributeGroupItem*)pAttrsSet->GetNext(pAttrGrpItem); } if (!InSet) // The AttrGroup needs adding to the pAttrsSet { // Create a new AttrGroupItem pAttrGrpItem = new AttributeGroupItem(); if (!pAttrGrpItem) goto Failed; pAttrGrpItem->AttrGroup = NewAttrGroup; // And add it to our set pAttrsSet->AddHead(pAttrGrpItem); } } if (CurrentNode->IsAnObject()) ((NodeRenderableInk*)CurrentNode)->InvalidateBoundingRect(); CurrentNode = pLevel->FindNext(CurrentNode); if (AppliedAttribIsCopy) { delete AttrToApply; // not required AttrToApply = NULL; } } ContinueSlowJob(); pAttrItem = (NodeAttributePtrItem*)(Attribs->GetNext(pAttrItem)); } // If all nodes report DiscardsAttributeChildren() = TRUE // Then we can abandon the entire Op once it's finished if (bCanDiscardUndo) SucceedAndDiscard(); return TRUE; Failed: // Tidyup, and return FALSE AttrGroupList->DeleteAll(); return FALSE; }

BOOL SelOperation::DoAttributesSelected (  List &  AttribsToApply, UINT32  OpName, BOOL  bPasteAttrs )  [virtual]

This high level function should be called whenever we need to apply multiple attributes to the selection (eg. PasteAttributes). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: AttribsToApply,:  A list of NodeAttributePtrItems. These are the attributes [INPUTS] which will be applied to the selection. The function does not currently support attribute mutation. All AttrFillGeometry attributes should have their current bounds set using AttrFillGeometry::SetBoundingRect. very important ~~~~~~~~~~~~~~ This function only ever applies copies of attributes in the AttribsToApply list. It is the responsibility of the caller to delete these attributes, if this is appropriate. OpName: The name to give the operation which is performed by this function to apply attributes. eg. 'Paste Attributes' Parameters: -  [OUTPUTS] Returns: - If any objects are selected then the function invokes an operation to apply the attributes to these objects. Before an AttrFillGeometry is applied to an object it gets moved and scaled. If no nodes are selected then the attributes may become current depending on the preferences and what the user decides. See also: AttributeManager::AttributeSelected Definition at line 2779 of file attrmgr.cpp. { // The AttributeList cannot be empty ERROR3IF(AttribsToApply.IsEmpty(), "No attributes to apply in AttributeManager::AttributesSelected"); if (AttribsToApply.IsEmpty()) return FALSE; // nothing to do // If there is no current document then there is very little we can do Document* CurrentDoc = Document::GetSelected(); if (CurrentDoc == NULL) return TRUE; // We are not going to be able to do anything if there is no document SelRange* Sel = GetApplication()->FindSelection(); ERROR3IF(Sel==NULL,"Can't find SelRange!"); if (Sel==NULL) return TRUE; // If there are no objects in the selection, or if none of the selected objects require // the attribute, then it will not be applied List AttrGroupsList; // Will contain a list of current Attribute group sets. one for each attribute // in the AttribsToApply list. Each item in this list will be a ListListItem. BOOL Success; // FALSE if the operation fails BOOL AnyAttrsApplied; // FALSE if the operation has not applied any attributes // Build the parameter we are about to pass to the operation ApplyAttribsToSelectedParam OpParam(&AttribsToApply, OpName, &AttrGroupsList, // One per attribute applied &Success, // Indicates if op was successful &AnyAttrsApplied); // Indicates if the operation applied // any attributes // Invoke the core of the operation DoApplyAttribsToSelection(&OpParam, !GetStarted()); // Don't clear actions if the caller already called DoStartSelOp if (Success) { // Inform neccessary parties if (AnyAttrsApplied) { // Inform the selection that attributes have changed Sel->AttrsHaveChanged(); // We've probably changed a Colour BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::COLOURATTCHANGED)); // and the Attrib may have changed shape or summit. Who knows ? BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED)); Sel->UpdateBounds(); } // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Now decide which attributes in the AttribsToApply list should be made current AttributeManager& AttrMgr = CurrentDoc->GetAttributeMgr(); AttributeManager::AttrsToMakeCurrent AttribsToMakeCurrent = AttrMgr.GetAttributesToMakeCurrent(AttribsToApply, AttrGroupsList, bPasteAttrs); if( AttribsToMakeCurrent == AttributeManager::NONE ) { // Allow fill tools to update after a cancel // I'm not sure if we need this ???? Ask Will BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED)); } else { BOOL AttributeApplied; NodeAttributePtrItem* pAttr = (NodeAttributePtrItem*)(AttribsToApply.GetHead()); ListListItem* pAttrsGroups = (ListListItem*) (AttrGroupsList.GetHead()); while (pAttr) { AttributeApplied = (!(pAttrsGroups->list.IsEmpty())); // Empty Current attribute group list if (!AttributeApplied || (AttribsToMakeCurrent == AttributeManager::ALL)) { // Add attribute to all current attribute groups in the list, or to the // group associated with the current tool if the list is empty. AttributeManager::UpdateCurrentAttr(pAttr->NodeAttribPtr, FALSE, // Not a mutator &(pAttrsGroups->list), FALSE); // Don't tell world yet (too slow) } pAttr = (NodeAttributePtrItem*)(AttribsToApply.GetNext(pAttr)); pAttrsGroups = (ListListItem*)(AttrGroupsList.GetNext(pAttrsGroups)); } // Tell world current attributes have changed BROADCAST_TO_ALL(CurrentAttrChangedMsg()); } } // Tidyup AttrGroupsList.DeleteAll(); // Delete all group lists // And ensure that if we've caused the SelRange to set up any delayed message // broadcasts, that it sends them now rather than at some random time in the future // when some Op just happens to end. Sel->BroadcastAnyPendingMessages(); return Success; }

BOOL SelOperation::DoEndSelOp (   )  [private]

This function gets called automatically by End(). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - It Invalidates the rectangle covered by the selection and its blobs Scope: protected Returns: Errors: - See also: - Definition at line 306 of file selop.cpp. { // Create a SelectionState object ALLOC_WITH_FAIL(SelState, (new SelectionState()), this); if (SelState == NULL) { return FALSE; // Failure } // We have managed to create a SelectionState instance, now lets try and // record the current selections BOOL Success; CALL_WITH_FAIL(SelState->Record(), this, Success) if (!Success) // We failed to allocate enough memory to store the selection state { // There was insufficient memory to record the selections delete SelState; // Delete the selection state SelState = NULL; return FALSE; } // We have successfully managed to create a Selection state, create an action // to restore the selections when executed // Recorded the current selection state ok RestoreSelectionsAction* RestoreAct; ActionCode ActCode; // Attempt to initialise the action ActCode = RestoreSelectionsAction::Init(this, &UndoActions, SelState, FALSE, // Don't Toggle FALSE, FALSE, // The SelState is not shared UndoRenderStartSelStateBlobs, UndoRenderEndSelStateBlobs, TRUE, // restore at start of undo ( Action**)(&RestoreAct)); if (ActCode == AC_FAIL) { delete SelState; // We won't be needing this return FALSE; } // OK the operation should have finished playing with the selection states, so we can turn // the blob rendering back on. If the operation needs to render the end SelState blobs then // this is done. // If the operation needs to restore the blobs then do so #if !defined(EXCLUDE_FROM_RALPH) if (RenderEndSelStateBlobs) { ENSURE(Camelot.FindSelection() != NULL, "There is no SelRange"); Node* SelNd = Camelot.FindSelection()->FindFirst(); if (SelNd != NULL) { Spread* SelSpread = (Spread*) SelNd->FindParent(CC_RUNTIME_CLASS(Spread)); ENSURE(SelSpread != NULL, "Could not find spread of selected item"); // Put the blobs back Camelot.GetBlobManager()->RenderOn(NULL, SelSpread); } } #endif m_bStartCalled = FALSE; return TRUE; }

BOOL SelOperation::DoStartSelOp (  BOOL  renderEndSelStateBlobs, BOOL  renderStartSelBlobs = TRUE, BOOL  UndorenderEndSelStateBlobs = FALSE, BOOL  UndorenderStartSelBlobs = FALSE )

This function must be called by all SelOperations. It does the following:. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Parameters: RenderEndSelStateBlobs,:  Flag indicating if the blobs should be drawn for [INPUTS] the end selection state or not. This flag should be set to TRUE if the bounds of all selected objects at the end of the operation are not invalidated. RenderStartSelBlobs: Flag indicating if the blobs should be drawn for the start selection state or not. This flag should be set to TRUE if the bounds of all selected objects at the start of an operation are not invalidated. All operations which insert a new object into the tree will have RenderStartSelBlobs set to TRUE. Parameters: -  [OUTPUTS] Returns: TRUE if successful, FALSE if memory ran out (call End) Records the current selection status Returns: Errors: - See also: SelOperation::End() Definition at line 201 of file selop.cpp. { SelOperation::RenderStartSelStateBlobs = renderStartSelBlobs; SelOperation::RenderEndSelStateBlobs = renderEndSelStateBlobs; if (UndorenderEndSelStateBlobs) SelOperation::UndoRenderEndSelStateBlobs = !renderEndSelStateBlobs; else SelOperation::UndoRenderEndSelStateBlobs = renderEndSelStateBlobs; if (UndorenderStartSelBlobs) SelOperation::UndoRenderStartSelStateBlobs = !renderStartSelBlobs; else SelOperation::UndoRenderStartSelStateBlobs = renderStartSelBlobs; // Create a SelectionState object ALLOC_WITH_FAIL(SelState, (new SelectionState()), this); if (SelState == NULL) { return FALSE; // Failure } // We have managed to create a SelectionState instance, now lets try and // record the current selections BOOL Success; CALL_WITH_FAIL(SelState->Record(), this, Success) if (!Success) // We failed to allocate enough memory to store the selection state { // There was insufficient memory to record the selections delete SelState; // Delete the selection state SelState = NULL; return FALSE; } // We have successfully managed to create a Selection state, create an action // to restore the selections when executed // Recorded the current selection state ok RestoreSelectionsAction* RestoreAct; ActionCode ActCode; // Attempt to initialise the action ActCode = RestoreSelectionsAction::Init(this, &UndoActions, SelState, FALSE, // Don't Toggle FALSE, FALSE, // The SelState is not shared UndoRenderStartSelStateBlobs, // Render the start blobs ? UndoRenderEndSelStateBlobs, // Render the end blobs ? FALSE, // End restore ( Action**)(&RestoreAct)); #if !defined(EXCLUDE_FROM_RALPH) if (RenderEndSelStateBlobs) { // Remove all existing blobs ENSURE(Camelot.FindSelection() != NULL, "There is no SelRange"); Node* SelNd = Camelot.FindSelection()->FindFirst(); if (SelNd != NULL) { Spread* SelSpread = (Spread*) SelNd->FindParent(CC_RUNTIME_CLASS(Spread)); ENSURE(SelSpread != NULL, "Could not find spread of selected item"); // Remove the blobs Camelot.GetBlobManager()->RenderOff(NULL, SelSpread); } } #endif if (ActCode == AC_FAIL) { delete SelState; // We won't be needing this return FALSE; } m_bStartCalled = TRUE; return TRUE; }

void SelOperation::End (   )  [virtual]

Calls DoEndSelOp(), then Operation::End(). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Operation. Reimplemented in OpAsynchClipartImport. Definition at line 398 of file selop.cpp. { if (OpStatus == DO && (!OpFlags.Failed)) { DoEndSelOp(); // We don't want to perform this if we are undoing or } Operation::End(); }

virtual BOOL SelOperation::GetStarted (   )  const [inline, virtual]

Reimplemented from UndoableOperation. Definition at line 139 of file selop.h. { return m_bStartCalled; }

BOOL SelOperation::InvalidateNodeRegion (  SelOperation *  pOp, NodeRenderableBounded *  CurrentNode, NodeAttribute *  Attrib, BOOL  Mutate )  [static]

Definition at line 1092 of file attrappl.cpp. { // Include the blobs, if the attribute will change the parents bounds. BOOL IncludeBlobs = Attrib->EffectsParentBounds(); if ( (Mutate && !Attrib->IsAValueChange()) || Attrib->GetRuntimeClass() == CC_RUNTIME_CLASS(AttrBitmapDpiChange) ) { // Check for special cases of, either a mutate from one fill type to another, // or a dpi change. Both of these can change the blob bounds. IncludeBlobs = TRUE; } // Invalidate the bounds of the node, including the blobs if necessary. if (pOp) { if (!pOp->DoInvalidateNodeRegion(CurrentNode, IncludeBlobs, FALSE, FALSE, FALSE)) // NOTE! We do not release cached info! // Must be used in conjunction with ApplyToSelection { // Summit went wrong. return FALSE; } } else { BaseDocument* pBaseDoc = CurrentNode->FindOwnerDoc(); if (pBaseDoc && pBaseDoc->IsKindOf(CC_RUNTIME_CLASS(Document))) { Document* pDoc = (Document*)pBaseDoc; Spread* pSpread = (Spread*)CurrentNode->FindParent(CC_RUNTIME_CLASS(Spread)); DocRect TempRect; TempRect = (IncludeBlobs ? (CurrentNode->GetUnionBlobBoundingRect()): (CurrentNode->GetBoundingRect()) ); TempRect = TempRect.Union(CurrentNode->GetEffectStackBounds()); pDoc->ForceRedraw(pSpread, TempRect, TRUE, CurrentNode, FALSE); } } return TRUE; // All ok }

virtual BOOL SelOperation::MayChangeNodeBounds (   )  const [inline, virtual]

Reimplemented from UndoableOperation. Reimplemented in OpCopy, OpGroup, OpMenuImport, OpDroppedFile, OpConvertToBitmap, OpMakeStroke, OpMenuLoad, OpBreakAtPoints, OpOverprintLine, OpOverprintFill, OpPrintOnAllPlates, OpBreakShapes, OpPutToBack, OpMoveForwards, OpMoveBackwards, OpMoveToLyrInFront, OpMoveToLyrBehind, OpCombineLayersToFrameLayer, OpChangeBlendSteps, OpApplyClipView, OpRemoveClipView, OpCreateContour, OpRemoveContour, OpChangeContourSteps, OpChangeContourColourType, OpChangeContourAttributeProfile, OpChangeContourObjectProfile, OpChangeContourStepDistance, OpConvertPathToShapes, OpToggleContourInsetPath, OpApplyLiveEffect, OpApplyFeatherEffect, OpEditLiveEffect, OpDeleteLiveEffect, OpDeleteAllLiveEffect, OpEffectRes, OpEffectLock, and OpEffectLockAll. Definition at line 137 of file selop.h. { return TRUE; }

BOOL SelOperation::ReleaseCachedForAttrApply (  NodeRenderableBounded *  pNode, BOOL  bEffectRootOnly )  [static]

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! Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 08/03/2005 Parameters: pCurrentNode  - the node that the attribute is being applied to [INPUTS] bEffectRootOnly - TRUE if Returns: TRUE if all ok. Errors: - See also: - Definition at line 737 of file attrappl.cpp. { if (bEffectRootOnly) pNode->ReleaseCached(TRUE, FALSE, FALSE, TRUE); // Parents and Derived data only else pNode->ReleaseCached(); // Self, Parents, Children and derived data return TRUE; }

---

Member Data Documentation

BOOL SelOperation::m_bStartCalled [private]

Definition at line 195 of file selop.h.

BOOL SelOperation::RenderEndSelStateBlobs [static, private]

Definition at line 199 of file selop.h.

BOOL SelOperation::RenderStartSelStateBlobs [static, private]

Definition at line 200 of file selop.h.

SelectionState* SelOperation::SelState [private]

Definition at line 191 of file selop.h.

BOOL SelOperation::UndoRenderEndSelStateBlobs [static, private]

Definition at line 201 of file selop.h.

BOOL SelOperation::UndoRenderStartSelStateBlobs [static, private]

Definition at line 202 of file selop.h.

---

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

• Kernel/selop.h (r1785/r1552)
• Kernel/attrappl.cpp (r1785/r1664)
• Kernel/attrmgr.cpp (r1785/r1445)
• Kernel/selop.cpp (r1785/r1282)

---