FeatherAttrValue Class Reference

#include <fthrattr.h>

Inheritance diagram for FeatherAttrValue:

List of all members.

Public Member Functions
	FeatherAttrValue ()
	~FeatherAttrValue ()
virtual void	SimpleCopy (AttributeValue *)
virtual NodeAttribute *	MakeNode ()
	Used when restoring attributes from the render region's context stack.Used when a render region needs to change a particular rendering attribute.This function provides a way of copying the contents of an AttributeValue derived class to another. It is assumed that the source object is the same class as the destination object. The data from the object pointed to by pAttr is copied into this object. This is primarily used when cloning render regions - the context stack must be copied, and if it points to any temporary objects, then they must be copied too, to avoid multiple deletion errors. Given an AttributeValue object, construct the appropriate NodeAttribute object which can be put into a document tree. This should be over-ridden for all derived AttributeValue classes, except those that cannot be put into the document tree (e.g. DrawingModeAttribute). The base class version (i.e. this one) will always ENSURE because it should not be called.
virtual BOOL	Blend (BlendAttrParam *pBlendParam)
	Blends this attr val with the attr val associated with the other NodeAttribute ptr held in pBlendParam This base version just returns FALSE, and sets the blended attr val ptr to NULL.
virtual void	Render (RenderRegion *, BOOL Temp=FALSE)
virtual void	Restore (RenderRegion *, BOOL)
virtual void	GetMinimumOffscreenBmpDimensions (UINT32 *RequiredWidth, UINT32 *RequiredHeight)
virtual void	OffscreenRenderingCompleted (RenderRegion *pRender, LPBITMAPINFO lpBitmapInfo, LPBYTE lpBits, DocRect BitmapRect)
virtual BOOL	DoesOffscreenBmpRequireTransp (GRenderRegion *pGRR)
	Override of OffscreenAttrValue virtual function. Feathers always require a transparent bitmap if their feather size is less than a certain value, otherwise they use the default implementation.
virtual BOOL	DoesOffscreenBMPCaptureBackground ()
virtual BOOL	CreateFeatherTransp (GRenderRegion *pGRR, Path *pPath, double dPixelWidth, BitmapTranspFillAttribute **ppFeatherTransp, KernelBitmap **ppFeatherBitmap)
	Create the feather transparency attribute using the supplied path /without/ reference to any surrounding nodes in the tree Used by NodeBitmap::GetDirectBitmap.
BOOL	SetupFeather (Node *pNode, INT32 Width=((MILLIPOINT)(2 *PX_MP_VAL)), UnitType type=MILLIPOINTS)
	Setup feather member variables so that it is created properly on rendering.
BOOL	ChangeFeatherProfile (CProfileBiasGain &biasgain)
BOOL	ChangeFeatherSize (INT32, UnitType)
MILLIPOINT	GetFeatherSize ()
	Accessor method for our feather size.
double	GetFeatherPixelSize (double fPixelWidth)
	Return the size of this feather, in pixels of the specified width. Different from GetFeatherSize(PIXELS) mainly because: 1. we return a double, so eg you can get back a value of 2.5 pix. 2. we're inline.
CProfileBiasGain	GetProfile ()
CProfileBiasGain *	GetProfilePtr ()
MILLIPOINT	SetFeatherSize (MILLIPOINT sz)
	Mutator method for our feather size.
void	SetFeatherProfile (CProfileBiasGain &biasgain)
virtual void	SetLinkedNode (NodeRenderableBounded *pNode)
	Our outer contour gap size depends on what our linked node is, so we must recalculate our gap size whenever our linked node is set.
virtual BOOL	CanBeRenderedDirectly ()
BOOL	GenerateOuterContour ()
Path *	GetOuterContour ()
BOOL	RegenerateOuterContourOnNextRedraw (UndoableOperation *pOp=NULL)
	Clear the cache of our outer-contour path.
void	SetOuterContour (Path *pNewOuterContour)
Static Public Member Functions
static BOOL	Init ()
	Declares a preference that allows you to clear memory in delete().
Private Member Functions
KernelBitmap *	CreateFeatherBitmap (GRenderRegion *pGRR, double pixBlurDiameter)
	Create the feather bitmap-transparency mask.
LPBITMAPINFO	CreateSilhouetteBitmap (GRenderRegion *GRR, LPBYTE *ppBmpBits, Path *pOutline=NULL)
void	SetupFeatherBitmapPalette (KernelBitmap *pFeatherBMP)
void	CreateBitmapFill (KernelBitmap *pBitmap, DocRect *dr, BitmapFillAttribute *BmpFill)
void	CreateBitmapFillRot90 (KernelBitmap *pBitmap, DocRect *dr, BitmapFillAttribute *BmpFill)
void	CreateBitmapTranspFill (KernelBitmap *pFeather, DocRect *dr, BitmapTranspFillAttribute *BmpTranspFill)
Path *	GetVisibleBoundingPath ()
Private Attributes
CProfileBiasGain	m_Profile
MILLIPOINT	m_FeatherSize
MILLIPOINT	m_GapSize
Path *	m_pOuterContour
DocRect	m_drFeatherBB
BOOL	m_bCached
Static Private Attributes
static const MILLIPOINT	MaxUserFeatherSize = 37500

---

Detailed Description

Definition at line 185 of file fthrattr.h.

---

Constructor & Destructor Documentation

FeatherAttrValue::FeatherAttrValue (   )

See also: Definition at line 272 of file fthrattr.cpp. { // m_Profile = CProfileBiasGain() // Defaults to this m_GapSize = DEFAULT_GAP_TOLERANCE_MP; m_FeatherSize = 0; // Document base Feather has 0 feather size. // The doc base feather is created when camelot // initialises a new document. // The default feather applied to each new object // is also setup by this constructor. m_pOuterContour = NULL; m_bCached = FALSE; }

FeatherAttrValue::~FeatherAttrValue (   )

Definition at line 292 of file fthrattr.cpp. { // only m_pOuterContour may be left because it is cached if (m_pOuterContour != NULL) { delete m_pOuterContour; m_pOuterContour = NULL; } }

---

Member Function Documentation

BOOL FeatherAttrValue::Blend (  BlendAttrParam *  pBlendParam  )  [virtual]

Blends this attr val with the attr val associated with the other NodeAttribute ptr held in pBlendParam This base version just returns FALSE, and sets the blended attr val ptr to NULL. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/10/94 Parameters: pBlendParam  = ptr to param holding all data needed for the attr val to blend [INPUTS] if  TRUE returned, pBlendParam->GetBlendedAttrVal() will get ptr to the blended attr val [OUTPUTS] if FALSE returned, pBlendParam->GetBlendedAttrVal() will return NULL Returns: TRUE if successful, FALSE otherwaie Errors: Errors in debug builds See also: - Reimplemented from AttributeValue. Definition at line 385 of file fthrattr.cpp. { // First get the fill that we are blending to FeatherAttrValue* OtherFthr = (FeatherAttrValue*)pBlendParam->GetOtherAttrVal(); if(IsDefaultFlagSet() && OtherFthr->IsDefaultFlagSet()) { // no blending required // pBlendParam->SetBlendedAttrVal(NULL); return FALSE; } FeatherAttrValue* pNewAttr = new FeatherAttrValue; if (pNewAttr == NULL) { // Fail if we couldn't create the new fill pBlendParam->SetBlendedAttrVal(NULL); return FALSE; } // and what point along the blend we are at double Ratio = pBlendParam->GetBlendRatio(); // blend m_pFeatherWidth MILLIPOINT Start = GetFeatherSize(); MILLIPOINT End = OtherFthr->GetFeatherSize(); pNewAttr->SetFeatherSize( (MILLIPOINT) ( Start + Ratio*(End - Start) ) ); // blend m_Profile CProfileBiasGain BiasGain = m_Profile; // the first fills profile CProfileBiasGain OtherBiasGain = OtherFthr->m_Profile; // the other fills profile if (!(BiasGain == OtherBiasGain)) { /* From other blend Profiles code double InvRatio = 1 - Ratio; double BlendedBias = (BiasGain.GetBias () * InvRatio) + (OtherBiasGain.GetBias () * Ratio); double BlendedGain = (BiasGain.GetGain () * InvRatio) + (OtherBiasGain.GetGain () * Ratio); */ double StartBias = m_Profile.GetBias(); double EndBias = OtherBiasGain.GetBias(); double StartGain = m_Profile.GetGain(); double EndGain = OtherBiasGain.GetGain(); double BlendedBias = StartBias + ((EndBias - StartBias) * Ratio); double BlendedGain = StartGain + ((EndGain - StartGain) * Ratio); pNewAttr->m_Profile.SetBias (BlendedBias); pNewAttr->m_Profile.SetGain (BlendedGain); } // Set the new fill as the blended attribute pBlendParam->SetBlendedAttrVal(pNewAttr); return TRUE; }

BOOL FeatherAttrValue::CanBeRenderedDirectly (   )  [virtual]

Reimplemented from GeometryLinkedAttrValue. Definition at line 1450 of file fthrattr.cpp. { if(!GetLinkedNode()) return FALSE; if(GetLinkedNode()->IS_KIND_OF(NodeDocument)) return FALSE; if(GetFeatherSize()==0) return FALSE; return TRUE; }

BOOL FeatherAttrValue::ChangeFeatherProfile (  CProfileBiasGain &  biasgain  )

Definition at line 1245 of file fthrattr.cpp. { AFp BiasValue = biasgain.GetBias(); AFp GainValue = biasgain.GetGain(); m_Profile.SetBias(BiasValue); m_Profile.SetGain(GainValue); return TRUE; }

BOOL FeatherAttrValue::ChangeFeatherSize (  INT32  , UnitType  )

Definition at line 1263 of file fthrattr.cpp. { BOOL res=SetupFeather(GetLinkedNode(), Width, type); return res; }

void FeatherAttrValue::CreateBitmapFill (  KernelBitmap *  pBitmap, DocRect *  dr, BitmapFillAttribute *  BmpFill )  [private]

Definition at line 1138 of file fthrattr.cpp. { // Bitmap fill is the size of the current offscreen bitmap DocCoord StartPoint(dr->lo); DocCoord EndPoint(dr->hi.x,dr->lo.y); DocCoord EndPoint2(dr->lo.x,dr->hi.y); DocCoord EndPoint3(dr->hi); BmpFill->SetStartPoint(&StartPoint); BmpFill->SetEndPoint(&EndPoint); BmpFill->SetEndPoint2(&EndPoint2); BmpFill->SetEndPoint3(&EndPoint3); BmpFill->GetBitmapRef()->SetBitmap(pBitmap); }

void FeatherAttrValue::CreateBitmapFillRot90 (  KernelBitmap *  pBitmap, DocRect *  dr, BitmapFillAttribute *  BmpFill )  [private]

Definition at line 1160 of file fthrattr.cpp. { // Bitmap fill is the size of the current offscreen bitmap DocCoord StartPoint(dr->hi.x, dr->lo.y); DocCoord EndPoint(dr->hi); DocCoord EndPoint2(dr->lo); DocCoord EndPoint3(dr->lo.x,dr->hi.y); BmpFill->SetStartPoint(&StartPoint); BmpFill->SetEndPoint(&EndPoint); BmpFill->SetEndPoint2(&EndPoint2); BmpFill->SetEndPoint3(&EndPoint3); BmpFill->GetBitmapRef()->SetBitmap(pBitmap); }

void FeatherAttrValue::CreateBitmapTranspFill (  KernelBitmap *  pFeather, DocRect *  dr, BitmapTranspFillAttribute *  BmpTranspFill )  [private]

Definition at line 1175 of file fthrattr.cpp. { // Transp fill is same size as viewable part of the bitmap DocCoord StartPoint(dr->lo); DocCoord EndPoint(dr->hi.x,dr->lo.y); DocCoord EndPoint2(dr->lo.x,dr->hi.y); DocCoord EndPoint3(dr->hi); BmpTranspFill->SetStartPoint(&StartPoint); BmpTranspFill->SetEndPoint(&EndPoint); BmpTranspFill->SetEndPoint2(&EndPoint2); BmpTranspFill->SetEndPoint3(&EndPoint3); BmpTranspFill->GetBitmapRef()->SetBitmap(pFeather); BmpTranspFill->Transp = 0; BmpTranspFill->EndTransp = 255; m_Profile.SetIsAFeatherProfile (TRUE); // enable extra processing on the profile BmpTranspFill->SetProfile(m_Profile); }

KernelBitmap * FeatherAttrValue::CreateFeatherBitmap (  GRenderRegion *  pGRR, double  pixBlurDiameter )  [private]

Create the feather bitmap-transparency mask. Returns: A ptr to a KernelBitmap containing the transparency mask part of the feather. See Also: CreateSilhouetteBitmap(). Definition at line 835 of file fthrattr.cpp. { // will contain the feather bitmap transparency mask. LPBYTE pFeatherBits = NULL; LPBITMAPINFO pFeatherInfo = NULL; KernelBitmap* kbmpFeather = NULL; // create the silhouette bitmap. LPBYTE pSilhouetteBits; LPBITMAPINFO pSilhouetteInfo = CreateSilhouetteBitmap(pGRR, &pSilhouetteBits); if (pSilhouetteInfo != NULL && pSilhouetteBits != NULL) { // TRACEUSER( "Gerry", _T("Silhouette size = (%d, %d)\n"), pSilhouetteInfo->bmiHeader.biWidth, pSilhouetteInfo->bmiHeader.biHeight); // blur the silhouette bitmap to obtain the feather bitmap. pFeatherInfo = CBitmapShadow::Feather8BppBitmap( pixBlurDiameter, pSilhouetteInfo, pSilhouetteBits, &pFeatherBits ); // If Feather8BPP returned the same bitmap, clear silhouette pointers so we don't // deallocate the bitmap at the end of this function... if (pFeatherInfo == pSilhouetteInfo) { pSilhouetteInfo = NULL; pSilhouetteBits = NULL; } if (pFeatherInfo != NULL && pFeatherBits != NULL) { // TRACEUSER( "Gerry", _T("Feather size = (%d, %d)\n"), pFeatherInfo->bmiHeader.biWidth, pFeatherInfo->bmiHeader.biHeight); CWxBitmap* wbmpFeather = new CWxBitmap(pFeatherInfo, pFeatherBits); kbmpFeather = new KernelBitmap(wbmpFeather, TRUE); SetupFeatherBitmapPalette(kbmpFeather); } } // // DEBUG: add copies of the silhouette and feather bitmaps to the bitmap gallery. // #ifdef DEBUG_ATTACH_SILHOUETTE_BMP if (pSilhouetteInfo != NULL && pSilhouetteBits != NULL) { CWxBitmap* wbmpSilhouette = new CWxBitmap(pSilhouetteInfo, pSilhouetteBits); KernelBitmap* kbmpSilhouette = new KernelBitmap(wbmpSilhouette, TRUE); SetupFeatherBitmapPalette(kbmpSilhouette); kbmpSilhouette->AttachDebugCopyToCurrentDocument("Silhouette Bitmap"); wbmpSilhouette->BMBytes = ((CWxBitmap*)OILBitmap::Default)->BMBytes; delete kbmpSilhouette; } #endif #ifdef DEBUG_ATTACH_FEATHER_BMP if (kbmpFeather != NULL) { kbmpFeather->AttachDebugCopyToCurrentDocument("Feather Mask Bitmap"); } #endif // // Silhouette bitmap does not use limited mem manager, so free its DIB ourself. if (pSilhouetteInfo != NULL && pSilhouetteBits != NULL) FreeDIB(pSilhouetteInfo, pSilhouetteBits, NULL, FALSE); return kbmpFeather; }

BOOL FeatherAttrValue::CreateFeatherTransp (  GRenderRegion *  pGRR, Path *  pPath, double  dPixelWidth, BitmapTranspFillAttribute **  ppFeatherTransp, KernelBitmap **  ppFeatherBitmap )  [virtual]

Create the feather transparency attribute using the supplied path /without/ reference to any surrounding nodes in the tree Used by NodeBitmap::GetDirectBitmap. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/08/2005 Parameters: pPath  - Pointer to path to be feathered [INPUTS] dPixelWidth - Pixel width in millipoints pFeatherTransp  - Pointer to transparency attribute for feathering [OUTPUTS] pFeatherBitmap - POinter to feather bitmap used in transparency attribute Returns: TRUE if it worked FALSE otherwise Definition at line 699 of file fthrattr.cpp. { double dpixBlurDiameter = GetFeatherPixelSize(dPixelWidth); LPBYTE pFeatherBits = NULL; LPBITMAPINFO pFeatherInfo = NULL; KernelBitmap* kbmpFeather = NULL; DocRect rectBounds = pPath->GetBoundingRect(); // UINT32 pixWidth = UINT32(floor( rectBounds.Width() / dPixelWidth + 0.5 )); // UINT32 pixHeight = UINT32(floor( rectBounds.Height() / dPixelWidth + 0.5 )); // ------------------------------------------------------------------- // First make the silhouette bitmap // create the silhouette bitmap. m_OffBB = rectBounds; m_GapSize = 0; LPBYTE pSilhouetteBits; LPBITMAPINFO pSilhouetteInfo = CreateSilhouetteBitmap(pGRR, &pSilhouetteBits, pPath); if (pSilhouetteInfo==NULL || pSilhouetteBits==NULL) return FALSE; // ------------------------------------------------------------------- // Next blur the silhouette bitmap to obtain the feather bitmap. pFeatherInfo = CBitmapShadow::Feather8BppBitmap( dpixBlurDiameter, pSilhouetteInfo, pSilhouetteBits, &pFeatherBits ); // If Feather8BPP returned the same bitmap, clear silhouette pointers so we don't // deallocate the bitmap at the end of this function... if (pFeatherInfo == pSilhouetteInfo) { pSilhouetteInfo = NULL; pSilhouetteBits = NULL; } if (pFeatherInfo != NULL && pFeatherBits != NULL) { CWxBitmap* wbmpFeather = new CWxBitmap(pFeatherInfo, pFeatherBits); kbmpFeather = new KernelBitmap(wbmpFeather, TRUE); SetupFeatherBitmapPalette(kbmpFeather); *ppFeatherBitmap = kbmpFeather; } // We don't need the silhouette bitmap any more if (pSilhouetteInfo != NULL && pSilhouetteBits != NULL) FreeDIB(pSilhouetteInfo, pSilhouetteBits); // If we failed to create the blurred bitmap then exit now if (*ppFeatherBitmap==NULL) return FALSE; // ---------------------------------------------------------------------- // Now make the transparency attribute to carry the feather bitmap *ppFeatherTransp = new BitmapTranspFillAttribute; if (*ppFeatherTransp==NULL) { delete *ppFeatherBitmap; *ppFeatherBitmap = NULL; return FALSE; } CreateBitmapTranspFill(*ppFeatherBitmap, &rectBounds, *ppFeatherTransp); return TRUE; }

LPBITMAPINFO FeatherAttrValue::CreateSilhouetteBitmap (  GRenderRegion *  GRR, LPBYTE *  ppBmpBits, Path *  pOutline = NULL )  [private]

I order to avoid DWORD aligning overhead in the convolution code we always render into bitmaps which are DWORD aligned. This means we need to be careful when creating a transparency attribute to hold the mask as we must use the aligned co-ords, not m_OffBB otherwise we will introduce scaling. NB we do this by drawing more pixels on the right hand border to account for the alignment. NB NB NB Non-technical notes: these notes are out of date so ignore! will fix later. Definition at line 943 of file fthrattr.cpp. { // ERROR3IF(m_pOffscreenBmpInfo == NULL, // "FeatherAttrValue::CreateSilhouetteBitmap; No offscreen bitmap info."); // generate a contour of m_GapSize around the path of our linked node, to // eradicate any small gaps which would otherwise be feathered. if (pOutline==NULL) { if (m_pOuterContour == NULL) GenerateOuterContour(); pOutline = m_pOuterContour; } // if we couldn't generate our outer contour, or it had no points in it, // don't try to produce a feather bitmap. if (pOutline == NULL || pOutline->GetNumCoords() == 0) { *ppBmpBits = NULL; return NULL; } // - Work out the appropriate size silhouette bitmap by inflating the invalid // offscreen rectangle by the blur *radius* (half the feather size). // - If the blur radius is above the maximum we can do, then we work out *how* // much bigger it is and render the silhouette bitmap appropriately scaled down. // - The final feather bitmap will then scale up to fill the offscreen rect, // making it look like we actually used the requested blur radius. const double ScaledPixelWidth = GRR->GetScaledPixelWidthDouble(); const double FeatherMPSize = GetFeatherSize(); const double FeatherPixelSize = GetFeatherPixelSize(ScaledPixelWidth); double FeatherScaleFactor = 1; DocRect drSilhouetteBounds = m_OffBB; m_drFeatherBB = drSilhouetteBounds; if (FeatherPixelSize >= MIN_BLUR_DIAMETER) { // requested blur diameter = BlurPixDiam pixels. // actual blur we can do = FeatherPixelSize pixels. double BlurPixDiam = (ScaledPixelWidth > 0) ? (FeatherMPSize / ScaledPixelWidth) : 0; if (BlurPixDiam > FeatherPixelSize) { FeatherScaleFactor = BlurPixDiam / FeatherPixelSize; // Scale the silhouette around its centre by the feather scale factor. // This is so that the rendered silhouette bitmap is has a width of // at least (2 * FeatherRadius + 1) pixels. double BoundsSF = (FeatherScaleFactor - 1.0) / 2.0; UINT32 nWidth = (UINT32)(0.5 + (double)drSilhouetteBounds.Width() * BoundsSF); UINT32 nHeight = (UINT32)(0.5 + (double)drSilhouetteBounds.Height() * BoundsSF); drSilhouetteBounds.Inflate(nWidth, nHeight); m_drFeatherBB = drSilhouetteBounds; } // Inflate the silhouette bounds by FeatherRadius pixels around each edge. // This will shrink down to the correct bounds when blurred. const UINT32 nBlur = (UINT32)(BlurPixDiam + 0.5); UINT32 nHiInflate = (nBlur - 1) / 2; UINT32 nLoInflate = (nBlur - 1) - nHiInflate; nHiInflate = (UINT32)(ScaledPixelWidth * (double)nHiInflate); nLoInflate = (UINT32)(ScaledPixelWidth * (double)nLoInflate); drSilhouetteBounds.hi.x += nHiInflate; drSilhouetteBounds.hi.y += nHiInflate; drSilhouetteBounds.lo.x -= nLoInflate; drSilhouetteBounds.lo.y -= nLoInflate; // Don't allow further code to try to make a zero pixel silhouette bitmap if (drSilhouetteBounds.Width()<ScaledPixelWidth || drSilhouetteBounds.Height()<ScaledPixelWidth) { *ppBmpBits = NULL; return NULL; } } // create our offscreen render-region. ConcurrentRenderer* pRendWrap = NULL; pRendWrap = GRenderRegionWrapper::GetConcurrentRenderer(GRR, 1.0 / FeatherScaleFactor, drSilhouetteBounds, 8, FALSE); if (pRendWrap == NULL) { *ppBmpBits = NULL; return NULL; } GRenderRegion* pLocalGRR = NULL; pLocalGRR = pRendWrap->GetRenderRegion(); pLocalGRR->GetDrawContext()->SetHintingFlag(FALSE); // ask the bitmap shadower if it the final feather bitmap will be offset diagonally // by half a pixel. if this is the case then we must compensate, by rendering // the silhouette bitmap at a half-pixel offset in the other direction. if (CBitmapShadow::BlurringWillOffsetBitmap(FeatherPixelSize)) pLocalGRR->OffsetByHalfPixel(); // Draw into new RenderRegion which GRenderRegionWrapper has created pLocalGRR->SaveContext(); // Initialise our new render-region: // 1. Render in solid black with solid white line-widths. // 1a. Line colour now graduates from black -> off-white over 0->2*MIN_BLUR_DIAMETER. // 2. Line width is half feather size + contour gap size, on either side. // 3. No arrowheads/dashed lines/fancy join types. // 4. High quality rendering, so we get anti-aliased lines. pLocalGRR->SetFillColour(COLOUR_BLACK); if (FeatherPixelSize < (2*MIN_BLUR_DIAMETER)) { double RampValue = FeatherPixelSize / (2*MIN_BLUR_DIAMETER); ColourValue GreyVal(0.8 * RampValue); DocColour FeatherGrey(GreyVal, GreyVal, GreyVal); pLocalGRR->SetLineColour(FeatherGrey); } else pLocalGRR->SetLineColour(COLOUR_WHITE); pLocalGRR->SetJoinType(RoundJoin); pLocalGRR->SetStartArrow(SA_NULLARROW); pLocalGRR->SetEndArrow(SA_NULLARROW); pLocalGRR->SetDashPattern(SD_SOLID); MILLIPOINT RequiredLineWidth = (MILLIPOINT)(FeatherMPSize + 2*m_GapSize); pLocalGRR->SetLineWidth(RequiredLineWidth); FlatTranspFillAttribute NoFillTransp(TT_NoTranspType); pLocalGRR->SetTranspFillGeometry(&NoFillTransp, FALSE); StrokeTranspAttribute NoLineTransp(TT_NoTranspType); pLocalGRR->SetLineTransp(&NoLineTransp, FALSE); Quality AntiAliasQuality; AntiAliasQuality.SetQuality(Quality::QualityMax); QualityAttribute AntiAliasQualityAttr(AntiAliasQuality); pLocalGRR->SetQuality(&AntiAliasQualityAttr, FALSE); // render our contoured silhouette path into the new RR. pOutline->IsFilled = TRUE; pOutline->IsStroked = TRUE; pLocalGRR->DrawPath(pOutline); pLocalGRR->RestoreContext(); // Extract bitmap from GRenderRegionWrapper and restore GDraw state LPBITMAPINFO tmpBI; pRendWrap->GetBitmapPointers(&tmpBI, ppBmpBits); pRendWrap->RestorePreviousRendererState(); return tmpBI; }

virtual BOOL FeatherAttrValue::DoesOffscreenBMPCaptureBackground (   )  [inline, virtual]

Reimplemented from OffscreenAttrValue. Definition at line 214 of file fthrattr.h. {return TRUE;} // Return TRUE if you can make this work

BOOL FeatherAttrValue::DoesOffscreenBmpRequireTransp (  GRenderRegion *  pGRR  )  [virtual]

Override of OffscreenAttrValue virtual function. Feathers always require a transparent bitmap if their feather size is less than a certain value, otherwise they use the default implementation. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 19/11/2000 Parameters: pGRR  the RR which the feather will be rendered into. [INPUTS] This prevents white artifacts on small feather sizes. See also: CreateSilhouetteBitmap, OffscreenAttrValue::DoesOffscreenBmpRequireTransp. Reimplemented from OffscreenAttrValue. Definition at line 796 of file fthrattr.cpp. { // In conjunction with DoesOffscreenBMPCaptureBackground this function should // now return FALSE always so that the offscreen bitmap does not attempt to // capture transparency info but rather captures the RESULTS of transparency... if (DoesOffscreenBMPCaptureBackground()) return FALSE; if (pGRR == NULL) { ERROR3("FeatherAttrValue::DoesOffscreenBmpRequireTransp; Invalid params!"); return FALSE; } const double ScaledPixelWidth = pGRR->GetScaledPixelWidthDouble(); const double FeatherPixelSize = GetFeatherPixelSize(ScaledPixelWidth); return (FeatherPixelSize < 2*MIN_BLUR_DIAMETER) ? TRUE : OffscreenAttrValue::DoesOffscreenBmpRequireTransp(pGRR) ; }

BOOL FeatherAttrValue::GenerateOuterContour (   )

Definition at line 1407 of file fthrattr.cpp. { // fail now if we have no linked node. if (GetLinkedNode() == NULL) { ERROR3("FeatherAttrValue::GenerateOuterContour; Aarrgh!! Where's our linked node?!!"); return FALSE; } // We know we are about to overwrite this value so if it's still set up // we shuold delete it now to prevent memory leaks if (m_pOuterContour) { delete m_pOuterContour; m_pOuterContour = NULL; } // Get outer contour // NB m_pOuterContour is a contour which is m_GapSize outside m_pPath's outline // Outer contour with m_GapSize is used so that small gaps are forced out. This is // especially desireable when there are a large number of tiny gaps within the object // we are trying feather (eg the gaps between the 'front windscreen' shape and the // 'windscreen frame') m_pOuterContour = new Path; BOOL fSuccess = NodeContour::GenerateContourPathForNode(m_pOuterContour, GetLinkedNode(), NULL, m_GapSize, TRUE, RoundJoin, -1, TRUE, TRUE); if (!fSuccess) { delete m_pOuterContour; m_pOuterContour = NULL; } return fSuccess; }

double FeatherAttrValue::GetFeatherPixelSize (  double  fPixelWidth  )  [inline]

Return the size of this feather, in pixels of the specified width. Different from GetFeatherSize(PIXELS) mainly because: 1. we return a double, so eg you can get back a value of 2.5 pix. 2. we're inline. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 17/08/2000 Parameters: fPixelWidth  width of a pixel in millipoints - accepts non-integer values. [INPUTS] Returns: The feather size, in pixels which are fPixelWidth millipoints wide, capped off to a maximum of (2 * MAX_SHADOW_BLUR) pixels. Notes: inline, as it's small and fast. Definition at line 1341 of file fthrattr.cpp. { const double MaxFeatherBlurDiameter = 2.0 * MAX_SHADOW_BLUR; double fFeatherSize = (fPixelWidth <= 0) ? 0 : (double)m_FeatherSize / fPixelWidth; return (fFeatherSize > MaxFeatherBlurDiameter) ? MaxFeatherBlurDiameter : fFeatherSize; }

MILLIPOINT FeatherAttrValue::GetFeatherSize (   )

Accessor method for our feather size. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/2001 Returns: Our feather size, in millipoints. Notes: This value is always capped off to MaxUserFeatherSize millipoints, to prevent anybody ever using a feather size which we cannot handle. Definition at line 1287 of file fthrattr.cpp. { return (m_FeatherSize > MaxUserFeatherSize) ? MaxUserFeatherSize : m_FeatherSize; }

void FeatherAttrValue::GetMinimumOffscreenBmpDimensions (  UINT32 *  RequiredWidth, UINT32 *  RequiredHeight )  [virtual]

Reimplemented from OffscreenAttrValue. Definition at line 505 of file fthrattr.cpp. { *RequiredWidth = 2; *RequiredHeight = 2; }

Path* FeatherAttrValue::GetOuterContour (   )  [inline]

Definition at line 265 of file fthrattr.h. { return m_pOuterContour; }

CProfileBiasGain FeatherAttrValue::GetProfile (   )  [inline]

Definition at line 244 of file fthrattr.h. { return m_Profile; }

CProfileBiasGain* FeatherAttrValue::GetProfilePtr (   )  [inline]

Definition at line 245 of file fthrattr.h. { return &m_Profile; } // return pointer to profile

Path * FeatherAttrValue::GetVisibleBoundingPath (   )  [private]

Definition at line 1194 of file fthrattr.cpp. { DocRect dr = GetOffscreenBoundingRect(); Path* p = new Path(); if (p != NULL) { p->Initialise(5); p->CreatePathFromDocRect(&dr); } return p; }

BOOL FeatherAttrValue::Init (  void   )  [static]

Declares a preference that allows you to clear memory in delete(). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/94 Returns: TRUE if it worked OK, FALSE if not Reimplemented from SimpleCCObject. Definition at line 309 of file fthrattr.cpp. { // Default to no feathering FeatherAttrValue *pAttr = new FeatherAttrValue; if (pAttr==NULL) // error message has already been set by new return FALSE; pAttr->SetDefault(); UINT32 AttrID = AttributeManager::RegisterDefaultAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pAttr); ERROR2IF(AttrID == ATTR_BAD_ID, FALSE, "Bad ID when Initialising FeatherAttrValue"); ERROR2IF(AttrID != ATTR_FEATHER, FALSE, "Incorrect ID for FeatherAttrValue"); return TRUE; }

NodeAttribute * FeatherAttrValue::MakeNode (   )  [virtual]

Used when restoring attributes from the render region's context stack.Used when a render region needs to change a particular rendering attribute.This function provides a way of copying the contents of an AttributeValue derived class to another. It is assumed that the source object is the same class as the destination object. The data from the object pointed to by pAttr is copied into this object. This is primarily used when cloning render regions - the context stack must be copied, and if it points to any temporary objects, then they must be copied too, to avoid multiple deletion errors. Given an AttributeValue object, construct the appropriate NodeAttribute object which can be put into a document tree. This should be over-ridden for all derived AttributeValue classes, except those that cannot be put into the document tree (e.g. DrawingModeAttribute). The base class version (i.e. this one) will always ENSURE because it should not be called. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 11/04/94 Returns: Pointer to NodeAttribute object, or NULL if out of memory. Errors: Out of memory. See also: NodeAttribute Reimplemented from AttributeValue. Definition at line 371 of file fthrattr.cpp. { AttrFeather* pNode = new AttrFeather(); pNode->Value.SimpleCopy(this); return pNode; }

void FeatherAttrValue::OffscreenRenderingCompleted (  RenderRegion *  pRender, LPBITMAPINFO  lpBitmapInfo, LPBYTE  lpBits, DocRect  BitmapRect )  [virtual]

Notes: 1) This function gets called when the RR exits the context under which the attribute was Render()ed (ie after completeing a DrawPath("this->m_pLinkedNode->Path"). 2) The offscreen rendering system (implemented in GRenderRegion) has already restored the clip rect and GDraw bitmap and matrix state of the previous offscreen attribute. This function is actually being called by the RenderRegion in the process of Restore()ing this previous offscreen attribute (ie the process of taking the attribute which is sitting on top of the attribute context stack, and restoring it to the CurrentAttrs table). So at this point the GRenderRegion and GDraw context are back the way they were before "this" offscreen attribute was Render()ed. 3) m_pOffscreenBmpBits points to the buffer holding the fully rendered bitmap of the subtree rooted at m_pLinkedNode 4) Any transparency attribute existing at the same level as this offscreen attr (ie attached to "this->m_pLinkedNode") will already have affected the bitmap in "this->m_pOffscreenBmpBits". 5) You don't need to delete the bitmap pointers UNLESS you installed "this" attribute as a non-temporary attribute in the Render() function (ie SetFeathering(this, FALSE..)). If it is a temporary attribute (which is the default) then the deconstructor will handle the deallocation of the memory pointed to by m_pOffscreenBmpBits & m_pOffscreenBmpInfo See also: GRenderRegion::RestoreFeathering(); ~FeatherAttrValue(); RenderRegion::RestoreAttribute() FeatherAttrValue::Render(), GRenderRegion::SetFeathering() Implements OffscreenAttrValue. Definition at line 542 of file fthrattr.cpp. { // TRACEUSER( "Gerry", _T("Feather attribute OffscreenRenderingCompleted (0x%08x)\n"), this); // TRACEUSER( "Phil", _T("Feather attribute OffscreenRenderingCompleted (0x%08x)\n"), this); // TEMP BODGE m_OffBB = BitmapRect; // Karim 20/07/2000 // currently, we only generate an offscreen bitmap for GRenderRegions, although we are // 'rendered' into all RR's. therefore we must quit quietly if pRender is not a GRR. if (!pRender->IS_KIND_OF(GRenderRegion)) return; GRenderRegion* pGRR = (GRenderRegion*)pRender; RRCaps Caps; pGRR->GetRenderRegionCaps(&Caps); if (!Caps.DoesRegionDoAll()) return; // Karim 19/10/2000 // The offscreen rendering may possibly fail, // in which case all we can do now is quit. if (lpBitmapInfo == NULL || lpBits == NULL) { // ERROR3("FeatherAttrValue::OffscreenRenderingCompleted; don't have any bitmap info!"); return; } double fScaledPixelWidth = pGRR->GetScaledPixelWidthDouble(); // TRACEUSER( "Gerry", _T("ScaledPixelWidth = %f\n"), fScaledPixelWidth); double pixBlurDiameter = GetFeatherPixelSize(fScaledPixelWidth); // TRACEUSER( "Gerry", _T("BlurDiameter = %f\n"), pixBlurDiameter); // Setup path to draw Path* pPathToDraw = GetVisibleBoundingPath(); if (pPathToDraw == NULL) { ERROR3("FeatherAttrValue::OffscreenRenderingCompleted; Couldn't create path!"); return; } // Create the bitmap fill containing the offscreen rendition of the objects to feather. CWxBitmap *wBitmap = NULL; KernelBitmap *OffscreenBitmap = NULL; // TRACEUSER( "Gerry", _T("Offscreen size = (%d, %d)\n"), pOffBmpHdr->biWidth, pOffBmpHdr->biHeight); // Create a Kernel bitmap from the bmp data. wBitmap = new CWxBitmap(lpBitmapInfo, lpBits); OffscreenBitmap = new KernelBitmap(wBitmap,TRUE); // Setup the bitmap fill. // Since the offscreen bitmap has been plotted using the full rendering matrix // which may include a rotation during printing, we must now force GDraw to // render it using the same rotation (see GRenderRegion::AllocateOffScreenState) BitmapFillAttribute BmpFill; ANGLE rot; Matrix m = pGRR->GetMatrix(); m.Decompose(NULL, NULL, &rot, NULL, NULL); if (rot==0) // CreateBitmapFill(OffscreenBitmap, &m_OffBB, &BmpFill); CreateBitmapFill(OffscreenBitmap, &BitmapRect, &BmpFill); else // CreateBitmapFillRot90(OffscreenBitmap, &m_OffBB, &BmpFill); CreateBitmapFillRot90(OffscreenBitmap, &BitmapRect, &BmpFill); // No other rotations are currently possible... // DEBUG: add offscreen bmp to bitmap gallery #ifdef DEBUG_ATTACH_OFFSCREEN_BMP OffscreenBitmap->AttachDebugCopyToCurrentDocument("Offscreen Bitmap"); #endif // Create the feather bitmap transparency mask. KernelBitmap* FeatherBitmap = CreateFeatherBitmap(pGRR, pixBlurDiameter); BitmapTranspFillAttribute BmpTranspFill; if (FeatherBitmap != NULL) { CreateBitmapTranspFill(FeatherBitmap, &m_drFeatherBB, &BmpTranspFill); } // Render the bitmaps together for the final feathered result. // // If we had any problems creating the feather bitmap transparency, or if our debug // rendering is enabled, then we try to fail gracefully by rendering just the // offscreen bitmap. Note that this bitmap will only have an alpha channel if some of // the feathered objects require it, and will have a white background otherwise. pGRR->SaveContext(); // DEBUG: see note above. #ifndef DEBUG_RENDER_OFFSCREEN_BMP_WITHOUT_MASK if (FeatherBitmap != NULL) pGRR->RenderBitmapWithTransparency(pPathToDraw, &BmpFill, &BmpTranspFill); #else pGRR->RenderBitmapWithTransparency(pPathToDraw, &BmpFill, NULL); #endif pGRR->RestoreContext(); // Clean up all our data structures. if (FeatherBitmap != NULL) { delete FeatherBitmap; FeatherBitmap = NULL; } if (pPathToDraw != NULL) { delete pPathToDraw; pPathToDraw = NULL; } FreeDIB(lpBitmapInfo, lpBits, NULL, FALSE); // makes ~CWxBitmap() think that bmp HasBeenDeleted(). wBitmap->BMBytes = ( (CWxBitmap *)OILBitmap::Default )->BMBytes; delete OffscreenBitmap; }

BOOL FeatherAttrValue::RegenerateOuterContourOnNextRedraw (  UndoableOperation *  pOp = NULL  )

Clear the cache of our outer-contour path. Author: Ilan_Copelyn (Xara Group Ltd) <camelotdev@xara.com>; Karim MacDonald Date: 24/01/2000; 01/03/2001 Parameters: pOp  optional ptr to an UndoOp, letting us store undo information. [INPUTS] Returns: TRUE if we were successful, FALSE otherwise. See also: AttrFeather::Transform(), AttrFeather::LinkedNodeGeometryHasChanged(). Definition at line 1480 of file fthrattr.cpp. { if (m_pOuterContour != NULL) { if (pOp != NULL) { // make this undoable RegenerateFeatherContourAction* pAct = NULL; if (RegenerateFeatherContourAction::Init(pOp, pOp->GetUndoActionList(), this, m_pOuterContour, &pAct) == AC_FAIL) { TRACEALL( _T("FeatherAttrValue::RegenerateOuterContourOnNextRedraw; Could not record undo information.\n")); return FALSE; } } // don't actually delete the old outer contour // if it's been saved via the undoable operation. if (pOp == NULL) delete m_pOuterContour; m_pOuterContour = NULL; } return TRUE; }

void FeatherAttrValue::Render (  RenderRegion *  , BOOL  Temp = FALSE )  [virtual]

Reimplemented from OffscreenAttrValue. Definition at line 448 of file fthrattr.cpp. { // TRACEUSER( "Gerry", _T("Rendering feather attribute of %d (0x%08x)\n"), GetFeatherSize(), this); // Karim 20/07/2000 // currently, we only generate an offscreen bitmap for GRenderRegions, although we are // 'rendered' into all RR's. therefore we must quit quietly if pRender is not a GRR. // Gerry 12/01/2005 // This is no longer true. We need to render this into all types of render region // so the code has been removed // if (!pRender->IS_KIND_OF(GRenderRegion)) // return; // if the feather size is zero, then quit now - no feathering is necessary. MILLIPOINT mpFeather = GetFeatherSize(); if (mpFeather == 0) return; // ... and shout out if the feather size is negative - something is WRONG! else if (mpFeather < 0) { ERROR3("Negative feather size! What's going on?"); return; } // you would place code here if you need to affect currentAttrs table // also alloc any mem you need for the duration of the rendering cycle OffscreenAttrValue::Render(pRender, Temp); }

void FeatherAttrValue::Restore (  RenderRegion *  , BOOL  )  [virtual]

Reimplemented from OffscreenAttrValue. Definition at line 486 of file fthrattr.cpp. { //TRACEUSER( "Phil", _T("Restoring feather attribute of %d (0x%08x)\n"), GetFeatherSize(), this); // NB this function doesn't need to be implemented - the base class handles everything // Just showing you where to put extra code OffscreenAttrValue::Restore(pRegion, Temp); }

void FeatherAttrValue::SetFeatherProfile (  CProfileBiasGain &  biasgain  )

Definition at line 1357 of file fthrattr.cpp. { AFp BiasValue = biasgain.GetBias(); AFp GainValue = biasgain.GetGain(); m_Profile.SetBias(BiasValue); m_Profile.SetGain(GainValue); }

MILLIPOINT FeatherAttrValue::SetFeatherSize (  MILLIPOINT  mpWidth  )

Mutator method for our feather size. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 31/01/2001 Parameters: Our  new feather size, in millipoints. [INPUTS] Returns: The feather size we actually set, taking cap values into account. Notes: This method will not set a value <0 mp or >MaxUserFeatherSize mp, to prevent us dealing in feather sizes that we cannot handle. Definition at line 1311 of file fthrattr.cpp. { m_FeatherSize = mpWidth < 0 ? 0 : mpWidth > MaxUserFeatherSize ? MaxUserFeatherSize : mpWidth; return m_FeatherSize; }

void FeatherAttrValue::SetLinkedNode (  NodeRenderableBounded *  pNode  )  [virtual]

Our outer contour gap size depends on what our linked node is, so we must recalculate our gap size whenever our linked node is set. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/2000 Reimplemented from GeometryLinkedAttrValue. Definition at line 1378 of file fthrattr.cpp. { m_pLinkedNode = pNode; if (pNode != NULL) { if (IS_A(GetLinkedNode(), NodeGroup) || IS_A(GetLinkedNode(), NodeMould) || IS_A(GetLinkedNode(), NodeBlend) || GetLinkedNode()->IsANodeClipViewController()) { m_GapSize = DEFAULT_GAP_TOLERANCE_MP; } else { m_GapSize = 1; } } }

void FeatherAttrValue::SetOuterContour (  Path *  pNewOuterContour  )  [inline]

Definition at line 267 of file fthrattr.h. { m_pOuterContour = pNewOuterContour; }

BOOL FeatherAttrValue::SetupFeather (  Node *  pNode, INT32  Width = ((MILLIPOINT) ( 2  * PX_MP_VAL)), UnitType  type = MILLIPOINTS )

Setup feather member variables so that it is created properly on rendering. type - which measurment used for size See also: OpFeather::Do Definition at line 1219 of file fthrattr.cpp. { // Get required feather size in Millipoints, taking current zoom into account // if width specified in Pixels MILLIPOINT BlurSize = ConvertMeasurementToMillipointsAtCurrentViewScale(Width,type); if (BlurSize == -1) BlurSize = DEFAULT_FEATHERSIZE_MP; SetFeatherSize(BlurSize); // Save pointer to node so we can get at it in the rendering code. SetLinkedNode((NodeRenderableBounded*) pNode); #ifdef _DEBUG_OFFSCREEN_PIXEL_WIDTH RenderDebuggingBitmaps(NULL, pNode, 1.0, 32, FALSE); #endif return TRUE; }

void FeatherAttrValue::SetupFeatherBitmapPalette (  KernelBitmap *  pFeatherBMP  )  [private]

Definition at line 1113 of file fthrattr.cpp. { LPRGBQUAD pPalette = pFeatherBMP->GetPaletteForBitmap(); // Using linear palette // For some reason we have to initialise the palette even though the rendering // code sets up the palette using the profile which is attached to the bitmap // transparency attribute which contains the feather bitmap mask. for (INT32 i = 0; i < 256; i ++) { pPalette[i].rgbRed = pPalette[i].rgbBlue = pPalette[i].rgbGreen = (BYTE)i; pPalette[i].rgbReserved = 0x00; } // Mark this bitmap as being greyscale to avoid re-conversion by GetGreyscaleVersion pFeatherBMP->SetAsGreyscale(); }

void FeatherAttrValue::SimpleCopy (  AttributeValue *   )  [virtual]

Reimplemented from OffscreenAttrValue. Definition at line 336 of file fthrattr.cpp. { ERROR3IF(!pVal->IS_KIND_OF(FeatherAttrValue), "Incorrect runtime class passed to FeatherAttrValue::SimpleCopy"); FeatherAttrValue* pFthr = (FeatherAttrValue*) pVal; m_Profile = pFthr->m_Profile; SetFeatherSize(pFthr->GetFeatherSize()); m_GapSize = pFthr->m_GapSize; // NOTE! Don't copy m_outerContour because callers assume that this will // not be copied and rely on it being regenerated on demand. Urgh! // Remember to copy or blank cached path data without leaking memory... if (m_pOuterContour) delete m_pOuterContour; m_pOuterContour = NULL; /* Path* pSrcPath = pFthr->GetOuterContour(); if (pSrcPath) { m_pOuterContour = new Path(); m_pOuterContour->Initialise(pSrcPath->GetNumCoords()); m_pOuterContour->CopyPathDataFrom(pSrcPath); } */ // preserves default flag to avoid confusion when copying CCAttrMaps GeometryLinkedAttrValue::SimpleCopy(pVal); }

---

Member Data Documentation

BOOL FeatherAttrValue::m_bCached [private]

Definition at line 281 of file fthrattr.h.

DocRect FeatherAttrValue::m_drFeatherBB [private]

Definition at line 279 of file fthrattr.h.

MILLIPOINT FeatherAttrValue::m_FeatherSize [private]

Definition at line 275 of file fthrattr.h.

MILLIPOINT FeatherAttrValue::m_GapSize [private]

Definition at line 276 of file fthrattr.h.

Path* FeatherAttrValue::m_pOuterContour [private]

Definition at line 277 of file fthrattr.h.

CProfileBiasGain FeatherAttrValue::m_Profile [private]

Definition at line 274 of file fthrattr.h.

const MILLIPOINT FeatherAttrValue::MaxUserFeatherSize = 37500 [static, private]

Definition at line 285 of file fthrattr.h.

---

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

• Kernel/fthrattr.h (r1785/r1282)
• Kernel/fthrattr.cpp (r1785/r1738)

---