AttributeManager Class Reference

The attribute manager is currently responsible for managing the application of current attributes. It contains a list of Attribute groups along with instances of current attributes which belong to each group. An attribute group is identified by the RuntimeClass of an object. More...

#include <attrmgr.h>

Inheritance diagram for AttributeManager:

List of all members.

Public Types
enum	AttrsToMakeCurrent { ALL, NOT_APPLIED, NONE }
Public Member Functions
	AttributeManager ()
	~AttributeManager ()
	Attribute manager destructor Currently destroys all attributes in all attribute groups.
BOOL	InitInstance ()
	Creates the current attribute groups, and adds the initial current attributes to them.
AttrsToMakeCurrent	GetAttributesToMakeCurrent (List &Attribs, List &AttrGroupsList, BOOL bPasteAttrs)
	To determine which attributes in the Attribs list to make current. The user is prompted where neccessary.
BOOL	WeShouldMakeAttrCurrent (BOOL AttributeApplied, NodeAttribute *pAttr, List *pAttrGroupList, BOOL DroppedAttr=FALSE, BOOL AttrDroppedOntoPage=FALSE)
	To determine if we should make an attribute current or not. The routine does NOT delete the Attrib if it is not being made current.
BOOL	ApplyCurrentAttribsToNode (NodeRenderableInk *Node)
	This function determines the attribute group associated with the object and then applies all attributes in the group to the object. If the group has a base group then all attributes in the base group with types different to those already applied get added to the object etc.
NodeAttribute *	GetSelToolCurrentAttribute (CCRuntimeClass *AttrType)
	For finding current attribute pAttrType in the current attribute group specified by the currently selected tool.
NodeAttribute *	GetCurrentAttribute (CCRuntimeClass *AttrGroup, CCRuntimeClass *AttrType)
	For finding current attribute pAttrType in attribute group pAttrGroup.
void	GetCurrentLineAndFillColour (CCRuntimeClass *AttrGroup, DocColour *LineCol, DocColour *FillCol)
BOOL	WriteCurrentAttributes (BaseCamelotFilter *pFilter)
void	UpdateForDeletedColours (ColourList *ParentList)
	Called by the ColourManager when colours in use by the attribute manager may have been deleted.
Static Public Member Functions
static BOOL	InitDefaults ()
	Initialises the Attribute Manager. Registers basic attributes Declares attribute preferences When TRUE - Whenever an attribute is applied to objects the attribute becomes a current attribute. When TRUE - The user is prompted before setting a current attribute, except when the LastAttrAppliedBecomesCurrent preference is TRUE when it makes no sense to prompt the user.
static void	Deinit ()
static void	AttributeSelected (NodeAttribute *Attrib, NodeAttribute *OldAttr=NULL)
	This function should be called whenever an attribute is selected by the user.
static void	AttributesSelected (List &AttribsToApply, UINT32 OpName)
	This high level function should be called whenever we need to apply multiple attributes to the selection (eg. PasteAttributes).
static void	ApplyAttribToNode (NodeRenderableInk *InkNode, NodeAttribute *NewAttr)
	Replaces an attribute within a specified Ink Node.
static void	ReplaceAttributes (NodeAttribute *Attrib, List *OldAttrs)
static void	UpdateCurrentAttr (NodeAttribute *Attr, BOOL Mutate, List *pAttrGroupList, BOOL TellWorld=TRUE)
	Adds Attr to all attribute groups in the AttrGroupList. If the list is empty then the attribute gets added to the attribute group associated with the selected tool.
static BOOL	UpdateCurrentAppliedAttr (NodeAttribute *pAttr, List *pAttrGroupList, BOOL bAttrApplied, BOOL bMutate)
static BOOL	UpdateAfterAttrApplied (NodeAttribute *pAttr)
static BOOL	CanBeAppliedToSelection (NodeAttribute *Attrib, List *pAttrGroups)
	This function would ideally live in the SelRange. It determines if the attribute can be applied to at least one object in the selection.
static BOOL	CanBeAppliedToNode (NodeRenderableInk *pObject, NodeAttribute *Attrib, List *pAttrGroups)
	This function would ideally live in the SelRange. It determines if the attribute can be applied to a specified object.
static void	FindDefaultColour (ColourList *ColList, UINT32 NameResID, DocColour *Result)
static UINT32	RegisterDefaultAttribute (CCRuntimeClass *pNodeType, AttributeValue *pValue)
static AttributeEntry *	GetDefaultAttributes ()
	Get a copy of all the default attributes. This is used by render regions and import filters to initialise themselves to a sensible default state.
static NodeAttribute *	GetDefaultAttribute (AttrIndex AttrID)
static AttributeValue *	GetDefaultAttributeVal (AttrIndex AttrID)
static BOOL	GetDefaultAttribute (AttrIndex aiToGet, AttributeValue *pavReturn)
	Gets the default value of a particular attribute.
static UINT32	GetNumAttributes ()
	Find out how many attributes have been registered with the attribute manager. This also tells you how long the default attribute array is as returned by AttributeManager::GetDefaultAttributes.
static BOOL	ApplyBasedOnDefaults (Node *Target, AttributeEntry *AttrsToApply)
	Given a set of attributes, apply the ones that differ from the defaults to the specified node. Most commonly used by import filters.
static NodeAttribute *	GetOtherAttrToApply (NodeAttribute *AttrApplied, BOOL *IsMutate)
Static Public Attributes
static BOOL	LastAttrAppliedBecomesCurrent = 1
static BOOL	AskBeforeSettingCurrentAttr = 0
static BOOL	ShouldAskAboutContoneColours = 1
static BOOL	HaveAskedAboutContoneColours = 0
static BOOL	UserCancelledContoneColours = 0
static BOOL	SendMessages = 1
static DocColour	DefaultBlack = DocColour(0L, 0L, 0L)
static DocColour	DefaultWhite = DocColour(255L, 255L, 255L)
static NodeRenderableInk *	pLastNodeAppliedTo = NULL
static DocRect	LastAppliedBounds = DocRect(0,0,0,0)
Private Member Functions
BOOL	CreateCurrentAttributeGroup (CCRuntimeClass *AttrGroup, CCRuntimeClass *BaseGroup, String_256 &GrpName)
	This fn creates a new AttributeGroup. An AttributeGroup will contain a set of current attributes which get applied to new objects which are associated with the group.
NodeAttribute *	UpdateCurrentAttribute (CCRuntimeClass *AttrGroup, NodeAttribute *Attribute, BOOL fCheckTransparency=TRUE, BOOL DefiningGroups=FALSE, BOOL TellWorld=TRUE, BOOL bForceNewValue=FALSE)
	This function Adds Attribute to the specified AttrGroup.
AttributeGroup *	GetAttributeGroup (CCRuntimeClass *GroupID)
	This function obtains a pointer to the requested group.
void	AddAttributeToGroup (AttributeGroup *pAttrGroup, NodeAttribute *Attribute, BOOL fCheckTransparency, BOOL TellWorld=TRUE, BOOL bRetainValues=FALSE)
	This function is a helper for AttributeManager::UpdateCurrentAttribute. it adds the specified attribute to the specified Attribute group. and BROADCASTS a CurrentAttrChangedMsg message.
BOOL	WriteCurrentAttributeGroupRecord (BaseCamelotFilter *pFilter, AttributeGroup *pGroup)
Static Private Member Functions
static void	ApplyAttribToNodeHelper (NodeRenderableInk *InkNode, NodeAttribute *NewAttr)
	Replaces an attribute within a specified Ink Node.
static BOOL	RegisterBasicAttributes ()
	Register all the 'built-in' rendering attributes that Camelot has. This allows us to register these basic attributes first and in a known order, so we can use a constant instead of a variable to access them, thus allowing us to get to these attributes quicker.
static BOOL	EnsureTableSpaceAvailable ()
Private Attributes
List	AttrGroupList
Static Private Attributes
static AttributeEntry *	DefaultAttrValues = NULL
static NodeTypeEntry *	DefaultNodeAttrs = NULL
static UINT32	NumAttributes = 0
static UINT32	AttributeTableSize = 0
Friends
class	BaseCamelotFilter

---

Detailed Description

The attribute manager is currently responsible for managing the application of current attributes. It contains a list of Attribute groups along with instances of current attributes which belong to each group. An attribute group is identified by the RuntimeClass of an object.

Author:

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

Date:

29/11/93

Each Document should have its own set of current attributes

It has been extended to store default attribute information by Tim

See also:

-

Definition at line 215 of file attrmgr.h.

---

Member Enumeration Documentation

enum AttributeManager::AttrsToMakeCurrent

Enumerator: ALL  NOT_APPLIED  NONE  Definition at line 255 of file attrmgr.h. { ALL, NOT_APPLIED, NONE };

---

Constructor & Destructor Documentation

AttributeManager::AttributeManager (   )

Definition at line 199 of file attrmgr.cpp. { }

AttributeManager::~AttributeManager (   )

Attribute manager destructor Currently destroys all attributes in all attribute groups. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 19/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1069 of file attrmgr.cpp. { // Delete all groups AttributeGroup* CurrentGroup = (AttributeGroup*)AttrGroupList.GetHead(); NodeAttribute* CurrentAttr; NodeAttribute* NextAttr; while (CurrentGroup != NULL) { // Delete all attributes in the group CurrentAttr = CurrentGroup->AttrListHd;// get pointer to first attribute in the // group while (CurrentAttr != NULL) { NextAttr = (NodeAttribute*)CurrentAttr->FindNext(); delete CurrentAttr; CurrentAttr = NextAttr; } delete (AttrGroupList.RemoveItem((ListItem*)CurrentGroup)); CurrentGroup =(AttributeGroup*)AttrGroupList.GetHead(); // Get next group } }

---

Member Function Documentation

void AttributeManager::AddAttributeToGroup (  AttributeGroup *  pAttrGroup, NodeAttribute *  Attribute, BOOL  fCheckTransparency, BOOL  TellWorld = TRUE, BOOL  bRetainValues = FALSE )  [private]

This function is a helper for AttributeManager::UpdateCurrentAttribute. it adds the specified attribute to the specified Attribute group. and BROADCASTS a CurrentAttrChangedMsg message. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/95 Parameters: pAttrGroup,:  The attribute group to add the attribute to [INPUTS] Attribute: The attribute to add fCheckTransparency if TRUE (the default) then the attribute will be tested on insertion into the tree as to whether it needs transparency mode. This is prevented upon Camelot initialisation, when default attributes are inserted in the tree. TellWorld: Broadcast a CurrentAttrChangedMsg Returns: Errors: - Scope: private See also: AttributeManager::UpdateCurrentAttribute Definition at line 1543 of file attrmgr.cpp. { // Add Attribute to the group if (pAttrGroup->AttrListHd != NULL) Attribute->AttachNode(pAttrGroup->AttrListHd, NEXT, fCheckTransparency); else pAttrGroup->AttrListHd = Attribute; // If this is a Fill Attribute then we need to make sure its // in a sensible state. if (Attribute->IsAFillAttr()) { AttrFillGeometry* Fill = (AttrFillGeometry*)Attribute; // Ensure that all it's control points are deselected, else // when it is applied to an object, the user may get confused. Fill->DeselectAll(); if (!bRetainValues && Fill->GetBoundingRect().IsEmpty()) { // If the bounding box is Empty then we know that this // fill has never been applied to an object before. // We ensure that it's control points are Null, so // they will be set to some sensible default (centre of // the object usually) when eventually applied. DocCoord coord; Fill->SetStartPoint( &coord ); Fill->SetEndPoint( &coord ); Fill->SetEndPoint2( &coord ); } } // Tell everyone that the Current Attributes have Changed. if (TellWorld) { BROADCAST_TO_ALL(CurrentAttrChangedMsg()); } }

void AttributeManager::ApplyAttribToNode (  NodeRenderableInk *  InkNode, NodeAttribute *  NewAttr )  [static]

Replaces an attribute within a specified Ink Node. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/1/94 Parameters: InkNode,:  The Ink node whos attribute is to be changed. [INPUTS] NewAttr: The new attribute that is to replace the Ink Nodes expisting one. See also: AttributeManager::AttributeSelected; AttributeManager::ReplaceAttributes Definition at line 3398 of file attrmgr.cpp. { // need to check the case where the selected node ApplyAttribToNodeHelper(InkNode, NewAttr); // We only need to tell everyone if the node is within the selection if (InkNode != NULL && (InkNode->IsSelected() || InkNode->IsChildOfSelected()) && SendMessages) { // Inform the selection that attributes have changed SelRange* Sel = GetApplication()->FindSelection(); if (Sel) Sel->AttrsHaveChanged(); if (NewAttr->IsKindOf(CC_RUNTIME_CLASS(AttrColourChange)) ) { // If the Attrib was a Colour Mutator, then we must have changed a colour // so lets tell someone about it BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::COLOURATTCHANGED)); } else { // 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)); if (Sel) Sel->UpdateBounds(); } // 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. if (Sel) Sel->BroadcastAnyPendingMessages(); } delete NewAttr; }

void AttributeManager::ApplyAttribToNodeHelper (  NodeRenderableInk *  InkNode, NodeAttribute *  NewAttr )  [static, private]

Replaces an attribute within a specified Ink Node. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 28/1/94 Parameters: InkNode,:  The Ink node whos attribute is to be changed. [INPUTS] NewAttr: The new attribute that is to replace the Ink Nodes expisting one. Scope: private See also: AttributeManager::AttributeSelected; AttributeManager::ReplaceAttributes Definition at line 3458 of file attrmgr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BOOL ApplyAttribute = FALSE; List AttrGroupList; pLastNodeAppliedTo = NULL; if (InkNode != NULL && NewAttr != NULL) { ApplyAttribute = CanBeAppliedToNode(InkNode, NewAttr, &AttrGroupList); } if (ApplyAttribute) { // Obtain a pointer to the op descriptor for the attribute operation OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpApplyAttribToNode)); // Get the number of selected fill control points, 'cus we may want to do // something different depending on how many their are. #ifdef BUILDSHADOWS // New check which will only be done in BUILDSHADOWS if(InkNode->IS_KIND_OF(NodeShadow)) { AttrFillGeometry::SelectionCount = 1; } else #endif { AttrFillGeometry::SelectionCount = AttrFillGeometry::CountSelectionControlPoints(); } // Removed the following section as we can do this now /* if (IS_A(NewAttr, AttrColourDrop)) { if (IS_A (InkNode, NodeBitmap)) { // Ask the user wether or not they want to use a 24bit copy of the BMP or use the Default Bitmap? //InformWarning(_R(IDS_BFX_BMP_CONVERT_MSG),_R(IDS_OK),0,0,0,1,2); NodeBitmap* pBitmap = (NodeBitmap*) InkNode; if (pBitmap->GetBitmap ()->ActualBitmap->GetBitmapInfoHeader ()->biBitCount == 32) { // we don't want the code to fire if were trying to apply a nocolour attribute .... BOOL isNoColour = FALSE; isNoColour = (((FlatFillAttribute*) NewAttr->GetAttributeValue ())->GetStartColour ()->IsTransparent ()); if (!isNoColour) { // Load and build the question text. String_256 QueryString(_R(IDS_QUERYTRANSP322)); // The only way of bringing up a box with a string in it Error::SetError(0, QueryString, 0); INT32 DlgResult = InformMessage(NULL, _R(IDS_YES), _R(IDS_NO)); Error::ClearError(); switch (DlgResult) { case 2: // NO return; // break out of this stuff! } } } } } */ // Invoke the operation, passing Attrib as a parameter OpParam tempParam((void *)InkNode,(void *)NewAttr); OpDesc->Invoke(&tempParam); } Document* CurrentDoc = Document::GetSelected(); if (CurrentDoc == NULL) return; // We are not going to be able to do anything if there is no document AttributeManager& AttrMgr = CurrentDoc->GetAttributeMgr(); if (AttrMgr.WeShouldMakeAttrCurrent(ApplyAttribute, NewAttr, &AttrGroupList, TRUE, // Drag n' drop InkNode == NULL)) // Dropped onto page { UpdateCurrentAttr(NewAttr, NewAttr->IsAFillAttr(), &AttrGroupList); // Some Attributes require a second attribute to be changed as well. BOOL IsMutate; NodeAttribute* pOther = AttributeManager::GetOtherAttrToApply(NewAttr, &IsMutate); if (pOther != NULL) { UpdateCurrentAttr(pOther, IsMutate, &AttrGroupList); // can't have a NULL AttrGroupList // or it will apply to tools list } if (pOther) { delete pOther; } } // Don't forget the AttrGroupList AttrGroupList.DeleteAll(); #endif }

BOOL AttributeManager::ApplyBasedOnDefaults (  Node *  Target, AttributeEntry *  AttrsToApply )  [static]

Given a set of attributes, apply the ones that differ from the defaults to the specified node. Most commonly used by import filters. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/04/94 Parameters: Target  - the node to apply the attributes to. [INPUTS] AttrsToApply - the attribute array to apply to this node. Returns: TRUE if attributes applied to nodes successfully; FALSE if otherwise. Errors: Out of memory. Definition at line 2287 of file attrmgr.cpp. { // Cycle through each type of attribute, and add it if: // (a) It is of a type that can take the attribute, and // (b) the attribute is different to the default attribute. // There is a short cut for telling if the attribute has been changed from the default; // if the pointer to the attribute is still the same as our copy, then it can't have // changed // ****** Bodge ******** // We must make the Line and Fill colours in the Default Attrs // into Index colours in the Current Document !! /* DocColour DefBlack; FindDefaultColour(ColourManager::GetCurrentColourList(), _R(IDS_BLACKNAME), &DefBlack); ((StrokeColourAttribute*)DefaultAttrValues[ATTR_STROKECOLOUR].pAttr)->SetStartColour(&DefBlack); ((FillGeometryAttribute*)DefaultAttrValues[ATTR_FILLGEOMETRY].pAttr)->SetStartColour(&DefBlack); */ // ****** End Bodge ******** for (INT32 i = NumAttributes - 1; i >= 0; i--) { // Has it changed, and is it of the right node type? if (!AttrsToApply[i].Ignore && (DefaultAttrValues[i].pAttr != AttrsToApply[i].pAttr) && (Target->IsKindOf(DefaultNodeAttrs[i].pNodeType))) { // This node can take this type of attribute. if ((DefaultAttrValues[i].pAttr == NULL) || (AttrsToApply[i].pAttr->GetRuntimeClass() != DefaultAttrValues[i].pAttr->GetRuntimeClass()) || AttrsToApply[i].pAttr->IsDifferent(DefaultAttrValues[i].pAttr)) { // The attribute is different to the default - construct the appropriate // attribute node. Node *pNode = AttrsToApply[i].pAttr->MakeNode(); // Enough memory? if (pNode == NULL) return FALSE; // Add it to the target pNode->AttachNode(Target, FIRSTCHILD); } } } // All default attributes processed ok. return TRUE; }

BOOL AttributeManager::ApplyCurrentAttribsToNode (  NodeRenderableInk *  Node  )

This function determines the attribute group associated with the object and then applies all attributes in the group to the object. If the group has a base group then all attributes in the base group with types different to those already applied get added to the object etc. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 19/8/94 Returns: FALSE if we run out of memory See also: NodeRenderableInk::GetCurrentAttribGroup AttributeManager::CreateCurrentAttributeGroup AttributeManager::UpdateCurrentAttribute Definition at line 1740 of file attrmgr.cpp. { ERROR3IF(Node == NULL, "NULL object passed to AttributeManager::ApplyCurrentAttribsToNode"); // Find the attribute group that contains the attributes we need to initially apply to the // node. CCRuntimeClass* IDCurrentAttrGroup = Node->GetCurrentAttribGroup(); ERROR3IF (IDCurrentAttrGroup == NULL, "Object has NULL attribute group associated with it"); // We need to find out quickly if an attribute has already been applied to Node // Maps Attribute types to TRUE/FALSE values CCAttrMap* pAppliedAttrsMap; try { pAppliedAttrsMap = new CCAttrMap(30); } catch( ... ) { return FALSE; } // Loop back here to apply base group attributes do { // Search for IDCurrentAttrGroup AttributeGroup* CurrentGrp = (AttributeGroup*)AttrGroupList.GetHead(); while (CurrentGrp != NULL) { if (CurrentGrp->AttrGroup == IDCurrentAttrGroup) // Found the group { // Create a copy of each attribute and add it as a child of Node NodeAttribute* CurrentAttrib = CurrentGrp->AttrListHd; while (CurrentAttrib != NULL) { // Has an attribute of the same type already been applied to the node, // this should only ever be the case if we are applying attributes from a base group !. CCRuntimeClass* CurrentAttrType = CurrentAttrib->GetAttributeType(); void* NotUsed; if( !pAppliedAttrsMap->Lookup( CurrentAttrType, NotUsed ) && Node->RequiresAttrib( CurrentAttrib ) ) { // Ensure the nodes bounding box is up to date, so that fill // attributes can be scaled correctly. Node->InvalidateBoundingRect(); DocRect NodeBounds = Node->GetBoundingRect(TRUE); // Take a copy of the attribute NodeAttribute* AttribClone = (NodeAttribute*)CurrentAttrib->SimpleCopy(); ERRORIF(!AttribClone, _R(IDE_NOMORE_MEMORY), FALSE); // Scale and move the attributes bounds so that it is ready to apply to the // new object. AttribClone->TransformToNewBounds(NodeBounds); // Attach AttribClone to Node AttribClone->AttachNode(Node, FIRSTCHILD); if (AttribClone->GetAttributeType() == CC_RUNTIME_CLASS(AttrFillGeometry) || AttribClone->GetAttributeType() == CC_RUNTIME_CLASS(AttrTranspFillGeometry)) { // 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*)AttribClone)->AttributeChanged(); } // end if // Add the attributes type to the applied attributes map so that it does not get // applied again. pAppliedAttrsMap->SetAt(CurrentAttrType, NULL); } CurrentAttrib = (NodeAttribute*)CurrentAttrib->FindNext(); } // ok now apply attributes from the base group, if one exists IDCurrentAttrGroup = CurrentGrp->BaseGroup; break; } CurrentGrp = (AttributeGroup *) AttrGroupList.GetNext(CurrentGrp); ERROR3IF(CurrentGrp == NULL, "Unable to find attribute group"); } // break takes us here } while (IDCurrentAttrGroup != NULL); delete pAppliedAttrsMap; // Map no longer required return TRUE; }

void AttributeManager::AttributeSelected (  NodeAttribute *  Attrib, NodeAttribute *  OldAttr = NULL )  [static]

This function should be called whenever an attribute is selected by the user. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: Attrib,:  The selected attribute. All attributes of the same type in the [INPUTS] selection will be replaced with this attribute. Don't delete this it may become a current attribute. New Bits Added by Will: When NULL this indicates that the OldAttr parameter should act as a Mutator. A Mutator will change all the fill attributes in the selection to be the same 'type' as the mutator, whilst retaining their individual control points and colours. A special kind of Mutator, 'AttrColourChange' will force all objects in the selection to change their selected control point colours, or to 'Mutate'into an 'AttrFlatFill' if there are no selected control points anywhere in the selection. A Mutator must be derived from AttrFillGeometry. OldAttr: When no-null, this specifies the node which 'Attrib' is to replace. It is used when an attribute is edited. When Attrib == NULL, this specifies a Mutator (see above). Intermediate: TRUE when we expect someone to call AttributeSelected again after this call with the same attr types, same selection and Intermediate set to FALSE If any nodes are selected the function invokes an operation to apply the attribute to the selected nodes. If no nodes are selected then the attribute may become a current attribute depending on the preferences. Returns: Errors: - See also: AttributeManager::ReplaceAttributes; AttributeManager::ApplyAttribToNode Definition at line 2389 of file attrmgr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ENSURE( (Attrib != NULL || OldAttr != NULL), "NULL attributes passed to AttributeSelected"); BOOL Mutate = (Attrib == NULL); AttrFillGeometry* Mutator = NULL; pLastNodeAppliedTo = NULL; // If parameter one is NULL then we must be doing a Mutation if (Mutate) { ERROR3IF(!OldAttr->IsAFillAttr(), "A Mutator must be a fill attribute"); // Make a more sensible pointer Mutator = (AttrFillGeometry*)OldAttr; } // If there are any objects selected then the attribute needs to be applied to these objects // OpDescriptor* OpDesc = NULL; // BOOL MakeAttrCurrent = FALSE; // until we know better SelRange* Sel = GetApplication()->FindSelection(); ERROR3IF(Sel==NULL,"Can't find SelRange!"); if (Sel==NULL) return; // If there are no objects in the selection, or if none of the selected objects require // the attribute, then it will not be applied BOOL ApplyAttribute; List AttrGroupList; if (Attrib != NULL) { ApplyAttribute = CanBeAppliedToSelection(Attrib, &AttrGroupList); } else { ERROR3IF(OldAttr == NULL, "What are we applying then exactly ??"); ApplyAttribute = CanBeAppliedToSelection(OldAttr, &AttrGroupList); // Mutator } if (ApplyAttribute) { // We need to invoke an operation to apply the attribute to the currently selected // objects. // Get the number of selected fill control points, 'cus we may want to do // something different depending on how many their are. AttrFillGeometry::SelectionCount = AttrFillGeometry::CountSelectionControlPoints(); // Obtain a pointer to the op descriptor for the attribute operation BOOL bApplying = TRUE; OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpApplyAttribToSelected)); // But first ... Was the pervious Op the same ? Operation* pLastOp = Document::GetSelected()->GetOpHistory().FindLastOp(); if (Mutate && pLastOp && pLastOp->GetRuntimeClass() == CC_RUNTIME_CLASS(OpApplyAttribToSelected)) { // The last operation was similar to this one, but was it exactly the same type ? OpApplyAttribToSelected* pLastApplyOp = (OpApplyAttribToSelected*)pLastOp; if (pLastApplyOp->GetValueChangeType() == Mutator->GetRuntimeClass() && pLastApplyOp->IsMergeableApplyOp()) { // Yep, they are exactly the same type of value change. // So we don't need to do an undoable op for this new change, // we can just invoke a special op that will change the attributes // directly. // But first ... Is the selection still the same ? RestoreSelectionsAction* pRestoreSelAct = (RestoreSelectionsAction*) pLastApplyOp->GetUndoActionList()->FindActionOfClass(CC_RUNTIME_CLASS(RestoreSelectionsAction)); SelectionState* LastOpsSelection = pRestoreSelAct->GetSelState(); SelectionState CurrentSelection; CurrentSelection.Record(); if (*LastOpsSelection == CurrentSelection) { FillBlobSelectionState CurrentFillBlobState; CurrentFillBlobState.Record(); if (OpRepeatApplyAttribToSelected::FillBlobState == CurrentFillBlobState) { OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpRepeatApplyAttribToSelected)); bApplying = FALSE; } } } } // Invoke the operation, passing Attrib as a parameter OpParam tempParam((void *)Attrib,(void *)OldAttr); OpDesc->Invoke(&tempParam); // Remember the current blob selection state, so we can decide whether or not to // merge future apply operations if (bApplying) OpRepeatApplyAttribToSelected::FillBlobState.Record(); UpdateAfterAttrApplied(Mutate ? Mutator : NULL); } BOOL bCurrentUpdated = UpdateCurrentAppliedAttr(Mutate ? Mutator: Attrib, &AttrGroupList, ApplyAttribute, Mutate); if (!bCurrentUpdated) { // Allow fill tools to update after a cancel BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED)); } // Tidy up attributes because they were only patterns and are no longer needed if (Mutate) { if (Mutator != NULL) { delete Mutator; Mutator = NULL; } } if (Attrib != NULL) { delete Attrib; Attrib = NULL; } // Don't forget the AttrGroupList AttrGroupList.DeleteAll(); // 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(); #endif }

void AttributeManager::AttributesSelected (  List &  AttribsToApply, UINT32  OpName )  [static]

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 2634 of file attrmgr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // The AttributeList cannot be empty ERROR3IF(AttribsToApply.IsEmpty(), "No attributes to apply in AttributeManager::AttributesSelected"); if (AttribsToApply.IsEmpty()) return; // 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; // 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; // If there are no objects in the selection, or if none of the selected objects require // the attribute, then it will not be applied // Obtain a pointer to the op descriptor for the operation OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpApplyAttribsToSelected)); 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 operation OpDesc->Invoke(&OpParam); 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(); AttrsToMakeCurrent AttribsToMakeCurrent = AttrMgr.GetAttributesToMakeCurrent(AttribsToApply, AttrGroupsList, FALSE); if (AttribsToMakeCurrent == 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 == 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. 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(); #endif }

BOOL AttributeManager::CanBeAppliedToNode (  NodeRenderableInk *  pObject, NodeAttribute *  Attrib, List *  pAttrGroups )  [static]

This function would ideally live in the SelRange. It determines if the attribute can be applied to a specified object. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/95 Parameters: Attrib,:  The attribute [INPUTS] AttrGroups,:  If the object requires Attrib then this list is updated to [OUTPUTS] include the current attribute group that the attribute should be added to if it were to be made current. This list should be passed in as a parameter to UpdateCurrentAttr. Returns: TRUE if the object requires Attrib See also: AttributeManager::CanBeAppliedToSelection; AttributeManager::AttributeSelected; AttributeManager::UpdateCurrentAttr Definition at line 3283 of file attrmgr.cpp. { BOOL RequiresAttrib = FALSE; CCRuntimeClass* NewAttrGroup; CCRuntimeClass* InSetAttrGroup; // One that's already in the list AttributeGroupItem* pAttrGrpItem; BOOL InSet; NodeRenderableInk* Current = pObject; if (Current != NULL) { if (Current->RequiresAttrib(Attrib)) { RequiresAttrib = TRUE; // Obtain the attribute group NewAttrGroup = Current->GetCurrentAttribGroup(); ERROR3IF(NewAttrGroup == NULL, "Object has a NULL attribute group"); InSet = FALSE; // Search the AttrGroups set to see if it's already there pAttrGrpItem = (AttributeGroupItem*)pAttrGroups->GetHead(); while(pAttrGrpItem != NULL) { 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*)pAttrGroups->GetNext(pAttrGrpItem); } if (!InSet) // The AttrGroup needs adding to the pAttrGroups set { // Create a new AttrGroupItem pAttrGrpItem = new AttributeGroupItem(); if (pAttrGrpItem == NULL) return FALSE; // Panic !! pAttrGrpItem->AttrGroup = NewAttrGroup; // And add it to our set pAttrGroups->AddHead(pAttrGrpItem); // Most recent at start of list. } } } return RequiresAttrib; }

BOOL AttributeManager::CanBeAppliedToSelection (  NodeAttribute *  Attrib, List *  pAttrGroups )  [static]

This function would ideally live in the SelRange. It determines if the attribute can be applied to at least one object in the selection. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 5/4/95 Parameters: Attrib,:  The attribute [INPUTS] AttrGroups,:  If any of the selected objects requires Attrib then this list [OUTPUTS] is a set of all current attribute groups that the attribute should be added to if it were to be made current. This list should be passed in as a parameter to UpdateCurrentAttr. If there are no objects in the selection, or if none of the selected objects requires the attribute then this list will be empty on return. UpdateCurrentAttr handles this case by adding the attribute to the attribute group associated with the selected tool. Returns: TRUE if at least one object requires Attrib See also: AttributeManager::AttributeSelected AttributeManager::UpdateCurrentAttr Definition at line 3231 of file attrmgr.cpp. { #if !defined(EXCLUDE_FROM_RALPH) SelRange* Sel = GetApplication()->FindSelection(); BOOL RequiresAttrib = FALSE; // Go though all the selected nodes NodeRenderableInk* Current = (NodeRenderableInk*)Sel->FindFirst(); while (Current != NULL) { // See if this node requires the attribute if (CanBeAppliedToNode(Current, Attrib, pAttrGroups)) { RequiresAttrib = TRUE; if ((