Beispiel #1
0
void CCAttrMap::TransformForBrush(TransformBase& Trans)
{
	CCRuntimeClass	   *pType;
	void			   *pVal;
	for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); )
	{
		GetNextAssoc(Pos,pType,pVal);
		if (pVal != NULL)
		{
			NodeAttribute* pNodeAttr = (NodeAttribute *)pVal;
			
			// check that we are not about to set line width to zero
			if( pNodeAttr->IsALineWidthAttr() && Trans.TransLines != FALSE )
			{
				double Test =  Trans.GetScalar().MakeDouble() * (double)((AttrLineWidth*)pNodeAttr)->Value.LineWidth;
		//		TRACEUSER( "Diccon", _T("Scale line width by %f\n"), Test);
				if (Test <= 1.0)
				{
				//	TRACEUSER( "Diccon", _T("Setting line width scaling OFF\n"));
					Trans.TransLines = FALSE;
				}
			}

			if (pNodeAttr->NeedsToRenderAtEachBrushStroke())
				pNodeAttr->Transform(Trans);
		}
	}
}
Beispiel #2
0
void CCAttrMap::TransformBrushFills(TransformBase& Trans)
{
	CCRuntimeClass	   *pType;
	void			   *pVal;
	for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); )
	{
		GetNextAssoc(Pos,pType,pVal);
		if (pVal != NULL)
		{
			NodeAttribute* pNodeAttr = (NodeAttribute *)pVal;
			
			// check that we are not about to set line width to zero
			if( pNodeAttr->IsALineWidthAttr() && Trans.TransLines != FALSE )
			{
				INT32 Test = labs( INT32(Trans.GetScalar().MakeDouble() * ((AttrLineWidth*)pNodeAttr)->Value.LineWidth) );		
				if (Test <= 10)
					Trans.TransLines = FALSE;
			}

			if (!pNodeAttr->NeedsToRenderAtEachBrushStroke())
				pNodeAttr->Transform(Trans);
		}
	}


}
Beispiel #3
0
CCAttrMap* CCAttrMap::Copy()
{
	CCAttrMap		   *pNewAttrMap = new CCAttrMap( GetCount() );
	if( pNewAttrMap != NULL )
	{
		// iterating all (key, value) pairs
		for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); )
		{
			CCRuntimeClass *pType;
			void	   *pVal;
			GetNextAssoc( Pos, pType, pVal );

			// Get the attribute value of this attribute
			NodeAttribute* pAttr = (NodeAttribute*)pVal;

			// Copy the attribute
			NodeAttribute* pNewAttr = (NodeAttribute*) (pAttr->SimpleCopy());

			// Stick the new attr into the new attr map
			if (pNewAttr != NULL)
				pNewAttrMap->SetAt(pNewAttr->GetAttributeType(),pNewAttr);
		}
	}

	pNewAttrMap->attrMapCreator = attrMapCreator;

	return pNewAttrMap;
}
Beispiel #4
0
void ERModel::reBuildPrimaryKeyFromAttribute( int attributeID, int entityID )
{
	NodeAttribute* attributeNode = static_cast<NodeAttribute*>(searchComponent(attributeID));
	NodeEntity* entityNode = static_cast<NodeEntity*>(searchComponent(entityID));

	attributeNode->setIsPrimaryKey(true);
	entityNode->setPrimaryKey(attributeID);
}
Beispiel #5
0
void NodeRenderableInk::DeleteFactoredOutAttribs(BOOL Global, AttrTypeSet* pAffectedAttrTypes)
{
	Node* pGroupNode = FindFirstChild(); 
	while(pGroupNode!=NULL)
	{
		// Karim 30/08/2000
		// Non-optimisable attributes, like feathers and names,
		// must not be automatically deleted - only automatically delete optimisable ones.
		if (pGroupNode->IsAnAttribute() && ((NodeAttribute*)pGroupNode)->ShouldBeOptimized())
		{
			NodeAttribute* pGroupAttr = (NodeAttribute*)pGroupNode;
			CCRuntimeClass* GrouptAttrType = pGroupAttr->GetAttributeType();
			if (pAffectedAttrTypes==NULL || pAffectedAttrTypes->InSet(GrouptAttrType))
			{
				// delete this group attr type from all child objects of this group
				// BUT if obj discards child attrs only delete attr if it also has same value
				for (Node* pNode=FindFirstChild(); pNode!=NULL; pNode=pNode->FindNext())
				{
					if (pNode->IsAnObject())
					{
						NodeRenderableInk* pObject = (NodeRenderableInk*)pNode;
						NodeAttribute* pDeadAttr = pObject->GetChildAttrOfType(GrouptAttrType);
						if (pDeadAttr!=NULL)
						{
							// This code used to only test the attribute for equality if pObject
							// returned TRUE from DiscardsAttributeChildren, otherwise it would 
							// just assume that they are identical and delete it.
							// The DiscardAttributeChildren checks are now done elsewhere so 
							// this code now just assumes it can delete any attributes that have 
							// got this far.
							// This optimisation relies on the tree being in a "legal" state 
							// at the start (i.e. correctly optimised) and also helps to correct 
							// problems where attributes may have been incorrectly left on children
							// (though such "corrections" may change the appearance of the document).

							pDeadAttr->CascadeDelete(); 
							delete pDeadAttr;	
						}
					}
				}
			}
		}
		pGroupNode = pGroupNode->FindNext(); 		
	}

	// Do we need to delete any parent compound's attributes
	if (Global)
	{
		Node* pParent = FindParent(); 
		if (pParent && (pParent->IsCompound()))
		{
			// We need to delete the parent's attributes first  (Recursive bit)
			((NodeRenderableInk*)pParent)->DeleteFactoredOutAttribs(Global, pAffectedAttrTypes); 
		}
	}
} 
Beispiel #6
0
void NodeRenderableInk::NormaliseAttributes()
{

	NodeAttribute* ChildAttribute;	   
	NodeAttribute* GlobalAttribute;

	Node* LocalScan;
	Node* NextLocal;  
	
	// Scan the child attribute block
	LocalScan = FindFirstChild();
	// Stop if we hit an object or if there are no more children 
	// NOTE: Stopping scanning when we find the first RendereblInk node prevents
	// Effect attributes being Normalised. THIS IS DELIBERATE!
	while((LocalScan != NULL) && (!LocalScan->IsAnObject())) 
	{
		// Hand over hand (LocalScan may get deleted)
		NextLocal = LocalScan->FindNext();
		if(LocalScan->IsAnAttribute() && ((NodeAttribute*)LocalScan)->ShouldBeOptimized())	// cos it could be a NodeHidden
		{
			ChildAttribute = (NodeAttribute*)LocalScan;  
			// We now need to search up the tree to see if ChildAttribute is redundant
//		   	Node* GlobalScan = FindPreviousEffectiveNode();
			Node* GlobalScan = NodeAttribute::FindPrevAppliedAttr(this);
			// Search until we can go no higher
			while (GlobalScan != NULL)
			{
				if (GlobalScan->IsAnAttribute())
				{
					GlobalAttribute = (NodeAttribute*)GlobalScan; 
					// An attribute has been found, is it the same class as ChildAttribute ?
					if(GlobalAttribute->GetRuntimeClass() ==
					   ChildAttribute->GetRuntimeClass())
					{
						// Yes it is, so let's check if they are equal
						if ((*GlobalAttribute)==(*ChildAttribute))
						{
							// They are equal so we can nuke the child object because it's 
							// redundant
							ChildAttribute->CascadeDelete();
							delete ChildAttribute;
						}
						break;	 // don't search any further
					}

				}
//				GlobalScan = GlobalScan->FindPreviousEffectiveNode(); // climb higher
				GlobalScan = NodeAttribute::FindPrevAppliedAttr(GlobalScan);
			} 
		}
		LocalScan = NextLocal; // Get the next child 
	}    

}
Beispiel #7
0
void CCAttrMap::Transform(TransformBase& Trans)
{
	CCRuntimeClass	   *pType;
	void			   *pVal;
	for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); )
	{
		GetNextAssoc(Pos,pType,pVal);
		if (pVal != NULL)
		{
			NodeAttribute* pNodeAttr = (NodeAttribute *)pVal;
			pNodeAttr->Transform(Trans);
		}
	}
}
Beispiel #8
0
vector<pair<int, bool>> ERModel::reBuildPrimaryKey( Component* oldAttributeNode, int newEntityNodeID, int newAttributeNodeID )
{
	vector<pair<int, bool>> reBuildPrimaryKeySet;
	vector<int> primaryKey;
	NodeAttribute* tempOldAttributeNode = static_cast<NodeAttribute*>(oldAttributeNode);
	if (tempOldAttributeNode->getIsPrimaryKey())
	{
		primaryKey.push_back(newAttributeNodeID);
		setPrimaryKey(newEntityNodeID, primaryKey);
		reBuildPrimaryKeySet.push_back(make_pair(newAttributeNodeID, true));
		return reBuildPrimaryKeySet;
	}
	return reBuildPrimaryKeySet;
}
Beispiel #9
0
BOOL NodeRenderableInk::FactorOutCommonChildAttrHelper(BOOL Global, AttrTypeSet* pAffectedAttrTypes)
{
	// This function should only ever get called on a compound object
	ENSURE(IsCompound(), "FactorOutCommonChildAttributes called on a non compound object"); 

 	CommonAttrSet CommonAttributeSet; // A list of CommonAttributeItems
	
	if (!FindCommonAttributesToFactorOut(&CommonAttributeSet))	 // Ignores attr discard nodes
	{
		return FALSE;  
	} 
	
	NodeAttribute* pFactoredOutAttr;

	// Ok let's add the common attributes to the first child of the group 
	CommonAttributeItem* pCommonAttr; 
	for (pCommonAttr = (CommonAttributeItem*)CommonAttributeSet.GetHead();
		 pCommonAttr != NULL;
		 pCommonAttr = (CommonAttributeItem*)CommonAttributeSet.GetNext(pCommonAttr)) 
	{
		// Is the common attribute an attribute which should be factored out ?
		if (!pAffectedAttrTypes || (pAffectedAttrTypes->InSet(pCommonAttr->pAttr->GetAttributeType())) )
		{
			//pCommonAttr->pAttr->MoveNode(this, FIRSTCHILD);    
			// Take a copy of the node and insert it as a first child
			pFactoredOutAttr = (NodeAttribute*)(pCommonAttr->pAttr->SimpleCopy());
			if (!pFactoredOutAttr)
				return FALSE; 
			pFactoredOutAttr->AttachNode(this, FIRSTCHILD, TRUE, FALSE);
		}  
	}

	// The CommonAttributeSet is no longer required
	CommonAttributeSet.DeleteAll(); 

	// Do we need to factor out the parents attributes ?
	if (Global)
	{
		Node* pParent = FindParent();
		if (pParent && (pParent->IsCompound()))
		{
			// We need to localise the parent's attributes first  (Recursive bit)
			if (!(((NodeRenderableInk*)pParent)->FactorOutCommonChildAttrHelper(TRUE, pAffectedAttrTypes)))
			{
				return FALSE; // Failed
			} 
		}
	}
	return TRUE; // Success
}
Beispiel #10
0
WebCommonAttributeResult WebAddressDlg::FindCommonWebAttribute(WebAddressAttribute* pwaaReturn)
{	
	//First we need to get the current selection
	SelRange* pSelRange=GetApplication()->FindSelection();

	//If pSelRange doesn't exist, return No Selection
	if (!pSelRange)
		return WCA_NOSELECTION;	
	
	//Find the common Web Attribute on the selection
	Range::CommonAttribResult carResult;
	NodeAttribute* pnaApplied;
	
	carResult=pSelRange->FindCommonAttribute(CC_RUNTIME_CLASS(AttrWebAddress), &pnaApplied);
	
	//If this function has returned ATTR_NONE or ATTR_MANY, return our
	//analogous value
	if (carResult==SelRange::ATTR_NONE)
		return WCA_NOSELECTION;

	if (carResult==SelRange::ATTR_MANY)
		return WCA_MANY;

	//Otherwise, we know we have one Web Address attribute on the selection.

	//We must find out whether it is the default attribute

	//First extract the attribute value from the node we have found
	WebAddressAttribute* pWebAddressAttribute=
		(WebAddressAttribute*) pnaApplied->GetAttributeValue();

	WebAddressAttribute waaApplied=*pWebAddressAttribute;

	//And if the user wants this value returned, make a copy of it now
	if (pwaaReturn)
		*pwaaReturn=waaApplied;

	//And get the default Web Address attribute
	WebAddressAttribute waaDefault;
	if (AttributeManager::GetDefaultAttribute(ATTR_WEBADDRESS, &waaDefault))
	{
		//If they are the same, return WCA_DEFAULT. 
		//If they are different, return WCA_SINGLE
		if (!waaApplied.IsDifferent(&waaDefault))
			return WCA_DEFAULT;
	}
	
	return WCA_SINGLE;
	
}
Beispiel #11
0
BOOL LoadBrushDirect::OnLoadDocument(Document* pDoc)
{
	ERROR3IF(pDoc==NULL,"No doc pointer during PrintMarksMan::ConvertAllDocColours!");

	Node *CurNode = Node::DocFindFirstDepthFirst(pDoc);
	Node *NextNode;

	while (CurNode !=NULL)
	{
		// We may be about to chop this node out of the tree, so get the next node now
		NextNode = CurNode->DocFindNextDepthFirst();

		// Use to scan the colour fields of the attribute.
		UINT32 Context = 0;
		DocColour *pColour;

		if (CurNode->IsAnAttribute())
		{
			NodeAttribute *pNodeAttr = (NodeAttribute *) CurNode;

			// Get the next colour field from the attribute
			pColour = pNodeAttr->EnumerateColourFields(Context++);

			while (pColour != NULL)
			{
				// For each colour field, make sure the colour is a local DocColour so that
				// the sub-tree is entirely stand-alone
				if (pColour->FindParentIndexedColour() != NULL)
				{
					ColourGeneric ColDef;
					ColourContext *cc = ColourManager::GetColourContext(pColour->GetColourModel());
					ERROR3IF(cc == NULL, "Can't find colour context?!");

					// Get the IndexedColour definition as a standalone colour definition
					cc->ConvertColour(pColour->FindParentIndexedColour(), &ColDef);

					// Make the DocColour into a simple standalone "lookalike" of the parent colour
					*pColour = DocColour(pColour->GetColourModel(), &ColDef);
				}

				pColour = pNodeAttr->EnumerateColourFields(Context++);
			}
		}
		CurNode = NextNode;
	}

	// All is well we hope.
	return TRUE;
}
Beispiel #12
0
BOOL OpBackground::GetPageColour(Spread *pSpread, KernelBitmap **ppOutBitmap, 
														DocColour **ppOutColour)
{
	ERROR2IF(pSpread == NULL,FALSE,"OpBackground::GetPageColour Bad params error!");
	ERROR2IF(ppOutBitmap == NULL || ppOutColour == NULL,FALSE,"OpBackground::GetPageColour Bad params error!");

	// Search for our special page background layer
	Layer* pFoundLayer = pSpread->FindFirstPageBackgroundLayer();
	if (pFoundLayer == NULL)
		return FALSE;

	// search for our page node
	NodeRegularShape *pNode = DoFindPageRectangle(pSpread, pFoundLayer);

	if (!pNode)
		return FALSE;

	// find the fill attribute applied to the page
	NodeAttribute *pAppliedAttr = NULL;
	pNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pAppliedAttr);

	if (pAppliedAttr != NULL)
	{
		if (IS_A(pAppliedAttr, AttrFlatColourFill)) // flat colour fill?
		{
			// get the colour attribute
			ColourFillAttribute *pColAttr = (ColourFillAttribute *)(pAppliedAttr->GetAttributeValue());

			// set the colour pointer to the doc colour, and the bitmap pointer to NULL
			*ppOutBitmap = NULL;
			*ppOutColour = pColAttr->GetStartColour();

		}
		else if (IS_A(pAppliedAttr, AttrBitmapColourFill)) // bitmap fill
		{

			// set the colour pointer to NULL, and the bitmap pointer to the kernel bitmap
			*ppOutBitmap = ((AttrFillGeometry *)pAppliedAttr)->GetBitmap();
			*ppOutColour = NULL;
		}
		else
			return FALSE;
	}
	else
		return FALSE;

	return TRUE;
}
Beispiel #13
0
/********************************************************************************************

>	BOOL CCAttrMap::IsSeeThrough()

	Author:		Karim_MacDonald (Xara Group Ltd) <*****@*****.**>
	Created:	19/02/2001

	Returns:	TRUE if at least one of our attrs IsSeeThrough(),
				FALSE otherwise.

	Purpose:	Test each of the attributes in this map for see-through-ness.
				This is not the same as transparency - what it means is: if I draw something
				in white, then draw its outline as retrieved from PathBecomeA in black over
				the top, will I still be able to see white bits?
				IsSeeThrough() therefore depends partly on the implementation of PathBecomeA.

				Examples:
					Transparency is always see-through unless it is a zero transparency.
					Line width is not see through - PathBecomeA can cope with this attr.
					Fill colour is not see-through unless it is COLOUR_NONE.
					Brush attrs are normally see-through, as PathBecomeA ignores them.

	See Also:	NodeRenderableInk::IsSeeThrough()

********************************************************************************************/
BOOL CCAttrMap::IsSeeThrough()
{
	CCRuntimeClass	   *pKey;
	void			   *pVal;
	BOOL				bIsSeeThrough = FALSE;

	for ( iterator	pos = GetStartPosition();
					pos != GetEndPosition() && !bIsSeeThrough;	)
	{
		GetNextAssoc(pos, pKey, pVal);
		NodeAttribute* pAttr = (NodeAttribute*)pVal;

		bIsSeeThrough = pAttr->IsSeeThrough(FALSE);
	}

	return bIsSeeThrough;
}
Beispiel #14
0
/********************************************************************************************

>	static CCAttrMap * CCAttrMap::MakeAttrMapFromRenderRegion(RenderRegion * pRegion)

	Author:		David_McClarnon (Xara Group Ltd) <*****@*****.**>
	Created:	24/2/2000
	Inputs:		The render region to get the attribute map from
	Outputs:	An attribute map (copied) from the render region
	Returns:	-
	Purpose:	Makes an attribute out of the render region's current attribute state
	Notes:		You MUST call DeleteAttributes afterwards to release memory - delete is
				not sufficient
	SeeAlso:	-

********************************************************************************************/
CCAttrMap * CCAttrMap::MakeAttrMapFromRenderRegion(RenderRegion * pRegion)
{
	CCAttrMap * pMap = new CCAttrMap;
	ENSURE(pMap,"No mem for attrmap");
	if(!pMap)
		return NULL;

	// let's get every attribute in the render region
	AttributeValue * pAttrVal = NULL;
	NodeAttribute * pNewAttr = NULL;

	for (UINT32 i = 0; i < ATTR_FIRST_FREE_ID; i++)
	{
		pAttrVal = pRegion->GetCurrentAttribute(i);

		// make a new node out of this attribute value
		pNewAttr = pAttrVal->MakeNode();
		
		// Karim 12/04/2000
		// AttributeValues _do_not_have_to_have_ a corresponding NodeAttribute,
		// so can we please *check* that MakeNode didn't just return NULL!
		if (pNewAttr != NULL)
		{
			if(!pNewAttr->IsLinkedToNodeGeometry())
				pMap->SetAt(pNewAttr->GetAttributeType(),pNewAttr);
			else
			{
				delete pNewAttr;
				pNewAttr = AttributeManager::GetDefaultAttribute((AttrIndex) i);
				if(pNewAttr)
				{
					ENSURE(pNewAttr->IsLinkedToNodeGeometry(),"Incorrect NodeAttribute returned by GetDefaultAttribute");
					pMap->SetAt(pNewAttr->GetAttributeType(), pNewAttr);
				}
				else
					return NULL;
			}
		}
	}

	pMap->attrMapCreator = NULL;

	return pMap;
}
Beispiel #15
0
void CCAttrMap::ApplyAttributesToNode(NodeRenderableInk * pInk)
{
	iterator			pos = GetStartPosition();

	while( pos != GetEndPosition() )
	{
		CCRuntimeClass *pKey;
		void		   *pVal;
		GetNextAssoc(pos, pKey, pVal);

		NodeAttribute * pAttr = (NodeAttribute *)pVal;

		// copy the attribute
		if( pAttr->CanBeAppliedToObject() )
		{
			NodeAttribute * pAttrCopy = NULL;
			pAttr->NodeCopy((Node **)(&pAttrCopy));
			
			pAttrCopy->AttachNode(pInk, LASTCHILD);

			// nb now that GLAs have an independent flag to indicate when
			// they are copied from the default, it is safe to fix linkages
			// this ensures that GLA defaults get copied when BlendRefs are
			// made from complex nodes, and that they are found when MakeAppliedAttributes
			// calls FindAppliedAttributes on the unattached subtree
			// TODO??
			// What about just copying compound node's Parent pointers to 
			// pseudo attach the tree, rather than copying applied attrs to unattached tree
			// Just need to watch when deleting that it doesn't do anything to the
			// parents pointers - which it shouldn't surely?
			pAttrCopy->LinkToGeometry(pInk);
		}
	}
}
Beispiel #16
0
/********************************************************************************************

>	void CCAttrMap::Render(RenderRegion * pRegion, BOOL RenderOffscreenAttributes = TRUE)

	Author:		David_McClarnon (Xara Group Ltd) <*****@*****.**>
	Created:	30/4/99
	Inputs:		pRegion						render-region to render into.
				RenderOffscreenAttributes	whether or not to render offscreen attributes,
											eg feathers.
	Outputs:	-
	Returns:	-
	Purpose:	Renders the attribute map into the given render region

	Notes:		Karim 15/11/2000
				Modified so that I can render an attribute map *without*
				rendering any offscreen attributes contained therein.

	SeeAlso:	-

********************************************************************************************/
void CCAttrMap::Render(RenderRegion * pRegion, BOOL RenderOffscreenAttributes)
{
	// OK, we have found the full quota of attributes.  Now render them all.
	iterator			pos = GetStartPosition();
	while( pos != GetEndPosition() )
	{
		CCRuntimeClass *pKey;
		void		   *pVal;
		GetNextAssoc( pos, pKey, pVal );

		NodeAttribute* pAttr = (NodeAttribute*)pVal;

		if ( pAttr->CanBeAppliedToObject() &&
			 pAttr->RenderSubtree(pRegion)==SUBTREE_ROOTONLY )
		{
			// render all attributes, unless we've been specifically asked
			// not to render offscreen attributes.
			if (RenderOffscreenAttributes || !pAttr->IsAnOffscreenAttribute())
				pAttr->Render(pRegion);
		}
	}
}
Beispiel #17
0
// Required for all GLA's
void CCAttrMap::PostBlendDeinit()
{
	INT32 curr = 0;

	do
	{
		CCRuntimeClass *pType = (CCRuntimeClass *)GeometryLinkedAttributeClasses[curr];
		void		   *pVal;
				
		if( Lookup( pType, pVal ) )
		{
			if (pVal != NULL)
			{
				NodeAttribute * pAttr = (NodeAttribute *)pVal;

				pAttr->PostDynCreateDeInit();
			}
		}

		curr++;
	}
	while(curr<NumGLAs);
}
Beispiel #18
0
// Required for all GLA's
// NB must only be called on attrmaps with copied attributes
// DO NOT CALL on maps with 'live' attributes - ie pointers to attrs in the tree
// (eg a mpa made by MakeAppliedAttrMap(pInk))
void CCAttrMap::PostBlendInit(Path* pPath, CCRuntimeClass* pCreatorClass)
{
	INT32 curr = 0;

	// NB this function is called on a Blended attr map
	// The Blend() function should return false if it doesn't want to be in the blended attr map
	// ie default GLAs shouldn't be in here!

	do
	{
		CCRuntimeClass *pType = (CCRuntimeClass *)GeometryLinkedAttributeClasses[curr];
		void		   *pVal;
				
		if( Lookup( pType, pVal ) )
		{
			if (pVal != NULL)
			{
				NodeAttribute * pAttr = (NodeAttribute *)pVal;

				// call the attributes routine to initialise itself
				if(!pAttr->PostDynCreateInit(this, pPath, pCreatorClass))
				{
					// make sure the node is not going to try and render itself
					TRACEUSER( "Ilan", wxT("Dynamically created attribute failed to post init itself. Removing attribute from map.\n") );
					// NB map must contain copied attrs
					RemoveKey( pType );
					// Must cast to NodeAttribute before deleting, otherwise wrong destructor gets called
					delete (NodeAttribute*)pVal;
				}
			}
		}

		curr++;
	}
	while(curr<NumGLAs);
}
Beispiel #19
0
BOOL NodeAttribute::Blend(BlendAttrParam* pBlendParam)
{
	// Check NULL entry param
	ERROR3IF(pBlendParam == NULL,"pBlendParam == NULL");
	if (pBlendParam == NULL) return FALSE;

	// Make a copy of this node, and make this the blended attribute
	NodeAttribute* pBlendedAttr = NULL;
	NodeAttribute* pAttrToCopy  = NULL;

	if (pBlendParam->GetBlendRatio() <= 0.5)
		pAttrToCopy = this;
	else
		pAttrToCopy = pBlendParam->GetOtherAttr();

	if (pAttrToCopy != NULL)
	{
		pBlendedAttr = (NodeAttribute*) pAttrToCopy->SimpleCopy();
		pBlendParam->SetBlendedAttr(pBlendedAttr);
	}

	// Return TRUE if we were able to make a copy of this node
	return (pBlendedAttr != NULL);
}
Beispiel #20
0
INT32 AttrWebAddress::operator==(const NodeAttribute& naCompare)
{
	//If naCompare is not an AttrWebAddress, return FALSE
	if (!naCompare.IsKindOf(CC_RUNTIME_CLASS(AttrWebAddress)))
		return FALSE;

	//Otherwise, cast naCompare into an AttrWebAddress pointer
	AttrWebAddress* pwaAttr = (AttrWebAddress*) &naCompare;
			 
	//And check whether the member variables are the same
	BOOL fAreDifferent=Value.IsDifferent((AttributeValue*) &(pwaAttr->Value));

	//And return accordingly
	return (!fAreDifferent); 
} 
Beispiel #21
0
BOOL BitmapExportDocument::Init(KernelBitmap* pBitmap, const DocRect& RectToExport)
{
	// Don't attach any CCamDoc.
	if (!Document::Init(0)) return(FALSE);

	Node *pSpread = FindFirstSpread();
	ERROR3IF(pSpread == NULL, "No Spread in document!");

	Node *pLayer = pSpread->FindFirstChild();
	ERROR3IF(pLayer == NULL, "No Spread-child in document!");

	// Store away the rectangle
	ExportRect = RectToExport;

	// Now scan the children of the first spread until we find a layer, or run out of nodes
	while (pLayer != NULL && !pLayer->IsLayer())
		pLayer = pLayer->FindNext();

	if (pLayer == NULL)		// No Layer, so we'd better add one for ourselves
	{
		String_256 LayerID = String_256(_R(IDS_K_CLIPINT_LAYERNAME));
		pLayer = new Layer(pSpread, LASTCHILD, LayerID);
		if (pLayer == NULL)
			return(InitFailed());
	}

	// Create a new NodeRect
	NodeRect* pRectNode = new NodeRect(pLayer, FIRSTCHILD);

	// Failed so cleanup and exit
	if (pRectNode == NULL)
		return(InitFailed());

	// Initilaise the node
	if (!pRectNode->SetUpPath(6,6))
		return(InitFailed());

	// Create the rectangle
	pRectNode->CreateShape(ExportRect);

	// Give the rectangle a line colour
#if 0
	// This memory leaks a StrokeColourAttribute
	StrokeColourAttribute* pAttrValue = new StrokeColourAttribute(DocColour(COLOUR_TRANS));
	if (pAttrValue == NULL)
		return(InitFailed());
	
	NodeAttribute* pAttr = pAttrValue->MakeNode();
	if (pAttr == NULL)
		return(InitFailed());

	// Attach the attribute to the rectangle
	pAttr->AttachNode(pRectNode, FIRSTCHILD);
#else
	// Do what ApplyDefaultBitmapAttrs does
	Node* pLineColAttr = new AttrStrokeColour();
	if (pLineColAttr == NULL)
		return(InitFailed());

	DocColour none(COLOUR_NONE);
	((AttrFillGeometry*)pLineColAttr)->SetStartColour(&none);
	pLineColAttr->AttachNode(pRectNode, FIRSTCHILD);
#endif

	// Create a NodeBitmap (don't attach it to the tree straight away 'cos we
	// have to put the attributes on it first)

	pBitmapNode = new NodeBitmap();
	if (pBitmapNode == NULL)
		return(InitFailed());

	if (!pBitmapNode->SetUpPath(6,6))
		return(InitFailed());

	pBitmapNode->CreateShape(ExportRect);

	if (!SetBitmap(pBitmap))
		return(InitFailed());

	// Set the bitmap's attributes
	// This must be done before the NodeBitmap is inserted into the tree
	if (!pBitmapNode->ApplyDefaultBitmapAttrs(NULL))
		return(InitFailed());

	// Attach it to the tree as the next sibling of the rectangle
	pBitmapNode->AttachNode(pRectNode, NEXT);

	// Success...
	return(TRUE);
}
Beispiel #22
0
/********************************************************************************************

>	BOOL BlendHelpers::BlendAttributes(BlendNodeParam * pParam, CCAttrMap* pBlendedAttrMap)

	Author:		David_McClarnon (Xara Group Ltd) <*****@*****.**> based on blender code
	Created:	21/2/2000
	Inputs:		pParam	-	the blend node param
	Outputs:	-
	Returns:	TRUE if successful, FALSE otherwise
	Purpose:	Blends the attributes of the two BlendPath objects by the amount specified in BlendRatio
	SeeAlso:	-

********************************************************************************************/
BOOL BlendHelpers::BlendAttributes(BlendNodeParam * pParam, CCAttrMap* pBlendedAttrMap)
{
	// Check entry params
	double BlendRatio = pParam->GetAttrBlendRatio();

	BOOL ok = (pParam != NULL && pBlendedAttrMap != NULL);
	ERROR3IF(!ok,"One or more NULL entry params");
	if (!ok) return FALSE;

	// Find the attributes that are applied to the blend paths

	BlendPath * pBlendPathStart = pParam->GetStartBlendPath();
	BlendPath * pBlendPathEnd   = pParam->GetEndBlendPath();
	ok = (pBlendPathStart != NULL && pBlendPathEnd != NULL);
	ERROR3IF(!ok, "Blend paths are NULL");
	if (!ok) return FALSE;

	ok = (pBlendPathStart->GetCreatedByNode() != NULL && 
		pBlendPathEnd->GetCreatedByNode() != NULL);
	ERROR3IF(!ok, "Blend path created by nodes are NULL");
	if (!ok) return FALSE;

	BOOL startExludeGLAs = TRUE, endExcludeGLAs = TRUE;

	NodeAttribute			* pAttr				= NULL;
	if(pBlendPathStart->GetCreatedByNode()->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFeather),&pAttr))
	{
		startExludeGLAs = FALSE;
	}
	if(pBlendPathEnd->GetCreatedByNode()->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFeather),&pAttr))
	{
		endExcludeGLAs = FALSE;
	}

	CCAttrMap* pAttrMapStart = CCAttrMap::MakeAppliedAttrMap(pBlendPathStart->GetCreatedByNode(), startExludeGLAs);
	CCAttrMap* pAttrMapEnd   = CCAttrMap::MakeAppliedAttrMap(pBlendPathEnd->GetCreatedByNode(), endExcludeGLAs);

	if (!pAttrMapStart || !pAttrMapEnd)
		return FALSE;

	// find the attributes on the nodes
	
	if (pParam->GetNodeBlendPath() != NULL)
	{
		Trans2DMatrix* pRotateStart = GetRotateMatrix(pParam->GetNodeStart(),
			360.0 - pParam->GetAngleStart());
		Trans2DMatrix* pRotateEnd   = GetRotateMatrix(pParam->GetNodeEnd(),
			360.0 - pParam->GetAngleEnd());
		if (pRotateStart)	pAttrMapStart->Transform(*pRotateStart);
		if (pRotateEnd)		pAttrMapEnd  ->Transform(*pRotateEnd);

		if (pRotateStart)
			delete pRotateStart;

		if (pRotateEnd)
			delete pRotateEnd;
	}

	// These vars are used as params to the CCAttrMap funcs
	CCRuntimeClass	   *pTypeStart; 
	void			   *pValStart;
	void			   *pValEnd;
	double				OldBlendRatio = pParam->GetBlendRatio();
	// Process each attribute in turn
	CCAttrMap::iterator	PosStart = pAttrMapStart->GetStartPosition();
	CCAttrMap::iterator	EndStart = pAttrMapStart->GetEndPosition();
	for (;PosStart != EndStart;)
	{
		// Get a ptr to the attr at position PosStart in the start node's attr map
		pAttrMapStart->GetNextAssoc(PosStart,pTypeStart,pValStart);
		NodeAttribute* pNodeAttrStart = (NodeAttribute *)pValStart;
	
		BlendRatio = OldBlendRatio;	
		// Diccon 10/99 When using non-linear profiles for the objects those attributes
		// that make use of control points were not being profiled, making the objects look strange.
		// to avoid this those attributes now share the same profiles as the objects.
		if (pNodeAttrStart->IsAGradFill())
		{
		
			if (!((AttrFillGeometry*)pNodeAttrStart)->IsAColourFill())
			{
				
				BlendRatio = pParam->GetObjectRatio();
			
			}
			else
			{
				BlendRatio = pParam->GetInvertedAttributeRatio();
			
			}

		}
		if (pNodeAttrStart->IsAFlatFill() || (pNodeAttrStart->GetRuntimeClass() == CC_RUNTIME_CLASS(AttrLineWidth)))
		{
			BlendRatio = pParam->GetInvertedAttributeRatio();
		}
			
		// Get a blended attribute
		NodeAttribute* pBlendedNodeAttr = NULL;

		// Find an attr of the same type in the end object's attr list,
		// and blend the two attrs together
		pValEnd = NULL;

		if (pAttrMapEnd->Lookup(pTypeStart,pValEnd))
		{
			// We've found a matching end attr, so try to blend it with the start attr

			// Set up the param object to pass to the start attr's blend method
			BlendAttrParam BlendParam;

			NodeAttribute * pEndAttr = (NodeAttribute *)pValEnd;

			// Initialise the BlendParam with the end attr and blend ratio
			if (BlendParam.Init(pParam->GetRenderRegion(),
								pEndAttr,BlendRatio,
								pParam->GetColourBlendType(),
								pAttrMapStart, pAttrMapEnd))
			{
				// Successfully initialised, so now try blending the attributes
				if (pNodeAttrStart->Blend(&BlendParam))
				{
					// Attrs successfully blended, now get a ptr to the new attr.
					// Once we get the blended attr ptr, it belongs to us, so we have
					// to delete it when it is not needed
					pBlendedNodeAttr = BlendParam.GetBlendedAttr();
				}
			}
		}

		// If we have a blended attr, pBlendedNodeAttr != NULL
		if (pBlendedNodeAttr != NULL)
		{
			// Get the type of the blended attr
			CCRuntimeClass *pTypeBlend = pBlendedNodeAttr->GetAttributeType();
			void* pValBlend;

			// If we already have an attr in the blended attr map of the same type,
			// remove it and delete it, before inserting a new attr of this type
			if (pBlendedAttrMap->Lookup(pTypeBlend,pValBlend))
			{
				if (pValBlend != NULL)
				{
					pBlendedAttrMap->RemoveKey(pTypeBlend);
					delete (NodeAttribute*)pValBlend;
				}
			}
			// add it to the blend map
			pBlendedAttrMap->SetAt(pTypeBlend,pBlendedNodeAttr);
		}
	}

	if (pParam->GetNodeBlendPath() != NULL)
	{
		Trans2DMatrix* pRotateStart = GetRotateMatrix(pParam->GetNodeStart(),
			pParam->GetAngleStart());
		Trans2DMatrix* pRotateEnd   = GetRotateMatrix(pParam->GetNodeEnd(),
			pParam->GetAngleEnd()  );
		if (pRotateStart)	pAttrMapStart->Transform(*pRotateStart);
		if (pRotateEnd)		pAttrMapEnd	 ->Transform(*pRotateEnd);

		if (pRotateStart)
			delete pRotateStart;
		
		if (pRotateEnd)
			delete pRotateEnd;
	}

	delete pAttrMapStart;
	delete pAttrMapEnd;

	return TRUE;	
}
Beispiel #23
0
bool ERModel::getTargetAttributeIsPrimaryKey( int targetNodeID )
{
	NodeAttribute* targetAttribute = static_cast<NodeAttribute*>(searchComponent(targetNodeID));

	return targetAttribute->getIsPrimaryKey();
}
Beispiel #24
0
BOOL NodeRenderableInk::MakeAttributeComplete(Node* Root, 
											  BOOL CheckForDuplicates, 		  /* = TRUE */
											  AttrTypeSet* pAffectedAttrTypes, /* = NULL */ 
											  BOOL IncludeDefaults, /* = FALSE */
											  BOOL bIncludeEffectAttrs /* = FALSE */)
{
	Node* Current = NULL;  // Pointer to the current node in the tree 

	NodeAttribute* CurAttr;
	CCRuntimeClass* AttrType;
	BOOL Exists; 

	Node* PreFirstChild = FindFirstChild(); // Remember the FirstChild of the node before we add
										    // any new attributes, this will come in handy if we
										    // need to abort.

	// Loop until all attributes are copied, we are not interested in the defaults cos these are the
	// same for all docs !.
	if (bIncludeEffectAttrs)
		Current = NodeAttribute::FindFirstAppliedAttr(this, Root);
	else
		Current = NodeAttribute::FindPrevAppliedAttr(this, Root);

	while (Current && (IncludeDefaults || (!(IS_A(Current->FindParent(), NodeDocument)))) )
	{
		// Find the next node, snaking up the tree
		if (Current->IsAnAttribute())
		{
			CurAttr = (NodeAttribute*)Current;
			if (CurAttr->CanBeAppliedToObject() && CurAttr->ShouldBeOptimized())
			{
				AttrType = CurAttr->GetAttributeType();

				BOOL Required = RequiresAttrib(AttrType) || this->IsCompound();
				// Is the attribute required ?
				if (Required && (!pAffectedAttrTypes || pAffectedAttrTypes->InSet(AttrType)))
				{
					Exists = FALSE; 
					if (CheckForDuplicates)
					{
						// triggers can have duplicates
						if(!CurAttr->CanBeMultiplyApplied())
						{
							// Does the node already have this child attribute
							Exists = (GetChildAttrOfType(AttrType) != NULL);
						}
					}

					#ifdef _DEBUG
					if (!CheckForDuplicates)
					{
						// If we feel there is no need to check for duplicates then there shouldn't be any !
						if (!CurAttr->CanBeMultiplyApplied())
						{
							NodeAttribute* pChildAttr = GetChildAttrOfType(AttrType);
							if ((pChildAttr != NULL))
							{
#if DEBUG_TREE
								DebugTreeDlg::DumpSubTree(this, 4);
#endif
								TRACE(_T("Duplicate Attr found at %x %s\n"), pChildAttr, pChildAttr->GetRuntimeClass()->m_lpszClassName);
							}
//							ERROR3IF((pChildAttr != NULL), "MakeAttributeComplete: Duplicate attr found !"); 
						}
					}
					#endif

					if (!Exists)
					{
						// Make a copy of the attribute
						NodeAttribute* NewAttr = (NodeAttribute*)CurAttr->SimpleCopy();

						if (NewAttr == NULL)
						{
							goto OutOfMemory; 
						}

						// Now add the attribute to this node
						NewAttr->AttachNode(this, FIRSTCHILD, TRUE, FALSE);
					}
				}
			}
		}
		Current = NodeAttribute::FindPrevAppliedAttr(Current, Root);

		// in order to copy brush ink nodes we need to break if the parent is NULL, else is violates
		if (Current!=NULL && Current->FindParent() == NULL)
			break;
	} 

	return TRUE;

OutOfMemory:
	
	// Delete any new attributes added to the node
	Current = FindFirstChild(); 
	Node* Next; 

	while (Current != PreFirstChild)
	{
		ENSURE(Current != NULL, "PreFirstChild could not be found");
		ENSURE(Current->IsAnAttribute(), "Should be a NodeAttribute"); 
		
		Next = Current->FindNext();
		// Delete the attribute
		Current->CascadeDelete(); 
		delete Current; 		    

		Current = Next; 
	}

	return FALSE; 
}
Beispiel #25
0
BOOL OpChangeLineAttribOpDesc::SetCurrentSelectedAttrib()
{
	// Nothing to do if no current document.
	if (Document::GetCurrent() == NULL)
	{
/*		TRACEUSER( "JustinF", _T("No current document in OpChangeLineAttribOpDesc")
							 "::SetCurrentSelectedAttrib\n");
*/		
		// There is no document so blank all gadgets.
		SetGadgetText(String(_T("")));
		return TRUE;
	}

	// Determine if there is a common attribute.
	NodeAttribute* pAttr;
	SelRange::CommonAttribResult eResult;
	eResult = GetApplication()->
				 FindSelection()->
					 FindCommonAttribute(GetAttribRuntimeClass(), &pAttr);

	// Work out what to put in the combo-box according to the returned result.
	UINT32 nTxtID;
	switch (eResult)
	{
		case SelRange::ATTR_COMMON:
		case SelRange::ATTR_NONE:
		{
			// If there isn't an attribute we just return (this logic is copied from the
			// line-width combo OpDescriptor code).
			if (pAttr == NULL)
			{
/*				TRACEUSER( "JustinF", _T("No attribute in OpChangeLineAttribOpDesc")
									 "::SetCurrentSelectedAttrib\n");
*/				return TRUE;
			}

			// Check for something screwy.
			ERROR3IF(pAttr->GetRuntimeClass() != GetAttribRuntimeClass(),
					 "Wrong kind of attribute in OpChangeLineAttribOpDesc"
					 "::SetCurrentSelectedAttrib");

			// There is, so call the derived class to provide some text.
			nTxtID = ConvertAttribToStringID(pAttr);
			if (nTxtID == 0)
			{
				ERROR3("Unexpected attribute type in OpChangeLineAttribOpDesc"
					   "::SetCurrentSelectedAttrib!");
				return FALSE;
			}
			break; 
		}

		case SelRange::ATTR_MANY:
			nTxtID = _R(IDS_MANY);
			break;

		default:
			ERROR3("Unexpected case in OpChangeLineAttribOpDesc::SetCurrentSelectedAttrib!");
			return FALSE;
	}

	// Set the gadget's text.
	SetGadgetText(String(nTxtID));
	return TRUE;
}
Beispiel #26
0
BOOL NodeRenderableInk::FindCommonAttributesToFactorOut(CommonAttrSet* CommonAttributeSet)
{
	CommonAttributeItem* CommonAttrItem;
	CommonAttributeItem* NextCommonAttrItem;

	// Place all attributes in the CommonAttributeSet
	if (!CommonAttributeSet->AddAllTypesToSet())
	{
		return FALSE; // ERROR already called 
	}

	// Scan all grouped objects
	for (Node* CurrentObject = FindFirstChild();  
		 CurrentObject != NULL;
		 CurrentObject = CurrentObject->FindNext())
	{
		if (CurrentObject->IsAnObject())
		{
			
			// Scan all attributes in the CommonAttributeSet in turn
			CommonAttrItem = (CommonAttributeItem*)CommonAttributeSet->GetHead();

			while(CommonAttrItem != NULL)
			{
				// Hand over hand cos we may well delete the CommonAttrItem
				NextCommonAttrItem = (CommonAttributeItem*)(CommonAttributeSet->GetNext(CommonAttrItem));

				// Does CurrentObject require the attribute	to render
				if ( (((NodeRenderableInk*)CurrentObject)->RequiresAttrib(CommonAttrItem->AttrType)) || CurrentObject->IsCompound())
				{
					BOOL DeleteCommonAttr = FALSE; // Until we know better
            
					// Ok the current object requires the attribute
					// Does the CurrentObject have a child attribute of this type ?
					NodeAttribute* pAttrNode = 
						((NodeRenderableInk*)CurrentObject)->GetChildAttrOfType(CommonAttrItem->AttrType);
					if (pAttrNode != NULL && pAttrNode->ShouldBeOptimized())
					{
						// Ok it has an attribute of this type
						if (CommonAttrItem->pAttr == NULL)
						{
							// The attribute becomes a common attribute
							CommonAttrItem->pAttr = pAttrNode;
							CommonAttrItem->Status = Range::ATTR_COMMON; 
						}
						else if(CommonAttrItem->pAttr->GetRuntimeClass() ==
							    pAttrNode->GetRuntimeClass())
						{
							// Ok they are the same runtime class but are they equal
							if (!((*pAttrNode)==(*(CommonAttrItem->pAttr))))
							{
								// They are not equal so remove CommonAttrItem from the
								// common attribute set.
								DeleteCommonAttr = TRUE; 
							}
							// DY 12/5/2000 AttrBrushTypes cannot be factored because they 
							// may contain caches of pressure or timestamp data which apply
							// to a specific node only.
							// They no longer contain this data so factor them like normal!
							//if (pAttrNode->IsKindOf(CC_RUNTIME_CLASS(AttrBrushType)))
							//	DeleteCommonAttr = TRUE;
						}
						else 
						{
							// They cannot be the same value cos they are different runtime types
							DeleteCommonAttr = TRUE; 
						}
					}
					else 
					{
						// The CurrentObject does not have an attribute of this type so it
						// cannot be common
						DeleteCommonAttr = TRUE; 
					}

					if (DeleteCommonAttr)
					{
						delete(CommonAttributeSet->RemoveItem(CommonAttrItem)); 
					}
				}

				CommonAttrItem = NextCommonAttrItem;
			}
		}
		// Removed because there are circumstances where certain attributes have 
		// already been factored out eg. Corel filter
		//else 
		//{
		//	ENSURE(CurrentObject->GetRuntimeClass() == CC_RUNTIME_CLASS(NodeHidden), 
		//				"It's not an object, it's not a hidden node, so what is it ??");
		//}
	} 	
	// Delete all NULL items in the CommonAttributeSet
	CommonAttrItem = (CommonAttributeItem*)CommonAttributeSet->GetHead();
	while (CommonAttrItem != NULL)
	{
		CommonAttributeItem* Next = (CommonAttributeItem*)CommonAttributeSet->GetNext(CommonAttrItem);
		if (CommonAttrItem->pAttr == NULL)
		{
			// Item is a non required attribute so zap it
			delete (CommonAttributeSet->RemoveItem(CommonAttrItem)); 
		}
		CommonAttrItem = Next; 
	}
	
	return TRUE; // Job done
}