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