NodeBevel Class Reference

Does the bevelling. More...

#include <nodebev.h>

Inheritance diagram for NodeBevel:

List of all members.

Public Member Functions
	NodeBevel ()
	Default constructor Note:.
	~NodeBevel ()
	Default destructor Note:.
	NodeBevel (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This constructor initialises the nodes flags and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated. Note: SetUpShape() must be called before the NodeRegularShape is in a state in which it can be used.
virtual Node *	SimpleCopy ()
	Returns a copy of me.
void	CopyNodeContents (NodeBevel *pNewNode)
	Sort of backwards copy constructor.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
BOOL	GenerateBevel ()
	Creates the beveller class, and the beveller bitmap Note:.
BOOL	GenerateBevelForBlendStep (SumAllPathsElem *pElem, CCAttrMap *pMap)
	Creates the bevel data from the given list of SumAllPathsElem.
BOOL	SetupVariables (CCAttrMap *pMap=NULL)
	Sets up all the attributes on myself and my parent by finding the appropriate attributes.
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
virtual DocRect	GetBlobBoundingRect ()
	Calculates the bounding rectangle of the nodes blobs.This should always be calculated on the fly as the view scale can change without the node knowing, giving an incorrect result.
virtual void	SetBoundingRect (DocRect rect)
virtual void	RenderBitmap (RenderRegion *pRender)
	Renders the bevel using the bitmap bevelling system.
virtual void	Render (RenderRegion *pRender)
	Will build a path for the shape and draw it to the given render region.
virtual void	Transform (TransformBase &Trans)
	Transforms the shape.
virtual BOOL	RequiresAttrib (CCRuntimeClass *pAttribClass, BOOL Search=FALSE)
	NodeBevel does not require brush attrs.
virtual BOOL	RequiresAttrib (NodeAttribute *pAttr, BOOL Search=FALSE)
	NodeBevel does not require brush attrs.
virtual BOOL	CanAttrBeAppliedToMe (CCRuntimeClass *pAttribClass)
	Determine whether the given attr type can be applied directly to me. We don't like brushed bevels, so we don't accept brush attrs.
virtual NodeCompound *	GetParentController () const
	Returns a type correct pointer to the parent Bevel controller.
virtual BOOL	IsNodePath () const
virtual BOOL	IsABevel () const
void	DeleteCache ()
	Deletes all data held in this class.
void	DeleteCachedBitmap ()
	Deletes the current Bevel Bitmap. Mainly used when printing to reduce memory usage.
BOOL	CreateBevelPaths ()
	Sets up all the attributes on myself and my parent by finding the appropriate attributes Note:.
virtual void	RenderEorDrag (RenderRegion *rr)
void	InvalidateMe ()
virtual BOOL	NeedsTransparency () const
	We sure do need transparency !
void	DisableRendering ()
void	EnableRendering ()
BOOL	IsRenderingStopped ()
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Converts me to a path.
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	Can become a path !
virtual String	Describe (BOOL Plural, BOOL Verbose=TRUE)
	Default constructor Note:.
virtual BOOL	NeedsParent (Node *pNode) const
	Do we need a parent of the same class as the given node ??? See also: NodeCompound::OnChildChange.
BOOL	PostDuplicate (UndoableOperation *pOp)
	Regens the node after a duplication.
BOOL	AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState, BOOL DoPreTriggerEdit=TRUE)
DocRect	GetPathBoundingRect ()
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes out a dummy record, for my attribute to be attached to.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
virtual BOOL	ExportRender (RenderRegion *pRegion)
	If pRenderRegion points to a FlashRenderRegion, the bevel will be processed as a bitmap filled shape, and stored as a pair of records (shape and bitmap) within the resulting Flash file.
virtual void	PreExportRender (RenderRegion *pRegion)
	Perform any rendering required when exporting to a file, and this node is being 'passed by' during the tree searching. For example, a group node being exported to EPS would output a "start group" token, and then its ExportRender function would output a "end group" token. By default, it does nothing. Nodes wishing to do special export processing should override this function (and ExportRender).
virtual void	RenderTinyBlobs (RenderRegion *pRender)
BitmapFillAttribute *	GetBitmapFillAttribute (void)
	Returns a pointer to the bitmap fill contained within NoveBevel.
virtual BOOL	OnNodePopUp (Spread *pSpread, DocCoord PointerPos, ContextMenu *pMenu)
	Allows the shadow to respond to the click.
BOOL	AmICached ()
virtual BOOL	IsTypeExtendible () const
virtual DocRect	ValidateExtend (const ExtendParams &ExtParams)
	Tests the reversibility of an Extend operation applied to this node.
virtual void	Extend (const ExtendParams &ExtParams)
	Perform an Extend operation on this Node, and its children if appropriate.
void	SetRenderBitmaps (BOOL b)
BOOL	GetRenderBitmaps ()
void	SetZeroLineWidths (BOOL b)
DocRect	GetInsideBoundingRect ()
	Gets the bounding rect of the original (non-bevelled) objects See also: NodeCompound::OnChildChange.
BOOL	ReRenderBevelBitmap (BOOL bAntialias)
	Re-renders the bevel bitmap using the beveler as it's already set up with the currently applied attributes.
virtual INT32	EstimateNodeComplexity (OpParam *details)
	This function estimates a complexity value for the node. The complexity value is based upon the total length of all paths in the node.
Path *	GetOuterBevelPath ()
Path *	GetBevelPath ()
void	DoRender (BOOL DoRender=TRUE)
KernelBitmap *	GetBevelBitmap () const
KernelBitmap *	CreateBitmapCopy (double DPI=-1.0, BOOL CheckFillFlags=TRUE)
	Creates a BitmapCopy of the Bevel Bitmap including the current fills and transparency settings generated at the given DPI!
void	SetConvertingFlag (BOOL Set=FALSE)
void	GetDebugDetails (StringBase *Str)
	Builds debug info for camelot tree dialog.
Public Attributes
Path	InkPath
BOOL	m_MustRegenOnChildChange
INT32	m_BevelType
INT32	m_Indent
double	m_LightAngle
BOOL	m_bOuter
INT32	m_Contrast
double	m_Tilt
BOOL	m_IsABlendStepBevel
DocCoord	m_BMPCentre
DocCoord	m_BMPPoint1
DocCoord	m_BMPPoint2
DocRect	m_SelectedRect
JointType	m_JointType
Protected Member Functions
KernelBitmap *	CreateCombinedBMPAndTranspFill (RenderRegion *pRegion=NULL)
	Creates a new 32Bit Bitmap to hold the combined Transp & Bitmap Fill Attributes.
void	CalculateBitmapSize (INT32 *retnWid, INT32 *retnHei, RenderRegion *pRegion=NULL)
	Calculates the width and the height for the bitmap depending on what's in m_Path.
void	RenderNodesForPrinting (RenderRegion *pRender)
	Renders all original nodes again Notes: Used because in printing, problems occur with the ShrinkPath stuff, causing holes to appear in the printed image. Thus, we take a different tack of rendering the bevelled path without the original being taken away from it, and then rendering the original nodes again so no holes occur See also: NodeBevel::RenderBitmap.
void	RenderNodeRecursively (Node *pNode, RenderRegion *pRender)
	Renders all children of this node first, then renders the node itself Notes: See also: NodeBevel::DrawNodesForPrinting.
void	SetUpBitmapPalette (RenderRegion *pRegion=NULL, DocColour FlatColour=COLOUR_BLACK)
	Sets up the bitmap palette depending on contrast setting.
BOOL	CreateBevelBitmap ()
	Creates the bitmap used in generating the highlights for bevels Note:.
BOOL	RenderBitmapForDisplay (RenderRegion *pRegion)
	Creates the Brigtness bitmap for the bevel.
BOOL	ReverseAndShrinkBevelPathIntoInkPath (Path *pBevelPath=NULL, double ZoomValue=1.0, BOOL IsAnOuter=TRUE)
Protected Attributes
Path	m_Path
BOOL	m_DoRender
KernelBitmap *	m_pBevelBitmap
KernelBitmap *	m_pCombiBitmap
BitmapFillAttribute *	m_pBMPFill
BitmapTranspFillAttribute *	m_pTranspFill
INT32	m_BitmapWidth
INT32	m_BitmapHeight
DocCoord	m_SubPixelOffset
DocRect	m_PixelAllignedRect
BOOL	m_IsFlatFilledOnly
BOOL	m_IsAnAlphaBMP
BOOL	m_HasTransparencyApplied
BOOL	m_AmConvertingToShapes
double	m_LastCachedPrintBMPDPI
double	m_LastExportedDPI
BOOL	m_bStopRender
BOOL	m_DoingRotation
Path	m_OuterBevelPath
UINT32	m_ViewScale
Path	m_ShrunkPath
BOOL	m_bLock
BOOL	m_bRenderBitmaps
BOOL	m_bZeroLineWidth
CBeveler *	m_pBeveler
BOOL	m_bPathIsClosed
BOOL	m_bCached
double	m_LastZoomFactor
UINT32	m_LastPixelSize
Private Member Functions
	CC_DECLARE_DYNCREATE (NodeBevel)

---

Detailed Description

Does the bevelling.

Author:

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

Date:

6/10/98

Definition at line 132 of file nodebev.h.

---

Constructor & Destructor Documentation

NodeBevel::NodeBevel (   )

Default constructor Note:. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/98 See also: Definition at line 280 of file nodebev.cpp. { m_bStopRender = FALSE; m_Indent = 0; m_LightAngle = 300; m_bLock = FALSE; m_BevelType = 0; m_bZeroLineWidth = TRUE; m_pBevelBitmap = NULL; m_bOuter = FALSE; m_Contrast = 100; m_ShrunkPath.Initialise(); m_ViewScale = 0; m_pBMPFill = NULL; m_bRenderBitmaps = TRUE; m_OuterBevelPath.Initialise(); m_Path.Initialise(); m_BevelType = 0; m_LightAngle = 0; m_JointType = MitreJoin; InkPath.Initialise(0,12); m_pBeveler = NULL; m_Tilt = 32.0; m_bPathIsClosed = FALSE; m_bCached = FALSE; m_DoingRotation = FALSE; m_SubPixelOffset.x = 0; m_SubPixelOffset.y = 0; m_IsFlatFilledOnly = TRUE; m_HasTransparencyApplied = FALSE; m_pTranspFill = NULL; m_pCombiBitmap = NULL; m_LastZoomFactor = 1.0; m_LastCachedPrintBMPDPI = 0.0; m_LastPixelSize = 0; m_IsABlendStepBevel = FALSE; m_DoRender = TRUE; m_IsAnAlphaBMP = FALSE; m_AmConvertingToShapes = FALSE; m_LastExportedDPI = 96.0; }

NodeBevel::~NodeBevel (   )

Default destructor Note:. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/98 See also: Definition at line 334 of file nodebev.cpp. { if (m_pBMPFill) { delete m_pBMPFill; m_pBMPFill = NULL; } if (m_pTranspFill) { delete m_pTranspFill; m_pTranspFill = NULL; } if (m_pBevelBitmap) { delete m_pBevelBitmap; m_pBevelBitmap = NULL; } if(m_pCombiBitmap) { delete m_pCombiBitmap; m_pCombiBitmap = NULL; } DeleteCache(); }

NodeBevel::NodeBevel (  Node *  ContextNode, AttachNodeDirection  Direction, BOOL  Locked = FALSE, BOOL  Mangled = FALSE, BOOL  Marked = FALSE, BOOL  Selected = FALSE )

This constructor initialises the nodes flags and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated. Note: SetUpShape() must be called before the NodeRegularShape is in a state in which it can be used. / const UINT32 BevelClipPathToPath_Tolerance = 30 ; const UINT32 BevelClipPathToPath_Flatness = 200 ; const UINT32 BevelStrokePathToPath_Flatness = 200 ; const double BevelMaxBitmapWidth = 1600.0; const double BevelMaxBitmapHeight = 1200.0; /*! Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 16/11/94 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] MonoOn Direction: MonoOff Specifies the direction in which the node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node BoundingRect: Bounding rectangle The remaining inputs specify the status of the node: Locked: Is node locked ? Mangled: Is node mangled ? Marked: Is node marked ? Selected: Is node selected ? See also: NodeRegularShape::SetUpShape Returns: Errors: An ENSURE will occur if ContextNode is NULL Definition at line 222 of file nodebev.cpp. : NodeRenderableInk(ContextNode, Direction, Locked, Mangled, Marked, Selected ) { m_Indent = 0; m_pBevelBitmap = NULL; m_Contrast = 100; m_bLock = FALSE; m_bRenderBitmaps = TRUE; m_bZeroLineWidth = TRUE; m_LastPixelSize = 0; m_bOuter = FALSE; m_BitmapWidth = 0; m_BitmapHeight = 0; InkPath.Initialise(0,12); m_ShrunkPath.Initialise(); m_bStopRender = FALSE; m_pBMPFill = NULL; m_BevelType = 0; m_LightAngle = 0; m_ViewScale = 0; m_OuterBevelPath.Initialise(); m_Path.Initialise(); m_pBeveler = NULL; m_Tilt = 32.0; m_bPathIsClosed = FALSE; m_bCached = FALSE; m_DoingRotation = FALSE; m_SubPixelOffset.x = 0; m_SubPixelOffset.y = 0; m_IsFlatFilledOnly = TRUE; m_HasTransparencyApplied = FALSE; m_pTranspFill = NULL; m_pCombiBitmap = NULL; m_LastZoomFactor = 1.0; m_LastCachedPrintBMPDPI = 0.0; m_IsABlendStepBevel = FALSE; m_DoRender = TRUE; m_IsAnAlphaBMP = FALSE; m_AmConvertingToShapes = FALSE; m_LastExportedDPI = 96.0; }

---

Member Function Documentation

BOOL NodeBevel::AllowOp (  ObjChangeParam *  pParam, BOOL  SetOpPermissionState, BOOL  DoPreTriggerEdit = TRUE )  [virtual]

Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com>; Karim 20/01/2000 Date: 20/11/96 Parameters: pParam  describes the way an op wants to change the node [INPUTS] SetOpPermissionState if TRUE the OpPermission of nodes should be set DoPreTriggerEdit if TRUE then NameGallery::PreTriggerEdit is called. Must* be TRUE if the calling Op may make any nodes change their bounds, eg move, line width, cut. Use TRUE if unsure. See also: Reimplemented from Node. Definition at line 3574 of file nodebev.cpp. { ERROR2IF(pParam==NULL, FALSE, "NodeBevel::AllowOp; NULL pParam"); // Set up a flag to see if any of the child objects get changed BOOL allowed = TRUE; UndoableOperation* pOp = pParam->GetOpPointer(); // clean out the calling-child ptr, so it doesn't get passed around unintentionally. pParam->SetCallingChild(NULL); // before going further, see whether our parents allow the Op. if (allowed && Parent != NULL && pParam->GetDirection()!= OBJCHANGE_CALLEDBYPARENT) { ObjChangeDirection OldDirection = pParam->GetDirection(); pParam->SetCallingChild(this); pParam->SetDirection(OBJCHANGE_CALLEDBYCHILD); allowed = Parent->AllowOp(pParam, SetOpPermissionState, DoPreTriggerEdit); pParam->SetDirection(OldDirection); } // if the parent allows this, then test the op for ourself. if (allowed && pOp) { // disallow mould and contour Ops. if ( pOp->IsKindOf(CC_RUNTIME_CLASS(OpCreateNewMould)) || pOp->IsKindOf(CC_RUNTIME_CLASS(OpPasteEnvelope)) || pOp->IsKindOf(CC_RUNTIME_CLASS(OpPastePerspective)) || pOp->IsKindOf(CC_RUNTIME_CLASS(OpCreateContour)) ) allowed = FALSE; if( (pOp->IsKindOf(CC_RUNTIME_CLASS(OpEditFill)) || pOp->IsKindOf(CC_RUNTIME_CLASS(OpApplyAttribToSelected))) && !m_IsFlatFilledOnly && m_HasTransparencyApplied && m_pCombiBitmap ) { // Make sure the attributes aren't pointing at the bitmap we are about to delete if (m_pBMPFill->GetBitmap() == m_pCombiBitmap) m_pBMPFill->BitmapRef.SetBitmap(NULL); if (m_pTranspFill->GetBitmap() == m_pCombiBitmap) m_pTranspFill->BitmapRef.SetBitmap(NULL); delete m_pCombiBitmap; m_pCombiBitmap = NULL; } } // if necessary, set permissions for OnChildChange. if (SetOpPermissionState) SetOpPermission(allowed ? PERMISSION_ALLOWED : PERMISSION_DENIED, TRUE); if (allowed) { UndoableOperation* pChangeOp = pParam->GetOpPointer(); // check for geometry linked attributes BOOL InformGeomLinkedAttrs = SetOpPermissionState && pChangeOp && pChangeOp->MayChangeNodeBounds(); if (InformGeomLinkedAttrs) { NodeAttribute* pNA = FindFirstGeometryLinkedAttr(); while(pNA) { pNA->LinkedNodeGeometryHasChanged(pChangeOp); pNA = pNA->FindNextGeometryLinkedAttr(); } } // if we're ok so far and were asked to do a PreTriggerEdit, then // determine whether the Op may change the bounds of some nodes. // If it may, then call NameGallery::PreTriggerEdit. if (DoPreTriggerEdit && pChangeOp && pChangeOp->MayChangeNodeBounds() && NameGallery::Instance()) allowed = NameGallery::Instance()->PreTriggerEdit(pChangeOp, pParam, this); } // return result (directly, or indirectly via a child AllowOp()) to op return allowed; }

BOOL NodeBevel::AmICached (   )  [inline]

Definition at line 231 of file nodebev.h. { return m_bCached; }

void NodeBevel::CalculateBitmapSize (  INT32 *  retnWid, INT32 *  retnHei, RenderRegion *  pRegion = NULL )  [protected]

Calculates the width and the height for the bitmap depending on what's in m_Path. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 7/10/98 Parameters: Return  pointers for witdth & height [INPUTS] Definition at line 1798 of file nodebev.cpp. { // Get a pointer to the controller node! NodeBevelController * pControl = (NodeBevelController *)FindParent(); // Check that all the pointers are valid! if(!retnWid || !retnHei || !pControl) return; // Get the bounding rect of the bevel! DocRect dr(0,0,0,0); // If it`s an outer then get the bounds that gavin creates when he generates his trap list! if(m_bOuter) { if(m_pBeveler) dr = m_pBeveler->GetSelectionRect(); else { InkPath.GetTrueBoundingRect(&dr); dr.Inflate(m_Indent); } } else { // If it`s an inner then just get the bounds of the object and not the bevel path m_Path.GetTrueBoundingRect(&dr); } // Make sure we check to see if the returned rect is not empty! if (dr.IsEmpty()) { *retnWid = 0; *retnHei = 0; return; } MILLIPOINT PixSize = 750; if(pRegion) PixSize = pRegion->GetScaledPixelWidth(); if(Document::GetCurrent() && Document::GetCurrent()->GetFirstDocView() && !(pRegion && pRegion->IS_KIND_OF(PrintingMaskedRenderRegion)) ) PixSize = (MILLIPOINT)((double)PixSize / (Document::GetCurrent()->GetFirstDocView())->GetViewScale().MakeDouble()); if(PixSize == 0) PixSize = 1; m_PixelAllignedRect = dr; double lWidth = dr.Width() / PixSize; double lHeight = dr.Height() / PixSize; // Check to see if we`re not printing and then Scale up the values! if ((!pControl->IsPrinting() && !m_AmConvertingToShapes) || (pRegion && pRegion->IS_KIND_OF(PrintingMaskedRenderRegion))) { // If the current render regions scale value is greater than 0 do the following if (pRegion && PixSize > 0 ) { lWidth = (lWidth * 750) / PixSize; lHeight = (lHeight * 750) / PixSize; } // Make sure the values are under the maximum values! while ( lWidth > BevelMaxBitmapWidth || lHeight > BevelMaxBitmapHeight ) { // Divide them by a half! lWidth *= 0.5; lHeight *= 0.5; } } else { double DPI = pControl->GetDPI(); lWidth = dr.Width () * DPI / 72000 ; lHeight = dr.Height() * DPI / 72000 ; } // Now place the new values into the passed in variables *retnWid = (INT32)ceil(lWidth); *retnHei = (INT32)ceil(lHeight); }

BOOL NodeBevel::CanAttrBeAppliedToMe (  CCRuntimeClass *  pAttribClass  )  [virtual]

Determine whether the given attr type can be applied directly to me. We don't like brushed bevels, so we don't accept brush attrs. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 22/08/2000 Parameters: pAttribClass  the attr type to test. [INPUTS] Returns: FALSE if pAttribClass is a brush attr, TRUE otherwise. Errors: returns FALSE if pAttribClass is NULL. Reimplemented from NodeRenderableInk. Definition at line 2906 of file nodebev.cpp. { if (pAttribClass == NULL || pAttribClass == CC_RUNTIME_CLASS(AttrBrushType)) return FALSE; else return TRUE; }

BOOL NodeBevel::CanBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Can become a path ! Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 26/2/99 Parameters: Ink  class to test [INPUTS] See also: Reimplemented from Node. Definition at line 2547 of file nodebev.cpp. { if (pBecomeA->BAPath()) { pBecomeA->AddCount(2); return TRUE; } return FALSE; }

NodeBevel::CC_DECLARE_DYNCREATE (  NodeBevel   )  [private]

void NodeBevel::CopyNodeContents (  NodeBevel *  pNewNode  )

Sort of backwards copy constructor. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/01/2004 Parameters: -  [INPUTS] Returns: Definition at line 3113 of file nodebev.cpp. { pNewNode->m_Indent = m_Indent; pNewNode->m_LightAngle = m_LightAngle; pNewNode->m_Contrast = m_Contrast; pNewNode->m_BevelType = m_BevelType; pNewNode->m_bOuter = m_bOuter; pNewNode->InkPath.Initialise(InkPath.GetNumCoords()); pNewNode->InkPath.CopyPathDataFrom(&InkPath); pNewNode->m_MustRegenOnChildChange = m_MustRegenOnChildChange; pNewNode->m_Tilt = m_Tilt; pNewNode->m_IsABlendStepBevel = m_IsABlendStepBevel; // points determining the fill control points pNewNode->m_BMPCentre = m_BMPCentre; pNewNode->m_BMPPoint1 = m_BMPPoint1; pNewNode->m_BMPPoint2 = m_BMPPoint2; // the rect of the (original) selection pNewNode->m_SelectedRect = m_SelectedRect; pNewNode->m_JointType = m_JointType; pNewNode->m_Path.Initialise(m_Path.GetNumCoords()); pNewNode->m_Path.CopyPathDataFrom(&m_Path); pNewNode->m_DoRender = TRUE; pNewNode->DeleteCachedBitmap(); if (m_pBevelBitmap==NULL && m_pBMPFill!=NULL) m_pBMPFill->BitmapRef.SetBitmap(m_pBevelBitmap); if (m_pBevelBitmap==NULL && m_pTranspFill!=NULL) m_pTranspFill->BitmapRef.SetBitmap(m_pBevelBitmap); if (pNewNode->m_pBMPFill) delete pNewNode->m_pBMPFill; pNewNode->m_pBMPFill = NULL; if (m_pBMPFill) { pNewNode->m_pBMPFill = new BitmapFillAttribute; pNewNode->m_pBMPFill->SimpleCopy(m_pBMPFill); } if (pNewNode->m_pTranspFill) delete pNewNode->m_pTranspFill; pNewNode->m_pTranspFill = NULL; if (m_pTranspFill) { pNewNode->m_pTranspFill = new BitmapTranspFillAttribute; pNewNode->m_pTranspFill->SimpleCopy(m_pTranspFill); } pNewNode->m_BitmapWidth = m_BitmapWidth; pNewNode->m_BitmapHeight = m_BitmapHeight; pNewNode->m_SubPixelOffset = m_SubPixelOffset; pNewNode->m_PixelAllignedRect = m_PixelAllignedRect; pNewNode->m_IsFlatFilledOnly = m_IsFlatFilledOnly; pNewNode->m_IsAnAlphaBMP = m_IsAnAlphaBMP; pNewNode->m_HasTransparencyApplied = m_HasTransparencyApplied; pNewNode->m_AmConvertingToShapes = m_AmConvertingToShapes; pNewNode->m_LastCachedPrintBMPDPI = m_LastCachedPrintBMPDPI; pNewNode->m_LastExportedDPI = m_LastExportedDPI; // lock on rendering pNewNode->m_bStopRender = m_bStopRender; pNewNode->m_DoingRotation = m_DoingRotation; // this is the bevel path generated by the path processor for outer bevels (without // the hole in it) pNewNode->m_OuterBevelPath.Initialise(m_OuterBevelPath.GetNumCoords()); pNewNode->m_OuterBevelPath.CopyPathDataFrom(&m_OuterBevelPath); // the pixel sizes used to create the bevel bitmap pNewNode->m_ViewScale = m_ViewScale; // the shrunk path used in rendering pNewNode->m_ShrunkPath.Initialise(m_ShrunkPath.GetNumCoords()); pNewNode->m_ShrunkPath.CopyPathDataFrom(&m_ShrunkPath); pNewNode->m_bLock = m_bLock; pNewNode->m_bRenderBitmaps = m_bRenderBitmaps; // indicates we should zero the line width of the path, or not (as the case might be) pNewNode->m_bZeroLineWidth = m_bZeroLineWidth; // Make sure the new node doesn't have an old CBeveler lying around. if (pNewNode->m_pBeveler) { delete pNewNode->m_pBeveler; pNewNode->m_pBeveler = NULL; } // whether the original path is closed or not // if not, don't do any path shrinking pNewNode->m_bPathIsClosed = m_bPathIsClosed; // flag to indicate that when this node is inside of a blend there's // no need to regenerate it - it's already been cached pNewNode->m_bCached = m_bCached; // Reverses the bevel path and adds it to the original to create the new bevel path // Also shrinks/Expands the inner/outer path edge by a pixel to get rid of antialiasing // effects when overlapping the object pNewNode->m_LastZoomFactor = m_LastZoomFactor; // the last pixel size for the bitmap pNewNode->m_LastPixelSize = m_LastPixelSize; NodeRenderableInk::CopyNodeContents(pNewNode); }

BOOL NodeBevel::CreateBevelBitmap (   )  [protected]

Creates the bitmap used in generating the highlights for bevels Note:. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 18/10/99 See also: Definition at line 569 of file nodebev.cpp. { // Find the parent node and make sure it`s not null and it`s a bevel controller node Node* pNode = FindParent(); if (!pNode && !pNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevelController))) { ERROR3("Bevel node has a parent which isn't a bevel controller node !"); return FALSE; } TRACEUSER( "MarkH", _T("Creating a new Bevel Bitmap!\n")); // Clear the current shrunken path m_ShrunkPath.ClearPath(); // delete the existing pointers if (m_pBevelBitmap) { delete m_pBevelBitmap; m_pBevelBitmap = NULL; } if (m_pBeveler) { delete m_pBeveler; m_pBeveler = NULL; } if(m_pCombiBitmap) { delete m_pCombiBitmap; m_pCombiBitmap = NULL; } // get the path to use from the processor if (m_Path.GetNumCoords() == 0) return FALSE; // Now create a new CBeveler Pointer m_pBeveler = new CBeveler(&m_Path); ERROR2IF(!m_pBeveler,FALSE,"Failed to create a CBeveler pointer!"); // the flatness needs to be linked to the height of this MILLIPOINT Flatness = BEVEL_FLATNESS; // alter the flatness for printing NodeBevelController* pBevelController = (NodeBevelController *) pNode; if (pBevelController && pBevelController->IsPrinting()) Flatness = (MILLIPOINT)(((double)BEVEL_FLATNESS) * (96.0 / pBevelController->GetDPI())); // set up the bevel type m_pBeveler->SetBevelType(m_BevelType); m_pBeveler->SetBevelAngle(m_LightAngle); m_pBeveler->SetBevelTilt(m_Tilt); // Find the current Join type AttrJoinType * pJoinType = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrJoinType), (NodeAttribute **)(&pJoinType)); JointType JT = RoundJoin; if (pJoinType) JT = pJoinType->Value.JoinType; // Calculate the angle using the lightangle variable double angle = 3.1415926536*m_LightAngle/180 ; NormCoord nc( cos(angle),sin(angle) ); // Set up the beveler with all the new variables! BOOL ok = m_pBeveler->SetUpBeveler(m_Indent, JT, &nc, m_bOuter, pBevelController->m_Contrast, NULL, BevelClipPathToPath_Flatness); // Check to see if the setup went ok if(!ok) return FALSE; // Do another recalculation to setup the fill handles! CalculateBitmapSize(&m_BitmapWidth, &m_BitmapHeight); // Check to see if the size is valid if (m_BitmapWidth <= 0 || m_BitmapHeight <= 0) return TRUE; // Now tell the beveler how large to make the bevels. m_pBeveler->SetBevelerSize(m_BitmapWidth,m_BitmapHeight); // make the bounding box the same as the selection bounds BoundingRectangle = m_PixelAllignedRect; IsBoundingRectValid = TRUE; m_BMPCentre.x = m_PixelAllignedRect.lo.x; m_BMPCentre.y = m_PixelAllignedRect.lo.y; m_BMPPoint1.x = m_PixelAllignedRect.hi.x; m_BMPPoint1.y = m_PixelAllignedRect.lo.y; m_BMPPoint2.x = m_PixelAllignedRect.lo.x; m_BMPPoint2.y = m_PixelAllignedRect.hi.y; NodeAttribute* pFillAttrib = NULL; DocColour FillColour = COLOUR_BLACK; // Test to see if theres a FillGeom Attribute applied to the bevel if(FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pFillAttrib)) { // If the pointer is valid and It`s a flat fill then get the colour and set the IsFlatFill Flag if(pFillAttrib != NULL && pFillAttrib->IsAFlatFill()) { FillColour = *((AttrFlatColourFill*)pFillAttrib)->GetStartColour(); m_IsFlatFilledOnly = TRUE; } else { // it`s not a plain flat fill so set the flag to false m_IsFlatFilledOnly = FALSE; // Make sure we know if it`s an Alpha Channel Bitmap as this needs special treatment! if(pFillAttrib->IsABitmapFill()) { BitmapFillAttribute* pFill = (BitmapFillAttribute*)pFillAttrib->GetAttributeValue(); m_IsAnAlphaBMP = (pFill->GetBitmap()->GetBitmapInfoHeader()->biBitCount == 32); } else m_IsAnAlphaBMP = FALSE; } } // make sure the palette is setup ready for the BMP SetUpBitmapPalette((RenderRegion *)NULL,FillColour); // Everythings cool, return TRUE return TRUE; }

BOOL NodeBevel::CreateBevelPaths (   )

Sets up all the attributes on myself and my parent by finding the appropriate attributes Note:. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 17/10/99 See also: ContourBecomeA (in kernel/nodecntr.h), NodeContour::GenerateContour Definition at line 784 of file nodebev.cpp. { // Delete the current Cache DeleteCache(); // build up the source path Node * pNode = FindParent(); NodeBevelController * pControl = (NodeBevelController *)FindParent(); if (!pNode) return FALSE; pNode = pNode->FindFirstChild(); if (!pNode || pNode == this) return FALSE; double CurrentFlatness = 200.0; // Mark Howitt 31/10/00 // This function call now replaces the passed in value when the BecomeA function is created. // This has been done to elliminate zoom dependancies which change the flatness values // depending on the current zoom value. See the function header for more details Node* pNodeToBevel = pNode->FindNextInk(); while(pNodeToBevel == this && pNodeToBevel) pNodeToBevel = pNodeToBevel->FindNextInk(); if(pNodeToBevel) { DocRect DR = ((NodeRenderableInk*)pNodeToBevel)->GetBoundingRect(); // Get the smallest dimesion, Width or Height. double Smallest = DR.Height() < DR.Width() ? (double)DR.Height() : (double)DR.Width(); // now make the flatness value equal to the smallest dimesion divided by 375 CurrentFlatness = Smallest / 375.0; // Check to see if we`re within the specified limits if(1.0 > CurrentFlatness) CurrentFlatness = 1.0; if(375.0 < CurrentFlatness) CurrentFlatness = 375.0; } // Check to see what the zoom factor is so we can take it into account for the flatness values! DocView* pDocView = Document::GetCurrent()->GetFirstDocView(); double CurrentZoom = 1.0; if(pDocView) CurrentZoom = pDocView->GetZoomFactor(); m_LastZoomFactor = CurrentZoom; m_Path.ClearPath(); InkPath.ClearPath(); m_OuterBevelPath.ClearPath(); INT32 Width = pControl->m_Indent; BOOL bOuter = pControl->m_bOuter; // bog standard profile CProfileBiasGain Profile; AttrJoinType * pJoinType = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrJoinType), (NodeAttribute **)(&pJoinType)); JointType JT = RoundJoin; if (pJoinType) JT = pJoinType->Value.JoinType; // use the BecomeA passback mechanism to contour everything /*#ifdef NEWBEVEL ContourBecomeA MyBecomeA(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL, FALSE, &m_OuterBevelPath, &m_Path, 0, 1, bOuter, Profile, JT, CurrentFlatness,TRUE); #else*/ ContourBecomeA MyBecomeA(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL, FALSE, &m_OuterBevelPath, &m_Path, Width, 1, bOuter, Profile, JT, CurrentFlatness,TRUE); //#endif m_bPathIsClosed = TRUE; Path CopyPath; CopyPath.Initialise(); Path TempPath; TempPath.Initialise(); // UINT32 NumObjects = 0; // AttrVariableWidth* pStroked = NULL; // TextStory* pTextStory = NULL; // run through all nodes, contouring them while (pNode) { if(pNode != this) { // When we conditionally call CanBecomeA below, we want to find the number of paths // pNode will produce. So we must clear the counter now before the condition starts MyBecomeA.ResetCount(); // is the node a blend path ? if (!pNode->IS_KIND_OF(NodeBlendPath)) { // is the node a path ? if (pNode->IsNodePath()) { // turn the path into a closed shape if (((NodePath *)pNode)->InkPath.IsClosed()) m_bPathIsClosed = FALSE; /* FindAppliedAttribute(CC_RUNTIME_CLASS(AttrVariableWidth),(NodeAttribute**)(&pStroked)); if(pStroked && ((VariableWidthAttrValue*)pStroked->GetAttributeValue())->GetWidthFunction() != NULL) { ((NodePath *)pNode)->DoBecomeA(&MyBecomeA); } else { */ NodePath* pPathNode = ((NodePath *)pNode)->MakeNodePathFromAttributes(CurrentFlatness); if (pPathNode) { pPathNode->DoBecomeA(&MyBecomeA); delete pPathNode; } // } } else if (pNode->CanBecomeA(&MyBecomeA)) { // If the NumObjects > 0 then we`ve got a compound node of some sort! if (MyBecomeA.GetCount() > 0) { // is this a text node ? if (pNode->IS_KIND_OF(TextStory)) { // reformat it first ((TextStory *)pNode)->FormatAndChildren(); } else { // See if we`ve got any text in our compound, and if so format them! Node* pLid = pNode; Node* pNext = pNode; while(pNext) { pNext = SliceHelper::FindNextOfClass(pNext,pLid,CC_RUNTIME_CLASS(TextStory)); if(pNext) ((TextStory*)pNext)->FormatAndChildren(); } } if (!pNode->DoBecomeA(&MyBecomeA)) break; } if (MyBecomeA.GetCount() > 1) { TRACEUSER( "MarkH", _T("Clipping group to tidy things up!\n")); // Need to clip! CopyPath.ClearPath(); CopyPath.CloneFrom(m_Path); m_Path.ClearPath(); if(TempPath.ClipPathToPath(CopyPath,&m_Path,7|CLIPPING_SOURCE_WINDING,BevelClipPathToPath_Tolerance,CurrentFlatness,CurrentFlatness) < 0) { TRACEUSER( "MarkH", _T("ClipFailed!!! NodeBev.cpp\n")); } } } } } pNode = pNode->FindNext(); } // set all the filled flags on the path list m_OuterBevelPath.IsFilled = TRUE; m_OuterBevelPath.IsStroked = FALSE; // reverse the original path so it will create a hole in the bevel path Path ReversedPath; ReversedPath.Initialise(); ReversedPath.CloneFrom(m_Path); return ReverseAndShrinkBevelPathIntoInkPath(&ReversedPath, CurrentZoom, bOuter); }

KernelBitmap * NodeBevel::CreateBitmapCopy (  double  DPI = -1.0, BOOL  CheckFillFlags = TRUE )

Creates a BitmapCopy of the Bevel Bitmap including the current fills and transparency settings generated at the given DPI! Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> Date: 07/12/00 Parameters: DPI  to render with, if this is -1.0 the code will find the options value. [INPUTS] CheckFillFlags when TRUE will use the member variable flags to decide what to render. FALSE render it anyway. Definition at line 1968 of file nodebev.cpp. { m_AmConvertingToShapes = TRUE; NodeBevelController* pControl = (NodeBevelController *)FindParent(); INT32 NewDPI = 96; if(pControl && DPI == -1.0) { View* pView = View::GetCurrent(); if (pView) NewDPI = (INT32)pView->GetConvertToEditableShapesDPI(); } else NewDPI = (INT32)DPI; if(pControl) pControl->SetDPI(NewDPI); // The bitmap has not been rendered at this stage so we need to call the // appropriate render function! ERROR2IF(!RenderBitmapForDisplay(NULL),FALSE,"Failed to create the bevel bitmap!"); NodeAttribute* pFillAttrib = NULL; NodeAttribute* pFillMapAttr = NULL; NodeAttribute* pFillTranspMapAttr = NULL; NodeAttribute* pFillEffectAttr = NULL; DocColour FillColour = COLOUR_BLACK; // Get the Current Applied MappingFill from the bevel. FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillMapping),&pFillMapAttr); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrTranspFillMapping),&pFillTranspMapAttr); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillEffect),&pFillEffectAttr); // Test to see if theres a FillGeom Attribute applied to the bevel if(FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pFillAttrib)) { // If the pointer is valid and It`s a flat fill then get the colour and set the IsFlatFill Flag if(pFillAttrib != NULL && pFillAttrib->IsAFlatFill()) FillColour = *((AttrFlatColourFill*)pFillAttrib)->GetStartColour(); } // make sure the palette is setup ready for the BMP SetUpBitmapPalette((RenderRegion *)NULL,FillColour); KernelBitmap* pConvertedBMP = NULL; // We now need to check to see if we`re a Fourth state bevel, in which case we need to // Create a new fill bitmap using the current Bevel Bitmap! if(!m_IsFlatFilledOnly && (m_HasTransparencyApplied || !CheckFillFlags)) { // Ok, Lets setup a few variables need to create the new BMP View* pView = View::GetCurrent(); Matrix Mat(1,0,0,1,0,0); FIXED16 Scale = 1; DocRect RenderRect(m_BMPPoint2.x,m_BMPPoint1.y,m_BMPPoint1.x,m_BMPPoint2.y); Path InflatePath; InflatePath.Initialise(); InflatePath.CreatePathFromDocRect(&RenderRect); // Check to see if we`ve got an empty rect if so then return NULL! ERROR2IF(RenderRect.IsEmpty(),NULL,"We`ve got an empty DocRect in the selection! (CBMPBits)"); // Create a new GRenderBitmap region GRenderBitmap* pGBMP = new GRenderBitmap(RenderRect, Mat, Scale, 32, NewDPI, FALSE, 0, NULL, TRUE); if(pGBMP) { pGBMP->m_DoCompression = TRUE; if(!pGBMP->AttachDevice(pView, NULL, NULL)) { delete pGBMP; pGBMP = NULL; } else { // Get the Current Applied Fill from the bevel. NodeAttribute * pFillAttr = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pFillAttr); pGBMP->InitDevice(); pGBMP->InitAttributes(); pGBMP->RRQuality.SetQuality(QUALITY_MAX); pGBMP->SetQualityLevel(); pGBMP->SetLineAttributes(); pGBMP->SetFillAttributes(); pGBMP->StartRender(); pGBMP->GetDrawContext()->SetAntialiasFlag(0); // If found, render the current Fill Attribute if(pFillAttr) pFillAttr->Render(pGBMP); if(pFillMapAttr) pFillMapAttr->Render(pGBMP); if(pFillEffectAttr) pFillEffectAttr->Render(pGBMP); pGBMP->SetLineColour(COLOUR_NONE); pGBMP->SetLineWidth(50); if (m_pTranspFill) { TRACEUSER( "MarkH", _T("Rendering Transparent Fill!\n")); m_pTranspFill->SetStartPoint(&m_BMPCentre); m_pTranspFill->SetEndPoint (&m_BMPPoint1); m_pTranspFill->SetEndPoint2 (&m_BMPPoint2); m_pTranspFill->Render(pGBMP); } // We need to render the bevel object with the current attributes into the new region! pGBMP->DrawPath(&InflatePath); pGBMP->StopRender(); pConvertedBMP = new KernelBitmap(pGBMP->ExtractBitmapCopy()); delete pGBMP; pGBMP = NULL; } } } else { // Now make a copy of the bevel bitmap! pConvertedBMP = new KernelBitmap(m_pBevelBitmap->ActualBitmap->MakeCopy()); } return pConvertedBMP; }

KernelBitmap * NodeBevel::CreateCombinedBMPAndTranspFill (  RenderRegion *  pRegion = NULL  )  [protected]

Creates a new 32Bit Bitmap to hold the combined Transp & Bitmap Fill Attributes. Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> Date: 20/07/00 Parameters: pRegion  - The render region to use for rendering [INPUTS] return: An OIL Bitmap pointer of the new Bitmap! Definition at line 1618 of file nodebev.cpp. { // Get the current view pointer View* pView = View::GetCurrent(); // check the passed in pointer and view pointer if(pRegion == NULL || pView == NULL) return NULL; // Create a local OILBitmap pointer ready to hold the new BMP // Now we want a 32Bit BMP so lets setup a render region! KernelBitmap* pNewBMP = NULL; // Get the current pixel width as a scale value. double GScale = 1.0; double SPW = pRegion->GetScaledPixelWidth(); // TRACEUSER( "Gerry", _T("ScaledPixelWidth = %g\n"), SPW); // Do a quick check to make sure we don`t get any funny values! // 0 will obviously crash the dive later on! // Anything above 3750 will result in a scale factor of less than 0.2 and as this only happens // at zoom factors of 50% or less, we might as well leave the quality at a higher value as the // bitmaps will be very small anyway! if(SPW <= 0.0 || SPW > 3750.0) SPW = 3750.0; // TRACEUSER( "Gerry", _T("Using ScaledPixelWidth = %g\n"), SPW); DocRect RRect(m_BMPPoint2.x,m_BMPPoint1.y,m_BMPPoint1.x,m_BMPPoint2.y);// = m_PixelAllignedRect; // Get the Pixel Width and Height using the scaled pixel width. double ScaledWidth = (double)RRect.Width() / SPW; double ScaledHeight = (double)RRect.Height() / SPW; // TRACEUSER( "Gerry", _T("scaled size (%g, %g)\n"), ScaledWidth, ScaledHeight); // Check to see if we`ve gone over the bounds! if((ScaledWidth > BevelMaxBitmapWidth) || (ScaledHeight > BevelMaxBitmapHeight)) { // See which is the greater error if((BevelMaxBitmapWidth / ScaledWidth) >= (BevelMaxBitmapHeight / ScaledHeight)) { // WIDTH SPW = 750.0 / (BevelMaxBitmapWidth / ScaledWidth); GScale = BevelMaxBitmapWidth / ScaledWidth; } else { // HEIGHT SPW = 750.0 / (BevelMaxBitmapHeight / ScaledHeight); GScale = BevelMaxBitmapHeight / ScaledHeight; } // TRACEUSER( "Gerry", _T("Using changed ScaledPixelWidth = %g\n"), SPW); } // This GScale stuff causes problems and this routine should always create // a bitmap of the same size as the source bitmaps so it will always use 1.0 // Gerry 22/06/2004 #if FALSE // Get a pointer to the controller node! NodeBevelController * pControl = (NodeBevelController *)FindParent(); if(pControl && pRegion->IsPrinting()) { GScale = 96; Document* pDoc = pView->GetDoc(); PrintComponent *pPrintComponent = (PrintComponent *)pDoc->GetDocComponent(CC_RUNTIME_CLASS(PrintComponent)); if(pPrintComponent) { PrintControl *pPrintControl = pPrintComponent->GetPrintControl(); if(pPrintControl) GScale = 1.0 * pPrintControl->GetDotsPerInch() / 96.0; } } else { GScale = 750.0 / SPW; if(GScale > 1.0) GScale = 1.0; } #endif // TRACEUSER( "Gerry", _T("GScale = %g\n"), GScale); // Now Expand the Path by 1 Pixel! Path InflatePath; InflatePath.Initialise(); InflatePath.CreatePathFromDocRect(&RRect); // Get the Current Applied Fill from the bevel. NodeAttribute * pFillAttr = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pFillAttr); // Get the Current Applied MappingFill from the bevel. NodeAttribute * pFillMapAttr = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillMapping),&pFillMapAttr); BOOL bOldForce = pView->SetForceDefaultColourContexts(); // We need to save the current GDraw Context before we try to setup a new region! ConcurrentRenderer* pGOffScreen = new ConcurrentRenderer; if (pGOffScreen == NULL) { pView->SetForceDefaultColourContexts(bOldForce); ERROR2(NULL, "Failed to create a new Borrower Class!"); } // (ChrisG 8/5/2001) Try to initialise the context. If this fails, then we won't // have a bitmap to render things into, so we can't do a lot else. if (pGOffScreen->Initialise((GRenderRegion*)pRegion, GScale, RRect, 32, TRUE)) { GRenderRegion* pGBMP = pGOffScreen->GetRenderRegion(); // Now make sure the pointer is valid! if(pGBMP) { pGBMP->GetDrawContext()->SetAntialiasFlag(0); // If found, render the current Fill Attribute if(pFillAttr) pFillAttr->Render(pGBMP); if(pFillMapAttr) pFillMapAttr->Render(pGBMP); pGBMP->SetLineColour(COLOUR_NONE); pGBMP->SetLineWidth(50); if (m_pTranspFill) { TRACEUSER( "MarkH", _T("Rendering Transparent Fill!\n")); m_pTranspFill->SetStartPoint(&m_BMPCentre); m_pTranspFill->SetEndPoint (&m_BMPPoint1); m_pTranspFill->SetEndPoint2 (&m_BMPPoint2); m_pTranspFill->Render(pGBMP); } // We need to render the bevel object with the current attributes into the new region! pGBMP->DrawPath(&InflatePath); // NewBMP Now needs to be setup with the newly created bitmap pNewBMP = pGOffScreen->GetKernelBitmap(); // TRACEUSER( "Gerry", _T("Created combined bitmap (%d, %d)\n"), pNewBMP->GetWidth(), pNewBMP->GetHeight()); } else { ERROR3("Failed to create a new GRenderBitmap!"); } // Now restore the original render region! pGOffScreen->RestorePreviousRendererState(); } else { // Initialise failed and we don't have a bitmap to give back, so clean up and give // nothing back. delete pGOffScreen; pNewBMP = NULL; } pView->SetForceDefaultColourContexts(bOldForce); // Return the new Pointer return pNewBMP; }

void NodeBevel::DeleteCache (   )

Deletes all data held in this class. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 9/10/98 Parameters: -  [INPUTS] Returns: Definition at line 2974 of file nodebev.cpp. { m_bCached = FALSE; if (m_pBevelBitmap) { m_pBevelBitmap->Detach(); delete m_pBevelBitmap; m_pBevelBitmap = NULL; } if (m_pBeveler) { delete m_pBeveler; m_pBeveler = NULL; } InkPath.ClearPath(); m_OuterBevelPath.ClearPath(); m_ShrunkPath.ClearPath(); m_Path.ClearPath(); InvalidateMe(); }

void NodeBevel::DeleteCachedBitmap (   )

Deletes the current Bevel Bitmap. Mainly used when printing to reduce memory usage. Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> Date: 9/10/98 Parameters: -  [INPUTS] Returns: Definition at line 2948 of file nodebev.cpp. { if(m_pBevelBitmap) { m_pBevelBitmap->Detach(); m_pBevelBitmap->DestroyGreyscaleVersion(); delete m_pBevelBitmap; m_pBevelBitmap = NULL; } if(m_pCombiBitmap) { delete m_pCombiBitmap; m_pCombiBitmap = NULL; } }

String NodeBevel::Describe (  BOOL  Plural, BOOL  Verbose = TRUE )  [virtual]

Default constructor Note:. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/98 See also: Reimplemented from Node. Definition at line 375 of file nodebev.cpp. { String Name; Name.Load(_R(IDS_BEVEL_NODE_NAME)); return Name; // Just to keep the compiler happy };

void NodeBevel::DisableRendering (   )  [inline]

Definition at line 201 of file nodebev.h. { m_bStopRender = TRUE; }

BOOL NodeBevel::DoBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Converts me to a path. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 26/2/99 Parameters: BecomeA  struct [INPUTS] See also: Reimplemented from Node. Definition at line 2113 of file nodebev.cpp. { // Check for a NULL entry param ERROR2IF_PF(pBecomeA == NULL,FALSE,("pBecomeA is NULL")); if (!pBecomeA->BAPath()) return FALSE; // This lump checks that the Reason is one that we understand // It also makes sure that we don't have a NULL UndoOp ptr BOOL ValidReason = (pBecomeA->GetReason() == BECOMEA_REPLACE || pBecomeA->GetReason() == BECOMEA_PASSBACK); ERROR2IF_PF(!ValidReason,FALSE,("Unkown BecomeA reason %d",pBecomeA->GetReason())); NodePath * pNewNodePath = NULL; Node * pBevelStartNode = NULL; NodeRenderableInk * pParent = NULL; NodeHidden * pHiddenNode = NULL; NodeAttribute * pAttr = NULL; // NodeAttribute * pAttrT = NULL; // AttrStrokeTransp * pStrokeColour1 = NULL; // BitmapFillAttribute * pBitmapFill = NULL; // AttrFillMappingLinear * pFillMapping = NULL; AttrStrokeColour * pStrokeColour = NULL; AttrLineWidth * pLineWidth = NULL; NodeAttribute* pFillMapAttr = NULL; NodeAttribute* pFillTranspMapAttr = NULL; NodeAttribute* pFillEffectAttr = NULL; // UINT32 startTrans = 0x00; // UINT32 endTrans = 0xff; DocColour dcNone(COLOUR_NONE); switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE: { // Mark Howitt 15/08/00 - Rewrite of david code!!!! // What we need to do here is be quite warry of the current set up of our bevels!! There are four types we can // have which are as follows... // // 1. Flat filled bevel NO transparency. This type is as with all the others is made up of just one // shape that just has a bitmap fill of the bevel. // 2. Flat filled WITH transparency. As type 1 but with the transparency applied as normal. // 3. NON Flat fill NO transparency. This type has the bevel bitmap as a transparency bitmap fill with applied // NON flat fill as normal. // 4. NON Flat filled WITH Transparency. NOTE! These are a special case as both the transparent and normal fill // attributes are already taken! In this case there is an off screen Bitmap render of the normal fill and the bevel bitmap // as a tranparency ( Not the applied transparency ) which replaces the normal fill. This means the bevel bitmap // is merged into the original fill to make a new one( 32Bit Alpha Channeled!!!) The Original transparency is rendered // as normal! // // As you can see we`ve got 4 cases that are different and will need to be converted in different ways! // The main variables which decide the the current state are... // m_IsFlatFilledOnly - which tells you wether you`ve got just a flat fill attribute. // m_HasTransparencyApplied - which indicates wether there is any transparency applied. // therefore the states match up as follows... // // 1. m_IsFlatFilledOnly && !m_HasTransparencyApplied // 2. m_IsFlatFilledOnly && m_HasTransparencyApplied // 3. !m_IsFlatFilledOnly && !m_HasTransparencyApplied // 4. !m_IsFlatFilledOnly && m_HasTransparencyApplied // CGS: actually this is more complex - because we can have ilans wonderful feathers knocking // around in here !!!! I have decided that the best way to account for this is to check for // the feather attribute directly within each of marks four cases .... // First things first, lets make a new NodePath to hold all the bevel info! // Get a pointer to the undo op and create a new path undoably! UndoableOperation* pOp = pBecomeA->GetUndoOp(); ALLOC_WITH_FAIL(pNewNodePath, new NodePath, pOp); /* NodeAttribute* pFillAttrib = NULL; DocColour FillColour = COLOUR_BLACK; // Get the Current Applied MappingFill from the bevel. FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillMapping),&pFillMapAttr); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrTranspFillMapping),&pFillTranspMapAttr); FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillEffect),&pFillEffectAttr); // Test to see if theres a FillGeom Attribute applied to the bevel if(FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pFillAttrib)) { // If the pointer is valid and It`s a flat fill then get the colour and set the IsFlatFill Flag if(pFillAttrib != NULL && pFillAttrib->IsAFlatFill()) FillColour = *((AttrFlatColourFill*)pFillAttrib)->GetStartColour(); } // make sure the palette is setup ready for the BMP SetUpBitmapPalette((RenderRegion *)NULL,FillColour); KernelBitmap* pConvertedBMP = NULL; // We now need to check to see if we`re a Fourth state bevel, in which case we need to // Create a new fill bitmap using the current Bevel Bitmap! if(!m_IsFlatFilledOnly && m_HasTransparencyApplied) { // Ok, Lets setup a few variables need to create the new BMP View* pView = View::GetCurrent(); Matrix Mat(1,0,0,1,0,0); FIXED16 Scale = 1; DocRect RenderRect(m_BMPPoint2.x,m_BMPPoint1.y,m_BMPPoint1.x,m_BMPPoint2.y); Path InflatePath; InflatePath.Initialise(); InflatePath.CreatePathFromDocRect(&RenderRect); // Check to see if we`ve got an empty rect if so then return NULL! ERROR2IF(RenderRect.IsEmpty(),NULL,"We`ve got an empty DocRect in the selection! (CBMPBits)"); // Create a new GRenderBitmap region GRenderBitmap* pGBMP = new GRenderBitmap(RenderRect, Mat, Scale, 32, DPI, FALSE, 0, NULL, TRUE); if(pGBMP) { pGBMP->m_DoCompression = TRUE; if(!pGBMP->AttachDevice(pView, NULL, NULL)) { delete pGBMP; pGBMP = NULL; } else { // Get the Current Applied Fill from the bevel. NodeAttribute * pFillAttr = NULL; FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pFillAttr); pGBMP->InitDevice(); pGBMP->InitAttributes(); pGBMP->RRQuality.SetQuality(QUALITY_MAX); pGBMP->SetQualityLevel(); pGBMP->SetLineAttributes(); pGBMP->SetFillAttributes(); pGBMP->StartRender(); pGBMP->GetDrawContext()->SetAntialiasFlag(0); // If found, render the current Fill Attribute if(pFillAttr) pFillAttr->Render(pGBMP); if(pFillMapAttr) pFillMapAttr->Render(pGBMP); if(pFillEffectAttr) pFillEffectAttr->Render(pGBMP); pGBMP->SetLineColour(COLOUR_NONE); pGBMP->SetLineWidth(50); if (m_pTranspFill) { TRACEUSER( "MarkH", _T("Rendering Transparent Fill!\n")); m_pTranspFill->SetStartPoint(&m_BMPCentre); m_pTranspFill->SetEndPoint (&m_BMPPoint1); m_pTranspFill->SetEndPoint2 (&m_BMPPoint2); m_pTranspFill->Render(pGBMP); } // We need to render the bevel object with the current attributes into the new region! pGBMP->DrawPath(&InflatePath); pGBMP->StopRender(); pConvertedBMP = new KernelBitmap(pGBMP->ExtractBitmapCopy()); delete pGBMP; pGBMP = NULL; } } } else { // Now make a copy of the bevel bitmap! pConvertedBMP = new KernelBitmap(m_pBevelBitmap->ActualBitmap->MakeCopy()); } */ // If the path to be bevelled has no points then don't insert anything to replace this node BOOL bCreateNew = (m_Path.GetNumCoords() != 0); KernelBitmap* pConvertedBMP = NULL; if (bCreateNew) { pConvertedBMP = CreateBitmapCopy(); if(!pConvertedBMP) { ERROR3("Failed To Create Bevel Bitmap Copy!"); return FALSE; } else { NodeCompound* pControl = GetParentController(); if (pControl != NULL) { LPBITMAPINFOHEADER pBevelHeader = pConvertedBMP->GetBitmapInfoHeader(); const double PixPerMetre = pControl->GetDPI() * INCHES_PER_METRE; pBevelHeader->biXPelsPerMeter = pBevelHeader->biYPelsPerMeter = (INT32)(PixPerMetre + 0.5); } pConvertedBMP->Attach(Document::GetCurrent()->GetBitmapList()); } // Now delete the bevel bitmap as when undoing it will automatically be recreated! if(m_pBevelBitmap) { delete m_pBevelBitmap; m_pBevelBitmap = NULL; } // Make sure that our fill attributes reference the new bitmap! m_pBMPFill->BitmapRef.SetBitmap(pConvertedBMP); m_pTranspFill->BitmapRef.SetBitmap(pConvertedBMP); if (m_pCombiBitmap) { delete m_pCombiBitmap; m_pCombiBitmap = NULL; } m_pBMPFill->SetStartPoint(&m_BMPCentre); m_pBMPFill->SetEndPoint(&m_BMPPoint1); m_pBMPFill->SetEndPoint2(&m_BMPPoint2); m_pTranspFill->SetStartPoint(&m_BMPCentre); m_pTranspFill->SetEndPoint(&m_BMPPoint1); m_pTranspFill->SetEndPoint2(&m_BMPPoint2); // Copy the current bevel path into the new path with flattening pNewNodePath->InkPath.Initialise(); pNewNodePath->InkPath.CloneFrom(InkPath); pNewNodePath->InkPath.IsFilled = TRUE; pNewNodePath->InkPath.TryToClose(); pNewNodePath->InkPath.InitialiseFlags(); // Make sure that we copy across the Feather attribute if there`s one there! if(FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFeather),&pAttr)) pAttr->CopyNode(pNewNodePath, FIRSTCHILD); // First state check if(m_IsFlatFilledOnly && !m_HasTransparencyApplied) { // STATE 1 if(m_pBMPFill) { // Make sure the Fill attributes point to the new bitmap! pAttr = m_pBMPFill->MakeNode(); pAttr->AttachNode(pNewNodePath,FIRSTCHILD); } } else if((m_IsFlatFilledOnly && m_HasTransparencyApplied) || (!m_IsFlatFilledOnly && m_HasTransparencyApplied)) { // STATE 2 OR STATE 4 if(FindAppliedAttribute(CC_RUNTIME_CLASS(AttrTranspFillGeometry),&pAttr)) pAttr->CopyNode(pNewNodePath, FIRSTCHILD); if(m_pBMPFill) { // Make sure the Fill attributes point to the new bitmap! pAttr = m_pBMPFill->MakeNode(); pAttr->AttachNode(pNewNodePath,FIRSTCHILD); } } else { // STATE 3 if(FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pAttr)) pAttr->CopyNode(pNewNodePath, FIRSTCHILD); if(m_pTranspFill) { // Make sure the Fill attributes point to the new bitmap! pAttr = m_pTranspFill->MakeNode(); pAttr->AttachNode(pNewNodePath,FIRSTCHILD); } } // Make sure the line width is none as they shouldn`t have outlines! ALLOC_WITH_FAIL(pLineWidth, new AttrLineWidth, pOp); pLineWidth->Value.LineWidth = 50; pLineWidth->AttachNode(pNewNodePath, FIRSTCHILD); // Also make the line colour NONE ALLOC_WITH_FAIL(pStrokeColour, new AttrStrokeColour, pOp); pStrokeColour->SetStartColour(&dcNone); pStrokeColour->AttachNode(pNewNodePath, FIRSTCHILD); if(pFillMapAttr) pFillMapAttr->CopyNode(pNewNodePath,FIRSTCHILD); if(pFillTranspMapAttr) pFillTranspMapAttr->CopyNode(pNewNodePath,FIRSTCHILD); if(pFillEffectAttr) pFillEffectAttr->CopyNode(pNewNodePath,FIRSTCHILD); } m_AmConvertingToShapes = FALSE; // hide the bevel start node & me and // insert the ink path node pParent = (NodeRenderableInk *)FindParent(); if (pParent) { // first, remove all existing line widths // and also all bevel attributes // TODOG: This must all work with a NULL pOp pointer!!! pBevelStartNode = pParent->FindFirstChild(CC_RUNTIME_CLASS(NodeBevelBegin)); if (pOp) { pOp->DoRemoveAttrTypeFromSubtree(pParent, CC_RUNTIME_CLASS(AttrBevelLightAngle)); pOp->DoRemoveAttrTypeFromSubtree(pParent, CC_RUNTIME_CLASS(AttrBevelType)); pOp->DoRemoveAttrTypeFromSubtree(pParent, CC_RUNTIME_CLASS(AttrBevelContrast)); pOp->DoRemoveAttrTypeFromSubtree(pParent, CC_RUNTIME_CLASS(AttrBevelIndent)); if (bCreateNew) { // insert all the nodes if(!m_bOuter) pOp->DoInsertNewNode(pNewNodePath, pParent, LASTCHILD, TRUE, FALSE, FALSE, TRUE); else pOp->DoInsertNewNode(pNewNodePath, pBevelStartNode, NEXT, TRUE, FALSE, FALSE, TRUE); } if (pBevelStartNode) pOp->DoHideNode(pBevelStartNode, TRUE, &pHiddenNode, FALSE); } else { pParent->RemoveAttrTypeFromSubtree(CC_RUNTIME_CLASS(AttrBevelLightAngle)); pParent->RemoveAttrTypeFromSubtree(CC_RUNTIME_CLASS(AttrBevelType)); pParent->RemoveAttrTypeFromSubtree(CC_RUNTIME_CLASS(AttrBevelContrast)); pParent->RemoveAttrTypeFromSubtree(CC_RUNTIME_CLASS(AttrBevelIndent)); if (bCreateNew) { // insert all the nodes if(!m_bOuter) pNewNodePath->AttachNode(pParent, LASTCHILD, FALSE, FALSE); else pNewNodePath->AttachNode(pBevelStartNode, NEXT, FALSE, FALSE); } if (pBevelStartNode) { pBevelStartNode->CascadeDelete(); delete pBevelStartNode; } } } if (bCreateNew) { CCAttrMap ThisMap; if (!pNewNodePath->FindAppliedAttributes(&ThisMap)) return FALSE; CCAttrMap* pThisMap = ThisMap.Copy(); if (pThisMap) { if (pThisMap->Lookup(CC_RUNTIME_CLASS(AttrStrokeColour), (void *&)(pStrokeColour))) { if (pStrokeColour && pStrokeColour->GetStartColour()) pStrokeColour->SetStartColour(&dcNone); } } pBecomeA->PassBack(pNewNodePath, this, pThisMap); } // now hide me too if (pOp) pOp->DoHideNode(this, TRUE, &pHiddenNode, FALSE); else { CascadeDelete(); delete this; } } break; case BECOMEA_PASSBACK: { // we need to pass back 2 node paths, with appropriate attributes maps pNewNodePath = new NodePath; ERRORIF(pNewNodePath == NULL, _R(IDE_NOMORE_MEMORY), FALSE); // clone the ink path from me ! pNewNodePath->InkPath.Initialise(); pNewNodePath->InkPath.CloneFrom(InkPath); pNewNodePath->InkPath.IsFilled = TRUE; pNewNodePath->InkPath.TryToClose(); pNewNodePath->InkPath.InitialiseFlags(); // if we're passing back, just do the first path CCAttrMap ThisMap; if (!FindAppliedAttributes(&ThisMap)) return FALSE; // make a copy of this attribute map CCAttrMap * pNewAttrMap = ThisMap.Copy(); // get the stroke colour attribute out of this map and set it to COLOUR_NONE if( pNewAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStrokeColour), (void *&)(pStrokeColour))) { if (pStrokeColour && pStrokeColour->GetStartColour()) pStrokeColour->SetStartColour(&dcNone); } // ok, now lets set up the attribute maps pBecomeA->PassBack(pNewNodePath, this, pNewAttrMap); } break; default: break; } return TRUE; }

void NodeBevel::DoRender (  BOOL  DoRender = TRUE  )  [inline]

Definition at line 262 of file nodebev.h. { m_DoRender = DoRender; }

void NodeBevel::EnableRendering (   )  [inline]

Definition at line 202 of file nodebev.h. { m_bStopRender = FALSE; }

INT32 NodeBevel::EstimateNodeComplexity (  OpParam *  details  )  [virtual]

This function estimates a complexity value for the node. The complexity value is based upon the total length of all paths in the node. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 6/09/2000 Parameters: details  any data that should be used for the calculation [INPUTS] -  [OUTPUTS] Returns: an estimate of the nodes complexity See Also: OpBlendNodes::DeterminBlendObjectsProcessorHit () Reimplemented from Node. Definition at line 3763 of file nodebev.cpp. { return (InkPath.GetUsedSlots ()); }

BOOL NodeBevel::ExportRender (  RenderRegion *  pRegion  )  [virtual]

If pRenderRegion points to a FlashRenderRegion, the bevel will be processed as a bitmap filled shape, and stored as a pair of records (shape and bitmap) within the resulting Flash file. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/99 Parameters: pRegion  - A pointer to a RenderRegion. [INPUTS] -  [OUTPUTS] Returns: TRUE if custom export code is invoked, otherwise FALSE. If pRenderRegion points to a CMXRenderRegion, a similar conversion function will be invoked. Reimplemented from NodeRenderableInk. Definition at line 3824 of file nodebev.cpp. { BOOL bResult = FALSE; // NodeBevelController * pController = (NodeBevelController *)FindParent(); // Step 1: If the RenderRegion is a FlashRenderRegion, use custom Flash export code. if ( pRegion->IsKindOf ( CC_RUNTIME_CLASS ( FlashRenderRegion ) ) ) { // Step 1a: Cast the pRegion pointer to be a FlashRenderRegion pointer, so that // it can access the custom Flash export methods. FlashRenderRegion *pFlash = ( FlashRenderRegion* ) pRegion; // Step 1b: Pass the character into the appropriate method to export the character. // This is where all the hard work is done. bResult = pFlash->ExportBevel ( this ); } PORTNOTE("cmx", "Removed CMX Support") #ifndef EXCLUDE_FROM_XARALX // Step 2: Otherwise check whether it's a CMXRenderRegion. else if ( pRegion->IsKindOf ( CC_RUNTIME_CLASS ( CMXRenderRegion ) ) ) { // Step 2a: Cast the pRegion pointer to be a CMXRenderRegion pointer. CMXRenderRegion *pCMX = ( CMXRenderRegion* ) pRegion; // Step 2b: Pass the character into the appropriate method to export the character. // This is where all the hard work is done. bResult = pCMX->ExportBevel ( this ); } #endif // Step 3: Otherwise check whether it's an AIEPSRenderRegion. else if ( pRegion->IsKindOf ( CC_RUNTIME_CLASS ( AIEPSRenderRegion ) ) ) { // Step 3a: Cast the pRegion pointer to be a CMXRenderRegion pointer. AIEPSRenderRegion *pAIEPS = ( AIEPSRenderRegion* ) pRegion; // Step 3b: Pass the character into the appropriate method to export the character. // This is where all the hard work is done. bResult = pAIEPS->ExportBevel ( this ); } // Step 4: The export has been done successfully. Return TRUE to prevent Camelot // from rendering the character out as paths as well as text. (If there's // been an error, bResult will have been set to FALSE.) return bResult; }

void NodeBevel::Extend (  const ExtendParams &  ExtParams  )  [virtual]

Perform an Extend operation on this Node, and its children if appropriate. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/1999 Parameters: ExtParams  description parameters for the extension. [INPUTS] Some  of the child nodes of this BevelNode's NodeBevelController may have [OUTPUTS] their dimensions altered. Returns: A NodeBevel cannot itself extend, so instead it asks its parent controller to extend for it. Infinite recursion does not occur, as the controller node ignores its child node, this NodeBevel. Returns: Errors: In debug builds, ERROR3 if this Node has no NodeBevelController, in release, we do nothing. See also: Reimplemented from Node. Definition at line 3728 of file nodebev.cpp. { Node* pBob = GetParentController(); if (pBob == NULL) { ERROR3("NodeBevel::ValidateExtend- no controller Node found!"); } else pBob->Extend(ExtParams); return; }

BOOL NodeBevel::GenerateBevel (   )

Creates the beveller class, and the beveller bitmap Note:. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/98 See also: ContourBecomeA Definition at line 394 of file nodebev.cpp. { NodeBevelController* pControl = (NodeBevelController *)FindParent(); if ( !pControl ) return FALSE ; // are we safe to render ? if ( pControl->GetInsideBoundingRect().IsEmpty() ) return FALSE; BOOL ok = TRUE; // Check the current bitmap pointers and delete them if still valid if (m_pBMPFill) { delete m_pBMPFill; m_pBMPFill = NULL; } if (m_pTranspFill) { delete m_pTranspFill; m_pTranspFill = NULL; } if (m_pCombiBitmap) { delete m_pCombiBitmap; m_pCombiBitmap = NULL; } // Create a new pointer for the bitmap and Transp Bitmap fill Attributes m_pBMPFill = new BitmapFillAttribute; ERROR2IF(m_pBMPFill == NULL,FALSE,"Failed to create a new BMP Fill Attrib!"); m_pTranspFill = new BitmapTranspFillAttribute; ERROR2IF(m_pTranspFill == NULL,FALSE,"Failed to create a new TranspBMP Fill Attrib!"); UINT32 startTrans = 0x00; UINT32 endTrans = 0xff; m_pTranspFill->SetTranspType(TT_BEVEL); m_pTranspFill->SetStartTransp(&startTrans); m_pTranspFill->SetEndTransp(&endTrans); m_pTranspFill->SetTesselation(RT_RepeatInverted); m_pBMPFill->SetTesselation(RT_RepeatInverted); // set up the variables on myself & my parent by finding the appropriate attributes // create all the paths for the bevel // no need to do this if we're printing - they should already be set up if (!SetupVariables() || !CreateBevelPaths()) ok = FALSE; return ok; }

BOOL NodeBevel::GenerateBevelForBlendStep (  SumAllPathsElem *  pElem, CCAttrMap *  pAttrMap )

Creates the bevel data from the given list of SumAllPathsElem. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 29/2/2000 Note: Takes the variables from FindAppliedAttribute therefore the attributes should be applied to this node before calling this function See also: ContourBecomeA Definition at line 463 of file nodebev.cpp. { // set up the variables on myself if (!SetupVariables(pAttrMap)) return FALSE; m_ViewScale = 0; BOOL bOuter = m_bOuter; INT32 Width = m_Indent; m_OuterBevelPath.ClearPath(); m_Path.ClearPath(); CProfileBiasGain Profile; // CGS - we need to generate the bevel with respect to the JoinType applied to the path // that we are generating it with; BUT if the original bevel had a jointype; then we need // to generate it with respect to this! JointType generateJoinType=MitreJoin; AttrJoinType * pJoinType = NULL; AttrJoinType * pBevelJoinType = NULL; pElem->GetAttrMap ()->Lookup( CC_RUNTIME_CLASS(AttrJoinType), (void *&)pJoinType); pAttrMap->Lookup( CC_RUNTIME_CLASS(AttrJoinType), (void *&)pBevelJoinType); if (pJoinType && pBevelJoinType) { if (*pJoinType == *pBevelJoinType) generateJoinType = pJoinType->Value.JoinType; else generateJoinType = pBevelJoinType->Value.JoinType; } // use the contour becomeA to generate all the paths ContourBecomeA MyBecomeA(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL, FALSE, &m_OuterBevelPath, &m_Path, Width, 1, bOuter, Profile,generateJoinType, BevelClipPathToPath_Flatness,TRUE); Path BlankPath; BlankPath.Initialise(); NodePath* pPathNode = new NodePath; ERRORIF(pPathNode == NULL, _R(IDE_NOMORE_MEMORY), FALSE); pPathNode->InkPath.Initialise(); pElem->GetPath()->ClipPathToPath(BlankPath, &(pPathNode->InkPath), 6); NodePath* pStrokedPathNode = pPathNode->MakeNodePathFromAttributes(30, pElem->GetAttrMap()); if (pStrokedPathNode) { pStrokedPathNode->DoBecomeA(&MyBecomeA); delete pStrokedPathNode; } delete pPathNode; pPathNode = NULL; if(m_Path.GetUsedSlots() <= 0) return TRUE; m_IsABlendStepBevel = TRUE; // set all the filled flags on the path list m_OuterBevelPath.IsFilled = TRUE; m_OuterBevelPath.IsStroked = FALSE; // reverse the original path so it will create a hole in the bevel path Path ReversedPath; ReversedPath.Initialise(); ReversedPath.CloneFrom(m_Path); // Check to see what the zoom factor is so we can take it into account for the flatness values! DocView* pDocView = Document::GetCurrent()->GetFirstDocView(); double CurrentZoom = 1.0; if(pDocView) CurrentZoom = pDocView->GetZoomFactor(); ReverseAndShrinkBevelPathIntoInkPath(&ReversedPath, CurrentZoom, bOuter); // now the path has been created, create the bevel bitmap if (!CreateBevelBitmap()) return FALSE; m_bCached = TRUE; return TRUE; }

KernelBitmap* NodeBevel::GetBevelBitmap (   )  const [inline]

Definition at line 264 of file nodebev.h. { return m_pBevelBitmap; }

Path* NodeBevel::GetBevelPath (   )  [inline]

Definition at line 260 of file nodebev.h. { return &m_Path; }

BitmapFillAttribute * NodeBevel::GetBitmapFillAttribute (  void   )

Returns a pointer to the bitmap fill contained within NoveBevel. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/99 Parameters: -  [INPUTS] Returns: A constant pointer to m_pBMPFill. Definition at line 2597 of file nodebev.cpp. { return m_pBMPFill; }

DocRect NodeBevel::GetBlobBoundingRect (   )  [virtual]

Calculates the bounding rectangle of the nodes blobs.This should always be calculated on the fly as the view scale can change without the node knowing, giving an incorrect result. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/94 Returns: DocRect - The rectangle that contains all the nodes selection blobs. Reimplemented from NodeRenderable. Definition at line 2673 of file nodebev.cpp. { // now, find out if the blob manager's interest is in artistic blobs or not BlobManager* BlobMgr = GetApplication()->GetBlobManager(); BlobStyle BS = BlobMgr->GetCurrentInterest(TRUE); INT32 BlobSize = BlobMgr->GetBlobSize(); DocRect br = GetBoundingRect(); br.lo.x -= BlobSize; br.lo.y -= BlobSize; br.hi.x += BlobSize; br.hi.y += BlobSize; IncludeChildrensBoundingRects(&br); // is the bevel tool active ? if (Tool::GetCurrentID() != TOOLID_BEVELTOOL || !BevelTool::AmActive()) return br; DocRect BlobRect; // calculate the position of the light angle blob DocCoord blob( (br.hi.x+br.lo.x)>>1, (br.hi.y+br.lo.y)>>1 ); View * pView = View::GetCurrent(); if (!pView) return br; INT32 iLen = (INT32)(pView->GetScaledPixelWidth().MakeDouble()*40) ; // get from the blob manager the size of blobs if (pView) { iLen += (INT32)(pView->GetScaledPixelWidth().MakeDouble()*15); iLen += GetApplication()->GetBlobManager()->GetBlobSize(); } DocRect dr; // calculate the rect for the blob dr.lo.x = blob.x - iLen; dr.lo.y = blob.y - iLen; dr.hi.x = blob.x + iLen; dr.hi.y = blob.y + iLen; BlobRect = br; // finally, union this with the standard group's bounding rect to give // the true blob bounding rect BlobRect = BlobRect.Union(dr); return BlobRect; }

DocRect NodeBevel::GetBoundingRect (  BOOL  DontUseAttrs = FALSE, BOOL  HitTest = FALSE )  [virtual]

Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 7/10/98 Parameters: -  [INPUTS] Returns: The bounding rect for the bevel Reimplemented from NodeRenderableBounded. Definition at line 2612 of file nodebev.cpp. { if ( IsBoundingRectValid && !DontUseAttrs ) return BoundingRectangle; DocRect dr(0,0,0,0); // run through all previous nodes calculating their bounding rects if (InkPath.GetNumCoords() == 0) { Node* pNode = NULL; if(m_bOuter) pNode = FindNext(CC_RUNTIME_CLASS(NodeRenderableBounded)); else pNode = FindPrevious(CC_RUNTIME_CLASS(NodeRenderableBounded)); if (!pNode) return DocRect(0,0,0,0); while (pNode) { if (pNode->IsRenderable() && !pNode->IsAnAttribute() && !pNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevelBegin)) && !pNode->IsNodeHidden()) { if (pNode->IsNodePath()) { // rough guess of how big the path bounding rect is NodePath * pNodePath = ((NodePath *)pNode)->MakeNodePathFromAttributes(BevelClipPathToPath_Flatness); DocRect dr2(0,0,0,0); pNodePath->InkPath.GetTrueBoundingRect(&dr2); dr = dr.Union(dr2); delete pNodePath; } else dr = dr.Union(((NodeRenderableBounded *) pNode)->GetBoundingRect(DontUseAttrs, HitTest)); } if(m_bOuter) pNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeRenderableBounded)); else pNode = pNode->FindPrevious(CC_RUNTIME_CLASS(NodeRenderableBounded)); } BoundingRectangle = dr; if (m_bOuter) BoundingRectangle.Inflate(m_Indent * 2); } else InkPath.GetTrueBoundingRect(&BoundingRectangle); IsBoundingRectValid = TRUE; return BoundingRectangle; }

void NodeBevel::GetDebugDetails (  StringBase *  Str  )  [virtual]

Builds debug info for camelot tree dialog. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 07/07/2005 Parameters: Str  - pointer to a StringBase [INPUTS] Reimplemented from NodeRenderableBounded. Definition at line 3909 of file nodebev.cpp. { #if DEBUG_TREE // Call base class NodeRenderableInk::GetDebugDetails( Str ); String_256 TempStr; String_256 TempStr2; (*Str) += TEXT( "\r\nNodeBevel Data Dump\r\n" ); DocRect BlobRect = GetBlobBoundingRect(); TempStr._MakeMsg( TEXT("Blob Bounding Rect :\r\n\t#1%ld,\t#2%ld\r\n\t#3%ld,\t#4%ld\r\n"), BlobRect.lo.x, BlobRect.lo.y, BlobRect.hi.x, BlobRect.hi.y ); (*Str) += TempStr; TempStr._MakeMsg( TEXT("Type :\t#1%d\r\n"), m_BevelType); (*Str) += TempStr; #endif }

DocRect NodeBevel::GetInsideBoundingRect (   )

Gets the bounding rect of the original (non-bevelled) objects See also: NodeCompound::OnChildChange. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 27/7/99 Parameters: [INPUTS]  Returns: A bounding rect Definition at line 3443 of file nodebev.cpp. { Node * pNode = FindPrevious(); DocRect dr(0,0,0,0); while (pNode) { if (pNode->IsAnObject() && !pNode->IsNodeHidden() && pNode->IsBounded() && !pNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevelBegin))) { dr = dr.Union(((NodeRenderableBounded *)pNode)->GetBoundingRect()); } pNode = pNode->FindPrevious(); } return dr; }

Path* NodeBevel::GetOuterBevelPath (   )  [inline]

Definition at line 259 of file nodebev.h. { return &m_OuterBevelPath; }

NodeCompound * NodeBevel::GetParentController (   )  const [virtual]

Returns a type correct pointer to the parent Bevel controller. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 4/12/96 Parameters: -  [INPUTS] Returns: Pointer to parent Bevel controller (NULL if not found!) Reimplemented from Node. Definition at line 2926 of file nodebev.cpp. { NodeBevelController* pBob = (NodeBevelController*)FindParent(); if (pBob != NULL && !IS_A(pBob, NodeBevelController)) { ERROR3("Parent of Bevel was not a NodeBevelController"); pBob = NULL; } return pBob; }

DocRect NodeBevel::GetPathBoundingRect (   )  [inline]

Definition at line 217 of file nodebev.h. { return m_Path.GetBoundingRect(); }

BOOL NodeBevel::GetRenderBitmaps (   )  [inline]

Definition at line 242 of file nodebev.h. { return m_bRenderBitmaps; }

void NodeBevel::InvalidateMe (   )  [inline]

Definition at line 197 of file nodebev.h. {};

virtual BOOL NodeBevel::IsABevel (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 185 of file nodebev.h. { return TRUE; }

BOOL NodeBevel::IsNodePath (   )  const [virtual]

Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 9/10/98 Parameters: -  [INPUTS] Returns: FALSE always since I'm not a path - just am pretending to be one Reimplemented from Node. Definition at line 3048 of file nodebev.cpp. { return FALSE; }

BOOL NodeBevel::IsRenderingStopped (   )  [inline]

Definition at line 203 of file nodebev.h. { return m_bStopRender; }

virtual BOOL NodeBevel::IsTypeExtendible (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 235 of file nodebev.h. { return TRUE; }

BOOL NodeBevel::NeedsParent (  Node *  pNode  )  const [virtual]

Do we need a parent of the same class as the given node ??? See also: NodeCompound::OnChildChange. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 7/5/99 Parameters: A  node to do the class checking on [INPUTS] Returns: Reimplemented from Node. Definition at line 3419 of file nodebev.cpp. { if (!pNode) return TRUE; if (pNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevelController))) return TRUE; return FALSE; }

BOOL NodeBevel::NeedsTransparency (  void   )  const [virtual]

We sure do need transparency ! Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 4/12/98 Parameters: -  [INPUTS] Returns: TRUE Reimplemented from Node. Definition at line 2828 of file nodebev.cpp. { return TRUE; }

BOOL NodeBevel::OnNodePopUp (  Spread *  pSpread, DocCoord  PointerPos, ContextMenu *  pMenu )  [virtual]

Allows the shadow to respond to the click. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 7/2/2000 Parameters: pSpread  The spread in which things are happening [INPUTS] PointerPos The Location of the mouse pointer at the time of the click pMenu The menu to which items should be added Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeRenderableInk. Definition at line 3885 of file nodebev.cpp. { BOOL ok = TRUE; PORTNOTETRACE("other","NodeBevel::ExportRender - do nothing"); #ifndef NO_ADVANCED_TOOLS ok = ok && pMenu->BuildCommand(TOOL_OPTOKEN_BEVEL, TRUE); #endif return ok; }

void NodeBevel::PolyCopyNodeContents (  NodeRenderable *  pNodeCopy  )  [virtual]

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/12/2003 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeRenderableBounded. Definition at line 3245 of file nodebev.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeBevel), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeBevel)) CopyNodeContents((NodeBevel*)pNodeCopy); }

BOOL NodeBevel::PostDuplicate (  UndoableOperation *  pOp  )  [virtual]

Regens the node after a duplication. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/99 Parameters: -  [INPUTS] Returns: - Reimplemented from Node. Definition at line 3265 of file nodebev.cpp. { // set my variables from the parent return TRUE; }

void NodeBevel::PreExportRender (  RenderRegion *  pRegion  )  [virtual]

Perform any rendering required when exporting to a file, and this node is being 'passed by' during the tree searching. For example, a group node being exported to EPS would output a "start group" token, and then its ExportRender function would output a "end group" token. By default, it does nothing. Nodes wishing to do special export processing should override this function (and ExportRender). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 25/03/94 Parameters: pRender  - the render region we are exporting to. [INPUTS] See also: Node::ExportRender; Node::NeedsToExport Reimplemented from Node. Definition at line 3768 of file nodebev.cpp. { if( pRegion PORTNOTE("other","Removed ImagemapRenderRegion usage") #ifndef EXCLUDE_FROM_XARALX && !pRegion->IsKindOf( CC_RUNTIME_CLASS(ImagemapRenderRegion) ) #endif ) { NodeBevelController* pControl = (NodeBevelController *)FindParent(); if(pControl) { INT32 NewDPI = 96; Camelot.GetPrefValue(TEXT("Displays"),TEXT("CompCToEDPI"),&NewDPI); pControl->SetDPI(NewDPI); DeleteCachedBitmap(); m_AmConvertingToShapes = TRUE; /* double ThisDPI = 96.0; if(pRegion->GetScaledPixelWidth() > 75) ThisDPI = (750.0 / pRegion->GetScaledPixelWidth()) * 96.0; if(m_LastExportedDPI != ThisDPI) { m_LastExportedDPI = ThisDPI; pControl->SetDPI(ThisDPI); DeleteCachedBitmap(); m_AmConvertingToShapes = TRUE; } else m_AmConvertingToShapes = FALSE; */ } } else m_AmConvertingToShapes = FALSE; }

void NodeBevel::Render (  RenderRegion *  pRender  )  [virtual]

Will build a path for the shape and draw it to the given render region. Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> Date: 13/07/00 Parameters: Pointer  to a render region [INPUTS] Reimplemented from Node. Definition at line 1040 of file nodebev.cpp. { // TRACEUSER( "Gerry", _T("NodeBevel::Render region 0x%08x\n"),pRender); // set up variables from parent NodeBevelController * pBevelController = (NodeBevelController *)GetParentController(); DocView* pDocView = Document::GetCurrent()->GetFirstDocView(); // Check to see if we`ve got valid pointer! if(pBevelController == NULL || pRender == NULL || !m_DoRender || !pDocView) return; // Get the bevel variables from the Bevel Controller node m_Indent = pBevelController->m_Indent; m_Contrast = pBevelController->m_Contrast; m_LightAngle = pBevelController->m_LightAngle; m_BevelType = pBevelController->m_BevelType; m_bOuter = pBevelController->m_bOuter; // if we have a zero indent, then there`s no bevel! just return if (m_Indent==0) return; // if we`re printing then we need to check that our bounding render intersects with // the current render regions clipping rect if (pBevelController->IsPrinting()) { // make sure we're intersected with the render regions clipping rectangle if (!(pRender->GetClipRect().IsIntersectedWith(BoundingRectangle))) { DeleteCachedBitmap(); return ; } } // first, check for re-entry of code if (m_bLock) return; m_bStopRender = FALSE; // check if we have anything to draw // do this after we've removed all the path processors if (pBevelController->GetInsideBoundingRect().IsEmpty() || InkPath.GetNumCoords() == 0) { m_bStopRender = TRUE; return; } BOOL DoReRender = FALSE; double CurrentZoom = pDocView->GetZoomFactor(); if(m_LastZoomFactor != CurrentZoom) { if(m_pCombiBitmap != NULL) { delete m_pCombiBitmap; m_pCombiBitmap = NULL; } Path ReversedPath; ReversedPath.Initialise(); ReversedPath.CloneFrom(m_Path); if(!ReverseAndShrinkBevelPathIntoInkPath(&ReversedPath, CurrentZoom, m_bOuter)) { m_bStopRender = TRUE; return; } m_LastZoomFactor = CurrentZoom; } pRender->SaveContext(); NodeAttribute* pFillAttrib = NULL; DocColour FillColour = COLOUR_BLACK; // Store the last state of the IsFlatFilledOnly flag BOOL LastFillWasFlat = m_IsFlatFilledOnly; // Test to see if theres a FillGeom Attribute applied to the bevel if(FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pFillAttrib)) { // If the pointer is valid and It`s a flat fill then get the colour and set the IsFlatFill Flag if(pFillAttrib != NULL && pFillAttrib->IsAFlatFill()) { FillColour = *((AttrFlatColourFill*)pFillAttrib)->GetStartColour(); m_IsFlatFilledOnly = (FillColour != COLOUR_NONE); } else { // it`s not a plain flat fill so set the flag to false m_IsFlatFilledOnly = FALSE; if(pFillAttrib && m_pBMPFill) m_pBMPFill->SetTesselation(((ColourFillAttribute*)pFillAttrib->GetAttributeValue())->GetTesselation()); } } // Test to see if there`s a transparency applied to the bevel if(FindAppliedAttribute(CC_RUNTIME_CLASS(AttrTranspFillGeometry),&pFillAttrib)) { if(pFillAttrib != NULL && pFillAttrib->IsATranspFill()) { // Check the Transparency Type. If it`s a flat fill check to see if the start value // is zero. if it`s not zero then it`s got transparency! if(pFillAttrib->IsAFlatFill()) { // Only set as Transparent if it`s not NONE! m_HasTransparencyApplied = *((AttrFlatTranspFill*)pFillAttrib)->GetStartTransp() > 0; } else m_HasTransparencyApplied = TRUE; if (m_HasTransparencyApplied && pFillAttrib!=NULL && m_pTranspFill!=NULL) m_pTranspFill->SetTesselation(((ColourFillAttribute*)pFillAttrib->GetAttributeValue())->GetTesselation()); } else { // Set the flag to false if it doesn`t m_HasTransparencyApplied = FALSE; } } // Only re-render the bitmap if we`re not rotating the light angle, as this has already been // done for us, or if we`re doing hit testing! if((!m_DoingRotation && !pRender->IsHitDetect() && pRender->RRQuality.GetQuality() > 10 && !pRender->IsKindOf(CC_RUNTIME_CLASS(ScanningRenderRegion))) || !m_pBevelBitmap) { // check to see if we have changed from a gradfill to a flat fill with transparency as the bitmap will need to be // updated! DoReRender |= (m_IsFlatFilledOnly && !LastFillWasFlat && m_HasTransparencyApplied); if(pRender->IsPrinting()) { // TRACEUSER( "Gerry", _T("Printing Render\n")); if(!pRender->IsKindOf(CC_RUNTIME_CLASS(ScanningRenderRegion)) && pRender->RRQuality.GetQuality() > 100) { if(m_LastCachedPrintBMPDPI == 0.0) { // TRACEUSER( "Gerry", _T("Printing Render Updating\n")); m_LastCachedPrintBMPDPI = pBevelController->GetDPI(); DoReRender = TRUE; } } } else m_LastCachedPrintBMPDPI = 0.0; if(m_pBevelBitmap == NULL) DoReRender = TRUE; // re-render the bitmap if(((MILLIPOINT)m_LastPixelSize != pRender->GetScaledPixelWidth() && !pBevelController->IsPrinting()) || DoReRender) { if(pRender->GetScaledPixelWidth() > 2) { m_LastPixelSize = pRender->GetScaledPixelWidth(); if (!RenderBitmapForDisplay(pRender)) { m_bStopRender = TRUE; pRender->RestoreContext(); return; } } else if(pRender->IsKindOf(CC_RUNTIME_CLASS(FlashRenderRegion))) { INT32 NewDPI = 96; Camelot.GetPrefValue(TEXT("Displays"),TEXT("CompCToEDPI"),&NewDPI); pBevelController->SetDPI(NewDPI); BOOL OldFlag = m_AmConvertingToShapes; m_AmConvertingToShapes = TRUE; CreateBevelBitmap(); RenderBitmapForDisplay(pRender); m_AmConvertingToShapes = OldFlag; } } // Now set up the palette (depending on contrast) SetUpBitmapPalette((RenderRegion *)NULL,FillColour); } // (ChrisG - 14/2/2001) Bitmaps should only be drawn if they have height or width // (otherwise GDraw has a fit and crashes). if (m_BitmapWidth > 0 && m_BitmapHeight > 0) { // now, render the bitmap to the display if(!pRender->IsHitDetect() && pRender->RRQuality.GetQuality() > 30) { RenderBitmap(pRender); } else { // DY 23/10/2000 if we have a brush attribute applied to this bevel then setting line width to 50 // will cause it to scale to a really small value and lock up the program. Therefore we // ask the render region to disable all brush path processors on the stack pRender->EnableAllBrushPathProcessors(FALSE); pRender->SetLineColour(COLOUR_BLACK); pRender->SetFillColour(FillColour); pRender->SetLineWidth(50); InkPath.IsStroked = TRUE; pRender->DrawPath(&InkPath); InkPath.IsStroked = FALSE; // re-enable the path processors pRender->EnableAllBrushPathProcessors(TRUE); } } m_bStopRender = TRUE; // Reset the Lock Flag m_bLock = FALSE; pRender->RestoreContext(); // TRACEUSER( "Gerry", _T("Finished rendering into region 0x%08x\n"),pRender); }

void NodeBevel::RenderBitmap (  RenderRegion *  pRender  )  [virtual]

Renders the bevel using the bitmap bevelling system. Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> Date: 20/07/00 Parameters: pRender  - The render region to use for rendering [INPUTS] Function Outline :- 1. Pass in render region. 2. Check pointers for Region and Bitmap - return if failed. 3. Save Region Context. 4. Get a pointer to the current stroke colour attrib. 5. Get the pointer for the parent bevel controller node. 6. Check pointers for attrib and node - restore contrext and return if failed. 7. Get the DocColour from the stroke attrib. 8. Get the current pixel width from the render region. 9. Get the pointer to the current view. 10. If valid do 11, else goto 26. !!! 11. Test that the current Pixel width is not equal to m_ViewScale, Test that m_ShrunkPath is not empty, Test the printing flag in the render region. 12. If any one is true, do 13. else goto 26. !!! 13. Check to see if the bevel is outer or inner. 14. If bevel is inner then do 15, else do 17. 15. Clear the m_ShrunkPath. 16. Contour the InkPath out by 1/2 pixel into m_ShrunkPath. 17. Else 18. Clone m_OuterBevelPath into m_ShrunkPath. 19. Contour m_Path in by 1/2 pixel into InnerMergePath. 20. Reverse InnerMergePath and Merge with m_ShrunkPath. 21. Clone m_ShrunkPath into InkPath. 22. Close m_ShrunkPath. 23. Set Filled and !Stroked 24. If m_bZeroLineWidth is true set the line width to 50. 25. m_VeiwScale = Pixel Width. 26. if m_bZeroLineWidth do 27 else do 28. 27. Set LineColour to NONE. 28. Set FillColour to BLACK. 29. Render m_ShrunkPath. 30. If Bevel is an inner do 31 else do 35. 31. Create a new winding rule attribute. 32. if pointer is NULL do 33. else do 34. 33. Restore Context and return. 34. Render the new Winding Attrib. 35. create a new AttrFillMappingLinear and set to repeat inverted. 36. Render the new attrib. 37. if m_bZeroLineWidth do 38. else do 40. 38. Set the LineColour to COLOUR_NONE. 39. Set the LineWidth to 50; 40. Check the BMPFill pointer and do 41 if valid else do 44. 41. Set up the fill handles. 42. Set the repeat type to norepeattype. 43. Render the fill into the region. 44. Create a new TransparencyFillAttrib 45. Check the pointer, if valid do 46 else do 50. 46. Set the start transparency to 0. 47. Set the end transparency to 0xff. 48. Set the transparency type to 25 (Brightness) 49. Render the TransparencyFillAttrib into the region. 50. Restore the Context and return. 51. Render the InkPath. 52. Restore the context and tidy up the pointers 53. return. Definition at line 1420 of file nodebev.cpp. { // TRACEUSER( "Gerry", _T("NodeBevel::RenderBitmap\n")); // check for valid pointers if(!pRender) return; // We should always do this so that 0% flat trans bevelled objects get treated // as transparent by the printing system // Otherwise we end up trying to generate a 72000 dpi bevel bitmap thanks // to the ScaledPixelWidth value of PrintPSRenderRegions if(pRender->IsKindOf(CC_RUNTIME_CLASS(ScanningRenderRegion))) { // with blends, we don't have a bitmap because this is generated on the fly // but a bitmap is NOT generated for a scanning render region .... ScanningRenderRegion* pScanner = (ScanningRenderRegion*)pRender; // we MUST force this node to be included pScanner->ComplexShapeFoundWrapper(); return; } // Check to see if we`ve got a bitmap for rendering! if(!m_pBevelBitmap) return; // Save the render regions context so we can mess about and restore all at the end pRender->SaveContext(); // Get the current Stroke colour and also a pointer to the bevel controller NodeBevelController* pControl = (NodeBevelController *)GetParentController(); // NodeAttribute* pFillAttrib = NULL; FillMappingAttribute FillMapAttrib; TranspFillMappingAttribute TranspFillMapAttrib; // Check for valid pointers if (pControl == NULL) { pRender->RestoreContext(); return; } // first, render the inking path with the current settings no lines needed! // reduce/extend the ink path slightly to account for antialiasing glitches // only do this if the view scale has changed or we've re-rendered the bevel double PixelWidth = pRender->GetScaledPixelWidth(); // Get the current View pointer View* pView = View::GetCurrent(); // if the view is valid then proceed if (pView) { // If the view scale is diffrent to the Pixel Width OR // the Shrunk Path is empty OR we are currently printing, then do the following if (m_ViewScale != PixelWidth || m_ShrunkPath.GetNumCoords() == 0 || pControl->IsPrinting()) { // If this flag is set then set the line width to 50 if (m_bZeroLineWidth) pRender->SetLineWidth(50); // Make the viewscale variable equal to the PixelWidth m_ViewScale = (UINT32)PixelWidth; } } // if we`re doing an inner bevel then we need to render a Winding Rule Attrib if (!m_bOuter) { // Create a new Winding Rule Attrib // pRender->SetWindingRule(PositiveWinding); } // if set, make sure we set the render region to have a line colour of NONE // and a line width of 50. if (m_bZeroLineWidth) { pRender->SetLineColour(COLOUR_NONE); pRender->SetLineWidth(50); } if(m_IsFlatFilledOnly) // Flat filled { // TRACEUSER( "Gerry", _T("Flat filled bevel\n")); // If we`ve got a valid pointer to the bitmap then setup the handles and render into // the render region FillMapAttrib.Repeat = 0; FillMapAttrib.Render(pRender); if (m_pBMPFill) { // TRACEUSER( "Gerry", _T("Rendering Bitmap Fill!\n")); m_pBMPFill->SetStartPoint(&m_BMPCentre); m_pBMPFill->SetEndPoint (&m_BMPPoint1); m_pBMPFill->SetEndPoint2 (&m_BMPPoint2); m_pBMPFill->Render(pRender); } else { pRender->RestoreContext(); ERROR1RAW(_R(IDE_NOMORE_MEMORY)); } } else if(!m_IsFlatFilledOnly && !m_HasTransparencyApplied) // Bitmap or Gradient Filled { // TRACEUSER( "Gerry", _T("Non-flat non-transp bevel\n")); // The pointer is valid then do the following if (m_pTranspFill) { TranspFillMapAttrib.Repeat = 0; TranspFillMapAttrib.Render(pRender); // TRACEUSER( "Gerry", _T("Rendering Transparent Fill\n")); m_pTranspFill->SetStartPoint(&m_BMPCentre); m_pTranspFill->SetEndPoint (&m_BMPPoint1); m_pTranspFill->SetEndPoint2 (&m_BMPPoint2); m_pTranspFill->Render(pRender); } else { pRender->RestoreContext(); ERROR1RAW(_R(IDE_NOMORE_MEMORY)); } } else if(!m_IsFlatFilledOnly && m_HasTransparencyApplied) { // TRACEUSER( "Gerry", _T("Non-flat transp bevel\n")); // Check for the special case of the bevel having a bitmapfill AND a transparency applied // This is special as we need to use the transparency attribute for the brightness bitmap, therefore // we need to render the current fill and transparency into a 32Bit bitmap and use this as the bitmap fill // leaving the transparency attribute free for our brightness bitmap!!! // Make sure we have valid pointers before doing anything to it! if(m_pBMPFill) { if(!pRender->IsKindOf(CC_RUNTIME_CLASS(ScanningRenderRegion))) { if(!m_pCombiBitmap) { // This involves the new technique of creating a new render region whilst still // in the rendering loop! Therefore we need to make sure we save the current GDraw Context. // TRACEUSER( "Gerry", _T("Creating a new OffScreen Bitmap!\n")); // Call the new OffSreen Bitmap Function to get the new 32Bit BMP Fill! // Check to see if it actually worked or failed! m_pCombiBitmap = CreateCombinedBMPAndTranspFill(pRender); } if(m_pCombiBitmap == NULL) { ERROR3("Failed to create a new BitmapTransparency Bitmap!"); pRender->RestoreContext(); return; } // Now setup the new Bitmap Fill Attribute and render it into the render region! m_pBMPFill->BitmapRef.SetBitmap(m_pCombiBitmap); m_pBMPFill->SetStartPoint(&m_BMPCentre); m_pBMPFill->SetEndPoint (&m_BMPPoint1); m_pBMPFill->SetEndPoint2 (&m_BMPPoint2); m_pBMPFill->Render(pRender); } else { // TRACEUSER( "Gerry", _T("Scanning RR\n")); } FillMapAttrib.Repeat = 0; FillMapAttrib.Render(pRender); } else { // TRACEUSER( "Gerry", _T("No m_pBMPFill\n")); pRender->RestoreContext(); ERROR1RAW(_R(IDE_NOMORE_MEMORY)); } } // We need to get a bitmap for the fill if(InkPath.GetNumCoords() > 2) pRender->DrawPath(&InkPath); pRender->RestoreContext(); // TRACEUSER( "Gerry", _T("End of NodeBevel::RenderBitmap\n")); }

BOOL NodeBevel::RenderBitmapForDisplay (  RenderRegion *  pRegion  )  [protected]

Creates the Brigtness bitmap for the bevel. Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> Date: 13/07/00 Parameters: The  render region to be rendered into! [INPUTS] Returns: TRUE for success, FALSE for Failure! Definition at line 1275 of file nodebev.cpp. { TRACEUSER( "Gerry", _T("NodeBevel::RenderBitmapForDisplay\n")); // Get the Bevel Controler NodeBevelController * pControl = (NodeBevelController *)GetParentController(); // Make sure we`ve got some valid pointers! if (pControl == NULL) return FALSE; // (ChrisG - 14/2/2001) If we've got a zero sized (or less) bitmap, get rid of // the old beveller and let it try to recreate the bitmap (hopefully at a // friendlier zoom factor). if (m_pBeveler != NULL) { if (m_BitmapHeight < 1 || m_BitmapWidth < 1) { delete m_pBeveler; m_pBeveler = NULL; } } if (m_pBeveler == NULL) { if (!CreateBevelBitmap()) return(FALSE); } if (m_pBevelBitmap) { delete m_pBevelBitmap; m_pBevelBitmap = NULL; } // Save the current Pixel scale if(pRegion) m_LastPixelSize = pRegion->GetScaledPixelWidth(); if (pRegion && pRegion->IS_KIND_OF(PrintingMaskedRenderRegion)) CalculateBitmapSize(&m_BitmapWidth, &m_BitmapHeight, pRegion); else CalculateBitmapSize(&m_BitmapWidth, &m_BitmapHeight, NULL); // Get the pixel size of the current clipping rect! SHOULD be pixel alligned. INT32 Width = m_BitmapWidth; INT32 Height = m_BitmapHeight; if (Width == 0 || Height == 0) return FALSE; // TRACEUSER( "Gerry", _T("Creating bevel bitmap (%d, %d)\n"), Width, Height); // Create a new bitmap of the current width and height! m_pBevelBitmap = new KernelBitmap(Width, Height, 8, 96, TRUE); ERROR2IF(m_pBevelBitmap == NULL,FALSE,"Failed to create a new bevel bitmap!"); // Now render the bevel into the new Bevel Bitmap! m_pBeveler->RenderToBitmap(m_pBevelBitmap, TRUE, &m_SubPixelOffset); // If we're going to change the transp fill then the combi // bitmap will become out of date so uncache it here. if (m_pCombiBitmap) { delete m_pCombiBitmap; m_pCombiBitmap = NULL; } // Now set the Bitmap Ref to the Bevel Bitmap! m_pBMPFill->BitmapRef.SetBitmap(m_pBevelBitmap); m_pTranspFill->BitmapRef.SetBitmap(m_pBevelBitmap); // Everythings cool, return TRUE! return TRUE; }

void NodeBevel::RenderEorDrag (  RenderRegion *  pRegion  )  [virtual]

Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 20/11/96 Parameters: [INPUTS]  See also: Reimplemented from NodeRenderableInk. Definition at line 3667 of file nodebev.cpp. { pRegion->DrawPath(&InkPath); }

void NodeBevel::RenderNodeRecursively (  Node *  pNode, RenderRegion *  pRender )  [protected]

Renders all children of this node first, then renders the node itself Notes: See also: NodeBevel::DrawNodesForPrinting. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 28/7/99 Parameters: [INPUTS]  Returns: Definition at line 3518 of file nodebev.cpp. { BOOL bHasChildren = FALSE; // get the first child node Node * pChildNode = pNode->FindFirstChild(); if (pChildNode) { // save the context if this node has children pRender->SaveContext(); bHasChildren = TRUE; } while (pChildNode) { if (!pChildNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevelBegin)) && !pChildNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevel)) && !pChildNode->IsNodeHidden() && pChildNode->IsNodeRenderableClass()) { RenderNodeRecursively(pChildNode, pRender); } pChildNode = pChildNode->FindNext(); } // now, render the node itself pRender->SaveContext(); pRender->SetLineColour(COLOUR_NONE); pNode->Render(pRender); pRender->RestoreContext(); // restore the context if (bHasChildren) pRender->RestoreContext(); }

void NodeBevel::RenderNodesForPrinting (  RenderRegion *  pRender  )  [protected]

Renders all original nodes again Notes: Used because in printing, problems occur with the ShrinkPath stuff, causing holes to appear in the printed image. Thus, we take a different tack of rendering the bevelled path without the original being taken away from it, and then rendering the original nodes again so no holes occur See also: NodeBevel::RenderBitmap. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 28/7/99 Parameters: [INPUTS]  Returns: Definition at line 3479 of file nodebev.cpp. { // first, save the context pRender->SaveContext(); // next get the first child node of the controller Node* pController = (Node*)GetParentController(); Node* pNode = pController->FindFirstChild(); while (pNode) { if (!pNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevelBegin)) && !pNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevel)) && !pNode->IsNodeHidden() && pNode->IsNodeRenderableClass()) { RenderNodeRecursively(pNode, pRender); } pNode = pNode->FindNext(); } pRender->RestoreContext(); }

void NodeBevel::RenderTinyBlobs (  RenderRegion *  pRender  )  [virtual]

Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 7/10/98 Parameters: -  [INPUTS] Returns: See base class Reimplemented from NodeRenderable. Definition at line 2568 of file nodebev.cpp. { pRender->SaveContext(); pRender->SetLineColour(COLOUR_NONE); pRender->SetFillColour(COLOUR_UNSELECTEDBLOB); // Render the blobs on the path BlobManager* BlobMgr = GetApplication()->GetBlobManager(); DocRect dr(0,0,0,0); InkPath.GetTrueBoundingRect(&dr); DocCoord Coord(dr.lo.x + (BlobMgr->GetBlobSize() / 2), dr.hi.y - (BlobMgr->GetBlobSize() / 2)); pRender->DrawBlob(Coord, BT_UNSELECTED); pRender->RestoreContext(); }

BOOL NodeBevel::RequiresAttrib (  NodeAttribute *  pAttr, BOOL  Search = FALSE )  [virtual]

NodeBevel does not require brush attrs. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/08/2000 Parameters: pAttr  the attr to test. [INPUTS] Search not a clue - look at base class implementation for info. Returns: FALSE if pAttr is a brush attr, calls base implementation otherwise. Errors: returns FALSE if pAttr is NULL. Reimplemented from NodeRenderableInk. Definition at line 2880 of file nodebev.cpp. { if (pAttr == NULL || pAttr->IS_KIND_OF(AttrBrushType)) return FALSE; else return NodeRenderableInk::RequiresAttrib(pAttr, Search); }

BOOL NodeBevel::RequiresAttrib (  CCRuntimeClass *  pAttribClass, BOOL  Search = FALSE )  [virtual]

NodeBevel does not require brush attrs. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/08/2000 Parameters: pAttribClass  the attr type to test. [INPUTS] Search not a clue - look at base class implementation for info. Returns: FALSE if pAttribClass is a brush attr, calls base implementation otherwise. Errors: returns FALSE if pAttribClass is NULL. Reimplemented from NodeRenderableInk. Definition at line 2852 of file nodebev.cpp. { if (pAttribClass == NULL || pAttribClass == CC_RUNTIME_CLASS(AttrBrushType)) return FALSE; else return NodeRenderableInk::RequiresAttrib(pAttribClass, Search); }

BOOL NodeBevel::ReRenderBevelBitmap (  BOOL  bAntialias  )

Re-renders the bevel bitmap using the beveler as it's already set up with the currently applied attributes. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 9/10/98 Parameters: -  [INPUTS] Returns: Definition at line 3008 of file nodebev.cpp. { BOOL ok = TRUE; if (m_pBeveler && m_pBevelBitmap) { // if the beveler is present, and we have a bitmap then re-render the bitmap m_pBeveler->SetBevelAngle(m_LightAngle); m_pBeveler->SetBevelType(m_BevelType); m_pBeveler->SetBevelTilt(m_Tilt); if(m_pCombiBitmap) { delete m_pCombiBitmap; m_pCombiBitmap = NULL; } // if we're antialiasing, then do the wait cursor if (bAntialias) m_DoingRotation = FALSE; else m_DoingRotation = TRUE; m_pBevelBitmap->DestroyGreyscaleVersion(); ok = m_pBeveler->RenderToBitmap(m_pBevelBitmap, bAntialias, &m_SubPixelOffset); } return ok; }

BOOL NodeBevel::ReverseAndShrinkBevelPathIntoInkPath (  Path *  pBevelPath = NULL, double  ZoomValue = 1.0, BOOL  IsAnOuter = TRUE )  [protected]

Definition at line 970 of file nodebev.cpp. { // Reverses the bevel path and adds it to the original to create the new bevel path // Also shrinks/Expands the inner/outer path edge by a pixel to get rid of antialiasing // effects when overlapping the object if(pBevelPath == NULL) return FALSE; double CurrentFlatness = 200.0 * ZoomValue; Path CopyPath; CopyPath.Initialise(); CopyPath.CloneFrom(*pBevelPath); pBevelPath->ClearPath(); UINT32 Modifier = 750; if(!m_bOuter) Modifier = 0; if(ZoomValue < 1.0) Modifier = UINT32( double(Modifier) * ZoomValue ); CurrentFlatness = CopyPath.CalculateFlatnessValueFromPath(375.0); CopyPath.InitializeContourValues(Modifier,JOIN_ROUND,!IsAnOuter,CurrentFlatness); if(CopyPath.GetContourForStep(pBevelPath) < 0) pBevelPath->CloneFrom(CopyPath); if(pBevelPath->GetUsedSlots() > 2) pBevelPath->Reverse(); if (IsAnOuter) { // copy the outer path into the inking path for the bevel, and add the // original path to create a hole in it InkPath.CloneFrom(m_OuterBevelPath); InkPath.MergeTwoPaths(*pBevelPath); } else { // create the path list for inner contours // copy the outer path into the inking path for the bevel, and add the // original path to create a hole in it if(m_OuterBevelPath.ClipPathToPath( *pBevelPath, &InkPath, 1 | CLIPPING_CLIP_WINDING, BevelClipPathToPath_Tolerance, CurrentFlatness,CurrentFlatness) < 0) { TRACEUSER( "MarkH", _T("ClipFailed so copying path! PATHS\n")); } } InkPath.IsFilled = TRUE; InkPath.IsStroked = FALSE; return TRUE; }

virtual void NodeBevel::SetBoundingRect (  DocRect  rect  )  [inline, virtual]

Definition at line 167 of file nodebev.h. { m_SelectedRect = rect; }

void NodeBevel::SetConvertingFlag (  BOOL  Set = FALSE  )  [inline]

Definition at line 268 of file nodebev.h. { m_AmConvertingToShapes = Set; }

void NodeBevel::SetRenderBitmaps (  BOOL  b  )  [inline]

Definition at line 241 of file nodebev.h. { m_bRenderBitmaps = b; }

void NodeBevel::SetUpBitmapPalette (  RenderRegion *  pRegion = NULL, DocColour  FlatColour = COLOUR_BLACK )  [protected]

Sets up the bitmap palette depending on contrast setting. Author: Mark_Howitt (Xara Group Ltd) <camelotdev@xara.com> - Rewrite of David Mc code Date: 19/07/00 Parameters: Currently  a pointer to a render region, But is not used. [INPUTS] Definition at line 1893 of file nodebev.cpp. { // Check the Bevel Bitmap Pointer if (!m_pBevelBitmap) return; // Check that the Bitmap is an 8Bit BMP if (m_pBevelBitmap->GetBPP() != 8) return; // Setup a few local variables LPRGBQUAD pPalette = m_pBevelBitmap->GetPaletteForBitmap(); INT32 Red = 0; INT32 Green = 0; INT32 Blue = 0; // Get the pointer to the parent controller and check it NodeBevelController* pControl = (NodeBevelController *)FindParent(); ERROR3IF(pControl == NULL, "No parent"); // Get the contrst value from the controller double Contrast = pControl->m_Contrast; // The following if statment never gets called as the pointer is always NULL if ( pRegion ) { // find out the contrast first BevelAttributeValueContrast *pVal = (BevelAttributeValueContrast *)pRegion->GetCurrentAttribute(ATTR_BEVELCONTRAST); if (!pVal) return; Contrast = pVal->m_Contrast; } GDrawContext* pGD = GRenderRegion::GetStaticDrawContext(); pGD->SetBevelLightness(UINT32( Contrast*2.5599900)) ; pGD->SetBevelDarkness (UINT32(Contrast*Contrast*0.0255999)) ; // Get the component parts of the FillColour FlatColour.GetRGBValue(&Red,&Green,&Blue); // Now setup the palette of 255 grey scales OR if the bevel is flat filled and NOT transparent // then the palette is translated using the flat fill colour for ( INT32 i=0 ; i<256 ; i++ ) { if(!m_IsFlatFilledOnly) { // Normal Brightness grey scales pPalette[i].rgbRed = pPalette[i].rgbBlue = pPalette[i].rgbGreen = i ; } else { // Translated colour table values used ONLY for Non Transparent Flat filled Bevels pPalette[i].rgbRed = pGD->TranslateBevelValue(i,Red ) ; pPalette[i].rgbGreen = pGD->TranslateBevelValue(i,Green) ; pPalette[i].rgbBlue = pGD->TranslateBevelValue(i,Blue ) ; } pPalette[i].rgbReserved = 0 ; } }

BOOL NodeBevel::SetupVariables (  CCAttrMap *  pMap = NULL  )

Sets up all the attributes on myself and my parent by finding the appropriate attributes. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 17/10/99 Parameters: The  attribute map to use, NULL to find applied attributes [INPUTS] Note: See also: Definition at line 714 of file nodebev.cpp. { // set the attributes up (on our parent !) AttrBevelIndent * pIndent = NULL; AttrBevelLightAngle * pLightAngle = NULL; AttrBevelContrast * pContrast = NULL; AttrBevelType * pType = NULL; AttrBevelLightTilt * pTilt = NULL; if(pMap == NULL) { this->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBevelIndent), (NodeAttribute **)(&pIndent)); this->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBevelLightAngle), (NodeAttribute **)(&pLightAngle)); this->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBevelContrast), (NodeAttribute **)(&pContrast)); this->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBevelType), (NodeAttribute **)(&pType)); this->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBevelLightTilt), (NodeAttribute **)(&pTilt)); } else { pMap->Lookup( CC_RUNTIME_CLASS(AttrBevelIndent), (void *&)pIndent); pMap->Lookup( CC_RUNTIME_CLASS(AttrBevelLightAngle), (void *&)pLightAngle); pMap->Lookup( CC_RUNTIME_CLASS(AttrBevelContrast), (void *&)pContrast); pMap->Lookup( CC_RUNTIME_CLASS(AttrBevelType), (void *&)pType); pMap->Lookup( CC_RUNTIME_CLASS(AttrBevelLightTilt), (void *&)pTilt); } NodeBevelController * pBevelController = (NodeBevelController *)FindParent(); if ( !pBevelController ) return FALSE ; // Now make sure we`ve got valid pointers to all the varibale if (pIndent && pLightAngle && pContrast && pType && pTilt) { if (pIndent->Value.m_Indent < 0) { pBevelController->m_Indent = -pIndent->Value.m_Indent; pBevelController->m_bOuter = TRUE; } else { pBevelController->m_Indent = pIndent->Value.m_Indent; pBevelController->m_bOuter = FALSE; } m_Indent = pBevelController->m_Indent; m_bOuter = pBevelController->m_bOuter; m_LightAngle = pBevelController->m_LightAngle = pLightAngle->Value.m_LightAngle; m_Contrast = pBevelController->m_Contrast = pContrast->Value.m_Contrast; m_BevelType = pBevelController->m_BevelType = pType->Value.m_Type; m_Tilt = pBevelController->m_Tilt = pTilt->Value.m_LightTilt; return TRUE; } return FALSE; }

void NodeBevel::SetZeroLineWidths (  BOOL  b  )  [inline]

Definition at line 245 of file nodebev.h. { m_bZeroLineWidth = b; }

Node * NodeBevel::SimpleCopy (  void   )  [virtual]

Returns a copy of me. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/98 Parameters: -  [INPUTS] Returns: Reimplemented from NodeRenderableInk. Definition at line 3089 of file nodebev.cpp. { NodeBevel * pNewNode = new NodeBevel; ERRORIF(pNewNode == NULL, _R(IDE_NOMORE_MEMORY), NULL); CopyNodeContents(pNewNode); return pNewNode; }

void NodeBevel::Transform (  TransformBase &  tb  )  [virtual]

Transforms the shape. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: Trans  - The transform Object [INPUTS] See also: NodePath::Transform() Reimplemented from NodeRenderableBounded. Definition at line 2737 of file nodebev.cpp. { if(!m_MustRegenOnChildChange) return; // get the scale factor for the transformation FIXED16 ScaleFactor = tb.GetScalar(); TransformChildren(tb); Trans2DMatrix * pMat2D = NULL; if (tb.IsInvertable()) pMat2D = (Trans2DMatrix*)(&tb); // And scale the line width m_Indent= labs( INT32(ScaleFactor.MakeDouble() * ((double)m_Indent) )); NodeBevelController * pControl = (NodeBevelController *)FindParent(); if (pControl) pControl->m_Indent = m_Indent; AttrBevelIndent * pApplied = NULL; AttrBevelIndent * pIndent = NULL; if ( pMat2D && !pMat2D->GetMatrix().IsTranslation() && FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBevelIndent),(NodeAttribute **)&pApplied) && pApplied->IsADefaultAttr() ) { // we need to insert an attribute onto me pIndent = new AttrBevelIndent(FindParent(), FIRSTCHILD); if (pIndent) { pIndent->Value.m_Indent = m_Indent; if (m_bOuter) pIndent->Value.m_Indent = -m_Indent; ((NodeRenderableInk *)FindParent())->NormaliseAttributes(); } } // transform the paths if (m_Path.GetNumCoords() > 0) tb.Transform(m_Path.GetCoordArray(), m_Path.GetNumCoords()); if (m_OuterBevelPath.GetNumCoords() > 0) tb.Transform(m_OuterBevelPath.GetCoordArray(), m_OuterBevelPath.GetNumCoords()); if (InkPath.GetNumCoords() > 0) tb.Transform(InkPath.GetCoordArray(), InkPath.GetNumCoords()); if (m_ShrunkPath.GetNumCoords() > 0) tb.Transform(m_ShrunkPath.GetCoordArray(), m_ShrunkPath.GetNumCoords()); // and regenerate the bitmap (if necessary) if (pMat2D) { if (!pMat2D->GetMatrix().IsTranslation()) { GenerateBevel(); } else { DocCoord TransCoords(0,0); pMat2D->GetMatrix().GetTranslation(TransCoords); // if(TransCoords.x % 750 != 0 || TransCoords.y % 750 != 0) // GenerateBevel(); // else { // transform the source points of the bitmap fill tb.Transform(&m_BMPCentre, 1); tb.Transform(&m_BMPPoint1, 1); tb.Transform(&m_BMPPoint2, 1); tb.Transform(&BoundingRectangle.lo, 1); tb.Transform(&BoundingRectangle.hi, 1); } } } InvalidateBoundingRect(); GetBoundingRect(TRUE, FALSE); }

DocRect NodeBevel::ValidateExtend (  const ExtendParams &  ExtParams  )  [virtual]

Tests the reversibility of an Extend operation applied to this node. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/1999 Parameters: ExtParams  description parameters for the extension. [INPUTS] [OUTPUTS]  Returns: TRUE if extending this Nodewill be a reversible operation, FALSE otherwise. A NodeBevel cannot itself extend, so instead it asks its parent controller to extend for it. Infinite recursion does not occur, as the controller node ignores its child node, this NodeBevel. Returns: Errors: In debug builds, ERROR3 if this Node has no NodeBevelController, in release, we return TRUE. See also: IsTypeExtendible(), Extend(). Reimplemented from Node. Definition at line 3692 of file nodebev.cpp. { Node* pBob = GetParentController(); if (pBob == NULL) { ERROR3("NodeBevel::ValidateExtend- no controller Node found!"); return DocRect(INT32_MAX, INT32_MAX, INT32_MAX, INT32_MAX); } else { return pBob->ValidateExtend(ExtParams); } }

BOOL NodeBevel::WritePreChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Reimplemented from Node. Definition at line 3073 of file nodebev.cpp. { return WritePreChildrenWeb(pFilter); }

BOOL NodeBevel::WritePreChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes out a dummy record, for my attribute to be attached to. Author: David_McClarnon (Xara Group Ltd) <camelotdev@xara.com> Date: 27/10/98 Parameters: -  [INPUTS] Returns: FALSE for failure Reimplemented from Node. Definition at line 3062 of file nodebev.cpp. { UINT32 Tag = TAG_BEVELINK; CamelotFileRecord Rec(pFilter,Tag,0); pFilter->Write(&Rec); return TRUE; }

---

Member Data Documentation

Path NodeBevel::InkPath

Definition at line 275 of file nodebev.h.

BOOL NodeBevel::m_AmConvertingToShapes [protected]

Definition at line 347 of file nodebev.h.

BOOL NodeBevel::m_bCached [protected]

Definition at line 379 of file nodebev.h.

INT32 NodeBevel::m_BevelType

Definition at line 279 of file nodebev.h.

INT32 NodeBevel::m_BitmapHeight [protected]

Definition at line 340 of file nodebev.h.

INT32 NodeBevel::m_BitmapWidth [protected]

Definition at line 339 of file nodebev.h.

BOOL NodeBevel::m_bLock [protected]

Definition at line 365 of file nodebev.h.

DocCoord NodeBevel::m_BMPCentre

Definition at line 290 of file nodebev.h.

DocCoord NodeBevel::m_BMPPoint1

Definition at line 291 of file nodebev.h.

DocCoord NodeBevel::m_BMPPoint2

Definition at line 292 of file nodebev.h.

BOOL NodeBevel::m_bOuter

Definition at line 283 of file nodebev.h.

BOOL NodeBevel::m_bPathIsClosed [protected]

Definition at line 375 of file nodebev.h.

BOOL NodeBevel::m_bRenderBitmaps [protected]

Definition at line 366 of file nodebev.h.

BOOL NodeBevel::m_bStopRender [protected]

Definition at line 353 of file nodebev.h.

BOOL NodeBevel::m_bZeroLineWidth [protected]

Definition at line 369 of file nodebev.h.

INT32 NodeBevel::m_Contrast

Definition at line 284 of file nodebev.h.

BOOL NodeBevel::m_DoingRotation [protected]

Definition at line 354 of file nodebev.h.

BOOL NodeBevel::m_DoRender [protected]

Definition at line 331 of file nodebev.h.

BOOL NodeBevel::m_HasTransparencyApplied [protected]

Definition at line 346 of file nodebev.h.

INT32 NodeBevel::m_Indent

Definition at line 280 of file nodebev.h.

BOOL NodeBevel::m_IsABlendStepBevel

Definition at line 287 of file nodebev.h.

BOOL NodeBevel::m_IsAnAlphaBMP [protected]

Definition at line 345 of file nodebev.h.

BOOL NodeBevel::m_IsFlatFilledOnly [protected]

Definition at line 344 of file nodebev.h.

JointType NodeBevel::m_JointType

Definition at line 296 of file nodebev.h.

double NodeBevel::m_LastCachedPrintBMPDPI [protected]

Definition at line 349 of file nodebev.h.

double NodeBevel::m_LastExportedDPI [protected]

Definition at line 350 of file nodebev.h.

UINT32 NodeBevel::m_LastPixelSize [protected]

Definition at line 387 of file nodebev.h.

double NodeBevel::m_LastZoomFactor [protected]

Definition at line 384 of file nodebev.h.

double NodeBevel::m_LightAngle

Definition at line 282 of file nodebev.h.

BOOL NodeBevel::m_MustRegenOnChildChange

Definition at line 277 of file nodebev.h.

Path NodeBevel::m_OuterBevelPath [protected]

Definition at line 358 of file nodebev.h.

Path NodeBevel::m_Path [protected]

Definition at line 330 of file nodebev.h.

KernelBitmap* NodeBevel::m_pBevelBitmap [protected]

Definition at line 333 of file nodebev.h.

CBeveler* NodeBevel::m_pBeveler [protected]

Definition at line 371 of file nodebev.h.

BitmapFillAttribute* NodeBevel::m_pBMPFill [protected]

Definition at line 336 of file nodebev.h.

KernelBitmap* NodeBevel::m_pCombiBitmap [protected]

Definition at line 334 of file nodebev.h.

DocRect NodeBevel::m_PixelAllignedRect [protected]

Definition at line 343 of file nodebev.h.

BitmapTranspFillAttribute* NodeBevel::m_pTranspFill [protected]

Definition at line 337 of file nodebev.h.

DocRect NodeBevel::m_SelectedRect

Definition at line 295 of file nodebev.h.

Path NodeBevel::m_ShrunkPath [protected]

Definition at line 364 of file nodebev.h.

DocCoord NodeBevel::m_SubPixelOffset [protected]

Definition at line 342 of file nodebev.h.

double NodeBevel::m_Tilt

Definition at line 285 of file nodebev.h.

UINT32 NodeBevel::m_ViewScale [protected]

Definition at line 361 of file nodebev.h.

---

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

• Kernel/nodebev.h (r1785/r1282)
• Kernel/nodebev.cpp (r1785/r1358)

---